Enhance AIAgent tool messaging and add Obsidian skill documentation

- Introduced a new method `_format_status` in `run_agent.py` for consistent formatting of tool execution messages in the CLI.
- Updated various tool messages to utilize the new formatting method, improving readability and alignment.
- Added a new skill documentation file for Obsidian, detailing commands for reading, searching, and creating notes within the Obsidian vault.

.cursorrules

@@ -0,0 +1,201 @@
+Hermes-Agent is an agent harness for LLMs with an interactive CLI.
+
+## Development Environment
+
+**IMPORTANT**: Always use the virtual environment if it exists:
+```bash
+source venv/bin/activate  # Before running any Python commands
+```
+
+## Project Structure
+
+- `hermes` - CLI launcher script (run with `./hermes`)
+- `cli.py` - Interactive CLI with Rich UI, prompt_toolkit, animated spinners
+- `cli-config.yaml` - CLI configuration (model, terminal, toolsets, personalities)
+- `tools/` - Individual tool implementations (web, terminal, browser, vision, etc.)
+- `tools/__init__.py` - Exports all tools for importing
+- `model_tools.py` - Consolidates tool schemas and handlers for the agent
+- `toolsets.py` - Groups tools into logical toolsets (web, terminal, browser, etc.)
+- `toolset_distributions.py` - Probability-based tool selection for data generation
+- `run_agent.py` - Primary agent runner with AIAgent class and KawaiiSpinner
+- `batch_runner.py` - Parallel batch processing with checkpointing
+- `tests/` - Test scripts
+
+## File Dependency Chain
+
+```
+tools/*.py → tools/__init__.py → model_tools.py → toolsets.py → toolset_distributions.py
+                                       ↑
+run_agent.py ──────────────────────────┘
+cli.py → run_agent.py (uses AIAgent with quiet_mode=True)
+batch_runner.py → run_agent.py + toolset_distributions.py
+```
+
+Always ensure consistency between tools, model_tools.py, and toolsets.py when changing any of them.
+
+## CLI Architecture (cli.py)
+
+The interactive CLI uses:
+- **Rich** - For the welcome banner and styled panels
+- **prompt_toolkit** - For fixed input area with history and `patch_stdout`
+- **KawaiiSpinner** (in run_agent.py) - Animated feedback during API calls and tool execution
+
+Key components:
+- `HermesCLI` class - Main CLI controller with commands and conversation loop
+- `load_cli_config()` - Loads `cli-config.yaml`, sets environment variables for terminal
+- `build_welcome_banner()` - Displays ASCII art logo, tools, and skills summary
+- `/commands` - Process user commands like `/help`, `/clear`, `/personality`, etc.
+
+CLI uses `quiet_mode=True` when creating AIAgent to suppress verbose logging and enable kawaii-style feedback instead.
+
+### Adding CLI Commands
+
+1. Add to `COMMANDS` dict with description
+2. Add handler in `process_command()` method
+3. For persistent settings, use `save_config_value()` to update `cli-config.yaml`
+
+## Adding a New Tool
+
+Follow this strict order to maintain consistency:
+
+1. Create `tools/your_tool.py` with:
+   - Handler function (sync or async) returning a JSON string via `json.dumps()`
+   - `check_*_requirements()` function to verify dependencies (e.g., API keys)
+   - Schema definition following OpenAI function-calling format
+
+2. Export in `tools/__init__.py`:
+   - Import the handler and check function
+   - Add to `__all__` list
+
+3. Register in `model_tools.py`:
+   - Create `get_*_tool_definitions()` function or add to existing
+   - Add routing in `handle_function_call()` dispatcher
+   - Update `get_all_tool_names()` with the tool name
+   - Update `get_toolset_for_tool()` mapping
+   - Update `get_available_toolsets()` and `check_toolset_requirements()`
+
+4. Add to toolset in `toolsets.py`:
+   - Add to existing toolset or create new one in TOOLSETS dict
+
+5. Optionally add to `toolset_distributions.py` for batch processing
+
+## Tool Implementation Pattern
+
+```python
+# tools/example_tool.py
+import json
+import os
+
+def check_example_requirements() -> bool:
+    """Check if required API keys/dependencies are available."""
+    return bool(os.getenv("EXAMPLE_API_KEY"))
+
+def example_tool(param: str, task_id: str = None) -> str:
+    """Execute the tool and return JSON string result."""
+    try:
+        result = {"success": True, "data": "..."}
+        return json.dumps(result, ensure_ascii=False)
+    except Exception as e:
+        return json.dumps({"error": str(e)}, ensure_ascii=False)
+```
+
+All tool handlers MUST return a JSON string. Never return raw dicts.
+
+## Stateful Tools
+
+Tools that maintain state (terminal, browser) require:
+- `task_id` parameter for session isolation between concurrent tasks
+- `cleanup_*()` function to release resources
+- Cleanup is called automatically in run_agent.py after conversation completes
+
+## Environment Variables
+
+API keys are loaded from `.env` file in repo root:
+- `OPENROUTER_API_KEY` - Main LLM API access (primary provider)
+- `FIRECRAWL_API_KEY` - Web search/extract tools
+- `BROWSERBASE_API_KEY` / `BROWSERBASE_PROJECT_ID` - Browser automation
+- `FAL_KEY` - Image generation (FLUX model)
+- `NOUS_API_KEY` - Vision and Mixture-of-Agents tools
+
+Terminal tool configuration (can also be set in `cli-config.yaml`):
+- `TERMINAL_ENV` - Backend: local, docker, singularity, modal, or ssh
+- `TERMINAL_CWD` - Working directory
+- `TERMINAL_SSH_HOST`, `TERMINAL_SSH_USER`, `TERMINAL_SSH_KEY` - For SSH backend
+
+## Agent Loop (run_agent.py)
+
+The AIAgent class handles:
+- Processing enabled toolsets to provide to the model
+- Piping prompts to the agent
+- Looping LLM calls when tools are invoked, until natural language response
+- Returning the final response
+
+Uses OpenAI-compatible API (primarily OpenRouter) with the OpenAI Python SDK.
+
+## Reasoning Model Support
+
+For models that support chain-of-thought reasoning:
+- Extract `reasoning_content` from API responses
+- Store in `assistant_msg["reasoning"]` for trajectory export
+- Pass back via `reasoning_content` field on subsequent turns
+
+## Trajectory Format
+
+Conversations are saved in ShareGPT format for training:
+```json
+{"from": "system", "value": "System prompt with <tools>...</tools>"}
+{"from": "human", "value": "User message"}
+{"from": "gpt", "value": "<think>reasoning</think>\n<tool_call>{...}</tool_call>"}
+{"from": "tool", "value": "<tool_response>{...}</tool_response>"}
+{"from": "gpt", "value": "Final response"}
+```
+
+Tool calls use `<tool_call>` XML tags, responses use `<tool_response>` tags, reasoning uses `<think>` tags.
+
+## Batch Processing (batch_runner.py)
+
+For processing multiple prompts:
+- Parallel execution with multiprocessing
+- Content-based resume for fault tolerance (matches on prompt text, not indices)
+- Toolset distributions control probabilistic tool availability per prompt
+- Output: `data/<run_name>/trajectories.jsonl` (combined) + individual batch files
+
+## Logging
+
+Trajectories restructure tools as a system prompt for storage in a format suitable for later training use.
+
+## Skills System
+
+Skills are on-demand knowledge documents the agent can load. Located in `skills/` directory:
+
+```
+skills/
+├── mlops/                    # Category folder
+│   ├── axolotl/             # Skill folder
+│   │   ├── SKILL.md         # Main instructions (required)
+│   │   ├── references/      # Additional docs, API specs
+│   │   └── templates/       # Output formats, configs
+│   └── vllm/
+│       └── SKILL.md
+└── example-skill/
+    └── SKILL.md
+```
+
+**Progressive disclosure** (token-efficient):
+1. `skills_categories()` - List category names (~50 tokens)
+2. `skills_list(category)` - Name + description per skill (~3k tokens)
+3. `skill_view(name)` - Full content + tags + linked files
+
+SKILL.md files use YAML frontmatter:
+```yaml
+---
+name: skill-name
+description: Brief description for listing
+tags: [tag1, tag2]
+related_skills: [other-skill]
+version: 1.0.0
+---
+# Skill Content...
+```
+
+Tool files: `tools/skills_tool.py` → `model_tools.py` → `toolsets.py`

.env.example

@@ -30,71 +30,58 @@ NOUS_API_KEY=
 FAL_KEY=
 
 # =============================================================================
-# TERMINAL TOOL CONFIGURATION (mini-swe-agent backend)
+# TERMINAL TOOL CONFIGURATION
 # =============================================================================
-# Backend type: "local", "singularity", "docker", "modal", or "ssh"
-# - local: Runs directly on your machine (fastest, no isolation)
-# - ssh: Runs on remote server via SSH (great for sandboxing - agent can't touch its own code)
-# - singularity: Runs in Apptainer/Singularity containers (HPC clusters, no root needed)
-# - docker: Runs in Docker containers (isolated, requires Docker + docker group)
-# - modal: Runs in Modal cloud sandboxes (scalable, requires Modal account)
-TERMINAL_ENV=local
+# Backend type: "local", "singularity", "docker", or "modal"
+# Uncomment ONE configuration block below based on your preferred backend.
 
-
-# Container images (for singularity/docker/modal backends)
-TERMINAL_DOCKER_IMAGE=python:3.11
-TERMINAL_SINGULARITY_IMAGE=docker://python:3.11
-TERMINAL_MODAL_IMAGE=python:3.11
-
-# Working directory inside the container
-TERMINAL_CWD=/tmp
-
-# Default command timeout in seconds
+# -----------------------------------------------------------------------------
+# OPTION 1: Singularity/Apptainer (RECOMMENDED for HPC clusters)
+# - No root required, common on shared systems
+# - Auto-builds and caches SIF images from docker:// URLs
+# - Uses /scratch if available, otherwise /tmp
+# -----------------------------------------------------------------------------
+TERMINAL_ENV=singularity
+TERMINAL_SINGULARITY_IMAGE=docker://nikolaik/python-nodejs:python3.11-nodejs20
+TERMINAL_CWD=/workspace
 TERMINAL_TIMEOUT=60
+# Optional: Override scratch directory (auto-detects /scratch or /tmp)
+# TERMINAL_SCRATCH_DIR=/scratch/myuser/hermes
 
-# Cleanup inactive environments after this many seconds
+# -----------------------------------------------------------------------------
+# OPTION 2: Local execution (FASTEST, but no isolation)
+# - Runs directly on your machine
+# - No containers, no setup required
+# - WARNING: Commands run with your user permissions
+# -----------------------------------------------------------------------------
+# TERMINAL_ENV=local
+# TERMINAL_CWD=/tmp
+# TERMINAL_TIMEOUT=60
+
+# -----------------------------------------------------------------------------
+# OPTION 3: Docker (good isolation, requires Docker)
+# - Requires Docker installed and user in 'docker' group
+# - Each task gets an isolated container
+# -----------------------------------------------------------------------------
+# TERMINAL_ENV=docker
+# TERMINAL_DOCKER_IMAGE=nikolaik/python-nodejs:python3.11-nodejs20
+# TERMINAL_CWD=/workspace
+# TERMINAL_TIMEOUT=60
+
+# -----------------------------------------------------------------------------
+# OPTION 4: Modal (cloud execution, scalable)
+# - Requires Modal account: pip install modal && modal setup
+# - Runs in Modal's cloud sandboxes
+# - Good for scaling to many parallel workers
+# -----------------------------------------------------------------------------
+# TERMINAL_ENV=modal
+# TERMINAL_MODAL_IMAGE=nikolaik/python-nodejs:python3.11-nodejs20
+# TERMINAL_CWD=/workspace
+# TERMINAL_TIMEOUT=60
+
+# Common settings for all backends
 TERMINAL_LIFETIME_SECONDS=300
-
-# =============================================================================
-# SSH REMOTE EXECUTION (for TERMINAL_ENV=ssh)
-# =============================================================================
-# Run terminal commands on a remote server via SSH.
-# Agent code stays on your machine, commands execute remotely.
-#
-# SECURITY BENEFITS:
-# - Agent cannot read your .env file (API keys protected)
-# - Agent cannot modify its own code
-# - Remote server acts as isolated sandbox
-# - Can safely configure passwordless sudo on remote
-#
-# TERMINAL_SSH_HOST=192.168.1.100
-# TERMINAL_SSH_USER=agent
-# TERMINAL_SSH_PORT=22
-# TERMINAL_SSH_KEY=~/.ssh/id_rsa
-
-# =============================================================================
-# SUDO SUPPORT (works with ALL terminal backends)
-# =============================================================================
-# If set, enables sudo commands by piping password via `sudo -S`.
-# Works with: local, docker, singularity, modal, and ssh backends.
-# 
-# SECURITY WARNING: Password stored in plaintext. Only use on trusted machines.
-# 
-# ALTERNATIVES:
-# - For SSH backend: Configure passwordless sudo on the remote server
-# - For containers: Run as root inside the container (no sudo needed)
-# - For local: Configure /etc/sudoers for specific commands
-# - For CLI: Leave unset - you'll be prompted interactively with 45s timeout
-#
-# SUDO_PASSWORD=your_password_here
-
-# =============================================================================
-# MODAL CLOUD BACKEND (Optional - for TERMINAL_ENV=modal)
-# =============================================================================
-# Modal uses CLI authentication, not environment variables.
-# Run: pip install modal && modal setup
-# This will authenticate via browser and store credentials locally.
-# No API key needed in .env - Modal handles auth automatically.
+TERMINAL_DISK_WARNING_GB=500
 
 # =============================================================================
 # BROWSER TOOL CONFIGURATION (agent-browser + Browserbase)
@@ -114,39 +101,25 @@ BROWSERBASE_API_KEY=
 BROWSERBASE_PROJECT_ID=
 
 # Enable residential proxies for better CAPTCHA solving (default: true)
-# Routes traffic through residential IPs, significantly improves success rate
 BROWSERBASE_PROXIES=true
 
 # Enable advanced stealth mode (default: false, requires Scale Plan)
-# Uses custom Chromium build to avoid bot detection altogether
 BROWSERBASE_ADVANCED_STEALTH=false
 
 # Browser session timeout in seconds (default: 300)
-# Sessions are cleaned up after this duration of inactivity
 BROWSER_SESSION_TIMEOUT=300
 
-# Browser inactivity timeout - auto-cleanup inactive sessions (default: 120 = 2 min)
-# Browser sessions are automatically closed after this period of no activity
-BROWSER_INACTIVITY_TIMEOUT=120
-
 # =============================================================================
-# SESSION LOGGING
-# =============================================================================
-# Session trajectories are automatically saved to logs/ directory
-# Format: logs/session_YYYYMMDD_HHMMSS_UUID.json
-# Contains full conversation history in trajectory format for debugging/replay
-
-# =============================================================================
-# LEGACY/OPTIONAL API KEYS
+# LEGACY/OPTIONAL
 # =============================================================================
 
-# Morph API Key - For legacy Hecate terminal backend (terminal-hecate tool)
+# Morph API Key - For legacy Hecate terminal backend
 # Get at: https://morph.so/
-MORPH_API_KEY=
+# MORPH_API_KEY=
 
 # Hecate VM Settings (only if using terminal-hecate tool)
-HECATE_VM_LIFETIME_SECONDS=300
-HECATE_DEFAULT_SNAPSHOT_ID=snapshot_p5294qxt
+# HECATE_VM_LIFETIME_SECONDS=300
+# HECATE_DEFAULT_SNAPSHOT_ID=snapshot_p5294qxt
 
 # =============================================================================
 # DEBUG OPTIONS
@@ -155,31 +128,3 @@ WEB_TOOLS_DEBUG=false
 VISION_TOOLS_DEBUG=false
 MOA_TOOLS_DEBUG=false
 IMAGE_TOOLS_DEBUG=false
-
-# =============================================================================
-# CONTEXT COMPRESSION (Auto-shrinks long conversations)
-# =============================================================================
-# When conversation approaches model's context limit, middle turns are
-# automatically summarized to free up space.
-#
-# CONTEXT_COMPRESSION_ENABLED=true        # Enable auto-compression (default: true)
-# CONTEXT_COMPRESSION_THRESHOLD=0.85      # Compress at 85% of context limit
-# CONTEXT_COMPRESSION_MODEL=google/gemini-2.0-flash-001  # Fast model for summaries
-
-# =============================================================================
-# RL TRAINING (Tinker + Atropos)
-# =============================================================================
-# Run reinforcement learning training on language models using the Tinker API.
-# Requires the rl-server to be running (from tinker-atropos package).
-
-# Tinker API Key - RL training service
-# Get at: https://tinker-console.thinkingmachines.ai/keys
-TINKER_API_KEY=
-
-# Weights & Biases API Key - Experiment tracking and metrics
-# Get at: https://wandb.ai/authorize
-WANDB_API_KEY=
-
-# RL API Server URL (default: http://localhost:8080)
-# Change if running the rl-server on a different host/port
-# RL_API_URL=http://localhost:8080

.gitignore

@@ -33,16 +33,11 @@ run_datagen_megascience_glm4-6.sh
 data/*
 node_modules/
 browser-use/
-agent-browser/
-# Private keys
-*.ppk
-*.pem
-privvy*
-images/
-__pycache__/
-hermes_agent.egg-info/
-wandb/
-testlogs
-
-# CLI config (may contain sensitive SSH paths)
-cli-config.yaml
+agent-browser/
+# Private keys
+*.ppk
+*.pem
+privvy*
+
+# CLI config (may contain sensitive SSH paths)
+cli-config.yaml

.gitmodules

@@ -1,6 +1,3 @@
 [submodule "mini-swe-agent"]
 	path = mini-swe-agent
 	url = https://github.com/SWE-agent/mini-swe-agent
-[submodule "tinker-atropos"]
-	path = tinker-atropos
-	url = https://github.com/nousresearch/tinker-atropos

AGENTS.md

@@ -1,533 +0,0 @@
-# Hermes Agent - Development Guide
-
-Instructions for AI coding assistants (GitHub Copilot, Cursor, etc.) and human developers.
-
-Hermes-Agent is an AI agent harness with tool-calling capabilities, interactive CLI, messaging integrations, and scheduled tasks.
-
-## Development Environment
-
-**IMPORTANT**: Always use the virtual environment if it exists:
-```bash
-source venv/bin/activate  # Before running any Python commands
-```
-
-## Project Structure
-
-```
-hermes-agent/
-├── hermes_cli/           # Unified CLI commands
-│   ├── main.py           # Entry point, command dispatcher
-│   ├── setup.py          # Interactive setup wizard
-│   ├── config.py         # Config management & migration
-│   ├── status.py         # Status display
-│   ├── doctor.py         # Diagnostics
-│   ├── gateway.py        # Gateway management
-│   ├── uninstall.py      # Uninstaller
-│   └── cron.py           # Cron job management
-├── tools/                # Tool implementations
-├── gateway/              # Messaging platform adapters
-├── cron/                 # Scheduler implementation
-├── skills/               # Knowledge documents
-├── cli.py                # Interactive CLI (Rich UI)
-├── run_agent.py          # Agent runner with AIAgent class
-├── model_tools.py        # Tool schemas and handlers
-├── toolsets.py           # Tool groupings
-├── toolset_distributions.py  # Probability-based tool selection
-└── batch_runner.py       # Parallel batch processing
-```
-
-**User Configuration** (stored in `~/.hermes/`):
-- `~/.hermes/config.yaml` - Settings (model, terminal, toolsets, etc.)
-- `~/.hermes/.env` - API keys and secrets
-
-## File Dependency Chain
-
-```
-tools/*.py → tools/__init__.py → model_tools.py → toolsets.py → toolset_distributions.py
-                                       ↑
-run_agent.py ──────────────────────────┘
-cli.py → run_agent.py (uses AIAgent with quiet_mode=True)
-batch_runner.py → run_agent.py + toolset_distributions.py
-```
-
-Always ensure consistency between tools, model_tools.py, and toolsets.py when changing any of them.
-
----
-
-## AIAgent Class
-
-The main agent is implemented in `run_agent.py`:
-
-```python
-class AIAgent:
-    def __init__(
-        self,
-        model: str = "anthropic/claude-sonnet-4",
-        api_key: str = None,
-        base_url: str = "https://openrouter.ai/api/v1",
-        max_iterations: int = 60,        # Max tool-calling loops
-        enabled_toolsets: list = None,
-        disabled_toolsets: list = None,
-        verbose_logging: bool = False,
-        quiet_mode: bool = False,         # Suppress progress output
-        tool_progress_callback: callable = None,  # Called on each tool use
-    ):
-        # Initialize OpenAI client, load tools based on toolsets
-        ...
-    
-    def chat(self, user_message: str, task_id: str = None) -> str:
-        # Main entry point - runs the agent loop
-        ...
-```
-
-### Agent Loop
-
-The core loop in `_run_agent_loop()`:
-
-```
-1. Add user message to conversation
-2. Call LLM with tools
-3. If LLM returns tool calls:
-   - Execute each tool
-   - Add tool results to conversation
-   - Go to step 2
-4. If LLM returns text response:
-   - Return response to user
-```
-
-```python
-while turns < max_turns:
-    response = client.chat.completions.create(
-        model=model,
-        messages=messages,
-        tools=tool_schemas,
-    )
-    
-    if response.tool_calls:
-        for tool_call in response.tool_calls:
-            result = await execute_tool(tool_call)
-            messages.append(tool_result_message(result))
-        turns += 1
-    else:
-        return response.content
-```
-
-### Conversation Management
-
-Messages are stored as a list of dicts following OpenAI format:
-
-```python
-messages = [
-    {"role": "system", "content": "You are a helpful assistant..."},
-    {"role": "user", "content": "Search for Python tutorials"},
-    {"role": "assistant", "content": None, "tool_calls": [...]},
-    {"role": "tool", "tool_call_id": "...", "content": "..."},
-    {"role": "assistant", "content": "Here's what I found..."},
-]
-```
-
-### Reasoning Model Support
-
-For models that support chain-of-thought reasoning:
-- Extract `reasoning_content` from API responses
-- Store in `assistant_msg["reasoning"]` for trajectory export
-- Pass back via `reasoning_content` field on subsequent turns
-
----
-
-## CLI Architecture (cli.py)
-
-The interactive CLI uses:
-- **Rich** - For the welcome banner and styled panels
-- **prompt_toolkit** - For fixed input area with history and `patch_stdout`
-- **KawaiiSpinner** (in run_agent.py) - Animated feedback during API calls and tool execution
-
-Key components:
-- `HermesCLI` class - Main CLI controller with commands and conversation loop
-- `load_cli_config()` - Loads config, sets environment variables for terminal
-- `build_welcome_banner()` - Displays ASCII art logo, tools, and skills summary
-- `/commands` - Process user commands like `/help`, `/clear`, `/personality`, etc.
-
-CLI uses `quiet_mode=True` when creating AIAgent to suppress verbose logging.
-
-### Adding CLI Commands
-
-1. Add to `COMMANDS` dict with description
-2. Add handler in `process_command()` method
-3. For persistent settings, use `save_config_value()` to update config
-
----
-
-## Hermes CLI Commands
-
-The unified `hermes` command provides all functionality:
-
-| Command | Description |
-|---------|-------------|
-| `hermes` | Interactive chat (default) |
-| `hermes chat -q "..."` | Single query mode |
-| `hermes setup` | Configure API keys and settings |
-| `hermes config` | View current configuration |
-| `hermes config edit` | Open config in editor |
-| `hermes config set KEY VAL` | Set a specific value |
-| `hermes config check` | Check for missing config |
-| `hermes config migrate` | Prompt for missing config interactively |
-| `hermes status` | Show configuration status |
-| `hermes doctor` | Diagnose issues |
-| `hermes update` | Update to latest (checks for new config) |
-| `hermes uninstall` | Uninstall (can keep configs for reinstall) |
-| `hermes gateway` | Start messaging gateway |
-| `hermes cron list` | View scheduled jobs |
-| `hermes version` | Show version info |
-
----
-
-## Messaging Gateway
-
-The gateway connects Hermes to Telegram, Discord, and WhatsApp.
-
-### Configuration (in `~/.hermes/.env`):
-
-```bash
-# Telegram
-TELEGRAM_BOT_TOKEN=123456:ABC-DEF...      # From @BotFather
-TELEGRAM_ALLOWED_USERS=123456789,987654   # Comma-separated user IDs (from @userinfobot)
-
-# Discord  
-DISCORD_BOT_TOKEN=MTIz...                 # From Developer Portal
-DISCORD_ALLOWED_USERS=123456789012345678  # Comma-separated user IDs
-
-# Agent Behavior
-HERMES_MAX_ITERATIONS=60                  # Max tool-calling iterations
-MESSAGING_CWD=/home/myuser                # Terminal working directory for messaging
-
-# Tool Progress (optional)
-HERMES_TOOL_PROGRESS=true                 # Send progress messages
-HERMES_TOOL_PROGRESS_MODE=new             # "new" or "all"
-```
-
-### Working Directory Behavior
-
-- **CLI (`hermes` command)**: Uses current directory (`.` → `os.getcwd()`)
-- **Messaging (Telegram/Discord)**: Uses `MESSAGING_CWD` (default: home directory)
-
-This is intentional: CLI users are in a terminal and expect the agent to work in their current directory, while messaging users need a consistent starting location.
-
-### Security (User Allowlists):
-
-**IMPORTANT**: Without an allowlist, anyone who finds your bot can use it!
-
-The gateway checks `{PLATFORM}_ALLOWED_USERS` environment variables:
-- If set: Only listed user IDs can interact with the bot
-- If unset: All users are allowed (dangerous with terminal access!)
-
-Users can find their IDs:
-- **Telegram**: Message [@userinfobot](https://t.me/userinfobot)
-- **Discord**: Enable Developer Mode, right-click name → Copy ID
-
-### Tool Progress Notifications
-
-When `HERMES_TOOL_PROGRESS=true`, the bot sends status messages as it works:
-- `💻 \`ls -la\`...` (terminal commands show the actual command)
-- `🔍 web_search...`
-- `📄 web_extract...`
-
-Modes:
-- `new`: Only when switching to a different tool (less spam)
-- `all`: Every single tool call
-
-### Typing Indicator
-
-The gateway keeps the "typing..." indicator active throughout processing, refreshing every 4 seconds. This lets users know the bot is working even during long tool-calling sequences.
-
-### Platform Toolsets:
-
-Each platform has a dedicated toolset in `toolsets.py`:
-- `hermes-telegram`: Full tools including terminal (with safety checks)
-- `hermes-discord`: Full tools including terminal
-- `hermes-whatsapp`: Full tools including terminal
-
----
-
-## Configuration System
-
-Configuration files are stored in `~/.hermes/` for easy user access:
-- `~/.hermes/config.yaml` - All settings (model, terminal, compression, etc.)
-- `~/.hermes/.env` - API keys and secrets
-
-### Adding New Configuration Options
-
-When adding new configuration variables, you MUST follow this process:
-
-#### For config.yaml options:
-
-1. Add to `DEFAULT_CONFIG` in `hermes_cli/config.py`
-2. **CRITICAL**: Bump `_config_version` in `DEFAULT_CONFIG` when adding required fields
-3. This triggers migration prompts for existing users on next `hermes update` or `hermes setup`
-
-Example:
-```python
-DEFAULT_CONFIG = {
-    # ... existing config ...
-    
-    "new_feature": {
-        "enabled": True,
-        "option": "default_value",
-    },
-    
-    # BUMP THIS when adding required fields
-    "_config_version": 2,  # Was 1, now 2
-}
-```
-
-#### For .env variables (API keys/secrets):
-
-1. Add to `REQUIRED_ENV_VARS` or `OPTIONAL_ENV_VARS` in `hermes_cli/config.py`
-2. Include metadata for the migration system:
-
-```python
-OPTIONAL_ENV_VARS = {
-    # ... existing vars ...
-    "NEW_API_KEY": {
-        "description": "What this key is for",
-        "prompt": "Display name in prompts",
-        "url": "https://where-to-get-it.com/",
-        "tools": ["tools_it_enables"],  # What tools need this
-        "password": True,  # Mask input
-    },
-}
-```
-
-#### Update related files:
-
-- `hermes_cli/setup.py` - Add prompts in the setup wizard
-- `cli-config.yaml.example` - Add example with comments
-- Update README.md if user-facing
-
-### Config Version Migration
-
-The system uses `_config_version` to detect outdated configs:
-
-1. `check_for_missing_config()` compares user config to `DEFAULT_CONFIG`
-2. `migrate_config()` interactively prompts for missing values
-3. Called automatically by `hermes update` and optionally by `hermes setup`
-
----
-
-## Environment Variables
-
-API keys are loaded from `~/.hermes/.env`:
-- `OPENROUTER_API_KEY` - Main LLM API access (primary provider)
-- `FIRECRAWL_API_KEY` - Web search/extract tools
-- `BROWSERBASE_API_KEY` / `BROWSERBASE_PROJECT_ID` - Browser automation
-- `FAL_KEY` - Image generation (FLUX model)
-- `NOUS_API_KEY` - Vision and Mixture-of-Agents tools
-
-Terminal tool configuration (in `~/.hermes/config.yaml`):
-- `terminal.backend` - Backend: local, docker, singularity, modal, or ssh
-- `terminal.cwd` - Working directory for CLI ("." = current directory)
-- `terminal.docker_image` - Image for Docker backend
-- `terminal.singularity_image` - Image for Singularity backend
-- `terminal.modal_image` - Image for Modal backend
-- SSH: `TERMINAL_SSH_HOST`, `TERMINAL_SSH_USER`, `TERMINAL_SSH_KEY` in .env
-
-Agent behavior (in `~/.hermes/.env`):
-- `HERMES_MAX_ITERATIONS` - Max tool-calling iterations (default: 60)
-- `MESSAGING_CWD` - Working directory for messaging platforms (default: ~)
-- `HERMES_TOOL_PROGRESS` - Enable tool progress messages (`true`/`false`)
-- `HERMES_TOOL_PROGRESS_MODE` - Progress mode: `new` (tool changes) or `all`
-
-### Dangerous Command Approval
-
-The terminal tool includes safety checks for potentially destructive commands (e.g., `rm -rf`, `DROP TABLE`, `chmod 777`, etc.):
-
-**Behavior by Backend:**
-- **Docker/Singularity/Modal**: Commands run unrestricted (isolated containers)
-- **Local/SSH**: Dangerous commands trigger approval flow
-
-**Approval Flow (CLI):**
-```
-⚠️  Potentially dangerous command detected: recursive delete
-    rm -rf /tmp/test
-
-    [o]nce  |  [s]ession  |  [a]lways  |  [d]eny
-    Choice [o/s/a/D]: 
-```
-
-**Approval Flow (Messaging):**
-- Command is blocked with explanation
-- Agent explains the command was blocked for safety
-- User must add the pattern to their allowlist via `hermes config edit` or run the command directly on their machine
-
-**Configuration:**
-- `command_allowlist` in `~/.hermes/config.yaml` stores permanently allowed patterns
-- Add patterns via "always" approval or edit directly
-
-**Sudo Handling (Messaging):**
-- If sudo fails over messaging, output includes tip to add `SUDO_PASSWORD` to `~/.hermes/.env`
-
----
-
-## Adding New Tools
-
-Follow this strict order to maintain consistency:
-
-1. Create `tools/your_tool.py` with:
-   - Handler function (sync or async) returning a JSON string via `json.dumps()`
-   - `check_*_requirements()` function to verify dependencies (e.g., API keys)
-   - Schema definition following OpenAI function-calling format
-
-2. Export in `tools/__init__.py`:
-   - Import the handler and check function
-   - Add to `__all__` list
-
-3. Register in `model_tools.py`:
-   - Add to `TOOLSET_REQUIREMENTS` if it needs API keys
-   - Create `get_*_tool_definitions()` function or add to existing
-   - Add routing in `handle_function_call()` dispatcher
-   - Update `get_all_tool_names()` with the tool name
-   - Update `get_toolset_for_tool()` mapping
-   - Update `get_available_toolsets()` and `check_toolset_requirements()`
-
-4. Add to toolset in `toolsets.py`:
-   - Add to existing toolset or create new one in TOOLSETS dict
-
-5. If the tool requires an API key:
-   - Add to `OPTIONAL_ENV_VARS` in `hermes_cli/config.py`
-   - The tool will be auto-disabled if the key is missing
-
-6. Optionally add to `toolset_distributions.py` for batch processing
-
-### Tool Implementation Pattern
-
-```python
-# tools/example_tool.py
-import json
-import os
-
-def check_example_requirements() -> bool:
-    """Check if required API keys/dependencies are available."""
-    return bool(os.getenv("EXAMPLE_API_KEY"))
-
-def example_tool(param: str, task_id: str = None) -> str:
-    """Execute the tool and return JSON string result."""
-    try:
-        result = {"success": True, "data": "..."}
-        return json.dumps(result, ensure_ascii=False)
-    except Exception as e:
-        return json.dumps({"error": str(e)}, ensure_ascii=False)
-```
-
-All tool handlers MUST return a JSON string. Never return raw dicts.
-
-### Dynamic Tool Availability
-
-Tools are automatically disabled when their API keys are missing:
-
-```python
-# In model_tools.py
-TOOLSET_REQUIREMENTS = {
-    "web": {"env_vars": ["FIRECRAWL_API_KEY"]},
-    "browser": {"env_vars": ["BROWSERBASE_API_KEY", "BROWSERBASE_PROJECT_ID"]},
-    "creative": {"env_vars": ["FAL_KEY"]},
-}
-```
-
-The `check_tool_availability()` function determines which tools to include.
-
-### Stateful Tools
-
-Tools that maintain state (terminal, browser) require:
-- `task_id` parameter for session isolation between concurrent tasks
-- `cleanup_*()` function to release resources
-- Cleanup is called automatically in run_agent.py after conversation completes
-
----
-
-## Trajectory Format
-
-Conversations are saved in ShareGPT format for training:
-```json
-{"from": "system", "value": "System prompt with <tools>...</tools>"}
-{"from": "human", "value": "User message"}
-{"from": "gpt", "value": "<think>reasoning</think>\n<tool_call>{...}</tool_call>"}
-{"from": "tool", "value": "<tool_response>{...}</tool_response>"}
-{"from": "gpt", "value": "Final response"}
-```
-
-Tool calls use `<tool_call>` XML tags, responses use `<tool_response>` tags, reasoning uses `<think>` tags.
-
-### Trajectory Export
-
-```python
-agent = AIAgent(save_trajectories=True)
-agent.chat("Do something")
-# Saves to trajectories/*.jsonl in ShareGPT format
-```
-
----
-
-## Batch Processing (batch_runner.py)
-
-For processing multiple prompts:
-- Parallel execution with multiprocessing
-- Content-based resume for fault tolerance (matches on prompt text, not indices)
-- Toolset distributions control probabilistic tool availability per prompt
-- Output: `data/<run_name>/trajectories.jsonl` (combined) + individual batch files
-
-```bash
-python batch_runner.py \
-    --dataset_file=prompts.jsonl \
-    --batch_size=20 \
-    --num_workers=4 \
-    --run_name=my_run
-```
-
----
-
-## Skills System
-
-Skills are on-demand knowledge documents the agent can load. Located in `skills/` directory:
-
-```
-skills/
-├── mlops/                    # Category folder
-│   ├── axolotl/             # Skill folder
-│   │   ├── SKILL.md         # Main instructions (required)
-│   │   ├── references/      # Additional docs, API specs
-│   │   └── templates/       # Output formats, configs
-│   └── vllm/
-│       └── SKILL.md
-└── example-skill/
-    └── SKILL.md
-```
-
-**Progressive disclosure** (token-efficient):
-1. `skills_categories()` - List category names (~50 tokens)
-2. `skills_list(category)` - Name + description per skill (~3k tokens)
-3. `skill_view(name)` - Full content + tags + linked files
-
-SKILL.md files use YAML frontmatter:
-```yaml
----
-name: skill-name
-description: Brief description for listing
-tags: [tag1, tag2]
-related_skills: [other-skill]
-version: 1.0.0
----
-# Skill Content...
-```
-
-Tool files: `tools/skills_tool.py` → `model_tools.py` → `toolsets.py`
-
----
-
-## Testing Changes
-
-After making changes:
-
-1. Run `hermes doctor` to check setup
-2. Run `hermes config check` to verify config
-3. Test with `hermes chat -q "test message"`
-4. For new config options, test fresh install: `rm -rf ~/.hermes && hermes setup`

TODO.md

@@ -4,126 +4,87 @@
 
 ---
 
-## 1. Subagent Architecture (Context Isolation) 🎯
+## 1. Memory & Context Management 🧠
 
-**Problem:** Long-running tools (terminal commands, browser automation, complex file operations) consume massive context. A single `ls -la` can add hundreds of lines. Browser snapshots, debugging sessions, and iterative terminal work quickly bloat the main conversation, leaving less room for actual reasoning.
-
-**Solution:** The main agent becomes an **orchestrator** that delegates context-heavy tasks to **subagents**.
-
-**Architecture:**
-```
-┌─────────────────────────────────────────────────────────────────┐
-│  ORCHESTRATOR (main agent)                                      │
-│  - Receives user request                                        │
-│  - Plans approach                                               │
-│  - Delegates heavy tasks to subagents                           │
-│  - Receives summarized results                                  │
-│  - Maintains clean, focused context                             │
-└─────────────────────────────────────────────────────────────────┘
-         │                    │                    │
-         ▼                    ▼                    ▼
-┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐
-│ TERMINAL AGENT  │  │ BROWSER AGENT   │  │ CODE AGENT      │
-│ - terminal tool │  │ - browser tools │  │ - file tools    │
-│ - file tools    │  │ - web_search    │  │ - terminal      │
-│                 │  │ - web_extract   │  │                 │
-│ Isolated context│  │ Isolated context│  │ Isolated context│
-│ Returns summary │  │ Returns summary │  │ Returns summary │
-└─────────────────┘  └─────────────────┘  └─────────────────┘
-```
-
-**How it works:**
-1. User asks: "Set up a new Python project with FastAPI and tests"
-2. Orchestrator plans: "I need to create files, install deps, write code"
-3. Orchestrator calls: `terminal_task(goal="Create venv, install fastapi pytest", context="New project in ~/myapp")`
-4. **Subagent spawns** with fresh context, only terminal/file tools
-5. Subagent iterates (may take 10+ tool calls, lots of output)
-6. Subagent completes → returns summary: "Created venv, installed fastapi==0.109.0, pytest==8.0.0"
-7. Orchestrator receives **only the summary**, context stays clean
-8. Orchestrator continues with next subtask
-
-**Key tools to implement:**
-- [ ] `terminal_task(goal, context, cwd?)` - Delegate terminal/shell work
-- [ ] `browser_task(goal, context, start_url?)` - Delegate web research/automation  
-- [ ] `code_task(goal, context, files?)` - Delegate code writing/modification
-- [ ] Generic `delegate_task(goal, context, toolsets=[])` - Flexible delegation
-
-**Implementation details:**
-- [ ] Subagent uses same `run_agent.py` but with:
-  - Fresh/empty conversation history
-  - Limited toolset (only what's needed)
-  - Smaller max_iterations (focused task)
-  - Task-specific system prompt
-- [ ] Subagent returns structured result:
-  ```python
-  {
-    "success": True,
-    "summary": "Installed 3 packages, created 2 files",
-    "details": "Optional longer explanation if needed",
-    "artifacts": ["~/myapp/requirements.txt", "~/myapp/main.py"],  # Files created
-    "errors": []  # Any issues encountered
-  }
-  ```
-- [ ] Orchestrator sees only the summary in its context
-- [ ] Full subagent transcript saved separately for debugging
-
-**Benefits:**
-- 🧹 **Clean context** - Orchestrator stays focused, doesn't drown in tool output
-- 📊 **Better token efficiency** - 50 terminal outputs → 1 summary paragraph
-- 🎯 **Focused subagents** - Each agent has just the tools it needs
-- 🔄 **Parallel potential** - Independent subtasks could run concurrently
-- 🐛 **Easier debugging** - Each subtask has its own isolated transcript
-
-**When to use subagents vs direct tools:**
-- **Subagent**: Multi-step tasks, iteration likely, lots of output expected
-- **Direct**: Quick one-off commands, simple file reads, user needs to see output
-
-**Files to modify:** `run_agent.py` (add orchestration mode), new `tools/delegate_tools.py`, new `subagent_runner.py`
-
----
-
-## 2. Planning & Task Management 📋
-
-**Problem:** Agent handles tasks reactively without explicit planning. Complex multi-step tasks lack structure, progress tracking, and the ability to decompose work into manageable chunks.
+**Problem:** Context grows unbounded during long conversations. Trajectory compression exists for training data post-hoc, but live conversations lack intelligent context management.
 
 **Ideas:**
-- [ ] **Task decomposition tool** - Break complex requests into subtasks:
-  ```
-  User: "Set up a new Python project with FastAPI, tests, and Docker"
+- [ ] **Incremental summarization** - Compress old tool outputs on-the-fly during conversations
+  - Trigger when context exceeds threshold (e.g., 80% of max tokens)
+  - Preserve recent turns fully, summarize older tool responses
+  - Could reuse logic from `trajectory_compressor.py`
   
-  Agent creates plan:
-  ├── 1. Create project structure and requirements.txt
-  ├── 2. Implement FastAPI app skeleton
-  ├── 3. Add pytest configuration and initial tests
-  ├── 4. Create Dockerfile and docker-compose.yml
-  └── 5. Verify everything works together
-  ```
-  - Each subtask becomes a trackable unit
-  - Agent can report progress: "Completed 3/5 tasks"
+- [ ] **Semantic memory retrieval** - Vector store for long conversation recall
+  - Embed important facts/findings as conversation progresses
+  - Retrieve relevant memories when needed instead of keeping everything in context
+  - Consider lightweight solutions: ChromaDB, FAISS, or even a simple embedding cache
   
-- [ ] **Progress checkpoints** - Periodic self-assessment:
-  - After N tool calls or time elapsed, pause to evaluate
-  - "What have I accomplished? What remains? Am I on track?"
-  - Detect if stuck in loops or making no progress
-  - Could trigger replanning if approach isn't working
-  
-- [ ] **Explicit plan storage** - Persist plan in conversation:
-  - Store as structured data (not just in context)
-  - Update status as tasks complete
-  - User can ask "What's the plan?" or "What's left?"
-  - Survives context compression (plans are protected)
+- [ ] **Working vs. episodic memory** distinction
+  - Working memory: Current task state, recent tool results (always in context)
+  - Episodic memory: Past findings, tried approaches (retrieved on demand)
+  - Clear eviction policies for each
 
-- [ ] **Failure recovery with replanning** - When things go wrong:
-  - Record what failed and why
-  - Revise plan to work around the issue
-  - "Step 3 failed because X, adjusting approach to Y"
-  - Prevents repeating failed strategies
-
-**Files to modify:** `run_agent.py` (add planning hooks), new `tools/planning_tool.py`
+**Files to modify:** `run_agent.py` (add memory manager), possibly new `tools/memory_tool.py`
 
 ---
 
-## 3. Dynamic Skills Expansion 📚
+## 2. Self-Reflection & Course Correction 🔄
+
+**Problem:** Current retry logic handles malformed outputs but not semantic failures. Agent doesn't reason about *why* something failed.
+
+**Ideas:**
+- [ ] **Meta-reasoning after failures** - When a tool returns an error or unexpected result:
+  ```
+  Tool failed → Reflect: "Why did this fail? What assumptions were wrong?"
+  → Adjust approach → Retry with new strategy
+  ```
+  - Could be a lightweight LLM call or structured self-prompt
+  
+- [ ] **Planning/replanning module** - For complex multi-step tasks:
+  - Generate plan before execution
+  - After each step, evaluate: "Am I on track? Should I revise the plan?"
+  - Store plan in working memory, update as needed
+  
+- [ ] **Approach memory** - Remember what didn't work:
+  - "I tried X for this type of problem and it failed because Y"
+  - Prevents repeating failed strategies in the same conversation
+
+**Files to modify:** `run_agent.py` (add reflection hooks in tool loop), new `tools/reflection_tool.py`
+
+---
+
+## 3. Tool Composition & Learning 🔧
+
+**Problem:** Tools are atomic. Complex tasks require repeated manual orchestration of the same tool sequences.
+
+**Ideas:**
+- [ ] **Macro tools / Tool chains** - Define reusable tool sequences:
+  ```yaml
+  research_topic:
+    description: "Deep research on a topic"
+    steps:
+      - web_search: {query: "$topic"}
+      - web_extract: {urls: "$search_results.urls[:3]"}
+      - summarize: {content: "$extracted"}
+  ```
+  - Could be defined in skills or a new `macros/` directory
+  - Agent can invoke macro as single tool call
+  
+- [ ] **Tool failure patterns** - Learn from failures:
+  - Track: tool, input pattern, error type, what worked instead
+  - Before calling a tool, check: "Has this pattern failed before?"
+  - Persistent across sessions (stored in skills or separate DB)
+  
+- [ ] **Parallel tool execution** - When tools are independent, run concurrently:
+  - Detect independence (no data dependencies between calls)
+  - Use `asyncio.gather()` for parallel execution
+  - Already have async support in some tools, just need orchestration
+
+**Files to modify:** `model_tools.py`, `toolsets.py`, new `tool_macros.py`
+
+---
+
+## 4. Dynamic Skills Expansion 📚
 
 **Problem:** Skills system is elegant but static. Skills must be manually created and added.
 
@@ -152,43 +113,56 @@
 
 ---
 
-## 4. Interactive Clarifying Questions Tool ❓
+## 5. Task Continuation Hints 🎯
 
-**Problem:** Agent sometimes makes assumptions or guesses when it should ask the user. Currently can only ask via text, which gets lost in long outputs.
+**Problem:** Could be more helpful by suggesting logical next steps.
 
 **Ideas:**
-- [ ] **Multiple-choice prompt tool** - Let agent present structured choices to user:
-  ```
-  ask_user_choice(
-    question="Should the language switcher enable only German or all languages?",
-    choices=[
-      "Only enable German - works immediately",
-      "Enable all, mark untranslated - show fallback notice",
-      "Let me specify something else"
-    ]
-  )
-  ```
-  - Renders as interactive terminal UI with arrow key / Tab navigation
-  - User selects option, result returned to agent
-  - Up to 4 choices + optional free-text option
-  
-- [ ] **Implementation:**
-  - Use `inquirer` or `questionary` Python library for rich terminal prompts
-  - Tool returns selected option text (or user's custom input)
-  - **CLI-only** - only works when running via `cli.py` (not API/programmatic use)
-  - Graceful fallback: if not in interactive mode, return error asking agent to rephrase as text
-  
-- [ ] **Use cases:**
-  - Clarify ambiguous requirements before starting work
-  - Confirm destructive operations with clear options
-  - Let user choose between implementation approaches
-  - Checkpoint complex multi-step workflows
+- [ ] **Suggest next steps** - At end of a task, suggest logical continuations:
+  - "Code is written. Want me to also write tests / docs / deploy?"
+  - Based on common workflows for task type
+  - Non-intrusive, just offer options
 
-**Files to modify:** New `tools/ask_user_tool.py`, `cli.py` (detect interactive mode), `model_tools.py`
+**Files to modify:** `run_agent.py`, response generation logic
 
 ---
 
-## 5. Collaborative Problem Solving 🤝
+## 6. Uncertainty & Honesty Calibration 🎚️
+
+**Problem:** Sometimes confidently wrong. Should be better calibrated about what I know vs. don't know.
+
+**Ideas:**
+- [ ] **Source attribution** - Track where information came from:
+  - "According to the docs I just fetched..." vs "From my training data (may be outdated)..."
+  - Let user assess reliability themselves
+
+- [ ] **Cross-reference high-stakes claims** - Self-check for made-up details:
+  - When stakes are high, verify with tools before presenting as fact
+  - "Let me verify that before you act on it..."
+
+**Files to modify:** `run_agent.py`, response generation logic
+
+---
+
+## 7. Resource Awareness & Efficiency 💰
+
+**Problem:** No awareness of costs, time, or resource usage. Could be smarter about efficiency.
+
+**Ideas:**
+- [ ] **Tool result caching** - Don't repeat identical operations:
+  - Cache web searches, extractions within a session
+  - Invalidation based on time-sensitivity of query
+  - Hash-based lookup: same input → cached output
+
+- [ ] **Lazy evaluation** - Don't fetch everything upfront:
+  - Get summaries first, full content only if needed
+  - "I found 5 relevant pages. Want me to deep-dive on any?"
+
+**Files to modify:** `model_tools.py`, new `resource_tracker.py`
+
+---
+
+## 8. Collaborative Problem Solving 🤝
 
 **Problem:** Interaction is command/response. Complex problems benefit from dialogue.
 
@@ -207,7 +181,7 @@
 
 ---
 
-## 6. Project-Local Context 💾
+## 9. Project-Local Context 💾
 
 **Problem:** Valuable context lost between sessions.
 
@@ -225,17 +199,40 @@
 
 **Files to modify:** New `project_context.py`, auto-load in `run_agent.py`
 
-## 6. Tools & Skills Wishlist 🧰
+---
+
+## 10. Graceful Degradation & Robustness 🛡️
+
+**Problem:** When things go wrong, recovery is limited. Should fail gracefully.
+
+**Ideas:**
+- [ ] **Fallback chains** - When primary approach fails, have backups:
+  - `web_extract` fails → try `browser_navigate` → try `web_search` for cached version
+  - Define fallback order per tool type
+  
+- [ ] **Partial progress preservation** - Don't lose work on failure:
+  - Long task fails midway → save what we've got
+  - "I completed 3/5 steps before the error. Here's what I have..."
+  
+- [ ] **Self-healing** - Detect and recover from bad states:
+  - Browser stuck → close and retry
+  - Terminal hung → timeout and reset
+
+**Files to modify:** `model_tools.py`, tool implementations, new `fallback_manager.py`
+
+---
+
+## 11. Tools & Skills Wishlist 🧰
 
 *Things that would need new tool implementations (can't do well with current tools):*
 
 ### High-Impact
 
-- [ ] **Audio/Video Transcription** 🎬 *(See also: Section 16 for detailed spec)*
+- [ ] **Audio/Video Transcription** 🎬
   - Transcribe audio files, podcasts, YouTube videos
   - Extract key moments from video
-  - Voice memo transcription for messaging integrations
-  - *Provider options: Whisper API, Deepgram, local Whisper*
+  - Currently blind to multimedia content
+  - *Could potentially use whisper via terminal, but native tool would be cleaner*
   
 - [ ] **Diagram Rendering** 📊
   - Render Mermaid/PlantUML to actual images
@@ -244,26 +241,6 @@
 
 ### Medium-Impact
 
-- [ ] **Canvas / Visual Workspace** 🖼️
-  - Agent-controlled visual panel for rendering interactive UI
-  - Inspired by OpenClaw's Canvas feature
-  - **Capabilities:**
-    - `present` / `hide` - Show/hide the canvas panel
-    - `navigate` - Load HTML files or URLs into the canvas
-    - `eval` - Execute JavaScript in the canvas context
-    - `snapshot` - Capture the rendered UI as an image
-  - **Use cases:**
-    - Display generated HTML/CSS/JS previews
-    - Show interactive data visualizations (charts, graphs)
-    - Render diagrams (Mermaid → rendered output)
-    - Present structured information in rich format
-    - A2UI-style component system for structured agent UI
-  - **Implementation options:**
-    - Electron-based panel for CLI
-    - WebSocket-connected web app
-    - VS Code webview extension
-  - *Would let agent "show" things rather than just describe them*
-
 - [ ] **Document Generation** 📄
   - Create styled PDFs, Word docs, presentations
   - *Can do basic PDF via terminal tools, but limited*
@@ -292,297 +269,36 @@
 
 ---
 
-## 7. Messaging Platform Integrations 💬 ✅ COMPLETE
+## Priority Order (Suggested)
 
-**Problem:** Agent currently only works via `cli.py` which requires direct terminal access. Users may want to interact via messaging apps from their phone or other devices.
-
-**Architecture:**
-- `run_agent.py` already accepts `conversation_history` parameter and returns updated messages ✅
-- Need: persistent session storage, platform monitors, session key resolution
-
-**Implementation approach:**
-```
-┌─────────────────────────────────────────────────────────────┐
-│  Platform Monitor (e.g., telegram_monitor.py)               │
-│  ├─ Long-running daemon connecting to messaging platform    │
-│  ├─ On message: resolve session key → load history from disk│
-│  ├─ Call run_agent.py with loaded history                   │
-│  ├─ Save updated history back to disk (JSONL)               │
-│  └─ Send response back to platform                          │
-└─────────────────────────────────────────────────────────────┘
-```
-
-**Platform support (each user sets up their own credentials):**
-- [x] **Telegram** - via `python-telegram-bot`
-  - Bot token from @BotFather
-  - Easiest to set up, good for personal use
-- [x] **Discord** - via `discord.py`
-  - Bot token from Discord Developer Portal
-  - Can work in servers (group sessions) or DMs
-- [x] **WhatsApp** - via Node.js bridge (whatsapp-web.js/baileys)
-  - Requires Node.js bridge setup
-  - More complex, but reaches most people
-
-**Session management:**
-- [x] **Session store** - JSONL persistence per session key
-  - `~/.hermes/sessions/{session_id}.jsonl`
-  - Session keys: `agent:main:telegram:dm`, `agent:main:discord:group:123`, etc.
-- [x] **Session expiry** - Configurable reset policies
-  - Daily reset (default 4am) OR idle timeout (default 2 hours)
-  - Manual reset via `/reset` or `/new` command in chat
-  - Per-platform and per-type overrides
-- [x] **Session continuity** - Conversations persist across messages until reset
-
-**Files created:** `gateway/`, `gateway/platforms/`, `gateway/config.py`, `gateway/session.py`, `gateway/delivery.py`, `gateway/run.py`
-
-**Configuration:**
-- Environment variables: `TELEGRAM_BOT_TOKEN`, `DISCORD_BOT_TOKEN`, etc.
-- Config file: `~/.hermes/gateway.json`
-- CLI commands: `/platforms` to check status, `--gateway` to start
-
-**Dynamic context injection:**
-- Agent knows its source platform and chat
-- Agent knows connected platforms and home channels
-- Agent can deliver cron outputs to specific platforms
+1. **Memory & Context Management** - Biggest impact on complex tasks
+2. **Self-Reflection** - Improves reliability and reduces wasted tool calls  
+3. **Project-Local Context** - Practical win, keeps useful info across sessions
+4. **Tool Composition** - Quality of life, builds on other improvements
+5. **Dynamic Skills** - Force multiplier for repeated tasks
 
 ---
 
-## 8. Text-to-Speech (TTS) 🔊
+## Removed Items (Unrealistic)
 
-**Problem:** Agent can only respond with text. Some users prefer audio responses (accessibility, hands-free use, podcasts).
+The following were removed because they're architecturally impossible:
 
-**Ideas:**
-- [ ] **TTS tool** - Generate audio files from text
-  ```python
-  tts_generate(text="Here's your summary...", voice="nova", output="summary.mp3")
-  ```
-  - Returns path to generated audio file
-  - For messaging integrations: can send as voice message
-  
-- [ ] **Provider options:**
-  - Edge TTS (free, good quality, many voices)
-  - OpenAI TTS (paid, excellent quality)
-  - ElevenLabs (paid, best quality, voice cloning)
-  - Local options (Coqui TTS, Bark)
-  
-- [ ] **Modes:**
-  - On-demand: User explicitly asks "read this to me"
-  - Auto-TTS: Configurable to always generate audio for responses
-  - Long-text handling: Summarize or chunk very long responses
-  
-- [ ] **Integration with messaging:**
-  - When enabled, can send voice notes instead of/alongside text
-  - User preference per channel
+- ~~Proactive suggestions / Prefetching~~ - Agent only runs on user request, can't interject
+- ~~Session save/restore across conversations~~ - Agent doesn't control session persistence
+- ~~User preference learning across sessions~~ - Same issue
+- ~~Clipboard integration~~ - No access to user's local system clipboard
+- ~~Voice/TTS playback~~ - Can generate audio but can't play it to user
+- ~~Set reminders~~ - No persistent background execution
 
-**Files to create:** `tools/tts_tool.py`, config in `cli-config.yaml`
+The following were removed because they're **already possible**:
 
----
-
-## 13. Speech-to-Text / Audio Transcription 🎤
-
-**Problem:** Users may want to send voice memos instead of typing. Agent is blind to audio content.
-
-**Ideas:**
-- [ ] **Voice memo transcription** - For messaging integrations
-  - User sends voice message → transcribe → process as text
-  - Seamless: user speaks, agent responds
-  
-- [ ] **Audio/video file transcription** - Existing idea, expanded:
-  - Transcribe local audio files (mp3, wav, m4a)
-  - Transcribe YouTube videos (download audio → transcribe)
-  - Extract key moments with timestamps
-  
-- [ ] **Provider options:**
-  - OpenAI Whisper API (good quality, cheap)
-  - Deepgram (fast, good for real-time)
-  - Local Whisper (free, runs on GPU)
-  - Groq Whisper (fast, free tier available)
-  
-- [ ] **Tool interface:**
-  ```python
-  transcribe(source="audio.mp3")  # Local file
-  transcribe(source="https://youtube.com/...")  # YouTube
-  transcribe(source="voice_message", data=bytes)  # Voice memo
-  ```
-
-**Files to create:** `tools/transcribe_tool.py`, integrate with messaging monitors
-
-### Plugin/Extension System 🔌
-
-**Concept:** Allow users to add custom tools/skills without modifying core code.
-
-**Why interesting:**
-- Community contributions
-- Organization-specific tools
-- Clean separation of core vs. extensions
-
-**Open questions:**
-- Security implications of loading arbitrary code
-- Versioning and compatibility
-- Discovery and installation UX
-
----
-
-## Recently Completed ✅
-
-### Dangerous Command Approval System
-**Implemented:** Dangerous command detection and approval for terminal tool.
-
-**Features:**
-- Pattern-based detection of dangerous commands (rm -rf, DROP TABLE, chmod 777, etc.)
-- CLI prompt with options: `[o]nce | [s]ession | [a]lways | [d]eny`
-- Session caching (approved patterns don't re-prompt)
-- Permanent allowlist in `~/.hermes/config.yaml`
-- Force flag for agent to bypass after user confirmation
-- Skip check for isolated backends (Docker, Singularity, Modal)
-- Helpful sudo failure messages for messaging platforms
-
-**Files:** `tools/terminal_tool.py`, `model_tools.py`, `hermes_cli/config.py`
-
----
-
-## 14. Learning Machine / Dynamic Memory System 🧠
-
-*Inspired by [Dash](~/agent-codebases/dash) - a self-learning data agent.*
-
-**Problem:** Agent starts fresh every session. Valuable learnings from debugging, error patterns, successful approaches, and user preferences are lost.
-
-**Dash's Key Insight:** Separate **Knowledge** (static, curated) from **Learnings** (dynamic, discovered):
-
-| System | What It Stores | How It Evolves |
-|--------|---------------|----------------|
-| **Knowledge** (Skills) | Validated approaches, templates, best practices | Curated by user |
-| **Learnings** | Error patterns, gotchas, discovered fixes | Managed automatically |
-
-**Tools to implement:**
-- [ ] `save_learning(topic, learning, context?)` - Record a discovered pattern
-  ```python
-  save_learning(
-    topic="python-ssl",
-    learning="On Ubuntu 22.04, SSL certificate errors often fixed by: apt install ca-certificates",
-    context="Debugging requests SSL failure"
-  )
-  ```
-- [ ] `search_learnings(query)` - Find relevant past learnings
-  ```python
-  search_learnings("SSL certificate error Python")
-  # Returns: "On Ubuntu 22.04, SSL certificate errors often fixed by..."
-  ```
-
-**User Profile & Memory:**
-- [ ] `user_profile` - Structured facts about user preferences
-  ```yaml
-  # ~/.hermes/user_profile.yaml
-  coding_style:
-    python_formatter: black
-    type_hints: always
-    test_framework: pytest
-  preferences:
-    verbosity: detailed
-    confirm_destructive: true
-  environment:
-    os: linux
-    shell: bash
-    default_python: 3.11
-  ```
-- [ ] `user_memory` - Unstructured observations the agent learns
-  ```yaml
-  # ~/.hermes/user_memory.yaml
-  - "User prefers tabs over spaces despite black's defaults"
-  - "User's main project is ~/work/myapp - a Django app"
-  - "User often works late - don't ask about timezone"
-  ```
-
-**When to learn:**
-- After fixing an error that took multiple attempts
-- When user corrects the agent's approach
-- When a workaround is discovered for a tool limitation
-- When user expresses a preference
-
-**Storage:** Vector database (ChromaDB) or simple YAML with embedding search.
-
-**Files to create:** `tools/learning_tools.py`, `learning/store.py`, `~/.hermes/learnings/`
-
----
-
-## 15. Layered Context Architecture 📊
-
-*Inspired by Dash's "Six Layers of Context" - grounding responses in multiple sources.*
-
-**Problem:** Context sources are ad-hoc. No clear hierarchy or strategy for what context to include when.
-
-**Proposed Layers for Hermes:**
-
-| Layer | Source | When Loaded | Example |
-|-------|--------|-------------|---------|
-| 1. **Project Context** | `.hermes/context.md` | Auto on cwd | "This is a FastAPI project using PostgreSQL" |
-| 2. **Skills** | `skills/*.md` | On request | "How to set up React project" |
-| 3. **User Profile** | `~/.hermes/user_profile.yaml` | Always | "User prefers pytest, uses black" |
-| 4. **Learnings** | `~/.hermes/learnings/` | Semantic search | "SSL fix for Ubuntu" |
-| 5. **External Knowledge** | Web search, docs | On demand | Current API docs, Stack Overflow |
-| 6. **Runtime Introspection** | Tool calls | Real-time | File contents, terminal output |
-
-**Benefits:**
-- Clear mental model for what context is available
-- Prioritization: local > learned > external
-- Debugging: "Why did agent do X?" → check which layers contributed
-
-**Files to modify:** `run_agent.py` (context loading), new `context/layers.py`
-
----
-
-## 16. Evaluation System with LLM Grading 📏
-
-*Inspired by Dash's evaluation framework.*
-
-**Problem:** `batch_runner.py` runs test cases but lacks quality assessment.
-
-**Dash's Approach:**
-- **String matching** (default) - Check if expected strings appear
-- **LLM grader** (-g flag) - GPT evaluates response quality
-- **Result comparison** (-r flag) - Compare against golden output
-
-**Implementation for Hermes:**
-
-- [ ] **Test case format:**
-  ```python
-  TestCase(
-    name="create_python_project",
-    prompt="Create a new Python project with FastAPI and tests",
-    expected_strings=["requirements.txt", "main.py", "test_"],  # Basic check
-    golden_actions=["write:main.py", "write:requirements.txt", "terminal:pip install"],
-    grader_criteria="Should create complete project structure with working code"
-  )
-  ```
-
-- [ ] **LLM grader mode:**
-  ```python
-  def grade_response(response: str, criteria: str) -> Grade:
-      """Use GPT to evaluate response quality."""
-      prompt = f"""
-      Evaluate this agent response against the criteria.
-      Criteria: {criteria}
-      Response: {response}
-      
-      Score (1-5) and explain why.
-      """
-      # Returns: Grade(score=4, explanation="Created all files but tests are minimal")
-  ```
-
-- [ ] **Action comparison mode:**
-  - Record tool calls made during test
-  - Compare against expected actions
-  - "Expected terminal call to pip install, got npm install"
-
-- [ ] **CLI flags:**
-  ```bash
-  python batch_runner.py eval test_cases.yaml       # String matching
-  python batch_runner.py eval test_cases.yaml -g    # + LLM grading
-  python batch_runner.py eval test_cases.yaml -r    # + Result comparison
-  python batch_runner.py eval test_cases.yaml -v    # Verbose (show responses)
-  ```
-
-**Files to modify:** `batch_runner.py`, new `evals/test_cases.py`, new `evals/grader.py`
+- ~~HTTP/API Client~~ → Use `curl` or Python `requests` in terminal
+- ~~Structured Data Manipulation~~ → Use `pandas` in terminal
+- ~~Git-Native Operations~~ → Use `git` CLI in terminal
+- ~~Symbolic Math~~ → Use `SymPy` in terminal
+- ~~Code Quality Tools~~ → Run linters (`eslint`, `black`, `mypy`) in terminal
+- ~~Testing Framework~~ → Run `pytest`, `jest`, etc. in terminal
+- ~~Translation~~ → LLM handles this fine, or use translation APIs
 
 ---
 

cli-config.yaml.example

@@ -23,15 +23,11 @@ model:
 # OPTION 1: Local execution (default)
 # Commands run directly on your machine in the current directory
 # -----------------------------------------------------------------------------
-# Working directory behavior:
-#   - CLI (`hermes` command): Uses "." (current directory where you run hermes)
-#   - Messaging (Telegram/Discord): Uses MESSAGING_CWD from .env (default: home)
 terminal:
   env_type: "local"
-  cwd: "."  # CLI working directory - "." means current directory
+  cwd: "."  # Use "." for current directory, or specify absolute path
   timeout: 180
   lifetime_seconds: 300
-  # sudo_password: ""  # Enable sudo commands (pipes via sudo -S) - SECURITY WARNING: plaintext!
 
 # -----------------------------------------------------------------------------
 # OPTION 2: SSH remote execution
@@ -58,7 +54,7 @@ terminal:
 #   cwd: "/workspace"
 #   timeout: 180
 #   lifetime_seconds: 300
-#   docker_image: "nikolaik/python-nodejs:python3.11-nodejs20"
+#   docker_image: "python:3.11"
 
 # -----------------------------------------------------------------------------
 # OPTION 4: Singularity/Apptainer container
@@ -70,7 +66,7 @@ terminal:
 #   cwd: "/workspace"
 #   timeout: 180
 #   lifetime_seconds: 300
-#   singularity_image: "docker://nikolaik/python-nodejs:python3.11-nodejs20"
+#   singularity_image: "docker://python:3.11"
 
 # -----------------------------------------------------------------------------
 # OPTION 5: Modal cloud execution
@@ -82,74 +78,14 @@ terminal:
 #   cwd: "/workspace"
 #   timeout: 180
 #   lifetime_seconds: 300
-#   modal_image: "nikolaik/python-nodejs:python3.11-nodejs20"
-
-# -----------------------------------------------------------------------------
-# SUDO SUPPORT (works with ALL backends above)
-# -----------------------------------------------------------------------------
-# Add sudo_password to any terminal config above to enable sudo commands.
-# The password is piped via `sudo -S`. Works with local, ssh, docker, etc.
-#
-# SECURITY WARNING: Password stored in plaintext!
-#
-# INTERACTIVE PROMPT: If no sudo_password is set and the CLI is running,
-# you'll be prompted to enter your password when sudo is needed:
-# - 45-second timeout (auto-skips if no input)
-# - Press Enter to skip (command fails gracefully)
-# - Password is hidden while typing
-# - Password is cached for the session
-#
-# ALTERNATIVES:
-# - SSH backend: Configure passwordless sudo on the remote server
-# - Containers: Run as root inside the container (no sudo needed)
-# - Local: Configure /etc/sudoers for specific commands
-#
-# Example (add to your terminal section):
-#   sudo_password: "your-password-here"
-
-# =============================================================================
-# Browser Tool Configuration
-# =============================================================================
-browser:
-  # Inactivity timeout in seconds - browser sessions are automatically closed
-  # after this period of no activity between agent loops (default: 120 = 2 minutes)
-  inactivity_timeout: 120
-
-# =============================================================================
-# Context Compression (Auto-shrinks long conversations)
-# =============================================================================
-# When conversation approaches model's context limit, middle turns are
-# automatically summarized to free up space while preserving important context.
-#
-# HOW IT WORKS:
-# 1. Tracks actual token usage from API responses (not estimates)
-# 2. When prompt_tokens >= threshold% of model's context_length, triggers compression
-# 3. Protects first 3 turns (system prompt, initial request, first response)
-# 4. Protects last 4 turns (recent context is most relevant)
-# 5. Summarizes middle turns using a fast/cheap model
-# 6. Inserts summary as a user message, continues conversation seamlessly
-#
-compression:
-  # Enable automatic context compression (default: true)
-  # Set to false if you prefer to manage context manually or want errors on overflow
-  enabled: true
-  
-  # Trigger compression at this % of model's context limit (default: 0.85 = 85%)
-  # Lower values = more aggressive compression, higher values = compress later
-  threshold: 0.85
-  
-  # Model to use for generating summaries (fast/cheap recommended)
-  # This model compresses the middle turns into a concise summary
-  summary_model: "google/gemini-2.0-flash-001"
+#   modal_image: "python:3.11"
 
 # =============================================================================
 # Agent Behavior
 # =============================================================================
 agent:
-  # Maximum tool-calling iterations per conversation
-  # Higher = more room for complex tasks, but costs more tokens
-  # Recommended: 20-30 for focused tasks, 50-100 for open exploration
-  max_turns: 60
+  # Maximum conversation turns before stopping
+  max_turns: 20
   
   # Enable verbose logging
   verbose: false
@@ -244,21 +180,6 @@ toolsets:
 # toolsets:
 #   - safe
 
-# =============================================================================
-# Session Logging
-# =============================================================================
-# Session trajectories are automatically saved to logs/ directory.
-# Each session creates: logs/session_YYYYMMDD_HHMMSS_UUID.json
-#
-# The session ID is displayed in the welcome banner for easy reference.
-# Logs contain full conversation history in trajectory format:
-# - System prompt, user messages, assistant responses
-# - Tool calls with inputs/outputs
-# - Timestamps for debugging
-#
-# No configuration needed - logging is always enabled.
-# To disable, you would need to modify the source code.
-
 # =============================================================================
 # Display
 # =============================================================================

cli.py

@@ -16,7 +16,6 @@ import os
 import sys
 import json
 import atexit
-import uuid
 from pathlib import Path
 from datetime import datetime
 from typing import List, Dict, Any, Optional
@@ -33,15 +32,6 @@ from prompt_toolkit.history import FileHistory
 from prompt_toolkit.styles import Style as PTStyle
 from prompt_toolkit.formatted_text import HTML
 from prompt_toolkit.patch_stdout import patch_stdout
-from prompt_toolkit.application import Application, get_app
-from prompt_toolkit.buffer import Buffer
-from prompt_toolkit.layout import Layout, HSplit, Window, FormattedTextControl
-from prompt_toolkit.layout.processors import BeforeInput
-from prompt_toolkit.widgets import TextArea
-from prompt_toolkit.key_binding import KeyBindings
-import asyncio
-import threading
-import queue
 
 # Load environment variables first
 from dotenv import load_dotenv
@@ -55,30 +45,12 @@ if env_path.exists():
 
 def load_cli_config() -> Dict[str, Any]:
     """
-    Load CLI configuration from config files.
-    
-    Config lookup order:
-    1. ~/.hermes/config.yaml (user config - preferred)
-    2. ./cli-config.yaml (project config - fallback)
+    Load CLI configuration from cli-config.yaml.
     
     Environment variables take precedence over config file values.
-    Returns default values if no config file exists.
+    Returns default values if config file doesn't exist.
     """
-    # Check user config first (~/.hermes/config.yaml)
-    user_config_path = Path.home() / '.hermes' / 'config.yaml'
-    project_config_path = Path(__file__).parent / 'cli-config.yaml'
-    
-    # Use user config if it exists, otherwise project config
-    if user_config_path.exists():
-        config_path = user_config_path
-    else:
-        config_path = project_config_path
-    
-    # Also load .env from ~/.hermes/.env if it exists
-    user_env_path = Path.home() / '.hermes' / '.env'
-    if user_env_path.exists():
-        from dotenv import load_dotenv
-        load_dotenv(dotenv_path=user_env_path, override=True)
+    config_path = Path(__file__).parent / 'cli-config.yaml'
     
     # Default configuration
     defaults = {
@@ -95,16 +67,8 @@ def load_cli_config() -> Dict[str, Any]:
             "singularity_image": "docker://python:3.11",
             "modal_image": "python:3.11",
         },
-        "browser": {
-            "inactivity_timeout": 120,  # Auto-cleanup inactive browser sessions after 2 min
-        },
-        "compression": {
-            "enabled": True,      # Auto-compress when approaching context limit
-            "threshold": 0.85,    # Compress at 85% of model's context limit
-            "summary_model": "google/gemini-2.0-flash-001",  # Fast/cheap model for summaries
-        },
         "agent": {
-            "max_turns": 60,  # Default max tool-calling iterations
+            "max_turns": 20,
             "verbose": False,
             "system_prompt": "",
             "personalities": {
@@ -135,29 +99,13 @@ def load_cli_config() -> Dict[str, Any]:
         try:
             with open(config_path, "r") as f:
                 file_config = yaml.safe_load(f) or {}
-            
-            # Handle model config - can be string (new format) or dict (old format)
-            if "model" in file_config:
-                if isinstance(file_config["model"], str):
-                    # New format: model is just a string, convert to dict structure
-                    defaults["model"]["default"] = file_config["model"]
-                elif isinstance(file_config["model"], dict):
-                    # Old format: model is a dict with default/base_url
-                    defaults["model"].update(file_config["model"])
-            
-            # Deep merge other keys with defaults
+            # Deep merge with defaults
             for key in defaults:
-                if key == "model":
-                    continue  # Already handled above
                 if key in file_config:
                     if isinstance(defaults[key], dict) and isinstance(file_config[key], dict):
                         defaults[key].update(file_config[key])
                     else:
                         defaults[key] = file_config[key]
-            
-            # Handle root-level max_turns (backwards compat) - copy to agent.max_turns
-            if "max_turns" in file_config and "agent" not in file_config:
-                defaults["agent"]["max_turns"] = file_config["max_turns"]
         except Exception as e:
             print(f"[Warning] Failed to load cli-config.yaml: {e}")
     
@@ -183,8 +131,6 @@ def load_cli_config() -> Dict[str, Any]:
         "ssh_user": "TERMINAL_SSH_USER",
         "ssh_port": "TERMINAL_SSH_PORT",
         "ssh_key": "TERMINAL_SSH_KEY",
-        # Sudo support (works with all backends)
-        "sudo_password": "SUDO_PASSWORD",
     }
     
     # CLI config overrides .env for terminal settings
@@ -192,28 +138,6 @@ def load_cli_config() -> Dict[str, Any]:
         if config_key in terminal_config:
             os.environ[env_var] = str(terminal_config[config_key])
     
-    # Apply browser config to environment variables
-    browser_config = defaults.get("browser", {})
-    browser_env_mappings = {
-        "inactivity_timeout": "BROWSER_INACTIVITY_TIMEOUT",
-    }
-    
-    for config_key, env_var in browser_env_mappings.items():
-        if config_key in browser_config:
-            os.environ[env_var] = str(browser_config[config_key])
-    
-    # Apply compression config to environment variables
-    compression_config = defaults.get("compression", {})
-    compression_env_mappings = {
-        "enabled": "CONTEXT_COMPRESSION_ENABLED",
-        "threshold": "CONTEXT_COMPRESSION_THRESHOLD",
-        "summary_model": "CONTEXT_COMPRESSION_MODEL",
-    }
-    
-    for config_key, env_var in compression_env_mappings.items():
-        if config_key in compression_config:
-            os.environ[env_var] = str(compression_config[config_key])
-    
     return defaults
 
 # Load configuration at module startup
@@ -235,9 +159,6 @@ from run_agent import AIAgent
 from model_tools import get_tool_definitions, get_all_tool_names, get_toolset_for_tool, get_available_toolsets
 from toolsets import get_all_toolsets, get_toolset_info, resolve_toolset, validate_toolset
 
-# Cron job system for scheduled tasks
-from cron import create_job, list_jobs, remove_job, get_job, run_daemon as run_cron_daemon, tick as cron_tick
-
 # ============================================================================
 # ASCII Art & Branding
 # ============================================================================
@@ -319,7 +240,7 @@ def _get_available_skills() -> Dict[str, List[str]]:
     return skills_by_category
 
 
-def build_welcome_banner(console: Console, model: str, cwd: str, tools: List[dict] = None, enabled_toolsets: List[str] = None, session_id: str = None):
+def build_welcome_banner(console: Console, model: str, cwd: str, tools: List[dict] = None, enabled_toolsets: List[str] = None):
     """
     Build and print a Claude Code-style welcome banner with caduceus on left and info on right.
     
@@ -329,19 +250,10 @@ def build_welcome_banner(console: Console, model: str, cwd: str, tools: List[dic
         cwd: Current working directory
         tools: List of tool definitions
         enabled_toolsets: List of enabled toolset names
-        session_id: Unique session identifier for logging
     """
-    from model_tools import check_tool_availability, TOOLSET_REQUIREMENTS
-    
     tools = tools or []
     enabled_toolsets = enabled_toolsets or []
     
-    # Get unavailable tools info for coloring
-    _, unavailable_toolsets = check_tool_availability(quiet=True)
-    disabled_tools = set()
-    for item in unavailable_toolsets:
-        disabled_tools.update(item.get("tools", []))
-    
     # Build the side-by-side content using a table for precise control
     layout_table = Table.grid(padding=(0, 2))
     layout_table.add_column("left", justify="center")
@@ -357,20 +269,14 @@ def build_welcome_banner(console: Console, model: str, cwd: str, tools: List[dic
     
     left_lines.append(f"[#FFBF00]{model_short}[/] [dim #B8860B]·[/] [dim #B8860B]Nous Research[/]")
     left_lines.append(f"[dim #B8860B]{cwd}[/]")
-    
-    # Add session ID if provided
-    if session_id:
-        left_lines.append(f"[dim #8B8682]Session: {session_id}[/]")
     left_content = "\n".join(left_lines)
     
     # Build right content: tools list grouped by toolset
     right_lines = []
     right_lines.append("[bold #FFBF00]Available Tools[/]")
     
-    # Group tools by toolset (include all possible tools, both enabled and disabled)
+    # Group tools by toolset
     toolsets_dict = {}
-    
-    # First, add all enabled tools
     for tool in tools:
         tool_name = tool["function"]["name"]
         toolset = get_toolset_for_tool(tool_name) or "other"
@@ -378,17 +284,6 @@ def build_welcome_banner(console: Console, model: str, cwd: str, tools: List[dic
             toolsets_dict[toolset] = []
         toolsets_dict[toolset].append(tool_name)
     
-    # Also add disabled toolsets so they show in the banner
-    for item in unavailable_toolsets:
-        # Map the internal toolset ID to display name
-        toolset_id = item["id"]
-        display_name = f"{toolset_id}_tools" if not toolset_id.endswith("_tools") else toolset_id
-        if display_name not in toolsets_dict:
-            toolsets_dict[display_name] = []
-        for tool_name in item.get("tools", []):
-            if tool_name not in toolsets_dict[display_name]:
-                toolsets_dict[display_name].append(tool_name)
-    
     # Display tools grouped by toolset (compact format, max 8 groups)
     sorted_toolsets = sorted(toolsets_dict.keys())
     display_toolsets = sorted_toolsets[:8]
@@ -396,38 +291,11 @@ def build_welcome_banner(console: Console, model: str, cwd: str, tools: List[dic
     
     for toolset in display_toolsets:
         tool_names = toolsets_dict[toolset]
-        # Color each tool name - red if disabled, normal if enabled
-        colored_names = []
-        for name in sorted(tool_names):
-            if name in disabled_tools:
-                colored_names.append(f"[red]{name}[/]")
-            else:
-                colored_names.append(f"[#FFF8DC]{name}[/]")
-        
-        tools_str = ", ".join(colored_names)
-        # Truncate if too long (accounting for markup)
-        if len(", ".join(sorted(tool_names))) > 45:
-            # Rebuild with truncation
-            short_names = []
-            length = 0
-            for name in sorted(tool_names):
-                if length + len(name) + 2 > 42:
-                    short_names.append("...")
-                    break
-                short_names.append(name)
-                length += len(name) + 2
-            # Re-color the truncated list
-            colored_names = []
-            for name in short_names:
-                if name == "...":
-                    colored_names.append("[dim]...[/]")
-                elif name in disabled_tools:
-                    colored_names.append(f"[red]{name}[/]")
-                else:
-                    colored_names.append(f"[#FFF8DC]{name}[/]")
-            tools_str = ", ".join(colored_names)
-        
-        right_lines.append(f"[dim #B8860B]{toolset}:[/] {tools_str}")
+        # Join tool names with commas, wrap if too long
+        tools_str = ", ".join(sorted(tool_names))
+        if len(tools_str) > 45:
+            tools_str = tools_str[:42] + "..."
+        right_lines.append(f"[dim #B8860B]{toolset}:[/] [#FFF8DC]{tools_str}[/]")
     
     if remaining_toolsets > 0:
         right_lines.append(f"[dim #B8860B](and {remaining_toolsets} more toolsets...)[/]")
@@ -496,8 +364,6 @@ COMMANDS = {
     "/reset": "Reset conversation only (keep screen)",
     "/save": "Save the current conversation",
     "/config": "Show current configuration",
-    "/cron": "Manage scheduled tasks (list, add, remove)",
-    "/platforms": "Show gateway/messaging platform status",
     "/quit": "Exit the CLI (also: /exit, /q)",
 }
 
@@ -560,7 +426,7 @@ class HermesCLI:
         toolsets: List[str] = None,
         api_key: str = None,
         base_url: str = None,
-        max_turns: int = 60,
+        max_turns: int = 20,
         verbose: bool = False,
         compact: bool = False,
     ):
@@ -572,7 +438,7 @@ class HermesCLI:
             toolsets: List of toolsets to enable (default: all)
             api_key: API key (default: from environment)
             base_url: API base URL (default: OpenRouter)
-            max_turns: Maximum tool-calling iterations (default: 60)
+            max_turns: Maximum conversation turns
             verbose: Enable verbose logging
             compact: Use compact display mode
         """
@@ -582,25 +448,10 @@ class HermesCLI:
         self.verbose = verbose if verbose is not None else CLI_CONFIG["agent"].get("verbose", False)
         
         # Configuration - priority: CLI args > env vars > config file
-        # Model can come from: CLI arg, LLM_MODEL env, OPENAI_MODEL env (custom endpoint), or config
-        self.model = model or os.getenv("LLM_MODEL") or os.getenv("OPENAI_MODEL") or CLI_CONFIG["model"]["default"]
-        
-        # Base URL: custom endpoint (OPENAI_BASE_URL) takes precedence over OpenRouter
-        self.base_url = base_url or os.getenv("OPENAI_BASE_URL") or os.getenv("OPENROUTER_BASE_URL", CLI_CONFIG["model"]["base_url"])
-        
-        # API key: custom endpoint (OPENAI_API_KEY) takes precedence over OpenRouter
-        self.api_key = api_key or os.getenv("OPENAI_API_KEY") or os.getenv("OPENROUTER_API_KEY")
-        # Max turns priority: CLI arg > env var > config file (agent.max_turns or root max_turns) > default
-        if max_turns != 60:  # CLI arg was explicitly set
-            self.max_turns = max_turns
-        elif os.getenv("HERMES_MAX_ITERATIONS"):
-            self.max_turns = int(os.getenv("HERMES_MAX_ITERATIONS"))
-        elif CLI_CONFIG["agent"].get("max_turns"):
-            self.max_turns = CLI_CONFIG["agent"]["max_turns"]
-        elif CLI_CONFIG.get("max_turns"):  # Backwards compat: root-level max_turns
-            self.max_turns = CLI_CONFIG["max_turns"]
-        else:
-            self.max_turns = 60
+        self.model = model or os.getenv("LLM_MODEL", CLI_CONFIG["model"]["default"])
+        self.base_url = base_url or os.getenv("OPENROUTER_BASE_URL", CLI_CONFIG["model"]["base_url"])
+        self.api_key = api_key or os.getenv("OPENROUTER_API_KEY")
+        self.max_turns = max_turns if max_turns != 20 else CLI_CONFIG["agent"].get("max_turns", 20)
         
         # Parse and validate toolsets
         self.enabled_toolsets = toolsets
@@ -621,12 +472,6 @@ class HermesCLI:
         self.conversation_history: List[Dict[str, Any]] = []
         self.session_start = datetime.now()
         
-        # Generate session ID with timestamp for display and logging
-        # Format: YYYYMMDD_HHMMSS_shortUUID (e.g., 20260201_143052_a1b2c3)
-        timestamp_str = self.session_start.strftime("%Y%m%d_%H%M%S")
-        short_uuid = uuid.uuid4().hex[:6]
-        self.session_id = f"{timestamp_str}_{short_uuid}"
-        
         # Setup prompt_toolkit session with history
         self._setup_prompt_session()
     
@@ -668,7 +513,6 @@ class HermesCLI:
                 verbose_logging=self.verbose,
                 quiet_mode=True,  # Suppress verbose output for clean CLI
                 ephemeral_system_prompt=self.system_prompt if self.system_prompt else None,
-                session_id=self.session_id,  # Pass CLI's session ID to agent
             )
             return True
         except Exception as e:
@@ -684,7 +528,7 @@ class HermesCLI:
             self._show_status()
         else:
             # Get tools for display
-            tools = get_tool_definitions(enabled_toolsets=self.enabled_toolsets, quiet_mode=True)
+            tools = get_tool_definitions(enabled_toolsets=self.enabled_toolsets)
             
             # Get terminal working directory (where commands will execute)
             cwd = os.getenv("TERMINAL_CWD", os.getcwd())
@@ -696,40 +540,14 @@ class HermesCLI:
                 cwd=cwd,
                 tools=tools,
                 enabled_toolsets=self.enabled_toolsets,
-                session_id=self.session_id,
             )
         
-        # Show tool availability warnings if any tools are disabled
-        self._show_tool_availability_warnings()
-        
         self.console.print()
     
-    def _show_tool_availability_warnings(self):
-        """Show warnings about disabled tools due to missing API keys."""
-        try:
-            from model_tools import check_tool_availability, TOOLSET_REQUIREMENTS
-            
-            available, unavailable = check_tool_availability()
-            
-            # Filter to only those missing API keys (not system deps)
-            api_key_missing = [u for u in unavailable if u["missing_vars"]]
-            
-            if api_key_missing:
-                self.console.print()
-                self.console.print("[yellow]⚠️  Some tools disabled (missing API keys):[/]")
-                for item in api_key_missing:
-                    tools_str = ", ".join(item["tools"][:2])  # Show first 2 tools
-                    if len(item["tools"]) > 2:
-                        tools_str += f", +{len(item['tools'])-2} more"
-                    self.console.print(f"   [dim]• {item['name']}[/] [dim italic]({', '.join(item['missing_vars'])})[/]")
-                self.console.print("[dim]   Run 'hermes setup' to configure[/]")
-        except Exception:
-            pass  # Don't crash on import errors
-    
     def _show_status(self):
         """Show current status bar."""
         # Get tool count
-        tools = get_tool_definitions(enabled_toolsets=self.enabled_toolsets, quiet_mode=True)
+        tools = get_tool_definitions(enabled_toolsets=self.enabled_toolsets)
         tool_count = len(tools) if tools else 0
         
         # Format model name (shorten if needed)
@@ -772,7 +590,7 @@ class HermesCLI:
     
     def show_tools(self):
         """Display available tools with kawaii ASCII art."""
-        tools = get_tool_definitions(enabled_toolsets=self.enabled_toolsets, quiet_mode=True)
+        tools = get_tool_definitions(enabled_toolsets=self.enabled_toolsets)
         
         if not tools:
             print("(;_;) No tools available")
@@ -1014,199 +832,6 @@ class HermesCLI:
             print("  Usage: /personality <name>")
             print()
     
-    def _handle_cron_command(self, cmd: str):
-        """Handle the /cron command to manage scheduled tasks."""
-        parts = cmd.split(maxsplit=2)
-        
-        if len(parts) == 1:
-            # /cron - show help and list
-            print()
-            print("+" + "-" * 60 + "+")
-            print("|" + " " * 18 + "(^_^) Scheduled Tasks" + " " * 19 + "|")
-            print("+" + "-" * 60 + "+")
-            print()
-            print("  Commands:")
-            print("    /cron                     - List scheduled jobs")
-            print("    /cron list                - List scheduled jobs")
-            print('    /cron add <schedule> <prompt>  - Add a new job')
-            print("    /cron remove <job_id>     - Remove a job")
-            print()
-            print("  Schedule formats:")
-            print("    30m, 2h, 1d              - One-shot delay")
-            print('    "every 30m", "every 2h"  - Recurring interval')
-            print('    "0 9 * * *"              - Cron expression')
-            print()
-            
-            # Show current jobs
-            jobs = list_jobs()
-            if jobs:
-                print("  Current Jobs:")
-                print("  " + "-" * 55)
-                for job in jobs:
-                    # Format repeat status
-                    times = job["repeat"].get("times")
-                    completed = job["repeat"].get("completed", 0)
-                    if times is None:
-                        repeat_str = "forever"
-                    else:
-                        repeat_str = f"{completed}/{times}"
-                    
-                    print(f"    {job['id'][:12]:<12} | {job['schedule_display']:<15} | {repeat_str:<8}")
-                    prompt_preview = job['prompt'][:45] + "..." if len(job['prompt']) > 45 else job['prompt']
-                    print(f"      {prompt_preview}")
-                    if job.get("next_run_at"):
-                        from datetime import datetime
-                        next_run = datetime.fromisoformat(job["next_run_at"])
-                        print(f"      Next: {next_run.strftime('%Y-%m-%d %H:%M')}")
-                    print()
-            else:
-                print("  No scheduled jobs. Use '/cron add' to create one.")
-            print()
-            return
-        
-        subcommand = parts[1].lower()
-        
-        if subcommand == "list":
-            # /cron list - just show jobs
-            jobs = list_jobs()
-            if not jobs:
-                print("(._.) No scheduled jobs.")
-                return
-            
-            print()
-            print("Scheduled Jobs:")
-            print("-" * 70)
-            for job in jobs:
-                times = job["repeat"].get("times")
-                completed = job["repeat"].get("completed", 0)
-                repeat_str = "forever" if times is None else f"{completed}/{times}"
-                
-                print(f"  ID: {job['id']}")
-                print(f"  Name: {job['name']}")
-                print(f"  Schedule: {job['schedule_display']} ({repeat_str})")
-                print(f"  Next run: {job.get('next_run_at', 'N/A')}")
-                print(f"  Prompt: {job['prompt'][:80]}{'...' if len(job['prompt']) > 80 else ''}")
-                if job.get("last_run_at"):
-                    print(f"  Last run: {job['last_run_at']} ({job.get('last_status', '?')})")
-                print()
-        
-        elif subcommand == "add":
-            # /cron add <schedule> <prompt>
-            if len(parts) < 3:
-                print("(._.) Usage: /cron add <schedule> <prompt>")
-                print("  Example: /cron add 30m Remind me to take a break")
-                print('  Example: /cron add "every 2h" Check server status at 192.168.1.1')
-                return
-            
-            # Parse schedule and prompt
-            rest = parts[2].strip()
-            
-            # Handle quoted schedule (e.g., "every 30m" or "0 9 * * *")
-            if rest.startswith('"'):
-                # Find closing quote
-                close_quote = rest.find('"', 1)
-                if close_quote == -1:
-                    print("(._.) Unmatched quote in schedule")
-                    return
-                schedule = rest[1:close_quote]
-                prompt = rest[close_quote + 1:].strip()
-            else:
-                # First word is schedule
-                schedule_parts = rest.split(maxsplit=1)
-                schedule = schedule_parts[0]
-                prompt = schedule_parts[1] if len(schedule_parts) > 1 else ""
-            
-            if not prompt:
-                print("(._.) Please provide a prompt for the job")
-                return
-            
-            try:
-                job = create_job(prompt=prompt, schedule=schedule)
-                print(f"(^_^)b Created job: {job['id']}")
-                print(f"  Schedule: {job['schedule_display']}")
-                print(f"  Next run: {job['next_run_at']}")
-            except Exception as e:
-                print(f"(x_x) Failed to create job: {e}")
-        
-        elif subcommand == "remove" or subcommand == "rm" or subcommand == "delete":
-            # /cron remove <job_id>
-            if len(parts) < 3:
-                print("(._.) Usage: /cron remove <job_id>")
-                return
-            
-            job_id = parts[2].strip()
-            job = get_job(job_id)
-            
-            if not job:
-                print(f"(._.) Job not found: {job_id}")
-                return
-            
-            if remove_job(job_id):
-                print(f"(^_^)b Removed job: {job['name']} ({job_id})")
-            else:
-                print(f"(x_x) Failed to remove job: {job_id}")
-        
-        else:
-            print(f"(._.) Unknown cron command: {subcommand}")
-            print("  Available: list, add, remove")
-    
-    def _show_gateway_status(self):
-        """Show status of the gateway and connected messaging platforms."""
-        from gateway.config import load_gateway_config, Platform
-        
-        print()
-        print("+" + "-" * 60 + "+")
-        print("|" + " " * 15 + "(✿◠‿◠) Gateway Status" + " " * 17 + "|")
-        print("+" + "-" * 60 + "+")
-        print()
-        
-        try:
-            config = load_gateway_config()
-            connected = config.get_connected_platforms()
-            
-            print("  Messaging Platform Configuration:")
-            print("  " + "-" * 55)
-            
-            platform_status = {
-                Platform.TELEGRAM: ("Telegram", "TELEGRAM_BOT_TOKEN"),
-                Platform.DISCORD: ("Discord", "DISCORD_BOT_TOKEN"),
-                Platform.WHATSAPP: ("WhatsApp", "WHATSAPP_ENABLED"),
-            }
-            
-            for platform, (name, env_var) in platform_status.items():
-                pconfig = config.platforms.get(platform)
-                if pconfig and pconfig.enabled:
-                    home = config.get_home_channel(platform)
-                    home_str = f" → {home.name}" if home else ""
-                    print(f"    ✓ {name:<12} Enabled{home_str}")
-                else:
-                    print(f"    ○ {name:<12} Not configured ({env_var})")
-            
-            print()
-            print("  Session Reset Policy:")
-            print("  " + "-" * 55)
-            policy = config.default_reset_policy
-            print(f"    Mode: {policy.mode}")
-            print(f"    Daily reset at: {policy.at_hour}:00")
-            print(f"    Idle timeout: {policy.idle_minutes} minutes")
-            
-            print()
-            print("  To start the gateway:")
-            print("    python cli.py --gateway")
-            print()
-            print("  Configuration file: ~/.hermes/gateway.json")
-            print()
-            
-        except Exception as e:
-            print(f"  Error loading gateway config: {e}")
-            print()
-            print("  To configure the gateway:")
-            print("    1. Set environment variables:")
-            print("       TELEGRAM_BOT_TOKEN=your_token")
-            print("       DISCORD_BOT_TOKEN=your_token")
-            print("    2. Or create ~/.hermes/gateway.json")
-            print()
-    
     def process_command(self, command: str) -> bool:
         """
         Process a slash command.
@@ -1262,10 +887,6 @@ class HermesCLI:
             self._handle_personality_command(cmd)
         elif cmd == "/save":
             self.save_conversation()
-        elif cmd.startswith("/cron"):
-            self._handle_cron_command(command)  # Use original command for proper parsing
-        elif cmd == "/platforms" or cmd == "/gateway":
-            self._show_gateway_status()
         else:
             self.console.print(f"[bold red]Unknown command: {cmd}[/]")
             self.console.print("[dim #B8860B]Type /help for available commands[/]")
@@ -1293,52 +914,17 @@ class HermesCLI:
         print("─" * 60, flush=True)
         
         try:
-            # Run the conversation with interrupt monitoring
-            result = None
-            
-            def run_agent():
-                nonlocal result
-                result = self.agent.run_conversation(
-                    user_message=message,
-                    conversation_history=self.conversation_history[:-1],  # Exclude the message we just added
-                )
-            
-            # Start agent in background thread
-            agent_thread = threading.Thread(target=run_agent)
-            agent_thread.start()
-            
-            # Monitor for new input in the pending queue while agent runs
-            interrupt_msg = None
-            while agent_thread.is_alive():
-                # Check if there's new input in the queue (from the persistent input area)
-                if hasattr(self, '_pending_input'):
-                    try:
-                        interrupt_msg = self._pending_input.get(timeout=0.1)
-                        if interrupt_msg:
-                            print(f"\n⚡ New message detected, interrupting...")
-                            self.agent.interrupt(interrupt_msg)
-                            break
-                    except:
-                        pass  # Queue empty or timeout, continue waiting
-                else:
-                    # Fallback if no queue (shouldn't happen)
-                    agent_thread.join(0.1)
-            
-            agent_thread.join()  # Ensure agent thread completes
+            # Run the conversation
+            result = self.agent.run_conversation(
+                user_message=message,
+                conversation_history=self.conversation_history[:-1],  # Exclude the message we just added
+            )
             
             # Update history with full conversation
-            self.conversation_history = result.get("messages", self.conversation_history) if result else self.conversation_history
+            self.conversation_history = result.get("messages", self.conversation_history)
             
             # Get the final response
-            response = result.get("final_response", "") if result else ""
-            
-            # Handle interrupt - check if we were interrupted
-            pending_message = None
-            if result and result.get("interrupted"):
-                pending_message = result.get("interrupt_message") or interrupt_msg
-                # Add indicator that we were interrupted
-                if response and pending_message:
-                    response = response + "\n\n---\n_[Interrupted - processing new message]_"
+            response = result.get("final_response", "")
             
             if response:
                 # Use simple print for compatibility with prompt_toolkit's patch_stdout
@@ -1351,11 +937,6 @@ class HermesCLI:
                 print()
                 print("─" * 60)
             
-            # If we have a pending message from interrupt, process it immediately
-            if pending_message:
-                print(f"\n📨 Processing: '{pending_message[:50]}{'...' if len(pending_message) > 50 else ''}'")
-                return self.chat(pending_message)  # Recursive call to handle the new message
-            
             return response
             
         except Exception as e:
@@ -1394,101 +975,22 @@ class HermesCLI:
             return None
     
     def run(self):
-        """Run the interactive CLI loop with persistent input at bottom."""
+        """Run the interactive CLI loop with fixed input at bottom."""
         self.show_banner()
+        
+        # These Rich prints work fine BEFORE patch_stdout
         self.console.print("[#FFF8DC]Welcome to Hermes Agent! Type your message or /help for commands.[/]")
         self.console.print()
         
-        # State for async operation
-        self._agent_running = False
-        self._pending_input = queue.Queue()
-        self._should_exit = False
-        
-        # Create a persistent input area using prompt_toolkit Application
-        input_buffer = Buffer()
-        
-        # Key bindings for the input area
-        kb = KeyBindings()
-        
-        @kb.add('enter')
-        def handle_enter(event):
-            """Handle Enter key - submit input."""
-            text = event.app.current_buffer.text.strip()
-            if text:
-                # Store the input
-                self._pending_input.put(text)
-                # Clear the buffer
-                event.app.current_buffer.reset()
-        
-        @kb.add('c-c')
-        def handle_ctrl_c(event):
-            """Handle Ctrl+C - interrupt or exit."""
-            if self._agent_running and self.agent:
-                print("\n⚡ Interrupting agent...")
-                self.agent.interrupt()
-            else:
-                self._should_exit = True
-                event.app.exit()
-        
-        @kb.add('c-d')
-        def handle_ctrl_d(event):
-            """Handle Ctrl+D - exit."""
-            self._should_exit = True
-            event.app.exit()
-        
-        # Create the input area widget
-        input_area = TextArea(
-            height=1,
-            prompt='❯ ',
-            style='class:input-area',
-            multiline=False,
-            wrap_lines=False,
-        )
-        
-        # Create a status line that shows when agent is working
-        def get_status_text():
-            if self._agent_running:
-                return [('class:status', ' 🔄 Agent working... (type to interrupt) ')]
-            return [('class:status', '')]
-        
-        status_window = Window(
-            content=FormattedTextControl(get_status_text),
-            height=1,
-        )
-        
-        # Layout with status and input at bottom
-        layout = Layout(
-            HSplit([
-                Window(height=0),  # Spacer that expands
-                status_window,
-                input_area,
-            ])
-        )
-        
-        # Style for the application
-        style = PTStyle.from_dict({
-            'input-area': '#FFF8DC',
-            'status': 'bg:#333333 #FFD700',
-        })
-        
-        # Create the application
-        app = Application(
-            layout=layout,
-            key_bindings=kb,
-            style=style,
-            full_screen=False,
-            mouse_support=False,
-        )
-        
-        # Background thread to process inputs and run agent
-        def process_loop():
-            while not self._should_exit:
+        # Use patch_stdout to ensure all output appears above the input prompt
+        with patch_stdout():
+            while True:
                 try:
-                    # Check for pending input with timeout
-                    try:
-                        user_input = self._pending_input.get(timeout=0.1)
-                    except queue.Empty:
-                        continue
+                    user_input = self.get_input()
+                    
+                    if user_input is None:
+                        print("\nGoodbye! ⚕")
+                        break
                     
                     if not user_input:
                         continue
@@ -1496,38 +998,16 @@ class HermesCLI:
                     # Check for commands
                     if user_input.startswith("/"):
                         if not self.process_command(user_input):
-                            self._should_exit = True
-                            # Schedule app exit
-                            if app.is_running:
-                                app.exit()
+                            print("\nGoodbye! ⚕")
+                            break
                         continue
                     
-                    # Regular chat - run agent
-                    self._agent_running = True
-                    app.invalidate()  # Refresh status line
+                    # Regular chat message
+                    self.chat(user_input)
                     
-                    try:
-                        self.chat(user_input)
-                    finally:
-                        self._agent_running = False
-                        app.invalidate()  # Refresh status line
-                    
-                except Exception as e:
-                    print(f"Error: {e}")
-        
-        # Start processing thread
-        process_thread = threading.Thread(target=process_loop, daemon=True)
-        process_thread.start()
-        
-        # Run the application with patch_stdout for proper output handling
-        try:
-            with patch_stdout():
-                app.run()
-        except (EOFError, KeyboardInterrupt):
-            pass
-        finally:
-            self._should_exit = True
-            print("\nGoodbye! ⚕")
+                except KeyboardInterrupt:
+                    print("\nInterrupted. Type /quit to exit.")
+                    continue
 
 
 # ============================================================================
@@ -1541,14 +1021,11 @@ def main(
     model: str = None,
     api_key: str = None,
     base_url: str = None,
-    max_turns: int = 60,
+    max_turns: int = 20,
     verbose: bool = False,
     compact: bool = False,
     list_tools: bool = False,
     list_toolsets: bool = False,
-    cron_daemon: bool = False,
-    cron_tick_once: bool = False,
-    gateway: bool = False,
 ):
     """
     Hermes Agent CLI - Interactive AI Assistant
@@ -1560,54 +1037,22 @@ def main(
         model: Model to use (default: anthropic/claude-opus-4-20250514)
         api_key: API key for authentication
         base_url: Base URL for the API
-        max_turns: Maximum tool-calling iterations (default: 60)
+        max_turns: Maximum conversation turns (default: 20)
         verbose: Enable verbose logging
         compact: Use compact display mode
         list_tools: List available tools and exit
         list_toolsets: List available toolsets and exit
-        cron_daemon: Run as cron daemon (check and execute due jobs continuously)
-        cron_tick_once: Run due cron jobs once and exit (for system cron integration)
     
     Examples:
         python cli.py                            # Start interactive mode
         python cli.py --toolsets web,terminal    # Use specific toolsets
         python cli.py -q "What is Python?"       # Single query mode
         python cli.py --list-tools               # List tools and exit
-        python cli.py --cron-daemon              # Run cron scheduler daemon
-        python cli.py --cron-tick-once           # Check and run due jobs once
     """
-    # Signal to terminal_tool that we're in interactive mode
-    # This enables interactive sudo password prompts with timeout
-    os.environ["HERMES_INTERACTIVE"] = "1"
-    
-    # Handle cron daemon mode (runs before CLI initialization)
-    if cron_daemon:
-        print("Starting Hermes Cron Daemon...")
-        print("Jobs will be checked every 60 seconds.")
-        print("Press Ctrl+C to stop.\n")
-        run_cron_daemon(check_interval=60, verbose=True)
-        return
-    
-    # Handle cron tick (single run for system cron integration)
-    if cron_tick_once:
-        jobs_run = cron_tick(verbose=True)
-        if jobs_run:
-            print(f"Executed {jobs_run} job(s)")
-        return
-    
-    # Handle gateway mode (messaging platforms)
-    if gateway:
-        import asyncio
-        from gateway.run import start_gateway
-        print("Starting Hermes Gateway (messaging platforms)...")
-        asyncio.run(start_gateway())
-        return
-    
     # Handle query shorthand
     query = query or q
     
     # Parse toolsets - handle both string and tuple/list inputs
-    # Default to hermes-cli toolset which includes cronjob management tools
     toolsets_list = None
     if toolsets:
         if isinstance(toolsets, str):
@@ -1620,9 +1065,6 @@ def main(
                     toolsets_list.extend([x.strip() for x in t.split(",")])
                 else:
                     toolsets_list.append(str(t))
-    else:
-        # Default: use hermes-cli toolset for full CLI functionality including cronjob tools
-        toolsets_list = ["hermes-cli"]
     
     # Create CLI instance
     cli = HermesCLI(

cron/__init__.py

@@ -1,36 +0,0 @@
-"""
-Cron job scheduling system for Hermes Agent.
-
-This module provides scheduled task execution, allowing the agent to:
-- Run automated tasks on schedules (cron expressions, intervals, one-shot)
-- Self-schedule reminders and follow-up tasks
-- Execute tasks in isolated sessions (no prior context)
-
-Usage:
-    # Run due jobs (for system cron integration)
-    python -c "from cron import tick; tick()"
-    
-    # Or via CLI
-    python cli.py --cron-daemon
-"""
-
-from cron.jobs import (
-    create_job,
-    get_job,
-    list_jobs,
-    remove_job,
-    update_job,
-    JOBS_FILE,
-)
-from cron.scheduler import tick, run_daemon
-
-__all__ = [
-    "create_job",
-    "get_job", 
-    "list_jobs",
-    "remove_job",
-    "update_job",
-    "tick",
-    "run_daemon",
-    "JOBS_FILE",
-]

cron/jobs.py

@@ -1,383 +0,0 @@
-"""
-Cron job storage and management.
-
-Jobs are stored in ~/.hermes/cron/jobs.json
-Output is saved to ~/.hermes/cron/output/{job_id}/{timestamp}.md
-"""
-
-import json
-import os
-import re
-import uuid
-from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Optional, Dict, List, Any
-
-try:
-    from croniter import croniter
-    HAS_CRONITER = True
-except ImportError:
-    HAS_CRONITER = False
-
-# =============================================================================
-# Configuration
-# =============================================================================
-
-HERMES_DIR = Path.home() / ".hermes"
-CRON_DIR = HERMES_DIR / "cron"
-JOBS_FILE = CRON_DIR / "jobs.json"
-OUTPUT_DIR = CRON_DIR / "output"
-
-
-def ensure_dirs():
-    """Ensure cron directories exist."""
-    CRON_DIR.mkdir(parents=True, exist_ok=True)
-    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-
-
-# =============================================================================
-# Schedule Parsing
-# =============================================================================
-
-def parse_duration(s: str) -> int:
-    """
-    Parse duration string into minutes.
-    
-    Examples:
-        "30m" → 30
-        "2h" → 120
-        "1d" → 1440
-    """
-    s = s.strip().lower()
-    match = re.match(r'^(\d+)\s*(m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days)$', s)
-    if not match:
-        raise ValueError(f"Invalid duration: '{s}'. Use format like '30m', '2h', or '1d'")
-    
-    value = int(match.group(1))
-    unit = match.group(2)[0]  # First char: m, h, or d
-    
-    multipliers = {'m': 1, 'h': 60, 'd': 1440}
-    return value * multipliers[unit]
-
-
-def parse_schedule(schedule: str) -> Dict[str, Any]:
-    """
-    Parse schedule string into structured format.
-    
-    Returns dict with:
-        - kind: "once" | "interval" | "cron"
-        - For "once": "run_at" (ISO timestamp)
-        - For "interval": "minutes" (int)
-        - For "cron": "expr" (cron expression)
-    
-    Examples:
-        "30m"              → once in 30 minutes
-        "2h"               → once in 2 hours
-        "every 30m"        → recurring every 30 minutes
-        "every 2h"         → recurring every 2 hours
-        "0 9 * * *"        → cron expression
-        "2026-02-03T14:00" → once at timestamp
-    """
-    schedule = schedule.strip()
-    original = schedule
-    schedule_lower = schedule.lower()
-    
-    # "every X" pattern → recurring interval
-    if schedule_lower.startswith("every "):
-        duration_str = schedule[6:].strip()
-        minutes = parse_duration(duration_str)
-        return {
-            "kind": "interval",
-            "minutes": minutes,
-            "display": f"every {minutes}m"
-        }
-    
-    # Check for cron expression (5 or 6 space-separated fields)
-    # Cron fields: minute hour day month weekday [year]
-    parts = schedule.split()
-    if len(parts) >= 5 and all(
-        re.match(r'^[\d\*\-,/]+$', p) for p in parts[:5]
-    ):
-        if not HAS_CRONITER:
-            raise ValueError("Cron expressions require 'croniter' package. Install with: pip install croniter")
-        # Validate cron expression
-        try:
-            croniter(schedule)
-        except Exception as e:
-            raise ValueError(f"Invalid cron expression '{schedule}': {e}")
-        return {
-            "kind": "cron",
-            "expr": schedule,
-            "display": schedule
-        }
-    
-    # ISO timestamp (contains T or looks like date)
-    if 'T' in schedule or re.match(r'^\d{4}-\d{2}-\d{2}', schedule):
-        try:
-            # Parse and validate
-            dt = datetime.fromisoformat(schedule.replace('Z', '+00:00'))
-            return {
-                "kind": "once",
-                "run_at": dt.isoformat(),
-                "display": f"once at {dt.strftime('%Y-%m-%d %H:%M')}"
-            }
-        except ValueError as e:
-            raise ValueError(f"Invalid timestamp '{schedule}': {e}")
-    
-    # Duration like "30m", "2h", "1d" → one-shot from now
-    try:
-        minutes = parse_duration(schedule)
-        run_at = datetime.now() + timedelta(minutes=minutes)
-        return {
-            "kind": "once",
-            "run_at": run_at.isoformat(),
-            "display": f"once in {original}"
-        }
-    except ValueError:
-        pass
-    
-    raise ValueError(
-        f"Invalid schedule '{original}'. Use:\n"
-        f"  - Duration: '30m', '2h', '1d' (one-shot)\n"
-        f"  - Interval: 'every 30m', 'every 2h' (recurring)\n"
-        f"  - Cron: '0 9 * * *' (cron expression)\n"
-        f"  - Timestamp: '2026-02-03T14:00:00' (one-shot at time)"
-    )
-
-
-def compute_next_run(schedule: Dict[str, Any], last_run_at: Optional[str] = None) -> Optional[str]:
-    """
-    Compute the next run time for a schedule.
-    
-    Returns ISO timestamp string, or None if no more runs.
-    """
-    now = datetime.now()
-    
-    if schedule["kind"] == "once":
-        run_at = datetime.fromisoformat(schedule["run_at"])
-        # If in the future, return it; if in the past, no more runs
-        return schedule["run_at"] if run_at > now else None
-    
-    elif schedule["kind"] == "interval":
-        minutes = schedule["minutes"]
-        if last_run_at:
-            # Next run is last_run + interval
-            last = datetime.fromisoformat(last_run_at)
-            next_run = last + timedelta(minutes=minutes)
-        else:
-            # First run is now + interval
-            next_run = now + timedelta(minutes=minutes)
-        return next_run.isoformat()
-    
-    elif schedule["kind"] == "cron":
-        if not HAS_CRONITER:
-            return None
-        cron = croniter(schedule["expr"], now)
-        next_run = cron.get_next(datetime)
-        return next_run.isoformat()
-    
-    return None
-
-
-# =============================================================================
-# Job CRUD Operations
-# =============================================================================
-
-def load_jobs() -> List[Dict[str, Any]]:
-    """Load all jobs from storage."""
-    ensure_dirs()
-    if not JOBS_FILE.exists():
-        return []
-    
-    try:
-        with open(JOBS_FILE, 'r', encoding='utf-8') as f:
-            data = json.load(f)
-            return data.get("jobs", [])
-    except (json.JSONDecodeError, IOError):
-        return []
-
-
-def save_jobs(jobs: List[Dict[str, Any]]):
-    """Save all jobs to storage."""
-    ensure_dirs()
-    with open(JOBS_FILE, 'w', encoding='utf-8') as f:
-        json.dump({"jobs": jobs, "updated_at": datetime.now().isoformat()}, f, indent=2)
-
-
-def create_job(
-    prompt: str,
-    schedule: str,
-    name: Optional[str] = None,
-    repeat: Optional[int] = None,
-    deliver: Optional[str] = None,
-    origin: Optional[Dict[str, Any]] = None
-) -> Dict[str, Any]:
-    """
-    Create a new cron job.
-    
-    Args:
-        prompt: The prompt to run (must be self-contained)
-        schedule: Schedule string (see parse_schedule)
-        name: Optional friendly name
-        repeat: How many times to run (None = forever, 1 = once)
-        deliver: Where to deliver output ("origin", "local", "telegram", etc.)
-        origin: Source info where job was created (for "origin" delivery)
-    
-    Returns:
-        The created job dict
-    """
-    parsed_schedule = parse_schedule(schedule)
-    
-    # Auto-set repeat=1 for one-shot schedules if not specified
-    if parsed_schedule["kind"] == "once" and repeat is None:
-        repeat = 1
-    
-    # Default delivery to origin if available, otherwise local
-    if deliver is None:
-        deliver = "origin" if origin else "local"
-    
-    job_id = uuid.uuid4().hex[:12]
-    now = datetime.now().isoformat()
-    
-    job = {
-        "id": job_id,
-        "name": name or prompt[:50].strip(),
-        "prompt": prompt,
-        "schedule": parsed_schedule,
-        "schedule_display": parsed_schedule.get("display", schedule),
-        "repeat": {
-            "times": repeat,  # None = forever
-            "completed": 0
-        },
-        "enabled": True,
-        "created_at": now,
-        "next_run_at": compute_next_run(parsed_schedule),
-        "last_run_at": None,
-        "last_status": None,
-        "last_error": None,
-        # Delivery configuration
-        "deliver": deliver,
-        "origin": origin,  # Tracks where job was created for "origin" delivery
-    }
-    
-    jobs = load_jobs()
-    jobs.append(job)
-    save_jobs(jobs)
-    
-    return job
-
-
-def get_job(job_id: str) -> Optional[Dict[str, Any]]:
-    """Get a job by ID."""
-    jobs = load_jobs()
-    for job in jobs:
-        if job["id"] == job_id:
-            return job
-    return None
-
-
-def list_jobs(include_disabled: bool = False) -> List[Dict[str, Any]]:
-    """List all jobs, optionally including disabled ones."""
-    jobs = load_jobs()
-    if not include_disabled:
-        jobs = [j for j in jobs if j.get("enabled", True)]
-    return jobs
-
-
-def update_job(job_id: str, updates: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-    """Update a job by ID."""
-    jobs = load_jobs()
-    for i, job in enumerate(jobs):
-        if job["id"] == job_id:
-            jobs[i] = {**job, **updates}
-            save_jobs(jobs)
-            return jobs[i]
-    return None
-
-
-def remove_job(job_id: str) -> bool:
-    """Remove a job by ID."""
-    jobs = load_jobs()
-    original_len = len(jobs)
-    jobs = [j for j in jobs if j["id"] != job_id]
-    if len(jobs) < original_len:
-        save_jobs(jobs)
-        return True
-    return False
-
-
-def mark_job_run(job_id: str, success: bool, error: Optional[str] = None):
-    """
-    Mark a job as having been run.
-    
-    Updates last_run_at, last_status, increments completed count,
-    computes next_run_at, and auto-deletes if repeat limit reached.
-    """
-    jobs = load_jobs()
-    for i, job in enumerate(jobs):
-        if job["id"] == job_id:
-            now = datetime.now().isoformat()
-            job["last_run_at"] = now
-            job["last_status"] = "ok" if success else "error"
-            job["last_error"] = error if not success else None
-            
-            # Increment completed count
-            if job.get("repeat"):
-                job["repeat"]["completed"] = job["repeat"].get("completed", 0) + 1
-                
-                # Check if we've hit the repeat limit
-                times = job["repeat"].get("times")
-                completed = job["repeat"]["completed"]
-                if times is not None and completed >= times:
-                    # Remove the job (limit reached)
-                    jobs.pop(i)
-                    save_jobs(jobs)
-                    return
-            
-            # Compute next run
-            job["next_run_at"] = compute_next_run(job["schedule"], now)
-            
-            # If no next run (one-shot completed), disable
-            if job["next_run_at"] is None:
-                job["enabled"] = False
-            
-            save_jobs(jobs)
-            return
-    
-    save_jobs(jobs)
-
-
-def get_due_jobs() -> List[Dict[str, Any]]:
-    """Get all jobs that are due to run now."""
-    now = datetime.now()
-    jobs = load_jobs()
-    due = []
-    
-    for job in jobs:
-        if not job.get("enabled", True):
-            continue
-        
-        next_run = job.get("next_run_at")
-        if not next_run:
-            continue
-        
-        next_run_dt = datetime.fromisoformat(next_run)
-        if next_run_dt <= now:
-            due.append(job)
-    
-    return due
-
-
-def save_job_output(job_id: str, output: str):
-    """Save job output to file."""
-    ensure_dirs()
-    job_output_dir = OUTPUT_DIR / job_id
-    job_output_dir.mkdir(parents=True, exist_ok=True)
-    
-    timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
-    output_file = job_output_dir / f"{timestamp}.md"
-    
-    with open(output_file, 'w', encoding='utf-8') as f:
-        f.write(output)
-    
-    return output_file

cron/scheduler.py

@@ -1,188 +0,0 @@
-"""
-Cron job scheduler - executes due jobs.
-
-This module provides:
-- tick(): Run all due jobs once (for system cron integration)
-- run_daemon(): Run continuously, checking every 60 seconds
-"""
-
-import os
-import sys
-import time
-import traceback
-from datetime import datetime
-from pathlib import Path
-from typing import Optional
-
-# Add parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from cron.jobs import get_due_jobs, mark_job_run, save_job_output
-
-
-def run_job(job: dict) -> tuple[bool, str, Optional[str]]:
-    """
-    Execute a single cron job.
-    
-    Returns:
-        Tuple of (success, output, error_message)
-    """
-    from run_agent import AIAgent
-    
-    job_id = job["id"]
-    job_name = job["name"]
-    prompt = job["prompt"]
-    
-    print(f"[cron] Running job '{job_name}' (ID: {job_id})")
-    print(f"[cron] Prompt: {prompt[:100]}{'...' if len(prompt) > 100 else ''}")
-    
-    try:
-        # Create agent with default settings
-        # Jobs run in isolated sessions (no prior context)
-        agent = AIAgent(
-            model=os.getenv("HERMES_MODEL", "anthropic/claude-sonnet-4"),
-            quiet_mode=True,
-            session_id=f"cron_{job_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-        )
-        
-        # Run the conversation
-        result = agent.run_conversation(prompt)
-        
-        # Extract final response
-        final_response = result.get("final_response", "")
-        if not final_response:
-            final_response = "(No response generated)"
-        
-        # Build output document
-        output = f"""# Cron Job: {job_name}
-
-**Job ID:** {job_id}
-**Run Time:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-**Schedule:** {job.get('schedule_display', 'N/A')}
-
-## Prompt
-
-{prompt}
-
-## Response
-
-{final_response}
-"""
-        
-        print(f"[cron] Job '{job_name}' completed successfully")
-        return True, output, None
-        
-    except Exception as e:
-        error_msg = f"{type(e).__name__}: {str(e)}"
-        print(f"[cron] Job '{job_name}' failed: {error_msg}")
-        
-        # Build error output
-        output = f"""# Cron Job: {job_name} (FAILED)
-
-**Job ID:** {job_id}
-**Run Time:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-**Schedule:** {job.get('schedule_display', 'N/A')}
-
-## Prompt
-
-{prompt}
-
-## Error
-
-```
-{error_msg}
-
-{traceback.format_exc()}
-```
-"""
-        return False, output, error_msg
-
-
-def tick(verbose: bool = True) -> int:
-    """
-    Check and run all due jobs.
-    
-    This is designed to be called by system cron every minute:
-        */1 * * * * cd ~/hermes-agent && python -c "from cron import tick; tick()"
-    
-    Args:
-        verbose: Whether to print status messages
-    
-    Returns:
-        Number of jobs executed
-    """
-    due_jobs = get_due_jobs()
-    
-    if verbose and not due_jobs:
-        print(f"[cron] {datetime.now().strftime('%H:%M:%S')} - No jobs due")
-        return 0
-    
-    if verbose:
-        print(f"[cron] {datetime.now().strftime('%H:%M:%S')} - {len(due_jobs)} job(s) due")
-    
-    executed = 0
-    for job in due_jobs:
-        try:
-            success, output, error = run_job(job)
-            
-            # Save output to file
-            output_file = save_job_output(job["id"], output)
-            if verbose:
-                print(f"[cron] Output saved to: {output_file}")
-            
-            # Mark job as run (handles repeat counting, next_run computation)
-            mark_job_run(job["id"], success, error)
-            executed += 1
-            
-        except Exception as e:
-            print(f"[cron] Error processing job {job['id']}: {e}")
-            mark_job_run(job["id"], False, str(e))
-    
-    return executed
-
-
-def run_daemon(check_interval: int = 60, verbose: bool = True):
-    """
-    Run the cron daemon continuously.
-    
-    Checks for due jobs every `check_interval` seconds.
-    
-    Args:
-        check_interval: Seconds between checks (default: 60)
-        verbose: Whether to print status messages
-    """
-    print(f"[cron] Starting daemon (checking every {check_interval}s)")
-    print(f"[cron] Press Ctrl+C to stop")
-    print()
-    
-    try:
-        while True:
-            try:
-                tick(verbose=verbose)
-            except Exception as e:
-                print(f"[cron] Tick error: {e}")
-            
-            time.sleep(check_interval)
-            
-    except KeyboardInterrupt:
-        print("\n[cron] Daemon stopped")
-
-
-if __name__ == "__main__":
-    # Allow running directly: python cron/scheduler.py [daemon|tick]
-    import argparse
-    
-    parser = argparse.ArgumentParser(description="Hermes Cron Scheduler")
-    parser.add_argument("mode", choices=["daemon", "tick"], default="tick", nargs="?",
-                        help="Mode: 'tick' to run once, 'daemon' to run continuously")
-    parser.add_argument("--interval", type=int, default=60,
-                        help="Check interval in seconds for daemon mode")
-    parser.add_argument("--quiet", "-q", action="store_true",
-                        help="Suppress status messages")
-    
-    args = parser.parse_args()
-    
-    if args.mode == "daemon":
-        run_daemon(check_interval=args.interval, verbose=not args.quiet)
-    else:
-        tick(verbose=not args.quiet)

docs/cli.md

@@ -117,29 +117,6 @@ terminal:
   modal_image: "python:3.11"
 ```
 
-### Sudo Support
-
-The CLI supports interactive sudo prompts:
-
-```
-┌──────────────────────────────────────────────────────────┐
-│  🔐 SUDO PASSWORD REQUIRED                               │
-├──────────────────────────────────────────────────────────┤
-│  Enter password below (input is hidden), or:             │
-│    • Press Enter to skip (command fails gracefully)      │
-│    • Wait 45s to auto-skip                               │
-└──────────────────────────────────────────────────────────┘
-
-  Password (hidden): 
-```
-
-**Options:**
-- **Interactive**: Leave `sudo_password` unset - you'll be prompted when needed
-- **Configured**: Set `sudo_password` in `cli-config.yaml` to auto-fill
-- **Environment**: Set `SUDO_PASSWORD` in `.env` for all runs
-
-Password is cached for the session once entered.
-
 ### Toolsets
 
 Control which tools are available:
@@ -225,62 +202,6 @@ This allows you to have different terminal configs for CLI vs batch processing.
 - **History**: Command history is saved to `~/.hermes_history`
 - **Conversations**: Use `/save` to export conversations
 - **Reset**: Use `/clear` for full reset, `/reset` to just clear history
-- **Session Logs**: Every session automatically logs to `logs/session_{session_id}.json`
-
-### Session Logging
-
-Sessions are automatically logged to the `logs/` directory:
-
-```
-logs/
-├── session_20260201_143052_a1b2c3.json
-├── session_20260201_150217_d4e5f6.json
-└── ...
-```
-
-The session ID is displayed in the welcome banner and follows the format: `YYYYMMDD_HHMMSS_UUID`.
-
-Log files contain:
-- Full conversation history in trajectory format
-- Timestamps for session start and last update
-- Model and message count metadata
-
-This is useful for:
-- Debugging agent behavior
-- Replaying conversations
-- Training data inspection
-
-### Context Compression
-
-Long conversations can exceed model context limits. The CLI automatically compresses context when approaching the limit:
-
-```yaml
-# In cli-config.yaml
-compression:
-  enabled: true                    # Enable auto-compression
-  threshold: 0.85                  # Compress at 85% of context limit  
-  summary_model: "google/gemini-2.0-flash-001"
-```
-
-**How it works:**
-1. Tracks actual token usage from each API response
-2. When tokens reach threshold, middle turns are summarized
-3. First 3 and last 4 turns are always protected
-4. Conversation continues seamlessly after compression
-
-**When compression triggers:**
-```
-📦 Context compression triggered (170,000 tokens ≥ 170,000 threshold)
-   📊 Model context limit: 200,000 tokens (85% = 170,000)
-   🗜️  Summarizing turns 4-15 (12 turns)
-   ✅ Compressed: 20 → 9 messages (~45,000 tokens saved)
-```
-
-To disable compression:
-```yaml
-compression:
-  enabled: false
-```
 
 ## Quiet Mode
 

docs/messaging.md

@@ -1,515 +0,0 @@
-# Messaging Platform Integrations (Gateway)
-
-Hermes Agent can connect to messaging platforms like Telegram, Discord, and WhatsApp to serve as a conversational AI assistant.
-
-## Quick Start
-
-```bash
-# 1. Set your bot token(s) in .env file
-echo 'TELEGRAM_BOT_TOKEN="your_telegram_bot_token"' >> .env
-echo 'DISCORD_BOT_TOKEN="your_discord_bot_token"' >> .env
-
-# 2. Test the gateway (foreground)
-./scripts/hermes-gateway run
-
-# 3. Install as a system service (runs in background)
-./scripts/hermes-gateway install
-
-# 4. Manage the service
-./scripts/hermes-gateway start
-./scripts/hermes-gateway stop
-./scripts/hermes-gateway restart
-./scripts/hermes-gateway status
-```
-
-**Quick test (without service install):**
-```bash
-python cli.py --gateway  # Runs in foreground, useful for debugging
-```
-
-## Architecture Overview
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                      Hermes Gateway                             │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                 │
-│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
-│  │   Telegram   │  │   Discord    │  │   WhatsApp   │          │
-│  │   Adapter    │  │   Adapter    │  │   Adapter    │          │
-│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘          │
-│         │                 │                 │                   │
-│         └─────────────────┼─────────────────┘                   │
-│                           │                                     │
-│                  ┌────────▼────────┐                            │
-│                  │  Session Store  │                            │
-│                  │  (per-chat)     │                            │
-│                  └────────┬────────┘                            │
-│                           │                                     │
-│                  ┌────────▼────────┐                            │
-│                  │   AIAgent       │                            │
-│                  │   (run_agent)   │                            │
-│                  └─────────────────┘                            │
-│                                                                 │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## Session Management
-
-### Session Persistence
-
-Sessions persist across messages until they reset. The agent remembers your conversation context.
-
-### Reset Policies
-
-Sessions reset based on configurable policies:
-
-| Policy | Default | Description |
-|--------|---------|-------------|
-| Daily | 4:00 AM | Reset at a specific hour each day |
-| Idle | 120 min | Reset after N minutes of inactivity |
-| Both | (combined) | Whichever triggers first |
-
-### Manual Reset
-
-Send `/new` or `/reset` as a message to start fresh.
-
-### Per-Platform Overrides
-
-Configure different reset policies per platform:
-
-```json
-{
-  "reset_by_platform": {
-    "telegram": { "mode": "idle", "idle_minutes": 240 },
-    "discord": { "mode": "idle", "idle_minutes": 60 }
-  }
-}
-```
-
-## Platform Setup
-
-### Telegram
-
-1. **Create a bot** via [@BotFather](https://t.me/BotFather)
-2. **Get your token** (looks like `123456789:ABCdefGHIjklMNOpqrsTUVwxyz`)
-3. **Set environment variable:**
-   ```bash
-   export TELEGRAM_BOT_TOKEN="your_token_here"
-   ```
-4. **Optional: Set home channel** for cron job delivery:
-   ```bash
-   export TELEGRAM_HOME_CHANNEL="-1001234567890"
-   export TELEGRAM_HOME_CHANNEL_NAME="My Notes"
-   ```
-
-**Requirements:**
-```bash
-pip install python-telegram-bot>=20.0
-```
-
-### Discord
-
-1. **Create an application** at [Discord Developer Portal](https://discord.com/developers/applications)
-2. **Create a bot** under your application
-3. **Get the bot token**
-4. **Enable required intents:**
-   - Message Content Intent
-   - Server Members Intent (optional)
-5. **Invite to your server** using OAuth2 URL generator (scopes: `bot`, `applications.commands`)
-6. **Set environment variable:**
-   ```bash
-   export DISCORD_BOT_TOKEN="your_token_here"
-   ```
-7. **Optional: Set home channel:**
-   ```bash
-   export DISCORD_HOME_CHANNEL="123456789012345678"
-   export DISCORD_HOME_CHANNEL_NAME="#bot-updates"
-   ```
-
-**Requirements:**
-```bash
-pip install discord.py>=2.0
-```
-
-### WhatsApp
-
-WhatsApp integration is more complex due to the lack of a simple bot API.
-
-**Options:**
-1. **WhatsApp Business API** (requires Meta verification)
-2. **whatsapp-web.js** via Node.js bridge (for personal accounts)
-
-**Bridge Setup:**
-1. Install Node.js
-2. Set up the bridge script (see `scripts/whatsapp-bridge/` for reference)
-3. Configure in gateway:
-   ```json
-   {
-     "platforms": {
-       "whatsapp": {
-         "enabled": true,
-         "extra": {
-           "bridge_script": "/path/to/bridge.js",
-           "bridge_port": 3000
-         }
-       }
-     }
-   }
-   ```
-
-## Configuration
-
-There are **three ways** to configure the gateway (in order of precedence):
-
-### 1. Environment Variables (`.env` file) - Recommended for Quick Setup
-
-Add to your `~/.hermes/.env` file:
-
-```bash
-# =============================================================================
-# MESSAGING PLATFORM TOKENS
-# =============================================================================
-
-# Telegram - get from @BotFather on Telegram
-TELEGRAM_BOT_TOKEN=your_telegram_bot_token
-TELEGRAM_ALLOWED_USERS=123456789,987654321    # Security: restrict to these user IDs
-
-# Optional: Default channel for cron job delivery
-TELEGRAM_HOME_CHANNEL=-1001234567890
-TELEGRAM_HOME_CHANNEL_NAME="My Notes"
-
-# Discord - get from Discord Developer Portal
-DISCORD_BOT_TOKEN=your_discord_bot_token
-DISCORD_ALLOWED_USERS=123456789012345678      # Security: restrict to these user IDs
-
-# Optional: Default channel for cron job delivery
-DISCORD_HOME_CHANNEL=123456789012345678
-DISCORD_HOME_CHANNEL_NAME="#bot-updates"
-
-# WhatsApp - requires Node.js bridge setup
-WHATSAPP_ENABLED=true
-
-# =============================================================================
-# AGENT SETTINGS
-# =============================================================================
-
-# Max tool-calling iterations per conversation (default: 60)
-HERMES_MAX_ITERATIONS=60
-
-# Working directory for terminal commands (default: home ~)
-MESSAGING_CWD=/home/myuser
-
-# =============================================================================
-# TOOL PROGRESS NOTIFICATIONS
-# =============================================================================
-
-# Show progress messages as agent uses tools
-HERMES_TOOL_PROGRESS=true
-
-# Mode: "new" (only when tool changes) or "all" (every tool call)
-HERMES_TOOL_PROGRESS_MODE=new
-
-# =============================================================================
-# SESSION SETTINGS
-# =============================================================================
-
-# Reset sessions after N minutes of inactivity (default: 120)
-SESSION_IDLE_MINUTES=120
-
-# Daily reset hour in 24h format (default: 4 = 4am)
-SESSION_RESET_HOUR=4
-```
-
-### 2. Gateway Config File (`~/.hermes/gateway.json`) - Full Control
-
-For advanced configuration, create `~/.hermes/gateway.json`:
-
-```json
-{
-  "platforms": {
-    "telegram": {
-      "enabled": true,
-      "token": "your_telegram_token",
-      "home_channel": {
-        "platform": "telegram",
-        "chat_id": "-1001234567890",
-        "name": "My Notes"
-      }
-    },
-    "discord": {
-      "enabled": true,
-      "token": "your_discord_token",
-      "home_channel": {
-        "platform": "discord",
-        "chat_id": "123456789012345678",
-        "name": "#bot-updates"
-      }
-    }
-  },
-  "default_reset_policy": {
-    "mode": "both",
-    "at_hour": 4,
-    "idle_minutes": 120
-  },
-  "reset_by_platform": {
-    "discord": {
-      "mode": "idle",
-      "idle_minutes": 60
-    }
-  },
-  "always_log_local": true
-}
-```
-
-## Platform-Specific Toolsets
-
-Each platform has its own toolset for security:
-
-| Platform | Toolset | Capabilities |
-|----------|---------|--------------|
-| CLI | `hermes-cli` | Full access (terminal, browser, etc.) |
-| Telegram | `hermes-telegram` | Full tools including terminal |
-| Discord | `hermes-discord` | Full tools including terminal |
-| WhatsApp | `hermes-whatsapp` | Full tools including terminal |
-
-## User Experience Features
-
-### Typing Indicator
-
-The gateway keeps the "typing..." indicator active throughout processing, refreshing every 4 seconds. This lets users know the bot is working even during long tool-calling sequences.
-
-### Tool Progress Notifications
-
-When `HERMES_TOOL_PROGRESS=true`, the bot sends status messages as it works:
-
-```
-💻 `ls -la`...
-🔍 web_search...
-📄 web_extract...
-🎨 image_generate...
-```
-
-Terminal commands show the actual command (truncated to 50 chars). Other tools just show the tool name.
-
-**Modes:**
-- `new`: Only sends message when switching to a different tool (less spam)
-- `all`: Sends message for every single tool call
-
-### Working Directory
-
-- **CLI (`hermes` command)**: Uses current directory where you run the command
-- **Messaging**: Uses `MESSAGING_CWD` (default: home directory `~`)
-
-This is intentional: CLI users are in a terminal and expect the agent to work in their current directory, while messaging users need a consistent starting location.
-
-### Max Iterations
-
-If the agent hits the max iteration limit while working, instead of a generic error, it asks the model to summarize what it found so far. This gives you a useful response even when the task couldn't be fully completed.
-
-## Cron Job Delivery
-
-When scheduling cron jobs, you can specify where the output should be delivered:
-
-```
-User: "Remind me to check the server in 30 minutes"
-
-Agent uses: schedule_cronjob(
-  prompt="Check server status...",
-  schedule="30m",
-  deliver="origin"  # Back to this chat
-)
-```
-
-### Delivery Options
-
-| Option | Description |
-|--------|-------------|
-| `"origin"` | Back to where the job was created |
-| `"local"` | Save to local files only |
-| `"telegram"` | Telegram home channel |
-| `"discord"` | Discord home channel |
-| `"telegram:123456"` | Specific Telegram chat |
-
-## Dynamic Context Injection
-
-The agent knows where it is via injected context:
-
-```
-## Current Session Context
-
-**Source:** Telegram (group: Dev Team, ID: -1001234567890)
-**Connected Platforms:** local, telegram, discord
-
-**Home Channels:**
-  - telegram: My Notes (ID: -1001234567890)
-  - discord: #bot-updates (ID: 123456789012345678)
-
-**Delivery options for scheduled tasks:**
-- "origin" → Back to this chat (Dev Team)
-- "local" → Save to local files only
-- "telegram" → Home channel (My Notes)
-- "discord" → Home channel (#bot-updates)
-```
-
-## CLI Commands
-
-| Command | Description |
-|---------|-------------|
-| `/platforms` | Show gateway configuration and status |
-| `--gateway` | Start the gateway (CLI flag) |
-
-## Troubleshooting
-
-### "python-telegram-bot not installed"
-
-```bash
-pip install python-telegram-bot>=20.0
-```
-
-### "discord.py not installed"
-
-```bash
-pip install discord.py>=2.0
-```
-
-### "No platforms connected"
-
-1. Check your environment variables are set
-2. Check your tokens are valid
-3. Try `/platforms` to see configuration status
-
-### Session not persisting
-
-1. Check `~/.hermes/sessions/` exists
-2. Check session policies aren't too aggressive
-3. Verify no errors in gateway logs
-
-## Adding a New Platform
-
-To add a new messaging platform:
-
-### 1. Create the adapter
-
-Create `gateway/platforms/your_platform.py`:
-
-```python
-from gateway.platforms.base import BasePlatformAdapter, MessageEvent, SendResult
-from gateway.config import Platform, PlatformConfig
-
-class YourPlatformAdapter(BasePlatformAdapter):
-    def __init__(self, config: PlatformConfig):
-        super().__init__(config, Platform.YOUR_PLATFORM)
-    
-    async def connect(self) -> bool:
-        # Connect to the platform
-        ...
-    
-    async def disconnect(self) -> None:
-        # Disconnect
-        ...
-    
-    async def send(self, chat_id: str, content: str, ...) -> SendResult:
-        # Send a message
-        ...
-    
-    async def get_chat_info(self, chat_id: str) -> Dict[str, Any]:
-        # Get chat information
-        ...
-```
-
-### 2. Register the platform
-
-Add to `gateway/config.py`:
-
-```python
-class Platform(Enum):
-    # ... existing ...
-    YOUR_PLATFORM = "your_platform"
-```
-
-### 3. Add to gateway runner
-
-Update `gateway/run.py` `_create_adapter()`:
-
-```python
-elif platform == Platform.YOUR_PLATFORM:
-    from gateway.platforms.your_platform import YourPlatformAdapter
-    return YourPlatformAdapter(config)
-```
-
-### 4. Create a toolset (optional)
-
-Add to `toolsets.py`:
-
-```python
-"hermes-your-platform": {
-    "description": "Your platform toolset",
-    "tools": [...],
-    "includes": []
-}
-```
-
-### 5. Configure
-
-Add environment variables to `.env`:
-
-```bash
-YOUR_PLATFORM_TOKEN=...
-YOUR_PLATFORM_HOME_CHANNEL=...
-```
-
-## Service Management
-
-### Linux (systemd)
-
-```bash
-# Install as user service
-./scripts/hermes-gateway install
-
-# Manage
-systemctl --user start hermes-gateway
-systemctl --user stop hermes-gateway
-systemctl --user restart hermes-gateway
-systemctl --user status hermes-gateway
-
-# View logs
-journalctl --user -u hermes-gateway -f
-
-# Enable lingering (keeps running after logout)
-sudo loginctl enable-linger $USER
-```
-
-### macOS (launchd)
-
-```bash
-# Install
-./scripts/hermes-gateway install
-
-# Manage
-launchctl start ai.hermes.gateway
-launchctl stop ai.hermes.gateway
-
-# View logs
-tail -f ~/.hermes/logs/gateway.log
-```
-
-### Manual (any platform)
-
-```bash
-# Run in foreground (for testing/debugging)
-./scripts/hermes-gateway run
-
-# Or via CLI (also foreground)
-python cli.py --gateway
-```
-
-## Storage Locations
-
-| Path | Purpose |
-|------|---------|
-| `~/.hermes/gateway.json` | Gateway configuration |
-| `~/.hermes/sessions/sessions.json` | Session index |
-| `~/.hermes/sessions/{id}.jsonl` | Conversation transcripts |
-| `~/.hermes/cron/output/` | Cron job outputs |
-| `~/.hermes/logs/gateway.log` | Gateway logs (macOS launchd) |

environments/__init__.py

@@ -1,28 +0,0 @@
-"""
-Hermes-Agent Atropos Environments
-
-Provides a layered integration between hermes-agent's tool-calling capabilities
-and the Atropos RL training framework.
-
-Layers:
-    - agent_loop: Reusable multi-turn agent loop with standard OpenAI-spec tool calling
-    - tool_context: Per-rollout tool access handle for reward/verification functions
-    - hermes_base_env: Abstract base environment (BaseEnv subclass) for Atropos
-    - tool_call_parsers: Client-side tool call parser registry for Phase 2 (VLLM /generate)
-
-Concrete environments:
-    - terminal_test_env: Simple file-creation tasks for testing the stack
-    - hermes_swe_env: SWE-bench style tasks with Modal sandboxes
-"""
-
-from environments.agent_loop import AgentResult, HermesAgentLoop
-from environments.tool_context import ToolContext
-from environments.hermes_base_env import HermesAgentBaseEnv, HermesAgentEnvConfig
-
-__all__ = [
-    "AgentResult",
-    "HermesAgentLoop",
-    "ToolContext",
-    "HermesAgentBaseEnv",
-    "HermesAgentEnvConfig",
-]

environments/agent_loop.py

@@ -1,372 +0,0 @@
-"""
-HermesAgentLoop -- Reusable Multi-Turn Agent Engine
-
-Runs the hermes-agent tool-calling loop using standard OpenAI-spec tool calling.
-Works with any server that returns ChatCompletion objects with tool_calls:
-    - Phase 1: OpenAI server type (VLLM, SGLang, OpenRouter, OpenAI API)
-    - Phase 2: ManagedServer with client-side tool call parser
-
-The loop passes tools= and checks response.choices[0].message.tool_calls,
-identical to hermes-agent's run_agent.py. Tool execution is dispatched via
-handle_function_call() from model_tools.py.
-"""
-
-import asyncio
-import concurrent.futures
-import json
-import logging
-import uuid
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Set
-
-from model_tools import handle_function_call
-
-# Thread pool for running sync tool calls that internally use asyncio.run()
-# (e.g., mini-swe-agent's modal/docker backends). Running them in a separate
-# thread gives them a clean event loop so they don't deadlock inside Atropos's loop.
-_tool_executor = concurrent.futures.ThreadPoolExecutor(max_workers=8)
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class ToolError:
-    """Record of a tool execution error during the agent loop."""
-
-    turn: int                  # Which turn the error occurred on
-    tool_name: str             # Which tool was called
-    arguments: str             # The arguments passed (truncated)
-    error: str                 # The error message
-    tool_result: str           # The raw result returned to the model
-
-
-@dataclass
-class AgentResult:
-    """Result of running the agent loop."""
-
-    # Full conversation history in OpenAI message format
-    messages: List[Dict[str, Any]]
-    # ManagedServer.get_state() if available (Phase 2), None otherwise
-    managed_state: Optional[Dict[str, Any]] = None
-    # How many LLM calls were made
-    turns_used: int = 0
-    # True if model stopped calling tools naturally (vs hitting max_turns)
-    finished_naturally: bool = False
-    # Extracted reasoning content per turn (from PR #297 helpers)
-    reasoning_per_turn: List[Optional[str]] = field(default_factory=list)
-    # Tool errors encountered during the loop
-    tool_errors: List[ToolError] = field(default_factory=list)
-
-
-def _extract_reasoning_from_message(message) -> Optional[str]:
-    """
-    Extract reasoning content from a ChatCompletion message.
-
-    Handles multiple provider formats:
-    1. message.reasoning_content field (some providers)
-    2. message.reasoning field (some providers)
-    3. message.reasoning_details[].text (OpenRouter style)
-
-    Note: <think> block extraction from content is NOT done here -- that's
-    handled by the response already in Phase 1 (server does it) or by
-    ManagedServer's patch in Phase 2.
-
-    Args:
-        message: The assistant message from ChatCompletion response
-
-    Returns:
-        Extracted reasoning text, or None if not found
-    """
-    # Check reasoning_content field (common across providers)
-    if hasattr(message, "reasoning_content") and message.reasoning_content:
-        return message.reasoning_content
-
-    # Check reasoning field
-    if hasattr(message, "reasoning") and message.reasoning:
-        return message.reasoning
-
-    # Check reasoning_details (OpenRouter style)
-    if hasattr(message, "reasoning_details") and message.reasoning_details:
-        for detail in message.reasoning_details:
-            if hasattr(detail, "text") and detail.text:
-                return detail.text
-            if isinstance(detail, dict) and detail.get("text"):
-                return detail["text"]
-
-    return None
-
-
-class HermesAgentLoop:
-    """
-    Runs hermes-agent's tool-calling loop using standard OpenAI-spec tool calling.
-
-    Same pattern as run_agent.py:
-    - Pass tools= to the API
-    - Check response.choices[0].message.tool_calls
-    - Dispatch via handle_function_call()
-
-    Works identically with any server type -- OpenAI, VLLM, SGLang, OpenRouter,
-    or ManagedServer with a parser. The server determines how tool_calls get
-    populated on the response.
-    """
-
-    def __init__(
-        self,
-        server,
-        tool_schemas: List[Dict[str, Any]],
-        valid_tool_names: Set[str],
-        max_turns: int = 30,
-        task_id: Optional[str] = None,
-        temperature: float = 1.0,
-        max_tokens: Optional[int] = None,
-    ):
-        """
-        Initialize the agent loop.
-
-        Args:
-            server: Server object with chat_completion() method (OpenAIServer,
-                    ManagedServer, ServerManager, etc.)
-            tool_schemas: OpenAI-format tool definitions from get_tool_definitions()
-            valid_tool_names: Set of tool names the model is allowed to call
-            max_turns: Maximum number of LLM calls before stopping
-            task_id: Unique ID for terminal/browser session isolation
-            temperature: Sampling temperature for generation
-            max_tokens: Max tokens per generation (None for server default)
-        """
-        self.server = server
-        self.tool_schemas = tool_schemas
-        self.valid_tool_names = valid_tool_names
-        self.max_turns = max_turns
-        self.task_id = task_id or str(uuid.uuid4())
-        self.temperature = temperature
-        self.max_tokens = max_tokens
-
-    async def run(self, messages: List[Dict[str, Any]]) -> AgentResult:
-        """
-        Execute the full agent loop using standard OpenAI tool calling.
-
-        Args:
-            messages: Initial conversation messages (system + user).
-                      Modified in-place as the conversation progresses.
-
-        Returns:
-            AgentResult with full conversation history, managed state, and metadata
-        """
-        reasoning_per_turn = []
-        tool_errors: List[ToolError] = []
-
-        for turn in range(self.max_turns):
-            # Build the chat_completion kwargs
-            chat_kwargs = {
-                "messages": messages,
-                "n": 1,
-                "temperature": self.temperature,
-            }
-
-            # Only pass tools if we have them
-            if self.tool_schemas:
-                chat_kwargs["tools"] = self.tool_schemas
-
-            # Only pass max_tokens if explicitly set
-            if self.max_tokens is not None:
-                chat_kwargs["max_tokens"] = self.max_tokens
-
-            # Make the API call -- standard OpenAI spec
-            try:
-                response = await self.server.chat_completion(**chat_kwargs)
-            except Exception as e:
-                logger.error("API call failed on turn %d: %s", turn + 1, e)
-                return AgentResult(
-                    messages=messages,
-                    managed_state=self._get_managed_state(),
-                    turns_used=turn + 1,
-                    finished_naturally=False,
-                    reasoning_per_turn=reasoning_per_turn,
-                    tool_errors=tool_errors,
-                )
-
-            if not response or not response.choices:
-                logger.warning("Empty response on turn %d", turn + 1)
-                return AgentResult(
-                    messages=messages,
-                    managed_state=self._get_managed_state(),
-                    turns_used=turn + 1,
-                    finished_naturally=False,
-                    reasoning_per_turn=reasoning_per_turn,
-                    tool_errors=tool_errors,
-                )
-
-            assistant_msg = response.choices[0].message
-
-            # Extract reasoning content from the response (all provider formats)
-            reasoning = _extract_reasoning_from_message(assistant_msg)
-            reasoning_per_turn.append(reasoning)
-
-            # Check for tool calls -- standard OpenAI spec
-            if assistant_msg.tool_calls:
-                # Build the assistant message dict for conversation history
-                msg_dict: Dict[str, Any] = {
-                    "role": "assistant",
-                    "content": assistant_msg.content or "",
-                    "tool_calls": [
-                        {
-                            "id": tc.id,
-                            "type": "function",
-                            "function": {
-                                "name": tc.function.name,
-                                "arguments": tc.function.arguments,
-                            },
-                        }
-                        for tc in assistant_msg.tool_calls
-                    ],
-                }
-
-                # Preserve reasoning_content for multi-turn chat template handling
-                # (e.g., Kimi-K2's template renders <think> blocks differently
-                # for history vs. the latest turn based on this field)
-                if reasoning:
-                    msg_dict["reasoning_content"] = reasoning
-
-                messages.append(msg_dict)
-
-                # Execute each tool call via hermes-agent's dispatch
-                for tc in assistant_msg.tool_calls:
-                    tool_name = tc.function.name
-                    tool_args_raw = tc.function.arguments
-
-                    # Validate tool name
-                    if tool_name not in self.valid_tool_names:
-                        tool_result = json.dumps(
-                            {
-                                "error": f"Unknown tool '{tool_name}'. "
-                                f"Available tools: {sorted(self.valid_tool_names)}"
-                            }
-                        )
-                        tool_errors.append(ToolError(
-                            turn=turn + 1, tool_name=tool_name,
-                            arguments=tool_args_raw[:200],
-                            error=f"Unknown tool '{tool_name}'",
-                            tool_result=tool_result,
-                        ))
-                        logger.warning(
-                            "Model called unknown tool '%s' on turn %d",
-                            tool_name, turn + 1,
-                        )
-                    else:
-                        # Parse arguments and dispatch
-                        try:
-                            args = json.loads(tool_args_raw)
-                        except json.JSONDecodeError:
-                            args = {}
-                            logger.warning(
-                                "Invalid JSON in tool call arguments for '%s': %s",
-                                tool_name, tool_args_raw[:200],
-                            )
-
-                        try:
-                            if tool_name == "terminal":
-                                import os
-                                backend = os.getenv("TERMINAL_ENV", "local")
-                                cmd_preview = args.get("command", "")[:80]
-                                print(f"  🖥️  [{backend}] $ {cmd_preview}")
-
-                            # Run tool calls in a thread pool so backends that use
-                            # asyncio.run() internally (modal, docker) get a clean
-                            # event loop instead of deadlocking inside Atropos's loop.
-                            loop = asyncio.get_event_loop()
-                            tool_result = await loop.run_in_executor(
-                                _tool_executor,
-                                lambda: handle_function_call(
-                                    tool_name, args, task_id=self.task_id
-                                ),
-                            )
-                        except Exception as e:
-                            tool_result = json.dumps(
-                                {"error": f"Tool execution failed: {type(e).__name__}: {str(e)}"}
-                            )
-                            tool_errors.append(ToolError(
-                                turn=turn + 1, tool_name=tool_name,
-                                arguments=tool_args_raw[:200],
-                                error=f"{type(e).__name__}: {str(e)}",
-                                tool_result=tool_result,
-                            ))
-                            logger.error(
-                                "Tool '%s' execution failed on turn %d: %s",
-                                tool_name, turn + 1, e,
-                            )
-
-                        # Also check if the tool returned an error in its JSON result
-                        try:
-                            result_data = json.loads(tool_result)
-                            if isinstance(result_data, dict):
-                                err = result_data.get("error")
-                                exit_code = result_data.get("exit_code")
-                                if err and exit_code and exit_code < 0:
-                                    tool_errors.append(ToolError(
-                                        turn=turn + 1, tool_name=tool_name,
-                                        arguments=tool_args_raw[:200],
-                                        error=str(err),
-                                        tool_result=tool_result[:500],
-                                    ))
-                        except (json.JSONDecodeError, TypeError):
-                            pass
-
-                    # Add tool response to conversation
-                    messages.append(
-                        {
-                            "role": "tool",
-                            "tool_call_id": tc.id,
-                            "content": tool_result,
-                        }
-                    )
-
-                logger.debug(
-                    "Turn %d: %d tool calls executed",
-                    turn + 1,
-                    len(assistant_msg.tool_calls),
-                )
-
-            else:
-                # No tool calls -- model is done
-                msg_dict = {
-                    "role": "assistant",
-                    "content": assistant_msg.content or "",
-                }
-                if reasoning:
-                    msg_dict["reasoning_content"] = reasoning
-                messages.append(msg_dict)
-
-                logger.debug(
-                    "Turn %d: model finished naturally (no tool calls)", turn + 1
-                )
-
-                return AgentResult(
-                    messages=messages,
-                    managed_state=self._get_managed_state(),
-                    turns_used=turn + 1,
-                    finished_naturally=True,
-                    reasoning_per_turn=reasoning_per_turn,
-                    tool_errors=tool_errors,
-                )
-
-        # Hit max turns without the model stopping
-        logger.info("Agent hit max_turns (%d) without finishing", self.max_turns)
-        return AgentResult(
-            messages=messages,
-            managed_state=self._get_managed_state(),
-            turns_used=self.max_turns,
-            finished_naturally=False,
-            reasoning_per_turn=reasoning_per_turn,
-            tool_errors=tool_errors,
-        )
-
-    def _get_managed_state(self) -> Optional[Dict[str, Any]]:
-        """
-        Get ManagedServer state if the server supports it.
-
-        Returns state dict with SequenceNodes containing tokens/logprobs/masks,
-        or None if the server doesn't support get_state() (e.g., regular OpenAI server).
-        """
-        if hasattr(self.server, "get_state"):
-            return self.server.get_state()
-        return None

environments/configs/swe_default.yaml

@@ -1,33 +0,0 @@
-# SWE Environment -- Default Configuration
-#
-# SWE-bench style tasks with Modal sandboxes for cloud isolation.
-# Uses terminal + file + web toolsets.
-#
-# Usage:
-#   python environments/hermes_swe_env.py serve --config environments/configs/swe_default.yaml
-
-env:
-  enabled_toolsets: ["terminal", "file", "web"]
-  max_agent_turns: 30
-  max_token_length: 4096
-  group_size: 4
-  terminal_backend: "modal"
-  tool_call_parser: "hermes"
-  tokenizer_name: "NousResearch/DeepHermes-3-Llama-3-3B-Preview"
-  dataset_name: "bigcode/humanevalpack"
-  dataset_split: "test"
-  prompt_field: "prompt"
-  steps_per_eval: 50
-  total_steps: 500
-  use_wandb: true
-  wandb_name: "hermes-swe"
-  system_prompt: >
-    You are a skilled software engineer. You have access to a terminal,
-    file tools, and web search. Use these tools to complete the coding task.
-    Write clean, working code and verify it runs correctly before finishing.
-
-openai:
-  base_url: "http://localhost:8000/v1"
-  model_name: "NousResearch/DeepHermes-3-Llama-3-3B-Preview"
-  server_type: "openai"
-  api_key: ""

environments/configs/terminal_test_default.yaml

@@ -1,35 +0,0 @@
-# Terminal Test Environment -- Default Configuration
-#
-# Simple file-creation tasks for validating the full Atropos + hermes-agent stack.
-# Uses Modal terminal backend and OpenRouter (Claude) for inference.
-# API keys loaded from ~/hermes-agent/.env
-#
-# Usage:
-#   run-api
-#   python environments/terminal_test_env.py serve
-#   # Or with config file:
-#   python environments/terminal_test_env.py serve --config environments/configs/terminal_test_default.yaml
-
-env:
-  enabled_toolsets: ["terminal", "file"]
-  max_agent_turns: 10
-  max_token_length: 2048
-  group_size: 3
-  total_steps: 3
-  steps_per_eval: 3
-  terminal_backend: "modal"
-  tool_call_parser: "hermes"
-  tokenizer_name: "NousResearch/DeepHermes-3-Llama-3-3B-Preview"
-  ensure_scores_are_not_same: false
-  use_wandb: false
-  system_prompt: >
-    You are a helpful assistant with access to a terminal and file tools.
-    Complete the user's request by using the available tools.
-    Be precise and follow instructions exactly.
-
-openai:
-  base_url: "https://openrouter.ai/api/v1"
-  model_name: "anthropic/claude-opus-4.6"
-  server_type: "openai"
-  health_check: false
-  # api_key loaded from OPENROUTER_API_KEY in .env

environments/hermes_base_env.py

@@ -1,615 +0,0 @@
-"""
-HermesAgentBaseEnv -- Abstract Base Environment for Hermes-Agent + Atropos
-
-Provides the Atropos integration plumbing that all hermes-agent environments share:
-- Two-mode operation (OpenAI server for Phase 1, VLLM ManagedServer for Phase 2)
-- Per-group toolset/distribution resolution
-- Agent loop orchestration via HermesAgentLoop
-- ToolContext creation for reward functions
-- ScoredDataGroup construction from ManagedServer state
-
-Subclasses only need to implement:
-    setup()           -- Load dataset, initialize state
-    get_next_item()   -- Return the next item from the dataset
-    format_prompt()   -- Convert a dataset item into the user message
-    compute_reward()  -- Score the rollout (has full ToolContext access)
-    evaluate()        -- Periodic evaluation
-"""
-
-import asyncio
-import json
-import logging
-import os
-import sys
-import uuid
-from abc import abstractmethod
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Tuple, Union
-
-# Ensure the hermes-agent repo root is on sys.path so that imports like
-# `from model_tools import ...` and `from environments.X import ...` work
-# regardless of where the script is invoked from.
-_repo_root = Path(__file__).resolve().parent.parent
-if str(_repo_root) not in sys.path:
-    sys.path.insert(0, str(_repo_root))
-
-from dotenv import load_dotenv
-from pydantic import Field
-
-# Load API keys from hermes-agent/.env so all environments can access them
-_env_path = _repo_root / ".env"
-if _env_path.exists():
-    load_dotenv(dotenv_path=_env_path)
-
-# Apply monkey patches for async-safe tool operation inside Atropos's event loop.
-# This patches SwerexModalEnvironment to use a background thread instead of
-# asyncio.run(), which would deadlock inside Atropos. Safe for normal CLI too.
-from environments.patches import apply_patches
-apply_patches()
-
-from atroposlib.envs.base import (
-    BaseEnv,
-    BaseEnvConfig,
-    ScoredDataGroup,
-    ScoredDataItem,
-)
-from atroposlib.envs.server_handling.server_manager import (
-    APIServerConfig,
-    ServerBaseline,
-    ServerManager,
-)
-from atroposlib.type_definitions import Item
-
-from environments.agent_loop import AgentResult, HermesAgentLoop
-from environments.tool_context import ToolContext
-
-# Import hermes-agent toolset infrastructure
-from model_tools import get_tool_definitions
-from toolset_distributions import sample_toolsets_from_distribution
-
-logger = logging.getLogger(__name__)
-
-
-class HermesAgentEnvConfig(BaseEnvConfig):
-    """
-    Configuration for hermes-agent Atropos environments.
-
-    Extends BaseEnvConfig with agent-specific settings for toolsets,
-    terminal backend, dataset loading, and tool call parsing.
-    """
-
-    # --- Toolset configuration ---
-    # Mutually exclusive: use either enabled_toolsets OR distribution
-    enabled_toolsets: Optional[List[str]] = Field(
-        default=None,
-        description="Explicit list of hermes toolsets to enable (e.g., ['terminal', 'file', 'web']). "
-        "If None and distribution is also None, all available toolsets are enabled.",
-    )
-    disabled_toolsets: Optional[List[str]] = Field(
-        default=None,
-        description="Toolsets to disable. Applied as a filter on top of enabled_toolsets or distribution.",
-    )
-    distribution: Optional[str] = Field(
-        default=None,
-        description="Name of a toolset distribution from toolset_distributions.py "
-        "(e.g., 'development', 'terminal_tasks'). Sampled once per group. "
-        "Mutually exclusive with enabled_toolsets.",
-    )
-
-    # --- Agent loop configuration ---
-    max_agent_turns: int = Field(
-        default=30,
-        description="Maximum number of LLM calls (tool-calling iterations) per rollout.",
-    )
-    system_prompt: Optional[str] = Field(
-        default=None,
-        description="System prompt for the agent. Tools are handled via the tools= parameter, "
-        "not embedded in the prompt text.",
-    )
-    agent_temperature: float = Field(
-        default=1.0,
-        description="Sampling temperature for agent generation during rollouts.",
-    )
-
-    # --- Terminal backend ---
-    terminal_backend: str = Field(
-        default="local",
-        description="Terminal backend: 'local', 'docker', 'modal', 'ssh', 'singularity'. "
-        "Modal recommended for production RL (cloud isolation per rollout).",
-    )
-
-    # --- Dataset ---
-    dataset_name: Optional[str] = Field(
-        default=None,
-        description="HuggingFace dataset name. Optional if tasks are defined inline.",
-    )
-    dataset_split: str = Field(
-        default="train",
-        description="Dataset split to use.",
-    )
-    prompt_field: str = Field(
-        default="prompt",
-        description="Which field in the dataset contains the prompt.",
-    )
-
-    # --- Phase 2: Tool call parsing ---
-    tool_call_parser: str = Field(
-        default="hermes",
-        description="Tool call parser name for Phase 2 (VLLM server type). "
-        "Ignored in Phase 1 (OpenAI server type where VLLM parses natively). "
-        "Options: hermes, mistral, llama3_json, qwen, deepseek_v3, etc.",
-    )
-
-
-class HermesAgentBaseEnv(BaseEnv):
-    """
-    Abstract base environment for hermes-agent Atropos integration.
-
-    Handles two modes of operation:
-    - Phase 1 (OpenAI server type): Uses server.chat_completion() directly.
-      The server (VLLM, SGLang, OpenRouter, OpenAI) handles tool call parsing
-      and reasoning extraction natively. DummyManagedServer provides placeholder
-      tokens. Good for SFT data gen, verifier testing, evaluation.
-
-    - Phase 2 (VLLM server type): Uses ManagedServer for exact token IDs + logprobs
-      via /generate. Client-side tool call parser reconstructs structured tool_calls
-      from raw output. Full RL training capability.
-
-    Subclasses must implement:
-        setup()           -- Load dataset, initialize state
-        get_next_item()   -- Return the next item to roll out
-        format_prompt()   -- Convert a dataset item into the user message string
-        compute_reward()  -- Score the rollout using ToolContext
-        evaluate()        -- Periodic evaluation
-    """
-
-    name: Optional[str] = "hermes-agent"
-    env_config_cls = HermesAgentEnvConfig
-
-    def __init__(
-        self,
-        config: HermesAgentEnvConfig,
-        server_configs: Union[ServerBaseline, List[APIServerConfig]],
-        slurm=False,
-        testing=False,
-    ):
-        super().__init__(config, server_configs, slurm, testing)
-
-        # Set terminal backend environment variable so hermes tools pick it up
-        if config.terminal_backend:
-            os.environ["TERMINAL_ENV"] = config.terminal_backend
-            print(f"🖥️  Terminal backend: {config.terminal_backend}")
-
-        # Current group's resolved tools (set in collect_trajectories)
-        self._current_group_tools: Optional[Tuple[List[Dict], Set[str]]] = None
-
-        # Tool error tracking for wandb logging
-        self._tool_error_buffer: List[Dict[str, Any]] = []
-
-    # =========================================================================
-    # Toolset resolution (per-group)
-    # =========================================================================
-
-    def _resolve_tools_for_group(self) -> Tuple[List[Dict[str, Any]], Set[str]]:
-        """
-        Resolve toolsets for a group. Called once in collect_trajectories(),
-        then shared by all collect_trajectory() calls in the group.
-
-        If distribution is set, samples probabilistically.
-        If enabled_toolsets is set, uses that explicit list.
-        disabled_toolsets is applied as a filter on top.
-
-        Returns:
-            (tool_schemas, valid_tool_names) tuple
-        """
-        config = self.config
-
-        if config.distribution:
-            group_toolsets = sample_toolsets_from_distribution(config.distribution)
-            logger.info("Sampled toolsets from '%s': %s", config.distribution, group_toolsets)
-        else:
-            group_toolsets = config.enabled_toolsets  # None means "all available"
-
-        tools = get_tool_definitions(
-            enabled_toolsets=group_toolsets,
-            disabled_toolsets=config.disabled_toolsets,
-            quiet_mode=True,
-        )
-
-        valid_names = {t["function"]["name"] for t in tools} if tools else set()
-        logger.info("Resolved %d tools for group: %s", len(valid_names), sorted(valid_names))
-        return tools, valid_names
-
-    # =========================================================================
-    # Server mode detection
-    # =========================================================================
-
-    def _use_managed_server(self) -> bool:
-        """
-        Determine if we should use ManagedServer (Phase 2) or direct server (Phase 1).
-
-        Phase 2 (ManagedServer) is used when the server type is 'vllm' or 'sglang',
-        which go through the /generate endpoint for exact token tracking.
-
-        Phase 1 (direct server) is used for 'openai' server type, which uses
-        /v1/chat/completions with native tool call parsing.
-        """
-        if not self.server.servers:
-            return False
-
-        server = self.server.servers[0]
-        # If the server is an OpenAI server (not VLLM/SGLang), use direct mode
-        from atroposlib.envs.server_handling.openai_server import OpenAIServer
-        return not isinstance(server, OpenAIServer)
-
-    # =========================================================================
-    # Core Atropos integration
-    # =========================================================================
-
-    async def collect_trajectories(
-        self, item: Item
-    ) -> Tuple[
-        Union[Optional[ScoredDataGroup], List[Optional[ScoredDataGroup]]],
-        List[Item],
-    ]:
-        """
-        Override collect_trajectories to resolve toolsets once per group,
-        then delegate to the standard group-level collection.
-
-        The default BaseEnv.collect_trajectories() calls collect_trajectory()
-        group_size times in parallel. We resolve tools once here and store
-        them for all those calls to use.
-        """
-        # Resolve toolsets for this group (shared by all rollouts in the group)
-        self._current_group_tools = self._resolve_tools_for_group()
-
-        # Delegate to the default implementation which calls collect_trajectory()
-        # group_size times via asyncio.gather
-        return await super().collect_trajectories(item)
-
-    # =========================================================================
-    # Wandb rollout display -- format trajectories nicely
-    # =========================================================================
-
-    @staticmethod
-    def _format_trajectory_for_display(messages: List[Dict[str, Any]]) -> str:
-        """
-        Format a conversation's messages into a readable trajectory string
-        for wandb rollout tables. Shows tool calls, tool results, and reasoning
-        in a structured way instead of raw token decoding.
-        """
-        parts = []
-        for msg in messages:
-            role = msg.get("role", "unknown")
-            content = msg.get("content", "")
-
-            if role == "system":
-                parts.append(f"[SYSTEM]\n{content}")
-
-            elif role == "user":
-                parts.append(f"[USER]\n{content}")
-
-            elif role == "assistant":
-                # Show reasoning if present
-                reasoning = msg.get("reasoning_content", "")
-                if reasoning:
-                    # Truncate long reasoning for display
-                    if len(reasoning) > 300:
-                        reasoning = reasoning[:300] + "..."
-                    parts.append(f"[ASSISTANT thinking]\n{reasoning}")
-
-                # Show content
-                if content:
-                    parts.append(f"[ASSISTANT]\n{content}")
-
-                # Show tool calls
-                tool_calls = msg.get("tool_calls", [])
-                for tc in tool_calls:
-                    func = tc.get("function", {})
-                    name = func.get("name", "?")
-                    args = func.get("arguments", "{}")
-                    # Truncate long arguments for display
-                    if len(args) > 200:
-                        args = args[:200] + "..."
-                    parts.append(f"[TOOL CALL] {name}({args})")
-
-            elif role == "tool":
-                tool_id = msg.get("tool_call_id", "")
-                result = content
-                # Truncate long tool results for display
-                if len(result) > 500:
-                    result = result[:500] + "..."
-                parts.append(f"[TOOL RESULT] {result}")
-
-        return "\n\n".join(parts)
-
-    async def add_rollouts_for_wandb(
-        self,
-        scored_data,
-        item=None,
-    ):
-        """
-        Override to show formatted trajectories with tool calls visible,
-        instead of raw token decoding which loses all structure.
-        """
-        num_keep = self.config.num_rollouts_per_group_for_logging
-        if num_keep == -1:
-            num_keep = self.config.group_size
-
-        group = []
-        for i in range(min(num_keep, len(scored_data.get("scores", [])))):
-            score = scored_data["scores"][i]
-
-            # Use messages if available for rich display
-            messages = None
-            if scored_data.get("messages") and i < len(scored_data["messages"]):
-                messages = scored_data["messages"][i]
-
-            if messages:
-                text = self._format_trajectory_for_display(messages)
-            elif scored_data.get("tokens") and i < len(scored_data["tokens"]):
-                text = self.tokenizer.decode(scored_data["tokens"][i])
-            else:
-                text = "(no data)"
-
-            group.append((text, score))
-
-        self.rollouts_for_wandb.append(group)
-        if len(self.rollouts_for_wandb) > self.config.num_rollouts_to_keep:
-            self.rollouts_for_wandb.pop(0)
-
-    async def wandb_log(self, wandb_metrics: Optional[Dict] = None):
-        """Log base metrics including tool errors to wandb."""
-        if wandb_metrics is None:
-            wandb_metrics = {}
-
-        # Log tool error stats
-        if self._tool_error_buffer:
-            wandb_metrics["train/tool_errors_count"] = len(self._tool_error_buffer)
-
-            # Log error details as a summary string (tables can crash wandb on tmp cleanup)
-            error_summaries = []
-            for err in self._tool_error_buffer:
-                error_summaries.append(
-                    f"[turn {err['turn']}] {err['tool']}({err['args'][:80]}) -> {err['error'][:150]}"
-                )
-            wandb_metrics["train/tool_error_details"] = "\n".join(error_summaries)
-
-            # Also print to stdout for immediate visibility
-            for summary in error_summaries:
-                print(f"  Tool Error: {summary}")
-
-            self._tool_error_buffer = []
-        else:
-            wandb_metrics["train/tool_errors_count"] = 0
-
-        await super().wandb_log(wandb_metrics)
-
-    async def collect_trajectory(
-        self, item: Item
-    ) -> Tuple[Optional[Union[ScoredDataItem, Any]], List[Item]]:
-        """
-        Run a single rollout: agent loop + reward computation.
-
-        This is called group_size times in parallel by collect_trajectories().
-        Each call gets its own task_id for terminal/browser session isolation.
-        """
-        task_id = str(uuid.uuid4())
-
-        # Get group-level tools (resolved once in collect_trajectories)
-        if self._current_group_tools is None:
-            # Fallback: resolve per-trajectory if called outside collect_trajectories
-            tools, valid_names = self._resolve_tools_for_group()
-        else:
-            tools, valid_names = self._current_group_tools
-
-        # Build initial messages
-        messages: List[Dict[str, Any]] = []
-        if self.config.system_prompt:
-            messages.append({"role": "system", "content": self.config.system_prompt})
-        messages.append({"role": "user", "content": self.format_prompt(item)})
-
-        # Run the agent loop
-        result: AgentResult
-        if self._use_managed_server():
-            # Phase 2: ManagedServer with parser -- exact tokens + logprobs
-            # Load the tool call parser from registry based on config
-            from environments.tool_call_parsers import get_parser
-            try:
-                tc_parser = get_parser(self.config.tool_call_parser)
-            except KeyError:
-                logger.warning(
-                    "Tool call parser '%s' not found, falling back to 'hermes'",
-                    self.config.tool_call_parser,
-                )
-                tc_parser = get_parser("hermes")
-
-            try:
-                async with self.server.managed_server(
-                    tokenizer=self.tokenizer,
-                    tool_call_parser=tc_parser,
-                ) as managed:
-                    agent = HermesAgentLoop(
-                        server=managed,
-                        tool_schemas=tools,
-                        valid_tool_names=valid_names,
-                        max_turns=self.config.max_agent_turns,
-                        task_id=task_id,
-                        temperature=self.config.agent_temperature,
-                        max_tokens=self.config.max_token_length,
-                    )
-                    result = await agent.run(messages)
-            except NotImplementedError:
-                # DummyManagedServer not allowed -- fall back to Phase 1
-                logger.warning(
-                    "ManagedServer not available (OpenAI server?). "
-                    "Falling back to direct server mode."
-                )
-                agent = HermesAgentLoop(
-                    server=self.server,
-                    tool_schemas=tools,
-                    valid_tool_names=valid_names,
-                    max_turns=self.config.max_agent_turns,
-                    task_id=task_id,
-                    temperature=self.config.agent_temperature,
-                    max_tokens=self.config.max_token_length,
-                )
-                result = await agent.run(messages)
-        else:
-            # Phase 1: OpenAI server -- native tool_calls, placeholder tokens
-            agent = HermesAgentLoop(
-                server=self.server,
-                tool_schemas=tools,
-                valid_tool_names=valid_names,
-                max_turns=self.config.max_agent_turns,
-                task_id=task_id,
-                temperature=self.config.agent_temperature,
-                max_tokens=self.config.max_token_length,
-            )
-            result = await agent.run(messages)
-
-        # Skip reward computation if the agent loop produced no meaningful work
-        # (e.g., API call failed on turn 1). No point spinning up a Modal sandbox
-        # just to verify files that were never created.
-        only_system_and_user = all(
-            msg.get("role") in ("system", "user") for msg in result.messages
-        )
-        if result.turns_used == 0 or only_system_and_user:
-            logger.warning(
-                "Agent loop produced no output (turns=%d, msgs=%d). Skipping reward.",
-                result.turns_used, len(result.messages),
-            )
-            reward = 0.0
-        else:
-            # Compute reward using ToolContext (gives verifier full tool access)
-            ctx = ToolContext(task_id)
-            try:
-                reward = await self.compute_reward(item, result, ctx)
-            except Exception as e:
-                logger.error("compute_reward failed: %s", e)
-                reward = 0.0
-            finally:
-                ctx.cleanup()
-
-        # Track tool errors for wandb logging
-        if result.tool_errors:
-            for err in result.tool_errors:
-                self._tool_error_buffer.append({
-                    "turn": err.turn,
-                    "tool": err.tool_name,
-                    "args": err.arguments[:150],
-                    "error": err.error[:300],
-                    "result": err.tool_result[:300],
-                })
-
-        # Build ScoredDataItem from ManagedServer state
-        # Phase 2: real tokens/masks/logprobs from SequenceNodes
-        # Phase 1: placeholder tokens (still need a valid ScoredDataItem for the pipeline)
-        nodes = (result.managed_state or {}).get("nodes", [])
-
-        if nodes:
-            # Phase 2 (or DummyManagedServer): use actual node data
-            node = nodes[-1]  # Final sequence node = full trajectory
-            scored_item: Dict[str, Any] = {
-                "tokens": node.tokens,
-                "masks": node.masked_tokens,
-                "scores": reward,
-            }
-
-            # Include logprobs if available (Phase 2)
-            if hasattr(node, "logprobs") and node.logprobs:
-                scored_item["advantages"] = None  # Computed by trainer
-                scored_item["ref_logprobs"] = None
-        else:
-            # Phase 1 with no managed state: create placeholder tokens
-            # so the data pipeline doesn't break. These are NOT suitable
-            # for training but allow process mode (SFT data gen) to work.
-            # Tokenize the full conversation to get approximate tokens.
-            full_text = "\n".join(
-                msg.get("content", "") for msg in result.messages if msg.get("content")
-            )
-            if self.tokenizer:
-                tokens = self.tokenizer.encode(full_text, add_special_tokens=True)
-            else:
-                tokens = list(range(min(len(full_text) // 4, 128)))
-
-            scored_item = {
-                "tokens": tokens,
-                "masks": [-100] + tokens[1:],  # Mask first token as prompt
-                "scores": reward,
-            }
-
-        # Always include messages for wandb rollout display and data logging
-        scored_item["messages"] = result.messages
-
-        return scored_item, []
-
-    # =========================================================================
-    # Abstract methods -- subclasses must implement
-    # =========================================================================
-
-    @abstractmethod
-    async def setup(self):
-        """
-        Load dataset, initialize state.
-
-        Called once when the environment starts. Typical implementation:
-            self.dataset = load_dataset(self.config.dataset_name, split=self.config.dataset_split)
-            self.iter = 0
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    async def get_next_item(self) -> Item:
-        """
-        Return the next item from the dataset for rollout.
-
-        Called by the base env's main loop to get items for workers.
-        Should cycle through the dataset.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    def format_prompt(self, item: Item) -> str:
-        """
-        Convert a dataset item into the user message for the agent.
-
-        Args:
-            item: Dataset item (dict, tuple, etc.)
-
-        Returns:
-            The prompt string to send to the agent
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    async def compute_reward(
-        self, item: Item, result: AgentResult, ctx: ToolContext
-    ) -> float:
-        """
-        Score the rollout. Has full access to:
-        - item: the original dataset item (ground truth, test commands, etc.)
-        - result: AgentResult with full messages, turn count, reasoning, etc.
-        - ctx: ToolContext -- call ANY hermes-agent tool (terminal, file, web,
-               browser, vision...) scoped to this rollout's sandbox. Nothing
-               is off-limits.
-
-        Args:
-            item: The dataset item that was rolled out
-            result: The agent's rollout result
-            ctx: ToolContext with full tool access for verification
-
-        Returns:
-            Reward float (typically 0.0 to 1.0, but any float is valid)
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    async def evaluate(self, *args, **kwargs):
-        """
-        Periodic evaluation. Called every steps_per_eval steps.
-
-        Typical implementation runs the agent on a held-out eval set
-        and logs metrics via wandb/evaluate_log.
-        """
-        raise NotImplementedError

environments/hermes_swe_env.py

@@ -1,229 +0,0 @@
-"""
-HermesSweEnv -- SWE-Bench Style Environment with Modal Sandboxes
-
-A concrete environment for software engineering tasks where the model writes code
-and the reward function runs tests to verify correctness. Uses Modal terminal
-backend for cloud-isolated sandboxes per rollout.
-
-The reward function uses ToolContext.terminal() to run test commands in the same
-Modal sandbox the model used during its agentic loop. All filesystem state from
-the model's tool calls is preserved for verification.
-
-Usage:
-    # Phase 1: OpenAI server type
-    vllm serve YourModel --tool-parser hermes
-    run-api
-    python environments/hermes_swe_env.py serve \\
-        --openai.base_url http://localhost:8000/v1 \\
-        --openai.model_name YourModel \\
-        --openai.server_type openai \\
-        --env.dataset_name bigcode/humanevalpack \\
-        --env.terminal_backend modal
-
-    # Phase 2: VLLM server type (full RL training)
-    python environments/hermes_swe_env.py serve \\
-        --openai.base_url http://localhost:8000/v1 \\
-        --openai.model_name YourModel \\
-        --openai.server_type vllm \\
-        --env.tool_call_parser hermes \\
-        --env.terminal_backend modal
-"""
-
-import logging
-import sys
-import time
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
-
-# Ensure repo root is on sys.path for imports
-_repo_root = Path(__file__).resolve().parent.parent
-if str(_repo_root) not in sys.path:
-    sys.path.insert(0, str(_repo_root))
-
-from datasets import load_dataset
-
-from atroposlib.envs.base import ScoredDataGroup
-from atroposlib.envs.server_handling.server_manager import APIServerConfig
-from atroposlib.type_definitions import Item
-
-from environments.agent_loop import AgentResult
-from environments.hermes_base_env import HermesAgentBaseEnv, HermesAgentEnvConfig
-from environments.tool_context import ToolContext
-
-logger = logging.getLogger(__name__)
-
-
-class HermesSweEnvConfig(HermesAgentEnvConfig):
-    """Config with defaults for SWE-bench style tasks."""
-
-    pass  # Inherits all fields, overrides defaults in config_init
-
-
-class HermesSweEnv(HermesAgentBaseEnv):
-    """
-    SWE-bench style environment using Modal terminal backend.
-
-    The model gets a coding task, uses terminal + file + web tools to solve it,
-    and the reward function runs tests in the same Modal sandbox to verify.
-
-    Subclass this for specific SWE datasets (HumanEval, SWE-bench, etc.)
-    and customize format_prompt() and compute_reward() as needed.
-    """
-
-    name = "hermes-swe"
-    env_config_cls = HermesSweEnvConfig
-
-    @classmethod
-    def config_init(cls) -> Tuple[HermesSweEnvConfig, List[APIServerConfig]]:
-        """
-        Default configuration for the SWE environment.
-
-        Uses Modal terminal backend for cloud isolation and terminal + file + web toolsets.
-        """
-        env_config = HermesSweEnvConfig(
-            # Toolsets: terminal for running code, file for reading/writing, web for docs
-            enabled_toolsets=["terminal", "file", "web"],
-            disabled_toolsets=None,
-            distribution=None,
-            # Agent settings -- SWE tasks need more turns
-            max_agent_turns=30,
-            max_token_length=4096,
-            agent_temperature=1.0,
-            system_prompt=(
-                "You are a skilled software engineer. You have access to a terminal, "
-                "file tools, and web search. Use these tools to complete the coding task. "
-                "Write clean, working code and verify it runs correctly before finishing."
-            ),
-            # Modal backend for cloud-isolated sandboxes
-            terminal_backend="modal",
-            # Dataset -- override via CLI for your specific SWE dataset
-            dataset_name="bigcode/humanevalpack",
-            dataset_split="test",
-            prompt_field="prompt",
-            # Atropos settings
-            group_size=4,
-            tokenizer_name="NousResearch/DeepHermes-3-Llama-3-3B-Preview",
-            tool_call_parser="hermes",
-            steps_per_eval=50,
-            total_steps=500,
-            use_wandb=True,
-            wandb_name="hermes-swe",
-        )
-
-        server_configs = [
-            APIServerConfig(
-                base_url="http://localhost:8000/v1",
-                model_name="NousResearch/DeepHermes-3-Llama-3-3B-Preview",
-                server_type="openai",  # Phase 1; switch to "vllm" for Phase 2
-                api_key="",
-            )
-        ]
-
-        return env_config, server_configs
-
-    async def setup(self):
-        """Load the SWE dataset."""
-        if self.config.dataset_name:
-            self.dataset = load_dataset(
-                self.config.dataset_name, split=self.config.dataset_split
-            )
-        else:
-            # Placeholder if no dataset specified
-            self.dataset = []
-        self.iter = 0
-        self.reward_buffer: List[float] = []
-
-    async def get_next_item(self) -> Dict[str, Any]:
-        """Cycle through the SWE dataset."""
-        if not self.dataset:
-            raise ValueError("No dataset loaded. Set dataset_name in config.")
-        item = self.dataset[self.iter % len(self.dataset)]
-        self.iter += 1
-        return item
-
-    def format_prompt(self, item: Dict[str, Any]) -> str:
-        """
-        Format the SWE task prompt.
-
-        Override this in subclasses for different dataset formats.
-        Default assumes the dataset has a 'prompt' field and optionally a 'test' field.
-        """
-        prompt = item.get(self.config.prompt_field, "")
-
-        # If the dataset has test information, include it in the prompt
-        test_info = item.get("test", item.get("test_code", item.get("tests", "")))
-        if test_info:
-            prompt += f"\n\nTests to pass:\n{test_info}"
-
-        return prompt
-
-    async def compute_reward(
-        self, item: Dict[str, Any], result: AgentResult, ctx: ToolContext
-    ) -> float:
-        """
-        Score by running tests in the model's Modal sandbox.
-
-        Default implementation:
-        - If the dataset item has a 'test' or 'test_code' field, run it
-        - Check exit code: 0 = pass, non-zero = fail
-        - Partial credit for file creation
-
-        Override this in subclasses for more sophisticated reward logic.
-        """
-        # Find the test command from the dataset item
-        test_code = item.get("test", item.get("test_code", item.get("tests", "")))
-
-        if test_code:
-            # Run the test in the model's sandbox
-            test_result = ctx.terminal(
-                f'cd /workspace && python3 -c "{test_code}"', timeout=60
-            )
-
-            if test_result["exit_code"] == 0:
-                self.reward_buffer.append(1.0)
-                return 1.0
-
-        # Partial credit: check if the model created any Python files
-        file_check = ctx.terminal("find /workspace -name '*.py' -newer /tmp/.start_marker 2>/dev/null | head -5")
-        if file_check["exit_code"] == 0 and file_check.get("output", "").strip():
-            self.reward_buffer.append(0.1)
-            return 0.1
-
-        self.reward_buffer.append(0.0)
-        return 0.0
-
-    async def evaluate(self, *args, **kwargs):
-        """
-        Run evaluation on a held-out set.
-
-        Override for dataset-specific evaluation logic.
-        """
-        start_time = time.time()
-        end_time = time.time()
-
-        eval_metrics = {"eval/placeholder": 0.0}
-        await self.evaluate_log(
-            metrics=eval_metrics,
-            start_time=start_time,
-            end_time=end_time,
-        )
-
-    async def wandb_log(self, wandb_metrics: Optional[Dict] = None):
-        """Log SWE-specific metrics."""
-        if wandb_metrics is None:
-            wandb_metrics = {}
-
-        if self.reward_buffer:
-            wandb_metrics["train/avg_reward"] = sum(self.reward_buffer) / len(
-                self.reward_buffer
-            )
-            wandb_metrics["train/pass_rate"] = sum(
-                1 for r in self.reward_buffer if r == 1.0
-            ) / len(self.reward_buffer)
-            self.reward_buffer = []
-
-        await super().wandb_log(wandb_metrics)
-
-
-if __name__ == "__main__":
-    HermesSweEnv.cli()

environments/patches.py

@@ -1,188 +0,0 @@
-"""
-Monkey patches for making hermes-agent tools work inside async frameworks (Atropos).
-
-Problem:
-    Some tools use asyncio.run() internally (e.g., mini-swe-agent's Modal backend,
-    web_extract). This crashes when called from inside Atropos's event loop because
-    asyncio.run() can't be nested.
-
-Solution:
-    Replace the problematic methods with versions that use a dedicated background
-    thread with its own event loop. The calling code sees the same sync interface --
-    call a function, get a result -- but internally the async work happens on a
-    separate thread that doesn't conflict with Atropos's loop.
-
-    These patches are safe for normal CLI use too: when there's no running event
-    loop, the behavior is identical (the background thread approach works regardless).
-
-What gets patched:
-    - SwerexModalEnvironment.__init__ -- creates Modal deployment on a background thread
-    - SwerexModalEnvironment.execute -- runs commands on the same background thread
-    - SwerexModalEnvironment.stop -- stops deployment on the background thread
-
-Usage:
-    Call apply_patches() once at import time (done automatically by hermes_base_env.py).
-    This is idempotent -- calling it multiple times is safe.
-"""
-
-import asyncio
-import logging
-import threading
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-_patches_applied = False
-
-
-class _AsyncWorker:
-    """
-    A dedicated background thread with its own event loop.
-
-    Allows sync code to submit async coroutines and block for results,
-    even when called from inside another running event loop. Used to
-    bridge sync tool interfaces with async backends (Modal, SWE-ReX).
-    """
-
-    def __init__(self):
-        self._loop: asyncio.AbstractEventLoop = None
-        self._thread: threading.Thread = None
-        self._started = threading.Event()
-
-    def start(self):
-        """Start the background event loop thread."""
-        self._thread = threading.Thread(target=self._run_loop, daemon=True)
-        self._thread.start()
-        self._started.wait(timeout=30)
-
-    def _run_loop(self):
-        """Background thread entry point -- runs the event loop forever."""
-        self._loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self._loop)
-        self._started.set()
-        self._loop.run_forever()
-
-    def run_coroutine(self, coro, timeout=600):
-        """
-        Submit a coroutine to the background loop and block until it completes.
-
-        Safe to call from any thread, including threads that already have
-        a running event loop.
-        """
-        if self._loop is None or self._loop.is_closed():
-            raise RuntimeError("AsyncWorker loop is not running")
-        future = asyncio.run_coroutine_threadsafe(coro, self._loop)
-        return future.result(timeout=timeout)
-
-    def stop(self):
-        """Stop the background event loop and join the thread."""
-        if self._loop and self._loop.is_running():
-            self._loop.call_soon_threadsafe(self._loop.stop)
-        if self._thread:
-            self._thread.join(timeout=10)
-
-
-def _patch_swerex_modal():
-    """
-    Monkey patch SwerexModalEnvironment to use a background thread event loop
-    instead of asyncio.run(). This makes it safe to call from inside Atropos's
-    async event loop.
-
-    The patched methods have the exact same interface and behavior -- the only
-    difference is HOW the async work is executed internally.
-    """
-    try:
-        from minisweagent.environments.extra.swerex_modal import (
-            SwerexModalEnvironment,
-            SwerexModalEnvironmentConfig,
-        )
-        from swerex.deployment.modal import ModalDeployment
-        from swerex.runtime.abstract import Command as RexCommand
-    except ImportError:
-        # mini-swe-agent or swe-rex not installed -- nothing to patch
-        logger.debug("mini-swe-agent Modal backend not available, skipping patch")
-        return
-
-    # Save original methods so we can refer to config handling
-    _original_init = SwerexModalEnvironment.__init__
-
-    def _patched_init(self, **kwargs):
-        """Patched __init__: creates Modal deployment on a background thread."""
-        self.config = SwerexModalEnvironmentConfig(**kwargs)
-
-        # Start a dedicated event loop thread for all Modal async operations
-        self._worker = _AsyncWorker()
-        self._worker.start()
-
-        # Create AND start the deployment entirely on the worker's loop/thread
-        # so all gRPC channels and async state are bound to that loop
-        async def _create_and_start():
-            deployment = ModalDeployment(
-                image=self.config.image,
-                startup_timeout=self.config.startup_timeout,
-                runtime_timeout=self.config.runtime_timeout,
-                deployment_timeout=self.config.deployment_timeout,
-                install_pipx=self.config.install_pipx,
-                modal_sandbox_kwargs=self.config.modal_sandbox_kwargs,
-            )
-            await deployment.start()
-            return deployment
-
-        self.deployment = self._worker.run_coroutine(_create_and_start())
-
-    def _patched_execute(self, command: str, cwd: str = "", *, timeout: int | None = None) -> dict[str, Any]:
-        """Patched execute: runs commands on the background thread's loop."""
-        async def _do_execute():
-            return await self.deployment.runtime.execute(
-                RexCommand(
-                    command=command,
-                    shell=True,
-                    check=False,
-                    cwd=cwd or self.config.cwd,
-                    timeout=timeout or self.config.timeout,
-                    merge_output_streams=True,
-                    env=self.config.env if self.config.env else None,
-                )
-            )
-
-        output = self._worker.run_coroutine(_do_execute())
-        return {
-            "output": output.stdout,
-            "returncode": output.exit_code,
-        }
-
-    def _patched_stop(self):
-        """Patched stop: stops deployment on the background thread, then stops the thread."""
-        try:
-            self._worker.run_coroutine(
-                asyncio.wait_for(self.deployment.stop(), timeout=10),
-                timeout=15,
-            )
-        except Exception:
-            pass
-        finally:
-            self._worker.stop()
-
-    # Apply the patches
-    SwerexModalEnvironment.__init__ = _patched_init
-    SwerexModalEnvironment.execute = _patched_execute
-    SwerexModalEnvironment.stop = _patched_stop
-
-    logger.debug("Patched SwerexModalEnvironment for async-safe operation")
-
-
-def apply_patches():
-    """
-    Apply all monkey patches needed for Atropos compatibility.
-
-    Safe to call multiple times -- patches are only applied once.
-    Safe for normal CLI use -- patched code works identically when
-    there is no running event loop.
-    """
-    global _patches_applied
-    if _patches_applied:
-        return
-
-    _patch_swerex_modal()
-
-    _patches_applied = True

environments/terminal_test_env.py

@@ -1,292 +0,0 @@
-"""
-TerminalTestEnv -- Simple Test Environment for Validating the Stack
-
-A self-contained environment with inline tasks (no external dataset needed).
-Each task asks the model to create a file at a known path with specific content.
-The reward verifier cats the file and checks if the content matches.
-
-Enables only terminal + file toolsets. Uses Modal terminal backend with
-OpenRouter (Claude) by default.
-
-Training tasks (3):
-    1. Create ~/greeting.txt with "Hello from Hermes Agent"
-    2. Create ~/count.txt with numbers 1-5, one per line
-    3. Create ~/answer.txt with the result of 123 + 456
-
-Eval task (1):
-    1. Create ~/result.txt with the result of 6 * 7
-
-Usage:
-    # Start Atropos API server
-    run-api
-
-    # Run environment (uses OpenRouter + Modal by default)
-    python environments/terminal_test_env.py serve
-
-    # Process mode (no run-api needed, saves to JSONL)
-    python environments/terminal_test_env.py process \\
-        --env.data_path_to_save_groups terminal_test_output.jsonl
-"""
-
-import logging
-import os
-import sys
-import time
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
-
-# Ensure repo root is on sys.path for imports
-_repo_root = Path(__file__).resolve().parent.parent
-if str(_repo_root) not in sys.path:
-    sys.path.insert(0, str(_repo_root))
-
-from atroposlib.envs.base import ScoredDataGroup
-from atroposlib.envs.server_handling.server_manager import APIServerConfig
-from atroposlib.type_definitions import Item
-
-from environments.agent_loop import AgentResult
-from environments.hermes_base_env import HermesAgentBaseEnv, HermesAgentEnvConfig
-from environments.tool_context import ToolContext
-
-logger = logging.getLogger(__name__)
-
-
-# =============================================================================
-# Inline task definitions -- no external dataset needed
-# =============================================================================
-
-TRAIN_TASKS = [
-    {
-        "prompt": "Create a file at ~/greeting.txt containing exactly the text: Hello from Hermes Agent",
-        "verify_path": "~/greeting.txt",
-        "expected_content": "Hello from Hermes Agent",
-    },
-    {
-        "prompt": "Create a file at ~/count.txt containing the numbers 1 through 5, one per line",
-        "verify_path": "~/count.txt",
-        "expected_content": "1\n2\n3\n4\n5",
-    },
-    {
-        "prompt": "Create a file at ~/answer.txt containing the result of 123 + 456",
-        "verify_path": "~/answer.txt",
-        "expected_content": "579",
-    },
-]
-
-EVAL_TASKS = [
-    {
-        "prompt": "Create a file at ~/result.txt containing the result of 6 * 7",
-        "verify_path": "~/result.txt",
-        "expected_content": "42",
-    },
-]
-
-
-class TerminalTestEnvConfig(HermesAgentEnvConfig):
-    """Config with defaults suitable for terminal testing."""
-
-    pass  # Inherits all fields, overrides defaults in config_init
-
-
-class TerminalTestEnv(HermesAgentBaseEnv):
-    """
-    Simple test environment with inline file-creation tasks.
-
-    All tasks follow the same pattern: "create a file at ~/X.txt with content Y".
-    The verifier runs `cat ~/X.txt` in the rollout's terminal and checks the output
-    against the expected string. Same verifier logic for all tasks.
-
-    This environment is designed to validate the full stack end-to-end:
-    - Agent loop executes tool calls (terminal/file)
-    - ToolContext provides terminal access to the reward function
-    - Reward function verifies file content via cat
-    - Scored data flows through the Atropos pipeline
-    """
-
-    name = "terminal-test"
-    env_config_cls = TerminalTestEnvConfig
-
-    @classmethod
-    def config_init(cls) -> Tuple[TerminalTestEnvConfig, List[APIServerConfig]]:
-        """
-        Default configuration for the terminal test environment.
-
-        Uses Modal terminal backend for cloud isolation and OpenRouter with
-        Claude for inference. API keys loaded from ~/hermes-agent/.env.
-        """
-        env_config = TerminalTestEnvConfig(
-            # Terminal + file tools only
-            enabled_toolsets=["terminal", "file"],
-            disabled_toolsets=None,
-            distribution=None,
-            # Agent settings
-            max_agent_turns=10,  # Simple tasks, don't need many turns
-            max_token_length=16000,
-            agent_temperature=1.0,
-            system_prompt=(
-                "You are a helpful assistant with access to a terminal and file tools. "
-                "Complete the user's request by using the available tools. "
-                "Be precise and follow instructions exactly."
-            ),
-            # Modal terminal backend for cloud-isolated sandboxes per rollout
-            terminal_backend="modal",
-            # Atropos settings
-            group_size=3,              # 3 rollouts per group
-            tokenizer_name="NousResearch/q-30b-t-h45-e1",
-            tool_call_parser="hermes",
-            steps_per_eval=3,          # Eval after all 3 steps
-            total_steps=3,             # 3 groups total (1 group per step)
-            use_wandb=True,
-            wandb_name="terminal-test",
-            ensure_scores_are_not_same=False,  # Allow all-same scores for simple tasks
-            # No external dataset
-            dataset_name=None,
-        )
-
-        # OpenRouter with Claude -- API key loaded from .env (OPENROUTER_API_KEY)
-        server_configs = [
-            APIServerConfig(
-                base_url="https://openrouter.ai/api/v1",
-                model_name="anthropic/claude-opus-4.6",
-                server_type="openai",
-                api_key=os.getenv("OPENROUTER_API_KEY", ""),
-                health_check=False,  # OpenRouter doesn't have a /health endpoint
-            )
-        ]
-
-        return env_config, server_configs
-
-    async def setup(self):
-        """Initialize inline task lists."""
-        self.train_tasks = list(TRAIN_TASKS)
-        self.eval_tasks = list(EVAL_TASKS)
-        self.iter = 0
-        # Track reward stats for wandb logging
-        self.reward_buffer: List[float] = []
-
-    async def get_next_item(self) -> Dict[str, str]:
-        """Cycle through training tasks."""
-        item = self.train_tasks[self.iter % len(self.train_tasks)]
-        self.iter += 1
-        return item
-
-    def format_prompt(self, item: Dict[str, str]) -> str:
-        """The prompt is directly in the task item."""
-        return item["prompt"]
-
-    async def compute_reward(
-        self, item: Dict[str, str], result: AgentResult, ctx: ToolContext
-    ) -> float:
-        """
-        Verify by cat-ing the expected file path and checking content matches.
-        Same verifier for all tasks -- they all write a file at a known path.
-
-        Scoring:
-            1.0 = exact match
-            0.5 = expected content is present but has extra stuff
-            0.0 = file doesn't exist or content doesn't match
-        """
-        verify_result = ctx.terminal(f"cat {item['verify_path']}")
-
-        # File doesn't exist or can't be read
-        if verify_result["exit_code"] != 0:
-            self.reward_buffer.append(0.0)
-            return 0.0
-
-        actual = verify_result.get("output", "").strip()
-        expected = item["expected_content"].strip()
-
-        # Exact match
-        if actual == expected:
-            self.reward_buffer.append(1.0)
-            return 1.0
-
-        # Partial credit: expected content is present but has extra stuff
-        if expected in actual:
-            self.reward_buffer.append(0.5)
-            return 0.5
-
-        self.reward_buffer.append(0.0)
-        return 0.0
-
-    async def evaluate(self, *args, **kwargs):
-        """
-        Run eval tasks using the agent loop and verify results.
-        Logs accuracy metrics.
-        """
-        start_time = time.time()
-        correct = 0
-        total = len(self.eval_tasks)
-        samples = []
-
-        for eval_item in self.eval_tasks:
-            try:
-                # For eval, we do a simple single-turn completion (not full agent loop)
-                # to keep eval fast. The agent loop is tested via training.
-                completion = await self.server.chat_completion(
-                    messages=[
-                        {"role": "system", "content": self.config.system_prompt or ""},
-                        {"role": "user", "content": eval_item["prompt"]},
-                    ],
-                    n=1,
-                    max_tokens=self.config.max_token_length,
-                    temperature=0.0,
-                    split="eval",
-                )
-
-                response_content = (
-                    completion.choices[0].message.content if completion.choices else ""
-                )
-
-                samples.append(
-                    {
-                        "prompt": eval_item["prompt"],
-                        "response": response_content,
-                        "expected": eval_item["expected_content"],
-                    }
-                )
-
-            except Exception as e:
-                logger.error("Eval failed for item: %s", e)
-                samples.append(
-                    {
-                        "prompt": eval_item["prompt"],
-                        "response": f"ERROR: {e}",
-                        "expected": eval_item["expected_content"],
-                    }
-                )
-
-        end_time = time.time()
-
-        eval_metrics = {
-            "eval/num_samples": total,
-        }
-
-        await self.evaluate_log(
-            metrics=eval_metrics,
-            samples=samples,
-            start_time=start_time,
-            end_time=end_time,
-        )
-
-    async def wandb_log(self, wandb_metrics: Optional[Dict] = None):
-        """Log training metrics including reward stats and accuracy."""
-        if wandb_metrics is None:
-            wandb_metrics = {}
-
-        if self.reward_buffer:
-            total = len(self.reward_buffer)
-            correct = sum(1 for r in self.reward_buffer if r == 1.0)
-            partial = sum(1 for r in self.reward_buffer if r == 0.5)
-
-            wandb_metrics["train/avg_reward"] = sum(self.reward_buffer) / total
-            wandb_metrics["train/accuracy"] = correct / total
-            wandb_metrics["train/partial_match_rate"] = partial / total
-            wandb_metrics["train/total_rollouts"] = total
-            self.reward_buffer = []
-
-        await super().wandb_log(wandb_metrics)
-
-
-if __name__ == "__main__":
-    TerminalTestEnv.cli()

environments/tool_call_parsers/__init__.py

@@ -1,120 +0,0 @@
-"""
-Tool Call Parser Registry
-
-Client-side parsers that extract structured tool_calls from raw model output text.
-Used in Phase 2 (VLLM server type) where ManagedServer's /generate endpoint returns
-raw text without tool call parsing.
-
-Each parser is a standalone reimplementation of the corresponding VLLM parser's
-non-streaming extract_tool_calls() logic. No VLLM dependency -- only standard library
-(re, json, uuid) and openai types.
-
-Usage:
-    from environments.tool_call_parsers import get_parser
-
-    parser = get_parser("hermes")
-    content, tool_calls = parser.parse(raw_model_output)
-    # content = text with tool call markup stripped
-    # tool_calls = list of ChatCompletionMessageToolCall objects, or None
-"""
-
-import logging
-from abc import ABC, abstractmethod
-from typing import Dict, List, Optional, Tuple, Type
-
-from openai.types.chat.chat_completion_message_tool_call import (
-    ChatCompletionMessageToolCall,
-)
-
-logger = logging.getLogger(__name__)
-
-# Type alias for parser return value
-ParseResult = Tuple[Optional[str], Optional[List[ChatCompletionMessageToolCall]]]
-
-
-class ToolCallParser(ABC):
-    """
-    Base class for tool call parsers.
-
-    Each parser knows how to extract structured tool_calls from a specific
-    model family's raw output text format.
-    """
-
-    @abstractmethod
-    def parse(self, text: str) -> ParseResult:
-        """
-        Parse raw model output text for tool calls.
-
-        Args:
-            text: Raw decoded text from the model's completion
-
-        Returns:
-            Tuple of (content, tool_calls) where:
-            - content: text with tool call markup stripped (the message 'content' field),
-                       or None if the entire output was tool calls
-            - tool_calls: list of ChatCompletionMessageToolCall objects,
-                          or None if no tool calls were found
-        """
-        raise NotImplementedError
-
-
-# Global parser registry: name -> parser class
-PARSER_REGISTRY: Dict[str, Type[ToolCallParser]] = {}
-
-
-def register_parser(name: str):
-    """
-    Decorator to register a parser class under a given name.
-
-    Usage:
-        @register_parser("hermes")
-        class HermesToolCallParser(ToolCallParser):
-            ...
-    """
-
-    def decorator(cls: Type[ToolCallParser]) -> Type[ToolCallParser]:
-        PARSER_REGISTRY[name] = cls
-        return cls
-
-    return decorator
-
-
-def get_parser(name: str) -> ToolCallParser:
-    """
-    Get a parser instance by name.
-
-    Args:
-        name: Parser name (e.g., "hermes", "mistral", "llama3_json")
-
-    Returns:
-        Instantiated parser
-
-    Raises:
-        KeyError: If parser name is not found in registry
-    """
-    if name not in PARSER_REGISTRY:
-        available = sorted(PARSER_REGISTRY.keys())
-        raise KeyError(
-            f"Tool call parser '{name}' not found. Available parsers: {available}"
-        )
-    return PARSER_REGISTRY[name]()
-
-
-def list_parsers() -> List[str]:
-    """Return sorted list of registered parser names."""
-    return sorted(PARSER_REGISTRY.keys())
-
-
-# Import all parser modules to trigger registration via @register_parser decorators
-# Each module registers itself when imported
-from environments.tool_call_parsers.hermes_parser import HermesToolCallParser  # noqa: E402, F401
-from environments.tool_call_parsers.longcat_parser import LongcatToolCallParser  # noqa: E402, F401
-from environments.tool_call_parsers.mistral_parser import MistralToolCallParser  # noqa: E402, F401
-from environments.tool_call_parsers.llama_parser import LlamaToolCallParser  # noqa: E402, F401
-from environments.tool_call_parsers.qwen_parser import QwenToolCallParser  # noqa: E402, F401
-from environments.tool_call_parsers.deepseek_v3_parser import DeepSeekV3ToolCallParser  # noqa: E402, F401
-from environments.tool_call_parsers.deepseek_v3_1_parser import DeepSeekV31ToolCallParser  # noqa: E402, F401
-from environments.tool_call_parsers.kimi_k2_parser import KimiK2ToolCallParser  # noqa: E402, F401
-from environments.tool_call_parsers.glm45_parser import Glm45ToolCallParser  # noqa: E402, F401
-from environments.tool_call_parsers.glm47_parser import Glm47ToolCallParser  # noqa: E402, F401
-from environments.tool_call_parsers.qwen3_coder_parser import Qwen3CoderToolCallParser  # noqa: E402, F401

environments/tool_call_parsers/deepseek_v3_1_parser.py

@@ -1,71 +0,0 @@
-"""
-DeepSeek V3.1 tool call parser.
-
-Similar to V3 but with a slightly different format:
-    <｜tool▁call▁begin｜>function_name<｜tool▁sep｜>arguments<｜tool▁call▁end｜>
-
-Note: V3 has type+name before the separator, V3.1 has name before and args after.
-
-Based on VLLM's DeepSeekV31ToolParser.extract_tool_calls()
-"""
-
-import re
-import uuid
-from typing import List, Optional
-
-from openai.types.chat.chat_completion_message_tool_call import (
-    ChatCompletionMessageToolCall,
-    Function,
-)
-
-from environments.tool_call_parsers import ParseResult, ToolCallParser, register_parser
-
-
-@register_parser("deepseek_v3_1")
-@register_parser("deepseek_v31")
-class DeepSeekV31ToolCallParser(ToolCallParser):
-    """
-    Parser for DeepSeek V3.1 tool calls.
-
-    Slightly different regex than V3: function_name comes before the separator,
-    arguments come after (no type field, no json code block wrapper).
-    """
-
-    START_TOKEN = "<｜tool▁calls▁begin｜>"
-
-    # Regex captures: function_name, function_arguments
-    PATTERN = re.compile(
-        r"<｜tool▁call▁begin｜>(?P<function_name>.*?)<｜tool▁sep｜>(?P<function_arguments>.*?)<｜tool▁call▁end｜>"
-    )
-
-    def parse(self, text: str) -> ParseResult:
-        if self.START_TOKEN not in text:
-            return text, None
-
-        try:
-            matches = self.PATTERN.findall(text)
-            if not matches:
-                return text, None
-
-            tool_calls: List[ChatCompletionMessageToolCall] = []
-            for match in matches:
-                func_name, func_args = match
-                tool_calls.append(
-                    ChatCompletionMessageToolCall(
-                        id=f"call_{uuid.uuid4().hex[:8]}",
-                        type="function",
-                        function=Function(
-                            name=func_name.strip(),
-                            arguments=func_args.strip(),
-                        ),
-                    )
-                )
-
-            if not tool_calls:
-                return text, None
-
-            content = text[: text.find(self.START_TOKEN)].strip()
-            return content if content else None, tool_calls
-
-        except Exception:
-            return text, None

environments/tool_call_parsers/deepseek_v3_parser.py

@@ -1,75 +0,0 @@
-"""
-DeepSeek V3 tool call parser.
-
-Format uses special unicode tokens:
-    <｜tool▁calls▁begin｜>
-    <｜tool▁call▁begin｜>type<｜tool▁sep｜>function_name
-    ```json
-    {"arg": "value"}
-    ```
-    <｜tool▁call▁end｜>
-    <｜tool▁calls▁end｜>
-
-Based on VLLM's DeepSeekV3ToolParser.extract_tool_calls()
-"""
-
-import re
-import uuid
-from typing import List, Optional
-
-from openai.types.chat.chat_completion_message_tool_call import (
-    ChatCompletionMessageToolCall,
-    Function,
-)
-
-from environments.tool_call_parsers import ParseResult, ToolCallParser, register_parser
-
-
-@register_parser("deepseek_v3")
-class DeepSeekV3ToolCallParser(ToolCallParser):
-    """
-    Parser for DeepSeek V3 tool calls.
-
-    Uses special unicode tokens with fullwidth angle brackets and block elements.
-    Extracts type, function name, and JSON arguments from the structured format.
-    """
-
-    START_TOKEN = "<｜tool▁calls▁begin｜>"
-
-    # Regex captures: type, function_name, function_arguments
-    PATTERN = re.compile(
-        r"<｜tool▁call▁begin｜>(?P<type>.*)<｜tool▁sep｜>(?P<function_name>.*)\n```json\n(?P<function_arguments>.*)\n```<｜tool▁call▁end｜>"
-    )
-
-    def parse(self, text: str) -> ParseResult:
-        if self.START_TOKEN not in text:
-            return text, None
-
-        try:
-            matches = self.PATTERN.findall(text)
-            if not matches:
-                return text, None
-
-            tool_calls: List[ChatCompletionMessageToolCall] = []
-            for match in matches:
-                tc_type, func_name, func_args = match
-                tool_calls.append(
-                    ChatCompletionMessageToolCall(
-                        id=f"call_{uuid.uuid4().hex[:8]}",
-                        type="function",
-                        function=Function(
-                            name=func_name.strip(),
-                            arguments=func_args.strip(),
-                        ),
-                    )
-                )
-
-            if not tool_calls:
-                return text, None
-
-            # Content is everything before the tool calls section
-            content = text[: text.find(self.START_TOKEN)].strip()
-            return content if content else None, tool_calls
-
-        except Exception:
-            return text, None

environments/tool_call_parsers/glm45_parser.py

@@ -1,109 +0,0 @@
-"""
-GLM 4.5 (GLM-4-MoE) tool call parser.
-
-Format uses custom arg_key/arg_value tags rather than standard JSON:
-    <tool_call>function_name
-    <arg_key>param1</arg_key><arg_value>value1</arg_value>
-    <arg_key>param2</arg_key><arg_value>value2</arg_value>
-    </tool_call>
-
-Values are deserialized using json.loads -> ast.literal_eval -> raw string fallback.
-
-Based on VLLM's Glm4MoeModelToolParser.extract_tool_calls()
-"""
-
-import ast
-import json
-import re
-import uuid
-from typing import Any, Dict, List, Optional
-
-from openai.types.chat.chat_completion_message_tool_call import (
-    ChatCompletionMessageToolCall,
-    Function,
-)
-
-from environments.tool_call_parsers import ParseResult, ToolCallParser, register_parser
-
-
-def _deserialize_value(value: str) -> Any:
-    """
-    Try to deserialize a string value to its native Python type.
-    Attempts json.loads, then ast.literal_eval, then returns raw string.
-    """
-    try:
-        return json.loads(value)
-    except (json.JSONDecodeError, TypeError):
-        pass
-
-    try:
-        return ast.literal_eval(value)
-    except (ValueError, SyntaxError, TypeError):
-        pass
-
-    return value
-
-
-@register_parser("glm45")
-class Glm45ToolCallParser(ToolCallParser):
-    """
-    Parser for GLM 4.5 (GLM-4-MoE) tool calls.
-
-    Uses <tool_call>...</tool_call> tags with <arg_key>/<arg_value> pairs
-    instead of standard JSON arguments.
-    """
-
-    FUNC_CALL_REGEX = re.compile(r"<tool_call>.*?</tool_call>", re.DOTALL)
-    FUNC_DETAIL_REGEX = re.compile(r"<tool_call>([^\n]*)\n(.*)</tool_call>", re.DOTALL)
-    FUNC_ARG_REGEX = re.compile(
-        r"<arg_key>(.*?)</arg_key>\s*<arg_value>(.*?)</arg_value>", re.DOTALL
-    )
-
-    START_TOKEN = "<tool_call>"
-
-    def parse(self, text: str) -> ParseResult:
-        if self.START_TOKEN not in text:
-            return text, None
-
-        try:
-            matched_calls = self.FUNC_CALL_REGEX.findall(text)
-            if not matched_calls:
-                return text, None
-
-            tool_calls: List[ChatCompletionMessageToolCall] = []
-
-            for match in matched_calls:
-                detail = self.FUNC_DETAIL_REGEX.search(match)
-                if not detail:
-                    continue
-
-                func_name = detail.group(1).strip()
-                func_args_raw = detail.group(2)
-
-                # Parse arg_key/arg_value pairs
-                pairs = self.FUNC_ARG_REGEX.findall(func_args_raw) if func_args_raw else []
-                arg_dict: Dict[str, Any] = {}
-                for key, value in pairs:
-                    arg_key = key.strip()
-                    arg_val = _deserialize_value(value.strip())
-                    arg_dict[arg_key] = arg_val
-
-                tool_calls.append(
-                    ChatCompletionMessageToolCall(
-                        id=f"call_{uuid.uuid4().hex[:8]}",
-                        type="function",
-                        function=Function(
-                            name=func_name,
-                            arguments=json.dumps(arg_dict, ensure_ascii=False),
-                        ),
-                    )
-                )
-
-            if not tool_calls:
-                return text, None
-
-            content = text[: text.find(self.START_TOKEN)].strip()
-            return content if content else None, tool_calls
-
-        except Exception:
-            return text, None

environments/tool_call_parsers/glm47_parser.py

@@ -1,35 +0,0 @@
-"""
-GLM 4.7 tool call parser.
-
-Same as GLM 4.5 but with slightly different regex patterns.
-The tool_call tags may wrap differently and arg parsing handles
-newlines between key/value pairs.
-
-Based on VLLM's Glm47MoeModelToolParser (extends Glm4MoeModelToolParser).
-"""
-
-import re
-
-from environments.tool_call_parsers import ParseResult, register_parser
-from environments.tool_call_parsers.glm45_parser import Glm45ToolCallParser
-
-
-@register_parser("glm47")
-class Glm47ToolCallParser(Glm45ToolCallParser):
-    """
-    Parser for GLM 4.7 tool calls.
-    Extends GLM 4.5 with updated regex patterns.
-    """
-
-    def __init__(self):
-        super().__init__()
-        # GLM 4.7 uses a slightly different detail regex that includes
-        # the <tool_call> wrapper and optional arg_key content
-        self.FUNC_DETAIL_REGEX = re.compile(
-            r"<tool_call>(.*?)(<arg_key>.*?)?</tool_call>", re.DOTALL
-        )
-        # GLM 4.7 handles newlines between arg_key and arg_value tags
-        self.FUNC_ARG_REGEX = re.compile(
-            r"<arg_key>(.*?)</arg_key>(?:\\n|\s)*<arg_value>(.*?)</arg_value>",
-            re.DOTALL,
-        )

environments/tool_call_parsers/hermes_parser.py

@@ -1,73 +0,0 @@
-"""
-Hermes tool call parser.
-
-Format: <tool_call>{"name": "func", "arguments": {...}}</tool_call>
-Based on VLLM's Hermes2ProToolParser.extract_tool_calls()
-"""
-
-import json
-import re
-import uuid
-from typing import List, Optional, Tuple
-
-from openai.types.chat.chat_completion_message_tool_call import (
-    ChatCompletionMessageToolCall,
-    Function,
-)
-
-from environments.tool_call_parsers import ParseResult, ToolCallParser, register_parser
-
-
-@register_parser("hermes")
-class HermesToolCallParser(ToolCallParser):
-    """
-    Parser for Hermes-format tool calls.
-
-    Matches <tool_call>...</tool_call> tags containing JSON with "name" and "arguments".
-    Also handles unclosed <tool_call> at end-of-string (truncated generation).
-    """
-
-    # Matches both closed and unclosed tool_call tags
-    PATTERN = re.compile(
-        r"<tool_call>\s*(.*?)\s*</tool_call>|<tool_call>\s*(.*)", re.DOTALL
-    )
-
-    def parse(self, text: str) -> ParseResult:
-        if "<tool_call>" not in text:
-            return text, None
-
-        try:
-            matches = self.PATTERN.findall(text)
-            if not matches:
-                return text, None
-
-            tool_calls: List[ChatCompletionMessageToolCall] = []
-            for match in matches:
-                # match is a tuple: (closed_content, unclosed_content)
-                raw_json = match[0] if match[0] else match[1]
-                if not raw_json.strip():
-                    continue
-
-                tc_data = json.loads(raw_json)
-                tool_calls.append(
-                    ChatCompletionMessageToolCall(
-                        id=f"call_{uuid.uuid4().hex[:8]}",
-                        type="function",
-                        function=Function(
-                            name=tc_data["name"],
-                            arguments=json.dumps(
-                                tc_data.get("arguments", {}), ensure_ascii=False
-                            ),
-                        ),
-                    )
-                )
-
-            if not tool_calls:
-                return text, None
-
-            # Content is everything before the first <tool_call> tag
-            content = text[: text.find("<tool_call>")].strip()
-            return content if content else None, tool_calls
-
-        except Exception:
-            return text, None

environments/tool_call_parsers/kimi_k2_parser.py

@@ -1,93 +0,0 @@
-"""
-Kimi K2 tool call parser.
-
-Format:
-    <|tool_calls_section_begin|>
-    <|tool_call_begin|>function_id:0<|tool_call_argument_begin|>{"arg": "val"}<|tool_call_end|>
-    <|tool_calls_section_end|>
-
-The function_id format is typically "functions.func_name:index" or "func_name:index".
-
-Based on VLLM's KimiK2ToolParser.extract_tool_calls()
-"""
-
-import re
-import uuid
-from typing import List, Optional
-
-from openai.types.chat.chat_completion_message_tool_call import (
-    ChatCompletionMessageToolCall,
-    Function,
-)
-
-from environments.tool_call_parsers import ParseResult, ToolCallParser, register_parser
-
-
-@register_parser("kimi_k2")
-class KimiK2ToolCallParser(ToolCallParser):
-    """
-    Parser for Kimi K2 tool calls.
-
-    Uses section begin/end tokens wrapping individual tool call begin/end tokens.
-    The tool_call_id contains the function name (after last dot, before colon).
-    """
-
-    # Support both singular and plural variants
-    START_TOKENS = [
-        "<|tool_calls_section_begin|>",
-        "<|tool_call_section_begin|>",
-    ]
-
-    # Regex captures: tool_call_id (e.g., "functions.get_weather:0"), function_arguments
-    PATTERN = re.compile(
-        r"<\|tool_call_begin\|>\s*(?P<tool_call_id>[^<]+:\d+)\s*"
-        r"<\|tool_call_argument_begin\|>\s*"
-        r"(?P<function_arguments>(?:(?!<\|tool_call_begin\|>).)*?)\s*"
-        r"<\|tool_call_end\|>",
-        re.DOTALL,
-    )
-
-    def parse(self, text: str) -> ParseResult:
-        # Check for any variant of the start token
-        has_start = any(token in text for token in self.START_TOKENS)
-        if not has_start:
-            return text, None
-
-        try:
-            matches = self.PATTERN.findall(text)
-            if not matches:
-                return text, None
-
-            tool_calls: List[ChatCompletionMessageToolCall] = []
-            for match in matches:
-                function_id, function_args = match
-
-                # Extract function name from ID format: "functions.get_weather:0" -> "get_weather"
-                function_name = function_id.split(":")[0].split(".")[-1]
-
-                tool_calls.append(
-                    ChatCompletionMessageToolCall(
-                        id=function_id,  # Preserve the original ID format
-                        type="function",
-                        function=Function(
-                            name=function_name,
-                            arguments=function_args.strip(),
-                        ),
-                    )
-                )
-
-            if not tool_calls:
-                return text, None
-
-            # Content is everything before the tool calls section
-            earliest_start = len(text)
-            for token in self.START_TOKENS:
-                idx = text.find(token)
-                if idx >= 0 and idx < earliest_start:
-                    earliest_start = idx
-
-            content = text[:earliest_start].strip()
-            return content if content else None, tool_calls
-
-        except Exception:
-            return text, None

environments/tool_call_parsers/llama_parser.py

@@ -1,96 +0,0 @@
-"""
-Llama 3.x / 4 tool call parser.
-
-Format: The model outputs JSON objects with "name" and "arguments" (or "parameters") keys.
-May be preceded by <|python_tag|> token. Supports multiple JSON objects separated
-by content or semicolons.
-
-Based on VLLM's Llama3JsonToolParser.extract_tool_calls()
-"""
-
-import json
-import re
-import uuid
-from typing import List, Optional
-
-from openai.types.chat.chat_completion_message_tool_call import (
-    ChatCompletionMessageToolCall,
-    Function,
-)
-
-from environments.tool_call_parsers import ParseResult, ToolCallParser, register_parser
-
-
-@register_parser("llama3_json")
-@register_parser("llama4_json")
-class LlamaToolCallParser(ToolCallParser):
-    """
-    Parser for Llama 3.x and 4 JSON-format tool calls.
-
-    Finds JSON objects containing "name" + ("arguments" or "parameters") keys.
-    Uses Python's json.JSONDecoder.raw_decode for robust extraction of
-    JSON objects from mixed text.
-    """
-
-    BOT_TOKEN = "<|python_tag|>"
-
-    # Regex to find the start of potential JSON objects
-    JSON_START = re.compile(r"\{")
-
-    def parse(self, text: str) -> ParseResult:
-        # Quick check: need either the bot token or a JSON brace
-        if self.BOT_TOKEN not in text and "{" not in text:
-            return text, None
-
-        try:
-            decoder = json.JSONDecoder()
-            tool_calls: List[ChatCompletionMessageToolCall] = []
-            end_index = -1  # Track where the last parsed JSON ended
-
-            for match in self.JSON_START.finditer(text):
-                start = match.start()
-                # Skip if this brace is inside a previously parsed JSON object
-                if start <= end_index:
-                    continue
-
-                try:
-                    obj, json_end = decoder.raw_decode(text[start:])
-                    end_index = start + json_end
-
-                    # Must have "name" and either "arguments" or "parameters"
-                    name = obj.get("name")
-                    args = obj.get("arguments", obj.get("parameters"))
-
-                    if not name or args is None:
-                        continue
-
-                    # Normalize arguments to JSON string
-                    if isinstance(args, dict):
-                        args = json.dumps(args, ensure_ascii=False)
-                    elif not isinstance(args, str):
-                        args = json.dumps(args, ensure_ascii=False)
-
-                    tool_calls.append(
-                        ChatCompletionMessageToolCall(
-                            id=f"call_{uuid.uuid4().hex[:8]}",
-                            type="function",
-                            function=Function(name=name, arguments=args),
-                        )
-                    )
-                except (json.JSONDecodeError, KeyError, ValueError):
-                    continue
-
-            if not tool_calls:
-                return text, None
-
-            # Content is everything before the first tool call JSON
-            # Find where the first tool call starts in the text
-            first_tc_start = text.find("{")
-            if self.BOT_TOKEN in text:
-                first_tc_start = text.find(self.BOT_TOKEN)
-            content = text[:first_tc_start].strip() if first_tc_start > 0 else None
-
-            return content, tool_calls
-
-        except Exception:
-            return text, None

environments/tool_call_parsers/longcat_parser.py

@@ -1,69 +0,0 @@
-"""
-Longcat Flash Chat tool call parser.
-
-Same as Hermes but uses <longcat_tool_call> tags instead of <tool_call>.
-Based on VLLM's LongcatFlashToolParser (extends Hermes2ProToolParser).
-"""
-
-import json
-import re
-import uuid
-from typing import List, Optional
-
-from openai.types.chat.chat_completion_message_tool_call import (
-    ChatCompletionMessageToolCall,
-    Function,
-)
-
-from environments.tool_call_parsers import ParseResult, ToolCallParser, register_parser
-
-
-@register_parser("longcat")
-class LongcatToolCallParser(ToolCallParser):
-    """
-    Parser for Longcat Flash Chat tool calls.
-    Identical logic to Hermes, just different tag names.
-    """
-
-    PATTERN = re.compile(
-        r"<longcat_tool_call>\s*(.*?)\s*</longcat_tool_call>|<longcat_tool_call>\s*(.*)",
-        re.DOTALL,
-    )
-
-    def parse(self, text: str) -> ParseResult:
-        if "<longcat_tool_call>" not in text:
-            return text, None
-
-        try:
-            matches = self.PATTERN.findall(text)
-            if not matches:
-                return text, None
-
-            tool_calls: List[ChatCompletionMessageToolCall] = []
-            for match in matches:
-                raw_json = match[0] if match[0] else match[1]
-                if not raw_json.strip():
-                    continue
-
-                tc_data = json.loads(raw_json)
-                tool_calls.append(
-                    ChatCompletionMessageToolCall(
-                        id=f"call_{uuid.uuid4().hex[:8]}",
-                        type="function",
-                        function=Function(
-                            name=tc_data["name"],
-                            arguments=json.dumps(
-                                tc_data.get("arguments", {}), ensure_ascii=False
-                            ),
-                        ),
-                    )
-                )
-
-            if not tool_calls:
-                return text, None
-
-            content = text[: text.find("<longcat_tool_call>")].strip()
-            return content if content else None, tool_calls
-
-        except Exception:
-            return text, None

environments/tool_call_parsers/mistral_parser.py

@@ -1,130 +0,0 @@
-"""
-Mistral tool call parser.
-
-Supports two formats depending on tokenizer version:
-- Pre-v11: content[TOOL_CALLS] [{"name": ..., "arguments": {...}}, ...]
-- v11+:    content[TOOL_CALLS]tool_name1{"arg": "val"}[TOOL_CALLS]tool_name2{"arg": "val"}
-
-Based on VLLM's MistralToolParser.extract_tool_calls()
-The [TOOL_CALLS] token is the bot_token used by Mistral models.
-"""
-
-import json
-import re
-import uuid
-from typing import List, Optional
-
-from openai.types.chat.chat_completion_message_tool_call import (
-    ChatCompletionMessageToolCall,
-    Function,
-)
-
-from environments.tool_call_parsers import ParseResult, ToolCallParser, register_parser
-
-
-def _generate_mistral_id() -> str:
-    """Mistral tool call IDs are 9-char alphanumeric strings."""
-    import random
-    import string
-
-    return "".join(random.choices(string.ascii_letters + string.digits, k=9))
-
-
-@register_parser("mistral")
-class MistralToolCallParser(ToolCallParser):
-    """
-    Parser for Mistral-format tool calls.
-
-    Detects format by checking if the content after [TOOL_CALLS] starts with '['
-    (pre-v11 JSON array) or with a tool name (v11+ format).
-    """
-
-    # The [TOOL_CALLS] token -- may appear as different strings depending on tokenizer
-    BOT_TOKEN = "[TOOL_CALLS]"
-
-    # Fallback regex for pre-v11 format when JSON parsing fails
-    TOOL_CALL_REGEX = re.compile(r"\[?\s*(\{.*?\})\s*\]?", re.DOTALL)
-
-    def parse(self, text: str) -> ParseResult:
-        if self.BOT_TOKEN not in text:
-            return text, None
-
-        try:
-            parts = text.split(self.BOT_TOKEN)
-            content = parts[0].strip()
-            raw_tool_calls = parts[1:]
-
-            # Detect format: if the first raw part starts with '[', it's pre-v11
-            first_raw = raw_tool_calls[0].strip() if raw_tool_calls else ""
-            is_pre_v11 = first_raw.startswith("[") or first_raw.startswith("{")
-
-            tool_calls: List[ChatCompletionMessageToolCall] = []
-
-            if not is_pre_v11:
-                # v11+ format: [TOOL_CALLS]tool_name{args}[TOOL_CALLS]tool_name2{args2}
-                for raw in raw_tool_calls:
-                    raw = raw.strip()
-                    if not raw or "{" not in raw:
-                        continue
-
-                    brace_idx = raw.find("{")
-                    tool_name = raw[:brace_idx].strip()
-                    args_str = raw[brace_idx:]
-
-                    tool_calls.append(
-                        ChatCompletionMessageToolCall(
-                            id=_generate_mistral_id(),
-                            type="function",
-                            function=Function(name=tool_name, arguments=args_str),
-                        )
-                    )
-            else:
-                # Pre-v11 format: [TOOL_CALLS] [{"name": ..., "arguments": {...}}]
-                try:
-                    parsed = json.loads(first_raw)
-                    if isinstance(parsed, dict):
-                        parsed = [parsed]
-
-                    for tc in parsed:
-                        args = tc.get("arguments", {})
-                        if isinstance(args, dict):
-                            args = json.dumps(args, ensure_ascii=False)
-
-                        tool_calls.append(
-                            ChatCompletionMessageToolCall(
-                                id=_generate_mistral_id(),
-                                type="function",
-                                function=Function(
-                                    name=tc["name"], arguments=args
-                                ),
-                            )
-                        )
-                except json.JSONDecodeError:
-                    # Fallback regex extraction
-                    match = self.TOOL_CALL_REGEX.findall(first_raw)
-                    if match:
-                        for raw_json in match:
-                            try:
-                                tc = json.loads(raw_json)
-                                args = tc.get("arguments", {})
-                                if isinstance(args, dict):
-                                    args = json.dumps(args, ensure_ascii=False)
-                                tool_calls.append(
-                                    ChatCompletionMessageToolCall(
-                                        id=_generate_mistral_id(),
-                                        type="function",
-                                        function=Function(
-                                            name=tc["name"], arguments=args
-                                        ),
-                                    )
-                                )
-                            except (json.JSONDecodeError, KeyError):
-                                continue
-
-            if not tool_calls:
-                return text, None
-
-            return content if content else None, tool_calls
-
-        except Exception:
-            return text, None

environments/tool_call_parsers/qwen3_coder_parser.py

@@ -1,163 +0,0 @@
-"""
-Qwen3-Coder tool call parser.
-
-Format uses XML-style nested tags:
-    <tool_call>
-    <function=function_name>
-    <parameter=param_name>value</parameter>
-    <parameter=param_name2>value2</parameter>
-    </function>
-    </tool_call>
-
-Parameters are extracted from <parameter=name>value</parameter> tags and
-type-converted using the schema if available, otherwise treated as strings.
-
-Based on VLLM's Qwen3CoderToolParser.extract_tool_calls()
-"""
-
-import ast
-import json
-import re
-import uuid
-from typing import Any, Dict, List, Optional
-
-from openai.types.chat.chat_completion_message_tool_call import (
-    ChatCompletionMessageToolCall,
-    Function,
-)
-
-from environments.tool_call_parsers import ParseResult, ToolCallParser, register_parser
-
-
-def _try_convert_value(value: str) -> Any:
-    """
-    Try to convert a parameter value string to a native Python type.
-    Handles null, numbers, booleans, JSON objects/arrays, and falls back to string.
-    """
-    stripped = value.strip()
-
-    # Handle null
-    if stripped.lower() == "null":
-        return None
-
-    # Try JSON first (handles objects, arrays, strings, numbers, booleans)
-    try:
-        return json.loads(stripped)
-    except (json.JSONDecodeError, TypeError):
-        pass
-
-    # Try Python literal eval (handles tuples, etc.)
-    try:
-        return ast.literal_eval(stripped)
-    except (ValueError, SyntaxError, TypeError):
-        pass
-
-    # Return as string
-    return stripped
-
-
-@register_parser("qwen3_coder")
-class Qwen3CoderToolCallParser(ToolCallParser):
-    """
-    Parser for Qwen3-Coder XML-format tool calls.
-
-    Uses nested XML tags: <tool_call><function=name><parameter=key>val</parameter></function></tool_call>
-    """
-
-    START_TOKEN = "<tool_call>"
-    FUNCTION_PREFIX = "<function="
-
-    # Find complete tool_call blocks (or unclosed at end)
-    TOOL_CALL_REGEX = re.compile(
-        r"<tool_call>(.*?)</tool_call>|<tool_call>(.*?)$", re.DOTALL
-    )
-
-    # Find function blocks within a tool_call
-    FUNCTION_REGEX = re.compile(
-        r"<function=(.*?)</function>|<function=(.*)$", re.DOTALL
-    )
-
-    # Find parameter blocks within a function
-    PARAMETER_REGEX = re.compile(
-        r"<parameter=(.*?)(?:</parameter>|(?=<parameter=)|(?=</function>)|$)",
-        re.DOTALL,
-    )
-
-    def _parse_function_call(self, function_str: str) -> Optional[ChatCompletionMessageToolCall]:
-        """Parse a single <function=name>...</function> block into a ToolCall."""
-        try:
-            # Extract function name: everything before the first '>'
-            gt_idx = function_str.index(">")
-            func_name = function_str[:gt_idx].strip()
-            params_str = function_str[gt_idx + 1:]
-
-            # Extract parameters
-            param_dict: Dict[str, Any] = {}
-            for match_text in self.PARAMETER_REGEX.findall(params_str):
-                if ">" not in match_text:
-                    continue
-                eq_idx = match_text.index(">")
-                param_name = match_text[:eq_idx].strip()
-                param_value = match_text[eq_idx + 1:]
-
-                # Clean up whitespace
-                if param_value.startswith("\n"):
-                    param_value = param_value[1:]
-                if param_value.endswith("\n"):
-                    param_value = param_value[:-1]
-
-                param_dict[param_name] = _try_convert_value(param_value)
-
-            return ChatCompletionMessageToolCall(
-                id=f"call_{uuid.uuid4().hex[:24]}",
-                type="function",
-                function=Function(
-                    name=func_name,
-                    arguments=json.dumps(param_dict, ensure_ascii=False),
-                ),
-            )
-        except (ValueError, IndexError):
-            return None
-
-    def parse(self, text: str) -> ParseResult:
-        if self.FUNCTION_PREFIX not in text:
-            return text, None
-
-        try:
-            # Find all tool_call blocks
-            tc_matches = self.TOOL_CALL_REGEX.findall(text)
-            raw_blocks = [m[0] if m[0] else m[1] for m in tc_matches]
-
-            # Fallback: if no tool_call tags, try the whole text
-            if not raw_blocks:
-                raw_blocks = [text]
-
-            # Find function blocks within each tool_call
-            function_strs: List[str] = []
-            for block in raw_blocks:
-                func_matches = self.FUNCTION_REGEX.findall(block)
-                function_strs.extend(m[0] if m[0] else m[1] for m in func_matches)
-
-            if not function_strs:
-                return text, None
-
-            # Parse each function call
-            tool_calls: List[ChatCompletionMessageToolCall] = []
-            for func_str in function_strs:
-                tc = self._parse_function_call(func_str)
-                if tc is not None:
-                    tool_calls.append(tc)
-
-            if not tool_calls:
-                return text, None
-
-            # Content before tool calls
-            first_tc = text.find(self.START_TOKEN)
-            if first_tc < 0:
-                first_tc = text.find(self.FUNCTION_PREFIX)
-            content = text[:first_tc].strip() if first_tc > 0 else None
-
-            return content, tool_calls
-
-        except Exception:
-            return text, None

environments/tool_call_parsers/qwen_parser.py

@@ -1,19 +0,0 @@
-"""
-Qwen 2.5 tool call parser.
-
-Uses the same <tool_call> format as Hermes.
-Registered as a separate parser name for clarity when using --tool-parser=qwen.
-"""
-
-from environments.tool_call_parsers import register_parser
-from environments.tool_call_parsers.hermes_parser import HermesToolCallParser
-
-
-@register_parser("qwen")
-class QwenToolCallParser(HermesToolCallParser):
-    """
-    Parser for Qwen 2.5 tool calls.
-    Same <tool_call>{"name": ..., "arguments": ...}</tool_call> format as Hermes.
-    """
-
-    pass  # Identical format -- inherits everything from Hermes

environments/tool_context.py

@@ -1,289 +0,0 @@
-"""
-ToolContext -- Unrestricted Tool Access for Reward Functions
-
-A per-rollout handle that gives reward/verification functions direct access to
-ALL hermes-agent tools, scoped to the rollout's task_id. The same task_id means
-the terminal/browser session is the SAME one the model used during its rollout --
-all state (files, processes, browser tabs) is preserved.
-
-The verifier author decides which tools to use. Nothing is hardcoded or gated.
-
-Example usage in a compute_reward():
-    async def compute_reward(self, item, result, ctx):
-        # Run tests in the model's terminal sandbox
-        test = ctx.terminal("pytest -v")
-        if test["exit_code"] == 0:
-            return 1.0
-
-        # Check if a file was created
-        content = ctx.read_file("/workspace/solution.py")
-        if content.get("content"):
-            return 0.5
-
-        return 0.0
-"""
-
-import json
-import logging
-import os
-from typing import Any, Dict, List, Optional
-
-import asyncio
-import concurrent.futures
-
-from model_tools import handle_function_call
-from tools.terminal_tool import cleanup_vm
-from tools.browser_tool import cleanup_browser
-
-logger = logging.getLogger(__name__)
-
-# Thread pool for running sync tool calls that internally use asyncio.run()
-_tool_executor = concurrent.futures.ThreadPoolExecutor(max_workers=4)
-
-
-def _run_tool_in_thread(tool_name: str, arguments: Dict[str, Any], task_id: str) -> str:
-    """
-    Run a tool call in a thread pool executor so backends that use asyncio.run()
-    internally (modal, docker) get a clean event loop.
-
-    If we're already in an async context, uses run_in_executor.
-    If not (e.g., called from sync code), runs directly.
-    """
-    try:
-        loop = asyncio.get_running_loop()
-        # We're in an async context -- need to run in thread
-        import concurrent.futures
-        with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
-            future = pool.submit(
-                handle_function_call, tool_name, arguments, task_id
-            )
-            return future.result(timeout=300)
-    except RuntimeError:
-        # No running event loop -- safe to call directly
-        return handle_function_call(tool_name, arguments, task_id)
-
-
-class ToolContext:
-    """
-    Open-ended access to all hermes-agent tools for a specific rollout.
-
-    Passed to compute_reward() so verifiers can use any tool they need:
-    terminal commands, file reads/writes, web searches, browser automation, etc.
-    All calls share the rollout's task_id for session isolation.
-    """
-
-    def __init__(self, task_id: str):
-        self.task_id = task_id
-
-    # -------------------------------------------------------------------------
-    # Terminal tools
-    # -------------------------------------------------------------------------
-
-    def terminal(self, command: str, timeout: int = 180) -> Dict[str, Any]:
-        """
-        Run a command in the rollout's terminal session.
-
-        Args:
-            command: Shell command to execute
-            timeout: Command timeout in seconds
-
-        Returns:
-            Dict with 'exit_code' (int) and 'output' (str)
-        """
-        import os
-        backend = os.getenv("TERMINAL_ENV", "local")
-        logger.debug("ToolContext.terminal [%s backend] task=%s: %s", backend, self.task_id[:8], command[:100])
-
-        # Run in thread pool so modal/docker backends' asyncio.run() doesn't deadlock
-        result = _run_tool_in_thread(
-            "terminal",
-            {"command": command, "timeout": timeout},
-            self.task_id,
-        )
-        try:
-            return json.loads(result)
-        except json.JSONDecodeError:
-            return {"exit_code": -1, "output": result}
-
-    # -------------------------------------------------------------------------
-    # File tools
-    # -------------------------------------------------------------------------
-
-    def read_file(self, path: str) -> Dict[str, Any]:
-        """
-        Read a file from the rollout's filesystem.
-
-        Args:
-            path: File path to read
-
-        Returns:
-            Dict with file content or error
-        """
-        result = handle_function_call(
-            "read_file", {"path": path}, task_id=self.task_id
-        )
-        try:
-            return json.loads(result)
-        except json.JSONDecodeError:
-            return {"error": result}
-
-    def write_file(self, path: str, content: str) -> Dict[str, Any]:
-        """
-        Write a file in the rollout's filesystem.
-
-        Args:
-            path: File path to write
-            content: Content to write
-
-        Returns:
-            Dict with success status or error
-        """
-        result = handle_function_call(
-            "write_file", {"path": path, "content": content}, task_id=self.task_id
-        )
-        try:
-            return json.loads(result)
-        except json.JSONDecodeError:
-            return {"error": result}
-
-    def search(self, query: str, path: str = ".") -> Dict[str, Any]:
-        """
-        Search for text in the rollout's filesystem.
-
-        Args:
-            query: Search query
-            path: Directory to search in
-
-        Returns:
-            Dict with search results
-        """
-        result = handle_function_call(
-            "search", {"query": query, "path": path}, task_id=self.task_id
-        )
-        try:
-            return json.loads(result)
-        except json.JSONDecodeError:
-            return {"error": result}
-
-    # -------------------------------------------------------------------------
-    # Web tools
-    # -------------------------------------------------------------------------
-
-    def web_search(self, query: str) -> Dict[str, Any]:
-        """
-        Search the web.
-
-        Args:
-            query: Search query
-
-        Returns:
-            Dict with search results
-        """
-        result = handle_function_call("web_search", {"query": query})
-        try:
-            return json.loads(result)
-        except json.JSONDecodeError:
-            return {"error": result}
-
-    def web_extract(self, urls: List[str]) -> Dict[str, Any]:
-        """
-        Extract content from URLs.
-
-        Args:
-            urls: List of URLs to extract content from
-
-        Returns:
-            Dict with extracted content
-        """
-        result = handle_function_call("web_extract", {"urls": urls})
-        try:
-            return json.loads(result)
-        except json.JSONDecodeError:
-            return {"error": result}
-
-    # -------------------------------------------------------------------------
-    # Browser tools
-    # -------------------------------------------------------------------------
-
-    def browser_navigate(self, url: str) -> Dict[str, Any]:
-        """
-        Navigate the rollout's browser session to a URL.
-
-        Args:
-            url: URL to navigate to
-
-        Returns:
-            Dict with page snapshot or error
-        """
-        result = handle_function_call(
-            "browser_navigate", {"url": url}, task_id=self.task_id
-        )
-        try:
-            return json.loads(result)
-        except json.JSONDecodeError:
-            return {"error": result}
-
-    def browser_snapshot(self) -> Dict[str, Any]:
-        """
-        Take a snapshot of the current browser page.
-
-        Returns:
-            Dict with page content/accessibility snapshot
-        """
-        result = handle_function_call(
-            "browser_snapshot", {}, task_id=self.task_id
-        )
-        try:
-            return json.loads(result)
-        except json.JSONDecodeError:
-            return {"error": result}
-
-    # -------------------------------------------------------------------------
-    # Generic tool access
-    # -------------------------------------------------------------------------
-
-    def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> str:
-        """
-        Call any hermes-agent tool by name.
-
-        This is the generic escape hatch -- if a tool doesn't have a convenience
-        wrapper above, you can call it directly here.
-
-        Args:
-            tool_name: Name of the tool (e.g., "vision_analyze", "skills_list")
-            arguments: Dict of arguments for the tool
-
-        Returns:
-            Raw JSON string result from the tool
-        """
-        return _run_tool_in_thread(tool_name, arguments, self.task_id)
-
-    # -------------------------------------------------------------------------
-    # Cleanup
-    # -------------------------------------------------------------------------
-
-    def cleanup(self):
-        """
-        Release all resources (terminal VMs, browser sessions) for this rollout.
-
-        Called automatically by the base environment via try/finally after
-        compute_reward() completes. You generally don't need to call this yourself.
-        """
-        try:
-            cleanup_vm(self.task_id)
-        except Exception as e:
-            logger.debug("VM cleanup for task %s: %s", self.task_id, e)
-
-        # Suppress browser_tool's noisy debug prints during cleanup.
-        # The cleanup still runs (safe), it just doesn't spam the console.
-        _prev_quiet = os.environ.get("HERMES_QUIET")
-        os.environ["HERMES_QUIET"] = "1"
-        try:
-            cleanup_browser(self.task_id)
-        except Exception as e:
-            logger.debug("Browser cleanup for task %s: %s", self.task_id, e)
-        finally:
-            if _prev_quiet is None:
-                os.environ.pop("HERMES_QUIET", None)
-            else:
-                os.environ["HERMES_QUIET"] = _prev_quiet

example-skill/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: example-skill
+description: An example skill demonstrating the skill file format and structure
+---
+
+# Example Skill
+
+This is an example skill file that demonstrates how to create skills for the Hermes Agent.
+
+## Skill File Format
+
+Skills are markdown files with YAML frontmatter at the top:
+
+```yaml
+---
+name: your-skill-name
+description: A brief one-line description of what this skill does
+---
+```
+
+The frontmatter fields:
+- **name**: The identifier used to reference this skill (lowercase, hyphens for spaces)
+- **description**: A brief description shown when listing skills (keep under 200 chars)
+
+## Writing Effective Skills
+
+### 1. Be Specific and Actionable
+
+Good skills provide clear, actionable instructions:
+
+```
+When reviewing code:
+1. Check for security vulnerabilities first
+2. Verify error handling is comprehensive
+3. Ensure tests cover edge cases
+```
+
+### 2. Include Examples
+
+Show concrete examples of what you want:
+
+```python
+# Good: Descriptive variable names
+user_authentication_token = get_token()
+
+# Bad: Cryptic abbreviations  
+uat = gt()
+```
+
+### 3. Define When to Use
+
+Help the agent understand when this skill applies:
+
+> Use this skill when: reviewing pull requests, auditing security, or checking code quality.
+
+## Skill Categories
+
+Consider organizing skills by purpose:
+
+- **Conventions**: Coding standards, API patterns, naming rules
+- **Workflows**: Step-by-step processes for deployments, reviews, releases
+- **Knowledge**: Domain-specific information, system architecture, gotchas
+- **Templates**: Boilerplate for common tasks, response formats
+
+## Tips
+
+1. Keep the description concise - it's shown in the skills list
+2. Use headers to organize longer skills
+3. Include code examples where helpful
+4. Reference other skills if they're related

gateway/__init__.py

@@ -1,35 +0,0 @@
-"""
-Hermes Gateway - Multi-platform messaging integration.
-
-This module provides a unified gateway for connecting the Hermes agent
-to various messaging platforms (Telegram, Discord, WhatsApp) with:
-- Session management (persistent conversations with reset policies)
-- Dynamic context injection (agent knows where messages come from)
-- Delivery routing (cron job outputs to appropriate channels)
-- Platform-specific toolsets (different capabilities per platform)
-"""
-
-from .config import GatewayConfig, PlatformConfig, HomeChannel, load_gateway_config
-from .session import (
-    SessionContext,
-    SessionStore,
-    SessionResetPolicy,
-    build_session_context_prompt,
-)
-from .delivery import DeliveryRouter, DeliveryTarget
-
-__all__ = [
-    # Config
-    "GatewayConfig",
-    "PlatformConfig", 
-    "HomeChannel",
-    "load_gateway_config",
-    # Session
-    "SessionContext",
-    "SessionStore",
-    "SessionResetPolicy",
-    "build_session_context_prompt",
-    # Delivery
-    "DeliveryRouter",
-    "DeliveryTarget",
-]

gateway/config.py

@@ -1,333 +0,0 @@
-"""
-Gateway configuration management.
-
-Handles loading and validating configuration for:
-- Connected platforms (Telegram, Discord, WhatsApp)
-- Home channels for each platform
-- Session reset policies
-- Delivery preferences
-"""
-
-import os
-import json
-from pathlib import Path
-from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Any
-from enum import Enum
-
-
-class Platform(Enum):
-    """Supported messaging platforms."""
-    LOCAL = "local"
-    TELEGRAM = "telegram"
-    DISCORD = "discord"
-    WHATSAPP = "whatsapp"
-
-
-@dataclass
-class HomeChannel:
-    """
-    Default destination for a platform.
-    
-    When a cron job specifies deliver="telegram" without a specific chat ID,
-    messages are sent to this home channel.
-    """
-    platform: Platform
-    chat_id: str
-    name: str  # Human-readable name for display
-    
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "platform": self.platform.value,
-            "chat_id": self.chat_id,
-            "name": self.name,
-        }
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "HomeChannel":
-        return cls(
-            platform=Platform(data["platform"]),
-            chat_id=str(data["chat_id"]),
-            name=data.get("name", "Home"),
-        )
-
-
-@dataclass
-class SessionResetPolicy:
-    """
-    Controls when sessions reset (lose context).
-    
-    Modes:
-    - "daily": Reset at a specific hour each day
-    - "idle": Reset after N minutes of inactivity
-    - "both": Whichever triggers first (daily boundary OR idle timeout)
-    """
-    mode: str = "both"  # "daily", "idle", or "both"
-    at_hour: int = 4  # Hour for daily reset (0-23, local time)
-    idle_minutes: int = 120  # Minutes of inactivity before reset
-    
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "mode": self.mode,
-            "at_hour": self.at_hour,
-            "idle_minutes": self.idle_minutes,
-        }
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "SessionResetPolicy":
-        return cls(
-            mode=data.get("mode", "both"),
-            at_hour=data.get("at_hour", 4),
-            idle_minutes=data.get("idle_minutes", 120),
-        )
-
-
-@dataclass
-class PlatformConfig:
-    """Configuration for a single messaging platform."""
-    enabled: bool = False
-    token: Optional[str] = None  # Bot token (Telegram, Discord)
-    api_key: Optional[str] = None  # API key if different from token
-    home_channel: Optional[HomeChannel] = None
-    
-    # Platform-specific settings
-    extra: Dict[str, Any] = field(default_factory=dict)
-    
-    def to_dict(self) -> Dict[str, Any]:
-        result = {
-            "enabled": self.enabled,
-            "extra": self.extra,
-        }
-        if self.token:
-            result["token"] = self.token
-        if self.api_key:
-            result["api_key"] = self.api_key
-        if self.home_channel:
-            result["home_channel"] = self.home_channel.to_dict()
-        return result
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "PlatformConfig":
-        home_channel = None
-        if "home_channel" in data:
-            home_channel = HomeChannel.from_dict(data["home_channel"])
-        
-        return cls(
-            enabled=data.get("enabled", False),
-            token=data.get("token"),
-            api_key=data.get("api_key"),
-            home_channel=home_channel,
-            extra=data.get("extra", {}),
-        )
-
-
-@dataclass
-class GatewayConfig:
-    """
-    Main gateway configuration.
-    
-    Manages all platform connections, session policies, and delivery settings.
-    """
-    # Platform configurations
-    platforms: Dict[Platform, PlatformConfig] = field(default_factory=dict)
-    
-    # Session reset policies by type
-    default_reset_policy: SessionResetPolicy = field(default_factory=SessionResetPolicy)
-    reset_by_type: Dict[str, SessionResetPolicy] = field(default_factory=dict)
-    reset_by_platform: Dict[Platform, SessionResetPolicy] = field(default_factory=dict)
-    
-    # Reset trigger commands
-    reset_triggers: List[str] = field(default_factory=lambda: ["/new", "/reset"])
-    
-    # Storage paths
-    sessions_dir: Path = field(default_factory=lambda: Path.home() / ".hermes" / "sessions")
-    
-    # Delivery settings
-    always_log_local: bool = True  # Always save cron outputs to local files
-    
-    def get_connected_platforms(self) -> List[Platform]:
-        """Return list of platforms that are enabled and configured."""
-        connected = []
-        for platform, config in self.platforms.items():
-            if config.enabled and (config.token or config.api_key):
-                connected.append(platform)
-        return connected
-    
-    def get_home_channel(self, platform: Platform) -> Optional[HomeChannel]:
-        """Get the home channel for a platform."""
-        config = self.platforms.get(platform)
-        if config:
-            return config.home_channel
-        return None
-    
-    def get_reset_policy(
-        self, 
-        platform: Optional[Platform] = None,
-        session_type: Optional[str] = None
-    ) -> SessionResetPolicy:
-        """
-        Get the appropriate reset policy for a session.
-        
-        Priority: platform override > type override > default
-        """
-        # Platform-specific override takes precedence
-        if platform and platform in self.reset_by_platform:
-            return self.reset_by_platform[platform]
-        
-        # Type-specific override (dm, group, thread)
-        if session_type and session_type in self.reset_by_type:
-            return self.reset_by_type[session_type]
-        
-        return self.default_reset_policy
-    
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "platforms": {
-                p.value: c.to_dict() for p, c in self.platforms.items()
-            },
-            "default_reset_policy": self.default_reset_policy.to_dict(),
-            "reset_by_type": {
-                k: v.to_dict() for k, v in self.reset_by_type.items()
-            },
-            "reset_by_platform": {
-                p.value: v.to_dict() for p, v in self.reset_by_platform.items()
-            },
-            "reset_triggers": self.reset_triggers,
-            "sessions_dir": str(self.sessions_dir),
-            "always_log_local": self.always_log_local,
-        }
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "GatewayConfig":
-        platforms = {}
-        for platform_name, platform_data in data.get("platforms", {}).items():
-            try:
-                platform = Platform(platform_name)
-                platforms[platform] = PlatformConfig.from_dict(platform_data)
-            except ValueError:
-                pass  # Skip unknown platforms
-        
-        reset_by_type = {}
-        for type_name, policy_data in data.get("reset_by_type", {}).items():
-            reset_by_type[type_name] = SessionResetPolicy.from_dict(policy_data)
-        
-        reset_by_platform = {}
-        for platform_name, policy_data in data.get("reset_by_platform", {}).items():
-            try:
-                platform = Platform(platform_name)
-                reset_by_platform[platform] = SessionResetPolicy.from_dict(policy_data)
-            except ValueError:
-                pass
-        
-        default_policy = SessionResetPolicy()
-        if "default_reset_policy" in data:
-            default_policy = SessionResetPolicy.from_dict(data["default_reset_policy"])
-        
-        sessions_dir = Path.home() / ".hermes" / "sessions"
-        if "sessions_dir" in data:
-            sessions_dir = Path(data["sessions_dir"])
-        
-        return cls(
-            platforms=platforms,
-            default_reset_policy=default_policy,
-            reset_by_type=reset_by_type,
-            reset_by_platform=reset_by_platform,
-            reset_triggers=data.get("reset_triggers", ["/new", "/reset"]),
-            sessions_dir=sessions_dir,
-            always_log_local=data.get("always_log_local", True),
-        )
-
-
-def load_gateway_config() -> GatewayConfig:
-    """
-    Load gateway configuration from multiple sources.
-    
-    Priority (highest to lowest):
-    1. Environment variables
-    2. ~/.hermes/gateway.json
-    3. cli-config.yaml gateway section
-    4. Defaults
-    """
-    config = GatewayConfig()
-    
-    # Try loading from ~/.hermes/gateway.json
-    gateway_config_path = Path.home() / ".hermes" / "gateway.json"
-    if gateway_config_path.exists():
-        try:
-            with open(gateway_config_path, "r") as f:
-                data = json.load(f)
-                config = GatewayConfig.from_dict(data)
-        except Exception as e:
-            print(f"[gateway] Warning: Failed to load {gateway_config_path}: {e}")
-    
-    # Override with environment variables
-    _apply_env_overrides(config)
-    
-    return config
-
-
-def _apply_env_overrides(config: GatewayConfig) -> None:
-    """Apply environment variable overrides to config."""
-    
-    # Telegram
-    telegram_token = os.getenv("TELEGRAM_BOT_TOKEN")
-    if telegram_token:
-        if Platform.TELEGRAM not in config.platforms:
-            config.platforms[Platform.TELEGRAM] = PlatformConfig()
-        config.platforms[Platform.TELEGRAM].enabled = True
-        config.platforms[Platform.TELEGRAM].token = telegram_token
-    
-    telegram_home = os.getenv("TELEGRAM_HOME_CHANNEL")
-    if telegram_home and Platform.TELEGRAM in config.platforms:
-        config.platforms[Platform.TELEGRAM].home_channel = HomeChannel(
-            platform=Platform.TELEGRAM,
-            chat_id=telegram_home,
-            name=os.getenv("TELEGRAM_HOME_CHANNEL_NAME", "Home"),
-        )
-    
-    # Discord
-    discord_token = os.getenv("DISCORD_BOT_TOKEN")
-    if discord_token:
-        if Platform.DISCORD not in config.platforms:
-            config.platforms[Platform.DISCORD] = PlatformConfig()
-        config.platforms[Platform.DISCORD].enabled = True
-        config.platforms[Platform.DISCORD].token = discord_token
-    
-    discord_home = os.getenv("DISCORD_HOME_CHANNEL")
-    if discord_home and Platform.DISCORD in config.platforms:
-        config.platforms[Platform.DISCORD].home_channel = HomeChannel(
-            platform=Platform.DISCORD,
-            chat_id=discord_home,
-            name=os.getenv("DISCORD_HOME_CHANNEL_NAME", "Home"),
-        )
-    
-    # WhatsApp (typically uses different auth mechanism)
-    whatsapp_enabled = os.getenv("WHATSAPP_ENABLED", "").lower() in ("true", "1", "yes")
-    if whatsapp_enabled:
-        if Platform.WHATSAPP not in config.platforms:
-            config.platforms[Platform.WHATSAPP] = PlatformConfig()
-        config.platforms[Platform.WHATSAPP].enabled = True
-    
-    # Session settings
-    idle_minutes = os.getenv("SESSION_IDLE_MINUTES")
-    if idle_minutes:
-        try:
-            config.default_reset_policy.idle_minutes = int(idle_minutes)
-        except ValueError:
-            pass
-    
-    reset_hour = os.getenv("SESSION_RESET_HOUR")
-    if reset_hour:
-        try:
-            config.default_reset_policy.at_hour = int(reset_hour)
-        except ValueError:
-            pass
-
-
-def save_gateway_config(config: GatewayConfig) -> None:
-    """Save gateway configuration to ~/.hermes/gateway.json."""
-    gateway_config_path = Path.home() / ".hermes" / "gateway.json"
-    gateway_config_path.parent.mkdir(parents=True, exist_ok=True)
-    
-    with open(gateway_config_path, "w") as f:
-        json.dump(config.to_dict(), f, indent=2)

gateway/delivery.py

@@ -1,318 +0,0 @@
-"""
-Delivery routing for cron job outputs and agent responses.
-
-Routes messages to the appropriate destination based on:
-- Explicit targets (e.g., "telegram:123456789")
-- Platform home channels (e.g., "telegram" → home channel)
-- Origin (back to where the job was created)
-- Local (always saved to files)
-"""
-
-import json
-from pathlib import Path
-from datetime import datetime
-from dataclasses import dataclass
-from typing import Dict, List, Optional, Any, Union
-from enum import Enum
-
-from .config import Platform, GatewayConfig, HomeChannel
-from .session import SessionSource
-
-
-@dataclass
-class DeliveryTarget:
-    """
-    A single delivery target.
-    
-    Represents where a message should be sent:
-    - "origin" → back to source
-    - "local" → save to local files
-    - "telegram" → Telegram home channel
-    - "telegram:123456" → specific Telegram chat
-    """
-    platform: Platform
-    chat_id: Optional[str] = None  # None means use home channel
-    is_origin: bool = False
-    is_explicit: bool = False  # True if chat_id was explicitly specified
-    
-    @classmethod
-    def parse(cls, target: str, origin: Optional[SessionSource] = None) -> "DeliveryTarget":
-        """
-        Parse a delivery target string.
-        
-        Formats:
-        - "origin" → back to source
-        - "local" → local files only
-        - "telegram" → Telegram home channel
-        - "telegram:123456" → specific Telegram chat
-        """
-        target = target.strip().lower()
-        
-        if target == "origin":
-            if origin:
-                return cls(
-                    platform=origin.platform,
-                    chat_id=origin.chat_id,
-                    is_origin=True,
-                )
-            else:
-                # Fallback to local if no origin
-                return cls(platform=Platform.LOCAL, is_origin=True)
-        
-        if target == "local":
-            return cls(platform=Platform.LOCAL)
-        
-        # Check for platform:chat_id format
-        if ":" in target:
-            platform_str, chat_id = target.split(":", 1)
-            try:
-                platform = Platform(platform_str)
-                return cls(platform=platform, chat_id=chat_id, is_explicit=True)
-            except ValueError:
-                # Unknown platform, treat as local
-                return cls(platform=Platform.LOCAL)
-        
-        # Just a platform name (use home channel)
-        try:
-            platform = Platform(target)
-            return cls(platform=platform)
-        except ValueError:
-            # Unknown platform, treat as local
-            return cls(platform=Platform.LOCAL)
-    
-    def to_string(self) -> str:
-        """Convert back to string format."""
-        if self.is_origin:
-            return "origin"
-        if self.platform == Platform.LOCAL:
-            return "local"
-        if self.chat_id:
-            return f"{self.platform.value}:{self.chat_id}"
-        return self.platform.value
-
-
-class DeliveryRouter:
-    """
-    Routes messages to appropriate destinations.
-    
-    Handles the logic of resolving delivery targets and dispatching
-    messages to the right platform adapters.
-    """
-    
-    def __init__(self, config: GatewayConfig, adapters: Dict[Platform, Any] = None):
-        """
-        Initialize the delivery router.
-        
-        Args:
-            config: Gateway configuration
-            adapters: Dict mapping platforms to their adapter instances
-        """
-        self.config = config
-        self.adapters = adapters or {}
-        self.output_dir = Path.home() / ".hermes" / "cron" / "output"
-    
-    def resolve_targets(
-        self,
-        deliver: Union[str, List[str]],
-        origin: Optional[SessionSource] = None
-    ) -> List[DeliveryTarget]:
-        """
-        Resolve delivery specification to concrete targets.
-        
-        Args:
-            deliver: Delivery spec - "origin", "telegram", ["local", "discord"], etc.
-            origin: The source where the request originated (for "origin" target)
-        
-        Returns:
-            List of resolved delivery targets
-        """
-        if isinstance(deliver, str):
-            deliver = [deliver]
-        
-        targets = []
-        seen_platforms = set()
-        
-        for target_str in deliver:
-            target = DeliveryTarget.parse(target_str, origin)
-            
-            # Resolve home channel if needed
-            if target.chat_id is None and target.platform != Platform.LOCAL:
-                home = self.config.get_home_channel(target.platform)
-                if home:
-                    target.chat_id = home.chat_id
-                else:
-                    # No home channel configured, skip this platform
-                    continue
-            
-            # Deduplicate
-            key = (target.platform, target.chat_id)
-            if key not in seen_platforms:
-                seen_platforms.add(key)
-                targets.append(target)
-        
-        # Always include local if configured
-        if self.config.always_log_local:
-            local_key = (Platform.LOCAL, None)
-            if local_key not in seen_platforms:
-                targets.append(DeliveryTarget(platform=Platform.LOCAL))
-        
-        return targets
-    
-    async def deliver(
-        self,
-        content: str,
-        targets: List[DeliveryTarget],
-        job_id: Optional[str] = None,
-        job_name: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
-        """
-        Deliver content to all specified targets.
-        
-        Args:
-            content: The message/output to deliver
-            targets: List of delivery targets
-            job_id: Optional job ID (for cron jobs)
-            job_name: Optional job name
-            metadata: Additional metadata to include
-        
-        Returns:
-            Dict with delivery results per target
-        """
-        results = {}
-        
-        for target in targets:
-            try:
-                if target.platform == Platform.LOCAL:
-                    result = self._deliver_local(content, job_id, job_name, metadata)
-                else:
-                    result = await self._deliver_to_platform(target, content, metadata)
-                
-                results[target.to_string()] = {
-                    "success": True,
-                    "result": result
-                }
-            except Exception as e:
-                results[target.to_string()] = {
-                    "success": False,
-                    "error": str(e)
-                }
-        
-        return results
-    
-    def _deliver_local(
-        self,
-        content: str,
-        job_id: Optional[str],
-        job_name: Optional[str],
-        metadata: Optional[Dict[str, Any]]
-    ) -> Dict[str, Any]:
-        """Save content to local files."""
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        
-        if job_id:
-            output_path = self.output_dir / job_id / f"{timestamp}.md"
-        else:
-            output_path = self.output_dir / "misc" / f"{timestamp}.md"
-        
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        
-        # Build the output document
-        lines = []
-        if job_name:
-            lines.append(f"# {job_name}")
-        else:
-            lines.append("# Delivery Output")
-        
-        lines.append("")
-        lines.append(f"**Timestamp:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-        
-        if job_id:
-            lines.append(f"**Job ID:** {job_id}")
-        
-        if metadata:
-            for key, value in metadata.items():
-                lines.append(f"**{key}:** {value}")
-        
-        lines.append("")
-        lines.append("---")
-        lines.append("")
-        lines.append(content)
-        
-        output_path.write_text("\n".join(lines))
-        
-        return {
-            "path": str(output_path),
-            "timestamp": timestamp
-        }
-    
-    async def _deliver_to_platform(
-        self,
-        target: DeliveryTarget,
-        content: str,
-        metadata: Optional[Dict[str, Any]]
-    ) -> Dict[str, Any]:
-        """Deliver content to a messaging platform."""
-        adapter = self.adapters.get(target.platform)
-        
-        if not adapter:
-            raise ValueError(f"No adapter configured for {target.platform.value}")
-        
-        if not target.chat_id:
-            raise ValueError(f"No chat ID for {target.platform.value} delivery")
-        
-        # Call the adapter's send method
-        # Adapters should implement: async def send(chat_id: str, content: str) -> Dict
-        return await adapter.send(target.chat_id, content, metadata=metadata)
-
-
-def parse_deliver_spec(
-    deliver: Optional[Union[str, List[str]]],
-    origin: Optional[SessionSource] = None,
-    default: str = "origin"
-) -> Union[str, List[str]]:
-    """
-    Normalize a delivery specification.
-    
-    If None or empty, returns the default.
-    """
-    if not deliver:
-        return default
-    return deliver
-
-
-def build_delivery_context_for_tool(
-    config: GatewayConfig,
-    origin: Optional[SessionSource] = None
-) -> Dict[str, Any]:
-    """
-    Build context for the schedule_cronjob tool to understand delivery options.
-    
-    This is passed to the tool so it can validate and explain delivery targets.
-    """
-    connected = config.get_connected_platforms()
-    
-    options = {
-        "origin": {
-            "description": "Back to where this job was created",
-            "available": origin is not None,
-        },
-        "local": {
-            "description": "Save to local files only",
-            "available": True,
-        }
-    }
-    
-    for platform in connected:
-        home = config.get_home_channel(platform)
-        options[platform.value] = {
-            "description": f"{platform.value.title()} home channel",
-            "available": True,
-            "home_channel": home.to_dict() if home else None,
-        }
-    
-    return {
-        "origin": origin.to_dict() if origin else None,
-        "options": options,
-        "always_log_local": config.always_log_local,
-    }

gateway/platforms/__init__.py

@@ -1,17 +0,0 @@
-"""
-Platform adapters for messaging integrations.
-
-Each adapter handles:
-- Receiving messages from a platform
-- Sending messages/responses back
-- Platform-specific authentication
-- Message formatting and media handling
-"""
-
-from .base import BasePlatformAdapter, MessageEvent, SendResult
-
-__all__ = [
-    "BasePlatformAdapter",
-    "MessageEvent",
-    "SendResult",
-]

gateway/platforms/base.py

@@ -1,365 +0,0 @@
-"""
-Base platform adapter interface.
-
-All platform adapters (Telegram, Discord, WhatsApp) inherit from this
-and implement the required methods.
-"""
-
-import asyncio
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from datetime import datetime
-from typing import Dict, List, Optional, Any, Callable, Awaitable
-from enum import Enum
-
-import sys
-sys.path.insert(0, str(__file__).rsplit("/", 3)[0])
-
-from gateway.config import Platform, PlatformConfig
-from gateway.session import SessionSource
-
-
-class MessageType(Enum):
-    """Types of incoming messages."""
-    TEXT = "text"
-    PHOTO = "photo"
-    VIDEO = "video"
-    AUDIO = "audio"
-    VOICE = "voice"
-    DOCUMENT = "document"
-    STICKER = "sticker"
-    COMMAND = "command"  # /command style
-
-
-@dataclass
-class MessageEvent:
-    """
-    Incoming message from a platform.
-    
-    Normalized representation that all adapters produce.
-    """
-    # Message content
-    text: str
-    message_type: MessageType = MessageType.TEXT
-    
-    # Source information
-    source: SessionSource = None
-    
-    # Original platform data
-    raw_message: Any = None
-    message_id: Optional[str] = None
-    
-    # Media attachments
-    media_urls: List[str] = field(default_factory=list)
-    media_types: List[str] = field(default_factory=list)
-    
-    # Reply context
-    reply_to_message_id: Optional[str] = None
-    
-    # Timestamps
-    timestamp: datetime = field(default_factory=datetime.now)
-    
-    def is_command(self) -> bool:
-        """Check if this is a command message (e.g., /new, /reset)."""
-        return self.text.startswith("/")
-    
-    def get_command(self) -> Optional[str]:
-        """Extract command name if this is a command message."""
-        if not self.is_command():
-            return None
-        # Split on space and get first word, strip the /
-        parts = self.text.split(maxsplit=1)
-        return parts[0][1:].lower() if parts else None
-    
-    def get_command_args(self) -> str:
-        """Get the arguments after a command."""
-        if not self.is_command():
-            return self.text
-        parts = self.text.split(maxsplit=1)
-        return parts[1] if len(parts) > 1 else ""
-
-
-@dataclass 
-class SendResult:
-    """Result of sending a message."""
-    success: bool
-    message_id: Optional[str] = None
-    error: Optional[str] = None
-    raw_response: Any = None
-
-
-# Type for message handlers
-MessageHandler = Callable[[MessageEvent], Awaitable[Optional[str]]]
-
-
-class BasePlatformAdapter(ABC):
-    """
-    Base class for platform adapters.
-    
-    Subclasses implement platform-specific logic for:
-    - Connecting and authenticating
-    - Receiving messages
-    - Sending messages/responses
-    - Handling media
-    """
-    
-    def __init__(self, config: PlatformConfig, platform: Platform):
-        self.config = config
-        self.platform = platform
-        self._message_handler: Optional[MessageHandler] = None
-        self._running = False
-        
-        # Track active message handlers per session for interrupt support
-        # Key: session_key (e.g., chat_id), Value: (event, asyncio.Event for interrupt)
-        self._active_sessions: Dict[str, asyncio.Event] = {}
-        self._pending_messages: Dict[str, MessageEvent] = {}
-    
-    @property
-    def name(self) -> str:
-        """Human-readable name for this adapter."""
-        return self.platform.value.title()
-    
-    @property
-    def is_connected(self) -> bool:
-        """Check if adapter is currently connected."""
-        return self._running
-    
-    def set_message_handler(self, handler: MessageHandler) -> None:
-        """
-        Set the handler for incoming messages.
-        
-        The handler receives a MessageEvent and should return
-        an optional response string.
-        """
-        self._message_handler = handler
-    
-    @abstractmethod
-    async def connect(self) -> bool:
-        """
-        Connect to the platform and start receiving messages.
-        
-        Returns True if connection was successful.
-        """
-        pass
-    
-    @abstractmethod
-    async def disconnect(self) -> None:
-        """Disconnect from the platform."""
-        pass
-    
-    @abstractmethod
-    async def send(
-        self,
-        chat_id: str,
-        content: str,
-        reply_to: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None
-    ) -> SendResult:
-        """
-        Send a message to a chat.
-        
-        Args:
-            chat_id: The chat/channel ID to send to
-            content: Message content (may be markdown)
-            reply_to: Optional message ID to reply to
-            metadata: Additional platform-specific options
-        
-        Returns:
-            SendResult with success status and message ID
-        """
-        pass
-    
-    async def send_typing(self, chat_id: str) -> None:
-        """
-        Send a typing indicator.
-        
-        Override in subclasses if the platform supports it.
-        """
-        pass
-    
-    async def _keep_typing(self, chat_id: str, interval: float = 2.0) -> None:
-        """
-        Continuously send typing indicator until cancelled.
-        
-        Telegram/Discord typing status expires after ~5 seconds, so we refresh every 2
-        to recover quickly after progress messages interrupt it.
-        """
-        try:
-            while True:
-                await self.send_typing(chat_id)
-                await asyncio.sleep(interval)
-        except asyncio.CancelledError:
-            pass  # Normal cancellation when handler completes
-    
-    async def handle_message(self, event: MessageEvent) -> None:
-        """
-        Process an incoming message.
-        
-        This method returns quickly by spawning background tasks.
-        This allows new messages to be processed even while an agent is running,
-        enabling interruption support.
-        """
-        if not self._message_handler:
-            return
-        
-        session_key = event.source.chat_id
-        
-        # Check if there's already an active handler for this session
-        if session_key in self._active_sessions:
-            # Store this as a pending message - it will interrupt the running agent
-            print(f"[{self.name}] ⚡ New message while session {session_key} is active - triggering interrupt")
-            self._pending_messages[session_key] = event
-            # Signal the interrupt (the processing task checks this)
-            self._active_sessions[session_key].set()
-            return  # Don't process now - will be handled after current task finishes
-        
-        # Spawn background task to process this message
-        asyncio.create_task(self._process_message_background(event, session_key))
-    
-    async def _process_message_background(self, event: MessageEvent, session_key: str) -> None:
-        """Background task that actually processes the message."""
-        # Create interrupt event for this session
-        interrupt_event = asyncio.Event()
-        self._active_sessions[session_key] = interrupt_event
-        
-        # Start continuous typing indicator (refreshes every 2 seconds)
-        typing_task = asyncio.create_task(self._keep_typing(event.source.chat_id))
-        
-        try:
-            # Call the handler (this can take a while with tool calls)
-            response = await self._message_handler(event)
-            
-            # Send response if any
-            if response:
-                result = await self.send(
-                    chat_id=event.source.chat_id,
-                    content=response,
-                    reply_to=event.message_id
-                )
-                
-                # Log send failures (don't raise - user already saw tool progress)
-                if not result.success:
-                    print(f"[{self.name}] Failed to send response: {result.error}")
-                    # Try sending without markdown as fallback
-                    fallback_result = await self.send(
-                        chat_id=event.source.chat_id,
-                        content=f"(Response formatting failed, plain text:)\n\n{response[:3500]}",
-                        reply_to=event.message_id
-                    )
-                    if not fallback_result.success:
-                        print(f"[{self.name}] Fallback send also failed: {fallback_result.error}")
-            
-            # Check if there's a pending message that was queued during our processing
-            if session_key in self._pending_messages:
-                pending_event = self._pending_messages.pop(session_key)
-                print(f"[{self.name}] 📨 Processing queued message from interrupt")
-                # Clean up current session before processing pending
-                if session_key in self._active_sessions:
-                    del self._active_sessions[session_key]
-                typing_task.cancel()
-                try:
-                    await typing_task
-                except asyncio.CancelledError:
-                    pass
-                # Process pending message in new background task
-                await self._process_message_background(pending_event, session_key)
-                return  # Already cleaned up
-                
-        except Exception as e:
-            print(f"[{self.name}] Error handling message: {e}")
-            import traceback
-            traceback.print_exc()
-        finally:
-            # Stop typing indicator
-            typing_task.cancel()
-            try:
-                await typing_task
-            except asyncio.CancelledError:
-                pass
-            # Clean up session tracking
-            if session_key in self._active_sessions:
-                del self._active_sessions[session_key]
-    
-    def has_pending_interrupt(self, session_key: str) -> bool:
-        """Check if there's a pending interrupt for a session."""
-        return session_key in self._active_sessions and self._active_sessions[session_key].is_set()
-    
-    def get_pending_message(self, session_key: str) -> Optional[MessageEvent]:
-        """Get and clear any pending message for a session."""
-        return self._pending_messages.get(session_key)
-    
-    def build_source(
-        self,
-        chat_id: str,
-        chat_name: Optional[str] = None,
-        chat_type: str = "dm",
-        user_id: Optional[str] = None,
-        user_name: Optional[str] = None,
-        thread_id: Optional[str] = None
-    ) -> SessionSource:
-        """Helper to build a SessionSource for this platform."""
-        return SessionSource(
-            platform=self.platform,
-            chat_id=str(chat_id),
-            chat_name=chat_name,
-            chat_type=chat_type,
-            user_id=str(user_id) if user_id else None,
-            user_name=user_name,
-            thread_id=str(thread_id) if thread_id else None,
-        )
-    
-    @abstractmethod
-    async def get_chat_info(self, chat_id: str) -> Dict[str, Any]:
-        """
-        Get information about a chat/channel.
-        
-        Returns dict with at least:
-        - name: Chat name
-        - type: "dm", "group", "channel"
-        """
-        pass
-    
-    def format_message(self, content: str) -> str:
-        """
-        Format a message for this platform.
-        
-        Override in subclasses to handle platform-specific formatting
-        (e.g., Telegram MarkdownV2, Discord markdown).
-        
-        Default implementation returns content as-is.
-        """
-        return content
-    
-    def truncate_message(self, content: str, max_length: int = 4096) -> List[str]:
-        """
-        Split a long message into chunks.
-        
-        Args:
-            content: The full message content
-            max_length: Maximum length per chunk (platform-specific)
-        
-        Returns:
-            List of message chunks
-        """
-        if len(content) <= max_length:
-            return [content]
-        
-        chunks = []
-        while content:
-            if len(content) <= max_length:
-                chunks.append(content)
-                break
-            
-            # Try to split at a newline
-            split_idx = content.rfind("\n", 0, max_length)
-            if split_idx == -1:
-                # No newline, split at space
-                split_idx = content.rfind(" ", 0, max_length)
-            if split_idx == -1:
-                # No space either, hard split
-                split_idx = max_length
-            
-            chunks.append(content[:split_idx])
-            content = content[split_idx:].lstrip()
-        
-        return chunks

gateway/platforms/discord.py

@@ -1,297 +0,0 @@
-"""
-Discord platform adapter.
-
-Uses discord.py library for:
-- Receiving messages from servers and DMs
-- Sending responses back
-- Handling threads and channels
-"""
-
-import asyncio
-from typing import Dict, List, Optional, Any
-
-try:
-    import discord
-    from discord import Message as DiscordMessage, Intents
-    from discord.ext import commands
-    DISCORD_AVAILABLE = True
-except ImportError:
-    DISCORD_AVAILABLE = False
-    discord = None
-    DiscordMessage = Any
-    Intents = Any
-    commands = None
-
-import sys
-sys.path.insert(0, str(__file__).rsplit("/", 3)[0])
-
-from gateway.config import Platform, PlatformConfig
-from gateway.platforms.base import (
-    BasePlatformAdapter,
-    MessageEvent,
-    MessageType,
-    SendResult,
-)
-
-
-def check_discord_requirements() -> bool:
-    """Check if Discord dependencies are available."""
-    return DISCORD_AVAILABLE
-
-
-class DiscordAdapter(BasePlatformAdapter):
-    """
-    Discord bot adapter.
-    
-    Handles:
-    - Receiving messages from servers and DMs
-    - Sending responses with Discord markdown
-    - Thread support
-    - Slash commands (future)
-    """
-    
-    # Discord message limits
-    MAX_MESSAGE_LENGTH = 2000
-    
-    def __init__(self, config: PlatformConfig):
-        super().__init__(config, Platform.DISCORD)
-        self._client: Optional[commands.Bot] = None
-        self._ready_event = asyncio.Event()
-    
-    async def connect(self) -> bool:
-        """Connect to Discord and start receiving events."""
-        if not DISCORD_AVAILABLE:
-            print(f"[{self.name}] discord.py not installed. Run: pip install discord.py")
-            return False
-        
-        if not self.config.token:
-            print(f"[{self.name}] No bot token configured")
-            return False
-        
-        try:
-            # Set up intents
-            intents = Intents.default()
-            intents.message_content = True
-            intents.dm_messages = True
-            intents.guild_messages = True
-            
-            # Create bot
-            self._client = commands.Bot(
-                command_prefix="!",  # Not really used, we handle raw messages
-                intents=intents,
-            )
-            
-            # Register event handlers
-            @self._client.event
-            async def on_ready():
-                print(f"[{self.name}] Connected as {self._client.user}")
-                self._ready_event.set()
-            
-            @self._client.event
-            async def on_message(message: DiscordMessage):
-                # Ignore bot's own messages
-                if message.author == self._client.user:
-                    return
-                await self._handle_message(message)
-            
-            # Start the bot in background
-            asyncio.create_task(self._client.start(self.config.token))
-            
-            # Wait for ready
-            await asyncio.wait_for(self._ready_event.wait(), timeout=30)
-            
-            self._running = True
-            return True
-            
-        except asyncio.TimeoutError:
-            print(f"[{self.name}] Timeout waiting for connection")
-            return False
-        except Exception as e:
-            print(f"[{self.name}] Failed to connect: {e}")
-            return False
-    
-    async def disconnect(self) -> None:
-        """Disconnect from Discord."""
-        if self._client:
-            try:
-                await self._client.close()
-            except Exception as e:
-                print(f"[{self.name}] Error during disconnect: {e}")
-        
-        self._running = False
-        self._client = None
-        self._ready_event.clear()
-        print(f"[{self.name}] Disconnected")
-    
-    async def send(
-        self,
-        chat_id: str,
-        content: str,
-        reply_to: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None
-    ) -> SendResult:
-        """Send a message to a Discord channel."""
-        if not self._client:
-            return SendResult(success=False, error="Not connected")
-        
-        try:
-            # Get the channel
-            channel = self._client.get_channel(int(chat_id))
-            if not channel:
-                channel = await self._client.fetch_channel(int(chat_id))
-            
-            if not channel:
-                return SendResult(success=False, error=f"Channel {chat_id} not found")
-            
-            # Format and split message if needed
-            formatted = self.format_message(content)
-            chunks = self.truncate_message(formatted, self.MAX_MESSAGE_LENGTH)
-            
-            message_ids = []
-            reference = None
-            
-            if reply_to:
-                try:
-                    ref_msg = await channel.fetch_message(int(reply_to))
-                    reference = ref_msg
-                except Exception:
-                    pass  # Ignore if we can't find the referenced message
-            
-            for i, chunk in enumerate(chunks):
-                msg = await channel.send(
-                    content=chunk,
-                    reference=reference if i == 0 else None,
-                )
-                message_ids.append(str(msg.id))
-            
-            return SendResult(
-                success=True,
-                message_id=message_ids[0] if message_ids else None,
-                raw_response={"message_ids": message_ids}
-            )
-            
-        except Exception as e:
-            return SendResult(success=False, error=str(e))
-    
-    async def send_typing(self, chat_id: str) -> None:
-        """Send typing indicator."""
-        if self._client:
-            try:
-                channel = self._client.get_channel(int(chat_id))
-                if channel:
-                    await channel.typing()
-            except Exception:
-                pass  # Ignore typing indicator failures
-    
-    async def get_chat_info(self, chat_id: str) -> Dict[str, Any]:
-        """Get information about a Discord channel."""
-        if not self._client:
-            return {"name": "Unknown", "type": "dm"}
-        
-        try:
-            channel = self._client.get_channel(int(chat_id))
-            if not channel:
-                channel = await self._client.fetch_channel(int(chat_id))
-            
-            if not channel:
-                return {"name": str(chat_id), "type": "dm"}
-            
-            # Determine channel type
-            if isinstance(channel, discord.DMChannel):
-                chat_type = "dm"
-                name = channel.recipient.name if channel.recipient else str(chat_id)
-            elif isinstance(channel, discord.Thread):
-                chat_type = "thread"
-                name = channel.name
-            elif isinstance(channel, discord.TextChannel):
-                chat_type = "channel"
-                name = f"#{channel.name}"
-                if channel.guild:
-                    name = f"{channel.guild.name} / {name}"
-            else:
-                chat_type = "channel"
-                name = getattr(channel, "name", str(chat_id))
-            
-            return {
-                "name": name,
-                "type": chat_type,
-                "guild_id": str(channel.guild.id) if hasattr(channel, "guild") and channel.guild else None,
-                "guild_name": channel.guild.name if hasattr(channel, "guild") and channel.guild else None,
-            }
-        except Exception as e:
-            return {"name": str(chat_id), "type": "dm", "error": str(e)}
-    
-    def format_message(self, content: str) -> str:
-        """
-        Format message for Discord.
-        
-        Discord uses its own markdown variant.
-        """
-        # Discord markdown is fairly standard, no special escaping needed
-        return content
-    
-    async def _handle_message(self, message: DiscordMessage) -> None:
-        """Handle incoming Discord messages."""
-        # Determine message type
-        msg_type = MessageType.TEXT
-        if message.content.startswith("/"):
-            msg_type = MessageType.COMMAND
-        elif message.attachments:
-            # Check attachment types
-            for att in message.attachments:
-                if att.content_type:
-                    if att.content_type.startswith("image/"):
-                        msg_type = MessageType.PHOTO
-                    elif att.content_type.startswith("video/"):
-                        msg_type = MessageType.VIDEO
-                    elif att.content_type.startswith("audio/"):
-                        msg_type = MessageType.AUDIO
-                    else:
-                        msg_type = MessageType.DOCUMENT
-                    break
-        
-        # Determine chat type
-        if isinstance(message.channel, discord.DMChannel):
-            chat_type = "dm"
-            chat_name = message.author.name
-        elif isinstance(message.channel, discord.Thread):
-            chat_type = "thread"
-            chat_name = message.channel.name
-        else:
-            chat_type = "group"  # Treat server channels as groups
-            chat_name = getattr(message.channel, "name", str(message.channel.id))
-            if hasattr(message.channel, "guild") and message.channel.guild:
-                chat_name = f"{message.channel.guild.name} / #{chat_name}"
-        
-        # Get thread ID if in a thread
-        thread_id = None
-        if isinstance(message.channel, discord.Thread):
-            thread_id = str(message.channel.id)
-        
-        # Build source
-        source = self.build_source(
-            chat_id=str(message.channel.id),
-            chat_name=chat_name,
-            chat_type=chat_type,
-            user_id=str(message.author.id),
-            user_name=message.author.display_name,
-            thread_id=thread_id,
-        )
-        
-        # Build media URLs
-        media_urls = [att.url for att in message.attachments]
-        media_types = [att.content_type or "unknown" for att in message.attachments]
-        
-        event = MessageEvent(
-            text=message.content,
-            message_type=msg_type,
-            source=source,
-            raw_message=message,
-            message_id=str(message.id),
-            media_urls=media_urls,
-            media_types=media_types,
-            reply_to_message_id=str(message.reference.message_id) if message.reference else None,
-            timestamp=message.created_at,
-        )
-        
-        await self.handle_message(event)

gateway/platforms/telegram.py

@@ -1,298 +0,0 @@
-"""
-Telegram platform adapter.
-
-Uses python-telegram-bot library for:
-- Receiving messages from users/groups
-- Sending responses back
-- Handling media and commands
-"""
-
-import asyncio
-from typing import Dict, List, Optional, Any
-
-try:
-    from telegram import Update, Bot, Message
-    from telegram.ext import (
-        Application,
-        CommandHandler,
-        MessageHandler as TelegramMessageHandler,
-        ContextTypes,
-        filters,
-    )
-    from telegram.constants import ParseMode, ChatType
-    TELEGRAM_AVAILABLE = True
-except ImportError:
-    TELEGRAM_AVAILABLE = False
-    Update = Any
-    Bot = Any
-    Message = Any
-    Application = Any
-    ContextTypes = Any
-
-import sys
-sys.path.insert(0, str(__file__).rsplit("/", 3)[0])
-
-from gateway.config import Platform, PlatformConfig
-from gateway.platforms.base import (
-    BasePlatformAdapter,
-    MessageEvent,
-    MessageType,
-    SendResult,
-)
-
-
-def check_telegram_requirements() -> bool:
-    """Check if Telegram dependencies are available."""
-    return TELEGRAM_AVAILABLE
-
-
-class TelegramAdapter(BasePlatformAdapter):
-    """
-    Telegram bot adapter.
-    
-    Handles:
-    - Receiving messages from users and groups
-    - Sending responses with Telegram markdown
-    - Forum topics (thread_id support)
-    - Media messages
-    """
-    
-    # Telegram message limits
-    MAX_MESSAGE_LENGTH = 4096
-    
-    def __init__(self, config: PlatformConfig):
-        super().__init__(config, Platform.TELEGRAM)
-        self._app: Optional[Application] = None
-        self._bot: Optional[Bot] = None
-    
-    async def connect(self) -> bool:
-        """Connect to Telegram and start polling for updates."""
-        if not TELEGRAM_AVAILABLE:
-            print(f"[{self.name}] python-telegram-bot not installed. Run: pip install python-telegram-bot")
-            return False
-        
-        if not self.config.token:
-            print(f"[{self.name}] No bot token configured")
-            return False
-        
-        try:
-            # Build the application
-            self._app = Application.builder().token(self.config.token).build()
-            self._bot = self._app.bot
-            
-            # Register handlers
-            self._app.add_handler(TelegramMessageHandler(
-                filters.TEXT & ~filters.COMMAND,
-                self._handle_text_message
-            ))
-            self._app.add_handler(TelegramMessageHandler(
-                filters.COMMAND,
-                self._handle_command
-            ))
-            self._app.add_handler(TelegramMessageHandler(
-                filters.PHOTO | filters.VIDEO | filters.AUDIO | filters.VOICE | filters.Document.ALL,
-                self._handle_media_message
-            ))
-            
-            # Start polling in background
-            await self._app.initialize()
-            await self._app.start()
-            await self._app.updater.start_polling(allowed_updates=Update.ALL_TYPES)
-            
-            self._running = True
-            print(f"[{self.name}] Connected and polling for updates")
-            return True
-            
-        except Exception as e:
-            print(f"[{self.name}] Failed to connect: {e}")
-            return False
-    
-    async def disconnect(self) -> None:
-        """Stop polling and disconnect."""
-        if self._app:
-            try:
-                await self._app.updater.stop()
-                await self._app.stop()
-                await self._app.shutdown()
-            except Exception as e:
-                print(f"[{self.name}] Error during disconnect: {e}")
-        
-        self._running = False
-        self._app = None
-        self._bot = None
-        print(f"[{self.name}] Disconnected")
-    
-    async def send(
-        self,
-        chat_id: str,
-        content: str,
-        reply_to: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None
-    ) -> SendResult:
-        """Send a message to a Telegram chat."""
-        if not self._bot:
-            return SendResult(success=False, error="Not connected")
-        
-        try:
-            # Format and split message if needed
-            formatted = self.format_message(content)
-            chunks = self.truncate_message(formatted, self.MAX_MESSAGE_LENGTH)
-            
-            message_ids = []
-            thread_id = metadata.get("thread_id") if metadata else None
-            
-            for i, chunk in enumerate(chunks):
-                # Try Markdown first, fall back to plain text if it fails
-                try:
-                    msg = await self._bot.send_message(
-                        chat_id=int(chat_id),
-                        text=chunk,
-                        parse_mode=ParseMode.MARKDOWN,
-                        reply_to_message_id=int(reply_to) if reply_to and i == 0 else None,
-                        message_thread_id=int(thread_id) if thread_id else None,
-                    )
-                except Exception as md_error:
-                    # Markdown parsing failed, try plain text
-                    if "parse" in str(md_error).lower() or "markdown" in str(md_error).lower():
-                        msg = await self._bot.send_message(
-                            chat_id=int(chat_id),
-                            text=chunk,
-                            parse_mode=None,  # Plain text
-                            reply_to_message_id=int(reply_to) if reply_to and i == 0 else None,
-                            message_thread_id=int(thread_id) if thread_id else None,
-                        )
-                    else:
-                        raise  # Re-raise if not a parse error
-                message_ids.append(str(msg.message_id))
-            
-            return SendResult(
-                success=True,
-                message_id=message_ids[0] if message_ids else None,
-                raw_response={"message_ids": message_ids}
-            )
-            
-        except Exception as e:
-            return SendResult(success=False, error=str(e))
-    
-    async def send_typing(self, chat_id: str) -> None:
-        """Send typing indicator."""
-        if self._bot:
-            try:
-                await self._bot.send_chat_action(
-                    chat_id=int(chat_id),
-                    action="typing"
-                )
-            except Exception:
-                pass  # Ignore typing indicator failures
-    
-    async def get_chat_info(self, chat_id: str) -> Dict[str, Any]:
-        """Get information about a Telegram chat."""
-        if not self._bot:
-            return {"name": "Unknown", "type": "dm"}
-        
-        try:
-            chat = await self._bot.get_chat(int(chat_id))
-            
-            chat_type = "dm"
-            if chat.type == ChatType.GROUP:
-                chat_type = "group"
-            elif chat.type == ChatType.SUPERGROUP:
-                chat_type = "group"
-                if chat.is_forum:
-                    chat_type = "forum"
-            elif chat.type == ChatType.CHANNEL:
-                chat_type = "channel"
-            
-            return {
-                "name": chat.title or chat.full_name or str(chat_id),
-                "type": chat_type,
-                "username": chat.username,
-                "is_forum": getattr(chat, "is_forum", False),
-            }
-        except Exception as e:
-            return {"name": str(chat_id), "type": "dm", "error": str(e)}
-    
-    def format_message(self, content: str) -> str:
-        """
-        Format message for Telegram.
-        
-        Telegram uses a subset of markdown. We'll use the simpler
-        Markdown mode (not MarkdownV2) for compatibility.
-        """
-        # Basic escaping for Telegram Markdown
-        # In Markdown mode (not V2), only certain characters need escaping
-        return content
-    
-    async def _handle_text_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-        """Handle incoming text messages."""
-        if not update.message or not update.message.text:
-            return
-        
-        event = self._build_message_event(update.message, MessageType.TEXT)
-        await self.handle_message(event)
-    
-    async def _handle_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-        """Handle incoming command messages."""
-        if not update.message or not update.message.text:
-            return
-        
-        event = self._build_message_event(update.message, MessageType.COMMAND)
-        await self.handle_message(event)
-    
-    async def _handle_media_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-        """Handle incoming media messages."""
-        if not update.message:
-            return
-        
-        msg = update.message
-        
-        # Determine media type
-        if msg.photo:
-            msg_type = MessageType.PHOTO
-        elif msg.video:
-            msg_type = MessageType.VIDEO
-        elif msg.audio:
-            msg_type = MessageType.AUDIO
-        elif msg.voice:
-            msg_type = MessageType.VOICE
-        else:
-            msg_type = MessageType.DOCUMENT
-        
-        event = self._build_message_event(msg, msg_type)
-        
-        # Add caption as text
-        if msg.caption:
-            event.text = msg.caption
-        
-        await self.handle_message(event)
-    
-    def _build_message_event(self, message: Message, msg_type: MessageType) -> MessageEvent:
-        """Build a MessageEvent from a Telegram message."""
-        chat = message.chat
-        user = message.from_user
-        
-        # Determine chat type
-        chat_type = "dm"
-        if chat.type in (ChatType.GROUP, ChatType.SUPERGROUP):
-            chat_type = "group"
-        elif chat.type == ChatType.CHANNEL:
-            chat_type = "channel"
-        
-        # Build source
-        source = self.build_source(
-            chat_id=str(chat.id),
-            chat_name=chat.title or (chat.full_name if hasattr(chat, "full_name") else None),
-            chat_type=chat_type,
-            user_id=str(user.id) if user else None,
-            user_name=user.full_name if user else None,
-            thread_id=str(message.message_thread_id) if message.message_thread_id else None,
-        )
-        
-        return MessageEvent(
-            text=message.text or "",
-            message_type=msg_type,
-            source=source,
-            raw_message=message,
-            message_id=str(message.message_id),
-            timestamp=message.date,
-        )

gateway/platforms/whatsapp.py

@@ -1,327 +0,0 @@
-"""
-WhatsApp platform adapter.
-
-WhatsApp integration is more complex than Telegram/Discord because:
-- No official bot API for personal accounts
-- Business API requires Meta Business verification
-- Most solutions use web-based automation
-
-This adapter supports multiple backends:
-1. WhatsApp Business API (requires Meta verification)
-2. whatsapp-web.js (via Node.js subprocess) - for personal accounts
-3. Baileys (via Node.js subprocess) - alternative for personal accounts
-
-For simplicity, we'll implement a generic interface that can work
-with different backends via a bridge pattern.
-"""
-
-import asyncio
-import json
-import subprocess
-from pathlib import Path
-from typing import Dict, List, Optional, Any
-
-import sys
-sys.path.insert(0, str(__file__).rsplit("/", 3)[0])
-
-from gateway.config import Platform, PlatformConfig
-from gateway.platforms.base import (
-    BasePlatformAdapter,
-    MessageEvent,
-    MessageType,
-    SendResult,
-)
-
-
-def check_whatsapp_requirements() -> bool:
-    """
-    Check if WhatsApp dependencies are available.
-    
-    WhatsApp requires a Node.js bridge for most implementations.
-    """
-    # Check for Node.js
-    try:
-        result = subprocess.run(
-            ["node", "--version"],
-            capture_output=True,
-            text=True,
-            timeout=5
-        )
-        return result.returncode == 0
-    except Exception:
-        return False
-
-
-class WhatsAppAdapter(BasePlatformAdapter):
-    """
-    WhatsApp adapter.
-    
-    This implementation uses a simple HTTP bridge pattern where:
-    1. A Node.js process runs the WhatsApp Web client
-    2. Messages are forwarded via HTTP/IPC to this Python adapter
-    3. Responses are sent back through the bridge
-    
-    The actual Node.js bridge implementation can vary:
-    - whatsapp-web.js based
-    - Baileys based
-    - Business API based
-    
-    Configuration:
-    - bridge_script: Path to the Node.js bridge script
-    - bridge_port: Port for HTTP communication (default: 3000)
-    - session_path: Path to store WhatsApp session data
-    """
-    
-    # WhatsApp message limits
-    MAX_MESSAGE_LENGTH = 65536  # WhatsApp allows longer messages
-    
-    def __init__(self, config: PlatformConfig):
-        super().__init__(config, Platform.WHATSAPP)
-        self._bridge_process: Optional[subprocess.Popen] = None
-        self._bridge_port: int = config.extra.get("bridge_port", 3000)
-        self._bridge_script: Optional[str] = config.extra.get("bridge_script")
-        self._session_path: Path = Path(config.extra.get(
-            "session_path",
-            Path.home() / ".hermes" / "whatsapp" / "session"
-        ))
-        self._message_queue: asyncio.Queue = asyncio.Queue()
-    
-    async def connect(self) -> bool:
-        """
-        Start the WhatsApp bridge.
-        
-        This launches the Node.js bridge process and waits for it to be ready.
-        """
-        if not check_whatsapp_requirements():
-            print(f"[{self.name}] Node.js not found. WhatsApp requires Node.js.")
-            return False
-        
-        if not self._bridge_script:
-            print(f"[{self.name}] No bridge script configured.")
-            print(f"[{self.name}] Set 'bridge_script' in whatsapp.extra config.")
-            print(f"[{self.name}] See docs/messaging.md for WhatsApp setup instructions.")
-            return False
-        
-        bridge_path = Path(self._bridge_script)
-        if not bridge_path.exists():
-            print(f"[{self.name}] Bridge script not found: {bridge_path}")
-            return False
-        
-        try:
-            # Ensure session directory exists
-            self._session_path.mkdir(parents=True, exist_ok=True)
-            
-            # Start the bridge process
-            self._bridge_process = subprocess.Popen(
-                [
-                    "node",
-                    str(bridge_path),
-                    "--port", str(self._bridge_port),
-                    "--session", str(self._session_path),
-                ],
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-            )
-            
-            # Wait for bridge to be ready (look for ready signal)
-            # This is a simplified version - real implementation would
-            # wait for an HTTP health check or specific stdout message
-            await asyncio.sleep(5)
-            
-            if self._bridge_process.poll() is not None:
-                stderr = self._bridge_process.stderr.read() if self._bridge_process.stderr else ""
-                print(f"[{self.name}] Bridge process died: {stderr}")
-                return False
-            
-            # Start message polling task
-            asyncio.create_task(self._poll_messages())
-            
-            self._running = True
-            print(f"[{self.name}] Bridge started on port {self._bridge_port}")
-            print(f"[{self.name}] Scan QR code if prompted (check bridge output)")
-            return True
-            
-        except Exception as e:
-            print(f"[{self.name}] Failed to start bridge: {e}")
-            return False
-    
-    async def disconnect(self) -> None:
-        """Stop the WhatsApp bridge."""
-        if self._bridge_process:
-            try:
-                self._bridge_process.terminate()
-                await asyncio.sleep(1)
-                if self._bridge_process.poll() is None:
-                    self._bridge_process.kill()
-            except Exception as e:
-                print(f"[{self.name}] Error stopping bridge: {e}")
-        
-        self._running = False
-        self._bridge_process = None
-        print(f"[{self.name}] Disconnected")
-    
-    async def send(
-        self,
-        chat_id: str,
-        content: str,
-        reply_to: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None
-    ) -> SendResult:
-        """Send a message via the WhatsApp bridge."""
-        if not self._running:
-            return SendResult(success=False, error="Not connected")
-        
-        try:
-            import aiohttp
-            
-            async with aiohttp.ClientSession() as session:
-                payload = {
-                    "chatId": chat_id,
-                    "message": content,
-                }
-                if reply_to:
-                    payload["replyTo"] = reply_to
-                
-                async with session.post(
-                    f"http://localhost:{self._bridge_port}/send",
-                    json=payload,
-                    timeout=aiohttp.ClientTimeout(total=30)
-                ) as resp:
-                    if resp.status == 200:
-                        data = await resp.json()
-                        return SendResult(
-                            success=True,
-                            message_id=data.get("messageId"),
-                            raw_response=data
-                        )
-                    else:
-                        error = await resp.text()
-                        return SendResult(success=False, error=error)
-                        
-        except ImportError:
-            return SendResult(
-                success=False, 
-                error="aiohttp not installed. Run: pip install aiohttp"
-            )
-        except Exception as e:
-            return SendResult(success=False, error=str(e))
-    
-    async def send_typing(self, chat_id: str) -> None:
-        """Send typing indicator via bridge."""
-        if not self._running:
-            return
-        
-        try:
-            import aiohttp
-            
-            async with aiohttp.ClientSession() as session:
-                await session.post(
-                    f"http://localhost:{self._bridge_port}/typing",
-                    json={"chatId": chat_id},
-                    timeout=aiohttp.ClientTimeout(total=5)
-                )
-        except Exception:
-            pass  # Ignore typing indicator failures
-    
-    async def get_chat_info(self, chat_id: str) -> Dict[str, Any]:
-        """Get information about a WhatsApp chat."""
-        if not self._running:
-            return {"name": "Unknown", "type": "dm"}
-        
-        try:
-            import aiohttp
-            
-            async with aiohttp.ClientSession() as session:
-                async with session.get(
-                    f"http://localhost:{self._bridge_port}/chat/{chat_id}",
-                    timeout=aiohttp.ClientTimeout(total=10)
-                ) as resp:
-                    if resp.status == 200:
-                        data = await resp.json()
-                        return {
-                            "name": data.get("name", chat_id),
-                            "type": "group" if data.get("isGroup") else "dm",
-                            "participants": data.get("participants", []),
-                        }
-        except Exception:
-            pass
-        
-        return {"name": chat_id, "type": "dm"}
-    
-    async def _poll_messages(self) -> None:
-        """Poll the bridge for incoming messages."""
-        try:
-            import aiohttp
-        except ImportError:
-            print(f"[{self.name}] aiohttp not installed, message polling disabled")
-            return
-        
-        while self._running:
-            try:
-                async with aiohttp.ClientSession() as session:
-                    async with session.get(
-                        f"http://localhost:{self._bridge_port}/messages",
-                        timeout=aiohttp.ClientTimeout(total=30)
-                    ) as resp:
-                        if resp.status == 200:
-                            messages = await resp.json()
-                            for msg_data in messages:
-                                event = self._build_message_event(msg_data)
-                                if event:
-                                    await self.handle_message(event)
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                print(f"[{self.name}] Poll error: {e}")
-                await asyncio.sleep(5)
-            
-            await asyncio.sleep(1)  # Poll interval
-    
-    def _build_message_event(self, data: Dict[str, Any]) -> Optional[MessageEvent]:
-        """Build a MessageEvent from bridge message data."""
-        try:
-            # Determine message type
-            msg_type = MessageType.TEXT
-            if data.get("hasMedia"):
-                media_type = data.get("mediaType", "")
-                if "image" in media_type:
-                    msg_type = MessageType.PHOTO
-                elif "video" in media_type:
-                    msg_type = MessageType.VIDEO
-                elif "audio" in media_type or "ptt" in media_type:  # ptt = voice note
-                    msg_type = MessageType.VOICE
-                else:
-                    msg_type = MessageType.DOCUMENT
-            
-            # Determine chat type
-            is_group = data.get("isGroup", False)
-            chat_type = "group" if is_group else "dm"
-            
-            # Build source
-            source = self.build_source(
-                chat_id=data.get("chatId", ""),
-                chat_name=data.get("chatName"),
-                chat_type=chat_type,
-                user_id=data.get("senderId"),
-                user_name=data.get("senderName"),
-            )
-            
-            return MessageEvent(
-                text=data.get("body", ""),
-                message_type=msg_type,
-                source=source,
-                raw_message=data,
-                message_id=data.get("messageId"),
-                media_urls=data.get("mediaUrls", []),
-            )
-        except Exception as e:
-            print(f"[{self.name}] Error building event: {e}")
-            return None
-
-
-# Note: A reference Node.js bridge script would be provided in scripts/whatsapp-bridge/
-# It would use whatsapp-web.js or Baileys to:
-# 1. Handle WhatsApp Web authentication (QR code)
-# 2. Listen for incoming messages
-# 3. Expose HTTP endpoints for send/receive/status

gateway/run.py

@@ -1,666 +0,0 @@
-"""
-Gateway runner - entry point for messaging platform integrations.
-
-This module provides:
-- start_gateway(): Start all configured platform adapters
-- GatewayRunner: Main class managing the gateway lifecycle
-
-Usage:
-    # Start the gateway
-    python -m gateway.run
-    
-    # Or from CLI
-    python cli.py --gateway
-"""
-
-import asyncio
-import os
-import sys
-import signal
-from pathlib import Path
-from datetime import datetime
-from typing import Dict, Optional, Any, List
-
-# Add parent directory to path
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-# Load environment variables from ~/.hermes/.env first
-from dotenv import load_dotenv
-_env_path = Path.home() / '.hermes' / '.env'
-if _env_path.exists():
-    load_dotenv(_env_path)
-# Also try project .env as fallback
-load_dotenv()
-
-# Gateway runs in quiet mode - suppress debug output and use cwd directly (no temp dirs)
-os.environ["HERMES_QUIET"] = "1"
-
-# Set terminal working directory for messaging platforms
-# Uses MESSAGING_CWD if set, otherwise defaults to home directory
-# This is separate from CLI which uses the directory where `hermes` is run
-messaging_cwd = os.getenv("MESSAGING_CWD") or str(Path.home())
-os.environ["TERMINAL_CWD"] = messaging_cwd
-
-from gateway.config import (
-    Platform,
-    GatewayConfig,
-    load_gateway_config,
-)
-from gateway.session import (
-    SessionStore,
-    SessionSource,
-    SessionContext,
-    build_session_context,
-    build_session_context_prompt,
-)
-from gateway.delivery import DeliveryRouter, DeliveryTarget
-from gateway.platforms.base import BasePlatformAdapter, MessageEvent
-
-
-class GatewayRunner:
-    """
-    Main gateway controller.
-    
-    Manages the lifecycle of all platform adapters and routes
-    messages to/from the agent.
-    """
-    
-    def __init__(self, config: Optional[GatewayConfig] = None):
-        self.config = config or load_gateway_config()
-        self.adapters: Dict[Platform, BasePlatformAdapter] = {}
-        self.session_store = SessionStore(self.config.sessions_dir, self.config)
-        self.delivery_router = DeliveryRouter(self.config)
-        self._running = False
-        self._shutdown_event = asyncio.Event()
-        
-        # Track running agents per session for interrupt support
-        # Key: session_key, Value: AIAgent instance
-        self._running_agents: Dict[str, Any] = {}
-        self._pending_messages: Dict[str, str] = {}  # Queued messages during interrupt
-    
-    async def start(self) -> bool:
-        """
-        Start the gateway and all configured platform adapters.
-        
-        Returns True if at least one adapter connected successfully.
-        """
-        print("[gateway] Starting Hermes Gateway...")
-        print(f"[gateway] Session storage: {self.config.sessions_dir}")
-        
-        connected_count = 0
-        
-        # Initialize and connect each configured platform
-        for platform, platform_config in self.config.platforms.items():
-            if not platform_config.enabled:
-                continue
-            
-            adapter = self._create_adapter(platform, platform_config)
-            if not adapter:
-                print(f"[gateway] No adapter available for {platform.value}")
-                continue
-            
-            # Set up message handler
-            adapter.set_message_handler(self._handle_message)
-            
-            # Try to connect
-            print(f"[gateway] Connecting to {platform.value}...")
-            try:
-                success = await adapter.connect()
-                if success:
-                    self.adapters[platform] = adapter
-                    connected_count += 1
-                    print(f"[gateway] ✓ {platform.value} connected")
-                else:
-                    print(f"[gateway] ✗ {platform.value} failed to connect")
-            except Exception as e:
-                print(f"[gateway] ✗ {platform.value} error: {e}")
-        
-        if connected_count == 0:
-            print("[gateway] No platforms connected. Check your configuration.")
-            return False
-        
-        # Update delivery router with adapters
-        self.delivery_router.adapters = self.adapters
-        
-        self._running = True
-        print(f"[gateway] Gateway running with {connected_count} platform(s)")
-        print("[gateway] Press Ctrl+C to stop")
-        
-        return True
-    
-    async def stop(self) -> None:
-        """Stop the gateway and disconnect all adapters."""
-        print("[gateway] Stopping gateway...")
-        self._running = False
-        
-        for platform, adapter in self.adapters.items():
-            try:
-                await adapter.disconnect()
-                print(f"[gateway] ✓ {platform.value} disconnected")
-            except Exception as e:
-                print(f"[gateway] ✗ {platform.value} disconnect error: {e}")
-        
-        self.adapters.clear()
-        self._shutdown_event.set()
-        print("[gateway] Gateway stopped")
-    
-    async def wait_for_shutdown(self) -> None:
-        """Wait for shutdown signal."""
-        await self._shutdown_event.wait()
-    
-    def _create_adapter(
-        self, 
-        platform: Platform, 
-        config: Any
-    ) -> Optional[BasePlatformAdapter]:
-        """Create the appropriate adapter for a platform."""
-        if platform == Platform.TELEGRAM:
-            from gateway.platforms.telegram import TelegramAdapter, check_telegram_requirements
-            if not check_telegram_requirements():
-                print(f"[gateway] Telegram: python-telegram-bot not installed")
-                return None
-            return TelegramAdapter(config)
-        
-        elif platform == Platform.DISCORD:
-            from gateway.platforms.discord import DiscordAdapter, check_discord_requirements
-            if not check_discord_requirements():
-                print(f"[gateway] Discord: discord.py not installed")
-                return None
-            return DiscordAdapter(config)
-        
-        elif platform == Platform.WHATSAPP:
-            from gateway.platforms.whatsapp import WhatsAppAdapter, check_whatsapp_requirements
-            if not check_whatsapp_requirements():
-                print(f"[gateway] WhatsApp: Node.js not installed or bridge not configured")
-                return None
-            return WhatsAppAdapter(config)
-        
-        return None
-    
-    def _is_user_authorized(self, source: SessionSource) -> bool:
-        """
-        Check if a user is authorized to use the bot.
-        
-        Authorization is checked via environment variables:
-        - GATEWAY_ALLOWED_USERS: Comma-separated list of user IDs (all platforms)
-        - TELEGRAM_ALLOWED_USERS: Telegram-specific user IDs
-        - DISCORD_ALLOWED_USERS: Discord-specific user IDs
-        
-        If no allowlist is configured, all users are allowed (open access).
-        """
-        user_id = source.user_id
-        if not user_id:
-            return False  # Can't verify unknown users
-        
-        # Check platform-specific allowlist first
-        platform_env_map = {
-            Platform.TELEGRAM: "TELEGRAM_ALLOWED_USERS",
-            Platform.DISCORD: "DISCORD_ALLOWED_USERS",
-            Platform.WHATSAPP: "WHATSAPP_ALLOWED_USERS",
-        }
-        
-        platform_allowlist = os.getenv(platform_env_map.get(source.platform, ""))
-        global_allowlist = os.getenv("GATEWAY_ALLOWED_USERS", "")
-        
-        # If no allowlists configured, allow all (backward compatible)
-        if not platform_allowlist and not global_allowlist:
-            return True
-        
-        # Check if user is in any allowlist
-        allowed_ids = set()
-        if platform_allowlist:
-            allowed_ids.update(uid.strip() for uid in platform_allowlist.split(","))
-        if global_allowlist:
-            allowed_ids.update(uid.strip() for uid in global_allowlist.split(","))
-        
-        return user_id in allowed_ids
-    
-    async def _handle_message(self, event: MessageEvent) -> Optional[str]:
-        """
-        Handle an incoming message from any platform.
-        
-        This is the core message processing pipeline:
-        1. Check user authorization
-        2. Check for commands (/new, /reset, etc.)
-        3. Check for running agent and interrupt if needed
-        4. Get or create session
-        5. Build context for agent
-        6. Run agent conversation
-        7. Return response
-        """
-        source = event.source
-        
-        # Check if user is authorized
-        if not self._is_user_authorized(source):
-            print(f"[gateway] Unauthorized user: {source.user_id} ({source.user_name}) on {source.platform.value}")
-            return None  # Silently ignore unauthorized users
-        
-        # Check for commands
-        command = event.get_command()
-        if command in ["new", "reset"]:
-            return await self._handle_reset_command(event)
-        
-        if command == "status":
-            return await self._handle_status_command(event)
-        
-        if command == "stop":
-            return await self._handle_stop_command(event)
-        
-        # Get or create session
-        session_entry = self.session_store.get_or_create_session(source)
-        session_key = session_entry.session_key
-        
-        # Check if there's already a running agent for this session
-        if session_key in self._running_agents:
-            running_agent = self._running_agents[session_key]
-            print(f"[gateway] ⚡ Interrupting running agent for session {session_key[:20]}...")
-            running_agent.interrupt(event.text)
-            # Store the new message to be processed after current agent finishes
-            self._pending_messages[session_key] = event.text
-            return None  # Don't respond yet - let the interrupt handle it
-        
-        # Build session context
-        context = build_session_context(source, self.config, session_entry)
-        
-        # Set environment variables for tools
-        self._set_session_env(context)
-        
-        # Build the context prompt to inject
-        context_prompt = build_session_context_prompt(context)
-        
-        # Load conversation history from transcript
-        history = self.session_store.load_transcript(session_entry.session_id)
-        
-        try:
-            # Run the agent
-            response = await self._run_agent(
-                message=event.text,
-                context_prompt=context_prompt,
-                history=history,
-                source=source,
-                session_id=session_entry.session_id,
-                session_key=session_key
-            )
-            
-            # Append to transcript
-            self.session_store.append_to_transcript(
-                session_entry.session_id,
-                {"role": "user", "content": event.text, "timestamp": datetime.now().isoformat()}
-            )
-            self.session_store.append_to_transcript(
-                session_entry.session_id,
-                {"role": "assistant", "content": response, "timestamp": datetime.now().isoformat()}
-            )
-            
-            # Update session
-            self.session_store.update_session(session_entry.session_key)
-            
-            return response
-            
-        except Exception as e:
-            print(f"[gateway] Agent error: {e}")
-            return f"Sorry, I encountered an error: {str(e)}"
-        finally:
-            # Clear session env
-            self._clear_session_env()
-    
-    async def _handle_reset_command(self, event: MessageEvent) -> str:
-        """Handle /new or /reset command."""
-        source = event.source
-        
-        # Get existing session key
-        session_key = f"agent:main:{source.platform.value}:" + \
-                      (f"dm" if source.chat_type == "dm" else f"{source.chat_type}:{source.chat_id}")
-        
-        # Reset the session
-        new_entry = self.session_store.reset_session(session_key)
-        
-        if new_entry:
-            return "✨ Session reset! I've started fresh with no memory of our previous conversation."
-        else:
-            # No existing session, just create one
-            self.session_store.get_or_create_session(source, force_new=True)
-            return "✨ New session started!"
-    
-    async def _handle_status_command(self, event: MessageEvent) -> str:
-        """Handle /status command."""
-        source = event.source
-        session_entry = self.session_store.get_or_create_session(source)
-        
-        connected_platforms = [p.value for p in self.adapters.keys()]
-        
-        # Check if there's an active agent
-        session_key = session_entry.session_key
-        is_running = session_key in self._running_agents
-        
-        lines = [
-            "📊 **Hermes Gateway Status**",
-            "",
-            f"**Session ID:** `{session_entry.session_id[:12]}...`",
-            f"**Created:** {session_entry.created_at.strftime('%Y-%m-%d %H:%M')}",
-            f"**Last Activity:** {session_entry.updated_at.strftime('%Y-%m-%d %H:%M')}",
-            f"**Tokens:** {session_entry.total_tokens:,}",
-            f"**Agent Running:** {'Yes ⚡' if is_running else 'No'}",
-            "",
-            f"**Connected Platforms:** {', '.join(connected_platforms)}",
-        ]
-        
-        return "\n".join(lines)
-    
-    async def _handle_stop_command(self, event: MessageEvent) -> str:
-        """Handle /stop command - interrupt a running agent."""
-        source = event.source
-        session_entry = self.session_store.get_or_create_session(source)
-        session_key = session_entry.session_key
-        
-        if session_key in self._running_agents:
-            agent = self._running_agents[session_key]
-            agent.interrupt()
-            return "⚡ Stopping the current task... The agent will finish its current step and respond."
-        else:
-            return "No active task to stop."
-    
-    def _set_session_env(self, context: SessionContext) -> None:
-        """Set environment variables for the current session."""
-        os.environ["HERMES_SESSION_PLATFORM"] = context.source.platform.value
-        os.environ["HERMES_SESSION_CHAT_ID"] = context.source.chat_id
-        if context.source.chat_name:
-            os.environ["HERMES_SESSION_CHAT_NAME"] = context.source.chat_name
-    
-    def _clear_session_env(self) -> None:
-        """Clear session environment variables."""
-        for var in ["HERMES_SESSION_PLATFORM", "HERMES_SESSION_CHAT_ID", "HERMES_SESSION_CHAT_NAME"]:
-            if var in os.environ:
-                del os.environ[var]
-    
-    async def _run_agent(
-        self,
-        message: str,
-        context_prompt: str,
-        history: List[Dict[str, Any]],
-        source: SessionSource,
-        session_id: str,
-        session_key: str = None
-    ) -> str:
-        """
-        Run the agent with the given message and context.
-        
-        This is run in a thread pool to not block the event loop.
-        Supports interruption via new messages.
-        """
-        from run_agent import AIAgent
-        import queue
-        
-        # Determine toolset based on platform
-        toolset_map = {
-            Platform.LOCAL: "hermes-cli",
-            Platform.TELEGRAM: "hermes-telegram",
-            Platform.DISCORD: "hermes-discord",
-            Platform.WHATSAPP: "hermes-whatsapp",
-        }
-        toolset = toolset_map.get(source.platform, "hermes-telegram")
-        
-        # Check if tool progress notifications are enabled
-        tool_progress_enabled = os.getenv("HERMES_TOOL_PROGRESS", "").lower() in ("1", "true", "yes")
-        progress_mode = os.getenv("HERMES_TOOL_PROGRESS_MODE", "new")  # "all" or "new" (only new tools)
-        
-        # Queue for progress messages (thread-safe)
-        progress_queue = queue.Queue() if tool_progress_enabled else None
-        last_tool = [None]  # Mutable container for tracking in closure
-        
-        def progress_callback(tool_name: str, preview: str = None):
-            """Callback invoked by agent when a tool is called."""
-            if not progress_queue:
-                return
-            
-            # "new" mode: only report when tool changes
-            if progress_mode == "new" and tool_name == last_tool[0]:
-                return
-            last_tool[0] = tool_name
-            
-            # Build progress message
-            tool_emojis = {
-                "terminal": "💻",
-                "web_search": "🔍",
-                "web_extract": "📄",
-                "read_file": "📖",
-                "write_file": "✍️",
-                "list_directory": "📂",
-                "image_generate": "🎨",
-                "browser_navigate": "🌐",
-                "browser_click": "👆",
-                "moa_query": "🧠",
-            }
-            emoji = tool_emojis.get(tool_name, "⚙️")
-            
-            if tool_name == "terminal" and preview:
-                msg = f"{emoji} `{preview}`..."
-            else:
-                msg = f"{emoji} {tool_name}..."
-            
-            progress_queue.put(msg)
-        
-        # Background task to send progress messages
-        async def send_progress_messages():
-            if not progress_queue:
-                return
-            
-            adapter = self.adapters.get(source.platform)
-            if not adapter:
-                return
-            
-            while True:
-                try:
-                    # Non-blocking check with small timeout
-                    msg = progress_queue.get_nowait()
-                    await adapter.send(chat_id=source.chat_id, content=msg)
-                    # Restore typing indicator after sending progress message
-                    await asyncio.sleep(0.3)
-                    await adapter.send_typing(source.chat_id)
-                except queue.Empty:
-                    await asyncio.sleep(0.3)  # Check again soon
-                except asyncio.CancelledError:
-                    # Drain remaining messages
-                    while not progress_queue.empty():
-                        try:
-                            msg = progress_queue.get_nowait()
-                            await adapter.send(chat_id=source.chat_id, content=msg)
-                        except:
-                            break
-                    return
-                except Exception as e:
-                    print(f"[Gateway] Progress message error: {e}")
-                    await asyncio.sleep(1)
-        
-        # We need to share the agent instance for interrupt support
-        agent_holder = [None]  # Mutable container for the agent instance
-        result_holder = [None]  # Mutable container for the result
-        
-        def run_sync():
-            # Read from env var or use default (same as CLI)
-            max_iterations = int(os.getenv("HERMES_MAX_ITERATIONS", "60"))
-            
-            agent = AIAgent(
-                model=os.getenv("HERMES_MODEL", "anthropic/claude-sonnet-4"),
-                max_iterations=max_iterations,
-                quiet_mode=True,
-                enabled_toolsets=[toolset],
-                ephemeral_system_prompt=context_prompt,
-                session_id=session_id,
-                tool_progress_callback=progress_callback if tool_progress_enabled else None,
-            )
-            
-            # Store agent reference for interrupt support
-            agent_holder[0] = agent
-            
-            # Convert transcript history to agent format
-            # Transcript has timestamps; agent expects {"role": ..., "content": ...}
-            agent_history = []
-            for msg in history:
-                role = msg.get("role")
-                content = msg.get("content")
-                if role and content:
-                    agent_history.append({"role": role, "content": content})
-            
-            result = agent.run_conversation(message, conversation_history=agent_history)
-            result_holder[0] = result
-            
-            # Return final response, or a message if something went wrong
-            final_response = result.get("final_response")
-            if final_response:
-                return final_response
-            elif result.get("error"):
-                # Agent couldn't recover - show the error
-                return f"⚠️ {result['error']}"
-            else:
-                return "(No response generated)"
-        
-        # Start progress message sender if enabled
-        progress_task = None
-        if tool_progress_enabled:
-            progress_task = asyncio.create_task(send_progress_messages())
-        
-        # Track this agent as running for this session (for interrupt support)
-        # We do this in a callback after the agent is created
-        async def track_agent():
-            # Wait for agent to be created
-            while agent_holder[0] is None:
-                await asyncio.sleep(0.05)
-            if session_key:
-                self._running_agents[session_key] = agent_holder[0]
-        
-        tracking_task = asyncio.create_task(track_agent())
-        
-        # Monitor for interrupts from the adapter (new messages arriving)
-        async def monitor_for_interrupt():
-            adapter = self.adapters.get(source.platform)
-            if not adapter:
-                return
-            
-            chat_id = source.chat_id
-            while True:
-                await asyncio.sleep(0.2)  # Check every 200ms
-                # Check if adapter has a pending interrupt for this session
-                if hasattr(adapter, 'has_pending_interrupt') and adapter.has_pending_interrupt(chat_id):
-                    agent = agent_holder[0]
-                    if agent:
-                        pending_event = adapter.get_pending_message(chat_id)
-                        pending_text = pending_event.text if pending_event else None
-                        print(f"[gateway] ⚡ Interrupt detected from adapter, signaling agent...")
-                        agent.interrupt(pending_text)
-                        break
-        
-        interrupt_monitor = asyncio.create_task(monitor_for_interrupt())
-        
-        try:
-            # Run in thread pool to not block
-            loop = asyncio.get_event_loop()
-            response = await loop.run_in_executor(None, run_sync)
-            
-            # Check if we were interrupted and have a pending message
-            result = result_holder[0]
-            adapter = self.adapters.get(source.platform)
-            
-            # Get pending message from adapter if interrupted
-            pending = None
-            if result and result.get("interrupted") and adapter:
-                pending_event = adapter.get_pending_message(source.chat_id)
-                if pending_event:
-                    pending = pending_event.text
-                elif result.get("interrupt_message"):
-                    pending = result.get("interrupt_message")
-            
-            if pending:
-                print(f"[gateway] 📨 Processing interrupted message: '{pending[:40]}...'")
-                # Add an indicator to the response
-                if response:
-                    response = response + "\n\n---\n_[Interrupted - processing your new message]_"
-                
-                # Send the interrupted response first
-                if adapter and response:
-                    await adapter.send(chat_id=source.chat_id, content=response)
-                
-                # Now process the pending message with updated history
-                updated_history = result.get("messages", history)
-                return await self._run_agent(
-                    message=pending,
-                    context_prompt=context_prompt,
-                    history=updated_history,
-                    source=source,
-                    session_id=session_id,
-                    session_key=session_key
-                )
-        finally:
-            # Stop progress sender and interrupt monitor
-            if progress_task:
-                progress_task.cancel()
-            interrupt_monitor.cancel()
-            
-            # Clean up tracking
-            tracking_task.cancel()
-            if session_key and session_key in self._running_agents:
-                del self._running_agents[session_key]
-            
-            # Wait for cancelled tasks
-            for task in [progress_task, interrupt_monitor, tracking_task]:
-                if task:
-                    try:
-                        await task
-                    except asyncio.CancelledError:
-                        pass
-        
-        return response
-
-
-async def start_gateway(config: Optional[GatewayConfig] = None) -> None:
-    """
-    Start the gateway and run until interrupted.
-    
-    This is the main entry point for running the gateway.
-    """
-    runner = GatewayRunner(config)
-    
-    # Set up signal handlers
-    def signal_handler():
-        asyncio.create_task(runner.stop())
-    
-    loop = asyncio.get_event_loop()
-    for sig in (signal.SIGINT, signal.SIGTERM):
-        try:
-            loop.add_signal_handler(sig, signal_handler)
-        except NotImplementedError:
-            # Windows doesn't support add_signal_handler
-            pass
-    
-    # Start the gateway
-    success = await runner.start()
-    if not success:
-        return
-    
-    # Wait for shutdown
-    await runner.wait_for_shutdown()
-
-
-def main():
-    """CLI entry point for the gateway."""
-    import argparse
-    
-    parser = argparse.ArgumentParser(description="Hermes Gateway - Multi-platform messaging")
-    parser.add_argument("--config", "-c", help="Path to gateway config file")
-    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
-    
-    args = parser.parse_args()
-    
-    config = None
-    if args.config:
-        import json
-        with open(args.config) as f:
-            data = json.load(f)
-            config = GatewayConfig.from_dict(data)
-    
-    # Run the gateway
-    asyncio.run(start_gateway(config))
-
-
-if __name__ == "__main__":
-    main()

gateway/session.py

@@ -1,522 +0,0 @@
-"""
-Session management for the gateway.
-
-Handles:
-- Session context tracking (where messages come from)
-- Session storage (conversations persisted to disk)
-- Reset policy evaluation (when to start fresh)
-- Dynamic system prompt injection (agent knows its context)
-"""
-
-import os
-import json
-import uuid
-from pathlib import Path
-from datetime import datetime, timedelta
-from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Any
-
-from .config import (
-    Platform,
-    GatewayConfig,
-    SessionResetPolicy,
-    HomeChannel,
-)
-
-
-@dataclass
-class SessionSource:
-    """
-    Describes where a message originated from.
-    
-    This information is used to:
-    1. Route responses back to the right place
-    2. Inject context into the system prompt
-    3. Track origin for cron job delivery
-    """
-    platform: Platform
-    chat_id: str
-    chat_name: Optional[str] = None
-    chat_type: str = "dm"  # "dm", "group", "channel", "thread"
-    user_id: Optional[str] = None
-    user_name: Optional[str] = None
-    thread_id: Optional[str] = None  # For forum topics, Discord threads, etc.
-    
-    @property
-    def description(self) -> str:
-        """Human-readable description of the source."""
-        if self.platform == Platform.LOCAL:
-            return "CLI terminal"
-        
-        parts = []
-        if self.chat_type == "dm":
-            parts.append(f"DM with {self.user_name or self.user_id or 'user'}")
-        elif self.chat_type == "group":
-            parts.append(f"group: {self.chat_name or self.chat_id}")
-        elif self.chat_type == "channel":
-            parts.append(f"channel: {self.chat_name or self.chat_id}")
-        else:
-            parts.append(self.chat_name or self.chat_id)
-        
-        if self.thread_id:
-            parts.append(f"thread: {self.thread_id}")
-        
-        return ", ".join(parts)
-    
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "platform": self.platform.value,
-            "chat_id": self.chat_id,
-            "chat_name": self.chat_name,
-            "chat_type": self.chat_type,
-            "user_id": self.user_id,
-            "user_name": self.user_name,
-            "thread_id": self.thread_id,
-        }
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "SessionSource":
-        return cls(
-            platform=Platform(data["platform"]),
-            chat_id=str(data["chat_id"]),
-            chat_name=data.get("chat_name"),
-            chat_type=data.get("chat_type", "dm"),
-            user_id=data.get("user_id"),
-            user_name=data.get("user_name"),
-            thread_id=data.get("thread_id"),
-        )
-    
-    @classmethod
-    def local_cli(cls) -> "SessionSource":
-        """Create a source representing the local CLI."""
-        return cls(
-            platform=Platform.LOCAL,
-            chat_id="cli",
-            chat_name="CLI terminal",
-            chat_type="dm",
-        )
-
-
-@dataclass
-class SessionContext:
-    """
-    Full context for a session, used for dynamic system prompt injection.
-    
-    The agent receives this information to understand:
-    - Where messages are coming from
-    - What platforms are available
-    - Where it can deliver scheduled task outputs
-    """
-    source: SessionSource
-    connected_platforms: List[Platform]
-    home_channels: Dict[Platform, HomeChannel]
-    
-    # Session metadata
-    session_key: str = ""
-    session_id: str = ""
-    created_at: Optional[datetime] = None
-    updated_at: Optional[datetime] = None
-    
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "source": self.source.to_dict(),
-            "connected_platforms": [p.value for p in self.connected_platforms],
-            "home_channels": {
-                p.value: hc.to_dict() for p, hc in self.home_channels.items()
-            },
-            "session_key": self.session_key,
-            "session_id": self.session_id,
-            "created_at": self.created_at.isoformat() if self.created_at else None,
-            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
-        }
-
-
-def build_session_context_prompt(context: SessionContext) -> str:
-    """
-    Build the dynamic system prompt section that tells the agent about its context.
-    
-    This is injected into the system prompt so the agent knows:
-    - Where messages are coming from
-    - What platforms are connected
-    - Where it can deliver scheduled task outputs
-    """
-    lines = [
-        "## Current Session Context",
-        "",
-    ]
-    
-    # Source info
-    platform_name = context.source.platform.value.title()
-    if context.source.platform == Platform.LOCAL:
-        lines.append(f"**Source:** {platform_name} (the machine running this agent)")
-    else:
-        lines.append(f"**Source:** {platform_name} ({context.source.description})")
-    
-    # Connected platforms
-    platforms_list = ["local (files on this machine)"]
-    for p in context.connected_platforms:
-        if p != Platform.LOCAL:
-            platforms_list.append(f"{p.value}: Connected ✓")
-    
-    lines.append(f"**Connected Platforms:** {', '.join(platforms_list)}")
-    
-    # Home channels
-    if context.home_channels:
-        lines.append("")
-        lines.append("**Home Channels (default destinations):**")
-        for platform, home in context.home_channels.items():
-            lines.append(f"  - {platform.value}: {home.name} (ID: {home.chat_id})")
-    
-    # Delivery options for scheduled tasks
-    lines.append("")
-    lines.append("**Delivery options for scheduled tasks:**")
-    
-    # Origin delivery
-    if context.source.platform == Platform.LOCAL:
-        lines.append("- `\"origin\"` → Local output (saved to files)")
-    else:
-        lines.append(f"- `\"origin\"` → Back to this chat ({context.source.chat_name or context.source.chat_id})")
-    
-    # Local always available
-    lines.append("- `\"local\"` → Save to local files only (~/.hermes/cron/output/)")
-    
-    # Platform home channels
-    for platform, home in context.home_channels.items():
-        lines.append(f"- `\"{platform.value}\"` → Home channel ({home.name})")
-    
-    # Note about explicit targeting
-    lines.append("")
-    lines.append("*For explicit targeting, use `\"platform:chat_id\"` format if the user provides a specific chat ID.*")
-    
-    return "\n".join(lines)
-
-
-@dataclass
-class SessionEntry:
-    """
-    Entry in the session store.
-    
-    Maps a session key to its current session ID and metadata.
-    """
-    session_key: str
-    session_id: str
-    created_at: datetime
-    updated_at: datetime
-    
-    # Origin metadata for delivery routing
-    origin: Optional[SessionSource] = None
-    
-    # Display metadata
-    display_name: Optional[str] = None
-    platform: Optional[Platform] = None
-    chat_type: str = "dm"
-    
-    # Token tracking
-    input_tokens: int = 0
-    output_tokens: int = 0
-    total_tokens: int = 0
-    
-    def to_dict(self) -> Dict[str, Any]:
-        result = {
-            "session_key": self.session_key,
-            "session_id": self.session_id,
-            "created_at": self.created_at.isoformat(),
-            "updated_at": self.updated_at.isoformat(),
-            "display_name": self.display_name,
-            "platform": self.platform.value if self.platform else None,
-            "chat_type": self.chat_type,
-            "input_tokens": self.input_tokens,
-            "output_tokens": self.output_tokens,
-            "total_tokens": self.total_tokens,
-        }
-        if self.origin:
-            result["origin"] = self.origin.to_dict()
-        return result
-    
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "SessionEntry":
-        origin = None
-        if "origin" in data and data["origin"]:
-            origin = SessionSource.from_dict(data["origin"])
-        
-        platform = None
-        if data.get("platform"):
-            try:
-                platform = Platform(data["platform"])
-            except ValueError:
-                pass
-        
-        return cls(
-            session_key=data["session_key"],
-            session_id=data["session_id"],
-            created_at=datetime.fromisoformat(data["created_at"]),
-            updated_at=datetime.fromisoformat(data["updated_at"]),
-            origin=origin,
-            display_name=data.get("display_name"),
-            platform=platform,
-            chat_type=data.get("chat_type", "dm"),
-            input_tokens=data.get("input_tokens", 0),
-            output_tokens=data.get("output_tokens", 0),
-            total_tokens=data.get("total_tokens", 0),
-        )
-
-
-class SessionStore:
-    """
-    Manages session storage and retrieval.
-    
-    Sessions are stored in:
-    - sessions.json: Index mapping session keys to session IDs
-    - {session_id}.jsonl: Conversation transcripts
-    """
-    
-    def __init__(self, sessions_dir: Path, config: GatewayConfig):
-        self.sessions_dir = sessions_dir
-        self.config = config
-        self._entries: Dict[str, SessionEntry] = {}
-        self._loaded = False
-    
-    def _ensure_loaded(self) -> None:
-        """Load sessions from disk if not already loaded."""
-        if self._loaded:
-            return
-        
-        self.sessions_dir.mkdir(parents=True, exist_ok=True)
-        sessions_file = self.sessions_dir / "sessions.json"
-        
-        if sessions_file.exists():
-            try:
-                with open(sessions_file, "r") as f:
-                    data = json.load(f)
-                    for key, entry_data in data.items():
-                        self._entries[key] = SessionEntry.from_dict(entry_data)
-            except Exception as e:
-                print(f"[gateway] Warning: Failed to load sessions: {e}")
-        
-        self._loaded = True
-    
-    def _save(self) -> None:
-        """Save sessions index to disk."""
-        self.sessions_dir.mkdir(parents=True, exist_ok=True)
-        sessions_file = self.sessions_dir / "sessions.json"
-        
-        data = {key: entry.to_dict() for key, entry in self._entries.items()}
-        with open(sessions_file, "w") as f:
-            json.dump(data, f, indent=2)
-    
-    def _generate_session_key(self, source: SessionSource) -> str:
-        """Generate a session key from a source."""
-        platform = source.platform.value
-        
-        if source.chat_type == "dm":
-            # DMs share the main session per platform
-            return f"agent:main:{platform}:dm"
-        else:
-            # Groups/channels get their own keys
-            return f"agent:main:{platform}:{source.chat_type}:{source.chat_id}"
-    
-    def _should_reset(self, entry: SessionEntry, source: SessionSource) -> bool:
-        """
-        Check if a session should be reset based on policy.
-        
-        Returns True if the session is stale and should start fresh.
-        """
-        policy = self.config.get_reset_policy(
-            platform=source.platform,
-            session_type=source.chat_type
-        )
-        
-        now = datetime.now()
-        
-        # Check idle timeout
-        if policy.mode in ("idle", "both"):
-            idle_deadline = entry.updated_at + timedelta(minutes=policy.idle_minutes)
-            if now > idle_deadline:
-                return True
-        
-        # Check daily reset
-        if policy.mode in ("daily", "both"):
-            # Find the most recent reset boundary
-            today_reset = now.replace(
-                hour=policy.at_hour, 
-                minute=0, 
-                second=0, 
-                microsecond=0
-            )
-            if now.hour < policy.at_hour:
-                # Reset boundary was yesterday
-                today_reset -= timedelta(days=1)
-            
-            if entry.updated_at < today_reset:
-                return True
-        
-        return False
-    
-    def get_or_create_session(
-        self, 
-        source: SessionSource,
-        force_new: bool = False
-    ) -> SessionEntry:
-        """
-        Get an existing session or create a new one.
-        
-        Evaluates reset policy to determine if the existing session is stale.
-        """
-        self._ensure_loaded()
-        
-        session_key = self._generate_session_key(source)
-        now = datetime.now()
-        
-        # Check for existing session
-        if session_key in self._entries and not force_new:
-            entry = self._entries[session_key]
-            
-            # Check if session should be reset
-            if not self._should_reset(entry, source):
-                # Update timestamp and return existing
-                entry.updated_at = now
-                self._save()
-                return entry
-        
-        # Create new session
-        session_id = f"{now.strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
-        
-        entry = SessionEntry(
-            session_key=session_key,
-            session_id=session_id,
-            created_at=now,
-            updated_at=now,
-            origin=source,
-            display_name=source.chat_name,
-            platform=source.platform,
-            chat_type=source.chat_type,
-        )
-        
-        self._entries[session_key] = entry
-        self._save()
-        
-        return entry
-    
-    def update_session(
-        self, 
-        session_key: str,
-        input_tokens: int = 0,
-        output_tokens: int = 0
-    ) -> None:
-        """Update a session's metadata after an interaction."""
-        self._ensure_loaded()
-        
-        if session_key in self._entries:
-            entry = self._entries[session_key]
-            entry.updated_at = datetime.now()
-            entry.input_tokens += input_tokens
-            entry.output_tokens += output_tokens
-            entry.total_tokens = entry.input_tokens + entry.output_tokens
-            self._save()
-    
-    def reset_session(self, session_key: str) -> Optional[SessionEntry]:
-        """Force reset a session, creating a new session ID."""
-        self._ensure_loaded()
-        
-        if session_key not in self._entries:
-            return None
-        
-        old_entry = self._entries[session_key]
-        now = datetime.now()
-        session_id = f"{now.strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
-        
-        new_entry = SessionEntry(
-            session_key=session_key,
-            session_id=session_id,
-            created_at=now,
-            updated_at=now,
-            origin=old_entry.origin,
-            display_name=old_entry.display_name,
-            platform=old_entry.platform,
-            chat_type=old_entry.chat_type,
-        )
-        
-        self._entries[session_key] = new_entry
-        self._save()
-        
-        return new_entry
-    
-    def list_sessions(self, active_minutes: Optional[int] = None) -> List[SessionEntry]:
-        """
-        List all sessions, optionally filtered by activity.
-        
-        Args:
-            active_minutes: If provided, only return sessions updated within this many minutes
-        """
-        self._ensure_loaded()
-        
-        entries = list(self._entries.values())
-        
-        if active_minutes is not None:
-            cutoff = datetime.now() - timedelta(minutes=active_minutes)
-            entries = [e for e in entries if e.updated_at >= cutoff]
-        
-        # Sort by most recently updated
-        entries.sort(key=lambda e: e.updated_at, reverse=True)
-        
-        return entries
-    
-    def get_transcript_path(self, session_id: str) -> Path:
-        """Get the path to a session's transcript file."""
-        return self.sessions_dir / f"{session_id}.jsonl"
-    
-    def append_to_transcript(self, session_id: str, message: Dict[str, Any]) -> None:
-        """Append a message to a session's transcript."""
-        transcript_path = self.get_transcript_path(session_id)
-        
-        with open(transcript_path, "a") as f:
-            f.write(json.dumps(message, ensure_ascii=False) + "\n")
-    
-    def load_transcript(self, session_id: str) -> List[Dict[str, Any]]:
-        """Load all messages from a session's transcript."""
-        transcript_path = self.get_transcript_path(session_id)
-        
-        if not transcript_path.exists():
-            return []
-        
-        messages = []
-        with open(transcript_path, "r") as f:
-            for line in f:
-                line = line.strip()
-                if line:
-                    messages.append(json.loads(line))
-        
-        return messages
-
-
-def build_session_context(
-    source: SessionSource,
-    config: GatewayConfig,
-    session_entry: Optional[SessionEntry] = None
-) -> SessionContext:
-    """
-    Build a full session context from a source and config.
-    
-    This is used to inject context into the agent's system prompt.
-    """
-    connected = config.get_connected_platforms()
-    
-    home_channels = {}
-    for platform in connected:
-        home = config.get_home_channel(platform)
-        if home:
-            home_channels[platform] = home
-    
-    context = SessionContext(
-        source=source,
-        connected_platforms=connected,
-        home_channels=home_channels,
-    )
-    
-    if session_entry:
-        context.session_key = session_entry.session_key
-        context.session_id = session_entry.session_id
-        context.created_at = session_entry.created_at
-        context.updated_at = session_entry.updated_at
-    
-    return context

hermes_cli/__init__.py

@@ -1,14 +0,0 @@
-"""
-Hermes CLI - Unified command-line interface for Hermes Agent.
-
-Provides subcommands for:
-- hermes chat          - Interactive chat (same as ./hermes)
-- hermes gateway       - Run gateway in foreground
-- hermes gateway start - Start gateway service
-- hermes gateway stop  - Stop gateway service  
-- hermes setup         - Interactive setup wizard
-- hermes status        - Show status of all components
-- hermes cron          - Manage cron jobs
-"""
-
-__version__ = "0.1.0"

hermes_cli/config.py

@@ -1,785 +0,0 @@
-"""
-Configuration management for Hermes Agent.
-
-Config files are stored in ~/.hermes/ for easy access:
-- ~/.hermes/config.yaml  - All settings (model, toolsets, terminal, etc.)
-- ~/.hermes/.env         - API keys and secrets
-
-This module provides:
-- hermes config          - Show current configuration
-- hermes config edit     - Open config in editor
-- hermes config set      - Set a specific value
-- hermes config wizard   - Re-run setup wizard
-"""
-
-import os
-import sys
-import subprocess
-from pathlib import Path
-from typing import Dict, Any, Optional, List, Tuple
-
-import yaml
-
-# ANSI colors
-class Colors:
-    RESET = "\033[0m"
-    BOLD = "\033[1m"
-    DIM = "\033[2m"
-    RED = "\033[31m"
-    GREEN = "\033[32m"
-    YELLOW = "\033[33m"
-    BLUE = "\033[34m"
-    MAGENTA = "\033[35m"
-    CYAN = "\033[36m"
-
-def color(text: str, *codes) -> str:
-    if not sys.stdout.isatty():
-        return text
-    return "".join(codes) + text + Colors.RESET
-
-
-# =============================================================================
-# Config paths
-# =============================================================================
-
-def get_hermes_home() -> Path:
-    """Get the Hermes home directory (~/.hermes)."""
-    return Path(os.getenv("HERMES_HOME", Path.home() / ".hermes"))
-
-def get_config_path() -> Path:
-    """Get the main config file path."""
-    return get_hermes_home() / "config.yaml"
-
-def get_env_path() -> Path:
-    """Get the .env file path (for API keys)."""
-    return get_hermes_home() / ".env"
-
-def get_project_root() -> Path:
-    """Get the project installation directory."""
-    return Path(__file__).parent.parent.resolve()
-
-def ensure_hermes_home():
-    """Ensure ~/.hermes directory structure exists."""
-    home = get_hermes_home()
-    (home / "cron").mkdir(parents=True, exist_ok=True)
-    (home / "sessions").mkdir(parents=True, exist_ok=True)
-    (home / "logs").mkdir(parents=True, exist_ok=True)
-
-
-# =============================================================================
-# Config loading/saving
-# =============================================================================
-
-DEFAULT_CONFIG = {
-    "model": "anthropic/claude-sonnet-4.5",
-    "toolsets": ["hermes-cli"],
-    "max_turns": 100,
-    
-    "terminal": {
-        "backend": "local",
-        "cwd": ".",  # Use current directory
-        "timeout": 180,
-        "docker_image": "nikolaik/python-nodejs:python3.11-nodejs20",
-        "singularity_image": "docker://nikolaik/python-nodejs:python3.11-nodejs20",
-        "modal_image": "nikolaik/python-nodejs:python3.11-nodejs20",
-    },
-    
-    "browser": {
-        "inactivity_timeout": 120,
-    },
-    
-    "compression": {
-        "enabled": True,
-        "threshold": 0.85,
-        "summary_model": "google/gemini-2.0-flash-001",
-    },
-    
-    "display": {
-        "compact": False,
-        "personality": "kawaii",
-    },
-    
-    # Permanently allowed dangerous command patterns (added via "always" approval)
-    "command_allowlist": [],
-    
-    # Config schema version - bump this when adding new required fields
-    "_config_version": 1,
-}
-
-# =============================================================================
-# Config Migration System
-# =============================================================================
-
-# Required environment variables with metadata for migration prompts
-REQUIRED_ENV_VARS = {
-    "OPENROUTER_API_KEY": {
-        "description": "OpenRouter API key (required for vision, web scraping, and tools)",
-        "prompt": "OpenRouter API key",
-        "url": "https://openrouter.ai/keys",
-        "required": True,
-        "password": True,
-    },
-}
-
-# Optional environment variables that enhance functionality
-OPTIONAL_ENV_VARS = {
-    "FIRECRAWL_API_KEY": {
-        "description": "Firecrawl API key for web search and scraping",
-        "prompt": "Firecrawl API key",
-        "url": "https://firecrawl.dev/",
-        "tools": ["web_search", "web_extract"],
-        "password": True,
-    },
-    "BROWSERBASE_API_KEY": {
-        "description": "Browserbase API key for browser automation",
-        "prompt": "Browserbase API key", 
-        "url": "https://browserbase.com/",
-        "tools": ["browser_navigate", "browser_click", "etc."],
-        "password": True,
-    },
-    "BROWSERBASE_PROJECT_ID": {
-        "description": "Browserbase project ID",
-        "prompt": "Browserbase project ID",
-        "url": "https://browserbase.com/",
-        "tools": ["browser_navigate", "browser_click", "etc."],
-        "password": False,
-    },
-    "FAL_KEY": {
-        "description": "FAL API key for image generation",
-        "prompt": "FAL API key",
-        "url": "https://fal.ai/",
-        "tools": ["image_generate"],
-        "password": True,
-    },
-    "TINKER_API_KEY": {
-        "description": "Tinker API key for RL training",
-        "prompt": "Tinker API key",
-        "url": "https://tinker-console.thinkingmachines.ai/keys",
-        "tools": ["rl_start_training", "rl_check_status", "rl_stop_training"],
-        "password": True,
-    },
-    "WANDB_API_KEY": {
-        "description": "Weights & Biases API key for experiment tracking",
-        "prompt": "WandB API key",
-        "url": "https://wandb.ai/authorize",
-        "tools": ["rl_get_results", "rl_check_status"],
-        "password": True,
-    },
-    "OPENAI_BASE_URL": {
-        "description": "Custom OpenAI-compatible API endpoint URL",
-        "prompt": "API base URL (e.g., https://api.example.com/v1)",
-        "url": None,
-        "password": False,
-    },
-    "OPENAI_API_KEY": {
-        "description": "API key for custom OpenAI-compatible endpoint",
-        "prompt": "API key for custom endpoint",
-        "url": None,
-        "password": True,
-    },
-    # Messaging platform tokens
-    "TELEGRAM_BOT_TOKEN": {
-        "description": "Telegram bot token from @BotFather",
-        "prompt": "Telegram bot token",
-        "url": "https://t.me/BotFather",
-        "password": True,
-    },
-    "TELEGRAM_ALLOWED_USERS": {
-        "description": "Comma-separated Telegram user IDs allowed to use the bot (get ID from @userinfobot)",
-        "prompt": "Allowed Telegram user IDs (comma-separated)",
-        "url": "https://t.me/userinfobot",
-        "password": False,
-    },
-    "DISCORD_BOT_TOKEN": {
-        "description": "Discord bot token from Developer Portal",
-        "prompt": "Discord bot token",
-        "url": "https://discord.com/developers/applications",
-        "password": True,
-    },
-    "DISCORD_ALLOWED_USERS": {
-        "description": "Comma-separated Discord user IDs allowed to use the bot",
-        "prompt": "Allowed Discord user IDs (comma-separated)",
-        "url": None,
-        "password": False,
-    },
-    # Terminal configuration
-    "MESSAGING_CWD": {
-        "description": "Working directory for terminal commands via messaging (Telegram/Discord/etc). CLI always uses current directory.",
-        "prompt": "Messaging working directory (default: home)",
-        "url": None,
-        "password": False,
-    },
-    "SUDO_PASSWORD": {
-        "description": "Sudo password for terminal commands requiring root access",
-        "prompt": "Sudo password",
-        "url": None,
-        "password": True,
-    },
-    # Agent configuration
-    "HERMES_MAX_ITERATIONS": {
-        "description": "Maximum tool-calling iterations per conversation (default: 60)",
-        "prompt": "Max iterations",
-        "url": None,
-        "password": False,
-    },
-    "HERMES_TOOL_PROGRESS": {
-        "description": "Send tool progress messages in messaging channels (true/false)",
-        "prompt": "Enable tool progress messages",
-        "url": None,
-        "password": False,
-    },
-    "HERMES_TOOL_PROGRESS_MODE": {
-        "description": "Progress mode: 'all' (every tool) or 'new' (only when tool changes)",
-        "prompt": "Progress mode (all/new)",
-        "url": None,
-        "password": False,
-    },
-}
-
-
-def get_missing_env_vars(required_only: bool = False) -> List[Dict[str, Any]]:
-    """
-    Check which environment variables are missing.
-    
-    Returns list of dicts with var info for missing variables.
-    """
-    missing = []
-    
-    # Check required vars
-    for var_name, info in REQUIRED_ENV_VARS.items():
-        if not get_env_value(var_name):
-            missing.append({"name": var_name, **info, "is_required": True})
-    
-    # Check optional vars (if not required_only)
-    if not required_only:
-        for var_name, info in OPTIONAL_ENV_VARS.items():
-            if not get_env_value(var_name):
-                missing.append({"name": var_name, **info, "is_required": False})
-    
-    return missing
-
-
-def get_missing_config_fields() -> List[Dict[str, Any]]:
-    """
-    Check which config fields are missing or outdated.
-    
-    Returns list of missing/outdated fields.
-    """
-    config = load_config()
-    missing = []
-    
-    # Check for new top-level keys in DEFAULT_CONFIG
-    for key, default_value in DEFAULT_CONFIG.items():
-        if key.startswith('_'):
-            continue  # Skip internal keys
-        if key not in config:
-            missing.append({
-                "key": key,
-                "default": default_value,
-                "description": f"New config section: {key}",
-            })
-        elif isinstance(default_value, dict):
-            # Check nested keys
-            for subkey, subvalue in default_value.items():
-                if subkey not in config.get(key, {}):
-                    missing.append({
-                        "key": f"{key}.{subkey}",
-                        "default": subvalue,
-                        "description": f"New config option: {key}.{subkey}",
-                    })
-    
-    return missing
-
-
-def check_config_version() -> Tuple[int, int]:
-    """
-    Check config version.
-    
-    Returns (current_version, latest_version).
-    """
-    config = load_config()
-    current = config.get("_config_version", 0)
-    latest = DEFAULT_CONFIG.get("_config_version", 1)
-    return current, latest
-
-
-def migrate_config(interactive: bool = True, quiet: bool = False) -> Dict[str, Any]:
-    """
-    Migrate config to latest version, prompting for new required fields.
-    
-    Args:
-        interactive: If True, prompt user for missing values
-        quiet: If True, suppress output
-        
-    Returns:
-        Dict with migration results: {"env_added": [...], "config_added": [...], "warnings": [...]}
-    """
-    results = {"env_added": [], "config_added": [], "warnings": []}
-    
-    # Check config version
-    current_ver, latest_ver = check_config_version()
-    
-    if current_ver < latest_ver and not quiet:
-        print(f"Config version: {current_ver} → {latest_ver}")
-    
-    # Check for missing required env vars
-    missing_env = get_missing_env_vars(required_only=True)
-    
-    if missing_env and not quiet:
-        print("\n⚠️  Missing required environment variables:")
-        for var in missing_env:
-            print(f"   • {var['name']}: {var['description']}")
-    
-    if interactive and missing_env:
-        print("\nLet's configure them now:\n")
-        for var in missing_env:
-            if var.get("url"):
-                print(f"  Get your key at: {var['url']}")
-            
-            if var.get("password"):
-                import getpass
-                value = getpass.getpass(f"  {var['prompt']}: ")
-            else:
-                value = input(f"  {var['prompt']}: ").strip()
-            
-            if value:
-                save_env_value(var["name"], value)
-                results["env_added"].append(var["name"])
-                print(f"  ✓ Saved {var['name']}")
-            else:
-                results["warnings"].append(f"Skipped {var['name']} - some features may not work")
-            print()
-    
-    # Check for missing config fields
-    missing_config = get_missing_config_fields()
-    
-    if missing_config:
-        config = load_config()
-        
-        for field in missing_config:
-            key = field["key"]
-            default = field["default"]
-            
-            # Add with default value
-            if "." in key:
-                # Nested key
-                parent, child = key.split(".", 1)
-                if parent not in config:
-                    config[parent] = {}
-                config[parent][child] = default
-            else:
-                config[key] = default
-            
-            results["config_added"].append(key)
-            if not quiet:
-                print(f"  ✓ Added {key} = {default}")
-        
-        # Update version and save
-        config["_config_version"] = latest_ver
-        save_config(config)
-    elif current_ver < latest_ver:
-        # Just update version
-        config = load_config()
-        config["_config_version"] = latest_ver
-        save_config(config)
-    
-    return results
-
-
-def load_config() -> Dict[str, Any]:
-    """Load configuration from ~/.hermes/config.yaml."""
-    config_path = get_config_path()
-    
-    config = DEFAULT_CONFIG.copy()
-    
-    if config_path.exists():
-        try:
-            with open(config_path) as f:
-                user_config = yaml.safe_load(f) or {}
-            
-            # Deep merge
-            for key, value in user_config.items():
-                if isinstance(value, dict) and key in config and isinstance(config[key], dict):
-                    config[key].update(value)
-                else:
-                    config[key] = value
-        except Exception as e:
-            print(f"Warning: Failed to load config: {e}")
-    
-    return config
-
-
-def save_config(config: Dict[str, Any]):
-    """Save configuration to ~/.hermes/config.yaml."""
-    ensure_hermes_home()
-    config_path = get_config_path()
-    
-    with open(config_path, 'w') as f:
-        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
-
-
-def load_env() -> Dict[str, str]:
-    """Load environment variables from ~/.hermes/.env."""
-    env_path = get_env_path()
-    env_vars = {}
-    
-    if env_path.exists():
-        with open(env_path) as f:
-            for line in f:
-                line = line.strip()
-                if line and not line.startswith('#') and '=' in line:
-                    key, _, value = line.partition('=')
-                    env_vars[key.strip()] = value.strip().strip('"\'')
-    
-    return env_vars
-
-
-def save_env_value(key: str, value: str):
-    """Save or update a value in ~/.hermes/.env."""
-    ensure_hermes_home()
-    env_path = get_env_path()
-    
-    # Load existing
-    lines = []
-    if env_path.exists():
-        with open(env_path) as f:
-            lines = f.readlines()
-    
-    # Find and update or append
-    found = False
-    for i, line in enumerate(lines):
-        if line.strip().startswith(f"{key}="):
-            lines[i] = f"{key}={value}\n"
-            found = True
-            break
-    
-    if not found:
-        lines.append(f"{key}={value}\n")
-    
-    with open(env_path, 'w') as f:
-        f.writelines(lines)
-
-
-def get_env_value(key: str) -> Optional[str]:
-    """Get a value from ~/.hermes/.env or environment."""
-    # Check environment first
-    if key in os.environ:
-        return os.environ[key]
-    
-    # Then check .env file
-    env_vars = load_env()
-    return env_vars.get(key)
-
-
-# =============================================================================
-# Config display
-# =============================================================================
-
-def redact_key(key: str) -> str:
-    """Redact an API key for display."""
-    if not key:
-        return color("(not set)", Colors.DIM)
-    if len(key) < 12:
-        return "***"
-    return key[:4] + "..." + key[-4:]
-
-
-def show_config():
-    """Display current configuration."""
-    config = load_config()
-    env_vars = load_env()
-    
-    print()
-    print(color("┌─────────────────────────────────────────────────────────┐", Colors.CYAN))
-    print(color("│              🦋 Hermes Configuration                    │", Colors.CYAN))
-    print(color("└─────────────────────────────────────────────────────────┘", Colors.CYAN))
-    
-    # Paths
-    print()
-    print(color("◆ Paths", Colors.CYAN, Colors.BOLD))
-    print(f"  Config:       {get_config_path()}")
-    print(f"  Secrets:      {get_env_path()}")
-    print(f"  Install:      {get_project_root()}")
-    
-    # API Keys
-    print()
-    print(color("◆ API Keys", Colors.CYAN, Colors.BOLD))
-    
-    keys = [
-        ("OPENROUTER_API_KEY", "OpenRouter"),
-        ("ANTHROPIC_API_KEY", "Anthropic"),
-        ("OPENAI_API_KEY", "OpenAI"),
-        ("FIRECRAWL_API_KEY", "Firecrawl"),
-        ("BROWSERBASE_API_KEY", "Browserbase"),
-        ("FAL_KEY", "FAL"),
-    ]
-    
-    for env_key, name in keys:
-        value = get_env_value(env_key)
-        print(f"  {name:<14} {redact_key(value)}")
-    
-    # Model settings
-    print()
-    print(color("◆ Model", Colors.CYAN, Colors.BOLD))
-    print(f"  Model:        {config.get('model', 'not set')}")
-    print(f"  Max turns:    {config.get('max_turns', 100)}")
-    print(f"  Toolsets:     {', '.join(config.get('toolsets', ['all']))}")
-    
-    # Terminal
-    print()
-    print(color("◆ Terminal", Colors.CYAN, Colors.BOLD))
-    terminal = config.get('terminal', {})
-    print(f"  Backend:      {terminal.get('backend', 'local')}")
-    print(f"  Working dir:  {terminal.get('cwd', '.')}")
-    print(f"  Timeout:      {terminal.get('timeout', 60)}s")
-    
-    if terminal.get('backend') == 'docker':
-        print(f"  Docker image: {terminal.get('docker_image', 'python:3.11-slim')}")
-    elif terminal.get('backend') == 'singularity':
-        print(f"  Image:        {terminal.get('singularity_image', 'docker://python:3.11')}")
-    elif terminal.get('backend') == 'modal':
-        print(f"  Modal image:  {terminal.get('modal_image', 'python:3.11')}")
-        modal_token = get_env_value('MODAL_TOKEN_ID')
-        print(f"  Modal token:  {'configured' if modal_token else '(not set)'}")
-    elif terminal.get('backend') == 'ssh':
-        ssh_host = get_env_value('TERMINAL_SSH_HOST')
-        ssh_user = get_env_value('TERMINAL_SSH_USER')
-        print(f"  SSH host:     {ssh_host or '(not set)'}")
-        print(f"  SSH user:     {ssh_user or '(not set)'}")
-    
-    # Compression
-    print()
-    print(color("◆ Context Compression", Colors.CYAN, Colors.BOLD))
-    compression = config.get('compression', {})
-    enabled = compression.get('enabled', True)
-    print(f"  Enabled:      {'yes' if enabled else 'no'}")
-    if enabled:
-        print(f"  Threshold:    {compression.get('threshold', 0.85) * 100:.0f}%")
-        print(f"  Model:        {compression.get('summary_model', 'google/gemini-2.0-flash-001')}")
-    
-    # Messaging
-    print()
-    print(color("◆ Messaging Platforms", Colors.CYAN, Colors.BOLD))
-    
-    telegram_token = get_env_value('TELEGRAM_BOT_TOKEN')
-    discord_token = get_env_value('DISCORD_BOT_TOKEN')
-    
-    print(f"  Telegram:     {'configured' if telegram_token else color('not configured', Colors.DIM)}")
-    print(f"  Discord:      {'configured' if discord_token else color('not configured', Colors.DIM)}")
-    
-    print()
-    print(color("─" * 60, Colors.DIM))
-    print(color("  hermes config edit     # Edit config file", Colors.DIM))
-    print(color("  hermes config set KEY VALUE", Colors.DIM))
-    print(color("  hermes setup           # Run setup wizard", Colors.DIM))
-    print()
-
-
-def edit_config():
-    """Open config file in user's editor."""
-    config_path = get_config_path()
-    
-    # Ensure config exists
-    if not config_path.exists():
-        save_config(DEFAULT_CONFIG)
-        print(f"Created {config_path}")
-    
-    # Find editor
-    editor = os.getenv('EDITOR') or os.getenv('VISUAL')
-    
-    if not editor:
-        # Try common editors
-        for cmd in ['nano', 'vim', 'vi', 'code', 'notepad']:
-            import shutil
-            if shutil.which(cmd):
-                editor = cmd
-                break
-    
-    if not editor:
-        print(f"No editor found. Config file is at:")
-        print(f"  {config_path}")
-        return
-    
-    print(f"Opening {config_path} in {editor}...")
-    subprocess.run([editor, str(config_path)])
-
-
-def set_config_value(key: str, value: str):
-    """Set a configuration value."""
-    # Check if it's an API key (goes to .env)
-    api_keys = [
-        'OPENROUTER_API_KEY', 'ANTHROPIC_API_KEY', 'OPENAI_API_KEY',
-        'FIRECRAWL_API_KEY', 'BROWSERBASE_API_KEY', 'BROWSERBASE_PROJECT_ID',
-        'FAL_KEY', 'TELEGRAM_BOT_TOKEN', 'DISCORD_BOT_TOKEN',
-        'TERMINAL_SSH_HOST', 'TERMINAL_SSH_USER', 'TERMINAL_SSH_KEY',
-        'SUDO_PASSWORD'
-    ]
-    
-    if key.upper() in api_keys or key.upper().startswith('TERMINAL_SSH'):
-        save_env_value(key.upper(), value)
-        print(f"✓ Set {key} in {get_env_path()}")
-        return
-    
-    # Otherwise it goes to config.yaml
-    config = load_config()
-    
-    # Handle nested keys (e.g., "terminal.backend")
-    parts = key.split('.')
-    current = config
-    
-    for part in parts[:-1]:
-        if part not in current:
-            current[part] = {}
-        current = current[part]
-    
-    # Convert value to appropriate type
-    if value.lower() in ('true', 'yes', 'on'):
-        value = True
-    elif value.lower() in ('false', 'no', 'off'):
-        value = False
-    elif value.isdigit():
-        value = int(value)
-    elif value.replace('.', '', 1).isdigit():
-        value = float(value)
-    
-    current[parts[-1]] = value
-    save_config(config)
-    print(f"✓ Set {key} = {value} in {get_config_path()}")
-
-
-# =============================================================================
-# Command handler
-# =============================================================================
-
-def config_command(args):
-    """Handle config subcommands."""
-    subcmd = getattr(args, 'config_command', None)
-    
-    if subcmd is None or subcmd == "show":
-        show_config()
-    
-    elif subcmd == "edit":
-        edit_config()
-    
-    elif subcmd == "set":
-        key = getattr(args, 'key', None)
-        value = getattr(args, 'value', None)
-        if not key or not value:
-            print("Usage: hermes config set KEY VALUE")
-            print()
-            print("Examples:")
-            print("  hermes config set model anthropic/claude-sonnet-4")
-            print("  hermes config set terminal.backend docker")
-            print("  hermes config set OPENROUTER_API_KEY sk-or-...")
-            sys.exit(1)
-        set_config_value(key, value)
-    
-    elif subcmd == "path":
-        print(get_config_path())
-    
-    elif subcmd == "env-path":
-        print(get_env_path())
-    
-    elif subcmd == "migrate":
-        print()
-        print(color("🔄 Checking configuration for updates...", Colors.CYAN, Colors.BOLD))
-        print()
-        
-        # Check what's missing
-        missing_env = get_missing_env_vars(required_only=False)
-        missing_config = get_missing_config_fields()
-        current_ver, latest_ver = check_config_version()
-        
-        if not missing_env and not missing_config and current_ver >= latest_ver:
-            print(color("✓ Configuration is up to date!", Colors.GREEN))
-            print()
-            return
-        
-        # Show what needs to be updated
-        if current_ver < latest_ver:
-            print(f"  Config version: {current_ver} → {latest_ver}")
-        
-        if missing_config:
-            print(f"\n  {len(missing_config)} new config option(s) will be added with defaults")
-        
-        required_missing = [v for v in missing_env if v.get("is_required")]
-        optional_missing = [v for v in missing_env if not v.get("is_required")]
-        
-        if required_missing:
-            print(f"\n  ⚠️  {len(required_missing)} required API key(s) missing:")
-            for var in required_missing:
-                print(f"     • {var['name']}")
-        
-        if optional_missing:
-            print(f"\n  ℹ️  {len(optional_missing)} optional API key(s) not configured:")
-            for var in optional_missing:
-                tools = var.get("tools", [])
-                tools_str = f" (enables: {', '.join(tools[:2])})" if tools else ""
-                print(f"     • {var['name']}{tools_str}")
-        
-        print()
-        
-        # Run migration
-        results = migrate_config(interactive=True, quiet=False)
-        
-        print()
-        if results["env_added"] or results["config_added"]:
-            print(color("✓ Configuration updated!", Colors.GREEN))
-        
-        if results["warnings"]:
-            print()
-            for warning in results["warnings"]:
-                print(color(f"  ⚠️  {warning}", Colors.YELLOW))
-        
-        print()
-    
-    elif subcmd == "check":
-        # Non-interactive check for what's missing
-        print()
-        print(color("📋 Configuration Status", Colors.CYAN, Colors.BOLD))
-        print()
-        
-        current_ver, latest_ver = check_config_version()
-        if current_ver >= latest_ver:
-            print(f"  Config version: {current_ver} ✓")
-        else:
-            print(color(f"  Config version: {current_ver} → {latest_ver} (update available)", Colors.YELLOW))
-        
-        print()
-        print(color("  Required:", Colors.BOLD))
-        for var_name in REQUIRED_ENV_VARS:
-            if get_env_value(var_name):
-                print(f"    ✓ {var_name}")
-            else:
-                print(color(f"    ✗ {var_name} (missing)", Colors.RED))
-        
-        print()
-        print(color("  Optional:", Colors.BOLD))
-        for var_name, info in OPTIONAL_ENV_VARS.items():
-            if get_env_value(var_name):
-                print(f"    ✓ {var_name}")
-            else:
-                tools = info.get("tools", [])
-                tools_str = f" → {', '.join(tools[:2])}" if tools else ""
-                print(color(f"    ○ {var_name}{tools_str}", Colors.DIM))
-        
-        missing_config = get_missing_config_fields()
-        if missing_config:
-            print()
-            print(color(f"  {len(missing_config)} new config option(s) available", Colors.YELLOW))
-            print(f"    Run 'hermes config migrate' to add them")
-        
-        print()
-    
-    else:
-        print(f"Unknown config command: {subcmd}")
-        print()
-        print("Available commands:")
-        print("  hermes config           Show current configuration")
-        print("  hermes config edit      Open config in editor")
-        print("  hermes config set K V   Set a config value")
-        print("  hermes config check     Check for missing/outdated config")
-        print("  hermes config migrate   Update config with new options")
-        print("  hermes config path      Show config file path")
-        print("  hermes config env-path  Show .env file path")
-        sys.exit(1)

hermes_cli/cron.py

@@ -1,131 +0,0 @@
-"""
-Cron subcommand for hermes CLI.
-
-Handles: hermes cron [list|daemon|tick]
-"""
-
-import json
-import sys
-import time
-from pathlib import Path
-from datetime import datetime
-
-PROJECT_ROOT = Path(__file__).parent.parent.resolve()
-sys.path.insert(0, str(PROJECT_ROOT))
-
-# ANSI colors
-class Colors:
-    RESET = "\033[0m"
-    BOLD = "\033[1m"
-    DIM = "\033[2m"
-    RED = "\033[31m"
-    GREEN = "\033[32m"
-    YELLOW = "\033[33m"
-    CYAN = "\033[36m"
-
-def color(text: str, *codes) -> str:
-    if not sys.stdout.isatty():
-        return text
-    return "".join(codes) + text + Colors.RESET
-
-
-def cron_list(show_all: bool = False):
-    """List all scheduled jobs."""
-    from cron.jobs import list_jobs
-    
-    jobs = list_jobs(include_disabled=show_all)
-    
-    if not jobs:
-        print(color("No scheduled jobs.", Colors.DIM))
-        print(color("Create one with: hermes cron add <schedule> <prompt>", Colors.DIM))
-        return
-    
-    print()
-    print(color("┌─────────────────────────────────────────────────────────────────────────┐", Colors.CYAN))
-    print(color("│                         Scheduled Jobs                                  │", Colors.CYAN))
-    print(color("└─────────────────────────────────────────────────────────────────────────┘", Colors.CYAN))
-    print()
-    
-    for job in jobs:
-        job_id = job.get("id", "?")[:8]
-        name = job.get("name", "(unnamed)")
-        schedule = job.get("schedule_display", job.get("schedule", {}).get("value", "?"))
-        enabled = job.get("enabled", True)
-        next_run = job.get("next_run_at", "?")
-        
-        # Repeat info
-        repeat_info = job.get("repeat", {})
-        repeat_times = repeat_info.get("times")
-        repeat_completed = repeat_info.get("completed", 0)
-        
-        if repeat_times:
-            repeat_str = f"{repeat_completed}/{repeat_times}"
-        else:
-            repeat_str = "∞"
-        
-        # Delivery targets
-        deliver = job.get("deliver", ["local"])
-        if isinstance(deliver, str):
-            deliver = [deliver]
-        deliver_str = ", ".join(deliver)
-        
-        # Status indicator
-        if not enabled:
-            status = color("[disabled]", Colors.RED)
-        else:
-            status = color("[active]", Colors.GREEN)
-        
-        print(f"  {color(job_id, Colors.YELLOW)} {status}")
-        print(f"    Name:      {name}")
-        print(f"    Schedule:  {schedule}")
-        print(f"    Repeat:    {repeat_str}")
-        print(f"    Next run:  {next_run}")
-        print(f"    Deliver:   {deliver_str}")
-        print()
-
-
-def cron_daemon(interval: int = 60):
-    """Run the cron daemon."""
-    from cron.scheduler import start_daemon
-    
-    print(color("┌─────────────────────────────────────────────────────────┐", Colors.CYAN))
-    print(color("│              🦋 Hermes Cron Daemon                      │", Colors.CYAN))
-    print(color("├─────────────────────────────────────────────────────────┤", Colors.CYAN))
-    print(color("│  Press Ctrl+C to stop                                   │", Colors.CYAN))
-    print(color("└─────────────────────────────────────────────────────────┘", Colors.CYAN))
-    print()
-    
-    try:
-        start_daemon(interval=interval)
-    except KeyboardInterrupt:
-        print()
-        print(color("Cron daemon stopped.", Colors.YELLOW))
-
-
-def cron_tick():
-    """Run due jobs once (for system cron integration)."""
-    from cron.scheduler import tick
-    
-    print(f"[{datetime.now().isoformat()}] Running cron tick...")
-    tick()
-
-
-def cron_command(args):
-    """Handle cron subcommands."""
-    subcmd = getattr(args, 'cron_command', None)
-    
-    if subcmd is None or subcmd == "list":
-        show_all = getattr(args, 'all', False)
-        cron_list(show_all)
-    
-    elif subcmd == "daemon":
-        interval = getattr(args, 'interval', 60)
-        cron_daemon(interval)
-    
-    elif subcmd == "tick":
-        cron_tick()
-    
-    else:
-        print(f"Unknown cron command: {subcmd}")
-        print("Usage: hermes cron [list|daemon|tick]")
-        sys.exit(1)

hermes_cli/doctor.py

@@ -1,352 +0,0 @@
-"""
-Doctor command for hermes CLI.
-
-Diagnoses issues with Hermes Agent setup.
-"""
-
-import os
-import sys
-import subprocess
-import shutil
-from pathlib import Path
-
-PROJECT_ROOT = Path(__file__).parent.parent.resolve()
-
-# ANSI colors
-class Colors:
-    RESET = "\033[0m"
-    BOLD = "\033[1m"
-    DIM = "\033[2m"
-    RED = "\033[31m"
-    GREEN = "\033[32m"
-    YELLOW = "\033[33m"
-    CYAN = "\033[36m"
-
-def color(text: str, *codes) -> str:
-    if not sys.stdout.isatty():
-        return text
-    return "".join(codes) + text + Colors.RESET
-
-def check_ok(text: str, detail: str = ""):
-    print(f"  {color('✓', Colors.GREEN)} {text}" + (f" {color(detail, Colors.DIM)}" if detail else ""))
-
-def check_warn(text: str, detail: str = ""):
-    print(f"  {color('⚠', Colors.YELLOW)} {text}" + (f" {color(detail, Colors.DIM)}" if detail else ""))
-
-def check_fail(text: str, detail: str = ""):
-    print(f"  {color('✗', Colors.RED)} {text}" + (f" {color(detail, Colors.DIM)}" if detail else ""))
-
-def check_info(text: str):
-    print(f"    {color('→', Colors.CYAN)} {text}")
-
-
-def run_doctor(args):
-    """Run diagnostic checks."""
-    should_fix = getattr(args, 'fix', False)
-    
-    issues = []
-    
-    print()
-    print(color("┌─────────────────────────────────────────────────────────┐", Colors.CYAN))
-    print(color("│                 🩺 Hermes Doctor                        │", Colors.CYAN))
-    print(color("└─────────────────────────────────────────────────────────┘", Colors.CYAN))
-    
-    # =========================================================================
-    # Check: Python version
-    # =========================================================================
-    print()
-    print(color("◆ Python Environment", Colors.CYAN, Colors.BOLD))
-    
-    py_version = sys.version_info
-    if py_version >= (3, 11):
-        check_ok(f"Python {py_version.major}.{py_version.minor}.{py_version.micro}")
-    elif py_version >= (3, 10):
-        check_ok(f"Python {py_version.major}.{py_version.minor}.{py_version.micro}")
-        check_warn("Python 3.11+ recommended for RL Training tools (tinker requires >= 3.11)")
-    elif py_version >= (3, 8):
-        check_warn(f"Python {py_version.major}.{py_version.minor}.{py_version.micro}", "(3.10+ recommended)")
-    else:
-        check_fail(f"Python {py_version.major}.{py_version.minor}.{py_version.micro}", "(3.10+ required)")
-        issues.append("Upgrade Python to 3.10+")
-    
-    # Check if in virtual environment
-    in_venv = sys.prefix != sys.base_prefix
-    if in_venv:
-        check_ok("Virtual environment active")
-    else:
-        check_warn("Not in virtual environment", "(recommended)")
-    
-    # =========================================================================
-    # Check: Required packages
-    # =========================================================================
-    print()
-    print(color("◆ Required Packages", Colors.CYAN, Colors.BOLD))
-    
-    required_packages = [
-        ("openai", "OpenAI SDK"),
-        ("rich", "Rich (terminal UI)"),
-        ("dotenv", "python-dotenv"),
-        ("yaml", "PyYAML"),
-        ("httpx", "HTTPX"),
-    ]
-    
-    optional_packages = [
-        ("croniter", "Croniter (cron expressions)"),
-        ("browserbase", "Browserbase SDK"),
-        ("telegram", "python-telegram-bot"),
-        ("discord", "discord.py"),
-    ]
-    
-    for module, name in required_packages:
-        try:
-            __import__(module)
-            check_ok(name)
-        except ImportError:
-            check_fail(name, "(missing)")
-            issues.append(f"Install {name}: uv pip install {module}")
-    
-    for module, name in optional_packages:
-        try:
-            __import__(module)
-            check_ok(name, "(optional)")
-        except ImportError:
-            check_warn(name, "(optional, not installed)")
-    
-    # =========================================================================
-    # Check: Configuration files
-    # =========================================================================
-    print()
-    print(color("◆ Configuration Files", Colors.CYAN, Colors.BOLD))
-    
-    env_path = PROJECT_ROOT / '.env'
-    if env_path.exists():
-        check_ok(".env file exists")
-        
-        # Check for common issues
-        content = env_path.read_text()
-        if "OPENROUTER_API_KEY" in content or "ANTHROPIC_API_KEY" in content:
-            check_ok("API key configured")
-        else:
-            check_warn("No API key found in .env")
-            issues.append("Run 'hermes setup' to configure API keys")
-    else:
-        check_fail(".env file missing")
-        check_info("Run 'hermes setup' to create one")
-        issues.append("Run 'hermes setup' to create .env")
-    
-    config_path = PROJECT_ROOT / 'cli-config.yaml'
-    if config_path.exists():
-        check_ok("cli-config.yaml exists")
-    else:
-        check_warn("cli-config.yaml not found", "(using defaults)")
-    
-    # =========================================================================
-    # Check: Directory structure
-    # =========================================================================
-    print()
-    print(color("◆ Directory Structure", Colors.CYAN, Colors.BOLD))
-    
-    hermes_home = Path.home() / ".hermes"
-    if hermes_home.exists():
-        check_ok("~/.hermes directory exists")
-    else:
-        check_warn("~/.hermes not found", "(will be created on first use)")
-    
-    logs_dir = PROJECT_ROOT / "logs"
-    if logs_dir.exists():
-        check_ok("logs/ directory exists")
-    else:
-        check_warn("logs/ not found", "(will be created on first use)")
-    
-    # =========================================================================
-    # Check: External tools
-    # =========================================================================
-    print()
-    print(color("◆ External Tools", Colors.CYAN, Colors.BOLD))
-    
-    # Git
-    if shutil.which("git"):
-        check_ok("git")
-    else:
-        check_warn("git not found", "(optional)")
-    
-    # ripgrep (optional, for faster file search)
-    if shutil.which("rg"):
-        check_ok("ripgrep (rg)", "(faster file search)")
-    else:
-        check_warn("ripgrep (rg) not found", "(file search uses grep fallback)")
-        check_info("Install for faster search: sudo apt install ripgrep")
-    
-    # Docker (optional)
-    terminal_env = os.getenv("TERMINAL_ENV", "local")
-    if terminal_env == "docker":
-        if shutil.which("docker"):
-            # Check if docker daemon is running
-            result = subprocess.run(["docker", "info"], capture_output=True)
-            if result.returncode == 0:
-                check_ok("docker", "(daemon running)")
-            else:
-                check_fail("docker daemon not running")
-                issues.append("Start Docker daemon")
-        else:
-            check_fail("docker not found", "(required for TERMINAL_ENV=docker)")
-            issues.append("Install Docker or change TERMINAL_ENV")
-    else:
-        if shutil.which("docker"):
-            check_ok("docker", "(optional)")
-        else:
-            check_warn("docker not found", "(optional)")
-    
-    # SSH (if using ssh backend)
-    if terminal_env == "ssh":
-        ssh_host = os.getenv("TERMINAL_SSH_HOST")
-        if ssh_host:
-            # Try to connect
-            result = subprocess.run(
-                ["ssh", "-o", "ConnectTimeout=5", "-o", "BatchMode=yes", ssh_host, "echo ok"],
-                capture_output=True,
-                text=True
-            )
-            if result.returncode == 0:
-                check_ok(f"SSH connection to {ssh_host}")
-            else:
-                check_fail(f"SSH connection to {ssh_host}")
-                issues.append(f"Check SSH configuration for {ssh_host}")
-        else:
-            check_fail("TERMINAL_SSH_HOST not set", "(required for TERMINAL_ENV=ssh)")
-            issues.append("Set TERMINAL_SSH_HOST in .env")
-    
-    # =========================================================================
-    # Check: API connectivity
-    # =========================================================================
-    print()
-    print(color("◆ API Connectivity", Colors.CYAN, Colors.BOLD))
-    
-    openrouter_key = os.getenv("OPENROUTER_API_KEY")
-    if openrouter_key:
-        try:
-            import httpx
-            response = httpx.get(
-                "https://openrouter.ai/api/v1/models",
-                headers={"Authorization": f"Bearer {openrouter_key}"},
-                timeout=10
-            )
-            if response.status_code == 200:
-                check_ok("OpenRouter API")
-            elif response.status_code == 401:
-                check_fail("OpenRouter API", "(invalid API key)")
-                issues.append("Check OPENROUTER_API_KEY in .env")
-            else:
-                check_fail("OpenRouter API", f"(HTTP {response.status_code})")
-        except Exception as e:
-            check_fail("OpenRouter API", f"({e})")
-            issues.append("Check network connectivity")
-    else:
-        check_warn("OpenRouter API", "(not configured)")
-    
-    anthropic_key = os.getenv("ANTHROPIC_API_KEY")
-    if anthropic_key:
-        try:
-            import httpx
-            response = httpx.get(
-                "https://api.anthropic.com/v1/models",
-                headers={
-                    "x-api-key": anthropic_key,
-                    "anthropic-version": "2023-06-01"
-                },
-                timeout=10
-            )
-            if response.status_code == 200:
-                check_ok("Anthropic API")
-            elif response.status_code == 401:
-                check_fail("Anthropic API", "(invalid API key)")
-            else:
-                # Note: Anthropic may not have /models endpoint
-                check_warn("Anthropic API", "(couldn't verify)")
-        except Exception as e:
-            check_warn("Anthropic API", f"({e})")
-    
-    # =========================================================================
-    # Check: Submodules
-    # =========================================================================
-    print()
-    print(color("◆ Submodules", Colors.CYAN, Colors.BOLD))
-    
-    # mini-swe-agent (terminal tool backend)
-    mini_swe_dir = PROJECT_ROOT / "mini-swe-agent"
-    if mini_swe_dir.exists() and (mini_swe_dir / "pyproject.toml").exists():
-        try:
-            __import__("minisweagent")
-            check_ok("mini-swe-agent", "(terminal backend)")
-        except ImportError:
-            check_warn("mini-swe-agent found but not installed", "(run: uv pip install -e ./mini-swe-agent)")
-            issues.append("Install mini-swe-agent: uv pip install -e ./mini-swe-agent")
-    else:
-        check_warn("mini-swe-agent not found", "(run: git submodule update --init --recursive)")
-    
-    # tinker-atropos (RL training backend)
-    tinker_dir = PROJECT_ROOT / "tinker-atropos"
-    if tinker_dir.exists() and (tinker_dir / "pyproject.toml").exists():
-        if py_version >= (3, 11):
-            try:
-                __import__("tinker_atropos")
-                check_ok("tinker-atropos", "(RL training backend)")
-            except ImportError:
-                check_warn("tinker-atropos found but not installed", "(run: uv pip install -e ./tinker-atropos)")
-                issues.append("Install tinker-atropos: uv pip install -e ./tinker-atropos")
-        else:
-            check_warn("tinker-atropos requires Python 3.11+", f"(current: {py_version.major}.{py_version.minor})")
-    else:
-        check_warn("tinker-atropos not found", "(run: git submodule update --init --recursive)")
-    
-    # =========================================================================
-    # Check: Tool Availability
-    # =========================================================================
-    print()
-    print(color("◆ Tool Availability", Colors.CYAN, Colors.BOLD))
-    
-    try:
-        # Add project root to path for imports
-        sys.path.insert(0, str(PROJECT_ROOT))
-        from model_tools import check_tool_availability, TOOLSET_REQUIREMENTS
-        
-        available, unavailable = check_tool_availability()
-        
-        for tid in available:
-            info = TOOLSET_REQUIREMENTS.get(tid, {})
-            check_ok(info.get("name", tid))
-        
-        for item in unavailable:
-            if item["missing_vars"]:
-                vars_str = ", ".join(item["missing_vars"])
-                check_warn(item["name"], f"(missing {vars_str})")
-            else:
-                check_warn(item["name"], "(system dependency not met)")
-        
-        # Count disabled tools with API key requirements
-        api_disabled = [u for u in unavailable if u["missing_vars"]]
-        if api_disabled:
-            issues.append("Run 'hermes setup' to configure missing API keys for full tool access")
-    except Exception as e:
-        check_warn("Could not check tool availability", f"({e})")
-    
-    # =========================================================================
-    # Summary
-    # =========================================================================
-    print()
-    if issues:
-        print(color("─" * 60, Colors.YELLOW))
-        print(color(f"  Found {len(issues)} issue(s) to address:", Colors.YELLOW, Colors.BOLD))
-        print()
-        for i, issue in enumerate(issues, 1):
-            print(f"  {i}. {issue}")
-        print()
-        
-        if should_fix:
-            print(color("  Attempting auto-fix is not yet implemented.", Colors.DIM))
-            print(color("  Please resolve issues manually.", Colors.DIM))
-    else:
-        print(color("─" * 60, Colors.GREEN))
-        print(color("  All checks passed! 🎉", Colors.GREEN, Colors.BOLD))
-    
-    print()

hermes_cli/gateway.py

@@ -1,487 +0,0 @@
-"""
-Gateway subcommand for hermes CLI.
-
-Handles: hermes gateway [run|start|stop|restart|status|install|uninstall]
-"""
-
-import asyncio
-import os
-import signal
-import subprocess
-import sys
-from pathlib import Path
-
-PROJECT_ROOT = Path(__file__).parent.parent.resolve()
-
-
-# =============================================================================
-# Process Management (for manual gateway runs)
-# =============================================================================
-
-def find_gateway_pids() -> list:
-    """Find PIDs of running gateway processes."""
-    pids = []
-    try:
-        # Look for gateway processes with multiple patterns
-        patterns = [
-            "hermes_cli.main gateway",
-            "hermes gateway",
-            "gateway/run.py",
-        ]
-        
-        result = subprocess.run(
-            ["ps", "aux"],
-            capture_output=True,
-            text=True
-        )
-        
-        for line in result.stdout.split('\n'):
-            # Skip grep and current process
-            if 'grep' in line or str(os.getpid()) in line:
-                continue
-            
-            for pattern in patterns:
-                if pattern in line:
-                    parts = line.split()
-                    if len(parts) > 1:
-                        try:
-                            pid = int(parts[1])
-                            if pid not in pids:
-                                pids.append(pid)
-                        except ValueError:
-                            continue
-                    break
-    except Exception:
-        pass
-    
-    return pids
-
-
-def kill_gateway_processes(force: bool = False) -> int:
-    """Kill any running gateway processes. Returns count killed."""
-    pids = find_gateway_pids()
-    killed = 0
-    
-    for pid in pids:
-        try:
-            if force:
-                os.kill(pid, signal.SIGKILL)
-            else:
-                os.kill(pid, signal.SIGTERM)
-            killed += 1
-        except ProcessLookupError:
-            # Process already gone
-            pass
-        except PermissionError:
-            print(f"⚠ Permission denied to kill PID {pid}")
-    
-    return killed
-
-
-def is_linux() -> bool:
-    return sys.platform.startswith('linux')
-
-def is_macos() -> bool:
-    return sys.platform == 'darwin'
-
-def is_windows() -> bool:
-    return sys.platform == 'win32'
-
-
-# =============================================================================
-# Service Configuration
-# =============================================================================
-
-SERVICE_NAME = "hermes-gateway"
-SERVICE_DESCRIPTION = "Hermes Agent Gateway - Messaging Platform Integration"
-
-def get_systemd_unit_path() -> Path:
-    return Path.home() / ".config" / "systemd" / "user" / f"{SERVICE_NAME}.service"
-
-def get_launchd_plist_path() -> Path:
-    return Path.home() / "Library" / "LaunchAgents" / "ai.hermes.gateway.plist"
-
-def get_python_path() -> str:
-    venv_python = PROJECT_ROOT / "venv" / "bin" / "python"
-    if venv_python.exists():
-        return str(venv_python)
-    return sys.executable
-
-def get_hermes_cli_path() -> str:
-    """Get the path to the hermes CLI."""
-    # Check if installed via pip
-    import shutil
-    hermes_bin = shutil.which("hermes")
-    if hermes_bin:
-        return hermes_bin
-    
-    # Fallback to direct module execution
-    return f"{get_python_path()} -m hermes_cli.main"
-
-
-# =============================================================================
-# Systemd (Linux)
-# =============================================================================
-
-def generate_systemd_unit() -> str:
-    python_path = get_python_path()
-    working_dir = str(PROJECT_ROOT)
-    
-    return f"""[Unit]
-Description={SERVICE_DESCRIPTION}
-After=network.target
-
-[Service]
-Type=simple
-ExecStart={python_path} -m hermes_cli.main gateway run
-WorkingDirectory={working_dir}
-Restart=on-failure
-RestartSec=10
-StandardOutput=journal
-StandardError=journal
-
-[Install]
-WantedBy=default.target
-"""
-
-def systemd_install(force: bool = False):
-    unit_path = get_systemd_unit_path()
-    
-    if unit_path.exists() and not force:
-        print(f"Service already installed at: {unit_path}")
-        print("Use --force to reinstall")
-        return
-    
-    unit_path.parent.mkdir(parents=True, exist_ok=True)
-    print(f"Installing systemd service to: {unit_path}")
-    unit_path.write_text(generate_systemd_unit())
-    
-    subprocess.run(["systemctl", "--user", "daemon-reload"], check=True)
-    subprocess.run(["systemctl", "--user", "enable", SERVICE_NAME], check=True)
-    
-    print()
-    print("✓ Service installed and enabled!")
-    print()
-    print("Next steps:")
-    print(f"  hermes gateway start              # Start the service")
-    print(f"  hermes gateway status             # Check status")
-    print(f"  journalctl --user -u {SERVICE_NAME} -f  # View logs")
-    print()
-    print("To enable lingering (keeps running after logout):")
-    print("  sudo loginctl enable-linger $USER")
-
-def systemd_uninstall():
-    subprocess.run(["systemctl", "--user", "stop", SERVICE_NAME], check=False)
-    subprocess.run(["systemctl", "--user", "disable", SERVICE_NAME], check=False)
-    
-    unit_path = get_systemd_unit_path()
-    if unit_path.exists():
-        unit_path.unlink()
-        print(f"✓ Removed {unit_path}")
-    
-    subprocess.run(["systemctl", "--user", "daemon-reload"], check=True)
-    print("✓ Service uninstalled")
-
-def systemd_start():
-    subprocess.run(["systemctl", "--user", "start", SERVICE_NAME], check=True)
-    print("✓ Service started")
-
-def systemd_stop():
-    subprocess.run(["systemctl", "--user", "stop", SERVICE_NAME], check=True)
-    print("✓ Service stopped")
-
-def systemd_restart():
-    subprocess.run(["systemctl", "--user", "restart", SERVICE_NAME], check=True)
-    print("✓ Service restarted")
-
-def systemd_status(deep: bool = False):
-    # Check if service unit file exists
-    unit_path = get_systemd_unit_path()
-    if not unit_path.exists():
-        print("✗ Gateway service is not installed")
-        print("  Run: hermes gateway install")
-        return
-    
-    # Show detailed status first
-    subprocess.run(
-        ["systemctl", "--user", "status", SERVICE_NAME, "--no-pager"],
-        capture_output=False
-    )
-    
-    # Check if service is active
-    result = subprocess.run(
-        ["systemctl", "--user", "is-active", SERVICE_NAME],
-        capture_output=True,
-        text=True
-    )
-    
-    status = result.stdout.strip()
-    
-    if status == "active":
-        print("✓ Gateway service is running")
-    else:
-        print("✗ Gateway service is stopped")
-        print("  Run: hermes gateway start")
-    
-    if deep:
-        print()
-        print("Recent logs:")
-        subprocess.run([
-            "journalctl", "--user", "-u", SERVICE_NAME,
-            "-n", "20", "--no-pager"
-        ])
-
-
-# =============================================================================
-# Launchd (macOS)
-# =============================================================================
-
-def generate_launchd_plist() -> str:
-    python_path = get_python_path()
-    working_dir = str(PROJECT_ROOT)
-    log_dir = Path.home() / ".hermes" / "logs"
-    log_dir.mkdir(parents=True, exist_ok=True)
-    
-    return f"""<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>ai.hermes.gateway</string>
-    
-    <key>ProgramArguments</key>
-    <array>
-        <string>{python_path}</string>
-        <string>-m</string>
-        <string>hermes_cli.main</string>
-        <string>gateway</string>
-        <string>run</string>
-    </array>
-    
-    <key>WorkingDirectory</key>
-    <string>{working_dir}</string>
-    
-    <key>RunAtLoad</key>
-    <true/>
-    
-    <key>KeepAlive</key>
-    <dict>
-        <key>SuccessfulExit</key>
-        <false/>
-    </dict>
-    
-    <key>StandardOutPath</key>
-    <string>{log_dir}/gateway.log</string>
-    
-    <key>StandardErrorPath</key>
-    <string>{log_dir}/gateway.error.log</string>
-</dict>
-</plist>
-"""
-
-def launchd_install(force: bool = False):
-    plist_path = get_launchd_plist_path()
-    
-    if plist_path.exists() and not force:
-        print(f"Service already installed at: {plist_path}")
-        print("Use --force to reinstall")
-        return
-    
-    plist_path.parent.mkdir(parents=True, exist_ok=True)
-    print(f"Installing launchd service to: {plist_path}")
-    plist_path.write_text(generate_launchd_plist())
-    
-    subprocess.run(["launchctl", "load", str(plist_path)], check=True)
-    
-    print()
-    print("✓ Service installed and loaded!")
-    print()
-    print("Next steps:")
-    print("  hermes gateway status             # Check status")
-    print("  tail -f ~/.hermes/logs/gateway.log  # View logs")
-
-def launchd_uninstall():
-    plist_path = get_launchd_plist_path()
-    subprocess.run(["launchctl", "unload", str(plist_path)], check=False)
-    
-    if plist_path.exists():
-        plist_path.unlink()
-        print(f"✓ Removed {plist_path}")
-    
-    print("✓ Service uninstalled")
-
-def launchd_start():
-    subprocess.run(["launchctl", "start", "ai.hermes.gateway"], check=True)
-    print("✓ Service started")
-
-def launchd_stop():
-    subprocess.run(["launchctl", "stop", "ai.hermes.gateway"], check=True)
-    print("✓ Service stopped")
-
-def launchd_restart():
-    launchd_stop()
-    launchd_start()
-
-def launchd_status(deep: bool = False):
-    result = subprocess.run(
-        ["launchctl", "list", "ai.hermes.gateway"],
-        capture_output=True,
-        text=True
-    )
-    
-    if result.returncode == 0:
-        print("✓ Gateway service is loaded")
-        print(result.stdout)
-    else:
-        print("✗ Gateway service is not loaded")
-    
-    if deep:
-        log_file = Path.home() / ".hermes" / "logs" / "gateway.log"
-        if log_file.exists():
-            print()
-            print("Recent logs:")
-            subprocess.run(["tail", "-20", str(log_file)])
-
-
-# =============================================================================
-# Gateway Runner
-# =============================================================================
-
-def run_gateway(verbose: bool = False):
-    """Run the gateway in foreground."""
-    sys.path.insert(0, str(PROJECT_ROOT))
-    
-    from gateway.run import start_gateway
-    
-    print("┌─────────────────────────────────────────────────────────┐")
-    print("│           🦋 Hermes Gateway Starting...                 │")
-    print("├─────────────────────────────────────────────────────────┤")
-    print("│  Press Ctrl+C to stop                                   │")
-    print("└─────────────────────────────────────────────────────────┘")
-    print()
-    
-    asyncio.run(start_gateway())
-
-
-# =============================================================================
-# Main Command Handler
-# =============================================================================
-
-def gateway_command(args):
-    """Handle gateway subcommands."""
-    subcmd = getattr(args, 'gateway_command', None)
-    
-    # Default to run if no subcommand
-    if subcmd is None or subcmd == "run":
-        verbose = getattr(args, 'verbose', False)
-        run_gateway(verbose)
-        return
-    
-    # Service management commands
-    if subcmd == "install":
-        force = getattr(args, 'force', False)
-        if is_linux():
-            systemd_install(force)
-        elif is_macos():
-            launchd_install(force)
-        else:
-            print("Service installation not supported on this platform.")
-            print("Run manually: hermes gateway run")
-            sys.exit(1)
-    
-    elif subcmd == "uninstall":
-        if is_linux():
-            systemd_uninstall()
-        elif is_macos():
-            launchd_uninstall()
-        else:
-            print("Not supported on this platform.")
-            sys.exit(1)
-    
-    elif subcmd == "start":
-        if is_linux():
-            systemd_start()
-        elif is_macos():
-            launchd_start()
-        else:
-            print("Not supported on this platform.")
-            sys.exit(1)
-    
-    elif subcmd == "stop":
-        # Try service first, fall back to killing processes directly
-        service_available = False
-        
-        if is_linux() and get_systemd_unit_path().exists():
-            try:
-                systemd_stop()
-                service_available = True
-            except subprocess.CalledProcessError:
-                pass  # Fall through to process kill
-        elif is_macos() and get_launchd_plist_path().exists():
-            try:
-                launchd_stop()
-                service_available = True
-            except subprocess.CalledProcessError:
-                pass
-        
-        if not service_available:
-            # Kill gateway processes directly
-            killed = kill_gateway_processes()
-            if killed:
-                print(f"✓ Stopped {killed} gateway process(es)")
-            else:
-                print("✗ No gateway processes found")
-    
-    elif subcmd == "restart":
-        # Try service first, fall back to killing and restarting
-        service_available = False
-        
-        if is_linux() and get_systemd_unit_path().exists():
-            try:
-                systemd_restart()
-                service_available = True
-            except subprocess.CalledProcessError:
-                pass
-        elif is_macos() and get_launchd_plist_path().exists():
-            try:
-                launchd_restart()
-                service_available = True
-            except subprocess.CalledProcessError:
-                pass
-        
-        if not service_available:
-            # Manual restart: kill existing processes
-            killed = kill_gateway_processes()
-            if killed:
-                print(f"✓ Stopped {killed} gateway process(es)")
-            
-            import time
-            time.sleep(2)
-            
-            # Start fresh
-            print("Starting gateway...")
-            run_gateway(verbose=False)
-    
-    elif subcmd == "status":
-        deep = getattr(args, 'deep', False)
-        
-        # Check for service first
-        if is_linux() and get_systemd_unit_path().exists():
-            systemd_status(deep)
-        elif is_macos() and get_launchd_plist_path().exists():
-            launchd_status(deep)
-        else:
-            # Check for manually running processes
-            pids = find_gateway_pids()
-            if pids:
-                print(f"✓ Gateway is running (PID: {', '.join(map(str, pids))})")
-                print("  (Running manually, not as a system service)")
-                print()
-                print("To install as a service:")
-                print("  hermes gateway install")
-            else:
-                print("✗ Gateway is not running")
-                print()
-                print("To start:")
-                print("  hermes gateway          # Run in foreground")
-                print("  hermes gateway install  # Install as service")

hermes_cli/main.py

@@ -1,516 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hermes CLI - Main entry point.
-
-Usage:
-    hermes                     # Interactive chat (default)
-    hermes chat                # Interactive chat
-    hermes gateway             # Run gateway in foreground
-    hermes gateway start       # Start gateway as service
-    hermes gateway stop        # Stop gateway service
-    hermes gateway status      # Show gateway status
-    hermes gateway install     # Install gateway service
-    hermes gateway uninstall   # Uninstall gateway service
-    hermes setup               # Interactive setup wizard
-    hermes status              # Show status of all components
-    hermes cron                # Manage cron jobs
-    hermes cron list           # List cron jobs
-    hermes cron daemon         # Run cron daemon
-    hermes doctor              # Check configuration and dependencies
-    hermes version             # Show version
-    hermes update              # Update to latest version
-    hermes uninstall           # Uninstall Hermes Agent
-"""
-
-import argparse
-import os
-import sys
-from pathlib import Path
-
-# Add project root to path
-PROJECT_ROOT = Path(__file__).parent.parent.resolve()
-sys.path.insert(0, str(PROJECT_ROOT))
-
-# Load .env file
-from dotenv import load_dotenv
-env_path = PROJECT_ROOT / '.env'
-if env_path.exists():
-    load_dotenv(dotenv_path=env_path)
-
-from hermes_cli import __version__
-
-
-def cmd_chat(args):
-    """Run interactive chat CLI."""
-    # Import and run the CLI
-    from cli import main as cli_main
-    
-    # Build kwargs from args
-    kwargs = {
-        "model": args.model,
-        "toolsets": args.toolsets,
-        "verbose": args.verbose,
-        "query": args.query,
-    }
-    # Filter out None values
-    kwargs = {k: v for k, v in kwargs.items() if v is not None}
-    
-    cli_main(**kwargs)
-
-
-def cmd_gateway(args):
-    """Gateway management commands."""
-    from hermes_cli.gateway import gateway_command
-    gateway_command(args)
-
-
-def cmd_setup(args):
-    """Interactive setup wizard."""
-    from hermes_cli.setup import run_setup_wizard
-    run_setup_wizard(args)
-
-
-def cmd_status(args):
-    """Show status of all components."""
-    from hermes_cli.status import show_status
-    show_status(args)
-
-
-def cmd_cron(args):
-    """Cron job management."""
-    from hermes_cli.cron import cron_command
-    cron_command(args)
-
-
-def cmd_doctor(args):
-    """Check configuration and dependencies."""
-    from hermes_cli.doctor import run_doctor
-    run_doctor(args)
-
-
-def cmd_config(args):
-    """Configuration management."""
-    from hermes_cli.config import config_command
-    config_command(args)
-
-
-def cmd_version(args):
-    """Show version."""
-    print(f"Hermes Agent v{__version__}")
-    print(f"Project: {PROJECT_ROOT}")
-    
-    # Show Python version
-    print(f"Python: {sys.version.split()[0]}")
-    
-    # Check for key dependencies
-    try:
-        import openai
-        print(f"OpenAI SDK: {openai.__version__}")
-    except ImportError:
-        print("OpenAI SDK: Not installed")
-
-
-def cmd_uninstall(args):
-    """Uninstall Hermes Agent."""
-    from hermes_cli.uninstall import run_uninstall
-    run_uninstall(args)
-
-
-def cmd_update(args):
-    """Update Hermes Agent to the latest version."""
-    import subprocess
-    import shutil
-    
-    print("🦋 Updating Hermes Agent...")
-    print()
-    
-    # Check if we're in a git repo
-    git_dir = PROJECT_ROOT / '.git'
-    if not git_dir.exists():
-        print("✗ Not a git repository. Please reinstall:")
-        print("  curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash")
-        sys.exit(1)
-    
-    # Fetch and pull
-    try:
-        print("→ Fetching updates...")
-        subprocess.run(["git", "fetch", "origin"], cwd=PROJECT_ROOT, check=True)
-        
-        # Get current branch
-        result = subprocess.run(
-            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
-            cwd=PROJECT_ROOT,
-            capture_output=True,
-            text=True,
-            check=True
-        )
-        branch = result.stdout.strip()
-        
-        # Check if there are updates
-        result = subprocess.run(
-            ["git", "rev-list", f"HEAD..origin/{branch}", "--count"],
-            cwd=PROJECT_ROOT,
-            capture_output=True,
-            text=True,
-            check=True
-        )
-        commit_count = int(result.stdout.strip())
-        
-        if commit_count == 0:
-            print("✓ Already up to date!")
-            return
-        
-        print(f"→ Found {commit_count} new commit(s)")
-        print("→ Pulling updates...")
-        subprocess.run(["git", "pull", "origin", branch], cwd=PROJECT_ROOT, check=True)
-        
-        # Reinstall Python dependencies (prefer uv for speed, fall back to pip)
-        print("→ Updating Python dependencies...")
-        uv_bin = shutil.which("uv")
-        if uv_bin:
-            subprocess.run(
-                [uv_bin, "pip", "install", "-e", ".", "--quiet"],
-                cwd=PROJECT_ROOT, check=True,
-                env={**os.environ, "VIRTUAL_ENV": str(PROJECT_ROOT / "venv")}
-            )
-        else:
-            venv_pip = PROJECT_ROOT / "venv" / "bin" / "pip"
-            if venv_pip.exists():
-                subprocess.run([str(venv_pip), "install", "-e", ".", "--quiet"], cwd=PROJECT_ROOT, check=True)
-            else:
-                subprocess.run(["pip", "install", "-e", ".", "--quiet"], cwd=PROJECT_ROOT, check=True)
-        
-        # Check for Node.js deps
-        if (PROJECT_ROOT / "package.json").exists():
-            import shutil
-            if shutil.which("npm"):
-                print("→ Updating Node.js dependencies...")
-                subprocess.run(["npm", "install", "--silent"], cwd=PROJECT_ROOT, check=False)
-        
-        print()
-        print("✓ Code updated!")
-        
-        # Check for config migrations
-        print()
-        print("→ Checking configuration for new options...")
-        
-        from hermes_cli.config import (
-            get_missing_env_vars, get_missing_config_fields, 
-            check_config_version, migrate_config
-        )
-        
-        missing_env = get_missing_env_vars(required_only=True)
-        missing_config = get_missing_config_fields()
-        current_ver, latest_ver = check_config_version()
-        
-        needs_migration = missing_env or missing_config or current_ver < latest_ver
-        
-        if needs_migration:
-            print()
-            if missing_env:
-                print(f"  ⚠️  {len(missing_env)} new required setting(s) need configuration")
-            if missing_config:
-                print(f"  ℹ️  {len(missing_config)} new config option(s) available")
-            
-            print()
-            response = input("Would you like to configure them now? [Y/n]: ").strip().lower()
-            
-            if response in ('', 'y', 'yes'):
-                print()
-                results = migrate_config(interactive=True, quiet=False)
-                
-                if results["env_added"] or results["config_added"]:
-                    print()
-                    print("✓ Configuration updated!")
-            else:
-                print()
-                print("Skipped. Run 'hermes config migrate' later to configure.")
-        else:
-            print("  ✓ Configuration is up to date")
-        
-        print()
-        print("✓ Update complete!")
-        print()
-        print("Note: If you have the gateway service running, restart it:")
-        print("  hermes gateway restart")
-        
-    except subprocess.CalledProcessError as e:
-        print(f"✗ Update failed: {e}")
-        sys.exit(1)
-
-
-def main():
-    """Main entry point for hermes CLI."""
-    parser = argparse.ArgumentParser(
-        prog="hermes",
-        description="Hermes Agent - AI assistant with tool-calling capabilities",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    hermes                        Start interactive chat
-    hermes chat -q "Hello"        Single query mode
-    hermes setup                  Run setup wizard
-    hermes config                 View configuration
-    hermes config edit            Edit config in $EDITOR
-    hermes config set model gpt-4 Set a config value
-    hermes gateway                Run messaging gateway
-    hermes gateway install        Install as system service
-    hermes update                 Update to latest version
-
-For more help on a command:
-    hermes <command> --help
-"""
-    )
-    
-    parser.add_argument(
-        "--version", "-V",
-        action="store_true",
-        help="Show version and exit"
-    )
-    
-    subparsers = parser.add_subparsers(dest="command", help="Command to run")
-    
-    # =========================================================================
-    # chat command
-    # =========================================================================
-    chat_parser = subparsers.add_parser(
-        "chat",
-        help="Interactive chat with the agent",
-        description="Start an interactive chat session with Hermes Agent"
-    )
-    chat_parser.add_argument(
-        "-q", "--query",
-        help="Single query (non-interactive mode)"
-    )
-    chat_parser.add_argument(
-        "-m", "--model",
-        help="Model to use (e.g., anthropic/claude-sonnet-4)"
-    )
-    chat_parser.add_argument(
-        "-t", "--toolsets",
-        help="Comma-separated toolsets to enable"
-    )
-    chat_parser.add_argument(
-        "-v", "--verbose",
-        action="store_true",
-        help="Verbose output"
-    )
-    chat_parser.set_defaults(func=cmd_chat)
-    
-    # =========================================================================
-    # gateway command
-    # =========================================================================
-    gateway_parser = subparsers.add_parser(
-        "gateway",
-        help="Messaging gateway management",
-        description="Manage the messaging gateway (Telegram, Discord, WhatsApp)"
-    )
-    gateway_subparsers = gateway_parser.add_subparsers(dest="gateway_command")
-    
-    # gateway run (default)
-    gateway_run = gateway_subparsers.add_parser("run", help="Run gateway in foreground")
-    gateway_run.add_argument("-v", "--verbose", action="store_true")
-    
-    # gateway start
-    gateway_start = gateway_subparsers.add_parser("start", help="Start gateway service")
-    
-    # gateway stop
-    gateway_stop = gateway_subparsers.add_parser("stop", help="Stop gateway service")
-    
-    # gateway restart
-    gateway_restart = gateway_subparsers.add_parser("restart", help="Restart gateway service")
-    
-    # gateway status
-    gateway_status = gateway_subparsers.add_parser("status", help="Show gateway status")
-    gateway_status.add_argument("--deep", action="store_true", help="Deep status check")
-    
-    # gateway install
-    gateway_install = gateway_subparsers.add_parser("install", help="Install gateway as service")
-    gateway_install.add_argument("--force", action="store_true", help="Force reinstall")
-    
-    # gateway uninstall
-    gateway_uninstall = gateway_subparsers.add_parser("uninstall", help="Uninstall gateway service")
-    
-    gateway_parser.set_defaults(func=cmd_gateway)
-    
-    # =========================================================================
-    # setup command
-    # =========================================================================
-    setup_parser = subparsers.add_parser(
-        "setup",
-        help="Interactive setup wizard",
-        description="Configure Hermes Agent with an interactive wizard"
-    )
-    setup_parser.add_argument(
-        "--non-interactive",
-        action="store_true",
-        help="Non-interactive mode (use defaults/env vars)"
-    )
-    setup_parser.add_argument(
-        "--reset",
-        action="store_true",
-        help="Reset configuration to defaults"
-    )
-    setup_parser.set_defaults(func=cmd_setup)
-    
-    # =========================================================================
-    # status command
-    # =========================================================================
-    status_parser = subparsers.add_parser(
-        "status",
-        help="Show status of all components",
-        description="Display status of Hermes Agent components"
-    )
-    status_parser.add_argument(
-        "--all",
-        action="store_true",
-        help="Show all details (redacted for sharing)"
-    )
-    status_parser.add_argument(
-        "--deep",
-        action="store_true",
-        help="Run deep checks (may take longer)"
-    )
-    status_parser.set_defaults(func=cmd_status)
-    
-    # =========================================================================
-    # cron command
-    # =========================================================================
-    cron_parser = subparsers.add_parser(
-        "cron",
-        help="Cron job management",
-        description="Manage scheduled tasks"
-    )
-    cron_subparsers = cron_parser.add_subparsers(dest="cron_command")
-    
-    # cron list
-    cron_list = cron_subparsers.add_parser("list", help="List scheduled jobs")
-    cron_list.add_argument("--all", action="store_true", help="Include disabled jobs")
-    
-    # cron daemon
-    cron_daemon = cron_subparsers.add_parser("daemon", help="Run cron daemon")
-    cron_daemon.add_argument("--interval", type=int, default=60, help="Check interval in seconds")
-    
-    # cron tick
-    cron_tick = cron_subparsers.add_parser("tick", help="Run due jobs once (for system cron)")
-    
-    cron_parser.set_defaults(func=cmd_cron)
-    
-    # =========================================================================
-    # doctor command
-    # =========================================================================
-    doctor_parser = subparsers.add_parser(
-        "doctor",
-        help="Check configuration and dependencies",
-        description="Diagnose issues with Hermes Agent setup"
-    )
-    doctor_parser.add_argument(
-        "--fix",
-        action="store_true",
-        help="Attempt to fix issues automatically"
-    )
-    doctor_parser.set_defaults(func=cmd_doctor)
-    
-    # =========================================================================
-    # config command
-    # =========================================================================
-    config_parser = subparsers.add_parser(
-        "config",
-        help="View and edit configuration",
-        description="Manage Hermes Agent configuration"
-    )
-    config_subparsers = config_parser.add_subparsers(dest="config_command")
-    
-    # config show (default)
-    config_show = config_subparsers.add_parser("show", help="Show current configuration")
-    
-    # config edit
-    config_edit = config_subparsers.add_parser("edit", help="Open config file in editor")
-    
-    # config set
-    config_set = config_subparsers.add_parser("set", help="Set a configuration value")
-    config_set.add_argument("key", nargs="?", help="Configuration key (e.g., model, terminal.backend)")
-    config_set.add_argument("value", nargs="?", help="Value to set")
-    
-    # config path
-    config_path = config_subparsers.add_parser("path", help="Print config file path")
-    
-    # config env-path
-    config_env = config_subparsers.add_parser("env-path", help="Print .env file path")
-    
-    # config check
-    config_check = config_subparsers.add_parser("check", help="Check for missing/outdated config")
-    
-    # config migrate
-    config_migrate = config_subparsers.add_parser("migrate", help="Update config with new options")
-    
-    config_parser.set_defaults(func=cmd_config)
-    
-    # =========================================================================
-    # version command
-    # =========================================================================
-    version_parser = subparsers.add_parser(
-        "version",
-        help="Show version information"
-    )
-    version_parser.set_defaults(func=cmd_version)
-    
-    # =========================================================================
-    # update command
-    # =========================================================================
-    update_parser = subparsers.add_parser(
-        "update",
-        help="Update Hermes Agent to the latest version",
-        description="Pull the latest changes from git and reinstall dependencies"
-    )
-    update_parser.set_defaults(func=cmd_update)
-    
-    # =========================================================================
-    # uninstall command
-    # =========================================================================
-    uninstall_parser = subparsers.add_parser(
-        "uninstall",
-        help="Uninstall Hermes Agent",
-        description="Remove Hermes Agent from your system. Can keep configs/data for reinstall."
-    )
-    uninstall_parser.add_argument(
-        "--full",
-        action="store_true",
-        help="Full uninstall - remove everything including configs and data"
-    )
-    uninstall_parser.add_argument(
-        "--yes", "-y",
-        action="store_true",
-        help="Skip confirmation prompts"
-    )
-    uninstall_parser.set_defaults(func=cmd_uninstall)
-    
-    # =========================================================================
-    # Parse and execute
-    # =========================================================================
-    args = parser.parse_args()
-    
-    # Handle --version flag
-    if args.version:
-        cmd_version(args)
-        return
-    
-    # Default to chat if no command specified
-    if args.command is None:
-        # No command = run chat
-        args.query = None
-        args.model = None
-        args.toolsets = None
-        args.verbose = False
-        cmd_chat(args)
-        return
-    
-    # Execute the command
-    if hasattr(args, 'func'):
-        args.func(args)
-    else:
-        parser.print_help()
-
-
-if __name__ == "__main__":
-    main()

hermes_cli/status.py

@@ -1,241 +0,0 @@
-"""
-Status command for hermes CLI.
-
-Shows the status of all Hermes Agent components.
-"""
-
-import os
-import sys
-import subprocess
-from pathlib import Path
-
-PROJECT_ROOT = Path(__file__).parent.parent.resolve()
-
-# ANSI colors
-class Colors:
-    RESET = "\033[0m"
-    BOLD = "\033[1m"
-    DIM = "\033[2m"
-    RED = "\033[31m"
-    GREEN = "\033[32m"
-    YELLOW = "\033[33m"
-    CYAN = "\033[36m"
-
-def color(text: str, *codes) -> str:
-    if not sys.stdout.isatty():
-        return text
-    return "".join(codes) + text + Colors.RESET
-
-def check_mark(ok: bool) -> str:
-    if ok:
-        return color("✓", Colors.GREEN)
-    return color("✗", Colors.RED)
-
-def redact_key(key: str) -> str:
-    """Redact an API key for display."""
-    if not key:
-        return "(not set)"
-    if len(key) < 12:
-        return "***"
-    return key[:4] + "..." + key[-4:]
-
-
-def show_status(args):
-    """Show status of all Hermes Agent components."""
-    show_all = getattr(args, 'all', False)
-    deep = getattr(args, 'deep', False)
-    
-    print()
-    print(color("┌─────────────────────────────────────────────────────────┐", Colors.CYAN))
-    print(color("│                 🦋 Hermes Agent Status                  │", Colors.CYAN))
-    print(color("└─────────────────────────────────────────────────────────┘", Colors.CYAN))
-    
-    # =========================================================================
-    # Environment
-    # =========================================================================
-    print()
-    print(color("◆ Environment", Colors.CYAN, Colors.BOLD))
-    print(f"  Project:      {PROJECT_ROOT}")
-    print(f"  Python:       {sys.version.split()[0]}")
-    
-    env_path = PROJECT_ROOT / '.env'
-    print(f"  .env file:    {check_mark(env_path.exists())} {'exists' if env_path.exists() else 'not found'}")
-    
-    # =========================================================================
-    # API Keys
-    # =========================================================================
-    print()
-    print(color("◆ API Keys", Colors.CYAN, Colors.BOLD))
-    
-    keys = {
-        "OpenRouter": "OPENROUTER_API_KEY",
-        "Anthropic": "ANTHROPIC_API_KEY", 
-        "OpenAI": "OPENAI_API_KEY",
-        "Firecrawl": "FIRECRAWL_API_KEY",
-        "Browserbase": "BROWSERBASE_API_KEY",
-        "FAL": "FAL_KEY",
-        "Tinker": "TINKER_API_KEY",
-        "WandB": "WANDB_API_KEY",
-    }
-    
-    for name, env_var in keys.items():
-        value = os.getenv(env_var, "")
-        has_key = bool(value)
-        display = redact_key(value) if not show_all else value
-        print(f"  {name:<12}  {check_mark(has_key)} {display}")
-    
-    # =========================================================================
-    # Terminal Configuration
-    # =========================================================================
-    print()
-    print(color("◆ Terminal Backend", Colors.CYAN, Colors.BOLD))
-    
-    terminal_env = os.getenv("TERMINAL_ENV", "local")
-    print(f"  Backend:      {terminal_env}")
-    
-    if terminal_env == "ssh":
-        ssh_host = os.getenv("TERMINAL_SSH_HOST", "")
-        ssh_user = os.getenv("TERMINAL_SSH_USER", "")
-        print(f"  SSH Host:     {ssh_host or '(not set)'}")
-        print(f"  SSH User:     {ssh_user or '(not set)'}")
-    elif terminal_env == "docker":
-        docker_image = os.getenv("TERMINAL_DOCKER_IMAGE", "python:3.11-slim")
-        print(f"  Docker Image: {docker_image}")
-    
-    sudo_password = os.getenv("SUDO_PASSWORD", "")
-    print(f"  Sudo:         {check_mark(bool(sudo_password))} {'enabled' if sudo_password else 'disabled'}")
-    
-    # =========================================================================
-    # Messaging Platforms
-    # =========================================================================
-    print()
-    print(color("◆ Messaging Platforms", Colors.CYAN, Colors.BOLD))
-    
-    platforms = {
-        "Telegram": ("TELEGRAM_BOT_TOKEN", "TELEGRAM_HOME_CHANNEL"),
-        "Discord": ("DISCORD_BOT_TOKEN", "DISCORD_HOME_CHANNEL"),
-        "WhatsApp": ("WHATSAPP_ENABLED", None),
-    }
-    
-    for name, (token_var, home_var) in platforms.items():
-        token = os.getenv(token_var, "")
-        has_token = bool(token)
-        
-        home_channel = ""
-        if home_var:
-            home_channel = os.getenv(home_var, "")
-        
-        status = "configured" if has_token else "not configured"
-        if home_channel:
-            status += f" (home: {home_channel})"
-        
-        print(f"  {name:<12}  {check_mark(has_token)} {status}")
-    
-    # =========================================================================
-    # Gateway Status
-    # =========================================================================
-    print()
-    print(color("◆ Gateway Service", Colors.CYAN, Colors.BOLD))
-    
-    if sys.platform.startswith('linux'):
-        result = subprocess.run(
-            ["systemctl", "--user", "is-active", "hermes-gateway"],
-            capture_output=True,
-            text=True
-        )
-        is_active = result.stdout.strip() == "active"
-        print(f"  Status:       {check_mark(is_active)} {'running' if is_active else 'stopped'}")
-        print(f"  Manager:      systemd (user)")
-        
-    elif sys.platform == 'darwin':
-        result = subprocess.run(
-            ["launchctl", "list", "ai.hermes.gateway"],
-            capture_output=True,
-            text=True
-        )
-        is_loaded = result.returncode == 0
-        print(f"  Status:       {check_mark(is_loaded)} {'loaded' if is_loaded else 'not loaded'}")
-        print(f"  Manager:      launchd")
-    else:
-        print(f"  Status:       {color('N/A', Colors.DIM)}")
-        print(f"  Manager:      (not supported on this platform)")
-    
-    # =========================================================================
-    # Cron Jobs
-    # =========================================================================
-    print()
-    print(color("◆ Scheduled Jobs", Colors.CYAN, Colors.BOLD))
-    
-    jobs_file = Path.home() / ".hermes" / "cron" / "jobs.json"
-    if jobs_file.exists():
-        import json
-        try:
-            with open(jobs_file) as f:
-                data = json.load(f)
-                jobs = data.get("jobs", [])
-                enabled_jobs = [j for j in jobs if j.get("enabled", True)]
-                print(f"  Jobs:         {len(enabled_jobs)} active, {len(jobs)} total")
-        except:
-            print(f"  Jobs:         (error reading jobs file)")
-    else:
-        print(f"  Jobs:         0")
-    
-    # =========================================================================
-    # Sessions
-    # =========================================================================
-    print()
-    print(color("◆ Sessions", Colors.CYAN, Colors.BOLD))
-    
-    sessions_file = Path.home() / ".hermes" / "sessions" / "sessions.json"
-    if sessions_file.exists():
-        import json
-        try:
-            with open(sessions_file) as f:
-                data = json.load(f)
-                print(f"  Active:       {len(data)} session(s)")
-        except:
-            print(f"  Active:       (error reading sessions file)")
-    else:
-        print(f"  Active:       0")
-    
-    # =========================================================================
-    # Deep checks
-    # =========================================================================
-    if deep:
-        print()
-        print(color("◆ Deep Checks", Colors.CYAN, Colors.BOLD))
-        
-        # Check OpenRouter connectivity
-        openrouter_key = os.getenv("OPENROUTER_API_KEY", "")
-        if openrouter_key:
-            try:
-                import httpx
-                response = httpx.get(
-                    "https://openrouter.ai/api/v1/models",
-                    headers={"Authorization": f"Bearer {openrouter_key}"},
-                    timeout=10
-                )
-                ok = response.status_code == 200
-                print(f"  OpenRouter:   {check_mark(ok)} {'reachable' if ok else f'error ({response.status_code})'}")
-            except Exception as e:
-                print(f"  OpenRouter:   {check_mark(False)} error: {e}")
-        
-        # Check gateway port
-        try:
-            import socket
-            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            sock.settimeout(1)
-            result = sock.connect_ex(('127.0.0.1', 18789))
-            sock.close()
-            # Port in use = gateway likely running
-            port_in_use = result == 0
-            # This is informational, not necessarily bad
-            print(f"  Port 18789:   {'in use' if port_in_use else 'available'}")
-        except:
-            pass
-    
-    print()
-    print(color("─" * 60, Colors.DIM))
-    print(color("  Run 'hermes doctor' for detailed diagnostics", Colors.DIM))
-    print(color("  Run 'hermes setup' to configure", Colors.DIM))
-    print()

hermes_cli/uninstall.py

@@ -1,341 +0,0 @@
-"""
-Hermes Agent Uninstaller.
-
-Provides options for:
-- Full uninstall: Remove everything including configs and data
-- Keep data: Remove code but keep ~/.hermes/ (configs, sessions, logs)
-"""
-
-import os
-import sys
-import shutil
-import subprocess
-from pathlib import Path
-from typing import Optional
-
-# ANSI colors
-class Colors:
-    RESET = "\033[0m"
-    BOLD = "\033[1m"
-    DIM = "\033[2m"
-    RED = "\033[31m"
-    GREEN = "\033[32m"
-    YELLOW = "\033[33m"
-    BLUE = "\033[34m"
-    MAGENTA = "\033[35m"
-    CYAN = "\033[36m"
-
-def color(text: str, *codes) -> str:
-    """Apply color codes to text (only in TTY)."""
-    if not sys.stdout.isatty():
-        return text
-    return "".join(codes) + text + Colors.RESET
-
-def log_info(msg: str):
-    print(f"{color('→', Colors.CYAN)} {msg}")
-
-def log_success(msg: str):
-    print(f"{color('✓', Colors.GREEN)} {msg}")
-
-def log_warn(msg: str):
-    print(f"{color('⚠', Colors.YELLOW)} {msg}")
-
-def log_error(msg: str):
-    print(f"{color('✗', Colors.RED)} {msg}")
-
-
-def get_project_root() -> Path:
-    """Get the project installation directory."""
-    return Path(__file__).parent.parent.resolve()
-
-
-def get_hermes_home() -> Path:
-    """Get the Hermes home directory (~/.hermes)."""
-    return Path(os.getenv("HERMES_HOME", Path.home() / ".hermes"))
-
-
-def find_shell_configs() -> list:
-    """Find shell configuration files that might have PATH entries."""
-    home = Path.home()
-    configs = []
-    
-    candidates = [
-        home / ".bashrc",
-        home / ".bash_profile",
-        home / ".profile",
-        home / ".zshrc",
-        home / ".zprofile",
-    ]
-    
-    for config in candidates:
-        if config.exists():
-            configs.append(config)
-    
-    return configs
-
-
-def remove_path_from_shell_configs():
-    """Remove Hermes PATH entries from shell configuration files."""
-    configs = find_shell_configs()
-    removed_from = []
-    
-    for config_path in configs:
-        try:
-            content = config_path.read_text()
-            original_content = content
-            
-            # Remove lines containing hermes-agent or hermes PATH entries
-            new_lines = []
-            skip_next = False
-            
-            for line in content.split('\n'):
-                # Skip the "# Hermes Agent" comment and following line
-                if '# Hermes Agent' in line or '# hermes-agent' in line:
-                    skip_next = True
-                    continue
-                if skip_next and ('hermes' in line.lower() and 'PATH' in line):
-                    skip_next = False
-                    continue
-                skip_next = False
-                
-                # Remove any PATH line containing hermes
-                if 'hermes' in line.lower() and ('PATH=' in line or 'path=' in line.lower()):
-                    continue
-                    
-                new_lines.append(line)
-            
-            new_content = '\n'.join(new_lines)
-            
-            # Clean up multiple blank lines
-            while '\n\n\n' in new_content:
-                new_content = new_content.replace('\n\n\n', '\n\n')
-            
-            if new_content != original_content:
-                config_path.write_text(new_content)
-                removed_from.append(config_path)
-                
-        except Exception as e:
-            log_warn(f"Could not update {config_path}: {e}")
-    
-    return removed_from
-
-
-def remove_wrapper_script():
-    """Remove the hermes wrapper script if it exists."""
-    wrapper_paths = [
-        Path.home() / ".local" / "bin" / "hermes",
-        Path("/usr/local/bin/hermes"),
-    ]
-    
-    removed = []
-    for wrapper in wrapper_paths:
-        if wrapper.exists():
-            try:
-                # Check if it's our wrapper (contains hermes_cli reference)
-                content = wrapper.read_text()
-                if 'hermes_cli' in content or 'hermes-agent' in content:
-                    wrapper.unlink()
-                    removed.append(wrapper)
-            except Exception as e:
-                log_warn(f"Could not remove {wrapper}: {e}")
-    
-    return removed
-
-
-def uninstall_gateway_service():
-    """Stop and uninstall the gateway service if running."""
-    import platform
-    
-    if platform.system() != "Linux":
-        return False
-    
-    service_file = Path.home() / ".config" / "systemd" / "user" / "hermes-gateway.service"
-    
-    if not service_file.exists():
-        return False
-    
-    try:
-        # Stop the service
-        subprocess.run(
-            ["systemctl", "--user", "stop", "hermes-gateway"],
-            capture_output=True,
-            check=False
-        )
-        
-        # Disable the service
-        subprocess.run(
-            ["systemctl", "--user", "disable", "hermes-gateway"],
-            capture_output=True,
-            check=False
-        )
-        
-        # Remove service file
-        service_file.unlink()
-        
-        # Reload systemd
-        subprocess.run(
-            ["systemctl", "--user", "daemon-reload"],
-            capture_output=True,
-            check=False
-        )
-        
-        return True
-        
-    except Exception as e:
-        log_warn(f"Could not fully remove gateway service: {e}")
-        return False
-
-
-def run_uninstall(args):
-    """
-    Run the uninstall process.
-    
-    Options:
-    - Full uninstall: removes code + ~/.hermes/ (configs, data, logs)
-    - Keep data: removes code but keeps ~/.hermes/ for future reinstall
-    """
-    project_root = get_project_root()
-    hermes_home = get_hermes_home()
-    
-    print()
-    print(color("┌─────────────────────────────────────────────────────────┐", Colors.MAGENTA, Colors.BOLD))
-    print(color("│            🦋 Hermes Agent Uninstaller                  │", Colors.MAGENTA, Colors.BOLD))
-    print(color("└─────────────────────────────────────────────────────────┘", Colors.MAGENTA, Colors.BOLD))
-    print()
-    
-    # Show what will be affected
-    print(color("Current Installation:", Colors.CYAN, Colors.BOLD))
-    print(f"  Code:    {project_root}")
-    print(f"  Config:  {hermes_home / 'config.yaml'}")
-    print(f"  Secrets: {hermes_home / '.env'}")
-    print(f"  Data:    {hermes_home / 'cron/'}, {hermes_home / 'sessions/'}, {hermes_home / 'logs/'}")
-    print()
-    
-    # Ask for confirmation
-    print(color("Uninstall Options:", Colors.YELLOW, Colors.BOLD))
-    print()
-    print("  1) " + color("Keep data", Colors.GREEN) + " - Remove code only, keep configs/sessions/logs")
-    print("     (Recommended - you can reinstall later with your settings intact)")
-    print()
-    print("  2) " + color("Full uninstall", Colors.RED) + " - Remove everything including all data")
-    print("     (Warning: This deletes all configs, sessions, and logs permanently)")
-    print()
-    print("  3) " + color("Cancel", Colors.CYAN) + " - Don't uninstall")
-    print()
-    
-    try:
-        choice = input(color("Select option [1/2/3]: ", Colors.BOLD)).strip()
-    except (KeyboardInterrupt, EOFError):
-        print()
-        print("Cancelled.")
-        return
-    
-    if choice == "3" or choice.lower() in ("c", "cancel", "q", "quit", "n", "no"):
-        print()
-        print("Uninstall cancelled.")
-        return
-    
-    full_uninstall = (choice == "2")
-    
-    # Final confirmation
-    print()
-    if full_uninstall:
-        print(color("⚠️  WARNING: This will permanently delete ALL Hermes data!", Colors.RED, Colors.BOLD))
-        print(color("   Including: configs, API keys, sessions, scheduled jobs, logs", Colors.RED))
-    else:
-        print("This will remove the Hermes code but keep your configuration and data.")
-    
-    print()
-    try:
-        confirm = input(f"Type '{color('yes', Colors.YELLOW)}' to confirm: ").strip().lower()
-    except (KeyboardInterrupt, EOFError):
-        print()
-        print("Cancelled.")
-        return
-    
-    if confirm != "yes":
-        print()
-        print("Uninstall cancelled.")
-        return
-    
-    print()
-    print(color("Uninstalling...", Colors.CYAN, Colors.BOLD))
-    print()
-    
-    # 1. Stop and uninstall gateway service
-    log_info("Checking for gateway service...")
-    if uninstall_gateway_service():
-        log_success("Gateway service stopped and removed")
-    else:
-        log_info("No gateway service found")
-    
-    # 2. Remove PATH entries from shell configs
-    log_info("Removing PATH entries from shell configs...")
-    removed_configs = remove_path_from_shell_configs()
-    if removed_configs:
-        for config in removed_configs:
-            log_success(f"Updated {config}")
-    else:
-        log_info("No PATH entries found to remove")
-    
-    # 3. Remove wrapper script
-    log_info("Removing hermes command...")
-    removed_wrappers = remove_wrapper_script()
-    if removed_wrappers:
-        for wrapper in removed_wrappers:
-            log_success(f"Removed {wrapper}")
-    else:
-        log_info("No wrapper script found")
-    
-    # 4. Remove installation directory (code)
-    log_info(f"Removing installation directory...")
-    
-    # Check if we're running from within the install dir
-    # We need to be careful here
-    try:
-        if project_root.exists():
-            # If the install is inside ~/.hermes/, just remove the hermes-agent subdir
-            if hermes_home in project_root.parents or project_root.parent == hermes_home:
-                shutil.rmtree(project_root)
-                log_success(f"Removed {project_root}")
-            else:
-                # Installation is somewhere else entirely
-                shutil.rmtree(project_root)
-                log_success(f"Removed {project_root}")
-    except Exception as e:
-        log_warn(f"Could not fully remove {project_root}: {e}")
-        log_info("You may need to manually remove it")
-    
-    # 5. Optionally remove ~/.hermes/ data directory
-    if full_uninstall:
-        log_info("Removing configuration and data...")
-        try:
-            if hermes_home.exists():
-                shutil.rmtree(hermes_home)
-                log_success(f"Removed {hermes_home}")
-        except Exception as e:
-            log_warn(f"Could not fully remove {hermes_home}: {e}")
-            log_info("You may need to manually remove it")
-    else:
-        log_info(f"Keeping configuration and data in {hermes_home}")
-    
-    # Done
-    print()
-    print(color("┌─────────────────────────────────────────────────────────┐", Colors.GREEN, Colors.BOLD))
-    print(color("│              ✓ Uninstall Complete!                      │", Colors.GREEN, Colors.BOLD))
-    print(color("└─────────────────────────────────────────────────────────┘", Colors.GREEN, Colors.BOLD))
-    print()
-    
-    if not full_uninstall:
-        print(color("Your configuration and data have been preserved:", Colors.CYAN))
-        print(f"  {hermes_home}/")
-        print()
-        print("To reinstall later with your existing settings:")
-        print(color("  curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash", Colors.DIM))
-        print()
-    
-    print(color("Reload your shell to complete the process:", Colors.YELLOW))
-    print("  source ~/.bashrc  # or ~/.zshrc")
-    print()
-    print("Thank you for using Hermes Agent! 🦋")
-    print()

package-lock.json

@@ -7,13 +7,9 @@
     "": {
       "name": "hermes-agent",
       "version": "1.0.0",
-      "hasInstallScript": true,
-      "license": "MIT",
+      "license": "ISC",
       "dependencies": {
         "agent-browser": "^0.7.6"
-      },
-      "engines": {
-        "node": ">=18.0.0"
       }
     },
     "node_modules/agent-browser": {

pyproject.toml

@@ -22,8 +22,6 @@ dependencies = [
   "requests",
   "jinja2",
   "pydantic>=2.0",
-  # Interactive CLI (prompt_toolkit is used directly by cli.py)
-  "prompt_toolkit",
   # Tools
   "firecrawl-py",
   "fal-client",
@@ -34,25 +32,14 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-modal = ["swe-rex[modal]>=1.4.0"]
+modal = ["modal", "boto3"]
 dev = ["pytest", "pytest-asyncio"]
-messaging = ["python-telegram-bot>=20.0", "discord.py>=2.0", "aiohttp>=3.9.0"]
-cron = ["croniter"]
-cli = ["simple-term-menu"]
-all = [
-  "hermes-agent[modal]",
-  "hermes-agent[messaging]",
-  "hermes-agent[cron]",
-  "hermes-agent[cli]",
-  "hermes-agent[dev]",
-]
 
 [project.scripts]
-hermes = "hermes_cli.main:main"
 hermes-agent = "run_agent:main"
 
 [tool.setuptools]
-py-modules = ["run_agent", "model_tools", "toolsets", "batch_runner", "trajectory_compressor", "toolset_distributions", "cli"]
+py-modules = ["run_agent", "model_tools", "toolsets", "batch_runner", "trajectory_compressor", "toolset_distributions"]
 
 [tool.setuptools.packages.find]
-include = ["tools", "hermes_cli", "gateway", "cron"]
+include = ["tools"]

requirements.txt

@@ -6,10 +6,6 @@ httpx
 rich
 tenacity
 prompt_toolkit
-pyyaml
-requests
-jinja2
-pydantic>=2.0
 
 # Web tools
 firecrawl-py
@@ -19,6 +15,10 @@ fal-client
 
 # mini-swe-agent dependencies (for terminal tool)
 # Note: Install mini-swe-agent itself with: pip install -e ./mini-swe-agent
+pyyaml
+requests
+jinja2
+pydantic>=2.0
 litellm>=1.75.5
 typer
 platformdirs
@@ -27,17 +27,8 @@ platformdirs
 # Requires Docker installed and user in 'docker' group
 
 # Optional: For Modal backend (cloud execution)
-# swe-rex[modal]>=1.4.0  # Includes modal + boto3 + swe-rex runtime
+# modal
+# boto3
 
-# Optional: For cron expression parsing (cronjob scheduling)
-croniter
-
-# Optional: For messaging platform integrations (gateway)
-# Telegram
-python-telegram-bot>=20.0
-
-# Discord
-discord.py>=2.0
-
-# WhatsApp bridge communication + general async HTTP (used by gateway)
-aiohttp>=3.9.0
+# Optional: Legacy Hecate terminal backend
+# git+ssh://git@github.com/NousResearch/hecate.git

rl_cli.py

@@ -1,448 +0,0 @@
-#!/usr/bin/env python3
-"""
-RL Training CLI Runner
-
-Dedicated CLI runner for RL training workflows with:
-- Extended timeouts for long-running training
-- RL-focused system prompts
-- Full toolset including RL training tools
-- Special handling for 30-minute check intervals
-
-Usage:
-    python rl_cli.py "Train a model on GSM8k for math reasoning"
-    python rl_cli.py --interactive
-    python rl_cli.py --list-environments
-
-Environment Variables:
-    TINKER_API_KEY: API key for Tinker service (required)
-    WANDB_API_KEY: API key for WandB metrics (required)
-    OPENROUTER_API_KEY: API key for OpenRouter (required for agent)
-"""
-
-import asyncio
-import os
-import sys
-from pathlib import Path
-
-import fire
-import yaml
-
-# Load environment variables from .env file
-from dotenv import load_dotenv
-
-# Load from ~/.hermes/.env first, then local .env
-hermes_env_path = Path.home() / '.hermes' / '.env'
-local_env_path = Path(__file__).parent / '.env'
-
-if hermes_env_path.exists():
-    load_dotenv(dotenv_path=hermes_env_path)
-    print(f"✅ Loaded environment variables from {hermes_env_path}")
-elif local_env_path.exists():
-    load_dotenv(dotenv_path=local_env_path)
-    print(f"✅ Loaded environment variables from {local_env_path}")
-
-# Set terminal working directory to tinker-atropos submodule
-# This ensures terminal commands run in the right context for RL work
-tinker_atropos_dir = Path(__file__).parent / 'tinker-atropos'
-if tinker_atropos_dir.exists():
-    os.environ['TERMINAL_CWD'] = str(tinker_atropos_dir)
-    os.environ['HERMES_QUIET'] = '1'  # Disable temp subdirectory creation
-    print(f"📂 Terminal working directory: {tinker_atropos_dir}")
-else:
-    # Fall back to hermes-agent directory if submodule not found
-    os.environ['TERMINAL_CWD'] = str(Path(__file__).parent)
-    os.environ['HERMES_QUIET'] = '1'
-    print(f"⚠️  tinker-atropos submodule not found, using: {Path(__file__).parent}")
-
-# Import agent and tools
-from run_agent import AIAgent
-from model_tools import get_tool_definitions, check_toolset_requirements
-from tools.rl_training_tool import check_rl_api_keys, get_missing_keys
-
-
-# ============================================================================
-# Config Loading
-# ============================================================================
-
-DEFAULT_MODEL = "anthropic/claude-opus-4.5"
-DEFAULT_BASE_URL = "https://openrouter.ai/api/v1"
-
-
-def load_hermes_config() -> dict:
-    """
-    Load configuration from ~/.hermes/config.yaml.
-    
-    Returns:
-        dict: Configuration with model, base_url, etc.
-    """
-    config_path = Path.home() / '.hermes' / 'config.yaml'
-    
-    config = {
-        "model": DEFAULT_MODEL,
-        "base_url": DEFAULT_BASE_URL,
-    }
-    
-    if config_path.exists():
-        try:
-            with open(config_path, "r") as f:
-                file_config = yaml.safe_load(f) or {}
-            
-            # Get model from config
-            if "model" in file_config:
-                if isinstance(file_config["model"], str):
-                    config["model"] = file_config["model"]
-                elif isinstance(file_config["model"], dict):
-                    config["model"] = file_config["model"].get("default", DEFAULT_MODEL)
-            
-            # Get base_url if specified
-            if "base_url" in file_config:
-                config["base_url"] = file_config["base_url"]
-                
-        except Exception as e:
-            print(f"⚠️  Warning: Failed to load config.yaml: {e}")
-    
-    return config
-
-
-# ============================================================================
-# RL-Specific Configuration
-# ============================================================================
-
-# Extended timeouts for long-running RL operations
-RL_MAX_ITERATIONS = 200  # Allow many more iterations for long workflows
-
-# RL-focused system prompt
-RL_SYSTEM_PROMPT = """You are an automated post-training engineer specializing in reinforcement learning for language models.
-
-## Your Capabilities
-
-You have access to RL training tools for running reinforcement learning on models through Tinker-Atropos:
-
-1. **DISCOVER**: Use `rl_list_environments` to see available RL environments
-2. **INSPECT**: Read environment files to understand how they work (verifiers, data loading, rewards)
-3. **INSPECT DATA**: Use terminal to explore HuggingFace datasets and understand their format
-4. **CREATE**: Copy existing environments as templates, modify for your needs
-5. **CONFIGURE**: Use `rl_select_environment` and `rl_edit_config` to set up training
-6. **TEST**: Always use `rl_test_inference` before full training to validate your setup
-7. **TRAIN**: Use `rl_start_training` to begin, `rl_check_status` to monitor
-8. **EVALUATE**: Use `rl_get_results` and analyze WandB metrics to assess performance
-
-## Environment Files
-
-Environment files are located in: `tinker-atropos/tinker_atropos/environments/`
-
-Study existing environments to learn patterns. Look for:
-- `load_dataset()` calls - how data is loaded
-- `score_answer()` / `score()` - verification logic
-- `get_next_item()` - prompt formatting
-- `system_prompt` - instruction format
-- `config_init()` - default configuration
-
-## Creating New Environments
-
-To create a new environment:
-1. Read an existing environment file (e.g., gsm8k_tinker.py)
-2. Use terminal to explore the target dataset format
-3. Copy the environment file as a template
-4. Modify the dataset loading, prompt formatting, and verifier logic
-5. Test with `rl_test_inference` before training
-
-## Important Guidelines
-
-- **Always test before training**: Training runs take hours - verify everything works first
-- **Monitor metrics**: Check WandB for reward/mean and percent_correct
-- **Status check intervals**: Wait at least 30 minutes between status checks
-- **Early stopping**: Stop training early if metrics look bad or stagnant
-- **Iterate quickly**: Start with small total_steps to validate, then scale up
-
-## Available Toolsets
-
-You have access to:
-- **RL tools**: Environment discovery, config management, training, testing
-- **Terminal**: Run commands, inspect files, explore datasets
-- **Web**: Search for information, documentation, papers
-- **File tools**: Read and modify code files
-
-When asked to train a model, follow this workflow:
-1. List available environments
-2. Select and configure the appropriate environment
-3. Test with sample prompts
-4. Start training with conservative settings
-5. Monitor progress and adjust as needed
-"""
-
-# Toolsets to enable for RL workflows
-RL_TOOLSETS = ["terminal", "web", "rl"]
-
-
-# ============================================================================
-# Helper Functions
-# ============================================================================
-
-def check_requirements():
-    """Check that all required environment variables and services are available."""
-    errors = []
-    
-    # Check API keys
-    if not os.getenv("OPENROUTER_API_KEY"):
-        errors.append("OPENROUTER_API_KEY not set - required for agent")
-    
-    missing_rl_keys = get_missing_keys()
-    if missing_rl_keys:
-        errors.append(f"Missing RL API keys: {', '.join(missing_rl_keys)}")
-    
-    if errors:
-        print("❌ Missing requirements:")
-        for error in errors:
-            print(f"   - {error}")
-        print("\nPlease set these environment variables in your .env file or shell.")
-        return False
-    
-    return True
-
-
-def check_tinker_atropos():
-    """Check if tinker-atropos submodule is properly set up."""
-    tinker_path = Path(__file__).parent / "tinker-atropos"
-    
-    if not tinker_path.exists():
-        return False, "tinker-atropos submodule not found. Run: git submodule update --init"
-    
-    envs_path = tinker_path / "tinker_atropos" / "environments"
-    if not envs_path.exists():
-        return False, f"environments directory not found at {envs_path}"
-    
-    env_files = list(envs_path.glob("*.py"))
-    env_files = [f for f in env_files if not f.name.startswith("_")]
-    
-    return True, {"path": str(tinker_path), "environments_count": len(env_files)}
-
-
-def list_environments_sync():
-    """List available environments (synchronous wrapper)."""
-    from tools.rl_training_tool import rl_list_environments
-    import json
-    
-    async def _list():
-        result = await rl_list_environments()
-        return json.loads(result)
-    
-    return asyncio.run(_list())
-
-
-# ============================================================================
-# Main CLI
-# ============================================================================
-
-def main(
-    task: str = None,
-    model: str = None,
-    api_key: str = None,
-    base_url: str = None,
-    max_iterations: int = RL_MAX_ITERATIONS,
-    interactive: bool = False,
-    list_environments: bool = False,
-    check_server: bool = False,
-    verbose: bool = False,
-    save_trajectories: bool = True,
-):
-    """
-    RL Training CLI - Dedicated runner for RL training workflows.
-    
-    Args:
-        task: The training task/goal (e.g., "Train a model on GSM8k for math")
-        model: Model to use for the agent (reads from ~/.hermes/config.yaml if not provided)
-        api_key: OpenRouter API key (uses OPENROUTER_API_KEY env var if not provided)
-        base_url: API base URL (reads from config or defaults to OpenRouter)
-        max_iterations: Maximum agent iterations (default: 200 for long workflows)
-        interactive: Run in interactive mode (multiple conversations)
-        list_environments: Just list available RL environments and exit
-        check_server: Check if RL API server is running and exit
-        verbose: Enable verbose logging
-        save_trajectories: Save conversation trajectories (default: True for RL)
-    
-    Examples:
-        # Train on a specific environment
-        python rl_cli.py "Train a model on GSM8k math problems"
-        
-        # Interactive mode
-        python rl_cli.py --interactive
-        
-        # List available environments
-        python rl_cli.py --list-environments
-        
-        # Check server status
-        python rl_cli.py --check-server
-    """
-    # Load config from ~/.hermes/config.yaml
-    config = load_hermes_config()
-    
-    # Use config values if not explicitly provided
-    if model is None:
-        model = config["model"]
-    if base_url is None:
-        base_url = config["base_url"]
-    
-    print("🎯 RL Training Agent")
-    print("=" * 60)
-    
-    # Handle setup check
-    if check_server:
-        print("\n🔍 Checking tinker-atropos setup...")
-        ok, result = check_tinker_atropos()
-        if ok:
-            print("✅ tinker-atropos submodule found")
-            print(f"   Path: {result.get('path')}")
-            print(f"   Environments found: {result.get('environments_count', 0)}")
-            
-            # Also check API keys
-            missing = get_missing_keys()
-            if missing:
-                print(f"\n⚠️  Missing API keys: {', '.join(missing)}")
-                print("   Add them to ~/.hermes/.env")
-            else:
-                print("✅ API keys configured")
-        else:
-            print(f"❌ tinker-atropos not set up: {result}")
-            print("\nTo set up:")
-            print("  git submodule update --init")
-            print("  pip install -e ./tinker-atropos")
-        return
-    
-    # Handle environment listing
-    if list_environments:
-        print("\n📋 Available RL Environments:")
-        print("-" * 40)
-        try:
-            data = list_environments_sync()
-            if "error" in data:
-                print(f"❌ Error: {data['error']}")
-                return
-            
-            envs = data.get("environments", [])
-            if not envs:
-                print("No environments found.")
-                print("\nMake sure tinker-atropos is set up:")
-                print("  git submodule update --init")
-                return
-            
-            for env in envs:
-                print(f"\n  📦 {env['name']}")
-                print(f"     Class: {env['class_name']}")
-                print(f"     Path: {env['file_path']}")
-                if env.get('description'):
-                    desc = env['description'][:100] + "..." if len(env.get('description', '')) > 100 else env.get('description', '')
-                    print(f"     Description: {desc}")
-            
-            print(f"\n📊 Total: {len(envs)} environments")
-            print("\nUse `rl_select_environment(name)` to select an environment for training.")
-        except Exception as e:
-            print(f"❌ Error listing environments: {e}")
-            print("\nMake sure tinker-atropos is set up:")
-            print("  git submodule update --init")
-            print("  pip install -e ./tinker-atropos")
-        return
-    
-    # Check requirements
-    if not check_requirements():
-        sys.exit(1)
-    
-    # Set default task if none provided
-    if not task and not interactive:
-        print("\n⚠️  No task provided. Use --interactive for interactive mode or provide a task.")
-        print("\nExamples:")
-        print('  python rl_cli.py "Train a model on GSM8k math problems"')
-        print('  python rl_cli.py "Create an RL environment for code generation"')
-        print('  python rl_cli.py --interactive')
-        return
-    
-    # Get API key
-    api_key = api_key or os.getenv("OPENROUTER_API_KEY")
-    if not api_key:
-        print("❌ No API key provided. Set OPENROUTER_API_KEY or pass --api-key")
-        sys.exit(1)
-    
-    print(f"\n🤖 Model: {model}")
-    print(f"🔧 Max iterations: {max_iterations}")
-    print(f"📁 Toolsets: {', '.join(RL_TOOLSETS)}")
-    print("=" * 60)
-    
-    # Create agent with RL configuration
-    agent = AIAgent(
-        base_url=base_url,
-        api_key=api_key,
-        model=model,
-        max_iterations=max_iterations,
-        enabled_toolsets=RL_TOOLSETS,
-        save_trajectories=save_trajectories,
-        verbose_logging=verbose,
-        quiet_mode=False,
-        ephemeral_system_prompt=RL_SYSTEM_PROMPT,
-    )
-    
-    if interactive:
-        # Interactive mode - multiple conversations
-        print("\n🔄 Interactive RL Training Mode")
-        print("Type 'quit' or 'exit' to end the session.")
-        print("Type 'status' to check active training runs.")
-        print("-" * 40)
-        
-        while True:
-            try:
-                user_input = input("\n🎯 RL Task> ").strip()
-                
-                if not user_input:
-                    continue
-                
-                if user_input.lower() in ('quit', 'exit', 'q'):
-                    print("\n👋 Goodbye!")
-                    break
-                
-                if user_input.lower() == 'status':
-                    # Quick status check
-                    from tools.rl_training_tool import rl_list_runs
-                    import json
-                    result = asyncio.run(rl_list_runs())
-                    runs = json.loads(result)
-                    if isinstance(runs, list) and runs:
-                        print("\n📊 Active Runs:")
-                        for run in runs:
-                            print(f"  - {run['run_id']}: {run['environment']} ({run['status']})")
-                    else:
-                        print("\nNo active runs.")
-                    continue
-                
-                # Run the agent
-                print("\n" + "=" * 60)
-                response = agent.run_conversation(user_input)
-                print("\n" + "=" * 60)
-                
-            except KeyboardInterrupt:
-                print("\n\n👋 Interrupted. Goodbye!")
-                break
-            except Exception as e:
-                print(f"\n❌ Error: {e}")
-                if verbose:
-                    import traceback
-                    traceback.print_exc()
-    else:
-        # Single task mode
-        print(f"\n📝 Task: {task}")
-        print("-" * 40)
-        
-        try:
-            response = agent.run_conversation(task)
-            print("\n" + "=" * 60)
-            print("✅ Task completed")
-        except KeyboardInterrupt:
-            print("\n\n⚠️ Interrupted by user")
-        except Exception as e:
-            print(f"\n❌ Error: {e}")
-            if verbose:
-                import traceback
-                traceback.print_exc()
-            sys.exit(1)
-
-
-if __name__ == "__main__":
-    fire.Fire(main)

scripts/hermes-gateway

@@ -1,414 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hermes Gateway - Standalone messaging platform integration.
-
-This is the proper entry point for running the gateway as a service.
-NOT tied to the CLI - runs independently.
-
-Usage:
-    # Run in foreground (for testing)
-    ./scripts/hermes-gateway
-    
-    # Install as systemd service
-    ./scripts/hermes-gateway install
-    
-    # Manage the service
-    ./scripts/hermes-gateway start
-    ./scripts/hermes-gateway stop
-    ./scripts/hermes-gateway restart
-    ./scripts/hermes-gateway status
-    
-    # Uninstall
-    ./scripts/hermes-gateway uninstall
-"""
-
-import argparse
-import asyncio
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-# Add parent directory to path
-SCRIPT_DIR = Path(__file__).parent.resolve()
-PROJECT_DIR = SCRIPT_DIR.parent
-sys.path.insert(0, str(PROJECT_DIR))
-
-# Load .env file
-from dotenv import load_dotenv
-env_path = PROJECT_DIR / '.env'
-if env_path.exists():
-    load_dotenv(dotenv_path=env_path)
-
-
-# =============================================================================
-# Service Configuration
-# =============================================================================
-
-SERVICE_NAME = "hermes-gateway"
-SERVICE_DESCRIPTION = "Hermes Agent Gateway - Messaging Platform Integration"
-
-def get_systemd_unit_path() -> Path:
-    """Get the path for the systemd user service file."""
-    return Path.home() / ".config" / "systemd" / "user" / f"{SERVICE_NAME}.service"
-
-def get_launchd_plist_path() -> Path:
-    """Get the path for the launchd plist file (macOS)."""
-    return Path.home() / "Library" / "LaunchAgents" / f"ai.hermes.gateway.plist"
-
-def get_python_path() -> str:
-    """Get the path to the Python interpreter."""
-    # Prefer the venv if it exists
-    venv_python = PROJECT_DIR / "venv" / "bin" / "python"
-    if venv_python.exists():
-        return str(venv_python)
-    return sys.executable
-
-def get_gateway_script_path() -> str:
-    """Get the path to this script."""
-    return str(Path(__file__).resolve())
-
-
-# =============================================================================
-# Systemd Service (Linux)
-# =============================================================================
-
-def generate_systemd_unit() -> str:
-    """Generate the systemd unit file content."""
-    python_path = get_python_path()
-    script_path = get_gateway_script_path()
-    working_dir = str(PROJECT_DIR)
-    
-    return f"""[Unit]
-Description={SERVICE_DESCRIPTION}
-After=network.target
-
-[Service]
-Type=simple
-ExecStart={python_path} {script_path} run
-WorkingDirectory={working_dir}
-Restart=on-failure
-RestartSec=10
-StandardOutput=journal
-StandardError=journal
-
-# Environment (optional - can also use .env file)
-# Environment="TELEGRAM_BOT_TOKEN=your_token"
-# Environment="DISCORD_BOT_TOKEN=your_token"
-
-[Install]
-WantedBy=default.target
-"""
-
-def install_systemd():
-    """Install the systemd user service."""
-    unit_path = get_systemd_unit_path()
-    unit_path.parent.mkdir(parents=True, exist_ok=True)
-    
-    print(f"Installing systemd service to: {unit_path}")
-    unit_path.write_text(generate_systemd_unit())
-    
-    # Reload systemd
-    subprocess.run(["systemctl", "--user", "daemon-reload"], check=True)
-    
-    # Enable the service (start on boot)
-    subprocess.run(["systemctl", "--user", "enable", SERVICE_NAME], check=True)
-    
-    print(f"✓ Service installed and enabled")
-    print(f"")
-    print(f"To start the service:")
-    print(f"  systemctl --user start {SERVICE_NAME}")
-    print(f"")
-    print(f"To view logs:")
-    print(f"  journalctl --user -u {SERVICE_NAME} -f")
-    print(f"")
-    print(f"To enable lingering (keeps service running after logout):")
-    print(f"  sudo loginctl enable-linger $USER")
-
-def uninstall_systemd():
-    """Uninstall the systemd user service."""
-    unit_path = get_systemd_unit_path()
-    
-    # Stop and disable first
-    subprocess.run(["systemctl", "--user", "stop", SERVICE_NAME], check=False)
-    subprocess.run(["systemctl", "--user", "disable", SERVICE_NAME], check=False)
-    
-    # Remove the unit file
-    if unit_path.exists():
-        unit_path.unlink()
-        print(f"✓ Removed {unit_path}")
-    
-    # Reload systemd
-    subprocess.run(["systemctl", "--user", "daemon-reload"], check=True)
-    print(f"✓ Service uninstalled")
-
-def systemd_status():
-    """Show systemd service status."""
-    subprocess.run(["systemctl", "--user", "status", SERVICE_NAME])
-
-def systemd_start():
-    """Start the systemd service."""
-    subprocess.run(["systemctl", "--user", "start", SERVICE_NAME], check=True)
-    print(f"✓ Service started")
-
-def systemd_stop():
-    """Stop the systemd service."""
-    subprocess.run(["systemctl", "--user", "stop", SERVICE_NAME], check=True)
-    print(f"✓ Service stopped")
-
-def systemd_restart():
-    """Restart the systemd service."""
-    subprocess.run(["systemctl", "--user", "restart", SERVICE_NAME], check=True)
-    print(f"✓ Service restarted")
-
-
-# =============================================================================
-# Launchd Service (macOS)
-# =============================================================================
-
-def generate_launchd_plist() -> str:
-    """Generate the launchd plist file content."""
-    python_path = get_python_path()
-    script_path = get_gateway_script_path()
-    working_dir = str(PROJECT_DIR)
-    log_dir = Path.home() / ".hermes" / "logs"
-    
-    return f"""<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>ai.hermes.gateway</string>
-    
-    <key>ProgramArguments</key>
-    <array>
-        <string>{python_path}</string>
-        <string>{script_path}</string>
-        <string>run</string>
-    </array>
-    
-    <key>WorkingDirectory</key>
-    <string>{working_dir}</string>
-    
-    <key>RunAtLoad</key>
-    <true/>
-    
-    <key>KeepAlive</key>
-    <dict>
-        <key>SuccessfulExit</key>
-        <false/>
-    </dict>
-    
-    <key>StandardOutPath</key>
-    <string>{log_dir}/gateway.log</string>
-    
-    <key>StandardErrorPath</key>
-    <string>{log_dir}/gateway.error.log</string>
-    
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
-    </dict>
-</dict>
-</plist>
-"""
-
-def install_launchd():
-    """Install the launchd service (macOS)."""
-    plist_path = get_launchd_plist_path()
-    plist_path.parent.mkdir(parents=True, exist_ok=True)
-    
-    # Ensure log directory exists
-    log_dir = Path.home() / ".hermes" / "logs"
-    log_dir.mkdir(parents=True, exist_ok=True)
-    
-    print(f"Installing launchd service to: {plist_path}")
-    plist_path.write_text(generate_launchd_plist())
-    
-    # Load the service
-    subprocess.run(["launchctl", "load", str(plist_path)], check=True)
-    
-    print(f"✓ Service installed and loaded")
-    print(f"")
-    print(f"To view logs:")
-    print(f"  tail -f ~/.hermes/logs/gateway.log")
-    print(f"")
-    print(f"To manage the service:")
-    print(f"  launchctl start ai.hermes.gateway")
-    print(f"  launchctl stop ai.hermes.gateway")
-
-def uninstall_launchd():
-    """Uninstall the launchd service (macOS)."""
-    plist_path = get_launchd_plist_path()
-    
-    # Unload first
-    subprocess.run(["launchctl", "unload", str(plist_path)], check=False)
-    
-    # Remove the plist file
-    if plist_path.exists():
-        plist_path.unlink()
-        print(f"✓ Removed {plist_path}")
-    
-    print(f"✓ Service uninstalled")
-
-def launchd_status():
-    """Show launchd service status."""
-    subprocess.run(["launchctl", "list", "ai.hermes.gateway"])
-
-def launchd_start():
-    """Start the launchd service."""
-    subprocess.run(["launchctl", "start", "ai.hermes.gateway"], check=True)
-    print(f"✓ Service started")
-
-def launchd_stop():
-    """Stop the launchd service."""
-    subprocess.run(["launchctl", "stop", "ai.hermes.gateway"], check=True)
-    print(f"✓ Service stopped")
-
-def launchd_restart():
-    """Restart the launchd service."""
-    launchd_stop()
-    launchd_start()
-
-
-# =============================================================================
-# Platform Detection
-# =============================================================================
-
-def is_linux() -> bool:
-    return sys.platform.startswith('linux')
-
-def is_macos() -> bool:
-    return sys.platform == 'darwin'
-
-def is_windows() -> bool:
-    return sys.platform == 'win32'
-
-
-# =============================================================================
-# Gateway Runner
-# =============================================================================
-
-def run_gateway():
-    """Run the gateway in foreground."""
-    from gateway.run import start_gateway
-    print("Starting Hermes Gateway...")
-    print("Press Ctrl+C to stop.")
-    print()
-    asyncio.run(start_gateway())
-
-
-# =============================================================================
-# Main CLI
-# =============================================================================
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Hermes Gateway - Messaging Platform Integration",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-    # Run in foreground (for testing)
-    ./scripts/hermes-gateway run
-    
-    # Install as system service
-    ./scripts/hermes-gateway install
-    
-    # Manage the service
-    ./scripts/hermes-gateway start
-    ./scripts/hermes-gateway stop
-    ./scripts/hermes-gateway restart
-    ./scripts/hermes-gateway status
-    
-    # Uninstall
-    ./scripts/hermes-gateway uninstall
-
-Configuration:
-    Set environment variables in .env file or system environment:
-    - TELEGRAM_BOT_TOKEN
-    - DISCORD_BOT_TOKEN
-    - WHATSAPP_ENABLED
-    
-    Or create ~/.hermes/gateway.json for advanced configuration.
-"""
-    )
-    
-    parser.add_argument(
-        "command",
-        choices=["run", "install", "uninstall", "start", "stop", "restart", "status"],
-        nargs="?",
-        default="run",
-        help="Command to execute (default: run)"
-    )
-    
-    parser.add_argument(
-        "--verbose", "-v",
-        action="store_true",
-        help="Verbose output"
-    )
-    
-    args = parser.parse_args()
-    
-    # Detect platform and dispatch command
-    if args.command == "run":
-        run_gateway()
-    
-    elif args.command == "install":
-        if is_linux():
-            install_systemd()
-        elif is_macos():
-            install_launchd()
-        else:
-            print("Service installation not supported on this platform.")
-            print("Please run manually: ./scripts/hermes-gateway run")
-            sys.exit(1)
-    
-    elif args.command == "uninstall":
-        if is_linux():
-            uninstall_systemd()
-        elif is_macos():
-            uninstall_launchd()
-        else:
-            print("Service uninstallation not supported on this platform.")
-            sys.exit(1)
-    
-    elif args.command == "start":
-        if is_linux():
-            systemd_start()
-        elif is_macos():
-            launchd_start()
-        else:
-            print("Not supported on this platform.")
-            sys.exit(1)
-    
-    elif args.command == "stop":
-        if is_linux():
-            systemd_stop()
-        elif is_macos():
-            launchd_stop()
-        else:
-            print("Not supported on this platform.")
-            sys.exit(1)
-    
-    elif args.command == "restart":
-        if is_linux():
-            systemd_restart()
-        elif is_macos():
-            launchd_restart()
-        else:
-            print("Not supported on this platform.")
-            sys.exit(1)
-    
-    elif args.command == "status":
-        if is_linux():
-            systemd_status()
-        elif is_macos():
-            launchd_status()
-        else:
-            print("Not supported on this platform.")
-            sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

scripts/install.ps1

@@ -1,582 +0,0 @@
-# ============================================================================
-# Hermes Agent Installer for Windows
-# ============================================================================
-# Installation script for Windows (PowerShell).
-# Uses uv for fast Python provisioning and package management.
-#
-# Usage:
-#   irm https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.ps1 | iex
-#
-# Or download and run with options:
-#   .\install.ps1 -NoVenv -SkipSetup
-#
-# ============================================================================
-
-param(
-    [switch]$NoVenv,
-    [switch]$SkipSetup,
-    [string]$Branch = "main",
-    [string]$HermesHome = "$env:USERPROFILE\.hermes",
-    [string]$InstallDir = "$env:USERPROFILE\.hermes\hermes-agent"
-)
-
-$ErrorActionPreference = "Stop"
-
-# ============================================================================
-# Configuration
-# ============================================================================
-
-$RepoUrlSsh = "git@github.com:NousResearch/hermes-agent.git"
-$RepoUrlHttps = "https://github.com/NousResearch/hermes-agent.git"
-$PythonVersion = "3.11"
-
-# ============================================================================
-# Helper functions
-# ============================================================================
-
-function Write-Banner {
-    Write-Host ""
-    Write-Host "┌─────────────────────────────────────────────────────────┐" -ForegroundColor Magenta
-    Write-Host "│             🦋 Hermes Agent Installer                   │" -ForegroundColor Magenta
-    Write-Host "├─────────────────────────────────────────────────────────┤" -ForegroundColor Magenta
-    Write-Host "│  I'm just a butterfly with a lot of tools.             │" -ForegroundColor Magenta
-    Write-Host "└─────────────────────────────────────────────────────────┘" -ForegroundColor Magenta
-    Write-Host ""
-}
-
-function Write-Info {
-    param([string]$Message)
-    Write-Host "→ $Message" -ForegroundColor Cyan
-}
-
-function Write-Success {
-    param([string]$Message)
-    Write-Host "✓ $Message" -ForegroundColor Green
-}
-
-function Write-Warn {
-    param([string]$Message)
-    Write-Host "⚠ $Message" -ForegroundColor Yellow
-}
-
-function Write-Err {
-    param([string]$Message)
-    Write-Host "✗ $Message" -ForegroundColor Red
-}
-
-# ============================================================================
-# Dependency checks
-# ============================================================================
-
-function Install-Uv {
-    Write-Info "Checking for uv package manager..."
-    
-    # Check if uv is already available
-    if (Get-Command uv -ErrorAction SilentlyContinue) {
-        $version = uv --version
-        $script:UvCmd = "uv"
-        Write-Success "uv found ($version)"
-        return $true
-    }
-    
-    # Check common install locations
-    $uvPaths = @(
-        "$env:USERPROFILE\.local\bin\uv.exe",
-        "$env:USERPROFILE\.cargo\bin\uv.exe"
-    )
-    foreach ($uvPath in $uvPaths) {
-        if (Test-Path $uvPath) {
-            $script:UvCmd = $uvPath
-            $version = & $uvPath --version
-            Write-Success "uv found at $uvPath ($version)"
-            return $true
-        }
-    }
-    
-    # Install uv
-    Write-Info "Installing uv (fast Python package manager)..."
-    try {
-        powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex" 2>&1 | Out-Null
-        
-        # Find the installed binary
-        $uvExe = "$env:USERPROFILE\.local\bin\uv.exe"
-        if (-not (Test-Path $uvExe)) {
-            $uvExe = "$env:USERPROFILE\.cargo\bin\uv.exe"
-        }
-        if (-not (Test-Path $uvExe)) {
-            # Refresh PATH and try again
-            $env:Path = [Environment]::GetEnvironmentVariable("Path", "User") + ";" + [Environment]::GetEnvironmentVariable("Path", "Machine")
-            if (Get-Command uv -ErrorAction SilentlyContinue) {
-                $uvExe = (Get-Command uv).Source
-            }
-        }
-        
-        if (Test-Path $uvExe) {
-            $script:UvCmd = $uvExe
-            $version = & $uvExe --version
-            Write-Success "uv installed ($version)"
-            return $true
-        }
-        
-        Write-Err "uv installed but not found on PATH"
-        Write-Info "Try restarting your terminal and re-running"
-        return $false
-    } catch {
-        Write-Err "Failed to install uv"
-        Write-Info "Install manually: https://docs.astral.sh/uv/getting-started/installation/"
-        return $false
-    }
-}
-
-function Test-Python {
-    Write-Info "Checking Python $PythonVersion..."
-    
-    # Let uv find or install Python
-    try {
-        $pythonPath = & $UvCmd python find $PythonVersion 2>$null
-        if ($pythonPath) {
-            $ver = & $pythonPath --version 2>$null
-            Write-Success "Python found: $ver"
-            return $true
-        }
-    } catch { }
-    
-    # Python not found — use uv to install it (no admin needed!)
-    Write-Info "Python $PythonVersion not found, installing via uv..."
-    try {
-        & $UvCmd python install $PythonVersion 2>&1 | Out-Null
-        $pythonPath = & $UvCmd python find $PythonVersion 2>$null
-        if ($pythonPath) {
-            $ver = & $pythonPath --version 2>$null
-            Write-Success "Python installed: $ver"
-            return $true
-        }
-    } catch { }
-    
-    Write-Err "Failed to install Python $PythonVersion"
-    Write-Info "Install Python $PythonVersion manually, then re-run this script"
-    return $false
-}
-
-function Test-Git {
-    Write-Info "Checking Git..."
-    
-    if (Get-Command git -ErrorAction SilentlyContinue) {
-        $version = git --version
-        Write-Success "Git found ($version)"
-        return $true
-    }
-    
-    Write-Err "Git not found"
-    Write-Info "Please install Git from:"
-    Write-Info "  https://git-scm.com/download/win"
-    return $false
-}
-
-function Test-Node {
-    Write-Info "Checking Node.js (optional, for browser tools)..."
-    
-    if (Get-Command node -ErrorAction SilentlyContinue) {
-        $version = node --version
-        Write-Success "Node.js $version found"
-        $script:HasNode = $true
-        return $true
-    }
-    
-    Write-Warn "Node.js not found (browser tools will be limited)"
-    Write-Info "To install Node.js (optional):"
-    Write-Info "  https://nodejs.org/en/download/"
-    $script:HasNode = $false
-    return $true  # Don't fail - Node is optional
-}
-
-function Test-Ripgrep {
-    Write-Info "Checking ripgrep (optional, for faster file search)..."
-    
-    if (Get-Command rg -ErrorAction SilentlyContinue) {
-        $version = rg --version | Select-Object -First 1
-        Write-Success "$version found"
-        $script:HasRipgrep = $true
-        return $true
-    }
-    
-    Write-Warn "ripgrep not found (file search will use findstr fallback)"
-    
-    # Check what package managers are available
-    $hasWinget = Get-Command winget -ErrorAction SilentlyContinue
-    $hasChoco = Get-Command choco -ErrorAction SilentlyContinue
-    $hasScoop = Get-Command scoop -ErrorAction SilentlyContinue
-    
-    # Offer to install
-    Write-Host ""
-    $response = Read-Host "Would you like to install ripgrep? (faster search, recommended) [Y/n]"
-    
-    if ($response -eq "" -or $response -match "^[Yy]") {
-        Write-Info "Installing ripgrep..."
-        
-        if ($hasWinget) {
-            try {
-                winget install BurntSushi.ripgrep.MSVC --silent 2>&1 | Out-Null
-                if ($LASTEXITCODE -eq 0) {
-                    Write-Success "ripgrep installed via winget"
-                    $script:HasRipgrep = $true
-                    return $true
-                }
-            } catch { }
-        }
-        
-        if ($hasChoco) {
-            try {
-                choco install ripgrep -y 2>&1 | Out-Null
-                if ($LASTEXITCODE -eq 0) {
-                    Write-Success "ripgrep installed via chocolatey"
-                    $script:HasRipgrep = $true
-                    return $true
-                }
-            } catch { }
-        }
-        
-        if ($hasScoop) {
-            try {
-                scoop install ripgrep 2>&1 | Out-Null
-                if ($LASTEXITCODE -eq 0) {
-                    Write-Success "ripgrep installed via scoop"
-                    $script:HasRipgrep = $true
-                    return $true
-                }
-            } catch { }
-        }
-        
-        Write-Warn "Auto-install failed. You can install manually:"
-    } else {
-        Write-Info "Skipping ripgrep installation. To install manually:"
-    }
-    
-    # Show manual install instructions
-    Write-Info "  winget install BurntSushi.ripgrep.MSVC"
-    Write-Info "  Or: choco install ripgrep"
-    Write-Info "  Or: scoop install ripgrep"
-    Write-Info "  Or download from: https://github.com/BurntSushi/ripgrep/releases"
-    
-    $script:HasRipgrep = $false
-    return $true  # Don't fail - ripgrep is optional
-}
-
-# ============================================================================
-# Installation
-# ============================================================================
-
-function Install-Repository {
-    Write-Info "Installing to $InstallDir..."
-    
-    if (Test-Path $InstallDir) {
-        if (Test-Path "$InstallDir\.git") {
-            Write-Info "Existing installation found, updating..."
-            Push-Location $InstallDir
-            git fetch origin
-            git checkout $Branch
-            git pull origin $Branch
-            Pop-Location
-        } else {
-            Write-Err "Directory exists but is not a git repository: $InstallDir"
-            Write-Info "Remove it or choose a different directory with -InstallDir"
-            exit 1
-        }
-    } else {
-        # Try SSH first (for private repo access), fall back to HTTPS
-        Write-Info "Trying SSH clone..."
-        $sshResult = git clone --branch $Branch --recurse-submodules $RepoUrlSsh $InstallDir 2>&1
-        
-        if ($LASTEXITCODE -eq 0) {
-            Write-Success "Cloned via SSH"
-        } else {
-            Write-Info "SSH failed, trying HTTPS..."
-            $httpsResult = git clone --branch $Branch --recurse-submodules $RepoUrlHttps $InstallDir 2>&1
-            
-            if ($LASTEXITCODE -eq 0) {
-                Write-Success "Cloned via HTTPS"
-            } else {
-                Write-Err "Failed to clone repository"
-                Write-Info "For private repo access, ensure your SSH key is added to GitHub:"
-                Write-Info "  ssh-add ~/.ssh/id_rsa"
-                Write-Info "  ssh -T git@github.com  # Test connection"
-                exit 1
-            }
-        }
-    }
-    
-    # Ensure submodules are initialized and updated
-    Write-Info "Initializing submodules (mini-swe-agent, tinker-atropos)..."
-    Push-Location $InstallDir
-    git submodule update --init --recursive
-    Pop-Location
-    Write-Success "Submodules ready"
-    
-    Write-Success "Repository ready"
-}
-
-function Install-Venv {
-    if ($NoVenv) {
-        Write-Info "Skipping virtual environment (-NoVenv)"
-        return
-    }
-    
-    Write-Info "Creating virtual environment with Python $PythonVersion..."
-    
-    Push-Location $InstallDir
-    
-    if (Test-Path "venv") {
-        Write-Info "Virtual environment already exists, recreating..."
-        Remove-Item -Recurse -Force "venv"
-    }
-    
-    # uv creates the venv and pins the Python version in one step
-    & $UvCmd venv venv --python $PythonVersion
-    
-    Pop-Location
-    
-    Write-Success "Virtual environment ready (Python $PythonVersion)"
-}
-
-function Install-Dependencies {
-    Write-Info "Installing dependencies..."
-    
-    Push-Location $InstallDir
-    
-    if (-not $NoVenv) {
-        # Tell uv to install into our venv (no activation needed)
-        $env:VIRTUAL_ENV = "$InstallDir\venv"
-    }
-    
-    # Install main package with all extras
-    try {
-        & $UvCmd pip install -e ".[all]" 2>&1 | Out-Null
-    } catch {
-        & $UvCmd pip install -e "." | Out-Null
-    }
-    
-    Write-Success "Main package installed"
-    
-    # Install submodules
-    Write-Info "Installing mini-swe-agent (terminal tool backend)..."
-    if (Test-Path "mini-swe-agent\pyproject.toml") {
-        try {
-            & $UvCmd pip install -e ".\mini-swe-agent" 2>&1 | Out-Null
-            Write-Success "mini-swe-agent installed"
-        } catch {
-            Write-Warn "mini-swe-agent install failed (terminal tools may not work)"
-        }
-    } else {
-        Write-Warn "mini-swe-agent not found (run: git submodule update --init)"
-    }
-    
-    Write-Info "Installing tinker-atropos (RL training backend)..."
-    if (Test-Path "tinker-atropos\pyproject.toml") {
-        try {
-            & $UvCmd pip install -e ".\tinker-atropos" 2>&1 | Out-Null
-            Write-Success "tinker-atropos installed"
-        } catch {
-            Write-Warn "tinker-atropos install failed (RL tools may not work)"
-        }
-    } else {
-        Write-Warn "tinker-atropos not found (run: git submodule update --init)"
-    }
-    
-    Pop-Location
-    
-    Write-Success "All dependencies installed"
-}
-
-function Set-PathVariable {
-    Write-Info "Setting up hermes command..."
-    
-    if ($NoVenv) {
-        $hermesBin = "$InstallDir"
-    } else {
-        $hermesBin = "$InstallDir\venv\Scripts"
-    }
-    
-    # Add the venv Scripts dir to user PATH so hermes is globally available
-    # On Windows, the hermes.exe in venv\Scripts\ has the venv Python baked in
-    $currentPath = [Environment]::GetEnvironmentVariable("Path", "User")
-    
-    if ($currentPath -notlike "*$hermesBin*") {
-        [Environment]::SetEnvironmentVariable(
-            "Path",
-            "$hermesBin;$currentPath",
-            "User"
-        )
-        Write-Success "Added to user PATH: $hermesBin"
-    } else {
-        Write-Info "PATH already configured"
-    }
-    
-    # Update current session
-    $env:Path = "$hermesBin;$env:Path"
-    
-    Write-Success "hermes command ready"
-}
-
-function Copy-ConfigTemplates {
-    Write-Info "Setting up configuration files..."
-    
-    # Create ~/.hermes directory structure
-    New-Item -ItemType Directory -Force -Path "$HermesHome\cron" | Out-Null
-    New-Item -ItemType Directory -Force -Path "$HermesHome\sessions" | Out-Null
-    New-Item -ItemType Directory -Force -Path "$HermesHome\logs" | Out-Null
-    
-    # Create .env
-    $envPath = "$HermesHome\.env"
-    if (-not (Test-Path $envPath)) {
-        $examplePath = "$InstallDir\.env.example"
-        if (Test-Path $examplePath) {
-            Copy-Item $examplePath $envPath
-            Write-Success "Created ~/.hermes/.env from template"
-        } else {
-            New-Item -ItemType File -Force -Path $envPath | Out-Null
-            Write-Success "Created ~/.hermes/.env"
-        }
-    } else {
-        Write-Info "~/.hermes/.env already exists, keeping it"
-    }
-    
-    # Create config.yaml
-    $configPath = "$HermesHome\config.yaml"
-    if (-not (Test-Path $configPath)) {
-        $examplePath = "$InstallDir\cli-config.yaml.example"
-        if (Test-Path $examplePath) {
-            Copy-Item $examplePath $configPath
-            Write-Success "Created ~/.hermes/config.yaml from template"
-        }
-    } else {
-        Write-Info "~/.hermes/config.yaml already exists, keeping it"
-    }
-    
-    Write-Success "Configuration directory ready: ~/.hermes/"
-}
-
-function Install-NodeDeps {
-    if (-not $HasNode) {
-        Write-Info "Skipping Node.js dependencies (Node not installed)"
-        return
-    }
-    
-    Push-Location $InstallDir
-    
-    if (Test-Path "package.json") {
-        Write-Info "Installing Node.js dependencies..."
-        try {
-            npm install --silent 2>&1 | Out-Null
-            Write-Success "Node.js dependencies installed"
-        } catch {
-            Write-Warn "npm install failed (browser tools may not work)"
-        }
-    }
-    
-    Pop-Location
-}
-
-function Invoke-SetupWizard {
-    if ($SkipSetup) {
-        Write-Info "Skipping setup wizard (-SkipSetup)"
-        return
-    }
-    
-    Write-Host ""
-    Write-Info "Starting setup wizard..."
-    Write-Host ""
-    
-    Push-Location $InstallDir
-    
-    # Run hermes setup using the venv Python directly (no activation needed)
-    if (-not $NoVenv) {
-        & ".\venv\Scripts\python.exe" -m hermes_cli.main setup
-    } else {
-        python -m hermes_cli.main setup
-    }
-    
-    Pop-Location
-}
-
-function Write-Completion {
-    Write-Host ""
-    Write-Host "┌─────────────────────────────────────────────────────────┐" -ForegroundColor Green
-    Write-Host "│              ✓ Installation Complete!                   │" -ForegroundColor Green
-    Write-Host "└─────────────────────────────────────────────────────────┘" -ForegroundColor Green
-    Write-Host ""
-    
-    # Show file locations
-    Write-Host "📁 Your files (all in ~/.hermes/):" -ForegroundColor Cyan
-    Write-Host ""
-    Write-Host "   Config:    " -NoNewline -ForegroundColor Yellow
-    Write-Host "$HermesHome\config.yaml"
-    Write-Host "   API Keys:  " -NoNewline -ForegroundColor Yellow
-    Write-Host "$HermesHome\.env"
-    Write-Host "   Data:      " -NoNewline -ForegroundColor Yellow
-    Write-Host "$HermesHome\cron\, sessions\, logs\"
-    Write-Host "   Code:      " -NoNewline -ForegroundColor Yellow
-    Write-Host "$HermesHome\hermes-agent\"
-    Write-Host ""
-    
-    Write-Host "─────────────────────────────────────────────────────────" -ForegroundColor Cyan
-    Write-Host ""
-    Write-Host "🚀 Commands:" -ForegroundColor Cyan
-    Write-Host ""
-    Write-Host "   hermes              " -NoNewline -ForegroundColor Green
-    Write-Host "Start chatting"
-    Write-Host "   hermes setup        " -NoNewline -ForegroundColor Green
-    Write-Host "Configure API keys & settings"
-    Write-Host "   hermes config       " -NoNewline -ForegroundColor Green
-    Write-Host "View/edit configuration"
-    Write-Host "   hermes config edit  " -NoNewline -ForegroundColor Green
-    Write-Host "Open config in editor"
-    Write-Host "   hermes gateway      " -NoNewline -ForegroundColor Green
-    Write-Host "Run messaging gateway"
-    Write-Host "   hermes update       " -NoNewline -ForegroundColor Green
-    Write-Host "Update to latest version"
-    Write-Host ""
-    
-    Write-Host "─────────────────────────────────────────────────────────" -ForegroundColor Cyan
-    Write-Host ""
-    Write-Host "⚡ Restart your terminal for PATH changes to take effect" -ForegroundColor Yellow
-    Write-Host ""
-    
-    if (-not $HasNode) {
-        Write-Host "Note: Node.js was not found. Browser automation tools" -ForegroundColor Yellow
-        Write-Host "will have limited functionality." -ForegroundColor Yellow
-        Write-Host ""
-    }
-    
-    if (-not $HasRipgrep) {
-        Write-Host "Note: ripgrep (rg) was not found. File search will use" -ForegroundColor Yellow
-        Write-Host "findstr as a fallback. For faster search:" -ForegroundColor Yellow
-        Write-Host "  winget install BurntSushi.ripgrep.MSVC" -ForegroundColor Yellow
-        Write-Host ""
-    }
-}
-
-# ============================================================================
-# Main
-# ============================================================================
-
-function Main {
-    Write-Banner
-    
-    if (-not (Install-Uv)) { exit 1 }
-    if (-not (Test-Python)) { exit 1 }
-    if (-not (Test-Git)) { exit 1 }
-    Test-Node      # Optional, doesn't fail
-    Test-Ripgrep   # Optional, doesn't fail
-    
-    Install-Repository
-    Install-Venv
-    Install-Dependencies
-    Install-NodeDeps
-    Set-PathVariable
-    Copy-ConfigTemplates
-    Invoke-SetupWizard
-    
-    Write-Completion
-}
-
-Main

scripts/install.sh

@@ -1,722 +0,0 @@
-#!/bin/bash
-# ============================================================================
-# Hermes Agent Installer
-# ============================================================================
-# Installation script for Linux and macOS.
-# Uses uv for fast Python provisioning and package management.
-#
-# Usage:
-#   curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
-#
-# Or with options:
-#   curl -fsSL ... | bash -s -- --no-venv --skip-setup
-#
-# ============================================================================
-
-set -e
-
-# Colors
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[0;33m'
-BLUE='\033[0;34m'
-MAGENTA='\033[0;35m'
-CYAN='\033[0;36m'
-NC='\033[0m' # No Color
-BOLD='\033[1m'
-
-# Configuration
-REPO_URL_SSH="git@github.com:NousResearch/hermes-agent.git"
-REPO_URL_HTTPS="https://github.com/NousResearch/hermes-agent.git"
-HERMES_HOME="$HOME/.hermes"
-INSTALL_DIR="${HERMES_INSTALL_DIR:-$HERMES_HOME/hermes-agent}"
-PYTHON_VERSION="3.11"
-
-# Options
-USE_VENV=true
-RUN_SETUP=true
-BRANCH="main"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --no-venv)
-            USE_VENV=false
-            shift
-            ;;
-        --skip-setup)
-            RUN_SETUP=false
-            shift
-            ;;
-        --branch)
-            BRANCH="$2"
-            shift 2
-            ;;
-        --dir)
-            INSTALL_DIR="$2"
-            shift 2
-            ;;
-        -h|--help)
-            echo "Hermes Agent Installer"
-            echo ""
-            echo "Usage: install.sh [OPTIONS]"
-            echo ""
-            echo "Options:"
-            echo "  --no-venv      Don't create virtual environment"
-            echo "  --skip-setup   Skip interactive setup wizard"
-            echo "  --branch NAME  Git branch to install (default: main)"
-            echo "  --dir PATH     Installation directory (default: ~/.hermes/hermes-agent)"
-            echo "  -h, --help     Show this help"
-            exit 0
-            ;;
-        *)
-            echo "Unknown option: $1"
-            exit 1
-            ;;
-    esac
-done
-
-# ============================================================================
-# Helper functions
-# ============================================================================
-
-print_banner() {
-    echo ""
-    echo -e "${MAGENTA}${BOLD}"
-    echo "┌─────────────────────────────────────────────────────────┐"
-    echo "│             🦋 Hermes Agent Installer                   │"
-    echo "├─────────────────────────────────────────────────────────┤"
-    echo "│  I'm just a butterfly with a lot of tools.             │"
-    echo "└─────────────────────────────────────────────────────────┘"
-    echo -e "${NC}"
-}
-
-log_info() {
-    echo -e "${CYAN}→${NC} $1"
-}
-
-log_success() {
-    echo -e "${GREEN}✓${NC} $1"
-}
-
-log_warn() {
-    echo -e "${YELLOW}⚠${NC} $1"
-}
-
-log_error() {
-    echo -e "${RED}✗${NC} $1"
-}
-
-# ============================================================================
-# System detection
-# ============================================================================
-
-detect_os() {
-    case "$(uname -s)" in
-        Linux*)
-            OS="linux"
-            if [ -f /etc/os-release ]; then
-                . /etc/os-release
-                DISTRO="$ID"
-            else
-                DISTRO="unknown"
-            fi
-            ;;
-        Darwin*)
-            OS="macos"
-            DISTRO="macos"
-            ;;
-        CYGWIN*|MINGW*|MSYS*)
-            OS="windows"
-            DISTRO="windows"
-            log_error "Windows detected. Please use the PowerShell installer:"
-            log_info "  irm https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.ps1 | iex"
-            exit 1
-            ;;
-        *)
-            OS="unknown"
-            DISTRO="unknown"
-            log_warn "Unknown operating system"
-            ;;
-    esac
-    
-    log_success "Detected: $OS ($DISTRO)"
-}
-
-# ============================================================================
-# Dependency checks
-# ============================================================================
-
-install_uv() {
-    log_info "Checking for uv package manager..."
-    
-    # Check common locations for uv
-    if command -v uv &> /dev/null; then
-        UV_CMD="uv"
-        UV_VERSION=$($UV_CMD --version 2>/dev/null)
-        log_success "uv found ($UV_VERSION)"
-        return 0
-    fi
-    
-    # Check ~/.local/bin (default uv install location) even if not on PATH yet
-    if [ -x "$HOME/.local/bin/uv" ]; then
-        UV_CMD="$HOME/.local/bin/uv"
-        UV_VERSION=$($UV_CMD --version 2>/dev/null)
-        log_success "uv found at ~/.local/bin ($UV_VERSION)"
-        return 0
-    fi
-    
-    # Check ~/.cargo/bin (alternative uv install location)
-    if [ -x "$HOME/.cargo/bin/uv" ]; then
-        UV_CMD="$HOME/.cargo/bin/uv"
-        UV_VERSION=$($UV_CMD --version 2>/dev/null)
-        log_success "uv found at ~/.cargo/bin ($UV_VERSION)"
-        return 0
-    fi
-    
-    # Install uv
-    log_info "Installing uv (fast Python package manager)..."
-    if curl -LsSf https://astral.sh/uv/install.sh | sh 2>/dev/null; then
-        # uv installs to ~/.local/bin by default
-        if [ -x "$HOME/.local/bin/uv" ]; then
-            UV_CMD="$HOME/.local/bin/uv"
-        elif [ -x "$HOME/.cargo/bin/uv" ]; then
-            UV_CMD="$HOME/.cargo/bin/uv"
-        elif command -v uv &> /dev/null; then
-            UV_CMD="uv"
-        else
-            log_error "uv installed but not found on PATH"
-            log_info "Try adding ~/.local/bin to your PATH and re-running"
-            exit 1
-        fi
-        UV_VERSION=$($UV_CMD --version 2>/dev/null)
-        log_success "uv installed ($UV_VERSION)"
-    else
-        log_error "Failed to install uv"
-        log_info "Install manually: https://docs.astral.sh/uv/getting-started/installation/"
-        exit 1
-    fi
-}
-
-check_python() {
-    log_info "Checking Python $PYTHON_VERSION..."
-    
-    # Let uv handle Python — it can download and manage Python versions
-    # First check if a suitable Python is already available
-    if $UV_CMD python find "$PYTHON_VERSION" &> /dev/null; then
-        PYTHON_PATH=$($UV_CMD python find "$PYTHON_VERSION")
-        PYTHON_FOUND_VERSION=$($PYTHON_PATH --version 2>/dev/null)
-        log_success "Python found: $PYTHON_FOUND_VERSION"
-        return 0
-    fi
-    
-    # Python not found — use uv to install it (no sudo needed!)
-    log_info "Python $PYTHON_VERSION not found, installing via uv..."
-    if $UV_CMD python install "$PYTHON_VERSION"; then
-        PYTHON_PATH=$($UV_CMD python find "$PYTHON_VERSION")
-        PYTHON_FOUND_VERSION=$($PYTHON_PATH --version 2>/dev/null)
-        log_success "Python installed: $PYTHON_FOUND_VERSION"
-    else
-        log_error "Failed to install Python $PYTHON_VERSION"
-        log_info "Install Python $PYTHON_VERSION manually, then re-run this script"
-        exit 1
-    fi
-}
-
-check_git() {
-    log_info "Checking Git..."
-    
-    if command -v git &> /dev/null; then
-        GIT_VERSION=$(git --version | awk '{print $3}')
-        log_success "Git $GIT_VERSION found"
-        return 0
-    fi
-    
-    log_error "Git not found"
-    log_info "Please install Git:"
-    
-    case "$OS" in
-        linux)
-            case "$DISTRO" in
-                ubuntu|debian)
-                    log_info "  sudo apt update && sudo apt install git"
-                    ;;
-                fedora)
-                    log_info "  sudo dnf install git"
-                    ;;
-                arch)
-                    log_info "  sudo pacman -S git"
-                    ;;
-                *)
-                    log_info "  Use your package manager to install git"
-                    ;;
-            esac
-            ;;
-        macos)
-            log_info "  xcode-select --install"
-            log_info "  Or: brew install git"
-            ;;
-    esac
-    
-    exit 1
-}
-
-check_node() {
-    log_info "Checking Node.js (optional, for browser tools)..."
-    
-    if command -v node &> /dev/null; then
-        NODE_VERSION=$(node --version)
-        log_success "Node.js $NODE_VERSION found"
-        HAS_NODE=true
-        return 0
-    fi
-    
-    log_warn "Node.js not found (browser tools will be limited)"
-    log_info "To install Node.js (optional):"
-    
-    case "$OS" in
-        linux)
-            case "$DISTRO" in
-                ubuntu|debian)
-                    log_info "  curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -"
-                    log_info "  sudo apt install -y nodejs"
-                    ;;
-                fedora)
-                    log_info "  sudo dnf install nodejs"
-                    ;;
-                arch)
-                    log_info "  sudo pacman -S nodejs npm"
-                    ;;
-                *)
-                    log_info "  https://nodejs.org/en/download/"
-                    ;;
-            esac
-            ;;
-        macos)
-            log_info "  brew install node"
-            log_info "  Or: https://nodejs.org/en/download/"
-            ;;
-    esac
-    
-    HAS_NODE=false
-    # Don't exit - Node is optional
-}
-
-check_ripgrep() {
-    log_info "Checking ripgrep (optional, for faster file search)..."
-    
-    if command -v rg &> /dev/null; then
-        RG_VERSION=$(rg --version | head -1)
-        log_success "$RG_VERSION found"
-        HAS_RIPGREP=true
-        return 0
-    fi
-    
-    log_warn "ripgrep not found (file search will use grep fallback)"
-    
-    # Offer to install
-    echo ""
-    read -p "Would you like to install ripgrep? (faster search, recommended) [Y/n] " -n 1 -r
-    echo
-    
-    if [[ $REPLY =~ ^[Yy]$ ]] || [[ -z $REPLY ]]; then
-        log_info "Installing ripgrep..."
-        
-        # Check if we can use sudo
-        CAN_SUDO=false
-        if command -v sudo &> /dev/null; then
-            if sudo -n true 2>/dev/null || sudo -v 2>/dev/null; then
-                CAN_SUDO=true
-            fi
-        fi
-        
-        case "$OS" in
-            linux)
-                if [ "$CAN_SUDO" = true ]; then
-                    case "$DISTRO" in
-                        ubuntu|debian)
-                            if sudo apt install -y ripgrep 2>/dev/null; then
-                                log_success "ripgrep installed"
-                                HAS_RIPGREP=true
-                                return 0
-                            fi
-                            ;;
-                        fedora)
-                            if sudo dnf install -y ripgrep 2>/dev/null; then
-                                log_success "ripgrep installed"
-                                HAS_RIPGREP=true
-                                return 0
-                            fi
-                            ;;
-                        arch)
-                            if sudo pacman -S --noconfirm ripgrep 2>/dev/null; then
-                                log_success "ripgrep installed"
-                                HAS_RIPGREP=true
-                                return 0
-                            fi
-                            ;;
-                    esac
-                else
-                    log_warn "sudo not available - cannot auto-install system packages"
-                    if command -v cargo &> /dev/null; then
-                        log_info "Trying cargo install (no sudo required)..."
-                        if cargo install ripgrep 2>/dev/null; then
-                            log_success "ripgrep installed via cargo"
-                            HAS_RIPGREP=true
-                            return 0
-                        fi
-                    fi
-                fi
-                ;;
-            macos)
-                if command -v brew &> /dev/null; then
-                    if brew install ripgrep 2>/dev/null; then
-                        log_success "ripgrep installed"
-                        HAS_RIPGREP=true
-                        return 0
-                    fi
-                fi
-                ;;
-        esac
-        log_warn "Auto-install failed. You can install manually later:"
-    else
-        log_info "Skipping ripgrep installation. To install manually:"
-    fi
-    
-    # Show manual install instructions
-    case "$OS" in
-        linux)
-            case "$DISTRO" in
-                ubuntu|debian)
-                    log_info "  sudo apt install ripgrep"
-                    ;;
-                fedora)
-                    log_info "  sudo dnf install ripgrep"
-                    ;;
-                arch)
-                    log_info "  sudo pacman -S ripgrep"
-                    ;;
-                *)
-                    log_info "  https://github.com/BurntSushi/ripgrep#installation"
-                    ;;
-            esac
-            if command -v cargo &> /dev/null; then
-                log_info "  Or without sudo: cargo install ripgrep"
-            fi
-            ;;
-        macos)
-            log_info "  brew install ripgrep"
-            ;;
-    esac
-    
-    HAS_RIPGREP=false
-    # Don't exit - ripgrep is optional (grep fallback exists)
-}
-
-# ============================================================================
-# Installation
-# ============================================================================
-
-clone_repo() {
-    log_info "Installing to $INSTALL_DIR..."
-    
-    if [ -d "$INSTALL_DIR" ]; then
-        if [ -d "$INSTALL_DIR/.git" ]; then
-            log_info "Existing installation found, updating..."
-            cd "$INSTALL_DIR"
-            git fetch origin
-            git checkout "$BRANCH"
-            git pull origin "$BRANCH"
-        else
-            log_error "Directory exists but is not a git repository: $INSTALL_DIR"
-            log_info "Remove it or choose a different directory with --dir"
-            exit 1
-        fi
-    else
-        # Try SSH first (for private repo access), fall back to HTTPS
-        # Use --recurse-submodules to also clone mini-swe-agent and tinker-atropos
-        log_info "Trying SSH clone..."
-        if git clone --branch "$BRANCH" --recurse-submodules "$REPO_URL_SSH" "$INSTALL_DIR" 2>/dev/null; then
-            log_success "Cloned via SSH"
-        else
-            log_info "SSH failed, trying HTTPS..."
-            if git clone --branch "$BRANCH" --recurse-submodules "$REPO_URL_HTTPS" "$INSTALL_DIR"; then
-                log_success "Cloned via HTTPS"
-            else
-                log_error "Failed to clone repository"
-                log_info "For private repo access, ensure your SSH key is added to GitHub:"
-                log_info "  ssh-add ~/.ssh/id_rsa"
-                log_info "  ssh -T git@github.com  # Test connection"
-                exit 1
-            fi
-        fi
-    fi
-    
-    cd "$INSTALL_DIR"
-    
-    # Ensure submodules are initialized and updated (for existing installs or if --recurse failed)
-    log_info "Initializing submodules (mini-swe-agent, tinker-atropos)..."
-    git submodule update --init --recursive
-    log_success "Submodules ready"
-    
-    log_success "Repository ready"
-}
-
-setup_venv() {
-    if [ "$USE_VENV" = false ]; then
-        log_info "Skipping virtual environment (--no-venv)"
-        return 0
-    fi
-    
-    log_info "Creating virtual environment with Python $PYTHON_VERSION..."
-    
-    if [ -d "venv" ]; then
-        log_info "Virtual environment already exists, recreating..."
-        rm -rf venv
-    fi
-    
-    # uv creates the venv and pins the Python version in one step
-    $UV_CMD venv venv --python "$PYTHON_VERSION"
-    
-    log_success "Virtual environment ready (Python $PYTHON_VERSION)"
-}
-
-install_deps() {
-    log_info "Installing dependencies..."
-    
-    if [ "$USE_VENV" = true ]; then
-        # Tell uv to install into our venv (no need to activate)
-        export VIRTUAL_ENV="$INSTALL_DIR/venv"
-    fi
-    
-    # Install the main package in editable mode with all extras
-    $UV_CMD pip install -e ".[all]" || $UV_CMD pip install -e "."
-    
-    log_success "Main package installed"
-    
-    # Install submodules
-    log_info "Installing mini-swe-agent (terminal tool backend)..."
-    if [ -d "mini-swe-agent" ] && [ -f "mini-swe-agent/pyproject.toml" ]; then
-        $UV_CMD pip install -e "./mini-swe-agent" || log_warn "mini-swe-agent install failed (terminal tools may not work)"
-        log_success "mini-swe-agent installed"
-    else
-        log_warn "mini-swe-agent not found (run: git submodule update --init)"
-    fi
-    
-    log_info "Installing tinker-atropos (RL training backend)..."
-    if [ -d "tinker-atropos" ] && [ -f "tinker-atropos/pyproject.toml" ]; then
-        $UV_CMD pip install -e "./tinker-atropos" || log_warn "tinker-atropos install failed (RL tools may not work)"
-        log_success "tinker-atropos installed"
-    else
-        log_warn "tinker-atropos not found (run: git submodule update --init)"
-    fi
-    
-    log_success "All dependencies installed"
-}
-
-setup_path() {
-    log_info "Setting up hermes command..."
-    
-    if [ "$USE_VENV" = true ]; then
-        HERMES_BIN="$INSTALL_DIR/venv/bin/hermes"
-    else
-        HERMES_BIN="$(which hermes 2>/dev/null || echo "")"
-        if [ -z "$HERMES_BIN" ]; then
-            log_warn "hermes not found on PATH after install"
-            return 0
-        fi
-    fi
-    
-    # Create symlink in ~/.local/bin (standard user binary location, usually on PATH)
-    mkdir -p "$HOME/.local/bin"
-    ln -sf "$HERMES_BIN" "$HOME/.local/bin/hermes"
-    log_success "Symlinked hermes → ~/.local/bin/hermes"
-    
-    # Check if ~/.local/bin is on PATH; if not, add it to shell config
-    if ! echo "$PATH" | tr ':' '\n' | grep -q "^$HOME/.local/bin$"; then
-        SHELL_CONFIG=""
-        if [ -n "$BASH_VERSION" ]; then
-            if [ -f "$HOME/.bashrc" ]; then
-                SHELL_CONFIG="$HOME/.bashrc"
-            elif [ -f "$HOME/.bash_profile" ]; then
-                SHELL_CONFIG="$HOME/.bash_profile"
-            fi
-        elif [ -n "$ZSH_VERSION" ] || [ -f "$HOME/.zshrc" ]; then
-            SHELL_CONFIG="$HOME/.zshrc"
-        fi
-        
-        PATH_LINE='export PATH="$HOME/.local/bin:$PATH"'
-        
-        if [ -n "$SHELL_CONFIG" ]; then
-            if ! grep -q '\.local/bin' "$SHELL_CONFIG" 2>/dev/null; then
-                echo "" >> "$SHELL_CONFIG"
-                echo "# Hermes Agent — ensure ~/.local/bin is on PATH" >> "$SHELL_CONFIG"
-                echo "$PATH_LINE" >> "$SHELL_CONFIG"
-                log_success "Added ~/.local/bin to PATH in $SHELL_CONFIG"
-            else
-                log_info "~/.local/bin already referenced in $SHELL_CONFIG"
-            fi
-        fi
-    else
-        log_info "~/.local/bin already on PATH"
-    fi
-    
-    # Export for current session so hermes works immediately
-    export PATH="$HOME/.local/bin:$PATH"
-    
-    log_success "hermes command ready"
-}
-
-copy_config_templates() {
-    log_info "Setting up configuration files..."
-    
-    # Create ~/.hermes directory structure (config at top level, code in subdir)
-    mkdir -p "$HERMES_HOME/cron"
-    mkdir -p "$HERMES_HOME/sessions"
-    mkdir -p "$HERMES_HOME/logs"
-    
-    # Create .env at ~/.hermes/.env (top level, easy to find)
-    if [ ! -f "$HERMES_HOME/.env" ]; then
-        if [ -f "$INSTALL_DIR/.env.example" ]; then
-            cp "$INSTALL_DIR/.env.example" "$HERMES_HOME/.env"
-            log_success "Created ~/.hermes/.env from template"
-        else
-            touch "$HERMES_HOME/.env"
-            log_success "Created ~/.hermes/.env"
-        fi
-    else
-        log_info "~/.hermes/.env already exists, keeping it"
-    fi
-    
-    # Create config.yaml at ~/.hermes/config.yaml (top level, easy to find)
-    if [ ! -f "$HERMES_HOME/config.yaml" ]; then
-        if [ -f "$INSTALL_DIR/cli-config.yaml.example" ]; then
-            cp "$INSTALL_DIR/cli-config.yaml.example" "$HERMES_HOME/config.yaml"
-            log_success "Created ~/.hermes/config.yaml from template"
-        fi
-    else
-        log_info "~/.hermes/config.yaml already exists, keeping it"
-    fi
-    
-    log_success "Configuration directory ready: ~/.hermes/"
-}
-
-install_node_deps() {
-    if [ "$HAS_NODE" = false ]; then
-        log_info "Skipping Node.js dependencies (Node not installed)"
-        return 0
-    fi
-    
-    if [ -f "$INSTALL_DIR/package.json" ]; then
-        log_info "Installing Node.js dependencies..."
-        cd "$INSTALL_DIR"
-        npm install --silent 2>/dev/null || {
-            log_warn "npm install failed (browser tools may not work)"
-            return 0
-        }
-        log_success "Node.js dependencies installed"
-    fi
-}
-
-run_setup_wizard() {
-    if [ "$RUN_SETUP" = false ]; then
-        log_info "Skipping setup wizard (--skip-setup)"
-        return 0
-    fi
-    
-    echo ""
-    log_info "Starting setup wizard..."
-    echo ""
-    
-    cd "$INSTALL_DIR"
-    
-    # Run hermes setup using the venv Python directly (no activation needed)
-    if [ "$USE_VENV" = true ]; then
-        "$INSTALL_DIR/venv/bin/python" -m hermes_cli.main setup
-    else
-        python -m hermes_cli.main setup
-    fi
-}
-
-print_success() {
-    echo ""
-    echo -e "${GREEN}${BOLD}"
-    echo "┌─────────────────────────────────────────────────────────┐"
-    echo "│              ✓ Installation Complete!                   │"
-    echo "└─────────────────────────────────────────────────────────┘"
-    echo -e "${NC}"
-    echo ""
-    
-    # Show file locations
-    echo -e "${CYAN}${BOLD}📁 Your files (all in ~/.hermes/):${NC}"
-    echo ""
-    echo -e "   ${YELLOW}Config:${NC}    ~/.hermes/config.yaml"
-    echo -e "   ${YELLOW}API Keys:${NC}  ~/.hermes/.env"
-    echo -e "   ${YELLOW}Data:${NC}      ~/.hermes/cron/, sessions/, logs/"
-    echo -e "   ${YELLOW}Code:${NC}      ~/.hermes/hermes-agent/"
-    echo ""
-    
-    echo -e "${CYAN}─────────────────────────────────────────────────────────${NC}"
-    echo ""
-    echo -e "${CYAN}${BOLD}🚀 Commands:${NC}"
-    echo ""
-    echo -e "   ${GREEN}hermes${NC}              Start chatting"
-    echo -e "   ${GREEN}hermes setup${NC}        Configure API keys & settings"
-    echo -e "   ${GREEN}hermes config${NC}       View/edit configuration"
-    echo -e "   ${GREEN}hermes config edit${NC}  Open config in editor"
-    echo -e "   ${GREEN}hermes gateway${NC}      Run messaging gateway"
-    echo -e "   ${GREEN}hermes update${NC}       Update to latest version"
-    echo ""
-    
-    echo -e "${CYAN}─────────────────────────────────────────────────────────${NC}"
-    echo ""
-    echo -e "${YELLOW}⚡ Reload your shell to use 'hermes' command:${NC}"
-    echo ""
-    echo "   source ~/.bashrc   # or ~/.zshrc"
-    echo ""
-    
-    # Show Node.js warning if not installed
-    if [ "$HAS_NODE" = false ]; then
-        echo -e "${YELLOW}"
-        echo "Note: Node.js was not found. Browser automation tools"
-        echo "will have limited functionality. Install Node.js later"
-        echo "if you need full browser support."
-        echo -e "${NC}"
-    fi
-    
-    # Show ripgrep note if not installed
-    if [ "$HAS_RIPGREP" = false ]; then
-        echo -e "${YELLOW}"
-        echo "Note: ripgrep (rg) was not found. File search will use"
-        echo "grep as a fallback. For faster search in large codebases,"
-        echo "install ripgrep: sudo apt install ripgrep (or brew install ripgrep)"
-        echo -e "${NC}"
-    fi
-}
-
-# ============================================================================
-# Main
-# ============================================================================
-
-main() {
-    print_banner
-    
-    detect_os
-    install_uv
-    check_python
-    check_git
-    check_node
-    check_ripgrep
-    
-    clone_repo
-    setup_venv
-    install_deps
-    install_node_deps
-    setup_path
-    copy_config_templates
-    run_setup_wizard
-    
-    print_success
-}
-
-main

setup-hermes.sh

@@ -1,275 +0,0 @@
-#!/bin/bash
-# ============================================================================
-# Hermes Agent Setup Script
-# ============================================================================
-# Quick setup for developers who cloned the repo manually.
-# Uses uv for fast Python provisioning and package management.
-#
-# Usage:
-#   ./setup-hermes.sh
-#
-# This script:
-# 1. Installs uv if not present
-# 2. Creates a virtual environment with Python 3.11 via uv
-# 3. Installs all dependencies (main package + submodules)
-# 4. Creates .env from template (if not exists)
-# 5. Symlinks the 'hermes' CLI command into ~/.local/bin
-# 6. Runs the setup wizard (optional)
-# ============================================================================
-
-set -e
-
-# Colors
-GREEN='\033[0;32m'
-YELLOW='\033[0;33m'
-CYAN='\033[0;36m'
-RED='\033[0;31m'
-NC='\033[0m'
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$SCRIPT_DIR"
-
-PYTHON_VERSION="3.11"
-
-echo ""
-echo -e "${CYAN}🦋 Hermes Agent Setup${NC}"
-echo ""
-
-# ============================================================================
-# Install / locate uv
-# ============================================================================
-
-echo -e "${CYAN}→${NC} Checking for uv..."
-
-UV_CMD=""
-if command -v uv &> /dev/null; then
-    UV_CMD="uv"
-elif [ -x "$HOME/.local/bin/uv" ]; then
-    UV_CMD="$HOME/.local/bin/uv"
-elif [ -x "$HOME/.cargo/bin/uv" ]; then
-    UV_CMD="$HOME/.cargo/bin/uv"
-fi
-
-if [ -n "$UV_CMD" ]; then
-    UV_VERSION=$($UV_CMD --version 2>/dev/null)
-    echo -e "${GREEN}✓${NC} uv found ($UV_VERSION)"
-else
-    echo -e "${CYAN}→${NC} Installing uv..."
-    if curl -LsSf https://astral.sh/uv/install.sh | sh 2>/dev/null; then
-        if [ -x "$HOME/.local/bin/uv" ]; then
-            UV_CMD="$HOME/.local/bin/uv"
-        elif [ -x "$HOME/.cargo/bin/uv" ]; then
-            UV_CMD="$HOME/.cargo/bin/uv"
-        fi
-        
-        if [ -n "$UV_CMD" ]; then
-            UV_VERSION=$($UV_CMD --version 2>/dev/null)
-            echo -e "${GREEN}✓${NC} uv installed ($UV_VERSION)"
-        else
-            echo -e "${RED}✗${NC} uv installed but not found. Add ~/.local/bin to PATH and retry."
-            exit 1
-        fi
-    else
-        echo -e "${RED}✗${NC} Failed to install uv. Visit https://docs.astral.sh/uv/"
-        exit 1
-    fi
-fi
-
-# ============================================================================
-# Python check (uv can provision it automatically)
-# ============================================================================
-
-echo -e "${CYAN}→${NC} Checking Python $PYTHON_VERSION..."
-
-if $UV_CMD python find "$PYTHON_VERSION" &> /dev/null; then
-    PYTHON_PATH=$($UV_CMD python find "$PYTHON_VERSION")
-    PYTHON_FOUND_VERSION=$($PYTHON_PATH --version 2>/dev/null)
-    echo -e "${GREEN}✓${NC} $PYTHON_FOUND_VERSION found"
-else
-    echo -e "${CYAN}→${NC} Python $PYTHON_VERSION not found, installing via uv..."
-    $UV_CMD python install "$PYTHON_VERSION"
-    PYTHON_PATH=$($UV_CMD python find "$PYTHON_VERSION")
-    PYTHON_FOUND_VERSION=$($PYTHON_PATH --version 2>/dev/null)
-    echo -e "${GREEN}✓${NC} $PYTHON_FOUND_VERSION installed"
-fi
-
-# ============================================================================
-# Virtual environment
-# ============================================================================
-
-echo -e "${CYAN}→${NC} Setting up virtual environment..."
-
-if [ -d "venv" ]; then
-    echo -e "${CYAN}→${NC} Removing old venv..."
-    rm -rf venv
-fi
-
-$UV_CMD venv venv --python "$PYTHON_VERSION"
-echo -e "${GREEN}✓${NC} venv created (Python $PYTHON_VERSION)"
-
-# Tell uv to install into this venv (no activation needed for uv)
-export VIRTUAL_ENV="$SCRIPT_DIR/venv"
-
-# ============================================================================
-# Dependencies
-# ============================================================================
-
-echo -e "${CYAN}→${NC} Installing dependencies..."
-
-$UV_CMD pip install -e ".[all]" || $UV_CMD pip install -e "."
-
-echo -e "${GREEN}✓${NC} Dependencies installed"
-
-# ============================================================================
-# Submodules (terminal backend + RL training)
-# ============================================================================
-
-echo -e "${CYAN}→${NC} Installing submodules..."
-
-# mini-swe-agent (terminal tool backend)
-if [ -d "mini-swe-agent" ] && [ -f "mini-swe-agent/pyproject.toml" ]; then
-    $UV_CMD pip install -e "./mini-swe-agent" && \
-        echo -e "${GREEN}✓${NC} mini-swe-agent installed" || \
-        echo -e "${YELLOW}⚠${NC} mini-swe-agent install failed (terminal tools may not work)"
-else
-    echo -e "${YELLOW}⚠${NC} mini-swe-agent not found (run: git submodule update --init --recursive)"
-fi
-
-# tinker-atropos (RL training backend)
-if [ -d "tinker-atropos" ] && [ -f "tinker-atropos/pyproject.toml" ]; then
-    $UV_CMD pip install -e "./tinker-atropos" && \
-        echo -e "${GREEN}✓${NC} tinker-atropos installed" || \
-        echo -e "${YELLOW}⚠${NC} tinker-atropos install failed (RL tools may not work)"
-else
-    echo -e "${YELLOW}⚠${NC} tinker-atropos not found (run: git submodule update --init --recursive)"
-fi
-
-# ============================================================================
-# Optional: ripgrep (for faster file search)
-# ============================================================================
-
-echo -e "${CYAN}→${NC} Checking ripgrep (optional, for faster search)..."
-
-if command -v rg &> /dev/null; then
-    echo -e "${GREEN}✓${NC} ripgrep found"
-else
-    echo -e "${YELLOW}⚠${NC} ripgrep not found (file search will use grep fallback)"
-    read -p "Install ripgrep for faster search? [Y/n] " -n 1 -r
-    echo
-    if [[ $REPLY =~ ^[Yy]$ ]] || [[ -z $REPLY ]]; then
-        INSTALLED=false
-        
-        # Check if sudo is available
-        if command -v sudo &> /dev/null && sudo -n true 2>/dev/null; then
-            if command -v apt &> /dev/null; then
-                sudo apt install -y ripgrep && INSTALLED=true
-            elif command -v dnf &> /dev/null; then
-                sudo dnf install -y ripgrep && INSTALLED=true
-            fi
-        fi
-        
-        # Try brew (no sudo needed)
-        if [ "$INSTALLED" = false ] && command -v brew &> /dev/null; then
-            brew install ripgrep && INSTALLED=true
-        fi
-        
-        # Try cargo (no sudo needed)
-        if [ "$INSTALLED" = false ] && command -v cargo &> /dev/null; then
-            echo -e "${CYAN}→${NC} Trying cargo install (no sudo required)..."
-            cargo install ripgrep && INSTALLED=true
-        fi
-        
-        if [ "$INSTALLED" = true ]; then
-            echo -e "${GREEN}✓${NC} ripgrep installed"
-        else
-            echo -e "${YELLOW}⚠${NC} Auto-install failed. Install options:"
-            echo "    sudo apt install ripgrep     # Debian/Ubuntu"
-            echo "    brew install ripgrep         # macOS"
-            echo "    cargo install ripgrep        # With Rust (no sudo)"
-            echo "    https://github.com/BurntSushi/ripgrep#installation"
-        fi
-    fi
-fi
-
-# ============================================================================
-# Environment file
-# ============================================================================
-
-if [ ! -f ".env" ]; then
-    if [ -f ".env.example" ]; then
-        cp .env.example .env
-        echo -e "${GREEN}✓${NC} Created .env from template"
-    fi
-else
-    echo -e "${GREEN}✓${NC} .env exists"
-fi
-
-# ============================================================================
-# PATH setup — symlink hermes into ~/.local/bin
-# ============================================================================
-
-echo -e "${CYAN}→${NC} Setting up hermes command..."
-
-HERMES_BIN="$SCRIPT_DIR/venv/bin/hermes"
-mkdir -p "$HOME/.local/bin"
-ln -sf "$HERMES_BIN" "$HOME/.local/bin/hermes"
-echo -e "${GREEN}✓${NC} Symlinked hermes → ~/.local/bin/hermes"
-
-# Ensure ~/.local/bin is on PATH in shell config
-SHELL_CONFIG=""
-if [ -f "$HOME/.zshrc" ]; then
-    SHELL_CONFIG="$HOME/.zshrc"
-elif [ -f "$HOME/.bashrc" ]; then
-    SHELL_CONFIG="$HOME/.bashrc"
-elif [ -f "$HOME/.bash_profile" ]; then
-    SHELL_CONFIG="$HOME/.bash_profile"
-fi
-
-if [ -n "$SHELL_CONFIG" ]; then
-    if ! echo "$PATH" | tr ':' '\n' | grep -q "^$HOME/.local/bin$"; then
-        if ! grep -q '\.local/bin' "$SHELL_CONFIG" 2>/dev/null; then
-            echo "" >> "$SHELL_CONFIG"
-            echo "# Hermes Agent — ensure ~/.local/bin is on PATH" >> "$SHELL_CONFIG"
-            echo 'export PATH="$HOME/.local/bin:$PATH"' >> "$SHELL_CONFIG"
-            echo -e "${GREEN}✓${NC} Added ~/.local/bin to PATH in $SHELL_CONFIG"
-        else
-            echo -e "${GREEN}✓${NC} ~/.local/bin already in $SHELL_CONFIG"
-        fi
-    else
-        echo -e "${GREEN}✓${NC} ~/.local/bin already on PATH"
-    fi
-fi
-
-# ============================================================================
-# Done
-# ============================================================================
-
-echo ""
-echo -e "${GREEN}✓ Setup complete!${NC}"
-echo ""
-echo "Next steps:"
-echo ""
-echo "  1. Reload your shell:"
-echo "     source $SHELL_CONFIG"
-echo ""
-echo "  2. Run the setup wizard to configure API keys:"
-echo "     hermes setup"
-echo ""
-echo "  3. Start chatting:"
-echo "     hermes"
-echo ""
-echo "Other commands:"
-echo "  hermes status        # Check configuration"
-echo "  hermes gateway       # Start messaging gateway"
-echo "  hermes cron daemon   # Run cron daemon"
-echo "  hermes doctor        # Diagnose issues"
-echo ""
-
-# Ask if they want to run setup wizard now
-read -p "Would you like to run the setup wizard now? [Y/n] " -n 1 -r
-echo
-if [[ $REPLY =~ ^[Yy]$ ]] || [[ -z $REPLY ]]; then
-    echo ""
-    # Run directly with venv Python (no activation needed)
-    "$SCRIPT_DIR/venv/bin/python" -m hermes_cli.main setup
-fi