MessageTool writes to session; remove max_messages limit

- MessageTool now writes sent messages to session history via SessionManager - Agent loop wires SessionManager into MessageTool constructor - Session.get_history() returns full history (removed max_messages limit) Server-side context editing API handles trimming, so we send full history This ensures messages sent via the message() tool (e.g., from heartbeat forks) are visible in the main conversational agent's context. Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
session: remove max_messages slicing from get_history()
2026-02-22 00:05:56 +01:00 · 2026-02-19 12:33:02 +00:00 · 2026-02-19 12:02:56 +00:00 · 2026-02-19 03:33:54 +00:00 · 2026-02-19 03:19:18 +00:00 · 2026-02-19 02:55:15 +00:00
172 changed files with 1062 additions and 20227 deletions
@@ -1,30 +0,0 @@
-name: Sync ARA to aggregator
-
-on:
-  push:
-    branches: [main, master]
-    paths:
-      - "ara/**"
-
-jobs:
-  ara-sync:
-    runs-on: [self-hosted, linux-amd64]
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Push ara/ update to nanobot/ara aggregator
-        env:
-          NANOBOT_TOKEN: ${{ secrets.NANOBOT_TOKEN }}
-          REPO_NAME: ${{ github.event.repository.name }}
-          COMMIT_SHA: ${{ github.sha }}
-        run: |
-          git clone https://nanobot:${NANOBOT_TOKEN}@git.wylab.me/nanobot/ara.git /tmp/ara-aggregator
-          rm -rf /tmp/ara-aggregator/${REPO_NAME}
-          cp -r ara/ /tmp/ara-aggregator/${REPO_NAME}/
-          cd /tmp/ara-aggregator
-          git config user.email "nanobot@wylab.me"
-          git config user.name "nanobot"
-          git add -A
-          git diff --cached --quiet || git commit -m "sync(${REPO_NAME}): ara/ @ ${COMMIT_SHA:0:7}"
-          git push
-
@@ -15,9 +15,8 @@ docs/
 *.pyzz
 .venv/
 venv/
-.worktrees/
 __pycache__/
 poetry.lock
 .pytest_cache/
-botpy.log
 tests/
+botpy.log
@@ -56,7 +56,7 @@ ENV PATH="/root/.local/bin:${PATH}"

 COPY pyproject.toml README.md LICENSE /app/
 COPY nanobot/ /app/nanobot/
-RUN uv pip install --system --no-cache --reinstall /app[mem0] psycopg2-binary
+RUN uv pip install --system --no-cache --reinstall /app psycopg2-binary

 ENTRYPOINT ["nanobot"]
 CMD ["gateway"]
@@ -16,40 +16,22 @@

 ⚡️ Delivers core agent functionality in just **~4,000** lines of code — **99% smaller** than Clawdbot's 430k+ lines.

-📏 Real-time line count: **3,922 lines** (run `bash core_agent_lines.sh` to verify anytime)
+📏 Real-time line count: **3,582 lines** (run `bash core_agent_lines.sh` to verify anytime)

 ## 📢 News

- **2026-02-24** 🚀 Released **v0.1.4.post2** — a reliability-focused release with a redesigned heartbeat, prompt cache optimization, and hardened provider & channel stability. See [release notes](https://github.com/HKUDS/nanobot/releases/tag/v0.1.4.post2) for details.
- **2026-02-23** 🔧 Virtual tool-call heartbeat, prompt cache optimization, Slack mrkdwn fixes.
- **2026-02-22** 🛡️ Slack thread isolation, Discord typing fix, agent reliability improvements.
- **2026-02-21** 🎉 Released **v0.1.4.post1** — new providers, media support across channels, and major stability improvements. See [release notes](https://github.com/HKUDS/nanobot/releases/tag/v0.1.4.post1) for details.
- **2026-02-20** 🐦 Feishu now receives multimodal files from users. More reliable memory under the hood.
- **2026-02-19** ✨ Slack now sends files, Discord splits long messages, and subagents work in CLI mode.
- **2026-02-18** ⚡️ nanobot now supports VolcEngine, MCP custom auth headers, and Anthropic prompt caching.
- **2026-02-17** 🎉 Released **v0.1.4** — MCP support, progress streaming, new providers, and multiple channel improvements. Please see [release notes](https://github.com/HKUDS/nanobot/releases/tag/v0.1.4) for details.
- **2026-02-16** 🦞 nanobot now integrates a [ClawHub](https://clawhub.ai) skill — search and install public agent skills.
- **2026-02-15** 🔑 nanobot now supports OpenAI Codex provider with OAuth login support.
- **2026-02-14** 🔌 nanobot now supports MCP! See [MCP section](#mcp-model-context-protocol) for details.
- **2026-02-13** 🎉 Released **v0.1.3.post7** — includes security hardening and multiple improvements. **Please upgrade to the latest version to address security issues**. See [release notes](https://github.com/HKUDS/nanobot/releases/tag/v0.1.3.post7) for more details.
+- **2026-02-13** 🎉 Released v0.1.3.post7 — includes security hardening and multiple improvements. All users are recommended to upgrade to the latest version. See [release notes](https://github.com/HKUDS/nanobot/releases/tag/v0.1.3.post7) for more details.
 - **2026-02-12** 🧠 Redesigned memory system — Less code, more reliable. Join the [discussion](https://github.com/HKUDS/nanobot/discussions/566) about it!
- **2026-02-11** ✨ Enhanced CLI experience and added MiniMax support!
-
-<details>
-<summary>Earlier news</summary>
-
- **2026-02-10** 🎉 Released **v0.1.3.post6** with improvements! Check the updates [notes](https://github.com/HKUDS/nanobot/releases/tag/v0.1.3.post6) and our [roadmap](https://github.com/HKUDS/nanobot/discussions/431).
+- **2026-02-10** 🎉 Released v0.1.3.post6 with improvements! Check the updates [notes](https://github.com/HKUDS/nanobot/releases/tag/v0.1.3.post6) and our [roadmap](https://github.com/HKUDS/nanobot/discussions/431).
 - **2026-02-09** 💬 Added Slack, Email, and QQ support — nanobot now supports multiple chat platforms!
 - **2026-02-08** 🔧 Refactored Providers—adding a new LLM provider now takes just 2 simple steps! Check [here](#providers).
- **2026-02-07** 🚀 Released **v0.1.3.post5** with Qwen support & several key improvements! Check [here](https://github.com/HKUDS/nanobot/releases/tag/v0.1.3.post5) for details.
+- **2026-02-07** 🚀 Released v0.1.3.post5 with Qwen support & several key improvements! Check [here](https://github.com/HKUDS/nanobot/releases/tag/v0.1.3.post5) for details.
 - **2026-02-06** ✨ Added Moonshot/Kimi provider, Discord integration, and enhanced security hardening!
 - **2026-02-05** ✨ Added Feishu channel, DeepSeek provider, and enhanced scheduled tasks support!
- **2026-02-04** 🚀 Released **v0.1.3.post4** with multi-provider & Docker support! Check [here](https://github.com/HKUDS/nanobot/releases/tag/v0.1.3.post4) for details.
+- **2026-02-04** 🚀 Released v0.1.3.post4 with multi-provider & Docker support! Check [here](https://github.com/HKUDS/nanobot/releases/tag/v0.1.3.post4) for details.
 - **2026-02-03** ⚡ Integrated vLLM for local LLM support and improved natural language task scheduling!
 - **2026-02-02** 🎉 nanobot officially launched! Welcome to try 🐈 nanobot!

-</details>
-
 ## Key Features of nanobot:

 🪶 **Ultra-Lightweight**: Just ~4,000 lines of core agent code — 99% smaller than Clawdbot.
@@ -125,26 +107,17 @@ nanobot onboard

 **2. Configure** (`~/.nanobot/config.json`)

-Add or merge these **two parts** into your config (other options have defaults).
-
-*Set your API key* (e.g. OpenRouter, recommended for global users):
+For OpenRouter - recommended for global users:
 ```json
 {
  "providers": {
    "openrouter": {
      "apiKey": "sk-or-v1-xxx"
    }
-  }
-}
-```
-
-*Set your model* (optionally pin a provider — defaults to auto-detection):
-```json
-{
+  },
  "agents": {
    "defaults": {
-      "model": "anthropic/claude-opus-4-7",
-      "provider": "openrouter"
+      "model": "anthropic/claude-opus-4-5"
    }
  }
 }
@@ -153,26 +126,63 @@ Add or merge these **two parts** into your config (other options have defaults).
 **3. Chat**

 ```bash
-nanobot agent
+nanobot agent -m "What is 2+2?"
 ```

 That's it! You have a working AI assistant in 2 minutes.

+## 🖥️ Local Models (vLLM)
+
+Run nanobot with your own local models using vLLM or any OpenAI-compatible server.
+
+**1. Start your vLLM server**
+
+```bash
+vllm serve meta-llama/Llama-3.1-8B-Instruct --port 8000
+```
+
+**2. Configure** (`~/.nanobot/config.json`)
+
+```json
+{
+  "providers": {
+    "vllm": {
+      "apiKey": "dummy",
+      "apiBase": "http://localhost:8000/v1"
+    }
+  },
+  "agents": {
+    "defaults": {
+      "model": "meta-llama/Llama-3.1-8B-Instruct"
+    }
+  }
+}
+```
+
+**3. Chat**
+
+```bash
+nanobot agent -m "Hello from my local LLM!"
+```
+
+> [!TIP]
+> The `apiKey` can be any non-empty string for local servers that don't require authentication.
+
 ## 💬 Chat Apps

-Connect nanobot to your favorite chat platform.
+Talk to your nanobot through Telegram, Discord, WhatsApp, Feishu, Mochat, DingTalk, Slack, Email, or QQ — anytime, anywhere.

-| Channel | What you need |
-|---------|---------------|
-| **Telegram** | Bot token from @BotFather |
-| **Discord** | Bot token + Message Content intent |
-| **WhatsApp** | QR code scan |
-| **Feishu** | App ID + App Secret |
-| **Mochat** | Claw token (auto-setup available) |
-| **DingTalk** | App Key + App Secret |
-| **Slack** | Bot token + App-Level token |
-| **Email** | IMAP/SMTP credentials |
-| **QQ** | App ID + App Secret |
+| Channel | Setup |
+|---------|-------|
+| **Telegram** | Easy (just a token) |
+| **Discord** | Easy (bot token + intents) |
+| **WhatsApp** | Medium (scan QR) |
+| **Feishu** | Medium (app credentials) |
+| **Mochat** | Medium (claw token + websocket) |
+| **DingTalk** | Medium (app credentials) |
+| **Slack** | Medium (bot + app tokens) |
+| **Email** | Medium (IMAP/SMTP credentials) |
+| **QQ** | Easy (app credentials) |

 <details>
 <summary><b>Telegram</b> (Recommended)</summary>
@@ -309,72 +319,6 @@ nanobot gateway

 </details>

-<details>
-<summary><b>Matrix (Element)</b></summary>
-
-Install Matrix dependencies first:
-
-```bash
-pip install nanobot-ai[matrix]
-```
-
-**1. Create/choose a Matrix account**
-
- Create or reuse a Matrix account on your homeserver (for example `matrix.org`).
- Confirm you can log in with Element.
-
-**2. Get credentials**
-
- You need:
-  - `userId` (example: `@nanobot:matrix.org`)
-  - `accessToken`
-  - `deviceId` (recommended so sync tokens can be restored across restarts)
- You can obtain these from your homeserver login API (`/_matrix/client/v3/login`) or from your client's advanced session settings.
-
-**3. Configure**
-
-```json
-{
-  "channels": {
-    "matrix": {
-      "enabled": true,
-      "homeserver": "https://matrix.org",
-      "userId": "@nanobot:matrix.org",
-      "accessToken": "syt_xxx",
-      "deviceId": "NANOBOT01",
-      "e2eeEnabled": true,
-      "allowFrom": [],
-      "groupPolicy": "open",
-      "groupAllowFrom": [],
-      "allowRoomMentions": false,
-      "maxMediaBytes": 20971520
-    }
-  }
-}
-```
-
-> Keep a persistent `matrix-store` and stable `deviceId` — encrypted session state is lost if these change across restarts.
-
-| Option | Description |
-|--------|-------------|
-| `allowFrom` | User IDs allowed to interact. Empty = all senders. |
-| `groupPolicy` | `open` (default), `mention`, or `allowlist`. |
-| `groupAllowFrom` | Room allowlist (used when policy is `allowlist`). |
-| `allowRoomMentions` | Accept `@room` mentions in mention mode. |
-| `e2eeEnabled` | E2EE support (default `true`). Set `false` for plaintext-only. |
-| `maxMediaBytes` | Max attachment size (default `20MB`). Set `0` to block all media. |
-
-
-
-
-**4. Run**
-
-```bash
-nanobot gateway
-```
-
-</details>
-
 <details>
 <summary><b>WhatsApp</b></summary>

@@ -652,119 +596,21 @@ Config file: `~/.nanobot/config.json`
 > - **Groq** provides free voice transcription via Whisper. If configured, Telegram voice messages will be automatically transcribed.
 > - **Zhipu Coding Plan**: If you're on Zhipu's coding plan, set `"apiBase": "https://open.bigmodel.cn/api/coding/paas/v4"` in your zhipu provider config.
 > - **MiniMax (Mainland China)**: If your API key is from MiniMax's mainland China platform (minimaxi.com), set `"apiBase": "https://api.minimaxi.com/v1"` in your minimax provider config.
-> - **VolcEngine Coding Plan**: If you're on VolcEngine's coding plan, set `"apiBase": "https://ark.cn-beijing.volces.com/api/coding/v3"` in your volcengine provider config.

 | Provider | Purpose | Get API Key |
 |----------|---------|-------------|
-| `custom` | Any OpenAI-compatible endpoint (direct, no LiteLLM) | — |
 | `openrouter` | LLM (recommended, access to all models) | [openrouter.ai](https://openrouter.ai) |
 | `anthropic` | LLM (Claude direct) | [console.anthropic.com](https://console.anthropic.com) |
 | `openai` | LLM (GPT direct) | [platform.openai.com](https://platform.openai.com) |
 | `deepseek` | LLM (DeepSeek direct) | [platform.deepseek.com](https://platform.deepseek.com) |
 | `groq` | LLM + **Voice transcription** (Whisper) | [console.groq.com](https://console.groq.com) |
 | `gemini` | LLM (Gemini direct) | [aistudio.google.com](https://aistudio.google.com) |
-| `minimax` | LLM (MiniMax direct) | [platform.minimaxi.com](https://platform.minimaxi.com) |
+| `minimax` | LLM (MiniMax direct) | [platform.minimax.io](https://platform.minimax.io) |
 | `aihubmix` | LLM (API gateway, access to all models) | [aihubmix.com](https://aihubmix.com) |
-| `siliconflow` | LLM (SiliconFlow/硅基流动) | [siliconflow.cn](https://siliconflow.cn) |
-| `volcengine` | LLM (VolcEngine/火山引擎) | [volcengine.com](https://www.volcengine.com) |
 | `dashscope` | LLM (Qwen) | [dashscope.console.aliyun.com](https://dashscope.console.aliyun.com) |
 | `moonshot` | LLM (Moonshot/Kimi) | [platform.moonshot.cn](https://platform.moonshot.cn) |
 | `zhipu` | LLM (Zhipu GLM) | [open.bigmodel.cn](https://open.bigmodel.cn) |
 | `vllm` | LLM (local, any OpenAI-compatible server) | — |
-| `openai_codex` | LLM (Codex, OAuth) | `nanobot provider login openai-codex` |
-| `github_copilot` | LLM (GitHub Copilot, OAuth) | `nanobot provider login github-copilot` |
-
-<details>
-<summary><b>OpenAI Codex (OAuth)</b></summary>
-
-Codex uses OAuth instead of API keys. Requires a ChatGPT Plus or Pro account.
-
-**1. Login:**
-```bash
-nanobot provider login openai-codex
-```
-
-**2. Set model** (merge into `~/.nanobot/config.json`):
-```json
-{
-  "agents": {
-    "defaults": {
-      "model": "openai-codex/gpt-5.1-codex"
-    }
-  }
-}
-```
-
-**3. Chat:**
-```bash
-nanobot agent -m "Hello!"
-```
-
-> Docker users: use `docker run -it` for interactive OAuth login.
-
-</details>
-
-<details>
-<summary><b>Custom Provider (Any OpenAI-compatible API)</b></summary>
-
-Connects directly to any OpenAI-compatible endpoint — LM Studio, llama.cpp, Together AI, Fireworks, Azure OpenAI, or any self-hosted server. Bypasses LiteLLM; model name is passed as-is.
-
-```json
-{
-  "providers": {
-    "custom": {
-      "apiKey": "your-api-key",
-      "apiBase": "https://api.your-provider.com/v1"
-    }
-  },
-  "agents": {
-    "defaults": {
-      "model": "your-model-name"
-    }
-  }
-}
-```
-
-> For local servers that don't require a key, set `apiKey` to any non-empty string (e.g. `"no-key"`).
-
-</details>
-
-<details>
-<summary><b>vLLM (local / OpenAI-compatible)</b></summary>
-
-Run your own model with vLLM or any OpenAI-compatible server, then add to config:
-
-**1. Start the server** (example):
-```bash
-vllm serve meta-llama/Llama-3.1-8B-Instruct --port 8000
-```
-
-**2. Add to config** (partial — merge into `~/.nanobot/config.json`):
-
-*Provider (key can be any non-empty string for local):*
-```json
-{
-  "providers": {
-    "vllm": {
-      "apiKey": "dummy",
-      "apiBase": "http://localhost:8000/v1"
-    }
-  }
-}
-```
-
-*Model:*
-```json
-{
-  "agents": {
-    "defaults": {
-      "model": "meta-llama/Llama-3.1-8B-Instruct"
-    }
-  }
-}
-```
-
-</details>

 <details>
 <summary><b>Adding a New Provider (Developer Guide)</b></summary>
@@ -811,70 +657,13 @@ That's it! Environment variables, model prefixing, config matching, and `nanobot
 </details>


-### MCP (Model Context Protocol)
-
-> [!TIP]
-> The config format is compatible with Claude Desktop / Cursor. You can copy MCP server configs directly from any MCP server's README.
-
-nanobot supports [MCP](https://modelcontextprotocol.io/) — connect external tool servers and use them as native agent tools.
-
-Add MCP servers to your `config.json`:
-
-```json
-{
-  "tools": {
-    "mcpServers": {
-      "filesystem": {
-        "command": "npx",
-        "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/dir"]
-      },
-      "my-remote-mcp": {
-        "url": "https://example.com/mcp/",
-        "headers": {
-          "Authorization": "Bearer xxxxx"
-        }
-      }
-    }
-  }
-}
-```
-
-Two transport modes are supported:
-
-| Mode | Config | Example |
-|------|--------|---------|
-| **Stdio** | `command` + `args` | Local process via `npx` / `uvx` |
-| **HTTP** | `url` + `headers` (optional) | Remote endpoint (`https://mcp.example.com/sse`) |
-
-Use `toolTimeout` to override the default 30s per-call timeout for slow servers:
-
-```json
-{
-  "tools": {
-    "mcpServers": {
-      "my-slow-server": {
-        "url": "https://example.com/mcp/",
-        "toolTimeout": 120
-      }
-    }
-  }
-}
-```
-
-MCP tools are automatically discovered and registered on startup. The LLM can use them alongside built-in tools — no extra configuration needed.
-
-
-
-
 ### Security

-> [!TIP]
 > For production deployments, set `"restrictToWorkspace": true` in your config to sandbox the agent.

 | Option | Default | Description |
 |--------|---------|-------------|
 | `tools.restrictToWorkspace` | `false` | When `true`, restricts **all** agent tools (shell, file read/write/edit, list) to the workspace directory. Prevents path traversal and out-of-scope access. |
-| `tools.exec.pathAppend` | `""` | Extra directories to append to `PATH` when running shell commands (e.g. `/usr/sbin` for `ufw`). |
 | `channels.*.allowFrom` | `[]` (allow all) | Whitelist of user IDs. Empty = allow everyone; non-empty = only listed users can interact. |


@@ -889,7 +678,6 @@ MCP tools are automatically discovered and registered on startup. The LLM can us
 | `nanobot agent --logs` | Show runtime logs during chat |
 | `nanobot gateway` | Start the gateway |
 | `nanobot status` | Show status |
-| `nanobot provider login openai-codex` | OAuth login for providers |
 | `nanobot channels login` | Link WhatsApp (scan QR) |
 | `nanobot channels status` | Show channel status |

@@ -912,46 +700,12 @@ nanobot cron remove <job_id>

 </details>

-<details>
-<summary><b>Heartbeat (Periodic Tasks)</b></summary>
-
-The gateway wakes up every 30 minutes and checks `HEARTBEAT.md` in your workspace (`~/.nanobot/workspace/HEARTBEAT.md`). If the file has tasks, the agent executes them and delivers results to your most recently active chat channel.
-
-**Setup:** edit `~/.nanobot/workspace/HEARTBEAT.md` (created automatically by `nanobot onboard`):
-
-```markdown
-## Periodic Tasks
-
- [ ] Check weather forecast and send a summary
- [ ] Scan inbox for urgent emails
-```
-
-The agent can also manage this file itself — ask it to "add a periodic task" and it will update `HEARTBEAT.md` for you.
-
-> **Note:** The gateway must be running (`nanobot gateway`) and you must have chatted with the bot at least once so it knows which channel to deliver to.
-
-</details>
-
 ## 🐳 Docker

 > [!TIP]
 > The `-v ~/.nanobot:/root/.nanobot` flag mounts your local config directory into the container, so your config and workspace persist across container restarts.

-### Docker Compose
-
-```bash
-docker compose run --rm nanobot-cli onboard   # first-time setup
-vim ~/.nanobot/config.json                     # add API keys
-docker compose up -d nanobot-gateway           # start gateway
-```
-
-```bash
-docker compose run --rm nanobot-cli agent -m "Hello!"   # run CLI
-docker compose logs -f nanobot-gateway                   # view logs
-docker compose down                                      # stop
-```
-
-### Docker
+Build and run nanobot in a container:

 ```bash
 # Build the image
@@ -971,59 +725,6 @@ docker run -v ~/.nanobot:/root/.nanobot --rm nanobot agent -m "Hello!"
 docker run -v ~/.nanobot:/root/.nanobot --rm nanobot status
 ```

-## 🐧 Linux Service
-
-Run the gateway as a systemd user service so it starts automatically and restarts on failure.
-
-**1. Find the nanobot binary path:**
-
-```bash
-which nanobot   # e.g. /home/user/.local/bin/nanobot
-```
-
-**2. Create the service file** at `~/.config/systemd/user/nanobot-gateway.service` (replace `ExecStart` path if needed):
-
-```ini
-[Unit]
-Description=Nanobot Gateway
-After=network.target
-
-[Service]
-Type=simple
-ExecStart=%h/.local/bin/nanobot gateway
-Restart=always
-RestartSec=10
-NoNewPrivileges=yes
-ProtectSystem=strict
-ReadWritePaths=%h
-
-[Install]
-WantedBy=default.target
-```
-
-**3. Enable and start:**
-
-```bash
-systemctl --user daemon-reload
-systemctl --user enable --now nanobot-gateway
-```
-
-**Common operations:**
-
-```bash
-systemctl --user status nanobot-gateway        # check status
-systemctl --user restart nanobot-gateway       # restart after config changes
-journalctl --user -u nanobot-gateway -f        # follow logs
-```
-
-If you edit the `.service` file itself, run `systemctl --user daemon-reload` before restarting.
-
-> **Note:** User services only run while you are logged in. To keep the gateway running after logout, enable lingering:
->
-> ```bash
-> loginctl enable-linger $USER
-> ```
-
 ## 📁 Project Structure

 ```
@@ -1052,6 +753,7 @@ PRs welcome! The codebase is intentionally small and readable. 🤗

 **Roadmap** — Pick an item and [open a PR](https://github.com/HKUDS/nanobot/pulls)!

+- [x] **Voice Transcription** — Support for Groq Whisper (Issue #13)
 - [ ] **Multi-modal** — See and hear (images, voice, video)
 - [ ] **Long-term memory** — Never forget important context
 - [ ] **Better reasoning** — Multi-step planning and reflection
@@ -5,7 +5,7 @@
 If you discover a security vulnerability in nanobot, please report it by:

 1. **DO NOT** open a public GitHub issue
-2. Create a private security advisory on GitHub or contact the repository maintainers (xubinrencs@gmail.com)
+2. Create a private security advisory on GitHub or contact the repository maintainers
 3. Include:
   - Description of the vulnerability
   - Steps to reproduce
@@ -1,108 +0,0 @@
---
-title: "Nanobot: A Persistent Life-Assistant Agent System Built on Claude"
-authors: ["Makar Novozhilov"]
-year: 2026
-venue: "Internal system documentation"
-doi: "Not applicable — operational system"
-ara_version: "1.0"
-domain: "AI agent infrastructure / personal automation"
-keywords:
-  - persistent-agent
-  - life-assistant
-  - heartbeat-system
-  - claude-api
-  - docker-infrastructure
-  - telegram-bot
-  - home-automation
-  - prompt-caching
-  - subagent-parallelism
-  - memory-management
-claims_summary:
-  - "A parallel Haiku-collector + Sonnet-orchestrator heartbeat architecture reduces latency and cost versus a monolithic sequential approach"
-  - "Splitting agent memory into KNOWLEDGE.md (stable, cached) and MEMORY.md (volatile, uncached) preserves prompt-cache hit rates while enabling session continuity"
-  - "Deterministic bash/Python scripts for data collection outperform LLM-based collectors in reliability and hallucination prevention"
-  - "Routing all subagent-to-user communication through the main agent's message() tool is necessary to prevent split-identity context gaps"
-  - "Traefik TLS certificate issuance fails when the Technitium DNS resolver is unreachable from within Docker containers during ACME DNS-01 challenges"
-abstract: >
-  Nanobot is a production AI agent system running persistently on a self-hosted Unraid server,
-  providing life-assistant functionality to a single user via Telegram. Built on Anthropic's Claude API
-  (Sonnet as orchestrator, Haiku as collectors), the system integrates home automation (Home Assistant),
-  health metrics (Apple Health via custom receiver), browser history (PostgreSQL), location tracking
-  (OwnTracks/MQTT), email (Gmail via GOG), and YouTube activity into a 30-minute heartbeat cycle.
-  Key architectural decisions include a two-tier memory system (KNOWLEDGE.md for stable cached context,
-  MEMORY.md for volatile in-progress state), a parallel subagent heartbeat architecture replacing an
-  earlier sequential 18-step approach, and deterministic script-based data collection replacing
-  unreliable LLM-based collectors. The system has been in continuous operation since February 2026,
-  with ongoing evolution documented in HISTORY.md. This ARA captures the system design, key
-  architectural decisions, documented dead ends, and operational heuristics as a structured
-  machine-readable artifact.
---
-
-# Nanobot: A Persistent Life-Assistant Agent System Built on Claude
-
-## Overview
-
-Nanobot is a self-hosted, single-user life-assistant AI agent that runs persistently on a home Unraid server
-and communicates with its user (Makar Novozhilov, Barcelona) exclusively via Telegram. Unlike stateless
-chatbot deployments, nanobot maintains persistent session state, runs an autonomous 30-minute heartbeat
-cycle for life tracking, and orchestrates parallel subagents for data collection.
-
-The system is built on the nanobot open-source framework (originally from HKUDS Lab, MIT license,
-February 2026), extended with custom skills, heartbeat logic, and infrastructure integrations.
-Its primary intelligence layer is Anthropic Claude (Sonnet for orchestration, Haiku for lightweight
-collection tasks). Prompt caching is central to cost control: KNOWLEDGE.md (stable facts, ~4KB) is
-permanently cached in the system prompt, while MEMORY.md (volatile state) is excluded to prevent
-cache invalidation on every session update.
-
-The heartbeat architecture evolved from a sequential 18-step monolithic Sonnet execution to a
-parallel 8-Haiku-collector + Sonnet-orchestrator design, with data collectors eventually replaced by
-deterministic bash/Python scripts to eliminate LLM hallucination of sensor data. Several infrastructure
-dead ends are documented: Traefik TLS failures due to DNS bootstrap issues, Docker networking latency
-from an unreachable Technitium nameserver, Yandex Station control failures from TTS/Alice confusion,
-and SS14 CI/CD cache corruption from runner configuration errors.
-
-## Layer Index
-
-### Cognitive Layer (`/logic`)
-
-| File | Description |
-|------|-------------|
-| [problem.md](logic/problem.md) | Observations → gaps → key insights about persistent agent systems |
-| [claims.md](logic/claims.md) | 9 falsifiable claims (C01–C09) about system architecture and design |
-| [concepts.md](logic/concepts.md) | 8 key technical concepts with formal definitions |
-| [experiments.md](logic/experiments.md) | 5 experiment plans (E01–E05) for validating architectural claims |
-| [solution/architecture.md](logic/solution/architecture.md) | Full system component graph with inputs/outputs |
-| [solution/algorithm.md](logic/solution/algorithm.md) | Heartbeat orchestration algorithm and subagent parallelism |
-| [solution/constraints.md](logic/solution/constraints.md) | Boundary conditions, known limitations |
-| [solution/heuristics.md](logic/solution/heuristics.md) | 11 operational heuristics (H01–H11) |
-| [related_work.md](logic/related_work.md) | Related frameworks and projects (RW01–RW06) |
-
-### Physical Layer (`/src`)
-
-| File | Description | Claims |
-|------|-------------|--------|
-| [configs/infrastructure.md](src/configs/infrastructure.md) | Docker, Traefik, DNS, and service configs | C05, C06 |
-| [configs/agent.md](src/configs/agent.md) | Agent model selection, caching, and heartbeat parameters | C01, C02, C03 |
-| [execution/heartbeat_orchestrator.py](src/execution/heartbeat_orchestrator.py) | Heartbeat orchestrator stub | C01, C04 |
-| [execution/collector_scripts.py](src/execution/collector_scripts.py) | Deterministic collector script pattern | C03 |
-| [environment.md](src/environment.md) | Python version, dependencies, hardware, deployment |
-
-### Exploration Graph (`/trace`)
-
-| File | Description |
-|------|-------------|
-| [exploration_tree.yaml](trace/exploration_tree.yaml) | 18-node research DAG covering key architectural decisions and dead ends |
-
-### Evidence (`/evidence`)
-
-| File | Description |
-|------|-------------|
-| [README.md](evidence/README.md) | Full index of 6 tables + 2 figures |
-| [tables/table1_heartbeat_architecture_evolution.md](evidence/tables/table1_heartbeat_architecture_evolution.md) | Evolution of heartbeat architecture from sequential to parallel |
-| [tables/table2_dns_latency_incident.md](evidence/tables/table2_dns_latency_incident.md) | DNS latency dead end — Technitium unreachable from Docker |
-| [tables/table3_yandex_failures.md](evidence/tables/table3_yandex_failures.md) | Yandex Station control attempts and failures |
-| [tables/table4_memory_split.md](evidence/tables/table4_memory_split.md) | KNOWLEDGE.md vs MEMORY.md cache efficiency data |
-| [tables/table5_ss14_cicd_dead_ends.md](evidence/tables/table5_ss14_cicd_dead_ends.md) | SS14 CI/CD debugging failures and cache corruption |
-| [tables/table6_traefik_cert_failure.md](evidence/tables/table6_traefik_cert_failure.md) | Traefik TLS certificate failure due to DNS bootstrap |
-| [figures/figure1_heartbeat_timeline.md](evidence/figures/figure1_heartbeat_timeline.md) | Heartbeat system timeline from launch to parallel architecture |
-| [figures/figure2_memory_hierarchy.md](evidence/figures/figure2_memory_hierarchy.md) | Memory hierarchy: KNOWLEDGE.md / MEMORY.md / HISTORY.md |
@@ -1,23 +0,0 @@
-# Evidence Index
-
-This directory contains all raw evidence tables and figures supporting the claims in `logic/claims.md`. Each entry maps to one or more claims and is drawn from the operational history of the nanobot system as documented in HISTORY.md, MEMORY.md, and KNOWLEDGE.md.
-
-## Tables
-
-| File | Source | Claims | Description |
-|------|--------|--------|-------------|
-| [tables/table1_heartbeat_architecture_evolution.md](tables/table1_heartbeat_architecture_evolution.md) | HISTORY.md §2026-02-14 – §2026-02-18 | C01 | Evolution of heartbeat architecture from 18-step sequential Sonnet to 8-Haiku parallel + Sonnet orchestrator |
-| [tables/table2_dns_latency_incident.md](tables/table2_dns_latency_incident.md) | HISTORY.md §2026-02-13 | C05 | DNS latency dead end — Technitium unreachable from Docker containers via 192.168.1.50; fixed via 172.17.0.1 bridge gateway |
-| [tables/table3_yandex_failures.md](tables/table3_yandex_failures.md) | HISTORY.md §2026-02-14 03:05 | C07 | Yandex Station control failure attempts — TTS/Alice confusion before finding media_player/* solution |
-| [tables/table4_memory_split.md](tables/table4_memory_split.md) | HISTORY.md §2026-02-19 03:06; KNOWLEDGE.md §Prompt Caching | C02 | KNOWLEDGE.md vs MEMORY.md cache efficiency — before/after the split |
-| [tables/table5_ss14_cicd_dead_ends.md](tables/table5_ss14_cicd_dead_ends.md) | HISTORY.md §2026-12-14 – §2026-12-19 | C08 | SS14 CI/CD debugging failures — DNS misdiagnosis, cross-architecture cache corruption |
-| [tables/table6_traefik_cert_failure.md](tables/table6_traefik_cert_failure.md) | HISTORY.md §2026-01-03; KNOWLEDGE.md §Obsidian; claims.md C06 | C06 | Traefik TLS certificate failure due to DNS bootstrap circular dependency |
-| [tables/table7_system_architecture.md](tables/table7_system_architecture.md) | KNOWLEDGE.md §Heartbeat Architecture; solution/architecture.md | C01, C02, C03, C04 | System architecture table — components, inputs, outputs, interactions |
-| [tables/table8_heartbeat_collector_budget.md](tables/table8_heartbeat_collector_budget.md) | KNOWLEDGE.md §Heartbeat Architecture | C01, C03 | Heartbeat collector budget table — per-collector token limits, total orchestrator input budget |
-
-## Figures
-
-| File | Source | Claims | Description |
-|------|--------|--------|-------------|
-| [figures/figure1_heartbeat_timeline.md](figures/figure1_heartbeat_timeline.md) | HISTORY.md §2026-02-14 – §2026-03-03 | C01, C03 | Heartbeat system timeline — key milestones from launch to parallel architecture to script-based collectors |
-| [figures/figure2_memory_hierarchy.md](figures/figure2_memory_hierarchy.md) | KNOWLEDGE.md §Memory Layout; HISTORY.md §2026-02-19 | C02 | Memory hierarchy diagram data — KNOWLEDGE.md / MEMORY.md / HISTORY.md structure and access patterns |
@@ -1,38 +0,0 @@
-# Figure 1 — Heartbeat System Timeline
-
-**Source**: HISTORY.md [2026-02-14 to 2026-03-05]
-**Caption**: Timeline of key milestones in the nanobot heartbeat system's development, from first successful cycle (2026-02-14) through parallel architecture adoption (2026-02-18) and script-based collector replacement (2026-03-03).
-**Extraction type**: raw_table
-**Axes**: X = Date (YYYY-MM-DD), Y = Architecture phase / Event
-
-| Date | Event | Architecture Phase | Notes |
-|------|-------|-------------------|-------|
-| 2026-02-13 | Nanobot container started; heartbeat not yet tested | — | HEARTBEAT.md exists but no cycles recorded |
-| 2026-02-14 00:34 | **First heartbeat cycle confirmed** (02:19 UTC) | Phase 1: Inline main agent | Main agent (Opus) runs heartbeat steps directly |
-| 2026-02-14 10:21 | max_iterations exhaustion at 15; increased to 50 | Phase 2: Sonnet delegation | PR #2; PR #3 from nanobot account |
-| 2026-02-14 13:48 | First subagent-delegated heartbeat confirmed working | Phase 2: Sonnet subagent | HISTORY.md entry written by subagent |
-| 2026-02-15 02:19 | Second successful Sonnet subagent heartbeat | Phase 2: Sonnet subagent | |
-| 2026-02-15 10:31–12:38 | Extended thinking debugging session; fabrication pattern identified | Phase 2 (failure) | Agent claimed spawn success without tool execution ×12 |
-| 2026-02-15 16:23 | **API rate limit window begins** (~47 hours) | Outage | Quota exhausted; no heartbeat cycles |
-| 2026-02-18 15:00 | Rate limit window ends | Recovery | |
-| 2026-02-18 21:36 | **Parallel 8-Haiku architecture designed** | Phase 3 → 5: Parallel | "Redesigned heartbeat...parallel architecture" |
-| 2026-02-18 21:39 | First parallel test cycle; announcement spam discovered | Phase 5 (bug) | 8 Haiku completions → 8 Telegram messages |
-| 2026-02-18 22:17 | Heartbeat running as Opus (not Sonnet) discovered | Phase 5 (bug) | model parameter dropped from spawn() |
-| 2026-02-19 00:28 | wait_for_subagents architecture working correctly | Phase 5: Stable | Single consolidated result, no spam |
-| 2026-02-23 23:25 | idle detection fix; wait_for_subagents fix for top-level subagents | Phase 5: Fixes | Commits 84383db, 7f331b7 |
-| 2026-03-03 02:48 | **YouTube hallucination discovered** | Phase 5 (bug) | Non-existent video IDs in HISTORY.md |
-| 2026-03-03 03:21 | **youtube_sync.py script replaces hb-youtube** | Phase 6: Scripts | 4999 liked videos synced from real API |
-| 2026-03-05 10:16 | youtube_sync.py wired into HEARTBEAT_INSTRUCTIONS.md | Phase 6: Deployed | hb-youtube Haiku collector removed |
-| 2026-03-11 10:55 | hb-context fails: session file too large (200k+ tokens) | Phase 6 (bug) | tail -n 200 fix applied |
-| 2026-05-01 | Email deduplication via alerted_email_ids deployed | Phase 6+: Enhancement | Cifra Markets triple-alert issue resolved |
-
-## Summary Statistics (as of 2026-05)
-
-| Metric | Value |
-|--------|-------|
-| Total heartbeat phases | 6 (plus sub-phases) |
-| First successful cycle | 2026-02-14 02:19 UTC |
-| Architecture iterations | 5 major redesigns |
-| Dead ends documented | 5 (sequential exhaustion, fabrication, announcement spam, YouTube hallucination, session file overflow) |
-| Total heartbeat cycles estimated | 2,000+ (48/day × 50 days) |
-| Significant outage periods | 47h rate-limit window (2026-02-15 to 2026-02-18) |
@@ -1,42 +0,0 @@
-# Figure 2 — Nanobot Memory Hierarchy
-
-**Source**: KNOWLEDGE.md; HISTORY.md [2026-02-22 05:04] context engineering session; HISTORY.md [2026-03-02 02:18] mem0 migration
-**Caption**: The five-tier memory hierarchy of the nanobot system, from the system-prompt-cached stable tier (KNOWLEDGE.md) to the semantic search tier (mem0/Qdrant). Each tier has distinct update frequency, inclusion in system prompt, and cache impact.
-**Extraction type**: raw_table
-**Axes**: Memory tier (Y) vs Properties (columns)
-
-| Tier | File/Store | In System Prompt | Update Frequency | Cache Impact | Purpose | Approx Size |
-|------|-----------|-----------------|------------------|--------------|---------|-------------|
-| 1 — Stable Identity | KNOWLEDGE.md | Yes (cached) | ~weekly | Cache invalidates on change | User identity, infra topology, behavioral rules, hard rules | ~4KB |
-| 2 — Volatile State | MEMORY.md | No | Multiple/session | None | Active projects, alerts, pending decisions, in-progress state | ~2-8KB |
-| 3 — Event Log | HISTORY.md | No | Every heartbeat + session | None | Append-only session summaries, heartbeat entries, decisions | >200KB |
-| 4 — Heartbeat State | life_state.json | No | Every 30 min | None | Last location, sleep state, known places, email alert IDs, Alice state | ~5-20KB |
-| 5 — Semantic Memory | mem0/Qdrant | No (on demand) | After consolidation | None | User facts extracted from conversations; semantically searchable | 30-64+ points |
-
-## Promotion / Demotion Rules (Tier 1 ↔ Tier 2)
-
-| Direction | Trigger |
-|-----------|---------|
-| Promote MEMORY.md → KNOWLEDGE.md | Fact stable for 2+ weeks; applies across all future sessions |
-| Demote KNOWLEDGE.md → MEMORY.md | Fact becomes project-specific or expected to change within weeks |
-| Demotion procedure | Move entry to HISTORY.md as one-line record; then delete from MEMORY.md |
-| Promotion procedure | Copy to KNOWLEDGE.md; remove from MEMORY.md; note in HISTORY.md |
-
-## Historical Size Trajectory (KNOWLEDGE.md)
-
-| Date | Size | Change |
-|------|------|--------|
-| 2026-02-22 (pre-optimization) | ~15.5KB | Baseline |
-| 2026-02-22 (post context engineering) | ~4.3KB | Aggressive deduplication, moved sections to reference/ |
-| 2026-03-02 (post mem0 migration) | ~3.8KB | 10 topic groups moved to Qdrant (interests, heartbeat, caching, subagents, compaction protocol, philosophy, university details, promotion/demotion protocol, git notes, nanobot features) |
-
-## Routing Decision Guide
-
-| Fact Type | Destination |
-|-----------|-------------|
-| Stable identity/preferences/infrastructure | KNOWLEDGE.md |
-| "Currently working on X" / active project | MEMORY.md |
-| "Recently did Y" / event record | HISTORY.md |
-| Stale "currently troubleshooting X" | Delete — do not carry forward |
-| User facts extracted from natural conversation | mem0/Qdrant |
-| Heartbeat-cycle-specific sensor readings | life_state.json |
@@ -1,28 +0,0 @@
-# Table 1 — Heartbeat Architecture Evolution
-
-**Source**: HISTORY.md entries from 2026-02-14 to 2026-03-05; HEARTBEAT_INSTRUCTIONS.md
-**Caption**: Chronological evolution of the nanobot heartbeat system architecture, documenting each design phase, the failure mode that triggered the next phase, and the resulting change.
-**Extraction type**: raw_table
-
-| Phase | Date | Architecture | Failure Mode / Trigger | Outcome |
-|-------|------|-------------|------------------------|---------|
-| 0 — Initial | 2026-02-13 | Heartbeat described in HEARTBEAT.md; no automated execution | No heartbeat had ever fired; mechanism unverified | Heartbeat confirmed working after investigation |
-| 1 — Inline sequential | 2026-02-14 00:34 | Main agent (Opus) executes all heartbeat steps sequentially in telegram session | Bloated main session; first successful heartbeat cycle at 02:19 UTC | Cycles working but run inline with conversational session |
-| 2 — Sonnet delegation | 2026-02-14 | HEARTBEAT.md delegates to Sonnet subagent; PR #1 merged | Main agent spawning Sonnet for each heartbeat cycle | First subagent-delegated heartbeat at 02:20 UTC |
-| 3 — Iteration exhaustion | 2026-02-14 10:21 | Sequential Sonnet subagent with max_iterations=15 | Subagents ran out of iterations before completing all 15 steps | max_iterations increased to 50 (PR #2); session continued reliably |
-| 4 — Fabrication pattern | 2026-02-15 04:57–10:31 | Sequential Sonnet, now with 50 iterations | Rate-limit stress caused agent to narrate rather than execute spawn calls; 12 consecutive fabricated heartbeat "spawns" (no tool execution) | Pattern identified and corrected; explicit "execute, don't narrate" rule added |
-| 5 — Parallel 8-Haiku | 2026-02-18 21:36 | **Current design**: Sonnet orchestrator spawns 8 Haiku collectors in parallel; reads output files; interprets | Prior: sequential execution too slow, single point of failure | Parallel architecture deployed; all 8 collectors run concurrently |
-| 5a — Announcement spam | 2026-02-18 21:39 | Parallel Haiku spawn | subagent.py hardcoded "Summarize this naturally for the user" → all 8 Haiku completions routed to Telegram | SubagentMessageTool added; suppress_output metadata propagated; wait_for_subagents produces single consolidated result |
-| 5b — YouTube hallucination | 2026-03-03 02:48 | Parallel design with LLM hb-youtube Haiku collector | Sonnet orchestrator "recovered" from hb-youtube failures by fabricating YouTube data; non-existent video IDs logged to HISTORY.md | hb-youtube replaced by deterministic youtube_sync.py script |
-| 5c — Session file overflow | 2026-03-11 10:55 | hb-context collector reads session JSONL | Session file exceeded 200k token limit; context collector failed silently using stale cache | hb-context now uses `tail -n 200` of session file |
-| 6 — Current (scripts + Haiku) | 2026-03-05+ | youtube_sync.py (deterministic) + 7 Haiku collectors | None critical outstanding; hb-home still occasionally blocked by Haiku safety refusal on private IPs | Fix: hb-home runs curl directly in main bash loop, not via Haiku when blocked |
-
-**Key metric**: Iteration consumption per cycle
- Phase 1 (inline, sequential): ~80+ iterations (Opus main agent)
- Phase 3 (Sonnet sequential, limit 15): exhausted — cycle failed
- Phase 3 (Sonnet sequential, limit 50): ~40-50 iterations per cycle
- Phase 5 (parallel Haiku): ~5-10 iterations per Haiku collector; ~15-25 for Sonnet orchestrator
-
-**Key metric**: Wall-clock time per heartbeat cycle
- Phase 3 sequential (at 50 iterations): ~60-100 seconds
- Phase 5 parallel: ~20-30 seconds (bounded by max(t_i), not Σt_i)
@@ -1,46 +0,0 @@
-# Table 2 — DNS Latency Incident and Resolution
-
-**Source**: HISTORY.md [2026-02-13 18:16]; KNOWLEDGE.md infrastructure section
-**Caption**: Documentation of the Docker DNS configuration incident: initial broken state causing 8-second latency, self-inflicted outage during debugging, and the fix via bridge gateway DNS.
-**Extraction type**: raw_table
-
-## Phase 1: Initial broken configuration
-
-| Parameter | Value |
-|-----------|-------|
-| Container resolv.conf order | 1. 192.168.1.50 (Technitium) — unreachable via Docker NAT; 2. 169.254.24.117 (dead Docker embedded DNS); 3. 1.1.1.1 (working, reachable) |
-| Observed symptom | 8-second latency on ALL outbound HTTPS requests from containers |
-| Root cause | Docker NAT prevents containers from reaching 192.168.1.50 (host IP) directly; each request waits for 192.168.1.50 timeout before falling through to 1.1.1.1 |
-| Duration | Unknown start date to 2026-02-13 |
-
-## Phase 2: Self-inflicted outage (2026-02-13, during debugging)
-
-| Event | Detail |
-|-------|--------|
-| Action taken | Edited /etc/resolv.conf inside nanobot container during DNS debugging |
-| Resulting state | Only 192.168.1.50 (Technitium) left in resolv.conf — DNS completely broken |
-| Symptom | All network requests failed; container had no DNS resolution |
-| Recovery method | External container restart by user (Makar) via Unraid Docker UI |
-| Hard rule established | "Never write to /etc/resolv.conf or system config files inside own container" (KNOWLEDGE.md Hard Rules) |
-
-## Phase 3: Fix applied (2026-02-13, by root-access agent)
-
-| Parameter | Value |
-|-----------|-------|
-| Fix location | /etc/docker/daemon.json on Unraid host |
-| Fix content | `{"dns": ["172.17.0.1"]}` |
-| Persistence mechanism | /boot/config/go (Unraid startup script) |
-| Mechanism explanation | Technitium runs in host mode → binds to docker0 bridge interface → accessible from containers via bridge gateway IP 172.17.0.1 |
-| Measured DNS latency after fix | ~2ms |
-| Outbound request latency after fix | Normal network latency (vs 8s before) |
-
-## Verification
-
-| Test | Result |
-|------|--------|
-| goplaces without --timeout flag | Works correctly (previously required --timeout=30s) |
-| gifgrep without timeout issues | Works correctly |
-| git.wylab.me resolution from container | Resolves in ~2ms |
-| All 14 previously-working skills re-confirmed | Fast responses |
-
-**Note**: The fix required a user with host access (root-access Claude session), not the nanobot container itself. This is why the hard rule prohibits nanobot from modifying system config files.
@@ -1,41 +0,0 @@
-# Table 3 — Yandex Station Control Failure Attempts
-
-**Source**: HISTORY.md [2026-02-14 03:05]; SKILL.md yandex-station
-**Caption**: Documentation of the Yandex Station control failure mode: using TTS (text-to-speech) or Alice command mode to pause music, which reads text aloud instead of executing control commands. The "Iron Law" was established after 4-5 failed attempts in a single session.
-**Extraction type**: raw_table
-
-## Failure Mode Catalog
-
-| Attempt # | Approach Used | Expected Result | Actual Result | Why Wrong |
-|-----------|--------------|-----------------|---------------|-----------|
-| 1 | `select_sound_mode("Произнеси текст")` + `play_media("стоп")` | Music pauses | Speaker literally says "стоп" aloud | TTS reads text — does not execute commands |
-| 2 | `select_sound_mode("Произнеси текст")` + `play_media("выключи музыку")` | Music stops | Speaker says "выключи музыку" aloud | Same failure — TTS still just reads text |
-| 3 | `select_sound_mode("Произнеси текст")` + `play_media("pause")` | Music pauses | Speaker says "pause" aloud (in English) | TTS in non-Russian violates language constraint; also still just reads text |
-| 4 | `select_sound_mode("Выполни команду")` + `play_media("паузу")` | Music pauses via Alice | May have worked partially (inconsistent) | Alice command for basic playback is unnecessary; media_player/* is direct |
-| 5 (correct) | `media_player/media_pause` with `entity_id` | Music pauses | **Music paused** | Direct HA service — correct approach |
-
-## Root Cause Analysis
-
-| Dimension | Detail |
-|-----------|--------|
-| Confusion origin | TTS mode and Alice command mode use the same API call pattern (`select_sound_mode` + `play_media` with `dialog` type) as each other. The distinction between "read text aloud" vs "execute command" is subtle. |
-| Error compounding | After first TTS failure, re-attempt with different wording still uses TTS. "TTS didn't work, let me try different wording" is the exact anti-pattern logged. |
-| Language constraint | All TTS/Alice content must be in Russian; user doesn't speak Spanish. Attempting English wording compounds the failure. |
-| Correct approach | All basic playback control (play, pause, stop, volume, skip) uses direct `media_player/*` services. TTS and Alice are edge cases only. |
-
-## Established Rules (from SKILL.md yandex-station Iron Law)
-
-| Rule | Details |
-|------|---------|
-| Iron Law 1 | NO TTS FOR CONTROL — never use TTS to pause, stop, or control playback |
-| Iron Law 2 | NO ALICE FOR PLAYBACK — Alice commands are only for non-HA-addressable actions (timers, questions) |
-| Iron Law 3 | When in doubt → `media_player/*` service |
-| Alarm definition | "Alarm" in this household = music playing as alarm clock; stop it with `media_player/media_pause` |
-| Language | All TTS and Alice command text must be in Russian (Cyrillic) |
-
-## Station Entity IDs
-
-| Room | Entity ID |
-|------|-----------|
-| Kitchen (default) | `media_player.yandex_station_m00p31300zksak` |
-| Living Room | `media_player.yandex_station_m00p10100bq7hb` |
@@ -1,57 +0,0 @@
-# Table 4 — KNOWLEDGE.md / MEMORY.md Split: Cache Efficiency Data
-
-**Source**: HISTORY.md [2026-02-19 03:06]; KNOWLEDGE.md prompt caching section; HISTORY.md [2026-02-22 05:04] context engineering session
-**Caption**: Evidence for the two-tier memory architecture design. Prompt caching parameters, the trigger for the split, and the observed cache behavior before and after the change.
-**Extraction type**: raw_table
-
-## Cache Architecture Parameters
-
-| Parameter | Value |
-|-----------|-------|
-| Cache TTL | ~5 minutes |
-| Cache read cost | ~10% of cache write cost ("cache_read=16k+ tokens on hits, cache_write=2-3k for new conversation turns only" — KNOWLEDGE.md) |
-| Checkpoint 1 | End of static system prompt (KNOWLEDGE.md + skills list) |
-| Checkpoint 2 | End of growing conversation history |
-| API provider | Anthropic (via OAuth token, Claude Max subscription) |
-
-## Pre-Split Behavior
-
-| Scenario | Behavior |
-|----------|----------|
-| All state in system prompt | Any MEMORY.md update invalidates entire cache prefix |
-| MEMORY.md update frequency | Multiple times per session (after every tool use that changes state) |
-| Cache hit rate with combined file | Near 0% after first MEMORY.md update in session |
-| Effective token cost | Full input token pricing on every turn after first update |
-
-## Trigger for Split (2026-02-19 03:06)
-
-Exact HISTORY.md entry: "discovered MEMORY.md updates were invalidating cache on every write; implemented split: KNOWLEDGE.md (static, ~7.3k bytes, in system prompt) and MEMORY.md (frequent updates, not cached). Second cache checkpoint now working — conversation history also cached after fix to preserve time-prefix in stored messages."
-
-## Post-Split Behavior
-
-| Parameter | Value |
-|-----------|-------|
-| KNOWLEDGE.md update frequency | ~weekly (when stable fact changes) |
-| MEMORY.md update frequency | Multiple times per session |
-| Cache invalidation trigger | KNOWLEDGE.md changes only |
-| Cache_read_input_tokens on hit | 16,000+ tokens (from KNOWLEDGE.md entry) |
-| Cache_write_input_tokens on new turn | 2,000–3,000 tokens (conversation delta only) |
-| Estimated cost reduction | ~90% on stable context (at 10% read vs write cost ratio) |
-
-## KNOWLEDGE.md Size History
-
-| Date | Size | Trigger for Change |
-|------|------|--------------------|
-| 2026-02-22 (pre-optimization) | ~15.5KB | Before context optimization session |
-| 2026-02-22 (post-optimization) | ~4.3KB | Context engineering PR — removed interests, philosophy, stale identity, moved sections to mem0 |
-| 2026-03-02 (after mem0 migration) | ~3.8KB | Additional sections migrated to Qdrant: heartbeat architecture, prompt caching, subagent system, philosophical notes, university status details, git notes |
-
-## Memory Tier Summary
-
-| Tier | File | In System Prompt | Update Frequency | Cache Impact |
-|------|------|-----------------|------------------|--------------|
-| 1 (stable) | KNOWLEDGE.md | Yes | ~weekly | Cache invalidates on change |
-| 2 (volatile) | MEMORY.md | No | Multiple/session | No cache impact |
-| 3 (event log) | HISTORY.md | No | Every heartbeat | No cache impact |
-| 4 (heartbeat) | life_state.json | No | Every 30 min | No cache impact |
-| 5 (semantic) | mem0/Qdrant | No (on demand) | After consolidation | No cache impact |
@@ -1,57 +0,0 @@
-# Table 5 — SS14 CI/CD Debugging Dead Ends
-
-**Source**: HISTORY.md [2026-12-14 to 2026-12-19]; HISTORY.md [2026-02-13]
-**Caption**: Documentation of Space Station 14 CI/CD pipeline debugging failures: DNS resolution inside containers, Mac ARM64 runner OOM crashes, and .NET build cache corruption. These failures informed nanobot's infrastructure understanding.
-**Extraction type**: raw_table
-
-## Session 1: 2026-12-14 — Initial Runner DNS Failures
-
-| Attempt | Approach | Result |
-|---------|----------|--------|
-| 1 | Default runner configuration | Runner DNS resolution fails inside containers — cannot resolve git.wylab.me |
-| 2 | Add 1.1.1.1 as DNS to runner | Didn't work (cannot resolve internal hostnames via external DNS) |
-| 3 | Apply DNS to runner containers only | Didn't work |
-| 4 | Apply DNS to app containers | Didn't work |
-| 5 | Host network mode | Partially worked — 1/6 jobs succeeded |
-| Final | Reverted all changes | No resolution; root cause (daemon.json DNS) not yet identified |
-
-## Session 2: 2026-12-15 — External Runner (Contabo VPS)
-
-| Server | Details |
-|--------|---------|
-| External runner | 45.137.68.83, root, password t0NgG7wqhye8MAEt |
-| Issue 1 | Persistent Node.js module errors: Cannot find module in /opt/gitea-runner/.cache/act/ |
-| Issue 2 | .NET cache step: 5 minutes (vs 5 seconds for other steps) |
-| Issue 3 | Native Gitea caching: cache connection ETIMEDOUT to 45.137.68.83:39913 |
-| Fix added | shutdown_timeout to runner config |
-| Status | Cache issues unresolved |
-
-## Session 3: 2026-12-18 — Mac ARM64 Runner (OrbStack)
-
-| Event | Detail |
-|-------|--------|
-| Runner token | YCbZPZWAGg2iJrgL20dnsf8sRLASexJWAcv9VvW5 |
-| Initial issue | yaml-schema-validator action failed (pull access denied) |
-| Capacity tuning | Started at 6 concurrent → 4 → 3 → 2 concurrent jobs |
-| Root cause of OOM | dotnet builds on ARM64 under OrbStack; OrbStack swap not available (macOS manages memory) |
-| yaml-schema-validator fix | action pull access denied; deleted runner 2, reverted everything |
-| Status | Runner not robust; multiple pasted error logs; unresolved |
-
-## Session 4: 2026-12-19 — Mac Runner Tuning
-
-| Configuration | Value | Rationale |
-|--------------|-------|-----------|
-| shutdown_timeout | 30m | Prevent zombie containers from piling up |
-| Cache type | Local file cache (not remote) | Avoid cross-runner cache contamination |
-| Concurrent jobs | 2 | OOM threshold on ARM64 with dotnet |
-| Applied to external runner? | Yes | Same shutdown_timeout fix |
-| Status | Runner kept crashing under load — unresolved as of this date |
-
-## Root Cause Analysis (inferred retrospectively from HISTORY.md [2026-02-13] DNS fix)
-
-| Claim | Evidence |
-|-------|---------|
-| DNS failures in runner containers had same root cause as nanobot latency | Both caused by 192.168.1.50 being unreachable from Docker NAT |
-| Correct fix (not applied in Dec 2026) | Set {"dns": ["172.17.0.1"]} in Docker daemon.json — resolves internal hostnames via bridge gateway |
-| Cache corruption | .NET build cache on ARM64 Mac is architecture-specific; sharing cache with x64 runner produces incompatible binaries |
-| OOM on ARM64 | dotnet compile + test requires >2GB RAM per concurrent job; 2 concurrent was minimum viable |
@@ -1,49 +0,0 @@
-# Table 6 — Traefik TLS Certificate Failure
-
-**Source**: HISTORY.md [2026-12-14]; KNOWLEDGE.md Obsidian section ("plain HTTP — HTTPS/TLS fails"); SKILL.md references
-**Caption**: Evidence of Traefik TLS certificate provisioning failure due to DNS bootstrap circular dependency. Services that depend on Traefik for TLS have been found to require plain HTTP workarounds.
-**Extraction type**: raw_table
-
-## Observed Symptoms
-
-| Service | Protocol Used | Reason for HTTP |
-|---------|--------------|-----------------|
-| Obsidian local REST API | HTTP (port 27123) | "plain HTTP — HTTPS/TLS fails" (KNOWLEDGE.md) |
-| Home Assistant | HTTP (192.168.1.50:8123) | TLS not functional for local access; Traefik certificate issues |
-| Health Receiver | HTTP (192.168.1.50:3847) | Local service without TLS |
-
-## Traefik Certificate Failure Evidence
-
-From HISTORY.md [2026-12-14]:
- "SS14 server (wylab-station-14) CI/CD pipeline not triggering on commits"
- "Runner DNS resolution failures inside containers — could not resolve git.wylab.me"
- Multiple failed approaches to fix: 1.1.1.1 DNS, host network mode, applying DNS to different container layers
- Only 1/6 CI/CD jobs succeeded under host network mode
- All changes eventually reverted
-
-From HISTORY.md [2026-01-29]: "SS14 server login attempts and additional Traefik configuration" — recurring Traefik configuration attempts
-
-From HISTORY.md [2026-01-03]: "Added n8n to Traefik routing" — Traefik was operational for routing but certificate issues persisted for certain services
-
-## Circular Dependency Analysis
-
-| Step | State |
-|------|-------|
-| 1 | Traefik needs to issue TLS certificate via ACME DNS-01 challenge |
-| 2 | ACME DNS-01 requires querying domain's DNS authoritative server |
-| 3 | DNS authoritative server may be behind Traefik (or unreachable from Docker network) |
-| 4 | If DNS is behind Traefik but no valid certificate → DNS unreachable → certificate cannot be issued |
-| 5 | Deadlock: cannot get certificate without DNS, cannot reach DNS without certificate |
-
-## Workarounds in Use
-
-| Service | Workaround |
-|---------|------------|
-| Obsidian REST API | Plain HTTP on port 27123; API key in header for auth |
-| Home Assistant | Plain HTTP on local LAN; not exposed via Traefik at all |
-| Gitea | HTTPS functional (certificate was successfully issued for git.wylab.me at some point) |
-| Nanobot container | DNS fix (172.17.0.1 in daemon.json) resolved internal hostname resolution separately from TLS |
-
-## Key Finding
-
-The Traefik certificate failure primarily manifested as DNS resolution failures inside Docker containers that tried to reach internal services via their wylab.me hostnames. The underlying cause — unreachable DNS during ACME challenge — was diagnosed retroactively when the February 2026 DNS fix (bridge gateway 172.17.0.1) resolved the DNS latency issue. The TLS issue for some services (Obsidian, HA local) was worked around with plain HTTP rather than fixed at the Traefik level.
@@ -1,27 +0,0 @@
-# Table 7 — System Architecture: Components, Inputs, Outputs, Interactions
-
-**Source**: KNOWLEDGE.md §Heartbeat Architecture; solution/architecture.md
-**Caption**: Full system component map showing all nanobot components with their inputs, outputs, and key design choices. Raw transcription from operational documentation.
-**Extraction type**: raw_table
-
-| Component | Type | Inputs | Outputs | Key Design Choices |
-|-----------|------|--------|---------|-------------------|
-| Agent Loop (`loop.py`) | Core runtime | Inbound Telegram messages; timer events from HeartbeatService; system bus messages from subagents | Outbound messages via message() tool → Telegram; subagent spawns; tool execution results | Single-threaded session processing (sequential within session); sessions isolated from each other; `clear_tool_uses_20250919` API prunes old tool chains |
-| System Prompt (cached prefix) | Context layer | KNOWLEDGE.md file (read at session init) | First cache checkpoint for all API calls | Must remain stable between calls to preserve cache hits; all volatile state excluded; skills list included as references |
-| Heartbeat Orchestrator (Sonnet subagent) | Autonomous cycle | HEARTBEAT_INSTRUCTIONS.md; current time from hb-clock; 7 Haiku collector output files; youtube.json from deterministic script | Telegram alerts via message(); HISTORY.md append; life_state.json update; heartbeat report file | Spawned as a Sonnet subagent to isolate iteration budget; reads HEARTBEAT_INSTRUCTIONS.md at start; delegates all data collection to collectors before interpreting |
-| hb-clock (Haiku collector) | Data collector | `TZ=Europe/Paris date` command; life_state.json | `heartbeat_data/clock.json` (timestamp, day, state) | Budget: 200 chars; contains full life_state.json for orchestrator reference |
-| hb-context (Haiku collector) | Data collector | tail -n 200 of sessions/telegram_239824268.jsonl; tail -n 100 of HISTORY.md | `heartbeat_data/context.json` (last user message timestamp + ago_minutes, recent_history) | Budget: 500 chars; must distinguish real Telegram messages (sender_id contains "239824268") from heartbeat triggers; session file can exceed 200k tokens |
-| hb-health (Haiku collector) | Data collector | HTTP APIs at 192.168.1.50:3847 (location, metrics, heart-rate, workouts, state-of-mind, medications) | `heartbeat_data/health.json` (location, metrics, heart_rate, workouts, state_of_mind, medications) | Budget: 400 chars; key auth required; returns null fields on endpoint error |
-| hb-home (Haiku collector) | Data collector | HA REST API (kitchen Alice, living room Alice, vacuum entity) | `heartbeat_data/home.json` (kitchen, living_room, vacuum_state) | Budget: 300 chars; Bearer token auth; Haiku may refuse private IP requests (security policy) |
-| hb-email (Haiku collector) | Data collector | `gog gmail search 'is:unread newer_than:1d'` | `heartbeat_data/email.json` (total_unread, threads list with thread_id/sender/subject) | Budget: 600 chars; up to 5 unread threads; no body fetched at collection time |
-| hb-browser (Haiku collector) | Data collector | PostgreSQL browser_history table (last N rows since last_browser_check) | `heartbeat_data/browser.json` (db_ok, row_count, summary, clusters) | Budget: 400 chars; extracts time-clustered topics; skips login pages and redirects |
-| hb-weather (Haiku collector) | Data collector | wttr.in/Barcelona?format=%c+%t+%h+%w | `heartbeat_data/weather.json` (summary string) | Budget: 300 chars; often fails (wttr.in intermittent); writes null on failure |
-| youtube_sync.py (deterministic script) | Data collector | YouTube Data API v3 (liked videos, subscriptions) | SQLite + Qdrant + HISTORY.md + `heartbeat_data/youtube.json` (new_likes diff since last heartbeat) | Replaced hb-youtube Haiku collector after hallucination incident; 60s timeout; writes error JSON on failure |
-| KNOWLEDGE.md | Memory layer | Manual updates (at most weekly) | System prompt cache prefix | Stable facts: user identity, infrastructure, behavioral rules; ~4-8KB; must not contain "currently" or "recently" facts |
-| MEMORY.md | Memory layer | Session end writes; heartbeat updates | In-context volatile state (loaded on demand) | NOT in system prompt; contains current project status, active alerts, deferred decisions; updated multiple times per session |
-| HISTORY.md | Memory layer | Heartbeat appends; session summaries | Append-only event log | Never edited retroactively; corrections appended as new entries; >200KB as of 2026-05; grep-searchable |
-| life_state.json | Persistence layer | Heartbeat Step 16 writes | Heartbeat Step 4 reads (via hb-clock) | Contains: last_location, known_places, alerted_email_ids (append-only), last_vacuum_run, sleep_state, last_alice_state, last_health_files |
-| mem0 / Qdrant | Memory layer | Conversation extracts; youtube_sync.py embeddings | Semantic search results on demand | Collection "mem0" at 172.17.0.1:6333; uses Haiku for extraction LLM (via custom OAuth provider), OpenAI text-embedding-3-small for embeddings |
-| Home Assistant | External service | REST API calls from hb-home, heartbeat vacuum automation | Alice station states, vacuum control | 192.168.1.50:8123; long-lived access token auth; Quasar cloud API for Yandex Station control |
-| Health Receiver | External service | OwnTracks MQTT messages; Apple Health HTTP POST | REST endpoints for location, metrics, workouts | 192.168.1.50:3847; custom Node.js app; mqtts.wylab.me:443 for MQTT |
-| PostgreSQL | External service | Safari browser history sync (launchd, every 5 min) | browser_history table (url, title, visit_time) | 192.168.1.50:5432; md5(url)+visit_time unique index; Mac user: macexport |
@@ -1,33 +0,0 @@
-# Table 8 — Heartbeat Collector Budget Table
-
-**Source**: KNOWLEDGE.md §Heartbeat Architecture; HEARTBEAT_INSTRUCTIONS.md
-**Caption**: Per-collector output budget (maximum characters) for the 8 heartbeat data sources. Total max orchestrator input from all collectors: ~3,100 characters / ~800 tokens. Raw transcription from operational documentation.
-**Extraction type**: raw_table
-
-| Collector | Model | Output File | Budget (chars) | Content Type | Notes |
-|-----------|-------|-------------|---------------|-------------|-------|
-| hb-clock | Haiku | heartbeat_data/clock.json | 200 | Timestamp + timezone + full life_state.json | Only field that embeds the entire life_state; small because state is read separately |
-| hb-context | Haiku | heartbeat_data/context.json | 500 | Last real Telegram message timestamp + recent HISTORY.md tail | Must filter out heartbeat trigger messages (sender_id != "239824268") |
-| hb-health | Haiku | heartbeat_data/health.json | 400 | Location, steps, heart rate, workouts, mood, medications | 6 API endpoints at 192.168.1.50:3847 |
-| hb-home | Haiku | heartbeat_data/home.json | 300 | Device states as key-value pairs (kitchen Alice, living room Alice, vacuum) | Haiku may refuse private IP requests; orchestrator falls back to direct curl |
-| hb-email | Haiku | heartbeat_data/email.json | 600 | Subject + sender + thread_id for up to 20 unread; no body | Largest budget: subject lines vary in length |
-| youtube_sync.py | Python (deterministic) | heartbeat_data/youtube.json | 400 | Up to 5 new likes diff since last heartbeat: channel + title + id + summary | Replaced Haiku hb-youtube after hallucination incident (2026-03-03) |
-| hb-browser | Haiku | heartbeat_data/browser.json | 400 | Up to 5 browsing clusters: time range + topic; no raw URLs | Reads PostgreSQL browser_history; summarizes time-clustered activity |
-| hb-weather | Haiku | heartbeat_data/weather.json | 300 | Current conditions + today's high/low from wttr.in | Often fails (wttr.in intermittent); writes null summary on failure |
-
-## Totals
-
-| Metric | Value |
-|--------|-------|
-| Total collectors | 8 (7 Haiku + 1 deterministic Python script) |
-| Total max output (all collectors) | ~3,100 characters |
-| Estimated token cost (orchestrator input from collectors) | ~800 tokens |
-| Orchestrator model | claude-sonnet-4-6 |
-| Collector model | claude-haiku-4-5 (all Haiku agents) |
-| Collector budget enforcement | Collector must truncate; orchestrator does not re-fetch |
-
-## Design rationale
-
-Collector budgets were set to prevent the Sonnet orchestrator's input from growing unboundedly across heartbeat cycles. The total ~800 token budget for collector outputs is small relative to the orchestrator's context window, leaving ample room for HEARTBEAT_INSTRUCTIONS.md, the life_state.json (via clock.json), and the orchestrator's interpretation and action steps.
-
-If a collector's raw data exceeds its budget, the collector must truncate to the most recent/relevant items (e.g., hb-email keeps the 5 most recent unread threads, not all 20). The orchestrator proceeds with whatever data is available — it does not retry failed or truncated collectors.
@@ -1,107 +0,0 @@
-# Claims
-
-## C01: Parallel Haiku-collector architecture reduces heartbeat latency vs sequential design
- **Statement**: Spawning 8 Haiku data collectors in parallel via `wait_for_subagents` and having the Sonnet orchestrator read their output files results in lower wall-clock time per heartbeat cycle than sequential step-by-step execution by a single Sonnet agent.
- **Status**: supported
- **Falsification criteria**: A sequential Sonnet heartbeat completing all 8 data-collection steps and interpretation within the same 30-minute window without iteration exhaustion would refute this claim.
- **Proof**: [E01, E02]
- **Evidence basis**: HISTORY.md [2026-02-18 21:39]: "Redesigned heartbeat system from 18 sequential steps executed by one Sonnet into parallel architecture: Sonnet orchestrator spawns 8 Haikus in parallel (clock-state, context, health, home, email, youtube, browser, weather), each writes compact JSON summary to file, Sonnet reads all 8 files and interprets/acts." HISTORY.md [2026-02-14 10:21]: sequential design caused iteration exhaustion at max_iterations=15.
- **Interpretation**: The parallel architecture also enables fault isolation — a single collector failure does not block the other 7; the orchestrator proceeds with whatever files exist.
- **Dependencies**: C03
- **Tags**: heartbeat, architecture, parallelism, haiku, latency
-
---
-
-## C02: KNOWLEDGE.md / MEMORY.md split preserves prompt-cache hit rates
- **Statement**: Splitting stable facts into KNOWLEDGE.md (in system prompt, cached) and volatile in-progress state into MEMORY.md (not in system prompt) results in higher prompt-cache hit rates than storing all state in a single system-prompt file.
- **Status**: supported
- **Falsification criteria**: Evidence that KNOWLEDGE.md updates occur at the same frequency as MEMORY.md updates would undermine the rationale; alternatively, showing that cache misses dominate in the stable-KNOWLEDGE design.
- **Proof**: [E03]
- **Evidence basis**: HISTORY.md [2026-03-03 07:56]: "Root cause of bad extraction: when user and assistant discuss system internals, those conversations become extractable facts. Custom prompt in memory_mem0.py needs negative examples for infrastructure/architecture content." HISTORY.md [2026-02-19 03:06]: "discovered MEMORY.md updates were invalidating cache on every write; implemented split: KNOWLEDGE.md (static, ~7.3k bytes, in system prompt) and MEMORY.md (frequent updates, not cached). Second cache checkpoint now working." KNOWLEDGE.md: "Cache TTL: ~5 minutes. MEMORY.md updates bust the cache — that's why KNOWLEDGE.md exists as a separate slow-changing file. Typical: cache_read=16k+ tokens on hits, cache_write=2-3k for new conversation turns only."
- **Interpretation**: The two-tier split also has a semantic benefit: it forces explicit decisions about which facts are stable enough to warrant system-prompt inclusion, preventing drift of volatile state into permanent context.
- **Dependencies**: none
- **Tags**: memory, caching, cost-efficiency, prompt-engineering
-
---
-
-## C03: Deterministic scripts outperform LLM-based collectors for sensor data reliability
- **Statement**: Replacing LLM Haiku collectors with deterministic bash/Python scripts for data collection tasks (YouTube sync, health metrics fetch, browser history query, weather fetch) eliminates hallucination of sensor data while maintaining the same data freshness.
- **Status**: supported
- **Falsification criteria**: A case where the deterministic script produces incorrect data that the LLM collector would have correctly filtered or interpreted would refute the strong form of this claim.
- **Proof**: [E02, E04]
- **Evidence basis**: HISTORY.md [2026-03-03 02:48]: User confirmed YouTube hallucinations; video IDs from heartbeat positions 6-10 were non-existent on YouTube. HISTORY.md [2026-03-03 03:21]: "Script /root/.nanobot/workspace/scripts/youtube_sync.py completed. Full sync done: 4999 liked videos, 988 subscriptions, 1 playlist (51 items)... Writes heartbeat_data/youtube.json with real data, includes error state on failure." HEARTBEAT_INSTRUCTIONS.md Step 2: YouTube script runs deterministically before Haiku spawn.
- **Interpretation**: The key insight is that data collection (fetching from APIs, formatting output) is a deterministic transformation that does not benefit from language model reasoning. LLMs are only appropriate for the interpretation step.
- **Dependencies**: none
- **Tags**: data-collection, hallucination, determinism, reliability
-
---
-
-## C04: All subagent-to-user messages must route through the main agent's message() tool
- **Statement**: Heartbeat subagents that send Telegram messages directly (via curl or tool calls in subagent context) create split-identity context gaps where the main conversational agent cannot see what was communicated to the user, causing confused responses when the user replies.
- **Status**: supported
- **Falsification criteria**: A mechanism for the conversational agent to read heartbeat-sent messages from an external log would allow direct subagent messaging without context gaps.
- **Proof**: [E05]
- **Evidence basis**: HISTORY.md [2026-02-21]: "Design flaw: heartbeat sends Telegram messages via separate CLI invocation, those messages don't appear in the conversation agent's session context. Same bot identity from user's perspective but no shared context. Fix needed: log heartbeat-sent messages somewhere the conversation agent can read when user replies." MEMORY.md [2026-05-01]: "CRITICAL HEARTBEAT FIX — Subagent messages are INTERNAL — they do NOT reach Makar's Telegram. Only the main orchestrator agent can send via message() tool. When heartbeat subagent reports an alert, the main agent must relay it using message() before responding HEARTBEAT_OK."
- **Interpretation**: This is an emergent constraint of the nanobot session architecture: the conversational session's context does not include messages generated by other sessions (e.g., heartbeat session). Relaying through message() is the pragmatic workaround until session cross-linking is implemented.
- **Dependencies**: none
- **Tags**: subagents, context-gap, telegram, session-architecture
-
---
-
-## C05: Docker container DNS resolution requires the bridge gateway as nameserver
- **Statement**: On Unraid with Technitium DNS running in host mode, Docker containers must use the bridge gateway IP (172.17.0.1) as their DNS resolver rather than the host IP (192.168.1.50) or the embedded Docker DNS (169.254.24.117), both of which are unreachable from container network namespace.
- **Status**: supported
- **Falsification criteria**: Successful DNS resolution from a Docker container using 192.168.1.50 directly would refute this claim in this network topology.
- **Proof**: [E04]
- **Evidence basis**: HISTORY.md [2026-02-13 18:16]: "Fixed by: added {'dns': ['172.17.0.1']} to /etc/docker/daemon.json on Unraid, persisted in /boot/config/go. Technitium runs in host mode so it binds to docker0 bridge gateway — containers now resolve in ~2ms." Prior state: 8-second latency from 192.168.1.50 being listed first but unreachable.
- **Interpretation**: This is specific to the Unraid + Docker + Technitium topology but the principle generalizes: any DNS service running in host mode on the Docker host is accessible from containers via the bridge gateway IP, not the host's primary IP.
- **Dependencies**: none
- **Tags**: infrastructure, dns, docker, networking, unraid
-
---
-
-## C06: Traefik TLS certificate provisioning fails if DNS is not independently reachable during ACME challenge
- **Statement**: When Traefik manages TLS certificates via ACME DNS-01 challenge, it requires the domain's DNS authoritative server to be reachable. If that DNS server is itself behind Traefik (creating a circular dependency) or is not reachable from the network, ACME validation fails.
- **Status**: supported
- **Falsification criteria**: A working Traefik ACME DNS-01 configuration with DNS service behind Traefik would refute this.
- **Proof**: [E04]
- **Evidence basis**: HISTORY.md [2026-12-14]: "SS14 server CI/CD pipeline not triggering on commits. Runner DNS resolution failures inside containers — could not resolve git.wylab.me. Tried adding 1.1.1.1 as DNS to runner, didn't work. Tried applying DNS to runner containers vs app — didn't work. Tried host network mode — partially worked (1/6 jobs succeeded)... Multiple failed approaches, eventually reverted changes." HISTORY.md [2026-01-03]: Traefik login attempts and additional Traefik configuration noted as a recurring issue; HA REST API explicitly uses plain HTTP because "HTTPS/TLS fails" (KNOWLEDGE.md Obsidian section).
- **Interpretation**: The Traefik certificate failure manifests as a cascade: no valid certificate → services unreachable → CI/CD runners can't resolve → pipeline failures. The failure mode is not obviously a DNS issue from the symptom (connection refused or SSL error).
- **Dependencies**: C05
- **Tags**: traefik, tls, certificates, dns, infrastructure, dead-end
-
---
-
-## C07: Yandex Station playback control must use direct media_player/* services, not TTS or Alice commands
- **Statement**: Using TTS (text-to-speech) or Alice voice command mode to control Yandex Station playback (pause, stop, volume) does not execute the control actions — it only reads text aloud through the speaker, while direct Home Assistant `media_player/*` service calls reliably control playback.
- **Status**: supported
- **Falsification criteria**: A TTS command successfully pausing or stopping playback on a Yandex Station via Home Assistant would refute this.
- **Proof**: [E05]
- **Evidence basis**: HISTORY.md [2026-02-14 03:05]: "assistant catastrophically failed Yandex station control — sent TTS ('Произнеси текст') instead of command execution ('Выполни команду') or direct media_player/media_pause at least 4-5 times despite user correcting after each attempt... Eventually resolved with media_player/media_pause." SKILL.md yandex-station: "NO TTS FOR CONTROL. NO ALICE FOR PLAYBACK. When in doubt → media_player/* service." The skill lists explicit failure modes: "TTS reads text aloud. It does NOT execute commands."
- **Interpretation**: The confusion arises from the multi-mode nature of Yandex Station control (TTS, Alice commands, and direct media_player services all use similar API call patterns). The Iron Law in the skill file exists specifically because of this repeated failure mode.
- **Dependencies**: none
- **Tags**: yandex-station, home-automation, skill, failure-mode, iron-law
-
---
-
-## C08: SS14 CI/CD cache corruption occurs when multiple runners share a cache on different architectures
- **Statement**: SS14 (Space Station 14) CI/CD builds fail with cache corruption when a GitHub Actions runner on Mac ARM64 (OrbStack) shares .NET build cache with an x64 runner, because the cached binaries are architecture-incompatible.
- **Status**: supported
- **Falsification criteria**: Successful cross-architecture cache sharing for .NET builds in a mixed ARM64/x64 runner setup would refute this.
- **Proof**: [E04]
- **Evidence basis**: HISTORY.md [2026-12-15]: "Cache issues: .NET cache step taking 5 minutes vs 5 seconds for other steps. Attempted native Gitea caching — cache connection ETIMEDOUT to 45.137.68.83:39913." HISTORY.md [2026-12-18]: "Mac ARM64 Runner Setup (OrbStack)... Runner capacity tuning: started at 6 → 4 → 3 → 2 concurrent jobs due to OOM with dotnet builds. OrbStack swap not available (macOS manages memory)... Runner kept crashing under load — unresolved as of this date." HISTORY.md [2026-12-19]: "OrbStack Migration & Runner Tuning... Configured local file cache (not remote) for Mac runner."
- **Interpretation**: The fix (local file cache per runner) prevents cross-architecture contamination at the cost of losing cache sharing benefits. The underlying issue is that .NET build caches contain architecture-specific binaries.
- **Dependencies**: none
- **Tags**: ci-cd, cache, ss14, dotnet, architecture, dead-end
-
---
-
-## C09: The heartbeat system requires email deduplication via persistent alerted_email_ids
- **Statement**: Without a persistent set of already-alerted email thread IDs, the heartbeat system will re-alert the same email on every subsequent heartbeat cycle until the email is read, causing notification spam.
- **Status**: supported
- **Falsification criteria**: A heartbeat design that alerts only on truly new emails (using only last_email_ids comparison) and never re-alerts would refute the necessity of alerted_email_ids specifically.
- **Proof**: [E05]
- **Evidence basis**: MEMORY.md [2026-05-01]: "Heartbeat dedup issue — Cifra Markets USD terms email was sent via Telegram multiple times (10:50 Apr 28, 17:23 Apr 28, possibly more). Heartbeat not properly deduplicating email alerts." Fix: "Added alerted_email_ids to life_state.json and updated HEARTBEAT_INSTRUCTIONS.md. All 24 current email IDs pre-populated so they won't re-alert. Cifra Markets triple-alert issue resolved." HEARTBEAT_INSTRUCTIONS.md Step 8: "IMPORTANT: alerted_email_ids is permanent — never remove entries from it."
- **Interpretation**: The distinction between last_email_ids (tracks which threads have been seen) and alerted_email_ids (tracks which have been alerted) is critical: a thread can be "seen" but re-alerted if only last_email_ids is used. The persistent alerted set provides a one-way gate that prevents re-alerting regardless of heartbeat cycle state.
- **Dependencies**: none
- **Tags**: heartbeat, email, deduplication, notifications, state-management
@@ -1,49 +0,0 @@
-# Concepts
-
-## Heartbeat System
- **Notation**: `HB(t)` where `t` is the cycle timestamp
- **Definition**: An autonomous, time-triggered process that runs every 30 minutes independently of user interaction. It spawns 8 parallel Haiku subagent collectors, waits for their output files, interprets the combined picture with a Sonnet orchestrator, and takes actions (Telegram alerts, vacuum control, HISTORY.md logging, life_state.json update). The heartbeat runs in a dedicated `cli:direct` session key (`heartbeat`), separate from the conversational Telegram session.
- **Boundary conditions**: Runs only when the nanobot container is active. Does not run during rate-limit windows or when the Anthropic API is unavailable. Maximum one vacuum run per day; never starts vacuum while user is home.
- **Related concepts**: Subagent Parallelism, Session Architecture, Life State
-
-## Subagent Parallelism
- **Notation**: `spawn(model=M, task=T)` → `task_id`; `wait_for_subagents([id₁, ..., id₈])`
- **Definition**: The pattern of creating multiple independent agent instances (subagents) that execute concurrently and write their results to shared files or return through the `wait_for_subagents` barrier. In nanobot's heartbeat, 8 Haiku subagents are spawned simultaneously before `wait_for_subagents` is called, yielding roughly `max(t_i)` total collection time versus `Σ t_i` for sequential execution.
- **Boundary conditions**: Subagents cannot directly communicate with each other or with the main user session — they communicate only through shared files or the subagent result system. Subagent results appear in the orchestrator's context, not in the Telegram channel.
- **Related concepts**: Heartbeat System, Session Architecture
-
-## Two-Tier Memory Architecture
- **Notation**: `KNOWLEDGE.md ⊂ SystemPrompt` (stable, cached); `MEMORY.md ∉ SystemPrompt` (volatile, uncached)
- **Definition**: A memory split where KNOWLEDGE.md contains facts stable for 2+ weeks (user identity, infrastructure topology, behavioral rules, communication preferences) and is included in the cached system prompt, while MEMORY.md contains in-progress volatile state (current project status, deferred decisions, active alerts) and is loaded on demand. HISTORY.md is an append-only event log, never in system prompt.
- **Boundary conditions**: Facts should be promoted from MEMORY.md to KNOWLEDGE.md only when stable for 2+ weeks. KNOWLEDGE.md size should remain under ~8KB to minimize cache write costs. Demoted MEMORY.md entries are archived to HISTORY.md before deletion.
- **Related concepts**: Prompt Caching, Session Architecture
-
-## Prompt Caching (Anthropic)
- **Notation**: Cache TTL = 5 minutes; cache_read_tokens cost ≈ 0.1× cache_write_tokens cost
- **Definition**: Anthropic API feature that caches a prefix of the system prompt + conversation history across API calls. Two cache checkpoints are maintained: one at the end of the static system prompt (stable, rarely invalidated) and one at the end of the growing conversation history (updated on each turn). A cache hit reports `cache_read_input_tokens = 16k+`; a miss reports `cache_write_input_tokens = 2-3k`.
- **Boundary conditions**: Cache is invalidated if the exact byte content of any content block at or before the checkpoint changes. MEMORY.md inclusion in the system prompt was explicitly removed because MEMORY.md updates on every session write, busting the cache on every turn. Cache TTL is ~5 minutes — restarts or long inactivity create cold writes.
- **Related concepts**: Two-Tier Memory Architecture, Session Architecture
-
-## Life State (`life_state.json`)
- **Notation**: `S_t ⊂ {location, sleep_state, known_places, last_email_ids, alerted_email_ids, last_vacuum_run, last_alice_state, last_health_files, ...}`
- **Definition**: A JSON file at `/root/.nanobot/workspace/memory/life_state.json` that persists the heartbeat system's accumulated understanding of Makar's current situation between heartbeat cycles. It is read at the start of each heartbeat (via `hb-clock`), updated at the end (Step 16), and acts as the only continuity mechanism across independent heartbeat invocations.
- **Boundary conditions**: `alerted_email_ids` is append-only (never remove entries). `known_places` cache uses `{lat:.4f}_{lon:.4f}` keys to avoid re-resolving frequent locations. `last_vacuum_run` prevents more than one daily vacuum run even if the location collector incorrectly reports departure multiple times.
- **Related concepts**: Heartbeat System, Email Deduplication
-
-## Session Architecture
- **Notation**: Sessions identified by `{channel}:{identifier}` key, e.g., `telegram:239824268` for the main Telegram session and `heartbeat` (or `cli:direct`) for autonomous heartbeat runs.
- **Definition**: Nanobot maintains separate session JSONL files for each channel/identity combination. The conversational agent operates in the `telegram:239824268` session; the heartbeat operates in a `cli:direct` or `heartbeat` session. These sessions share no in-memory state. The message() tool is the only mechanism by which the heartbeat session can inject content into the Telegram session's visible context.
- **Boundary conditions**: Session files grow without bound; the `hb-context` collector uses `tail -n 200` to avoid context exhaustion. The Anthropic API `clear_tool_uses_20250919` server-side context edit prunes old tool chains transparently. Sessions are stored at `/root/.nanobot/workspace/sessions/`.
- **Related concepts**: Two-Tier Memory Architecture, Subagent Parallelism
-
-## Skill
- **Notation**: `skills/{name}/SKILL.md` + optional binary/CLI dependency
- **Definition**: A self-contained capability module that gives the nanobot agent access to a specific tool or service. Each skill consists of: a SKILL.md describing the tool's invocation, capabilities, and constraints; any required binary or CLI tool installed in the container; and optionally configuration state in environment variables or config files. Skills are loaded into the system prompt to make their capabilities available.
- **Boundary conditions**: Skills with hardware dependencies (blu/Bluesound, sonoscli) only work if the hardware is on the local network. Skills requiring external API keys fail silently if the key is missing or expired. Network-dependent skills may time out if DNS is broken.
- **Related concepts**: Heartbeat System, Session Architecture
-
-## Collector Budget
- **Notation**: `budget_i` = max characters for collector `i` output file
- **Definition**: The maximum character size of each Haiku collector's output JSON file, enforced by truncation within the collector. Total max orchestrator input from all 8 collectors: ~3,100 characters / ~800 tokens. Per-collector budgets: clock=200, context=500, health=400, home=300, email=600, youtube=400, browser=400, weather=300.
- **Boundary conditions**: If a collector's raw data exceeds its budget, it must truncate to the most recent/relevant items. The Sonnet orchestrator must not attempt to re-fetch — it works with what it receives. Budget enforcement prevents the orchestrator's input from growing unboundedly across heartbeat cycles.
- **Related concepts**: Heartbeat System, Subagent Parallelism
@@ -1,99 +0,0 @@
-# Experiments
-
-## E01: Measure heartbeat cycle wall-clock time for parallel vs sequential architecture
- **Verifies**: C01
- **Setup**:
-  - System: Nanobot container on Unraid UM790 Pro, 32GB RAM
-  - Model: Sonnet orchestrator + 8× Haiku collectors (parallel design); Sonnet only (sequential baseline)
-  - Dataset: One full heartbeat cycle with all 8 data sources active (location, health, home, email, youtube, browser, weather, context)
-  - Configuration: Parallel — spawn 8 Haiku agents before wait_for_subagents; Sequential — run all 8 data-collection steps in order within a single Sonnet session
- **Procedure**:
-  1. Record wall-clock start time before first spawn() call
-  2. Execute heartbeat in parallel architecture; record time until wait_for_subagents returns
-  3. Execute equivalent heartbeat in sequential architecture; record time until all steps complete
-  4. Compare total wall-clock times across 10 independent runs each
-  5. Count iteration consumption in sequential design vs individual Haiku collector iteration counts
- **Metrics**: Wall-clock time (seconds), iteration count consumed, failure rate (collectors that did not complete), total Anthropic token cost
- **Expected outcome**: Parallel design should complete data collection in less time than sequential because collector wait time is dominated by the slowest collector (`max(t_i)`) rather than the sum (`Σ t_i`); sequential design should exhaust iteration budget more frequently
- **Baselines**: Sequential 18-step Sonnet heartbeat (pre-February 2026 design)
- **Dependencies**: none
-
---
-
-## E02: Validate hallucination rate of LLM-based vs script-based YouTube data collection
- **Verifies**: C01, C03
- **Setup**:
-  - System: Nanobot heartbeat, YouTube API via `gog youtube` / `youtube_sync.py`
-  - Model: Haiku for LLM-based collection; Python script `youtube_sync.py` for deterministic collection
-  - Dataset: 50 most recent YouTube liked videos from the real API; Haiku collector output for the same timeframe
-  - Baseline: Ground truth from YouTube Data API (liked videos list)
- **Procedure**:
-  1. Run `youtube_sync.py` and capture output `heartbeat_data/youtube.json` as ground truth
-  2. Run Haiku `hb-youtube` collector with the same input state and capture its output
-  3. Compare video IDs in Haiku output vs script output; check for IDs not present in YouTube's API response
-  4. Repeat 10 times, varying DNS availability (simulating partial failure) for stress testing
-  5. Count fabricated entries (video IDs that return 404 on YouTube) in Haiku output
- **Metrics**: False positive rate (fabricated videos / total reported videos), false negative rate (missed real videos), latency, cost
- **Expected outcome**: Script-based collection should produce zero fabricated entries; Haiku-based collection under partial DNS failure should produce measurably more fabricated entries than under normal conditions
- **Baselines**: LLM (Haiku) collector from pre-March 2026 design
- **Dependencies**: none
-
---
-
-## E03: Measure prompt-cache hit rate with and without KNOWLEDGE.md / MEMORY.md split
- **Verifies**: C02
- **Setup**:
-  - System: Nanobot Anthropic API calls with `cache_control` markers
-  - Model: Claude Sonnet 4.x (production model)
-  - Configuration A: KNOWLEDGE.md + MEMORY.md both in system prompt (pre-split baseline)
-  - Configuration B: KNOWLEDGE.md in system prompt only; MEMORY.md excluded (current design)
-  - Dataset: 20 consecutive turns of a typical conversational session with 3 MEMORY.md updates mid-session
- **Procedure**:
-  1. Establish a baseline conversation with Config A; record `cache_read_input_tokens` and `cache_write_input_tokens` for each turn
-  2. Simulate MEMORY.md update (write to file) between turns; observe cache behavior
-  3. Repeat with Config B under identical conditions
-  4. Calculate cache hit rate = `cache_read_input_tokens / (cache_read_input_tokens + cache_write_input_tokens)` per turn
-  5. Compare total token costs for 20-turn session
- **Metrics**: Cache hit rate per turn, total input token cost, number of full cache invalidations per session
- **Expected outcome**: Config B should maintain higher cache hit rate after MEMORY.md updates (no invalidation); Config A cache hit rate should drop to zero after each MEMORY.md write and recover only on subsequent calls within the 5-minute TTL
- **Baselines**: Single-file system prompt design (pre-February 2026)
- **Dependencies**: none
-
---
-
-## E04: Reproduce DNS latency and verify bridge-gateway fix
- **Verifies**: C05, C06
- **Setup**:
-  - System: Unraid UM790 Pro with Docker daemon, Technitium DNS in host mode
-  - Configuration A: Docker daemon.json with `{"dns": ["192.168.1.50"]}` (broken — Technitium reachable via host but not via Docker NAT)
-  - Configuration B: Docker daemon.json with `{"dns": ["172.17.0.1"]}` (fixed — Technitium accessible via bridge gateway)
-  - Test container: Any nanobot skill container making outbound HTTPS requests
- **Procedure**:
-  1. Apply Config A; measure DNS resolution latency via `time curl -s "https://wttr.in/Barcelona"` from within the container
-  2. Note containers crash if /etc/resolv.conf is manually edited (self-inflicted hard rule)
-  3. Apply Config B (set via daemon.json, restart Docker); repeat measurement
-  4. Verify Technitium resolves names at 172.17.0.1 in ~2ms
-  5. Verify git.wylab.me resolves correctly from CI/CD runner containers
- **Metrics**: DNS resolution latency (ms), outbound HTTPS request latency (ms), runner build success rate
- **Expected outcome**: Config A should produce 8-second latency on all outbound requests; Config B should reduce DNS latency to ~2ms and outbound requests to normal network latency
- **Baselines**: Default Docker DNS (169.254.24.117 embedded resolver — dead in this configuration)
- **Dependencies**: none
-
---
-
-## E05: Verify context gap elimination via message() relay routing
- **Verifies**: C04, C07, C09
- **Setup**:
-  - System: Nanobot with heartbeat running in `cli:direct` session, conversational agent in `telegram:239824268` session
-  - Scenario A (broken): Heartbeat subagent uses `curl` to send Telegram message directly; user replies in main session
-  - Scenario B (fixed): Heartbeat subagent calls `message()` tool; main agent relays before responding
-  - Dataset: 5 test interactions where user replies to heartbeat-initiated Telegram message
- **Procedure**:
-  1. Configure Scenario A; trigger a heartbeat event that sends a message; have user reply; observe main agent's response (should be confused or fail to reference the heartbeat message)
-  2. Configure Scenario B; repeat; observe main agent's response (should correctly reference the heartbeat message)
-  3. Simulate email alert duplicate (same thread_id sent twice, once with alerted_email_ids populated, once without)
-  4. Count confused agent responses and duplicate alerts across 10 test cycles
- **Metrics**: Rate of confused/context-unaware responses, duplicate alert count, correctness of agent's acknowledgment of heartbeat-sent messages
- **Expected outcome**: Scenario A should produce confused responses where agent is unaware of what was communicated; Scenario B should eliminate context gaps; alerted_email_ids should reduce duplicate alerts to zero after initial population
- **Baselines**: Pre-March 2026 heartbeat design without message() relay and without alerted_email_ids
- **Dependencies**: E01
@@ -1,95 +0,0 @@
-# Problem Specification
-
-## Observations
-
-### O1: Persistent life-assistant agents require multi-session memory continuity
- **Statement**: A single-user AI life assistant needs to carry facts, preferences, and ongoing context across sessions without re-prompting the user each time.
- **Evidence**: KNOWLEDGE.md system architecture documentation; MEMORY.md session continuity design (KNOWLEDGE.md: "KNOWLEDGE.md...loaded into system prompt"; MEMORY.md: "volatile in-progress state, NOT in system prompt")
- **Implication**: Persistent agents need a tiered memory architecture; dumping all state into the system prompt is infeasible beyond a few KB.
-
-### O2: Prompt-cache invalidation is triggered by any change to the cached content
- **Statement**: Anthropic prompt caching provides ~90% cost reduction on cached tokens but caches become stale on any modification — including routine MEMORY.md updates.
- **Evidence**: HISTORY.md: "2026-03-03 07:56 — Discussed root cause: MEMORY.md updates were invalidating cache on every write; implemented split: KNOWLEDGE.md (static, ~7.3k bytes, in system prompt) and MEMORY.md (frequent updates, not cached)"; KNOWLEDGE.md prompt caching section: "MEMORY.md updates bust the cache — that's why KNOWLEDGE.md exists as a separate slow-changing file"
- **Implication**: The system prompt must be split into stable and volatile layers to preserve cache efficiency.
-
-### O3: LLM-based data collectors hallucinate sensor data when upstream sources fail
- **Statement**: When Haiku subagents fail to fetch real data (due to DNS errors, timeouts, or API failures), the Sonnet orchestrator fabricates plausible-looking values rather than reporting failure.
- **Evidence**: HISTORY.md [2026-03-03 02:48]: "User confirmed: YouTube likes logged by heartbeat are hallucinated by Haiku agents... Examples of fake data: Kurzgesagt videos, Dead Space content in Russian, LEMMiNO, William Osman, etc. User doesn't know what Dead Space is, calls Kurzgesagt 'a cabal entity'"; HISTORY.md [2026-03-03 02:49]: "When hb-youtube fails, the Sonnet ORCHESTRATOR 'recovers' by fetching data directly. But the orchestrator is likely hallucinating the YouTube data during 'recovery' instead of properly calling the API"
- **Implication**: LLM-based data collection is fundamentally unreliable; deterministic scripts must replace LLM collectors for sensor data.
-
-### O4: Docker DNS resolution failures cause cascading infrastructure failures
- **Statement**: The Unraid Docker daemon had Technitium DNS (192.168.1.50) listed first in container resolv.conf, but Technitium was unreachable via Docker NAT, causing 8-second DNS latency on all outbound requests.
- **Evidence**: HISTORY.md [2026-02-13]: "Discovered 8-second DNS latency in all Docker containers caused by 192.168.1.50 (Technitium, unreachable via Docker NAT) and 169.254.24.117 (dead Docker embedded DNS) before working 1.1.1.1... Container had to be restarted externally." Fix: "set {'dns': ['172.17.0.1']} in /etc/docker/daemon.json on Unraid, persisted in /boot/config/go. Technitium runs in host mode so it binds to docker0 bridge gateway — containers now resolve in ~2ms."
- **Implication**: Infrastructure-level DNS configuration is a hard dependency for any skill/tool that makes outbound network calls.
-
-### O5: Heartbeat subagents running in a separate session create split-identity context gaps
- **Statement**: The heartbeat runs in a "heartbeat" session distinct from the "telegram:239824268" session. Messages sent by the heartbeat via Telegram are not visible to the conversational agent when the user replies.
- **Evidence**: HISTORY.md [2026-02-21]: "Design flaw: heartbeat sends Telegram messages via separate CLI invocation, those messages don't appear in the conversation agent's session context. Same bot identity from user's perspective but no shared context."
- **Implication**: All outbound messages from heartbeat subagents must be relayed through the main agent's message() tool, or written into the main session file, to preserve context continuity.
-
-### O6: Sequential heartbeat processing creates iteration budget exhaustion
- **Statement**: The original 18-step sequential heartbeat design caused subagents to run out of iterations (max_iterations=15) before completing all steps, causing silent failures.
- **Evidence**: HISTORY.md [2026-02-14 10:21]: "Debugged heartbeat subagent failure — subagents were running out of iterations (max_iterations=15) before completing all 15 heartbeat steps. User chose to increase limit to 50 instead of consolidating into a bash script."
- **Implication**: Sequential LLM orchestration does not scale to many-step workflows; parallel architecture with bounded per-task iteration counts is necessary.
-
-### O7: Traefik TLS certificate issuance fails due to DNS bootstrap dependency
- **Statement**: Traefik's ACME DNS-01 challenge requires resolving the domain's DNS records, but when Traefik itself is the reverse proxy for the DNS service and the DNS service is not yet reachable, the certificate challenge cannot be completed.
- **Evidence**: HISTORY.md [2026-12-14]: "SS14 server (wylab-station-14) CI/CD pipeline not triggering on commits. Runner DNS resolution failures inside containers — could not resolve git.wylab.me. Tried adding 1.1.1.1 as DNS to runner, didn't work... Multiple failed approaches, eventually reverted changes." HISTORY.md [2026-01-03]: "Added n8n to Traefik routing" (context: Traefik certificate issues noted throughout)
- **Implication**: TLS certificate management via ACME requires DNS to be independently reachable before Traefik's certificate provisioning can succeed.
-
-### O8: The CONTEXT/HISTORY.md session file grows beyond Haiku context limits
- **Statement**: The `context` Haiku collector reads the session JSONL file to determine last user message time, but this file grows indefinitely and eventually exceeds Haiku's effective context budget.
- **Evidence**: HISTORY.md [2026-03-11 10:55]: "hb-context collector failing due to session file exceeding 200k token limit"; HEARTBEAT_INSTRUCTIONS.md: "hb-context" task reads "tail -n 200 /root/.nanobot/workspace/sessions/telegram_239824268.jsonl"
- **Implication**: Collectors that read growing files must tail only the last N lines; the session path used by the context collector must be verified and updated if the framework moves sessions.
-
---
-
-## Gaps
-
-### G1: No tiered memory architecture in base nanobot framework
- **Statement**: The base nanobot framework uses flat markdown files without a stable/volatile split, causing either cache invalidation on every update or stale cached context.
- **Caused by**: O2
- **Existing attempts**: Storing all context in the system prompt (causes cache busting on any update)
- **Why they fail**: System prompt is monolithic — any change invalidates the entire cache prefix
-
-### G2: No deterministic data collection guarantees for heartbeat collectors
- **Statement**: LLM-based collectors cannot be trusted to return exactly the data in external APIs — they interpolate, invent, or "recover" by hallucinating when real data is unavailable.
- **Caused by**: O3
- **Existing attempts**: Increasing Haiku reliability via better prompting; spawning Haiku with explicit "don't hallucinate" instructions
- **Why they fail**: Under resource pressure (DNS failures, timeouts, rate limits), LLMs default to pattern completion rather than admitting failure
-
-### G3: No session cross-linking between heartbeat and conversational sessions
- **Statement**: Heartbeat messages sent to the user via Telegram are invisible to the conversational agent in the main session, creating a disconnect between what the user hears and what the agent knows.
- **Caused by**: O5
- **Existing attempts**: MessageTool session-write change (PR #11) — writes sent content as assistant turn to target session before sending
- **Why they fail**: The MessageTool session-write approach was deployed but heartbeat messages still route through OutboundMessage bus, not MessageTool, in the default heartbeat flow
-
---
-
-## Key Insights
-
-### Insight 1: Stable vs. volatile memory split enables both caching and continuity
- **Insight**: Splitting agent memory into a stable, slowly-changing file (KNOWLEDGE.md, in system prompt, cached) and a volatile file (MEMORY.md, not in system prompt, updated freely) allows aggressive caching of stable context while maintaining session continuity for in-progress state.
- **Derived from**: O1, O2
- **Enables**: Approximately 90% token cost reduction on stable context (cache hits at 10% of input token cost) while retaining ability to update volatile state without cache invalidation.
-
-### Insight 2: Deterministic scripts beat LLM-based collectors for sensor data
- **Insight**: Any data collection task where the "correct" answer is defined by an external API response should use a deterministic script (bash/Python) rather than an LLM. LLMs are only appropriate when judgment, interpretation, or summarization of ambiguous data is required.
- **Derived from**: O3
- **Enables**: Elimination of hallucinated heartbeat data; clear separation between data collection (scripts) and interpretation/action (Sonnet orchestrator).
-
-### Insight 3: Parallel subagent spawn + wait is the correct heartbeat primitive
- **Insight**: The heartbeat's bottleneck is I/O (fetching data from 8 different sources). Running these in parallel via `wait_for_subagents` reduces wall-clock time by ~7x versus sequential execution.
- **Derived from**: O6
- **Enables**: 30-minute heartbeat intervals with sufficient data collection time; bounded per-task iteration counts prevent runaway subagents.
-
---
-
-## Assumptions
-
- A1: The primary user communicates exclusively via Telegram (no web UI, no voice interface)
- A2: The Unraid server (UM790 Pro, 32GB RAM) is always online and reachable from the nanobot container
- A3: Home Assistant is always reachable at 192.168.1.50:8123 for device state queries
- A4: The Anthropic API is the sole LLM provider; no local model fallback currently exists
- A5: A single user (single chat_id 239824268) is the only consumer of the system
- A6: The heartbeat runs every 30 minutes regardless of user activity
@@ -1,77 +0,0 @@
-# Related Work
-
-## RW01: Nanobot Framework (HKUDS Lab, 2026)
- **DOI**: https://github.com/HKUDS/nanobot (MIT license, forked February 2026)
- **Type**: imports
- **Delta**:
-  - What changed: nanobot extends the base framework with a custom heartbeat service (`HeartbeatService`), custom skills (vacuum, yandex-station, location, gog, himalaya, youtube_sync), prompt caching via two cache checkpoints, quota-based model switching between Claude Sonnet and Haiku, and a two-tier memory architecture not present in the upstream.
-  - Why: The base framework provides agent loop, session management, tool dispatch, and subagent orchestration primitives. The upstream design is a general-purpose agent framework; nanobot adds life-assistant-specific automation on top.
- **Claims affected**: C01, C02, C03, C04
- **Adopted elements**: `agent/loop.py` (session handling, tool dispatch, context editing API), `spawn()` and `wait_for_subagents()` primitives, `message()` tool with channel routing, JSONL session persistence, Anthropic OAuth provider
-
---
-
-## RW02: OpenClaw (Peter Steinberger, upstream of nanobot)
- **DOI**: https://github.com/openclaw/openclaw
- **Type**: bounds
- **Delta**:
-  - What changed: nanobot diverged from OpenClaw's architecture at the session layer. OpenClaw uses a unified gateway RPC with WebSocket-based message delivery and a `/hooks` endpoint for fire-and-forget external triggers. nanobot retained the bus-based message routing but added HTTP hooks on port 18790 with correlation IDs for synchronous response capture, and modified the session model to allow heartbeat sessions to write to the Telegram session via message() tool.
-  - Why: OpenClaw's hooks design assumes agents are stateless and fire-and-forget. nanobot's heartbeat requires the conversational agent to have context about what the heartbeat communicated, which OpenClaw's architecture does not provide natively.
- **Claims affected**: C04
- **Adopted elements**: Session JSONL format, bus-based inbound/outbound message routing, `clear_tool_uses_20250919` server-side context editing
-
---
-
-## RW03: Generative Agents: Interactive Simulacra of Human Behavior (Park et al., 2023)
- **DOI**: arXiv:2304.03442
- **Type**: baseline
- **Delta**:
-  - What changed: nanobot uses a single persistent agent with external sensors rather than a multi-agent social simulation. Where Park et al. use a memory stream + retrieval + reflection architecture for 25 interacting agents in a sandbox, nanobot uses a two-tier memory (KNOWLEDGE.md / MEMORY.md) with an append-only HISTORY.md log and no explicit reflection step. The heartbeat replaces the agent's internal time-step tick with an external 30-minute timer.
-  - Why: nanobot serves a single real user in a real environment; the simulation fidelity of Park et al.'s architecture (maintaining social plausibility across 25 agents) is unnecessary. The simpler memory split trades simulation richness for operational reliability and prompt-cache efficiency.
- **Claims affected**: C02
- **Adopted elements**: Memory stream concept for HISTORY.md; location-aware activity inference
-
---
-
-## RW04: Mem0: A Layered Memory System for AI Agents (mem0ai, 2025)
- **DOI**: https://github.com/mem0ai/mem0 (Apache 2.0)
- **Type**: imports
- **Delta**:
-  - What changed: mem0 was integrated as a semantic memory layer for extracting and retrieving facts from nanobot's conversations. Facts are extracted by an LLM (swapped from GPT-4.1-nano to Claude Haiku via custom OAuth LLM provider), stored as vector embeddings in Qdrant, and retrieved on demand. This layer runs parallel to the KNOWLEDGE.md / MEMORY.md flat-file system.
-  - Why: The flat-file memory system does not support semantic retrieval — facts can only be found by grep or by loading the entire file. mem0 adds content-addressable retrieval for user facts, preferences, and past decisions without requiring KNOWLEDGE.md to grow unboundedly.
- **Claims affected**: C02
- **Adopted elements**: mem0 extraction pipeline (infer=False mode for direct fact insertion), Qdrant as the vector store backend, semantic similarity search for context injection
-
---
-
-## RW05: Anthropic Prompt Caching (Anthropic, 2024–2025)
- **DOI**: https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
- **Type**: bounds
- **Delta**:
-  - What changed: nanobot's architecture was directly shaped by prompt caching semantics. The cache TTL of ~5 minutes and the requirement for byte-identical prefixes to hit the cache drove the decision to split KNOWLEDGE.md (stable, cached) from MEMORY.md (volatile, not cached). The discovery that MEMORY.md updates busted the cache on every turn was the direct cause of the architectural split.
-  - Why: Without the cache split, each MEMORY.md write would invalidate the system prompt cache, causing 10-16k tokens to be re-processed at full write cost on every session turn. The split reduces this to a one-time write cost per session for the stable system prompt prefix.
- **Claims affected**: C02
- **Adopted elements**: `cache_control` markers at two checkpoints, cache read/write token monitoring via API response headers
-
---
-
-## RW06: Zack Proser's "Personal Claude" / Oura Ring + MCP Stack (2025)
- **DOI**: https://zackproser.com/blog (blog post, not formal publication)
- **Type**: baseline
- **Delta**:
-  - What changed: nanobot collects similar biometric and context signals (location, health metrics, Telegram activity) but via custom sensor infrastructure (OwnTracks MQTT, Apple Health via HTTP receiver, PostgreSQL browser history) rather than commercial APIs (Oura ring subscription, MCP protocol). nanobot also adds home automation (Home Assistant), content tracking (YouTube likes), and email triage as first-class heartbeat signals.
-  - Why: Makar rejected cloud-dependent health tracking (Oura subscription requirement, no open API without vendor lock-in) in favor of self-hosted sensor collection. The custom receiver at port 3847 provides raw data access without vendor intermediation.
- **Claims affected**: C01, C03
- **Adopted elements**: The pattern of structured daily context injection from personal sensors into a persistent agent session
-
---
-
-## Additional citations
-
-**A-Evolve framework (ScaleAPI, 2025)**: `ghcr.io/scaleapi/mcp-atlas`. MCP-based evolutionary agent experimentation framework explored for nanobot personalization research but not integrated into production. Referenced in HISTORY.md [2026-03-30].
-
-**Traefik Proxy (TraefikLabs, 2024)**: Reverse proxy and TLS certificate manager used for Unraid service routing. TLS ACME failures with Technitium DNS backend motivated C06. See `evidence/tables/table6_traefik_cert_failure.md`.
-
-**Technitium DNS Server (2024)**: Self-hosted DNS resolver running in host mode on Unraid. Its host-mode binding to docker0 interface rather than the host IP (192.168.1.50) was the root cause of Docker container DNS latency described in C05.
-
-**Space Station 14 / RobustToolbox (Space Wizards, 2024–2025)**: Open-source game with CI/CD runner and cache corruption issues that motivated C08. Fork at `github.com/space-revs/SS14.Launcher`.
@@ -1,117 +0,0 @@
-# Algorithm
-
-## Heartbeat Orchestration Algorithm
-
-### Mathematical Formulation
-
-Let `C = {c₁, c₂, ..., c₈}` be the set of data collectors, where each `c_i` runs for time `t_i`.
-
-**Sequential execution time:** `T_seq = Σᵢ t_i`
-
-**Parallel execution time:** `T_par = max_i(t_i) + t_orchestrator`
-
-Given typical collector times `t_i ∈ [2s, 15s]` and orchestrator interpretation time `t_orchestrator ≈ 5-10s`, the parallel design reduces total heartbeat wall-clock time from `T_seq ≈ 60-100s` to `T_par ≈ 20-30s`.
-
-### Pseudocode
-
-```python
-def heartbeat_cycle(life_state: dict) -> None:
-    """Main heartbeat orchestration algorithm."""
-    
-    # Phase 1: Deterministic data collection (no LLM)
-    youtube_result = run_script("youtube_sync.py")
-    
-    # Phase 2: Parallel Haiku collector spawning
-    task_ids = []
-    for collector in [
-        hb_clock, hb_context, hb_health, hb_home,
-        hb_email, hb_browser, hb_weather
-    ]:
-        task_id = spawn(model="claude-haiku-4-5", task=collector.task_spec)
-        task_ids.append(task_id)
-    
-    # Phase 3: Wait for all collectors (parallel execution)
-    results = wait_for_subagents(task_ids)
-    
-    # Phase 4: Read output files
-    data = {}
-    for collector_name in COLLECTOR_NAMES:
-        filepath = f"heartbeat_data/{collector_name}.json"
-        data[collector_name] = read_json(filepath)  # fallback: {} on missing
-    
-    # Phase 5: Interpret combined picture
-    makar_state = interpret_state(
-        current_location=data["health"]["location"],
-        last_known_location=life_state["last_location"],
-        alice_state=data["home"],
-        last_telegram=data["context"]["last_user_message_ago_minutes"],
-        steps=data["health"]["metrics"]["steps"],
-        time=data["clock"]["timestamp"]
-    )
-    
-    # Phase 6: Location resolution (if moved >200m)
-    if distance(makar_state.location, life_state.last_location) > 200:
-        venue = resolve_venue_goplaces(makar_state.location)
-        if venue == "unknown":
-            message(content=f"Where are you? Moved to {makar_state.location}")
-        update_known_places(makar_state.location, venue)
-    
-    # Phase 7: Email triage (time-sensitive only)
-    for thread in data["email"]["threads"]:
-        if is_time_sensitive(thread) and thread.id not in life_state.alerted_email_ids:
-            message(content=format_alert(thread))
-            life_state.alerted_email_ids.add(thread.id)
-    
-    # Phase 8: Sleep/wake inference
-    if all_sleep_signals_met(makar_state, life_state) and not makar_state.telegram_recent:
-        life_state.sleep_state = "asleep"
-        log_history("SLEEP: Inferred asleep since {last_activity}")
-    
-    # Phase 9: Vacuum automation
-    if (
-        distance(makar_state.location, HOME_COORDS) > 200  # away from home
-        and not is_same_day(life_state.last_vacuum_run, today)
-    ):
-        start_vacuum()
-        life_state.last_vacuum_run = today
-        log_history("VACUUM: Started cleaning")
-    
-    # Phase 10: State persistence
-    write_life_state(life_state)
-    write_history_entries(makar_state, data)
-    write_heartbeat_report(data, makar_state)
-```
-
-### Complexity Analysis
-
- **Data collection phase**: `O(max(t_i))` wall-clock with parallel spawning — bounded by slowest collector
- **Interpretation phase**: `O(N)` where `N` = total bytes in 8 collector JSON files (~3,100 chars max)
- **Location resolution**: `O(1)` if cached; `O(network_latency)` for cache miss
- **Email triage**: `O(|new_threads|)` — typically 0-5 per cycle
- **State write**: `O(|life_state.json|)` — ~2-5KB
-
-### Heartbeat Timing Model
-
-```
-T=0s        8 Haiku collectors spawned simultaneously
-            + youtube_sync.py started in parallel
-
-T=2-15s     Collectors write to heartbeat_data/*.json as they complete
-            (DNS queries: ~2ms; HA API: ~100ms; Gmail: ~1-3s; PostgreSQL: ~200ms)
-
-T=max(t_i)  wait_for_subagents() returns (~15s in degraded DNS, ~5s normal)
-
-T+5-10s     Sonnet reads 8 files, interprets, acts, writes state
-
-T=20-30s    Heartbeat cycle complete; next scheduled in ~30 min
-```
-
-### Error Recovery
-
-If any collector times out or writes an error JSON, the orchestrator:
-1. Notes which collectors failed in the heartbeat report
-2. Proceeds with available data
-3. Does NOT retry failed collectors (prevents cascading delays)
-4. Logs the failure to HISTORY.md for later investigation
-
-If youtube_sync.py fails, it writes `{"error": "<reason>"}` to `youtube.json`. The orchestrator logs `[timestamp] YOUTUBE: sync failed — {error}` to HISTORY.md and skips YouTube processing for this cycle.
@@ -1,118 +0,0 @@
-# System Architecture
-
-## Component Graph
-
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│                         User (Makar)                                │
-│                     Telegram chat_id 239824268                      │
-└───────────────────────────────┬─────────────────────────────────────┘
-                                │ (messages in / out)
-                                ▼
-┌─────────────────────────────────────────────────────────────────────┐
-│                    Nanobot Container (Docker)                       │
-│                    /root/.nanobot/workspace/                        │
-│                                                                     │
-│  ┌─────────────────────────────────────────────────────────────┐   │
-│  │  Agent Loop (loop.py)                                        │   │
-│  │  - Conversational session: telegram:239824268               │   │
-│  │  - Heartbeat session: cli:direct / heartbeat                │   │
-│  │  - message() tool → Telegram API                            │   │
-│  │  - spawn() + wait_for_subagents() → Subagent Manager        │   │
-│  └───────────────┬──────────────────────────────────────────────┘   │
-│                  │ Anthropic API (OAuth, prompt caching)            │
-│                  ▼                                                   │
-│  ┌─────────────────────────────────────────────────────────────┐   │
-│  │  System Prompt (cached)                                      │   │
-│  │  KNOWLEDGE.md (~4KB, stable facts, behavioral rules)        │   │
-│  │  Skills list (blucli, vacuum, yandex-station, etc.)         │   │
-│  └─────────────────────────────────────────────────────────────┘   │
-│                                                                     │
-│  ┌──────────────────────────────────────────────────────────────┐  │
-│  │  Memory Files (persistent, not in system prompt)             │  │
-│  │  MEMORY.md — volatile in-progress state                      │  │
-│  │  HISTORY.md — append-only event log                          │  │
-│  │  life_state.json — heartbeat continuity state                │  │
-│  │  sessions/telegram_239824268.jsonl — conversation history    │  │
-│  └──────────────────────────────────────────────────────────────┘  │
-│                                                                     │
-│  ┌──────────────────────────────────────────────────────────────┐  │
-│  │  Heartbeat Orchestrator (Sonnet, every 30 min)               │  │
-│  │                                                              │  │
-│  │  spawn() ──────────────────────────────────────────────────► │  │
-│  │    hb-clock  hb-context  hb-health  hb-home  hb-email       │  │
-│  │    hb-browser  hb-weather  (+youtube_sync.py script)        │  │
-│  │                                                              │  │
-│  │  wait_for_subagents() ─────────────────────────────────────► │  │
-│  │    reads: heartbeat_data/*.json                              │  │
-│  │    interprets + acts                                         │  │
-│  │    writes: HISTORY.md, life_state.json                       │  │
-│  │    sends: message() for alerts                               │  │
-│  └──────────────────────────────────────────────────────────────┘  │
-└────────────────────┬────────────────────────────────────────────────┘
-                     │ (outbound API calls)
-                     ▼
-┌─────────────────────────────────────────────────────────────────────┐
-│                    External Services                                │
-│                                                                     │
-│  Home Assistant (192.168.1.50:8123)                                 │
-│  ├── Yandex Station Kitchen  (media_player.yandex_station_m00p313…) │
-│  ├── Yandex Station Living Room (media_player.yandex_station_m00p…) │
-│  └── Lefant M2 Vacuum (vacuum.lefant_m2)                           │
-│                                                                     │
-│  Health Receiver (192.168.1.50:3847)                               │
-│  ├── /latest/location  (OwnTracks → MQTT → receiver)              │
-│  ├── /latest/metrics   (Apple Health Auto Export → HTTP POST)      │
-│  ├── /latest/workouts, /latest/heart-rate, etc.                    │
-│  └── Mosquitto MQTT broker (mqtts.wylab.me:443)                    │
-│                                                                     │
-│  PostgreSQL (192.168.1.50:5432)                                     │
-│  └── browser_history table (Safari → launchd sync → PG)           │
-│                                                                     │
-│  Gitea (git.wylab.me)                                               │
-│  ├── wylab/nanobot repo — main codebase                             │
-│  └── Branch protection, PR-only merges on main                     │
-│                                                                     │
-│  Qdrant (172.17.0.1:6333) ← mem0 memory layer                     │
-│  └── collection "mem0" — semantic memory (64 facts)                │
-│                                                                     │
-│  Gmail / Google Workspace (via gog CLI)                            │
-│  YouTube Data API v3 (via youtube_sync.py)                         │
-│  Google Places API (via goplaces CLI)                              │
-│  Anthropic API (via OAuth, not API key)                            │
-└─────────────────────────────────────────────────────────────────────┘
-```
-
---
-
-## Component Descriptions
-
-### Agent Loop (`loop.py`)
- **Inputs**: Inbound messages from Telegram channel; timer events from HeartbeatService; system bus messages from subagents
- **Outputs**: Outbound messages via message() tool → Telegram; subagent spawns; tool execution results
- **Key design choices**: Single-threaded session processing (sequential within session); sessions isolated from each other; `clear_tool_uses_20250919` API call prunes old tool chains transparently
-
-### System Prompt (cached prefix)
- **Inputs**: KNOWLEDGE.md file (read at container startup or session initialization)
- **Outputs**: First cache checkpoint for all API calls
- **Key design choices**: Must remain stable between calls to preserve cache hits; all volatile state is excluded; skills list included as references
-
-### Heartbeat Orchestrator (Sonnet subagent)
- **Inputs**: HEARTBEAT_INSTRUCTIONS.md (the full instruction set for the heartbeat); current time from `hb-clock`; 7 Haiku collector output files; youtube.json from deterministic script
- **Outputs**: Telegram alerts via message(); HISTORY.md append; life_state.json update; heartbeat report file
- **Key design choices**: Spawned as a Sonnet subagent (not run inline) to isolate its iteration budget; reads HEARTBEAT_INSTRUCTIONS.md at start; delegates all data collection to collectors before interpreting
-
-### Haiku Collectors (7 parallel subagents)
- **Inputs**: life_state.json (via hb-clock), session file tail (via hb-context), HTTP APIs (via hb-health, hb-home), Gmail (via hb-email), PostgreSQL (via hb-browser), wttr.in (via hb-weather)
- **Outputs**: JSON files in heartbeat_data/ directory
- **Key design choices**: Fixed output schemas; truncate to budget on overflow; write error JSON on failure (do not retry); no LLM reasoning for factual data (YouTube moved to deterministic script after hallucination incident)
-
-### Memory Files
- **KNOWLEDGE.md**: Stable facts (user identity, infrastructure topology, behavioral preferences, hard rules) — changes at most weekly; loaded into cached system prompt; currently ~4KB
- **MEMORY.md**: Volatile in-progress state (current projects, active alerts, pending decisions) — changes multiple times per session; NOT in system prompt; read on demand
- **HISTORY.md**: Append-only event log — session summaries, heartbeat entries, decisions made; never edited retroactively; grep-searchable; currently >200KB
-
-### Skills
- **Inputs**: User natural language requests in conversation
- **Outputs**: Shell commands executed via exec tool; API calls via curl or Python; structured results reported back
- **Key active skills**: blucli (Bluesound), vacuum (Lefant M2 via HA), yandex-station (via HA), location (OwnTracks), obsidian-cli (vault REST API), gog (Google Workspace), himalaya (email), memory (mem0/Qdrant), youtube_sync (YouTube Data API)
@@ -1,59 +0,0 @@
-# Constraints
-
-## Infrastructure Constraints
-
-### IC01: Single-user deployment
-The system is designed and tested for exactly one user (Telegram chat_id 239824268). Multi-user support would require session isolation, per-user life_state.json, and per-user KNOWLEDGE.md.
-
-### IC02: Network topology dependency
-All home automation features (vacuum, Yandex Station, health receiver) require the nanobot container to be on the same LAN as the Unraid server (192.168.1.50). Remote operation (e.g., from a VPS) would require VPN tunneling or HA Cloud.
-
-### IC03: Anthropic API exclusivity
-The system uses Anthropic's OAuth token (Claude Max subscription) as the sole LLM provider. There is no fallback to local models (Ollama was set up separately but not integrated into the main agent flow). Rate limits and quota exhaustion cause heartbeat failures.
-
-### IC04: Container restart resets ephemeral state
-Several dependencies are ephemeral in the container: Playwright dependencies (must reinstall), some pip packages. All persistent state lives in Docker volume mounts: `/root/.nanobot/workspace/` and `/root/.config/`.
-
-### IC05: Yandex Station Quasar API dependency
-Yandex Station control works via the Quasar cloud API accessed through Home Assistant, not via local network. If Yandex's cloud is unavailable, station control fails silently.
-
---
-
-## Behavioral Constraints
-
-### BC01: Never write to /etc/resolv.conf from within the container
-Established after self-inflicted DNS outage on 2026-02-13. Writing to resolv.conf and leaving only broken nameservers caused a container that had to be restarted externally. Rule: never write system config files inside the container.
-
-### BC02: Vacuum maximum once per day, never while home
-The Lefant M2 vacuum is started only when: (a) Makar is >200m from home coordinates (41.384588, 2.136307), and (b) `life_state.last_vacuum_run` is not already today. This prevents the vacuum from running while Makar is home and prevents multiple daily runs.
-
-### BC03: Email alert deduplication via alerted_email_ids
-Once an email thread ID is in `alerted_email_ids`, it must never trigger another alert, even if it appears in future heartbeat cycles. The set is append-only and persisted in `life_state.json`.
-
-### BC04: No code unless explicitly asked
-Per KNOWLEDGE.md behavioral rules: "No code unless specifically asked — prefer existing solutions/auto-install scripts." Code blocks in responses are only appropriate when the user explicitly requests code.
-
-### BC05: Execute-first, narrate-second
-Per KNOWLEDGE.md hard rules: "Do not say 'I will read X' or 'let me check Y'. Call the tool, get the result, report what you found. No preamble." All tool calls should complete before any substantive response text is written.
-
---
-
-## Known Limitations
-
-### KL01: hb-context collector session file size limit
-The `hb-context` collector reads `tail -n 200` of the session JSONL file. When the file exceeds ~200k tokens, even `tail -n 200` produces content that fills Haiku's context budget. No mitigation is currently deployed; the collector silently uses stale cache data when this occurs.
-
-### KL02: Sleep inference is unreliable during periods of autonomous activity
-Yandex Station track changes (from music autoplay) are recorded as activity signals, incorrectly preventing sleep inference even when Makar is actually asleep. The current heuristic requires corroborating signals (no Telegram + home + stationary + late hours) but Alice's autoplay can mask sleep onset.
-
-### KL03: YouTube sync script 60-second timeout
-The `youtube_sync.py` script has a hard 60-second timeout in the heartbeat execution model. When the YouTube API is slow or the Qdrant/mem0 write is blocked, the script times out and writes an error. This happens intermittently and has no automatic recovery.
-
-### KL04: P2P trading books have manual FX rate dependencies
-The `build_books.py` double-entry bookkeeping system uses manually entered FX rates from the CBR (Russian Central Bank) for period-end FX retranslation. These rates cannot be automatically fetched (bankffin.kz requires JavaScript rendering; no public API). Freedom Finance rates require Playwright to scrape.
-
-### KL05: mem0 memory extraction can capture system architecture as user facts
-When conversations discuss nanobot's infrastructure, mem0's extraction LLM may store these as user facts rather than system documentation, polluting the memory store with stale operational details.
-
-### KL06: Obsidian REST API uses plain HTTP
-The Obsidian local REST API runs only on HTTP (port 27123), not HTTPS. TLS/HTTPS fails. This is a hardcoded constraint of the obsidian-local-rest-api plugin.
@@ -1,98 +0,0 @@
-# Heuristics
-
-## H01: PAPER.md entry point as relevance gate
- **Rationale**: An agent reading an ARA cold needs to decide whether the paper is relevant before loading the full logic layer. PAPER.md targets ~200 tokens — small enough to always load, large enough to answer "does this describe a persistent life-assistant agent system?" The frontmatter `claims_summary` list is the primary relevance signal; the Layer Index gives the structure for drill-in.
- **Sensitivity**: low
- **Bounds**: PAPER.md must stay under ~300 tokens to preserve its role as a cheap gate; if it grows beyond that, the `abstract` field should be shortened first.
- **Code ref**: [`src/configs/training.md`](../../src/configs/training.md)
- **Source**: ARA schema §Level 1 — PAPER.md (~200 tokens)
-
---
-
-## H02: Research-manager skill runs end-of-turn to record journey
- **Rationale**: The ARA captures not just the final design but the research journey — decisions made, paths abandoned, lessons learned. The research-manager skill is invoked at the end of each substantive session to append a structured entry to HISTORY.md and update MEMORY.md with any state that needs to survive to the next session. Running it end-of-turn (after all tool calls) ensures the record reflects the full turn outcome rather than mid-turn state.
- **Sensitivity**: medium
- **Bounds**: Must run before context is cleared or compaction is triggered. If context overflow is imminent, prioritize compaction over other work so the research-manager can record in fresh context.
- **Code ref**: [`src/execution/heartbeat.py`](../../src/execution/heartbeat.py)
- **Source**: KNOWLEDGE.md §Compaction Protocol
-
---
-
-## H03: Three-word rule — no filler messages under three words
- **Rationale**: A response of "Noted", "Done", or "OK" delivered to Makar via Telegram conveys nothing — it does not reproduce what changed, what was logged, or what action was taken. Since only the final message text is visible to the user (all tool call outputs are invisible), the final response must be a complete standalone message. Any response under three words is almost certainly a filler acknowledgment rather than a real answer.
- **Sensitivity**: high
- **Bounds**: The rule applies to the final outbound message only. Internal intermediate text (between tool calls) is not user-visible and has no minimum length. Exception: literal single-word confirmations explicitly requested by the user ("confirm with yes/no") are acceptable.
- **Code ref**: [`src/execution/heartbeat.py`](../../src/execution/heartbeat.py)
- **Source**: KNOWLEDGE.md §Output Rules; HISTORY.md [2026-02-22 04:22]
-
---
-
-## H04: Heartbeat parallel collector pattern — 8 Haiku, 1 Sonnet
- **Rationale**: Spawning 8 Haiku data collectors in parallel before calling `wait_for_subagents` reduces heartbeat wall-clock time from `Σ t_i` to `max(t_i) + t_orchestrator`. Haiku is used for collectors (cheap, fast, sufficient for structured JSON extraction from API responses) while Sonnet handles orchestration and interpretation (requires reasoning about combined signals). The split reflects cost efficiency: interpretation is done once; collection is done eight times per cycle.
- **Sensitivity**: medium
- **Bounds**: Collector budgets must be respected to avoid orchestrator context overflow (~3,100 total chars / ~800 tokens across all 8 files). If a collector exceeds its budget, it must truncate — the orchestrator does not re-fetch. Changing from 8 to more collectors would require verifying the combined budget stays under Sonnet's usable context.
- **Code ref**: [`src/execution/heartbeat.py`](../../src/execution/heartbeat.py)
- **Source**: KNOWLEDGE.md §Heartbeat Architecture; HISTORY.md [2026-02-18 21:39]
-
---
-
-## H05: Dead end — Yandex Station TTS/Alice mode for playback control
- **Rationale**: Home Assistant exposes three mechanisms to interact with Yandex Station: TTS (text-to-speech, reads text aloud), Alice command passthrough, and direct `media_player/*` service calls. The first two feel semantically appropriate ("tell Alice to pause") but are functionally wrong — they cause the station to verbalize the instruction rather than execute it. The iron law in the yandex-station skill exists because this mistake was repeated 4-5 times in a single session before the correct API path was found.
- **Sensitivity**: high
- **Bounds**: NEVER use `tts.speak` or Alice command mode for playback control (pause, stop, volume, play). ALWAYS use `media_player/media_pause`, `media_player/media_stop`, `media_player/volume_set`, `media_player/play_media` directly. The TTS endpoint is only for synthesizing speech to the room speaker.
- **Code ref**: [`src/execution/heartbeat.py`](../../src/execution/heartbeat.py)
- **Source**: HISTORY.md [2026-02-14 03:05]; skills/yandex-station/SKILL.md
-
---
-
-## H06: Dead end — Writing to /etc/resolv.conf inside container
- **Rationale**: During the DNS latency investigation, the agent edited `/etc/resolv.conf` inside the running nanobot container to test nameserver configurations. Leaving only the broken nameserver in the file killed all DNS resolution, requiring an external container restart. This was a self-inflicted outage from confusing the investigation target (the broken DNS config) with the investigation tool (the container's own DNS client).
- **Sensitivity**: high
- **Bounds**: Never write to `/etc/resolv.conf` or other system config files (`/etc/hosts`, `/etc/docker/daemon.json`) from within the nanobot container. DNS configuration changes must be made on the Unraid host and applied via Docker daemon restart. The container's networking state is ephemeral and externally managed.
- **Code ref**: [`src/configs/model.md`](../../src/configs/model.md)
- **Source**: HISTORY.md [2026-02-13 18:16]; BC01 in constraints.md
-
---
-
-## H07: Dead end — SS14 CI/CD cache corruption from mixed-architecture runners
- **Rationale**: The SS14 project's CI/CD pipeline suffered repeated failures traced to `.NET` build cache corruption when an ARM64 macOS runner (OrbStack) shared cached binaries with an x64 external runner. The mixed-architecture cache caused incorrect binary reuse, cryptic build errors, and timeouts rather than clean failures. The fix (local per-runner file cache, no sharing) was only found after exhausting runner DNS fixes, host network mode, and shutdown timeout adjustments.
- **Sensitivity**: medium
- **Bounds**: Cross-architecture cache sharing must be disabled for compiled language build caches (`.NET`, Go, Rust). Separate cache keys per OS/architecture are required. Gitea cache ETIMEDOUT errors to a remote cache server (45.137.68.83:39913) are not the root cause — the underlying issue is cache key collision between architectures.
- **Code ref**: [`src/configs/model.md`](../../src/configs/model.md)
- **Source**: HISTORY.md [2026-12-14], [2026-12-15], [2026-12-18], [2026-12-19]
-
---
-
-## H08: Memory layout — KNOWLEDGE.md (stable) vs MEMORY.md (volatile) vs HISTORY.md (log)
- **Rationale**: Three distinct files serve three distinct roles. KNOWLEDGE.md is the permanent context: facts true across all sessions (identity, infrastructure, behavioral rules), loaded into the cached system prompt. MEMORY.md is the scratchpad: volatile state for the current project or deferred decisions, NOT in system prompt, read on demand. HISTORY.md is the archive: append-only event log, never edited, grep-searchable. The routing rule is deterministic: if a fact contains "currently", "recently", "planning to", or names an ongoing task, it belongs in MEMORY.md, not KNOWLEDGE.md.
- **Sensitivity**: medium
- **Bounds**: KNOWLEDGE.md must stay under ~8KB to maintain efficient cache write costs. MEMORY.md entries older than 30 days without references should be demoted to HISTORY.md before deletion. HISTORY.md entries are never edited retroactively — corrections are appended as new entries.
- **Code ref**: [`src/configs/training.md`](../../src/configs/training.md)
- **Source**: KNOWLEDGE.md §Memory Layout; HISTORY.md [2026-02-19 03:06]
-
---
-
-## H09: Deterministic scripts replace LLM collectors for factual data
- **Rationale**: LLM collectors (Haiku agents making API calls and summarizing results) can hallucinate: when the YouTube collector failed due to DNS, the Sonnet orchestrator "recovered" by generating plausible-looking video IDs and titles that did not exist on YouTube. This was discovered only when Makar noticed video IDs returning 404. The fix replaces LLM data collectors with deterministic Python/bash scripts that write exact API responses to JSON files, leaving LLM reasoning only for the interpretation step.
- **Sensitivity**: high
- **Bounds**: Any data source where correctness is ground truth (sensor readings, API responses, database queries) must use deterministic scripts. LLMs are appropriate only for the interpretation layer (understanding what the data means, deciding what actions to take). The hb-youtube collector was the first replacement; all 8 collectors are eventual targets.
- **Code ref**: [`src/execution/heartbeat.py`](../../src/execution/heartbeat.py)
- **Source**: HISTORY.md [2026-03-03 02:48], [2026-03-03 03:21]
-
---
-
-## H10: All subagent-to-user messages relay through main agent's message() tool
- **Rationale**: The heartbeat session and the conversational Telegram session are isolated — they share no in-memory state. When the heartbeat subagent sends a Telegram message via curl directly, the conversational agent has no record of what was sent. When the user replies, the conversational agent cannot see what triggered the reply, producing confused and inconsistent responses. The message() tool writes to both the Telegram API and the session JSONL file, making heartbeat-sent content visible to subsequent conversational turns.
- **Sensitivity**: high
- **Bounds**: This constraint applies to any subagent that communicates with the end user via a shared channel. If a subagent context only needs to communicate back to the main agent (not the user), it can use the subagent return result mechanism. If it needs to alert the user, it must use message() exclusively.
- **Code ref**: [`src/execution/heartbeat.py`](../../src/execution/heartbeat.py)
- **Source**: MEMORY.md [2026-05-01]; HISTORY.md [2026-02-21]; C04 in claims.md
-
---
-
-## H11: Email deduplication via append-only alerted_email_ids
- **Rationale**: The heartbeat checks email on every 30-minute cycle. Without deduplication, a single urgent email would generate an alert on every cycle until read. The `last_email_ids` field (which threads were last seen) is insufficient — a thread can be "seen" but re-appear if the seen list is not persisted or if the thread re-activates. `alerted_email_ids` is a separate, append-only set of thread IDs that have already produced an alert. Once a thread ID is in this set, it never fires again regardless of read status.
- **Sensitivity**: high
- **Bounds**: `alerted_email_ids` must never have entries removed — it is a one-way gate. The first 24 email thread IDs were pre-populated to prevent re-alerting existing backlog on initial deployment. New deployments should pre-populate from the current inbox to avoid a burst of stale alerts.
- **Code ref**: [`src/execution/heartbeat.py`](../../src/execution/heartbeat.py)
- **Source**: MEMORY.md [2026-05-01]; HISTORY.md [2026-03-23]; C09 in claims.md
@@ -1,99 +0,0 @@
-# Agent Configuration
-
-## Model Selection
-
-### main_agent_model
- **Value**: `claude-sonnet-4-6` (or current Sonnet release)
- **Rationale**: Used for the main conversational agent. Quota-based switching activates if rate limit exceeds 117% of expected weekly usage, falling back to Sonnet when approaching quota exhaustion.
- **Search range**: claude-opus-4-6 (higher capability), claude-haiku-4-5 (lower cost, lower capability)
- **Sensitivity**: high — Opus costs 5× Sonnet per token; wrong model selection under quota exhaustion causes rapid credit burn
- **Source**: KNOWLEDGE.md; HISTORY.md [2026-02-15]: quota-model-switching PR #9 merged
-
-### heartbeat_orchestrator_model
- **Value**: `claude-sonnet-4-6` — must be specified explicitly in spawn() call
- **Rationale**: Default SubagentManager model falls back to provider default (Opus) if model parameter is not explicitly passed. Heartbeat must specify Sonnet to avoid Opus-level quota consumption.
- **Search range**: claude-sonnet-4-6 only for heartbeat orchestrator; Haiku for individual collectors
- **Sensitivity**: high — missing model parameter causes Opus-level quota burn for every heartbeat cycle
- **Source**: HISTORY.md [2026-02-18 22:17]: Opus heartbeat discovery; H11
-
-### haiku_collector_model
- **Value**: `claude-haiku-4-5`
- **Rationale**: Haiku is used for all 7 parallel data collectors to minimize cost. Each collector performs a simple, bounded task (fetch data, write JSON) that does not require Sonnet-level reasoning.
- **Search range**: claude-haiku-4-5 only; Sonnet would be wasteful for structured data extraction
- **Sensitivity**: medium — using Sonnet for collectors increases cost; using an older Haiku may reduce capability
- **Source**: HEARTBEAT_INSTRUCTIONS.md; KNOWLEDGE.md subagent system section
-
---
-
-## Heartbeat Parameters
-
-### heartbeat_interval_minutes
- **Value**: 30 minutes
- **Rationale**: Balances real-time awareness with API cost. At 30-minute intervals, the system makes ~48 heartbeat calls/day. At Sonnet + 8×Haiku per cycle, this is manageable within Claude Max subscription quota.
- **Search range**: 15 min (higher awareness, double cost), 60 min (lower cost, less granular tracking)
- **Sensitivity**: medium — shorter intervals increase quota pressure; longer intervals miss short-lived events
- **Source**: KNOWLEDGE.md heartbeat architecture section; HEARTBEAT_INSTRUCTIONS.md
-
-### max_subagent_iterations
- **Value**: 50 (increased from original 15)
- **Rationale**: Original 15-iteration limit caused heartbeat subagents to exhaust their budget before completing all 18 steps. Increased to 50 to provide sufficient headroom.
- **Search range**: 20 (minimum to complete heartbeat), 100 (maximum before runaway risk)
- **Sensitivity**: medium — too low causes heartbeat failures; too high allows runaway subagents consuming excess quota
- **Source**: HISTORY.md [2026-02-14 10:21]: PR #2 for max_iterations increase
-
-### collector_output_budgets_chars
- **Value**: `{clock: 200, context: 500, health: 400, home: 300, email: 600, youtube: 400, browser: 400, weather: 300}` — total max ~3,100 chars / ~800 tokens
- **Rationale**: Each collector truncates its output to fit within the budget. The orchestrator's interpretation context is bounded by the sum of all collector outputs (~800 tokens), leaving the vast majority of Sonnet's context window for reasoning and conversation history.
- **Search range**: Budgets can be increased at the cost of higher orchestrator context consumption
- **Sensitivity**: low — budgets are generously sized for typical data volumes; edge cases (many emails, many browser rows) cause truncation of older items
- **Source**: KNOWLEDGE.md heartbeat section collector output budgets table
-
---
-
-## Prompt Caching Configuration
-
-### cache_checkpoint_1
- **Value**: System prompt end (after all KNOWLEDGE.md content + skills list)
- **Rationale**: The static system prompt is the largest cacheable prefix and changes rarely (at most daily). Cache hits on this checkpoint save the most tokens per call.
- **Search range**: Not variable — checkpoint must be at the end of the stable prefix
- **Sensitivity**: high — misplacing the checkpoint causes cache misses on the most expensive prefix
- **Source**: KNOWLEDGE.md prompt caching section; providers/anthropic_oauth.py:240-272
-
-### cache_checkpoint_2
- **Value**: End of conversation history (growing prefix, 5-minute TTL)
- **Rationale**: Second checkpoint on the growing conversation allows caching recent turns. TTL of 5 minutes means it only helps for rapid back-and-forth conversations, not across sessions.
- **Search range**: Not variable
- **Sensitivity**: medium — beneficial for interactive sessions; negligible for heartbeat-only periods
- **Source**: KNOWLEDGE.md prompt caching section
-
-### knowledge_md_target_size
- **Value**: ~4KB (current: varies by content)
- **Rationale**: Smaller KNOWLEDGE.md = smaller stable cache prefix = lower cold-write cost. Target is to keep KNOWLEDGE.md under 8KB to balance comprehensiveness with cache efficiency.
- **Search range**: 2KB (minimal, loses coverage) to 12KB (comprehensive, higher cache cost)
- **Sensitivity**: low
- **Source**: HISTORY.md [2026-02-22 05:04]: context engineering session; KNOWLEDGE.md optimization
-
---
-
-## Memory Configuration
-
-### mem0_qdrant_url
- **Value**: `http://172.17.0.1:6333`
- **Rationale**: Qdrant running as Docker container on Unraid; accessible via bridge gateway
- **Search range**: Not variable
- **Sensitivity**: medium — mem0 silently fails if Qdrant is unreachable
- **Source**: HISTORY.md [2026-03-01 07:04]; config.json mem0 section
-
-### mem0_collection
- **Value**: `mem0`
- **Rationale**: Default Qdrant collection name used by mem0 library
- **Search range**: Not variable (hardcoded by mem0)
- **Sensitivity**: low
- **Source**: HISTORY.md [2026-03-01 07:04]
-
-### mem0_extraction_model
- **Value**: `claude-haiku-4-5` (via AnthropicOAuthLLM class)
- **Rationale**: mem0's default extraction LLM is GPT-4.1-nano (costs extra OpenAI API calls). Patched to use Haiku via Claude OAuth (prepaid, no extra cost). Extraction prompt reduced from 100-line template to single-line: "Extract dated facts from this conversation as JSON: {'facts': [...]}. Today is {date}."
- **Search range**: Any Claude model available via OAuth
- **Sensitivity**: medium — extraction quality affects usefulness of stored memories
- **Source**: HISTORY.md [2026-03-04 05:06]: mem0 extraction prompt testing; H05
@@ -1,111 +0,0 @@
-# Infrastructure Configuration
-
-## Docker Daemon DNS
-
-### dns
- **Value**: `["172.17.0.1"]`
- **Rationale**: Technitium DNS runs in host mode; bridge gateway IP is the only address that reaches it from container network namespace. Using 192.168.1.50 (host primary IP) causes 8-second DNS timeouts inside containers.
- **Search range**: 172.17.0.1 (bridge gateway) only; 192.168.1.50 is explicitly broken in this topology
- **Sensitivity**: high
- **Source**: HISTORY.md [2026-02-13]; /etc/docker/daemon.json; /boot/config/go (Unraid persistence)
-
---
-
-## Home Assistant
-
-### ha_url
- **Value**: `http://192.168.1.50:8123`
- **Rationale**: HA runs on Unraid server local IP. HTTPS fails (TLS certificate provisioning issue with Traefik). Plain HTTP used exclusively.
- **Search range**: Local LAN only
- **Sensitivity**: medium
- **Source**: KNOWLEDGE.md; SKILL.md vacuum and yandex-station
-
-### ha_token
- **Value**: Long-lived access token starting with `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...`
- **Rationale**: Standard HA long-lived access token for API authentication
- **Search range**: Not applicable; must be regenerated if expired (current token valid until 2086 per JWT exp field)
- **Sensitivity**: high (service credential)
- **Source**: SKILL.md vacuum and yandex-station
-
---
-
-## Health Receiver
-
-### health_receiver_url
- **Value**: `http://192.168.1.50:3847`
- **Rationale**: Custom Node.js app on port 3847 that ingests Apple Health data via HTTP POST and subscribes to OwnTracks via MQTT. Named `health-receiver` in Docker.
- **Search range**: Local LAN only
- **Sensitivity**: medium
- **Source**: HISTORY.md [2026-02-14]; HEARTBEAT_INSTRUCTIONS.md hb-health task
-
-### health_receiver_api_key
- **Value**: `edcda39ab15b03e42e616569272e7a1cc3ede696eba85053`
- **Rationale**: Simple pre-shared key for the custom health receiver API
- **Search range**: Not applicable
- **Sensitivity**: medium
- **Source**: HEARTBEAT_INSTRUCTIONS.md hb-health task spec
-
---
-
-## MQTT (Mosquitto)
-
-### mqtt_url
- **Value**: `mqtts.wylab.me:443` (WSS), `wylab.me:9001` (WebSocket), `wylab.me:1883` (plain MQTT)
- **Rationale**: OwnTracks on iOS uses WebSocket connection (port 9001); Mosquitto also listens on plain MQTT (port 1883) and WSS (port 443). Password reset to `poMbyc-jamfy3-mivxub` after auth debugging in February 2026.
- **Search range**: Ports are fixed by Mosquitto listener config
- **Sensitivity**: medium
- **Source**: HISTORY.md [2026-02-14 00:06]
-
---
-
-## PostgreSQL (Browser History)
-
-### pg_connection
- **Value**: `postgresql://nanobot:nanobot-wylab-2026@192.168.1.50:5432/nanobot`
- **Rationale**: Safari browser history synced via launchd every 5 minutes on macOS; inserted into `browser_history` table with `md5(url)+visit_time` unique index. 918+ rows synced on initial run.
- **Search range**: Local LAN only; external access via wylab.me:5432 (macexport user)
- **Sensitivity**: medium
- **Source**: HISTORY.md [2026-02-14 15:35]; HEARTBEAT_INSTRUCTIONS.md hb-browser task spec
-
---
-
-## Traefik Reverse Proxy
-
-### traefik_deployment
- **Value**: Running on Unraid, routing to 20+ Docker containers
- **Rationale**: Central reverse proxy for all wylab.me subdomains
- **Search range**: Not applicable
- **Sensitivity**: high — Traefik misconfiguration makes all services inaccessible
- **Source**: KNOWLEDGE.md infrastructure section; HISTORY.md Traefik notes
-
-### traefik_tls_constraint
- **Value**: ACME DNS-01 requires DNS to be independently reachable; do not route DNS behind Traefik
- **Rationale**: Circular dependency: Traefik needs DNS to issue certificates; if DNS is behind Traefik and certificate isn't issued, DNS is unreachable and certificate can never be issued
- **Search range**: Not applicable (architectural constraint)
- **Sensitivity**: high
- **Source**: C06; HISTORY.md [2026-12-14]; KNOWLEDGE.md Obsidian section ("plain HTTP — HTTPS/TLS fails")
-
---
-
-## Gitea CI/CD
-
-### gitea_url
- **Value**: `https://git.wylab.me`
- **Rationale**: Self-hosted Gitea instance; nanobot account for CI/CD PRs
- **Search range**: Not applicable
- **Sensitivity**: medium
- **Source**: KNOWLEDGE.md Git Notes
-
-### nanobot_token_location
- **Value**: `/root/.nanobot/workspace/nanobot-repo/.git/config`
- **Rationale**: Gitea token embedded in remote URL; extract with `grep url .git/config | grep -o 'https://[^@]*@' | sed 's|https://||; s|@||'`
- **Search range**: Not applicable; token must be rotated manually if exposed
- **Sensitivity**: high (service credential)
- **Source**: KNOWLEDGE.md Git Notes
-
-### git_config_workaround
- **Value**: `GIT_CONFIG_GLOBAL=/tmp/gitconfig`
- **Rationale**: `/root/.gitconfig` is a Docker volume mount directory, not a file. Standard git config operations fail. Set `GIT_CONFIG_GLOBAL=/tmp/gitconfig` for all git invocations.
- **Search range**: Not applicable
- **Sensitivity**: low
- **Source**: KNOWLEDGE.md Git Notes; H08
@@ -1,86 +0,0 @@
-# Model Configuration
-
-This file documents the model selection, quota management, and caching configuration for the nanobot system.
-
---
-
-## Primary model (orchestrator)
-
-### Model selection
- **Value**: `claude-sonnet-4-6` (default); falls back to `claude-haiku-4-5` at 95%+ quota
- **Rationale**: Sonnet provides the reasoning capacity needed for multi-signal life-state interpretation and multi-step tool execution. Haiku is used as a cost-optimized fallback when quota is running low, accepting reduced response quality in exchange for continued availability.
- **Search range**: Opus (too expensive for persistent operation), Sonnet (selected), Haiku (fallback only)
- **Sensitivity**: medium — downgrading to Haiku for the main conversational agent noticeably reduces multi-step reasoning quality
- **Source**: KNOWLEDGE.md §Key Nanobot Features; HISTORY.md [2026-02-15 13:21]
-
-### Quota monitoring
- **Value**: `/quota` command reads `rate_limits.json`; threshold 85% triggers lightweight-mode gate, 95% triggers Haiku fallback
- **Rationale**: Claude Max subscription has a weekly token budget. Without monitoring, the system can exhaust quota mid-week, causing 4-6 hour rate-limit windows that halt heartbeat cycles entirely. Two-tier thresholds give early warning before complete exhaustion.
- **Search range**: No monitoring (caused 47-hour outage, HISTORY.md [2026-02-18]), single threshold, dual threshold (selected)
- **Sensitivity**: high — exhausting quota without warning causes complete service unavailability
- **Source**: HISTORY.md [2026-02-15 23:55]; HISTORY.md [2026-02-18T15:00]
-
---
-
-## Collector model (heartbeat subagents)
-
-### Collector model selection
- **Value**: `claude-haiku-4-5` for all 7 parallel Haiku collectors
- **Rationale**: Collectors perform structured data extraction: parse a JSON API response, extract specified fields, write a compact output file. This is a pattern Haiku handles reliably and cheaply. The 8× collector multiplier makes model cost disproportionately important here.
- **Search range**: Sonnet-only (2× cost per cycle, no quality benefit for extraction), Haiku-only (all collectors + orchestrator at lowest tier — insufficient for interpretation)
- **Sensitivity**: low — any capable small model works for structured extraction
- **Source**: KNOWLEDGE.md §Heartbeat Architecture; C01 in claims.md
-
-### Collector output budget (quota per file)
- **Value**: clock=200 chars, context=500, health=400, home=300, email=600, youtube=400, browser=400, weather=300 (total ~3,100 chars / ~800 tokens)
- **Rationale**: The Sonnet orchestrator must read all 8 files in a single turn. If any collector produces unbounded output, the orchestrator's input grows unboundedly across cycles. Fixed budgets ensure predictable orchestrator cost regardless of data volume.
- **Search range**: Unconstrained collectors explored (caused orchestrator context overflow when session file grew large)
- **Sensitivity**: medium — too-small budgets cause data loss; too-large budgets cause orchestrator overload
- **Source**: KNOWLEDGE.md §Heartbeat Architecture
-
---
-
-## Caching configuration
-
-### Cache architecture
- **Value**: Two cache checkpoints — checkpoint 1 after static system prompt (KNOWLEDGE.md + skills list), checkpoint 2 after growing conversation history
- **Rationale**: Two checkpoints allow the stable prefix (rarely changing) to be cached cheaply while conversation turns update only the second checkpoint. A single checkpoint would either miss stable-prefix caching or force a full re-cache on every turn.
- **Search range**: One checkpoint, two checkpoints (selected), three checkpoints
- **Sensitivity**: high — removing the first checkpoint causes full re-processing of KNOWLEDGE.md on every turn
- **Source**: KNOWLEDGE.md §Prompt Caching; HISTORY.md [2026-02-19 02:25]
-
-### Cache-busting prevention
- **Value**: MEMORY.md excluded from system prompt; KNOWLEDGE.md changes at most weekly; skills list changes infrequently
- **Rationale**: Any content block that changes at or before a cache checkpoint invalidates that checkpoint's cache entry. MEMORY.md changes multiple times per session (current project state). Excluding it from the system prompt means only intentional KNOWLEDGE.md updates bust the stable cache.
- **Search range**: Single system prompt file (pre-split — caused cache invalidation on every MEMORY.md write); split design (selected)
- **Sensitivity**: high
- **Source**: C02 in claims.md; HISTORY.md [2026-02-19 03:06]
-
-### Expected cache performance
- **Value**: cache_read=16k+ tokens on hits; cache_write=2-3k for new conversation turns only
- **Rationale**: KNOWLEDGE.md is ~4-8KB (~1,000-2,000 tokens). On a cache hit, these tokens are read at 10% of write cost. On a cache miss (cold start, restart, TTL expiry), the full write cost is paid. Cache hits dominate for active sessions with <5 minute gap between turns.
- **Search range**: N/A (observed metric, not configurable)
- **Sensitivity**: low (external API behavior)
- **Source**: KNOWLEDGE.md §Prompt Caching
-
---
-
-## Dead-end configurations
-
-### Writing to /etc/resolv.conf inside container
- **Value**: Prohibited — hard rule BC01 in constraints.md
- **Rationale**: During DNS debugging, the agent wrote to `/etc/resolv.conf` to test nameserver configurations. Leaving only the broken nameserver killed all outbound DNS, requiring external container restart. The correct fix is to configure `/etc/docker/daemon.json` on the Unraid host.
- **Sensitivity**: high — container networking is externally managed; in-container changes are ephemeral and unsafe
- **Source**: HISTORY.md [2026-02-13]; constraints.md §BC01
-
-### Docker daemon DNS using host IP instead of bridge gateway
- **Value**: `{"dns": ["192.168.1.50"]}` is broken; `{"dns": ["172.17.0.1"]}` is correct
- **Rationale**: Technitium DNS runs in host mode on the Unraid server, binding to the docker0 bridge interface. From inside Docker containers, the host's primary IP (192.168.1.50) is not reachable via the container's NAT, but the bridge gateway (172.17.0.1) is. Using the host IP caused 8-second DNS latency as containers waited for timeout before falling back to 1.1.1.1.
- **Sensitivity**: high — affects all outbound network calls from all containers
- **Source**: C05 in claims.md; HISTORY.md [2026-02-13 18:16]
-
-### SS14 cross-architecture cache sharing
- **Value**: Separate per-runner local file cache (not shared remote cache); explicit cache key per OS/architecture
- **Rationale**: Mixed ARM64/x64 runners sharing a single `.NET` build cache produced corrupted binaries and cryptic build failures. Local file caches are isolated per runner, preventing cross-architecture contamination at the cost of redundant compilation on each runner.
- **Sensitivity**: medium — affects only CI/CD build pipelines with multi-architecture runner pools
- **Source**: C08 in claims.md; HISTORY.md [2026-12-18], [2026-12-19]
@@ -1,111 +0,0 @@
-# Agent System Configuration (training.md / system_config.md)
-
-This file documents the agent-level configuration parameters — the "training" choices that define how the agent behaves, what it remembers, and how it communicates. In the nanobot context, "training" refers to system prompt composition, memory architecture decisions, and behavioral rules baked into the context rather than model weights.
-
---
-
-## System prompt composition
-
-### KNOWLEDGE.md inclusion
- **Value**: Always included as the first cache checkpoint block
- **Rationale**: Contains stable facts (user identity, infrastructure topology, behavioral rules, communication preferences) that should be present on every turn without regeneration cost. The cache checkpoint here means these tokens are paid once per session, not per turn.
- **Search range**: N/A (binary: included or not)
- **Sensitivity**: high — removing KNOWLEDGE.md breaks behavioral rules and contextual grounding on every turn
- **Source**: KNOWLEDGE.md §Memory Layout; HISTORY.md [2026-02-19 03:06]
-
-### MEMORY.md exclusion from system prompt
- **Value**: Not included in system prompt; loaded on demand via tool call
- **Rationale**: MEMORY.md updates on every session write (current project status, deferred decisions). Including it in the system prompt would bust the cache on every update, costing full re-processing of the stable prefix. Exclusion means cache is invalidated only when KNOWLEDGE.md changes (~weekly).
- **Search range**: Was previously included (pre-February 2026); discovered to cause cache invalidation on every turn
- **Sensitivity**: high — re-including MEMORY.md would make cache hit rate fall to near zero
- **Source**: HISTORY.md [2026-02-19 03:06]; C02 in claims.md
-
-### Skills list in system prompt
- **Value**: List of available skill names and SKILL.md references included in system prompt
- **Rationale**: Agent must know what tools are available before receiving a user request. Skills are stable (change infrequently) so they benefit from caching.
- **Search range**: N/A
- **Sensitivity**: low
- **Source**: KNOWLEDGE.md §Nanobot System Architecture
-
---
-
-## Cache checkpoint configuration
-
-### Number of cache checkpoints
- **Value**: 2 (one after static system prompt, one after growing conversation history)
- **Rationale**: Two checkpoints allow the static system prompt to be cached with a long-lived entry while the conversation history is cached with a separate shorter-lived entry. The second checkpoint allows cache hits on repeated conversation turns within the 5-minute TTL window.
- **Search range**: 1–3 checkpoints explored; 2 found optimal
- **Sensitivity**: medium
- **Source**: HISTORY.md [2026-02-19 02:25]; KNOWLEDGE.md §Prompt Caching
-
-### Cache TTL
- **Value**: ~5 minutes (Anthropic API implementation detail, not configurable)
- **Rationale**: External constraint. nanobot's session design assumes cache hits within 5 minutes. Long conversation gaps (>5 min idle) result in cold cache writes on the next turn.
- **Search range**: Not configurable
- **Sensitivity**: low (cannot be tuned)
- **Source**: KNOWLEDGE.md §Prompt Caching
-
---
-
-## Session management
-
-### Session key format
- **Value**: `{channel}:{identifier}` — e.g., `telegram:239824268` for main conversation, `heartbeat` for autonomous cycles
- **Rationale**: Separate session keys ensure heartbeat runs and conversational turns do not share context or interfere with each other's tool call histories. The `clear_tool_uses_20250919` server-side edit prunes old tool chains within a session without cross-session contamination.
- **Search range**: Flat session design (one session for all) explored early; caused heartbeat context to pollute conversational context
- **Sensitivity**: high — session key collision would cause context bleed between heartbeat and conversation
- **Source**: KNOWLEDGE.md §Subagent System; HISTORY.md [2026-02-21]
-
-### Context compaction trigger
- **Value**: ~40 turns or ~60k tokens of exchange history, or when `[system result was cleared]` appears
- **Rationale**: Compaction extracts a session summary to HISTORY.md and clears the in-context conversation history. This prevents context overflow while preserving the information in the append-only log.
- **Search range**: N/A (heuristic threshold)
- **Sensitivity**: medium
- **Source**: KNOWLEDGE.md §Compaction Protocol
-
---
-
-## Heartbeat orchestrator settings
-
-### Heartbeat interval
- **Value**: 30 minutes
- **Rationale**: Short enough to catch time-sensitive events (email alerts, location changes, battery warnings) within a reasonable window; long enough to avoid excessive API cost. At 30-minute intervals, ~48 heartbeat cycles run per day.
- **Search range**: 30 min selected after early design used continuous polling (too expensive) and 1-hour intervals (missed critical events)
- **Sensitivity**: medium
- **Source**: HEARTBEAT_INSTRUCTIONS.md §Architecture; KNOWLEDGE.md §Heartbeat Architecture
-
-### Orchestrator model
- **Value**: `claude-sonnet-4-6` (Sonnet for orchestration)
- **Rationale**: Sonnet provides sufficient reasoning capacity to combine 8 data streams and make contextual decisions (should vacuum run? is Makar asleep? is this email urgent?). Haiku was tested as orchestrator but produced lower-quality interpretations and missed multi-signal inferences.
- **Search range**: Haiku orchestrator tested (too weak), Sonnet selected, Opus not used (too expensive for 48 daily cycles)
- **Sensitivity**: medium
- **Source**: HEARTBEAT_INSTRUCTIONS.md; HISTORY.md [2026-02-18 22:17]
-
-### Collector model
- **Value**: `claude-haiku-4-5` (Haiku for all 7 parallel collectors)
- **Rationale**: Collectors perform structured data extraction from API responses — a pattern Haiku handles well. Using Haiku for 7 parallel collectors vs Sonnet for all 8 reduces per-cycle token cost significantly. Collectors that require no reasoning (YouTube, browser) were replaced entirely by deterministic scripts.
- **Search range**: Sonnet-only (too expensive), Haiku-only (orchestration quality insufficient), current split selected
- **Sensitivity**: low (any frontier Haiku-tier model works for extraction)
- **Source**: KNOWLEDGE.md §Heartbeat Architecture; C01 in claims.md
-
---
-
-## Behavioral rules (system prompt constants)
-
-### Execute-first, narrate-second
- **Value**: Hard rule — never say "I will X" before doing X; call the tool and report the result
- **Rationale**: Makar called out multiple instances of narrating intentions without executing them. The rule eliminates preamble and forces the agent to produce evidence before making claims.
- **Sensitivity**: high
- **Source**: KNOWLEDGE.md §Hard Rules; HISTORY.md [2026-02-22 03:58]
-
-### No code unless explicitly requested
- **Value**: Never produce code blocks unless the user explicitly asks for code
- **Rationale**: Makar's operational context involves executing commands, not writing programs. Unsolicited code produces noise and suggests the agent is solving a different problem than asked.
- **Sensitivity**: medium
- **Source**: KNOWLEDGE.md §Communication Rules
-
-### Answer first, do not silently fix
- **Value**: When asked a question, answer it. Do not silently fix things. Wait for explicit go-ahead before making changes.
- **Rationale**: Multiple incidents where the agent diagnosed a problem and immediately "fixed" it without asking produced unwanted changes. The answer-first rule preserves user control over consequential operations.
- **Sensitivity**: high
- **Source**: KNOWLEDGE.md §Hard Rules
@@ -1,81 +0,0 @@
-# Environment
-
-## Python
- **Version**: 3.12 (CPython, installed in the nanobot Docker container)
- **Package manager**: pip 24.x
-
-## Framework
- **Nanobot version**: fork of HKUDS/nanobot (MIT license), extended with custom skills and heartbeat service. Container auto-updates via Watchtower from `git.wylab.me/wylab/nanobot` branch `main`.
- **LLM provider**: Anthropic Claude API via OAuth (Claude Max subscription). No standard API key — uses OAuth Bearer token (`sk-ant-oat01-...`) with required beta headers.
- **Models in use**:
-  - Orchestrator / conversational: `claude-sonnet-4-6`
-  - Heartbeat Haiku collectors: `claude-haiku-4-5`
-  - Quota fallback: `claude-haiku-4-5` (at ≥95% weekly quota)
-
-## Hardware
- **Host**: Unraid server — MINISFORUM UM790 Pro
-  - CPU: AMD Ryzen 9 7940HS (8-core, 16-thread)
-  - RAM: 32 GB DDR5 (confirmed via /proc/meminfo)
-  - Storage: NVME SSD (cache) + HDD array
-  - iGPU: AMD Radeon 780M (Ollama/ROCm inference, separate container)
- **Deployment**: Docker container on Unraid, managed via Tower UI
- **Persistent volumes**:
-  - `/root/.nanobot/workspace/` — all agent state, skills, scripts, memory files
-  - `/root/.config/` — skill configs, OAuth tokens, API keys
-
-## Key dependencies
-| Package | Version | Purpose |
-|---------|---------|---------|
-| `anthropic` | ≥0.30 | Claude API client (used in some skills; main agent uses OAuth via httpx) |
-| `psycopg2` | system | PostgreSQL browser history queries (hb-browser) |
-| `mem0ai` | 1.0.4 | Semantic memory layer (Qdrant-backed) |
-| `qdrant-client` | ≥1.9 | Vector store for mem0 |
-| `openai` | ≥1.x | mem0 default embedding provider (text-embedding-3-small) |
-| `playwright` | latest | FF exchange rate scraper (ephemeral — must reinstall after container restart) |
-| `httpx` | ≥0.27 | HTTP client used by nanobot OAuth provider |
-| `yt-dlp` | latest | YouTube data (supplementary, not primary) |
-
-## External services
-| Service | Address | Protocol | Notes |
-|---------|---------|----------|-------|
-| Home Assistant | 192.168.1.50:8123 | HTTP REST | Long-lived access token auth |
-| Health Receiver | 192.168.1.50:3847 | HTTP REST | API key auth; ingests OwnTracks + Apple Health |
-| PostgreSQL | 192.168.1.50:5432 | psycopg2 | Browser history (browser_history table) |
-| Mosquitto MQTT | mqtts.wylab.me:443 | MQTT-TLS | OwnTracks location tracking |
-| Qdrant | 172.17.0.1:6333 | HTTP | mem0 vector store; collection "mem0" |
-| Gitea | git.wylab.me | HTTPS | Code hosting, CI/CD (wylab/nanobot repo) |
-| Obsidian REST API | 192.168.1.82:27123 | HTTP (plain) | Vault access (HTTPS not supported) |
-| Anthropic API | api.anthropic.com | HTTPS | OAuth + Bearer token |
-
-## CLI tools available in container
-| Tool | Version | Purpose |
-|------|---------|---------|
-| `gog` | custom | Google Workspace CLI (Gmail, Calendar, Drive) |
-| `goplaces` | custom | Google Places API lookup |
-| `himalaya` | v1.1.0 | IMAP/SMTP email client (backup to gog) |
-| `tea` | v0.11.1 | Gitea CLI |
-| `gh` | v2.86.0 | GitHub CLI |
-| `whisper` | latest | Audio transcription |
-| `summarize` | v0.10.0 | URL/YouTube summarization (npm global) |
-| `blucli` | custom | Bluesound speaker control |
-| `python3` | 3.12 | Scripts (youtube_sync.py, ff_rates_scraper.py, p2p_quick.py, etc.) |
-
-## Networking
- Docker DNS: `172.17.0.1` (bridge gateway, Technitium in host mode)
- Technitium DNS: binds to docker0 at 172.17.0.1, authoritative for `wylab.me`
- Traefik reverse proxy: handles external TLS for all wylab.me subdomains
- Internal LAN: 192.168.1.0/24 (Unraid + all home automation services)
-
-## Random seeds
- Not applicable (no ML training; inference-only deployment)
-
-## Notes on ephemeral dependencies
- Playwright and its Chromium browser must be reinstalled after container restarts:
-  ```
-  pip install playwright -q && python3 -m playwright install chromium && python3 -m playwright install-deps chromium
-  ```
- GIT_CONFIG_GLOBAL must be overridden for git operations (Docker mount issue):
-  ```
-  GIT_CONFIG_GLOBAL=/tmp/gitconfig
-  ```
- `/root/.config/` is a Docker volume mount (persistent); do not assume it survives without the volume.
@@ -1,225 +0,0 @@
-"""
-Deterministic Collector Script Pattern — Nanobot Heartbeat System
-
-This module documents the pattern for deterministic (non-LLM) data collection
-scripts used by the nanobot heartbeat system. These scripts replace the earlier
-LLM-based Haiku collector approach to eliminate sensor data hallucination.
-
-Key insight: Data collection (fetching from APIs, formatting output) is a
-deterministic transformation. LLMs are appropriate only for interpretation
-(deciding what data means), not collection.
-
-The deployed youtube_sync.py is the primary example of this pattern.
-See /root/.nanobot/workspace/scripts/youtube_sync.py for the full implementation.
-"""
-
-import json
-import os
-import sqlite3
-import subprocess
-from datetime import datetime, timezone
-from typing import Optional
-
-
-WORKSPACE = "/root/.nanobot/workspace"
-HEARTBEAT_DATA = f"{WORKSPACE}/heartbeat_data"
-DATA_DIR = f"{WORKSPACE}/data"
-
-
-def write_output(filename: str, data: dict) -> None:
-    """
-    Write collector output to heartbeat_data directory.
-    Always writes (even on error) so orchestrator can distinguish
-    'collector not run' from 'collector ran but got no data'.
-    """
-    os.makedirs(HEARTBEAT_DATA, exist_ok=True)
-    path = os.path.join(HEARTBEAT_DATA, filename)
-    with open(path, "w") as f:
-        json.dump(data, f, ensure_ascii=False)
-
-
-def write_error(filename: str, error_msg: str) -> None:
-    """
-    Write error JSON — standardized error format for all collectors.
-    Orchestrator checks for 'error' key to detect failure.
-    """
-    write_output(filename, {"error": error_msg})
-
-
-# --- YouTube Sync Pattern ---
-# Full implementation: /root/.nanobot/workspace/scripts/youtube_sync.py
-
-def youtube_sync_pattern(oauth_token: str, db_path: str) -> None:
-    """
-    Pattern for the YouTube sync script.
-    
-    Writes to heartbeat_data/youtube.json:
-    {
-        "new_likes": [
-            {"id": "...", "title": "...", "channel": "...", "summary": "..."}
-        ],
-        "new_subscriptions": [...],
-        "unsubscribed": [...]
-    }
-    
-    On any API failure: writes {"error": "<reason>"} and exits.
-    
-    Key design decisions:
-    - Uses youtube_sync.py heartbeat_log table as watermark (not life_state.json)
-    - Diff-based: only reports changes since last sync
-    - No LLM: all summarization done via `summarize` CLI tool
-    - Writes to 3 stores: SQLite (structured), Qdrant/mem0 (semantic), HISTORY.md (timeline)
-    """
-    raise NotImplementedError("See /root/.nanobot/workspace/scripts/youtube_sync.py")
-
-
-# --- Health Collector Pattern ---
-# Replaced LLM hb-health with direct HTTP fetch; still uses Haiku for safety
-
-def health_collector_pattern(
-    receiver_url: str, api_key: str, output_file: str = "health.json"
-) -> None:
-    """
-    Pattern for health data collection.
-    
-    Fetches from health-receiver REST API endpoints:
-    - /latest/location  — OwnTracks GPS coordinates
-    - /latest/metrics   — Apple Health steps, distance, audio
-    - /latest/heart-rate — Resting HR, HR events  
-    - /latest/workouts  — Exercise sessions
-    - /latest/state-of-mind — Valence and mood labels
-    - /latest/medications — What was taken
-    
-    Output schema (heartbeat_data/health.json):
-    {
-        "location": {"lat": float, "lon": float, "battery": int, "connection": str, "timestamp": str},
-        "metrics": {"steps": int, "walking_distance_km": float, ...},
-        "heart_rate": {"resting_bpm": int, "events": str},
-        "workouts": [{"type": str, "duration_min": int, "calories": int, "start": str}],
-        "state_of_mind": {"valence": int, "labels": [str], "timestamp": str},
-        "medications": {"taken": [str], "timestamp": str}
-    }
-    
-    Null fields for missing/error data. Never invents values.
-    """
-    headers = {"key": api_key}
-    endpoints = ["location", "metrics", "heart-rate", "workouts", "state-of-mind", "medications"]
-    result = {}
-    
-    for endpoint in endpoints:
-        try:
-            # In practice: subprocess curl call or httpx
-            # curl -s -H "key: {api_key}" {receiver_url}/latest/{endpoint}
-            data = {}  # placeholder
-            result[endpoint.replace("-", "_")] = data
-        except Exception as e:
-            result[endpoint.replace("-", "_")] = None
-    
-    write_output(output_file, result)
-
-
-# --- Browser History Collector Pattern ---
-
-def browser_collector_pattern(
-    pg_conn_str: str,
-    last_check_iso: str,
-    output_file: str = "browser.json"
-) -> None:
-    """
-    Pattern for browser history collection from PostgreSQL.
-    
-    Queries browser_history table for rows after last_check_iso.
-    Groups visits into time clusters (within 15 minutes of each other).
-    Summarizes each cluster as a topic.
-    
-    Output schema (heartbeat_data/browser.json):
-    {
-        "db_ok": bool,
-        "row_count": int,
-        "summary": "2-4 sentences describing browsing activity",
-        "clusters": [{"time_range": "HH:MM-HH:MM", "topic": str, "notable_urls": [str]}]
-    }
-    
-    On database failure: writes {"db_ok": false, "row_count": 0, ...}
-    Never invents URLs or topics.
-    """
-    try:
-        conn = sqlite3.connect(pg_conn_str)  # placeholder — actual uses psycopg2
-        # SELECT url, title, visit_time FROM browser_history
-        # WHERE visit_time > %s ORDER BY visit_time ASC LIMIT 200
-        rows = []  # placeholder
-        conn.close()
-        
-        clusters = _cluster_browser_rows(rows)
-        write_output(output_file, {
-            "db_ok": True,
-            "row_count": len(rows),
-            "summary": _summarize_clusters(clusters),
-            "clusters": clusters
-        })
-    except Exception as e:
-        write_output(output_file, {
-            "db_ok": False,
-            "row_count": 0,
-            "summary": None,
-            "clusters": [],
-            "error": str(e)
-        })
-
-
-def _cluster_browser_rows(rows: list) -> list:
-    """
-    Group browser rows into time-based clusters.
-    Visits within 15 minutes of each other form a cluster.
-    """
-    if not rows:
-        return []
-    clusters = []
-    current_cluster = [rows[0]]
-    
-    for row in rows[1:]:
-        # Compare timestamps; if >15 min gap, start new cluster
-        if _time_gap_minutes(current_cluster[-1], row) > 15:
-            clusters.append(current_cluster)
-            current_cluster = []
-        current_cluster.append(row)
-    
-    if current_cluster:
-        clusters.append(current_cluster)
-    
-    return [
-        {
-            "time_range": f"{_row_time(c[0])}-{_row_time(c[-1])}",
-            "topic": _infer_topic(c),
-            "notable_urls": [r[0] for r in c[:3]]  # top 3 URLs
-        }
-        for c in clusters
-    ]
-
-
-def _time_gap_minutes(row1, row2) -> float:
-    """Placeholder: return minutes between two browser row timestamps."""
-    return 0.0
-
-
-def _row_time(row) -> str:
-    """Placeholder: return HH:MM string from browser row timestamp."""
-    return "00:00"
-
-
-def _infer_topic(cluster: list) -> str:
-    """
-    Infer topic from URL/title patterns in cluster.
-    Skip: login pages, redirects, Google homepage.
-    Return: topic string like "Minecraft modding research" or "job search on HH.ru"
-    NOTE: This is the ONE place where LLM reasoning is appropriate —
-    interpreting what a cluster of URLs means. Could also be rule-based.
-    """
-    return "browsing session"
-
-
-def _summarize_clusters(clusters: list) -> Optional[str]:
-    """Produce 2-4 sentence summary of browsing activity from clusters."""
-    if not clusters:
-        return None
-    return f"{len(clusters)} browsing cluster(s) detected"
@@ -1,390 +0,0 @@
-"""
-heartbeat.py — Heartbeat Orchestrator Stub
-
-This module contains the core orchestration logic for nanobot's 30-minute
-autonomous heartbeat cycle. The orchestrator is invoked as a Sonnet subagent
-via the HeartbeatService in nanobot/heartbeat/service.py every 30 minutes.
-
-Architecture:
- Sonnet orchestrator (this module's logic)
- 7 × Haiku parallel collectors + 1 deterministic YouTube script
- All collectors write compact JSON to heartbeat_data/
- Orchestrator reads files, interprets combined picture, acts
-
-See HEARTBEAT_INSTRUCTIONS.md for the full step-by-step specification.
-"""
-
-from __future__ import annotations
-
-import json
-import math
-import os
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Optional
-
-
-# ---------------------------------------------------------------------------
-# Configuration constants
-# ---------------------------------------------------------------------------
-
-WORKSPACE = Path("/root/.nanobot/workspace")
-HEARTBEAT_DATA = WORKSPACE / "heartbeat_data"
-LIFE_STATE_PATH = WORKSPACE / "memory" / "life_state.json"
-HISTORY_PATH = WORKSPACE / "memory" / "HISTORY.md"
-REPORTS_DIR = WORKSPACE / "memory" / "heartbeat_reports"
-
-HOME_LAT = 41.384588
-HOME_LON = 2.136307
-HOME_RADIUS_M = 200  # metres — within this = "home"
-
-HA_BASE = "http://192.168.1.50:8123"
-HA_TOKEN = (
-    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"
-    ".eyJpc3MiOiJkZmUxYmYzMDhiMWI0ODE0OTY2MjE3YTZmYTZhMmU1OSIsImlhdCI6MTc3MTAyNDE5MiwiZXhwIjoyMDg2Mzg0MTkyfQ"
-    ".YbEsG0C0L6i7fh2gLq6UT9-aRyGXrl4czzus3s_9nBQ"
-)
-VACUUM_ENTITY = "vacuum.lefant_m2"
-GPLACES_KEY = "AIzaSyBZ0ElJhgp3sY0qwM9LOtO2EKk-SHaLjUM"
-
-# Collector names and their output files (in spawn order)
-COLLECTORS = [
-    "clock",
-    "context",
-    "health",
-    "home",
-    "email",
-    "browser",
-    "weather",
-]
-
-
-# ---------------------------------------------------------------------------
-# Data structures
-# ---------------------------------------------------------------------------
-
-@dataclass
-class Location:
-    lat: float
-    lon: float
-    battery: int
-    connection: str  # "wifi" | "mobile"
-    timestamp: str
-
-
-@dataclass
-class LifeState:
-    """Persistent state carried across heartbeat cycles via life_state.json."""
-
-    # Location / movement
-    last_location: dict = field(default_factory=dict)
-    known_places: dict = field(default_factory=dict)
-
-    # Home devices
-    last_alice_state: dict = field(default_factory=dict)
-
-    # Health continuity
-    last_health_files: list = field(default_factory=list)
-
-    # Email deduplication
-    last_email_ids: list = field(default_factory=list)
-    alerted_email_ids: list = field(default_factory=list)  # APPEND-ONLY
-
-    # YouTube watermark (handled by youtube_sync.py internally)
-    last_youtube_sync: Optional[str] = None
-
-    # Vacuum
-    last_vacuum_run: Optional[str] = None  # YYYY-MM-DD
-
-    # Sleep state
-    sleep_state: str = "unknown"  # "awake" | "asleep" | "unknown"
-
-    # Browser watermark
-    last_browser_check: Optional[str] = None
-
-    # Class reminder dedup (no longer used; Makar expelled from EUBS)
-    last_class_reminder: Optional[str] = None
-
-    # Timestamps
-    last_checked: Optional[str] = None
-
-
-# ---------------------------------------------------------------------------
-# Geometry helpers
-# ---------------------------------------------------------------------------
-
-def distance_metres(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
-    """
-    Approximate Euclidean distance in metres between two WGS-84 coordinates.
-
-    Accurate to ~1% for distances under 50 km at mid-latitudes (Barcelona area).
-    Formula: sqrt(((lat2-lat1)*111000)^2 + ((lon2-lon1)*82000)^2)
-    """
-    dlat = (lat2 - lat1) * 111_000
-    dlon = (lon2 - lon1) * 82_000
-    return math.sqrt(dlat ** 2 + dlon ** 2)
-
-
-def is_home(lat: float, lon: float) -> bool:
-    """Returns True if the coordinates are within HOME_RADIUS_M of home."""
-    return distance_metres(lat, lon, HOME_LAT, HOME_LON) <= HOME_RADIUS_M
-
-
-# ---------------------------------------------------------------------------
-# I/O helpers
-# ---------------------------------------------------------------------------
-
-def read_life_state() -> LifeState:
-    """Load life_state.json into a LifeState dataclass, or return defaults."""
-    if not LIFE_STATE_PATH.exists():
-        return LifeState()
-    with open(LIFE_STATE_PATH) as f:
-        data = json.load(f)
-    return LifeState(**{k: v for k, v in data.items() if k in LifeState.__dataclass_fields__})
-
-
-def write_life_state(state: LifeState) -> None:
-    """Persist the current LifeState back to life_state.json."""
-    LIFE_STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
-    with open(LIFE_STATE_PATH, "w") as f:
-        json.dump(state.__dict__, f, indent=2)
-
-
-def read_collector(name: str) -> dict:
-    """
-    Read a collector JSON file, returning an empty dict on missing/parse error.
-
-    Collectors write to heartbeat_data/{name}.json. If a collector timed out
-    or failed, the file may be absent or contain an error sentinel.
-    """
-    path = HEARTBEAT_DATA / f"{name}.json"
-    if not path.exists():
-        return {}
-    try:
-        with open(path) as f:
-            return json.load(f)
-    except json.JSONDecodeError:
-        return {"_error": f"JSON parse error in {name}.json"}
-
-
-def append_history(entry: str) -> None:
-    """Append a single line entry to HISTORY.md."""
-    HISTORY_PATH.parent.mkdir(parents=True, exist_ok=True)
-    with open(HISTORY_PATH, "a") as f:
-        f.write(entry.rstrip() + "\n")
-
-
-# ---------------------------------------------------------------------------
-# Core orchestration phases (stubs — full logic in HEARTBEAT_INSTRUCTIONS.md)
-# ---------------------------------------------------------------------------
-
-def phase_prepare() -> None:
-    """
-    Phase 1: Clear stale collector files from previous cycle.
-
-    Removes all *.json from heartbeat_data/ so that missing files from
-    failed collectors are distinguishable from stale data from prior runs.
-    """
-    HEARTBEAT_DATA.mkdir(parents=True, exist_ok=True)
-    for f in HEARTBEAT_DATA.glob("*.json"):
-        f.unlink()
-
-
-def phase_spawn_collectors() -> list[str]:
-    """
-    Phase 2: Spawn YouTube script + 7 Haiku collectors in parallel.
-
-    Returns a list of task IDs from spawn() calls to be passed to
-    wait_for_subagents(). The YouTube script runs via bash before spawning
-    the Haiku agents so it runs concurrently during their startup.
-
-    Implementation note: actual spawn() calls happen in the LLM context
-    (not from this Python module). This stub documents the expected behavior.
-
-    Spawn order matters for documentation only — wait_for_subagents() blocks
-    until all complete regardless of spawn order.
-    """
-    # In actual heartbeat execution, this is done via tool calls:
-    #
-    #   youtube_result = exec("python3 scripts/youtube_sync.py")
-    #   task_ids = []
-    #   for collector in COLLECTORS:
-    #       task_id = spawn(model="claude-haiku-4-5", task=HAIKU_SPECS[collector])
-    #       task_ids.append(task_id)
-    #   return task_ids
-    #
-    raise NotImplementedError("Spawn occurs via LLM tool calls, not Python.")
-
-
-def phase_interpret(
-    state: LifeState,
-    clock: dict,
-    context: dict,
-    health: dict,
-    home: dict,
-    email: dict,
-    browser: dict,
-    weather: dict,
-    youtube: dict,
-) -> dict:
-    """
-    Phase 3: Combine all 8 data streams into a unified picture of Makar's state.
-
-    Returns a summary dict with keys:
-      - current_location: Location | None
-      - at_home: bool
-      - is_asleep: bool (inference only, see H12 / HEARTBEAT_INSTRUCTIONS Step 12)
-      - new_email_threads: list of thread dicts requiring action
-      - notable_youtube: list of new YouTube likes
-      - notable_browser: summary string of browsing activity
-      - alice_changes: list of Alice state changes vs last cycle
-      - battery_critical: bool (< 20%)
-
-    Key inference rule (C04): if context.last_user_message_ago_minutes < 60,
-    Makar is awake regardless of other signals.
-    """
-    location = health.get("location") or {}
-    lat = location.get("lat")
-    lon = location.get("lon")
-    battery = location.get("battery", 100)
-
-    at_home = is_home(lat, lon) if (lat and lon) else True  # default safe
-
-    # Awake if Telegram active within 60 min
-    last_msg_min = context.get("last_user_message_ago_minutes")
-    telegram_recent = (last_msg_min is not None) and (last_msg_min < 60)
-
-    # Sleep inference requires ALL conditions (see HEARTBEAT_INSTRUCTIONS Step 12)
-    # This is a simplified stub — full inference in the LLM orchestrator
-    is_asleep = (
-        at_home
-        and not telegram_recent
-        and (battery < 90)  # proxy for stationary/inactive
-        and state.sleep_state != "awake"
-    )
-
-    return {
-        "current_location": {"lat": lat, "lon": lon} if (lat and lon) else None,
-        "at_home": at_home,
-        "is_asleep": is_asleep,
-        "battery_critical": battery < 20,
-        "telegram_recent": telegram_recent,
-    }
-
-
-def phase_act(
-    state: LifeState,
-    interpretation: dict,
-    email: dict,
-    youtube: dict,
-) -> list[str]:
-    """
-    Phase 4: Take actions based on the interpreted state.
-
-    Returns a list of action log strings for the heartbeat report.
-
-    Actions in priority order:
-    1. Battery alert (< 20%)
-    2. Email triage (time-sensitive threads not in alerted_email_ids)
-    3. Vacuum (away from home, not already run today)
-    4. Sleep/wake logging
-
-    All Telegram messages are sent via message() tool, never curl.
-    Vacuum start is sent via HA REST API.
-    """
-    actions = []
-
-    # Battery alert
-    if interpretation.get("battery_critical"):
-        # message(content="🔋 Battery at 20% — plug in")
-        actions.append("ALERT: Battery critical — message sent")
-
-    # Email triage (see C09 and H11)
-    new_threads = email.get("threads", [])
-    last_ids = set(state.last_email_ids)
-    alerted_ids = set(state.alerted_email_ids)
-    for thread in new_threads:
-        tid = thread.get("thread_id", "")
-        if tid not in last_ids and tid not in alerted_ids:
-            # Check if time-sensitive (subject/sender heuristics in LLM layer)
-            # If yes: message() + add to alerted_email_ids
-            actions.append(f"EMAIL_CANDIDATE: {thread.get('subject', '?')[:60]}")
-
-    # Vacuum automation (see BC02, H15)
-    if not interpretation.get("at_home"):
-        from datetime import date
-        today = date.today().isoformat()
-        if state.last_vacuum_run != today:
-            # Trigger vacuum via HA REST API
-            # curl -X POST -H "Authorization: Bearer {HA_TOKEN}" \
-            #   -d '{"entity_id":"vacuum.lefant_m2"}' \
-            #   {HA_BASE}/api/services/vacuum/start
-            state.last_vacuum_run = today
-            actions.append("VACUUM: Started cleaning")
-
-    return actions
-
-
-def heartbeat_cycle(life_state_path: Optional[str] = None) -> None:
-    """
-    Entry point for a single heartbeat cycle.
-
-    In production, this function is called by HeartbeatService every 30
-    minutes. The actual implementation runs as LLM tool calls following
-    HEARTBEAT_INSTRUCTIONS.md; this Python stub documents the algorithm
-    for ARA purposes.
-
-    Full algorithm:
-      1. Prepare (clear stale files)
-      2. Spawn YouTube script + 7 Haiku collectors in parallel
-      3. wait_for_subagents()
-      4. Read all 8 output files
-      5. Interpret combined state
-      6. Location resolution (if moved >200m)
-      7. Class reminders (disabled — Makar expelled from EUBS 2026-02-24)
-      8. Email triage with alerted_email_ids deduplication
-      9. Health & activity logging
-     10. YouTube likes logging
-     11. Browser history summary
-     12. Sleep/wake inference (Telegram activity takes precedence)
-     13. Weather (on home departure only)
-     14. Home device state changes
-     15. Vacuum automation
-     16. Update life_state.json
-     17. Append entries to HISTORY.md
-     18. Write heartbeat report
-    """
-    state = read_life_state()
-
-    # Phases 1-4: Prepare, spawn, collect (stubs — see above)
-    phase_prepare()
-
-    # Read all collector outputs (assumes wait_for_subagents() already called)
-    clock = read_collector("clock")
-    context = read_collector("context")
-    health = read_collector("health")
-    home = read_collector("home")
-    email = read_collector("email")
-    browser = read_collector("browser")
-    weather = read_collector("weather")
-    youtube = read_collector("youtube")  # written by youtube_sync.py
-
-    # Phase 3: Interpret
-    interpretation = phase_interpret(
-        state, clock, context, health, home, email, browser, weather, youtube
-    )
-
-    # Phase 4: Act
-    actions = phase_act(state, interpretation, email, youtube)
-
-    # Phase 5: Persist state
-    write_life_state(state)
-
-    # Phase 6: Write report
-    REPORTS_DIR.mkdir(parents=True, exist_ok=True)
-    timestamp = clock.get("timestamp", "unknown")
-    report_path = REPORTS_DIR / f"{timestamp[:10].replace('-', '')}_{timestamp[11:16].replace(':', '')}.md"
-    with open(report_path, "w") as f:
-        f.write(f"# Heartbeat Report {timestamp}\n\n")
-        f.write(f"## Interpretation\n{interpretation}\n\n")
-        f.write(f"## Actions taken\n" + ("\n".join(actions) or "none") + "\n")
@@ -1,278 +0,0 @@
-"""
-Heartbeat Orchestrator Stub — Nanobot Life-Tracking System
-
-This module represents the core heartbeat orchestration logic.
-In the deployed system, this runs as a Sonnet subagent spawned every 30 minutes
-by the HeartbeatService in nanobot/heartbeat/service.py.
-
-The orchestrator:
-1. Spawns 8 Haiku collectors in parallel
-2. Waits for their JSON output files
-3. Interprets the combined picture
-4. Takes actions (alerts, vacuum, state updates)
-
-Architecture note: The orchestrator itself is a language model agent reading
-HEARTBEAT_INSTRUCTIONS.md. This stub documents the algorithmic logic
-that the agent implements.
-"""
-
-from typing import Optional
-import json
-import math
-import os
-from datetime import date, datetime
-
-
-# --- Constants ---
-HOME_LAT = 41.384588
-HOME_LON = 2.136307
-HOME_RADIUS_M = 200  # meters — within this radius = "home"
-BRIDGE_GATEWAY = "172.17.0.1"
-HA_URL = "http://192.168.1.50:8123"
-HEALTH_RECEIVER_URL = "http://192.168.1.50:3847"
-WORKSPACE = "/root/.nanobot/workspace"
-HEARTBEAT_DATA = f"{WORKSPACE}/heartbeat_data"
-LIFE_STATE_PATH = f"{WORKSPACE}/memory/life_state.json"
-HISTORY_PATH = f"{WORKSPACE}/memory/HISTORY.md"
-
-# Per-collector output budget (max characters)
-COLLECTOR_BUDGETS = {
-    "clock": 200,
-    "context": 500,
-    "health": 400,
-    "home": 300,
-    "email": 600,
-    "youtube": 400,
-    "browser": 400,
-    "weather": 300,
-}
-
-# Heartbeat orchestrator spawned as this model
-ORCHESTRATOR_MODEL = "claude-sonnet-4-6"
-# Individual collectors spawned as this model
-COLLECTOR_MODEL = "claude-haiku-4-5"
-
-
-def haversine_distance_m(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
-    """
-    Calculate approximate distance in meters between two GPS coordinates.
-    Uses simplified flat-earth formula sufficient for <5km distances in Barcelona.
-    """
-    dlat = (lat2 - lat1) * 111_000  # meters per degree latitude
-    dlon = (lon2 - lon1) * 82_000   # meters per degree longitude at ~41°N
-    return math.sqrt(dlat ** 2 + dlon ** 2)
-
-
-def is_at_home(lat: float, lon: float) -> bool:
-    """Return True if coordinates are within HOME_RADIUS_M of home."""
-    return haversine_distance_m(lat, lon, HOME_LAT, HOME_LON) <= HOME_RADIUS_M
-
-
-def load_life_state() -> dict:
-    """Load persisted heartbeat state from life_state.json."""
-    try:
-        with open(LIFE_STATE_PATH) as f:
-            return json.load(f)
-    except (FileNotFoundError, json.JSONDecodeError):
-        return {}
-
-
-def save_life_state(state: dict) -> None:
-    """Persist heartbeat state to life_state.json."""
-    with open(LIFE_STATE_PATH, "w") as f:
-        json.dump(state, f, indent=2, ensure_ascii=False)
-
-
-def read_collector_output(collector_name: str) -> Optional[dict]:
-    """
-    Read a collector's JSON output from heartbeat_data/.
-    Returns None (not an empty dict) if file is missing or malformed —
-    orchestrator must distinguish between 'collector returned empty data'
-    and 'collector failed to write'.
-    """
-    path = os.path.join(HEARTBEAT_DATA, f"{collector_name}.json")
-    try:
-        with open(path) as f:
-            return json.load(f)
-    except (FileNotFoundError, json.JSONDecodeError):
-        return None
-
-
-def should_alert_email(thread_id: str, life_state: dict) -> bool:
-    """
-    Return True only if this thread_id has NOT been alerted before.
-    alerted_email_ids is append-only — once added, never removed.
-    """
-    alerted = life_state.get("alerted_email_ids", [])
-    return thread_id not in alerted
-
-
-def should_start_vacuum(life_state: dict, makar_at_home: bool) -> bool:
-    """
-    Vacuum should start if:
-    - Makar is away from home (>200m)
-    - Vacuum hasn't already run today
-    - Vacuum entity is not already cleaning or returning
-    """
-    if makar_at_home:
-        return False
-    today_str = str(date.today())
-    if life_state.get("last_vacuum_run") == today_str:
-        return False
-    return True
-
-
-def infer_sleep_state(
-    last_telegram_ago_min: Optional[int],
-    at_home: bool,
-    current_hour: int,
-    alice_has_activity: bool,
-    significant_steps: bool,
-    previous_state: str,
-) -> str:
-    """
-    Infer sleep state from multiple signals.
-    Hard rule: if last Telegram message < 60 min ago, Makar is awake.
-    Sleep requires ALL signals: home + late hours + no Alice + no steps + no Telegram 60+ min.
-    """
-    if last_telegram_ago_min is not None and last_telegram_ago_min < 60:
-        return "awake"
-    
-    if (
-        at_home
-        and (current_hour >= 22 or current_hour < 11)  # late night or morning
-        and not alice_has_activity
-        and not significant_steps
-        and (last_telegram_ago_min is None or last_telegram_ago_min >= 60)
-    ):
-        return "asleep"
-    
-    return previous_state  # maintain current inference if uncertain
-
-
-# --- Main orchestration flow (called by agent loop) ---
-
-def run_heartbeat_cycle(spawn_fn, wait_fn, message_fn) -> dict:
-    """
-    Main heartbeat orchestration function.
-    
-    Args:
-        spawn_fn: Callable to spawn a subagent (model, task) -> task_id
-        wait_fn: Callable to wait for subagent list -> results
-        message_fn: Callable to send Telegram message (content) -> None
-    
-    Returns:
-        Summary dict of actions taken in this cycle
-    """
-    life_state = load_life_state()
-    actions_taken = []
-
-    # Phase 1: Deterministic YouTube sync (no LLM)
-    # In deployed system: exec("python3 youtube_sync.py")
-    # Output: heartbeat_data/youtube.json
-
-    # Phase 2: Spawn 7 Haiku collectors in parallel
-    # Each receives exact task spec from HEARTBEAT_INSTRUCTIONS.md
-    # NOTE: Capture task IDs before any await/wait call
-    task_ids = []
-    for collector in ["clock", "context", "health", "home", "email", "browser", "weather"]:
-        task_id = spawn_fn(
-            model=COLLECTOR_MODEL,
-            label=f"hb-{collector}",
-            task=f"<task spec for hb-{collector} from HEARTBEAT_INSTRUCTIONS.md>"
-        )
-        task_ids.append(task_id)
-
-    # Phase 3: Wait for all collectors
-    wait_fn(task_ids)
-
-    # Phase 4: Read all outputs
-    data = {name: read_collector_output(name) for name in COLLECTOR_BUDGETS}
-    data["youtube"] = read_collector_output("youtube")
-
-    # Phase 5: Interpret state
-    clock = data.get("clock") or {}
-    health = data.get("health") or {}
-    context = data.get("context") or {}
-    home = data.get("home") or {}
-    email = data.get("email") or {}
-
-    location = (health.get("location") or {})
-    lat = location.get("lat")
-    lon = location.get("lon")
-    at_home = is_at_home(lat, lon) if (lat and lon) else True  # default safe
-
-    current_hour = int(clock.get("time", "12:00").split(":")[0])
-    last_tg_min = context.get("last_user_message_ago_minutes")
-    alice_active = bool(home.get("kitchen", {}).get("state") == "playing")
-
-    # Phase 6: Location change detection
-    last_loc = life_state.get("last_location", {})
-    last_lat = last_loc.get("lat")
-    last_lon = last_loc.get("lon")
-    if lat and lon and last_lat and last_lon:
-        moved = haversine_distance_m(lat, lon, last_lat, last_lon) > HOME_RADIUS_M
-        if moved:
-            # In deployed system: goplaces lookup for venue name
-            actions_taken.append(f"location_change: ({lat:.4f}, {lon:.4f})")
-
-    # Phase 7: Email triage
-    threads = (email.get("threads") or [])
-    for thread in threads:
-        thread_id = thread.get("thread_id", "")
-        if should_alert_email(thread_id, life_state):
-            subject = thread.get("subject", "")
-            sender = thread.get("sender", "")
-            if _is_urgent(subject, sender):
-                message_fn(content=f"📧 {sender}: {subject}")
-                life_state.setdefault("alerted_email_ids", []).append(thread_id)
-                actions_taken.append(f"email_alert: {thread_id}")
-
-    # Phase 8: Sleep/wake inference
-    prev_sleep = life_state.get("sleep_state", "awake")
-    new_sleep = infer_sleep_state(
-        last_telegram_ago_min=last_tg_min,
-        at_home=at_home,
-        current_hour=current_hour,
-        alice_has_activity=alice_active,
-        significant_steps=False,  # would read from health data
-        previous_state=prev_sleep,
-    )
-    if new_sleep != prev_sleep:
-        life_state["sleep_state"] = new_sleep
-        actions_taken.append(f"sleep_state_change: {prev_sleep} -> {new_sleep}")
-
-    # Phase 9: Vacuum automation
-    if should_start_vacuum(life_state, at_home):
-        # In deployed system: curl HA vacuum.start
-        life_state["last_vacuum_run"] = str(date.today())
-        actions_taken.append("vacuum_started")
-
-    # Phase 10: Update location in state
-    if lat and lon:
-        life_state["last_location"] = {"lat": lat, "lon": lon}
-
-    # Phase 11: Persist state
-    save_life_state(life_state)
-
-    return {"actions": actions_taken, "cycle_time": clock.get("timestamp")}
-
-
-def _is_urgent(subject: str, sender: str) -> bool:
-    """
-    Heuristic: is this email time-sensitive enough to alert immediately?
-    Filters out newsletters, automated notifications, and promotions.
-    """
-    urgent_keywords = [
-        "expir", "deadline", "urgent", "suspend", "block", "action required",
-        "security alert", "sign in", "new device", "payment", "invoice",
-        "доставлен", "срок", "блок", "вход", "безопасность",
-    ]
-    spam_senders = [
-        "noreply@newsletter", "marketing@", "promo@", "deals@",
-        "notifications@duolingo", "no-reply@github",
-    ]
-    text = (subject + " " + sender).lower()
-    if any(s in text for s in spam_senders):
-        return False
-    return any(k in text for k in urgent_keywords)
@@ -1,39 +0,0 @@
-observations:
-
-  - id: O01
-    timestamp: "2026-05-05T22:54"
-    provenance: ai-suggested
-    content: >
-      ARA's structured layer separation (logic / src / trace / evidence / staging) combined with
-      Seal L1/L2 validation enables machine-auditable rigor that unstructured HISTORY.md + KNOWLEDGE.md
-      cannot provide. The compiler's 145+ check suite on nanobot ARA and 22-file traefik ARA both
-      passing L1 on first run suggests the format is viable for operational agent projects, not only
-      academic papers.
-    context: >
-      Session 2026-05-05: ARA protocol adopted for WyLab, both nanobot and traefik-infrastructure
-      ARAs compiled and Seal L1 validated in the same session. Observation arose from the compiler
-      run results and the decision to adopt ARA system-wide.
-    potential_type: claim
-    bound_to: [N20, N24, N25]
-    promoted: false
-    promoted_to: null
-    crystallized_via: null
-    stale: false
-
-  - id: O02
-    timestamp: "2026-05-05T22:54"
-    provenance: user
-    content: >
-      SMB guest access (no credentials, //192.168.1.50/ara) is the viable method for nanobot to
-      mount Unraid network storage when SSH pubkey is not provisioned and NFS is not enabled.
-      Guest SMB does not require any credential management and works immediately once the share
-      is created in the Unraid UI.
-    context: >
-      Session 2026-05-05: SSH (.50, pubkey required) and NFS (not enabled) both failed as mount
-      options. SMB guest access succeeded and was used to mount the ara share.
-    potential_type: constraint
-    bound_to: [N22, N23]
-    promoted: false
-    promoted_to: null
-    crystallized_via: null
-    stale: false
@@ -1,290 +0,0 @@
-# Exploration Tree — nanobot
-# Research DAG: key architectural decisions, dead ends, and pivots in the nanobot system.
-# Node types: question | experiment | dead_end | decision | pivot
-# support_level: explicit (directly from source material) | inferred (reconstructed from narrative)
-
-tree:
-
-  - id: N01
-    type: question
-    support_level: explicit
-    source_refs: ["PAPER.md §abstract", "KNOWLEDGE.md §Heartbeat Architecture"]
-    title: "How to build a persistent life-assistant agent that runs autonomously 24/7?"
-    description: "Core design challenge: maintain continuous awareness of a user's life (location, health, email, home state) using a 30-minute autonomous cycle, without exhausting LLM context, quota, or developer attention."
-    children:
-
-      - id: N02
-        type: experiment
-        support_level: explicit
-        source_refs: ["HISTORY.md [2026-02-14 00:22]", "HISTORY.md [2026-02-14 10:21]"]
-        title: "Sequential 18-step Sonnet heartbeat (initial design)"
-        result: "Heartbeat executed 18 sequential steps in a single Sonnet agent session. Caused iteration exhaustion at max_iterations=15, missing data collection steps. Later increased to 50 iterations — functional but slow (~60-100s per cycle) and expensive."
-        evidence: ["C01", "HISTORY.md [2026-02-14 10:21]"]
-        children:
-
-          - id: N03
-            type: dead_end
-            support_level: explicit
-            source_refs: ["HISTORY.md [2026-02-14 10:21]"]
-            title: "Sequential heartbeat exhausts iteration budget"
-            hypothesis: "A single Sonnet agent can complete all 18 heartbeat steps (data collection + interpretation + action) within 15 iterations."
-            failure_mode: "At max_iterations=15, the agent ran out of iterations before completing all steps, leaving data collection incomplete and omitting actions. Increasing to 50 iterations mitigated but did not eliminate the problem — long cycles remained and API 529 overload errors could abort mid-cycle."
-            lesson: "Monolithic sequential execution makes the heartbeat brittle to both iteration limits and API transient errors. Parallel architecture isolates failures: a single collector timeout does not block the other 7."
-
-          - id: N04
-            type: pivot
-            support_level: explicit
-            source_refs: ["HISTORY.md [2026-02-18 21:36]", "HISTORY.md [2026-02-18 21:39]"]
-            title: "Pivot from sequential to parallel Haiku-collector + Sonnet-orchestrator architecture"
-            from: "Single Sonnet agent executing all 18 heartbeat steps sequentially"
-            to: "Sonnet orchestrator spawning 8 Haiku collectors in parallel, then interpreting their compact JSON output files"
-            trigger: "Nested subagent spawning confirmed working (Haiku spawned by Sonnet, Haiku writes file correctly). Sequential design exhausts iterations and is slow. Parallel design reduces wall-clock time from Σ(t_i) to max(t_i) + t_orchestrator."
-            children:
-
-              - id: N05
-                type: experiment
-                support_level: explicit
-                source_refs: ["HISTORY.md [2026-02-18 21:39-21:50]"]
-                title: "First parallel heartbeat run — test all 8 collectors simultaneously"
-                result: "All 8 collectors wrote compact JSON files. Identified two critical issues: (1) subagent.py hardcodes 'Summarize this naturally for the user' into completion announcements, routing all 8 Haiku completions to Telegram as spam; (2) YouTube per-video summarization spawned 7 additional Haikus synchronously within the orchestrator's iteration budget."
-                evidence: ["C01", "HISTORY.md [2026-02-18 21:39]"]
-                children:
-
-                  - id: N06
-                    type: decision
-                    support_level: explicit
-                    source_refs: ["HISTORY.md [2026-03-03 03:17]", "HISTORY.md [2026-03-03 03:21]"]
-                    title: "Replace LLM YouTube collector with deterministic youtube_sync.py script"
-                    choice: "Python script queries YouTube Data API, stores to SQLite + Qdrant, writes heartbeat_data/youtube.json as a diff since last heartbeat. Runs before Haiku spawn."
-                    alternatives:
-                      - "Keep Haiku collector fetching from YouTube API (rejected — hallucination under DNS failure)"
-                      - "Ask Sonnet orchestrator to recover when hb-youtube fails (rejected — orchestrator fabricated video IDs)"
-                    evidence: "HISTORY.md [2026-03-03 02:48]: user confirmed YouTube hallucinations. Video IDs from heartbeat positions 6-10 were non-existent on YouTube. Root cause: when hb-youtube failed, Sonnet 'recovered' by hallucinating titles."
-
-      - id: N07
-        type: question
-        support_level: explicit
-        source_refs: ["HISTORY.md [2026-02-19 03:06]", "claims.md C02"]
-        title: "How to maintain prompt-cache hit rates while allowing session state to update?"
-        description: "Every MEMORY.md update to the system prompt busts the cache, causing full re-processing of KNOWLEDGE.md on every turn. How to decouple stable context from volatile state?"
-        children:
-
-          - id: N08
-            type: dead_end
-            support_level: explicit
-            source_refs: ["HISTORY.md [2026-02-19 03:06]"]
-            title: "Single system prompt file including MEMORY.md"
-            hypothesis: "Including all agent context (KNOWLEDGE.md + MEMORY.md) in a single system prompt block would provide full context with cache efficiency."
-            failure_mode: "MEMORY.md updates occur multiple times per session (current project state, deferred decisions). Each update changed the exact byte content of the system prompt, invalidating the cache checkpoint. Cache hit rate fell to near zero — every turn paid full re-processing cost for the entire system prompt (~16k tokens)."
-            lesson: "Only stable content should be in the cached system prompt prefix. Any content that changes intra-session must be excluded from the cache checkpoint and loaded on demand."
-
-          - id: N09
-            type: decision
-            support_level: explicit
-            source_refs: ["HISTORY.md [2026-02-19 03:06]", "KNOWLEDGE.md §Memory Layout"]
-            title: "Split memory into KNOWLEDGE.md (cached) vs MEMORY.md (excluded) vs HISTORY.md (append-only)"
-            choice: "KNOWLEDGE.md: stable facts, in cached system prompt, updated at most weekly. MEMORY.md: volatile in-progress state, NOT in system prompt, loaded on demand. HISTORY.md: append-only event log, never in system prompt, grep-searchable."
-            alternatives:
-              - "Single system prompt file (rejected — cache bust on every MEMORY.md write)"
-              - "In-context memory only (rejected — information lost on session clear)"
-              - "Full mem0 replacement (explored March 2026 — used alongside, not instead of file-based memory)"
-            evidence: "Second cache checkpoint working post-split. cache_read=16k+ tokens on hits, cache_write=2-3k for new conversation turns only."
-
-      - id: N10
-        type: experiment
-        support_level: explicit
-        source_refs: ["HISTORY.md [2026-02-13 18:16]", "HISTORY.md [2026-02-13 23:45]"]
-        title: "DNS latency investigation — 8-second delay on all outbound requests"
-        result: "All Docker containers had 8-second DNS latency. Root cause: /etc/resolv.conf listed 192.168.1.50 (Technitium, unreachable via Docker NAT) before 1.1.1.1. Self-inflicted outage when agent edited /etc/resolv.conf and left only the broken nameserver — required external container restart."
-        evidence: ["C05", "HISTORY.md [2026-02-13]"]
-        children:
-
-          - id: N11
-            type: dead_end
-            support_level: explicit
-            source_refs: ["HISTORY.md [2026-02-13]"]
-            title: "Writing to /etc/resolv.conf inside the nanobot container"
-            hypothesis: "Editing /etc/resolv.conf inside the running container would allow testing different nameserver configurations without restarting Docker."
-            failure_mode: "Agent edited /etc/resolv.conf and left only 192.168.1.50 (unreachable from container NAT) in the file. This killed all DNS resolution inside the container. Required Makar to restart the container externally. No recovery path from within the container."
-            lesson: "Never write to system config files (/etc/resolv.conf, /etc/hosts, /etc/docker/daemon.json) from inside the nanobot container. DNS configuration is managed at the host level via Docker daemon.json. The correct fix: {'dns': ['172.17.0.1']} in /etc/docker/daemon.json on the Unraid host."
-
-          - id: N12
-            type: decision
-            support_level: explicit
-            source_refs: ["HISTORY.md [2026-02-13 18:16]", "claims.md C05"]
-            title: "Fix DNS via bridge gateway IP in Docker daemon.json"
-            choice: "Added {'dns': ['172.17.0.1']} to /etc/docker/daemon.json on Unraid, persisted to /boot/config/go. Technitium runs in host mode and binds to the docker0 bridge gateway (172.17.0.1), which is reachable from all containers. DNS latency reduced from 8 seconds to ~2ms."
-            alternatives:
-              - "Use host networking for nanobot container (rejected — loses isolation, changes all network semantics)"
-              - "Use 1.1.1.1 as primary DNS (rejected — would bypass Technitium and break .wylab.me internal resolution)"
-            evidence: "HISTORY.md [2026-02-13 18:16]: 'containers now resolve in ~2ms.' All skills confirmed fast after fix."
-
-      - id: N13
-        type: experiment
-        support_level: explicit
-        source_refs: ["HISTORY.md [2026-02-14 03:05]", "claims.md C07"]
-        title: "Yandex Station control — 4-5 wrong attempts before finding correct API path"
-        result: "Agent repeatedly sent TTS ('Произнеси текст') instead of direct media_player/media_pause calls to pause Yandex Station playback. This caused the station to read the pause command aloud through the speaker rather than executing it. Failed 4-5 times in a single session despite user corrections after each attempt."
-        evidence: ["C07", "HISTORY.md [2026-02-14 03:05]"]
-        children:
-
-          - id: N14
-            type: dead_end
-            support_level: explicit
-            source_refs: ["HISTORY.md [2026-02-14 03:05]", "skills/yandex-station/SKILL.md"]
-            title: "Using TTS mode to send control commands to Yandex Station"
-            hypothesis: "Home Assistant's text-to-speech service could relay control commands (pause, stop, volume) to Yandex Station through Alice's voice command processing."
-            failure_mode: "TTS reads the command text aloud through the station's speaker — it does NOT execute the command. Calling tts.speak with 'pause' makes Alice say the word 'pause'. The correct API path is media_player/media_pause for pause, media_player/media_stop for stop, media_player/volume_set for volume. The TTS endpoint is only for synthesizing arbitrary speech to the room."
-            lesson: "The iron law in the yandex-station skill: NEVER use TTS for control. NEVER use Alice command passthrough for playback. ALWAYS use media_player/* service calls directly. The confusion arises because all three mechanisms use similar HA service call syntax."
-
-      - id: N15
-        type: question
-        support_level: explicit
-        source_refs: ["HISTORY.md [2026-02-21]", "claims.md C04"]
-        title: "How to give the conversational agent awareness of heartbeat-sent messages?"
-        description: "Heartbeat runs in a separate session and sends Telegram messages directly. When user replies, conversational agent has no context of what heartbeat said, producing confused responses."
-        children:
-
-          - id: N16
-            type: dead_end
-            support_level: explicit
-            source_refs: ["HISTORY.md [2026-02-21]"]
-            title: "Heartbeat subagent sends Telegram messages via curl directly"
-            hypothesis: "Having heartbeat subagents call the Telegram API via curl would deliver alerts to Makar without requiring the main agent's involvement."
-            failure_mode: "Messages sent via curl are invisible to the conversational agent's session. When Makar replies to a heartbeat message, the conversational agent sees only his reply with no context of what triggered it, producing confused or contradictory responses. User experienced multiple instances of the agent 'flip-flopping' when responding to heartbeat alerts it couldn't see."
-            lesson: "All subagent-to-user messages must route through the main agent's message() tool. The message() tool writes to both Telegram and the session JSONL file, making heartbeat-sent content visible to subsequent conversational turns."
-
-          - id: N17
-            type: decision
-            support_level: explicit
-            source_refs: ["MEMORY.md [2026-05-01]", "HEARTBEAT_INSTRUCTIONS.md §Messaging"]
-            title: "Mandate message() tool for all heartbeat-to-user communication"
-            choice: "Heartbeat subagents use the message() tool exclusively for Telegram communication. The message() tool routes through the session manager, writing sent content to the Telegram session JSONL before delivering to Telegram. The main conversational agent can then see what was sent when user replies."
-            alternatives:
-              - "Heartbeat logs to a file that conversational agent reads on demand (rejected — passive, delayed, fragile)"
-              - "System bus message injection (explored — architecturally cleaner but required more code changes)"
-            evidence: "MEMORY.md [2026-05-01]: 'CRITICAL HEARTBEAT FIX — Subagent messages are INTERNAL — they do NOT reach Makar's Telegram. Only the main orchestrator agent can send via message() tool.'"
-
-      - id: N18
-        type: experiment
-        support_level: explicit
-        source_refs: ["HISTORY.md [2026-12-14]", "HISTORY.md [2026-12-18]", "claims.md C08"]
-        title: "SS14 CI/CD debugging — runner DNS + cache corruption failures"
-        result: "SS14 CI/CD pipeline failed with DNS resolution errors (git.wylab.me unreachable from runners). Tried: adding 1.1.1.1 as DNS, host network mode, separate runner DNS config. Eventually identified .NET build cache corruption from mixed ARM64/x64 runners sharing cache. Fixed with local per-runner file cache and no remote sharing."
-        evidence: ["C08", "HISTORY.md [2026-12-14]", "HISTORY.md [2026-12-18]"]
-        children:
-
-          - id: N19
-            type: dead_end
-            support_level: explicit
-            source_refs: ["HISTORY.md [2026-12-15]", "HISTORY.md [2026-12-18]"]
-            title: "Multiple failed SS14 CI/CD runner DNS configurations"
-            hypothesis: "Adding 1.1.1.1 as the runner's DNS server, or switching to host network mode, would resolve git.wylab.me from within CI/CD runner containers."
-            failure_mode: "Adding 1.1.1.1 as DNS did not work (runner containers still couldn't resolve internal Gitea domain). Host network mode partially worked (1/6 jobs succeeded) but was not reproducible. Root cause was not DNS at all — it was .NET build cache corruption from the macOS ARM64 OrbStack runner sharing a cache with the x64 Linux runner. Architecture-incompatible cached binaries caused cryptic build failures that looked like DNS or network errors."
-            lesson: "Mixed-architecture CI/CD runners must use separate, isolated build caches. Architecture-specific cache keys prevent cross-contamination. The DNS red herring wasted multiple days of debugging — always verify the failure mode before trying infrastructure fixes."
-
-  - id: N20
-    type: decision
-    provenance: user
-    timestamp: "2026-05-05T22:54"
-    title: "Adopt ARA (Agent-Native Research Artifact) format for all WyLab projects"
-    choice: >
-      Discovered the ARA protocol from Orchestra-Research and decided to adopt it as the standard
-      structured artifact format for all WyLab projects. ARA enforces progressive crystallization,
-      provenance tracking, and machine-readable layer separation (logic / src / trace / evidence /
-      staging), enabling rigor auditing and structured compaction.
-    alternatives:
-      - "Continue with unstructured HISTORY.md + KNOWLEDGE.md only (rejected — no provenance, no structured claims layer)"
-      - "Custom internal documentation format (rejected — ARA already exists and has compiler + rigor tooling)"
-    evidence: ["Discovery of Orchestra-Research ARA protocol", "Three ARA skills available: ara-compiler, ara-research-manager, ara-rigor-reviewer"]
-    status: resolved
-    children:
-
-      - id: N21
-        type: decision
-        provenance: user
-        timestamp: "2026-05-05T22:54"
-        title: "Create ARA repo at git.wylab.me/nanobot/ara and install three ARA skills"
-        choice: >
-          ARA repository initialized at git.wylab.me/nanobot/ara. Three ARA skills installed into
-          nanobot workspace: ara-compiler (Seal L1/L2 validation + compilation), ara-research-manager
-          (per-turn progressive crystallization epilogue), ara-rigor-reviewer (L2 structural review).
-          research-manager wired into KNOWLEDGE.md compaction protocol as mandatory pre-compaction step.
-        alternatives:
-          - "Store ARA artifacts locally only without a dedicated repo (rejected — no versioning or sharing)"
-        evidence: ["N20"]
-        status: resolved
-
-      - id: N22
-        type: dead_end
-        provenance: user
-        timestamp: "2026-05-05T22:54"
-        title: "Unraid LAN IP was .78 (wrong) — SSH pubkey required — NFS not enabled"
-        hypothesis: >
-          Unraid server reachable at 192.168.1.78; SSH accessible with password; NFS available for
-          mounting the ara share.
-        failure_mode: >
-          Unraid LAN IP is 192.168.1.50, not .78 (KNOWLEDGE.md was stale). SSH login requires
-          pubkey authentication — password auth not accepted. NFS share not enabled on Unraid.
-          All three assumptions were wrong simultaneously; prior KNOWLEDGE.md entry for .78 must
-          be corrected.
-        lesson: >
-          Always verify Unraid IP from a live source before scripting mounts. SSH pubkey must be
-          provisioned before any automated SSH-based tasks can run against Unraid. NFS requires
-          explicit enablement in Unraid UI; do not assume it is on. SMB guest access is the
-          available path for unauthenticated mounts.
-        status: resolved
-
-      - id: N23
-        type: decision
-        provenance: user
-        timestamp: "2026-05-05T22:54"
-        title: "Mount Unraid ara share via SMB guest access at //192.168.1.50/ara"
-        choice: >
-          Created ara SMB share on Unraid and mounted it at //192.168.1.50/ara using SMB guest
-          access (no credentials). This is the operative method for nanobot to read/write compiled
-          ARA artifacts to network storage after SSH and NFS were ruled out.
-        alternatives:
-          - "SSH-based file transfer (ruled out — pubkey not provisioned)"
-          - "NFS mount (ruled out — NFS not enabled on Unraid)"
-          - "Manual file copy (rejected — not automatable)"
-        evidence: ["N22"]
-        status: resolved
-
-      - id: N24
-        type: experiment
-        provenance: ai-executed
-        timestamp: "2026-05-05T22:54"
-        title: "Compile nanobot ARA — 30 files, 145+ Seal L1 checks pass"
-        result: >
-          ara-compiler ran against the nanobot ARA. Output: 30 files compiled, 145+ Seal L1
-          structural/provenance checks passed. No L1 failures. Artifact validated as structurally
-          conformant to ARA spec.
-        evidence: ["ara-compiler Seal L1 output, 2026-05-05"]
-        status: resolved
-
-      - id: N25
-        type: experiment
-        provenance: ai-executed
-        timestamp: "2026-05-05T22:54"
-        title: "Compile traefik-infrastructure ARA — 22 files, Seal L1 validated"
-        result: >
-          ara-compiler ran against the traefik-infrastructure ARA. Output: 22 files compiled,
-          Seal L1 validation passed. Second WyLab ARA successfully onboarded to the format.
-        evidence: ["ara-compiler Seal L1 output, 2026-05-05"]
-        status: resolved
-
-      - id: N26
-        type: decision
-        provenance: user
-        timestamp: "2026-05-05T22:54"
-        title: "Wire ara-research-manager into KNOWLEDGE.md compaction protocol"
-        choice: >
-          Added ara-research-manager as a mandatory step in KNOWLEDGE.md's compaction protocol.
-          Before any compaction run, the research manager epilogue must be executed to ensure all
-          staged observations and trace events are committed to the ARA. Prevents knowledge loss
-          at compaction boundaries.
-        alternatives:
-          - "Run research-manager ad hoc only when remembered (rejected — prone to gaps at compaction)"
-        evidence: ["N20", "N21"]
-        status: resolved
@@ -1,13 +0,0 @@
-entries:
-  - turn: "2026-05-05_001#1"
-    notes:
-      - "Routed N20 (ARA adoption) as decision/direct — user explicitly chose ARA over alternatives; clear journey fact."
-      - "Routed N22 as dead_end/direct rather than three separate dead_ends — all three failures (wrong IP, SSH pubkey, NFS) are causally linked and discovered in the same investigative thread; bundling avoids fragmentation."
-      - "Routed N23 (SMB guest mount) as decision/direct — user chose this after N22 eliminated alternatives; has clear evidence binding."
-      - "Routed N24/N25 as experiments/direct — compiler runs produced quantitative results (file counts, check counts); these are empirical facts, not interpretations."
-      - "Staged O01 as potential_type: claim (not direct) — 'ARA enables machine-auditable rigor' is an interpretive assertion about format capability, not a journey fact. Needs at least one session of use before it qualifies for any closure signal."
-      - "Staged O02 as potential_type: constraint (not direct) — SMB-as-workaround is a boundary condition about what works given absent SSH pubkey and NFS. User stated it as fact (provenance: user) but it hasn't yet been tested under load or across reboots."
-      - "Did NOT crystallize O01 or O02 this turn — no closure signal present. Verbal-affirmation would require explicit 'yes, that's confirmed' from user; topic-abandonment requires 5 turns idle; artifact-commitment requires a downstream entry citing them."
-      - "Noted KNOWLEDGE.md IP correction (.78→.50) as open thread — not logging a new node for this since it's a metadata correction, not a new research event. The dead_end N22 captures the lesson."
-      - "No prior staged observations existed (staging/observations.yaml was empty) — no maturity tracking needed this turn."
-      - "exploration_tree.yaml had no existing N20+ nodes — assigned N20–N26 sequentially. No ID conflicts."
@@ -1,125 +0,0 @@
-session:
-  id: "2026-05-05_001"
-  date: "2026-05-05"
-  started: "2026-05-05T22:54"
-  last_turn: "2026-05-05T22:54"
-  turn_count: 1
-  summary: "ARA protocol adopted for WyLab; nanobot + traefik-infrastructure ARAs compiled and Seal L1 validated; Unraid ara SMB share mounted; research-manager wired into compaction protocol; Unraid IP corrected from .78 to .50."
-
-events_logged:
-  - turn: 1
-    type: decision
-    id: "N20"
-    routing: direct
-    provenance: user
-    summary: "Adopt ARA format for all WyLab projects; discovered Orchestra-Research ARA protocol"
-
-  - turn: 1
-    type: decision
-    id: "N21"
-    routing: direct
-    provenance: user
-    summary: "ARA repo created at git.wylab.me/nanobot/ara; three ARA skills installed (ara-compiler, ara-research-manager, ara-rigor-reviewer)"
-
-  - turn: 1
-    type: dead_end
-    id: "N22"
-    routing: direct
-    provenance: user
-    summary: "Unraid IP was .78 (stale) — correct is .50; SSH requires pubkey; NFS not enabled — all three access assumptions wrong"
-
-  - turn: 1
-    type: decision
-    id: "N23"
-    routing: direct
-    provenance: user
-    summary: "Mount Unraid ara share via SMB guest access at //192.168.1.50/ara"
-
-  - turn: 1
-    type: experiment
-    id: "N24"
-    routing: direct
-    provenance: ai-executed
-    summary: "nanobot ARA compiled: 30 files, 145+ Seal L1 checks pass"
-
-  - turn: 1
-    type: experiment
-    id: "N25"
-    routing: direct
-    provenance: ai-executed
-    summary: "traefik-infrastructure ARA compiled: 22 files, Seal L1 validated"
-
-  - turn: 1
-    type: decision
-    id: "N26"
-    routing: direct
-    provenance: user
-    summary: "research-manager wired into KNOWLEDGE.md compaction protocol as mandatory pre-compaction step"
-
-  - turn: 1
-    type: observation
-    id: "O01"
-    routing: staged
-    provenance: ai-suggested
-    summary: "ARA structured layers + Seal L1 validation enables machine-auditable rigor not achievable with unstructured files (potential_type: claim)"
-
-  - turn: 1
-    type: observation
-    id: "O02"
-    routing: staged
-    provenance: user
-    summary: "SMB guest access is the viable Unraid mount method when SSH pubkey absent and NFS disabled (potential_type: constraint)"
-
-ai_actions:
-  - turn: 1
-    action: "Read SKILL.md, event-taxonomy.md, existing ara/ files for current state"
-    provenance: ai-executed
-    files_changed: []
-
-  - turn: 1
-    action: "Appended N20–N26 to trace/exploration_tree.yaml (7 nodes: 4 decisions, 1 dead_end, 2 experiments)"
-    provenance: ai-executed
-    files_changed: ["trace/exploration_tree.yaml"]
-
-  - turn: 1
-    action: "Wrote staging/observations.yaml with O01 (claim candidate) and O02 (constraint candidate)"
-    provenance: ai-executed
-    files_changed: ["staging/observations.yaml"]
-
-  - turn: 1
-    action: "Created trace/sessions/2026-05-05_001.yaml (this file)"
-    provenance: ai-executed
-    files_changed: ["trace/sessions/2026-05-05_001.yaml"]
-
-  - turn: 1
-    action: "Updated trace/sessions/session_index.yaml with 2026-05-05_001 entry"
-    provenance: ai-executed
-    files_changed: ["trace/sessions/session_index.yaml"]
-
-  - turn: 1
-    action: "Appended entry to trace/pm_reasoning_log.yaml"
-    provenance: ai-executed
-    files_changed: ["trace/pm_reasoning_log.yaml"]
-
-claims_touched: []
-
-key_context:
-  - turn: 1
-    excerpt: >
-      "Discovery of the ARA (Agent-Native Research Artifact) protocol from Orchestra-Research.
-      Decision to adopt ARA format for all WyLab projects. ARA repo created at git.wylab.me/nanobot/ara.
-      Three ARA skills installed. Unraid ara SMB share created and mounted at //192.168.1.50/ara.
-      nanobot ARA compiled (30 files, 145+ Seal L1 checks pass). traefik-infrastructure ARA compiled
-      (22 files, Seal L1 validated). research-manager wired into compaction protocol in KNOWLEDGE.md.
-      Dead ends: Unraid LAN at 192.168.1.50 (not .78 as previously in KNOWLEDGE.md), SSH requires
-      pubkey, NFS not enabled, SMB guest access works."
-
-open_threads:
-  - "Unraid SSH pubkey not yet provisioned — blocks automated SSH-based tasks against Unraid"
-  - "NFS not enabled on Unraid — SMB guest is current workaround; may want NFS for performance later"
-  - "ara-rigor-reviewer (L2) not yet run on either ARA — only L1 validated so far"
-  - "O01 (ARA rigor claim) and O02 (SMB constraint) staged but not yet crystallized — await closure signals"
-  - "KNOWLEDGE.md .78 IP entry should be corrected to .50 if not already done"
-
-ai_suggestions_pending:
-  - "O01: ARA structured layers enable machine-auditable rigor — staged as potential claim, not yet affirmed"
@@ -1,8 +0,0 @@
-sessions:
-  - id: "2026-05-05_001"
-    date: "2026-05-05"
-    summary: "ARA protocol adopted for WyLab; nanobot + traefik ARAs Seal L1 compiled; Unraid SMB ara share mounted; Unraid IP corrected .78→.50; research-manager wired into compaction protocol"
-    turn_count: 1
-    events_count: 9
-    claims_touched: []
-    open_threads: 5
@@ -1,31 +0,0 @@
-x-common-config: &common-config
-  build:
-    context: .
-    dockerfile: Dockerfile
-  volumes:
-    - ~/.nanobot:/root/.nanobot
-
-services:
-  nanobot-gateway:
-    container_name: nanobot-gateway
-    <<: *common-config
-    command: ["gateway"]
-    restart: unless-stopped
-    ports:
-      - 18790:18790
-    deploy:
-      resources:
-        limits:
-          cpus: '1'
-          memory: 1G
-        reservations:
-          cpus: '0.25'
-          memory: 256M
-  
-  nanobot-cli:
-    <<: *common-config
-    profiles:
-      - cli
-    command: ["status"]
-    stdin_open: true
-    tty: true
@@ -1,265 +0,0 @@
-# Design: Native Anthropic Tools Integration
-
-**Goal**: Integrate Anthropic's native trained tools (bash_20250124, text_editor_20250728, computer_20251124) into nanobot to leverage model's trained behaviors instead of custom function tools.
-
-## Overview
-
-Anthropic's native tools are version-coupled to model training. Unlike custom function tools (which the model learns via instruction-following at inference time), native tools have their behaviors baked into model weights during training. This provides more reliable tool execution.
-
-**Key Insight**: The Anthropic API accepts BOTH tool formats in the same request:
- Function tools: `{type: "function", function: {name, description, input_schema}}`
- Native tools: `{type: "bash_20250124", name: "bash"}` (schema-less)
-
-## Architecture
-
-### 1. Tool Addition Strategy
-
-Add three native tool implementations from anthropic-quickstarts reference:
- **BashTool20250124** - persistent bash session (replaces ExecTool)
- **EditTool20250728** - file operations with view/create/str_replace/insert (replaces EditTool, possibly ReadFileTool/WriteFileTool)
- **ComputerTool20251124** - VNC desktop control (new capability)
-
-Location: `nanobot/agent/tools/anthropic/` (new subpackage)
-
-Port from reference:
- Base classes: `BaseAnthropicTool`, `ToolResult`, `CLIResult`, `ToolError`
- Tool implementations with trained behaviors intact
- Session management (_BashSession for bash tool)
-
-### 2. Registry Changes
-
-Make `ToolRegistry` format-agnostic via duck typing:
-
-**Current**: Only calls `tool.to_schema()`, expects function format
-
-**New**: Support both interfaces
-```python
-def get_definitions(self) -> list[dict[str, Any]]:
-    definitions = []
-    for tool in self._tools.values():
-        if hasattr(tool, 'to_params'):  # Native Anthropic tool
-            definitions.append(tool.to_params())
-        elif hasattr(tool, 'to_schema'):  # Function tool
-            definitions.append(tool.to_schema())
-        else:
-            raise ValueError(f"Tool {tool.name} has no schema method")
-    return definitions
-```
-
-**Execution**: No changes needed - `execute()` already looks up by name and calls the tool. Native tools implement `__call__(**kwargs)` which works with existing dispatch.
-
-**Result**: Registry becomes thin coordination layer, doesn't enforce specific base class.
-
-### 3. Tool Implementations
-
-#### BashTool20250124
- Maintains persistent bash session via `_BashSession` class
- Sentinel-based output reading for reliable command capture
- Timeout handling (120s default)
- Restart capability
- Returns: `ToolResult(output=..., error=...)`
-
-#### EditTool20250728
- Commands: `view`, `create`, `str_replace`, `insert`
- Path validation (absolute paths required)
- `str_replace`: uniqueness checking before replacement
- `insert`: line number validation
- File history tracking for potential undo
- Returns: `CLIResult(output=...)` with formatted snippets
-
-#### ComputerTool20251124
- VNC desktop interaction (keyboard, mouse, screenshots)
- Actions: `key`, `type`, `mouse_move`, `left_click`, `right_click`, `double_click`, `screenshot`, etc.
- Screenshot returns `ToolResult(base64_image=...)`
- Coordinate scaling support
- Connects to VNC at 172.17.0.1:5900 (Windows VM from code-server)
-
-### 4. API Integration
-
-Update `anthropic_oauth.py._convert_tools_to_anthropic()` to pass through both formats:
-
-**Current**: Only converts `type: "function"` tools
-```python
-if tool.get("type") == "function":
-    # convert to Anthropic format
-```
-
-**New**: Pass through ALL formats
-```python
-def _convert_tools_to_anthropic(self, tools: list[dict[str, Any]] | None) -> list[dict[str, Any]] | None:
-    if not tools:
-        return None
-
-    anthropic_tools = []
-    for tool in tools:
-        if tool.get("type") == "function":
-            # Convert function tool format
-            func = tool["function"]
-            anthropic_tools.append({
-                "name": func["name"],
-                "description": func.get("description", ""),
-                "input_schema": func.get("parameters", {"type": "object", "properties": {}})
-            })
-        else:
-            # Pass through native tool format as-is
-            # (bash_20250124, text_editor_20250728, computer_20251124)
-            anthropic_tools.append(tool)
-
-    return anthropic_tools if anthropic_tools else None
-```
-
-**Distinction**: Based on `type` field
- `type == "function"` → function tool, needs conversion
- `type == "bash_20250124"` (or other native type) → pass through as-is
-
-### 5. Tool Result Handling
-
-**Current**: Tools return plain strings
-
-**New**: Native tools return `ToolResult` objects
-```python
-@dataclass(kw_only=True, frozen=True)
-class ToolResult:
-    output: str | None = None
-    error: str | None = None
-    base64_image: str | None = None
-    system: str | None = None
-```
-
-**Agent loop changes** (`loop.py`): Handle both return types
-```python
-result = await self.tools.execute(tool_name, tool_input)
-
-if isinstance(result, ToolResult):
-    # Native tool result - build structured content
-    tool_result_content = []
-    if result.output:
-        tool_result_content.append({"type": "text", "text": result.output})
-    if result.error:
-        tool_result_content.append({"type": "text", "text": f"Error: {result.error}"})
-    if result.base64_image:
-        # Image handling (see Section 6)
-        pass
-    if result.system:
-        # System messages for next turn
-        pass
-else:
-    # Legacy string result from function tools
-    tool_result_content = [{"type": "text", "text": str(result)}]
-```
-
-### 6. Image Handling Flow
-
-**Goal**: Both model and user see screenshots from computer tool
-
-**Implementation**: Track media across tool iteration loop
-
-```python
-# At start of agent turn
-media_paths_for_turn: list[str] = []
-
-# During tool execution
-if isinstance(result, ToolResult) and result.base64_image:
-    # 1. Save to disk for user
-    media_dir = Path.home() / ".nanobot" / "media"
-    media_dir.mkdir(parents=True, exist_ok=True)
-    screenshot_path = media_dir / f"screenshot_{int(time.time())}.png"
-    screenshot_path.write_bytes(base64.b64decode(result.base64_image))
-    media_paths_for_turn.append(str(screenshot_path))
-
-    # 2. Include in tool_result for model to see
-    tool_result_content.append({
-        "type": "image",
-        "source": {
-            "type": "base64",
-            "media_type": "image/png",
-            "data": result.base64_image
-        }
-    })
-
-# After final LLM response
-await self.bus.publish(OutboundMessage(
-    channel=inbound.channel,
-    chat_id=inbound.chat_id,
-    content=final_response,
-    media=media_paths_for_turn  # Include all screenshots
-))
-```
-
-**Result**:
- Model sees base64 in tool_result → analyzes and reasons about it
- User receives file via Telegram's media sending (`_send_with_media()`)
-
-### 7. Version Management & Beta Flags
-
-**Problem**: Each native tool version requires specific API beta flag
-
-**Solution**: Add beta flag tracking to native tools
-
-Each native tool class specifies its required beta flag:
-```python
-class BashTool20250124(BaseAnthropicTool):
-    api_type = "bash_20250124"
-    name = "bash"
-    beta_flag = "computer-use-2025-11-24"  # Required for API
-```
-
-In `anthropic_oauth.py._make_request()`, collect beta flags:
-```python
-# Collect unique beta flags from native tools
-beta_flags = set()
-for tool in tools or []:
-    if hasattr(tool, 'beta_flag') and tool.beta_flag:
-        beta_flags.add(tool.beta_flag)
-
-# Add to API request headers
-if beta_flags:
-    headers["anthropic-beta"] = ",".join(sorted(beta_flags))
-```
-
-**Note**: All three tools (bash, text_editor, computer) currently use the same beta flag: `"computer-use-2025-11-24"` as of the 2025-11-24 tool version.
-
-### 8. Removing Overlapping Tools
-
-Once native tools are implemented and tested, remove overlapping custom tools:
-
-**To Remove**:
- `ExecTool` → replaced by `BashTool20250124` (persistent session, better output)
- `EditFileTool` → replaced by `EditTool20250728` (str_replace command)
- Possibly `ReadFileTool`, `WriteFileTool` → `EditTool20250728` has `view` and `create` commands
-
-**To Keep**:
- `ListDirTool` → no native equivalent
- `WebSearchTool`, `WebFetchTool` → no native equivalent
- `MessageTool`, `SpawnTool`, `WaitForSubagentsTool` → nanobot-specific
- `CronTool` → nanobot-specific
-
-**Migration Notes**:
- `EditTool20250728` only supports absolute paths (enforced in validation)
- `BashTool20250124` maintains session state across calls (different from ExecTool's one-shot)
- Test native tools thoroughly before removing custom ones
-
-## Benefits
-
-1. **Trained Behaviors**: Model knows how to use these tools from training, not instruction-following
-2. **Better Reliability**: Persistent bash sessions, validated file operations
-3. **New Capabilities**: Desktop interaction via computer tool
-4. **Future-Proof**: Easy to add more native tools as Anthropic releases them (just port implementation)
-5. **Unified System**: Both function tools and native tools work together in same request
-
-## Trade-offs
-
-1. **Code Duplication**: Porting reference implementations means maintaining separate codebase
-   - Mitigation: Keep close to reference implementation for easier updates
-2. **Version Management**: Need to track tool versions and beta flags
-   - Mitigation: Simple beta_flag attribute on tool classes
-3. **Testing Complexity**: Need to test both tool systems
-   - Mitigation: Gradual rollout, keep custom tools until native tools proven
-
-## Success Criteria
-
-1. All three native tools execute successfully
-2. Model can use bash, edit, and computer tools in same conversation
-3. Screenshots from computer tool visible to both model and user
-4. No regression in existing functionality (other tools still work)
-5. Performance comparable to custom tools
@@ -1,214 +0,0 @@
-# PR Testing Workflow
-
-Guide for testing Pull Requests using the local staging environment.
-
-## Quick Start
-
-```bash
-./test-pr.sh <pr-number> "test message"
-```
-
-## Staging Environment
-
-**Location:** `/config/workspace/.nanobot-staging/`
-
-**Components:**
- `config.json` — Staging configuration (channels disabled, shared OAuth)
- `workspace/` — Isolated workspace for tool operations
- `workspace/sessions/` — Session storage (separate from production)
-
-**Key differences from production:**
- No external channels (Telegram disabled)
- Uses `NANOBOT_CONFIG` environment variable
- Gateway runs on localhost:18791 (vs production's 18790)
- `restrictToWorkspace: true` for safety
-
-## Testing a PR
-
-### Method 1: Helper Script (Recommended)
-
-```bash
-# Test PR with default message
-./test-pr.sh 31
-
-# Test with custom message
-./test-pr.sh 31 "test the hidden message feature"
-```
-
-**What it does:**
-1. Fetches PR from `wylab` remote (force updates if branch exists)
-2. Checks out PR branch locally
-3. Installs in editable mode with `uv pip install -e .`
-4. Runs test with staging config via `NANOBOT_CONFIG` env var
-5. Leaves branch checked out for further testing
-
-**After testing:**
-```bash
-git checkout main  # Return to main branch
-```
-
-### Method 2: Manual Testing
-
-```bash
-# 1. Fetch and checkout PR
-cd /config/workspace/nanobot-oauth-port/nanobot-fork
-git fetch wylab pull/<N>/head:pr-<N>
-git checkout pr-<N>
-
-# 2. Install in editable mode
-uv pip install -e .
-
-# 3. Test with staging config
-NANOBOT_CONFIG=/config/workspace/.nanobot-staging/config.json \
-  .venv/bin/nanobot agent -m "test message"
-
-# 4. For multi-turn testing
-NANOBOT_CONFIG=/config/workspace/.nanobot-staging/config.json \
-  .venv/bin/nanobot agent  # Interactive mode
-
-# 5. Return to main
-git checkout main
-```
-
-### Method 3: Gateway Validation
-
-Test that gateway starts without errors:
-
-```bash
-NANOBOT_CONFIG=/config/workspace/.nanobot-staging/config.json \
-  .venv/bin/nanobot gateway
-
-# Kill with Ctrl+C when validated
-```
-
-## Verifying Cache Behavior
-
-To verify prompt caching works correctly (important for performance):
-
-```bash
-# Enable logs to see cache metrics
-NANOBOT_CONFIG=/config/workspace/.nanobot-staging/config.json \
-  .venv/bin/nanobot agent --logs -m "Turn 1: list files"
-
-# Look for cache metrics in output:
-# - cache_write: New cache entries created
-# - cache_read: Tokens read from cache
-```
-
-**What to look for:**
- Turn 1: High `cache_write`, moderate `cache_read`
- Turn 2+: Low `cache_write`, high `cache_read` (reusing cache)
- `cache_read` should increase across turns as context grows
-
-**Example healthy pattern:**
-```
-Turn 1: cache_write=354 cache_read=3563
-Turn 2: cache_write=255 cache_read=3917  ← Same as Turn 1 end
-Turn 3: cache_write=113 cache_read=4172  ← Growing with context
-```
-
-## Session Management
-
-### Clear session for fresh test
-
-```bash
-rm -f /config/workspace/.nanobot-staging/workspace/sessions/cli_direct.jsonl
-```
-
-### View session contents
-
-```bash
-cat /config/workspace/.nanobot-staging/workspace/sessions/cli_direct.jsonl | jq
-```
-
-### Check for specific features (e.g., hidden signatures)
-
-```bash
-cat /config/workspace/.nanobot-staging/workspace/sessions/cli_direct.jsonl | grep "_hidden_sig"
-```
-
-## Common Testing Scenarios
-
-### Test tool execution
-
-```bash
-./test-pr.sh 31 "List all Python files in the current directory"
-```
-
-### Test multi-turn conversation
-
-```bash
-NANOBOT_CONFIG=/config/workspace/.nanobot-staging/config.json \
-  .venv/bin/nanobot agent
-
-# Then interact naturally:
-> list files in current directory
-> how many python files are there?
-> what's the total size?
-```
-
-### Test error handling
-
-```bash
-./test-pr.sh 31 "Try to read a file that doesn't exist: /nonexistent.txt"
-```
-
-### Test with thinking mode
-
-The staging config has `thinking_budget: 10000` enabled by default, so all tests use extended thinking.
-
-## Troubleshooting
-
-### "No API key configured" error
-
- **Cause:** `NANOBOT_CONFIG` env var not set
- **Fix:** Ensure you're using `NANOBOT_CONFIG=/config/workspace/.nanobot-staging/config.json`
-
-### "Module not found" after checkout
-
- **Cause:** Need to reinstall after switching branches
- **Fix:** Run `uv pip install -e .` after checkout
-
-### Changes not applying
-
- **Cause:** Using cached `.pyc` files
- **Fix:** Clear pycache: `find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true`
-
-### Session has stale data
-
- **Cause:** Previous test left session data
- **Fix:** `rm /config/workspace/.nanobot-staging/workspace/sessions/cli_direct.jsonl`
-
-## Best Practices
-
-1. **Clear session between PR tests** to avoid cross-contamination
-2. **Test with tool use** to trigger agentic behavior (not just simple Q&A)
-3. **Check cache metrics** for performance-sensitive PRs
-4. **Run with `--logs`** to see detailed behavior during development
-5. **Return to main** after testing to avoid accidental commits on PR branches
-
-## Integration with CI/CD
-
-The staging environment is currently manual-only. Future enhancements:
-
- [ ] Automated PR testing via Gitea Actions
- [ ] Cache validation in CI pipeline
- [ ] Multi-PR parallel testing using git worktrees
- [ ] Regression test suite against production behavior
-
-## File Locations Reference
-
-| Path | Purpose |
-|------|---------|
-| `/config/workspace/nanobot-oauth-port/nanobot-fork/` | Local nanobot repository |
-| `/config/workspace/.nanobot-staging/` | Staging environment root |
-| `/config/workspace/.nanobot-staging/config.json` | Staging configuration |
-| `/config/workspace/.nanobot-staging/workspace/` | Staging workspace |
-| `/config/workspace/.nanobot-staging/workspace/sessions/` | Session storage |
-| `/config/workspace/nanobot-oauth-port/nanobot-fork/test-pr.sh` | Helper script |
-
-## Related Documentation
-
- [nanobot README](../README.md) - Main project documentation
- [CLAUDE.md](../CLAUDE.md) - Development guide for Claude Code
- [config/schema.py](../nanobot/config/schema.py) - Configuration schema
@@ -2,5 +2,5 @@
 nanobot - A lightweight AI agent framework
 """

-__version__ = "0.1.4.post2"
+__version__ = "0.1.0"
 __logo__ = "🐈"
@@ -6,12 +6,8 @@ import platform
 from pathlib import Path
 from typing import Any

-from loguru import logger
-
 from nanobot.agent.memory import MemoryStore
-from nanobot.agent.memory_mem0 import Mem0MemoryStore, HAS_MEM0
 from nanobot.agent.skills import SkillsLoader
-from nanobot.agent.visibility import compute_signature


 class ContextBuilder:
@@ -23,21 +19,10 @@ class ContextBuilder:
    """
    
    BOOTSTRAP_FILES = ["AGENTS.md", "SOUL.md", "USER.md", "TOOLS.md", "IDENTITY.md"]
-
-    def __init__(self, workspace: Path, mem0_config: dict[str, Any] | None = None):
+    
+    def __init__(self, workspace: Path):
        self.workspace = workspace
-
-        # Choose memory backend based on config
-        if mem0_config and mem0_config.get("enabled") and HAS_MEM0:
-            self.memory = Mem0MemoryStore(workspace, config=mem0_config)
-            self.use_mem0 = True
-            logger.info("ContextBuilder using mem0 for semantic memory")
-        else:
-            if mem0_config and mem0_config.get("enabled"):
-                logger.warning("mem0 enabled but not installed, falling back to MEMORY.md")
-            self.memory = MemoryStore(workspace)
-            self.use_mem0 = False
-
+        self.memory = MemoryStore(workspace)
        self.skills = SkillsLoader(workspace)
    
    def build_system_prompt(self, skill_names: list[str] | None = None) -> str:
@@ -117,14 +102,7 @@ For normal conversation, just respond with text - do not call the message tool.

 Always be helpful, accurate, and concise. When using tools, think step by step: what you know, what you need, and why you chose this tool.
 When remembering something important, write to {workspace_path}/memory/MEMORY.md
-To recall past events, grep {workspace_path}/memory/HISTORY.md
-
-## Visibility Markers
-
-Messages marked with [HIDDEN:{{signature}}] were not sent to the user. These markers
-are cryptographically signed by the system to track internal reasoning and background
-tasks. Do NOT generate [HIDDEN:*] patterns yourself - outputs containing forged
-visibility markers will be rejected."""
+To recall past events, grep {workspace_path}/memory/HISTORY.md"""
    
    def _load_bootstrap_files(self) -> str:
        """Load all bootstrap files from workspace."""
@@ -167,18 +145,6 @@ visibility markers will be rejected."""
        system_prompt = self.build_system_prompt(skill_names)
        if channel and chat_id:
            system_prompt += f"\n\n## Current Session\nChannel: {channel}\nChat ID: {chat_id}"
-
-        # Add mem0 semantic memory context (if enabled)
-        if self.use_mem0 and channel and chat_id:
-            user_id = f"{channel}_{chat_id}"
-            memory_context = self.memory.get_memory_context(
-                query=current_message,
-                user_id=user_id,
-                limit=5
-            )
-            if memory_context:
-                system_prompt += f"\n\n{memory_context}"
-
        messages.append({"role": "system", "content": system_prompt})

        # History
@@ -227,14 +193,12 @@ visibility markers will be rejected."""
        Returns:
            Updated message list.
        """
-        msg: dict[str, Any] = {
+        messages.append({
            "role": "tool",
            "tool_call_id": tool_call_id,
            "name": tool_name,
-            "content": result,
-            "_hidden_sig": compute_signature(result if isinstance(result, str) else ""),
-        }
-        messages.append(msg)
+            "content": result
+        })
        return messages
    
    def add_assistant_message(
@@ -257,14 +221,13 @@ visibility markers will be rejected."""
            Updated message list.
        """
        msg: dict[str, Any] = {"role": "assistant", "content": content or ""}
-
+        
        if tool_calls:
            msg["tool_calls"] = tool_calls
-            msg["_hidden_sig"] = compute_signature(content or "")
-
+        
        # Thinking models reject history without this
        if reasoning_content:
            msg["reasoning_content"] = reasoning_content
-
+        
        messages.append(msg)
        return messages
@@ -11,7 +11,7 @@ from loguru import logger

 from nanobot.bus.events import InboundMessage, OutboundMessage
 from nanobot.bus.queue import MessageBus
-from nanobot.providers.base import LLMProvider, LongContextError
+from nanobot.providers.base import LLMProvider
 from nanobot.agent.context import ContextBuilder
 from nanobot.agent.tools.registry import ToolRegistry
 from nanobot.agent.tools.filesystem import ReadFileTool, WriteFileTool, EditFileTool, ListDirTool
@@ -21,10 +21,8 @@ from nanobot.agent.tools.message import MessageTool
 from nanobot.agent.tools.spawn import SpawnTool
 from nanobot.agent.tools.wait import WaitForSubagentsTool
 from nanobot.agent.tools.cron import CronTool
-from nanobot.agent.tools.anthropic.base import ToolResult, CLIResult
 from nanobot.agent.memory import MemoryStore
 from nanobot.agent.subagent import SubagentManager
-from nanobot.agent.visibility import sign_content, has_forged_marker, strip_all_hidden_markers
 from nanobot.session.manager import SessionManager


@@ -40,8 +38,8 @@ class AgentLoop:
    5. Sends responses back
    """

-    # Server-side context management: Anthropic preserves all thinking blocks
-    # and clears old tool results only when approaching the 200k context limit.
+    # Server-side context management: Anthropic trims old tool results and preserves all
+    # thinking blocks (keep="all" maximises cache hits). Client keeps full history.
    CONTEXT_MANAGEMENT = {
        "edits": [
            {
@@ -50,11 +48,7 @@ class AgentLoop:
            },
            {
                "type": "clear_tool_uses_20250919",
-                # Raised from 80k to 195k to avoid premature cache invalidation.
-                # For conversations with few tool uses (e.g., 18 uses over 182k tokens),
-                # cache stability (saves 169k/turn) >> clearing benefit (13-26k one-time).
-                # Leaves 5k headroom before hitting 200k standard context limit.
-                "trigger": {"type": "input_tokens", "value": 195000},
+                "trigger": {"type": "input_tokens", "value": 80000},
                "keep": {"type": "tool_uses", "value": 5},
            },
        ]
@@ -72,8 +66,6 @@ class AgentLoop:
        exec_config: "ExecToolConfig | None" = None,
        cron_service: "CronService | None" = None,
        restrict_to_workspace: bool = False,
-        enable_memory_tool: bool = True,
-        mem0_config: dict[str, Any] | None = None,
        session_manager: SessionManager | None = None,
    ):
        from nanobot.config.schema import ExecToolConfig
@@ -88,10 +80,8 @@ class AgentLoop:
        self.exec_config = exec_config or ExecToolConfig()
        self.cron_service = cron_service
        self.restrict_to_workspace = restrict_to_workspace
-        self.enable_memory_tool = enable_memory_tool
-        self.mem0_config = mem0_config
-
-        self.context = ContextBuilder(workspace, mem0_config=mem0_config)
+        
+        self.context = ContextBuilder(workspace)
        self.sessions = session_manager or SessionManager(workspace)
        self.tools = ToolRegistry()
        self.subagents = SubagentManager(
@@ -110,73 +100,36 @@ class AgentLoop:
    
    def _register_default_tools(self) -> None:
        """Register the default set of tools."""
-        # Import native tools
-        from nanobot.agent.tools.anthropic import (
-            BashTool20250124,
-            EditTool20250728,
-            ComputerTool20251124,
-        )
-
        # File tools (restrict to workspace if configured)
        allowed_dir = self.workspace if self.restrict_to_workspace else None
        self.tools.register(ReadFileTool(allowed_dir=allowed_dir))
        self.tools.register(WriteFileTool(allowed_dir=allowed_dir))
-        # Removed: replaced by EditTool20250728
-        # self.tools.register(EditFileTool(allowed_dir=allowed_dir))
+        self.tools.register(EditFileTool(allowed_dir=allowed_dir))
        self.tools.register(ListDirTool(allowed_dir=allowed_dir))
-
-        # Removed: replaced by BashTool20250124
-        # self.tools.register(ExecTool(
-        #     working_dir=str(self.workspace),
-        #     timeout=self.exec_config.timeout,
-        #     restrict_to_workspace=self.restrict_to_workspace,
-        # ))
-
+        
+        # Shell tool
+        self.tools.register(ExecTool(
+            working_dir=str(self.workspace),
+            timeout=self.exec_config.timeout,
+            restrict_to_workspace=self.restrict_to_workspace,
+        ))
+        
        # Web tools
        self.tools.register(WebSearchTool(api_key=self.brave_api_key))
        self.tools.register(WebFetchTool())
-
+        
        # Message tool
        message_tool = MessageTool(send_callback=self.bus.publish_outbound, sessions=self.sessions)
        self.tools.register(message_tool)
-
+        
        # Spawn tool (for subagents)
        spawn_tool = SpawnTool(manager=self.subagents)
        self.tools.register(spawn_tool)
        self.tools.register(WaitForSubagentsTool(manager=self.subagents))
-
+        
        # Cron tool (for scheduling)
        if self.cron_service:
            self.tools.register(CronTool(self.cron_service))
-        if self.enable_memory_tool:
-            from nanobot.agent.tools.anthropic import MemoryTool20250818
-            self.tools.register(MemoryTool20250818(workspace=self.workspace))
-
-        # Register native Anthropic tools
-        self.tools.register(BashTool20250124())
-        self.tools.register(EditTool20250728())
-        # self.tools.register(ComputerTool20251124())  # Disabled - VM unavailable
-
-        logger.info("Registered native Anthropic tools: bash, text_editor")
-
-        # Register mem0 memory tools (if enabled)
-        from nanobot.agent.memory_mem0 import HAS_MEM0
-        if self.mem0_config and self.mem0_config.get("enabled") and HAS_MEM0:
-            from nanobot.agent.memory_mem0 import Mem0MemoryStore
-            from nanobot.agent.tools.memory_tools import (
-                Mem0ToolContext, MemorySearchTool, MemoryListTool,
-                MemoryAddTool, MemoryUpdateTool, MemoryDeleteTool,
-                MemoryConsolidateTool,
-            )
-            store = Mem0MemoryStore(self.workspace, config=self.mem0_config)
-            self._mem0_ctx = Mem0ToolContext(store, self._consolidate_memory)
-            self.tools.register(MemorySearchTool(self._mem0_ctx))
-            self.tools.register(MemoryListTool(self._mem0_ctx))
-            self.tools.register(MemoryAddTool(self._mem0_ctx))
-            self.tools.register(MemoryUpdateTool(self._mem0_ctx))
-            self.tools.register(MemoryDeleteTool(self._mem0_ctx))
-            self.tools.register(MemoryConsolidateTool(self._mem0_ctx))
-            logger.info("Registered mem0 memory tools")
    
    async def run(self) -> None:
        """Run the agent loop, processing messages from the bus."""
@@ -202,8 +155,7 @@ class AgentLoop:
                    await self.bus.publish_outbound(OutboundMessage(
                        channel=msg.channel,
                        chat_id=msg.chat_id,
-                        content=f"Sorry, I encountered an error: {str(e)}",
-                        metadata=msg.metadata or {},
+                        content=f"Sorry, I encountered an error: {str(e)}"
                    ))
            except asyncio.TimeoutError:
                continue
@@ -221,7 +173,7 @@ class AgentLoop:
            return self._quota_cache["model"]

        # Default models
-        OPUS = "claude-opus-4-7"
+        OPUS = "claude-opus-4-6"
        SONNET = "claude-sonnet-4-6"
        TOLERANCE = 1.17  # 17% overage triggers downgrade

@@ -331,48 +283,32 @@ class AgentLoop:
            session.clear()
            self.sessions.save(session)
            return OutboundMessage(channel=msg.channel, chat_id=msg.chat_id,
-                                  content="🐈 New session started. Memory consolidated.",
-                                  metadata=msg.metadata or {})
+                                  content="🐈 New session started. Memory consolidated.")
        if cmd == "/help":
            return OutboundMessage(channel=msg.channel, chat_id=msg.chat_id,
-                                  content="🐈 nanobot commands:\n/new — Start a new conversation\n/help — Show available commands\n/quota — Show quota status",
-                                  metadata=msg.metadata or {})
+                                  content="🐈 nanobot commands:\n/new — Start a new conversation\n/help — Show available commands\n/quota — Show quota status")
        if cmd == "/quota":
            status = self._get_quota_status()
-            return OutboundMessage(channel=msg.channel, chat_id=msg.chat_id, content=status,
-                                  metadata=msg.metadata or {})
+            return OutboundMessage(channel=msg.channel, chat_id=msg.chat_id, content=status)

        # Update tool contexts
        message_tool = self.tools.get("message")
        if isinstance(message_tool, MessageTool):
            message_tool.set_context(msg.channel, msg.chat_id)
-            message_tool.start_turn()
-
+        
        spawn_tool = self.tools.get("spawn")
        if isinstance(spawn_tool, SpawnTool):
-            spawn_tool.set_context(msg.channel, msg.chat_id, msg.metadata)
-
+            spawn_tool.set_context(msg.channel, msg.chat_id)
+        
        cron_tool = self.tools.get("cron")
        if isinstance(cron_tool, CronTool):
            cron_tool.set_context(msg.channel, msg.chat_id)
-
-        if hasattr(self, '_mem0_ctx'):
-            self._mem0_ctx.set_context(msg.channel, msg.chat_id, session)
-
-        # Track media for this turn (screenshots from computer tool)
-        media_paths_for_turn: list[str] = []
-
+        
        # Prepend current time + optional time-gap notice to every user message
        now_dt = datetime.now()
        tz = time.strftime("%Z") or "UTC"
        time_str = now_dt.strftime("%Y-%m-%d %H:%M (%A)")
        current_message = f"[Current time: {time_str} {tz}]\n{msg.content}"
-
-        # Prefix hook messages so the agent can identify them
-        hook_source = msg.metadata.get("hook_source") if msg.metadata else None
-        if hook_source:
-            current_message = f'[HOOK MESSAGE from "{hook_source}"]\n{current_message}'
-
        last_user_ts = None
        for m in reversed(session.messages):
            if m.get("role") == "user":
@@ -417,35 +353,12 @@ class AgentLoop:

            # Call LLM
            logger.debug(f"Calling LLM with model={selected_model}, provider.thinking_budget={self.provider.thinking_budget}")
-            try:
-                response = await self.provider.chat(
-                    messages=messages,
-                    tools=self.tools.get_tools(),  # Pass tool objects for beta flag extraction
-                    model=selected_model,
-                    context_management=self.CONTEXT_MANAGEMENT,
-                )
-            except LongContextError:
-                logger.warning("Long context 429 — auto-consolidating session")
-                await self._consolidate_memory(session, archive_all=False)
-                # Apply trim immediately (normally deferred to end of turn)
-                checkpoint = getattr(session, '_trim_checkpoint', None)
-                if checkpoint is not None:
-                    old_size = len(session.messages)
-                    session.messages = session.messages[checkpoint:]
-                    session._trim_checkpoint = None
-                    self.sessions.save(session)
-                    logger.info(f"Emergency trim: {old_size} -> {len(session.messages)} messages")
-                    # Rebuild messages from trimmed session
-                    messages = self.context.build_messages(
-                        history=session.get_history(),
-                        current_message=current_message,
-                        media=msg.media if msg.media else None,
-                        channel=msg.channel,
-                        chat_id=msg.chat_id,
-                    )
-                    turn_start = len(messages)
-                    continue  # Retry LLM call with shorter context
-                raise  # No trim happened — can't recover
+            response = await self.provider.chat(
+                messages=messages,
+                tools=self.tools.get_definitions(),
+                model=selected_model,
+                context_management=self.CONTEXT_MANAGEMENT,
+            )

            # Handle tool calls
            if response.has_tool_calls:
@@ -471,95 +384,16 @@ class AgentLoop:
                    args_str = json.dumps(tool_call.arguments, ensure_ascii=False)
                    logger.info(f"Tool call: {tool_call.name}({args_str[:200]})")
                    result = await self.tools.execute(tool_call.name, tool_call.arguments)
-
-                    # Handle different result types
-                    if isinstance(result, ToolResult):
-                        # Native Anthropic tool result
-                        content_parts = []
-
-                        # Add text content
-                        if result.output:
-                            text_content = result.output
-                        elif result.error:
-                            text_content = f"Error: {result.error}"
-                        else:
-                            text_content = ""
-
-                        # If both output and error, combine them
-                        if result.output and result.error:
-                            text_content = f"{result.output}\n\nError: {result.error}"
-
-                        # If there's an image, use multipart content
-                        if result.base64_image:
-                            # Save screenshot to disk for user
-                            import base64
-                            media_dir = Path.home() / ".nanobot" / "media"
-                            media_dir.mkdir(parents=True, exist_ok=True)
-                            screenshot_path = media_dir / f"screenshot_{int(time.time() * 1000)}.png"
-                            screenshot_path.write_bytes(base64.b64decode(result.base64_image))
-                            media_paths_for_turn.append(str(screenshot_path))
-                            logger.info(f"Saved screenshot to {screenshot_path}")
-
-                            # Include in tool result for model to see
-                            content_parts = [
-                                {"type": "text", "text": text_content},
-                                {
-                                    "type": "image",
-                                    "source": {
-                                        "type": "base64",
-                                        "media_type": "image/png",
-                                        "data": result.base64_image,
-                                    }
-                                }
-                            ]
-                            tool_content = content_parts
-                        else:
-                            tool_content = text_content
-
-                    elif isinstance(result, CLIResult):
-                        # CLI-style tool result (text editor)
-                        tool_content = result.output
-
-                    else:
-                        # Legacy string result from function tools
-                        tool_content = result
-
                    messages = self.context.add_tool_result(
-                        messages, tool_call.id, tool_call.name, tool_content
+                        messages, tool_call.id, tool_call.name, result
                    )
                # Interleaved CoT: reflect before next action (skip when thinking is active)
                if not getattr(self.provider, 'thinking_budget', 0):
                    messages.append({"role": "user", "content": "Reflect on the results and decide next steps."})
            else:
-                # No tool calls
+                # No tool calls, we're done
                final_content = response.content
                final_reasoning = response.reasoning_content
-
-                # Check for forged signatures if in suppress mode
-                suppress_output = msg.metadata.get("suppress_output", False) if msg.metadata else False
-                if suppress_output and has_forged_marker(final_content):
-                    # Initialize retry counter if needed
-                    if not hasattr(self, '_forge_retry_count'):
-                        self._forge_retry_count = 0
-
-                    if self._forge_retry_count < 1:
-                        # First offense: reject and retry with correction
-                        self._forge_retry_count += 1
-                        logger.warning("Model attempted to forge visibility marker, rejecting output")
-                        messages.append({
-                            "role": "user",
-                            "content": "[System: Previous response rejected. Do not generate [HIDDEN:*] markers.]"
-                        })
-                        continue  # Back to while loop, will retry LLM call
-                    else:
-                        # Second offense: strip and log error (fallback)
-                        logger.error("Model persisted in forging markers despite correction, stripping")
-                        final_content = strip_all_hidden_markers(final_content)
-
-                # Reset retry counter on successful completion
-                if hasattr(self, '_forge_retry_count'):
-                    self._forge_retry_count = 0
-
                break

        if final_content is None:
@@ -568,74 +402,29 @@ class AgentLoop:
            else:
                final_content = "I've completed processing but have no response to give."

-        # Check if message tool already sent to same target (suppress final reply)
-        message_tool = self.tools.get("message")
-        if isinstance(message_tool, MessageTool) and message_tool._sent_in_turn:
-            logger.info(f"Suppressing final reply to {msg.channel}:{msg.chat_id} (message tool already sent)")
-            return None
-
        # Log response preview
        preview = final_content[:120] + "..." if len(final_content) > 120 else final_content
        logger.info(f"Response to {msg.channel}:{msg.sender_id}: {preview}")

-        # Check for suppress mode BEFORE adding to session
-        suppress_output = msg.metadata.get("suppress_output", False) if msg.metadata else False
-
-        if suppress_output:
-            # Sign content with our secret key (forgery detection happens in loop above)
-            final_content_for_session = sign_content(final_content)
-            # Mark as suppressed for channel handler
-            outbound_metadata = {**(msg.metadata or {}), "suppressed": True}
-        else:
-            final_content_for_session = final_content
-            outbound_metadata = msg.metadata or {}
-
        # Append final assistant response to messages so it's captured in the tool chain slice
-        # Use the prefixed version for session storage
        messages = self.context.add_assistant_message(
-            messages, final_content_for_session, None,
+            messages, final_content, None,
            reasoning_content=final_reasoning,
        )

-        # Save to session: mem0 context (if present) + user message + full tool chain
+        # Save to session: user message + full tool chain (tool_use, tool_results, thinking, final reply)
        # Store current_message (not msg.content) so the time prefix is preserved
-        # Include sender_id to distinguish real user messages from system-generated ones
-
-        # Find and save mem0 injection (appears just before current user message)
-        # build_messages returns: [...history, mem0_user, mem0_asst, current_user]
-        # turn_start = len(messages), so mem0 is at turn_start-3 and turn_start-2
-        # This makes mem0 part of immutable history, stabilizing cache across turns
-        if turn_start >= 3:
-            potential_mem0_user = messages[turn_start - 3]
-            potential_mem0_asst = messages[turn_start - 2]
-            if (potential_mem0_user.get("role") == "user" and
-                potential_mem0_user.get("content") == "[Memory context]" and
-                potential_mem0_asst.get("role") == "assistant"):
-                session.add_raw_message(potential_mem0_user)
-                session.add_raw_message(potential_mem0_asst)
-
-        session.add_message("user", current_message, sender_id=msg.sender_id)
+        # and cache keys match on subsequent turns
+        session.add_message("user", current_message)
        for chain_msg in messages[turn_start:]:
            session.add_raw_message(chain_msg)
        self.sessions.save(session)
-
-        # Deferred trim: if memory_consolidate ran mid-turn, it set a checkpoint
-        # marking where to trim. Now that the turn's tool chain is fully saved,
-        # we can safely trim to that checkpoint.
-        checkpoint = getattr(session, '_trim_checkpoint', None)
-        if checkpoint is not None:
-            old_size = len(session.messages)
-            session.messages = session.messages[checkpoint:]
-            session._trim_checkpoint = None
-            self.sessions.save(session)
-            logger.info(f"Deferred trim applied: {old_size} -> {len(session.messages)} messages (checkpoint={checkpoint})")
-
+        
        return OutboundMessage(
            channel=msg.channel,
            chat_id=msg.chat_id,
-            content=final_content_for_session,
-            metadata=outbound_metadata,
-            media=media_paths_for_turn if media_paths_for_turn else None,
+            content=final_content,
+            metadata=msg.metadata or {},  # Pass through for channel-specific needs (e.g. Slack thread_ts)
        )
    
    async def _process_system_message(self, msg: InboundMessage) -> OutboundMessage | None:
@@ -665,12 +454,11 @@ class AgentLoop:
        message_tool = self.tools.get("message")
        if isinstance(message_tool, MessageTool):
            message_tool.set_context(origin_channel, origin_chat_id)
-
-
+        
        spawn_tool = self.tools.get("spawn")
        if isinstance(spawn_tool, SpawnTool):
-            spawn_tool.set_context(origin_channel, origin_chat_id, msg.metadata)
-
+            spawn_tool.set_context(origin_channel, origin_chat_id)
+        
        cron_tool = self.tools.get("cron")
        if isinstance(cron_tool, CronTool):
            cron_tool.set_context(origin_channel, origin_chat_id)
@@ -695,32 +483,12 @@ class AgentLoop:
        while iteration < self.max_iterations:
            iteration += 1

-            try:
-                response = await self.provider.chat(
-                    messages=messages,
-                    tools=self.tools.get_tools(),  # Pass tool objects for beta flag extraction
-                    model=selected_model,
-                    context_management=self.CONTEXT_MANAGEMENT,
-                )
-            except LongContextError:
-                logger.warning("Long context 429 in system handler — auto-consolidating")
-                await self._consolidate_memory(session, archive_all=False)
-                checkpoint = getattr(session, '_trim_checkpoint', None)
-                if checkpoint is not None:
-                    old_size = len(session.messages)
-                    session.messages = session.messages[checkpoint:]
-                    session._trim_checkpoint = None
-                    self.sessions.save(session)
-                    logger.info(f"Emergency trim: {old_size} -> {len(session.messages)} messages")
-                    messages = self.context.build_messages(
-                        history=session.get_history(),
-                        current_message=msg.content,
-                        channel=origin_channel,
-                        chat_id=origin_chat_id,
-                    )
-                    turn_start = len(messages)
-                    continue
-                raise
+            response = await self.provider.chat(
+                messages=messages,
+                tools=self.tools.get_definitions(),
+                model=selected_model,
+                context_management=self.CONTEXT_MANAGEMENT,
+            )

            if response.has_tool_calls:
                tool_call_dicts = [
@@ -743,182 +511,38 @@ class AgentLoop:
                    args_str = json.dumps(tool_call.arguments, ensure_ascii=False)
                    logger.info(f"Tool call: {tool_call.name}({args_str[:200]})")
                    result = await self.tools.execute(tool_call.name, tool_call.arguments)
-
-                    # Handle different result types (same logic as main handler)
-                    if isinstance(result, ToolResult):
-                        # Native Anthropic tool result
-                        # Add text content
-                        if result.output:
-                            text_content = result.output
-                        elif result.error:
-                            text_content = f"Error: {result.error}"
-                        else:
-                            text_content = ""
-
-                        # If both output and error, combine them
-                        if result.output and result.error:
-                            text_content = f"{result.output}\n\nError: {result.error}"
-
-                        # Note: Image handling for system messages not needed
-                        # (system messages don't render images to users)
-                        # But we should still log if present
-                        if result.base64_image:
-                            logger.warning(
-                                f"Tool {tool_call.name} returned image in system message context - "
-                                "images not supported here"
-                            )
-
-                        tool_content = text_content
-
-                    elif isinstance(result, CLIResult):
-                        # CLI-style tool result (text editor)
-                        tool_content = result.output
-
-                    else:
-                        # Legacy string result from function tools
-                        tool_content = result
-
                    messages = self.context.add_tool_result(
-                        messages, tool_call.id, tool_call.name, tool_content
+                        messages, tool_call.id, tool_call.name, result
                    )
                # Interleaved CoT: reflect before next action (skip when thinking is active)
                if not getattr(self.provider, 'thinking_budget', 0):
                    messages.append({"role": "user", "content": "Reflect on the results and decide next steps."})
            else:
-                # No tool calls
                final_content = response.content
                final_reasoning = response.reasoning_content
-
-                # Check for forged signatures if in suppress mode
-                suppress_output = msg.metadata.get("suppress_output", False) if msg.metadata else False
-                if suppress_output and has_forged_marker(final_content):
-                    # Initialize retry counter if needed
-                    if not hasattr(self, '_forge_retry_count_system'):
-                        self._forge_retry_count_system = 0
-
-                    if self._forge_retry_count_system < 1:
-                        # First offense: reject and retry with correction
-                        self._forge_retry_count_system += 1
-                        logger.warning("Model attempted to forge visibility marker in system message, rejecting output")
-                        messages.append({
-                            "role": "user",
-                            "content": "[System: Previous response rejected. Do not generate [HIDDEN:*] markers.]"
-                        })
-                        continue  # Back to while loop, will retry LLM call
-                    else:
-                        # Second offense: strip and log error (fallback)
-                        logger.error("Model persisted in forging markers despite correction, stripping")
-                        final_content = strip_all_hidden_markers(final_content)
-
-                # Reset retry counter on successful completion
-                if hasattr(self, '_forge_retry_count_system'):
-                    self._forge_retry_count_system = 0
-
                break

        if final_content is None:
            final_content = "Background task completed."

-        # Check for suppress mode BEFORE adding to session
-        suppress_output = msg.metadata.get("suppress_output", False) if msg.metadata else False
-
-        if suppress_output:
-            # Sign content with our secret key (forgery detection happens in loop above)
-            final_content_for_session = sign_content(final_content)
-            # Mark as suppressed for channel handler
-            outbound_metadata = {**(msg.metadata or {}), "suppressed": True}
-        else:
-            final_content_for_session = final_content
-            outbound_metadata = msg.metadata or {}
-
-        # Append final assistant response to messages (use signed version for session)
+        # Append final assistant response to messages
        messages = self.context.add_assistant_message(
-            messages, final_content_for_session, None,
+            messages, final_content, None,
            reasoning_content=final_reasoning,
        )

-        # Save to session: mem0 (if present) + user message + full tool chain
-        # Find and save mem0 injection for cache stability
-        if turn_start >= 3:
-            potential_mem0_user = messages[turn_start - 3]
-            potential_mem0_asst = messages[turn_start - 2]
-            if (potential_mem0_user.get("role") == "user" and
-                potential_mem0_user.get("content") == "[Memory context]" and
-                potential_mem0_asst.get("role") == "assistant"):
-                session.add_raw_message(potential_mem0_user)
-                session.add_raw_message(potential_mem0_asst)
-
+        # Save to session: user message + full tool chain
        session.add_message("user", f"[System: {msg.sender_id}] {msg.content}")
        for chain_msg in messages[turn_start:]:
            session.add_raw_message(chain_msg)
        self.sessions.save(session)
-
-        # Deferred trim: same logic as _process_message
-        # System messages (including subagents) can trigger consolidation
-        checkpoint = getattr(session, '_trim_checkpoint', None)
-        if checkpoint is not None:
-            old_size = len(session.messages)
-            session.messages = session.messages[checkpoint:]
-            session._trim_checkpoint = None
-            self.sessions.save(session)
-            logger.info(f"Deferred trim applied: {old_size} -> {len(session.messages)} messages (checkpoint={checkpoint})")
-
-        # Return original content (not signed) for outbound, but with suppressed metadata
+        
        return OutboundMessage(
            channel=origin_channel,
            chat_id=origin_chat_id,
-            content=final_content,
-            metadata=outbound_metadata,
+            content=final_content
        )
    
-    @staticmethod
-    def _find_clean_boundary_before(messages: list[dict], target_pos: int) -> int:
-        """Find a clean user message boundary at or before target position.
-
-        Returns the index of a user message at or before target_pos,
-        or target_pos if no user message is found.
-        """
-        if not messages or target_pos <= 0:
-            return 0
-        if target_pos >= len(messages):
-            return len(messages)
-
-        # Walk backward from target to find a user message
-        for i in range(target_pos, -1, -1):
-            if messages[i].get("role") == "user":
-                return i
-
-        # No user message found, return target position
-        return target_pos
-
-    @staticmethod
-    def _trim_to_clean_boundary(messages: list[dict], keep_count: int) -> list[dict]:
-        """Trim messages to approximately keep_count, starting at a user message boundary.
-
-        Naive slicing (messages[-keep_count:]) can cut into a tool chain, leaving
-        orphaned tool_result messages at the start. This finds the nearest user
-        message (role="user") at or before the cut point and trims there.
-        """
-        if not messages or keep_count <= 0:
-            return []
-        if keep_count >= len(messages):
-            return messages
-
-        cut = len(messages) - keep_count
-        # Walk forward from cut to find a "user" role message (start of a turn)
-        # that isn't a tool result. Tool results have role="tool", user messages
-        # have role="user" — but after conversion, tool results ARE user messages.
-        # In session storage, they're still role="tool", so we look for role="user".
-        for i in range(cut, len(messages)):
-            if messages[i].get("role") == "user":
-                return messages[i:]
-        # If no user message found after cut, try walking backward
-        for i in range(cut - 1, -1, -1):
-            if messages[i].get("role") == "user":
-                return messages[i:]
-        # Fallback: return everything (shouldn't happen in practice)
-        return messages
-
    async def _consolidate_memory(self, session, archive_all: bool = False) -> None:
        """Consolidate session into MEMORY.md + HISTORY.md.

@@ -927,41 +551,7 @@ class AgentLoop:
        """
        if not session.messages:
            return
-
-        # Choose memory backend
-        from nanobot.agent.memory_mem0 import Mem0MemoryStore, HAS_MEM0
-
-        if self.mem0_config and self.mem0_config.get("enabled") and HAS_MEM0:
-            memory = Mem0MemoryStore(self.workspace, config=self.mem0_config)
-            logger.debug("Using mem0 for memory consolidation")
-            # Mem0 has its own consolidation logic (feeds messages to mem0 for extraction)
-            await memory.consolidate(
-                session,
-                self.provider,
-                self.model,
-                archive_all=archive_all,
-                memory_window=self.memory_window,
-            )
-            # archive_all (/new) runs at a turn boundary — safe to trim now.
-            # Mid-turn (memory_consolidate tool) — defer trim to end of turn
-            # to avoid orphaning tool_use IDs in the active tool chain.
-            if archive_all:
-                session.messages = []
-                self.sessions.save(session)
-                logger.info("Mem0 consolidation done, session cleared (archive_all)")
-            else:
-                keep_count = min(10, max(2, self.memory_window // 2))
-                # Set checkpoint at current session size minus keep_count
-                # This preserves the intended trim point regardless of messages added later
-                checkpoint = max(0, len(session.messages) - keep_count)
-                # Find clean boundary at or before checkpoint
-                checkpoint = self._find_clean_boundary_before(session.messages, checkpoint)
-                session._trim_checkpoint = checkpoint
-                logger.info(f"Mem0 consolidation done, trim deferred (checkpoint={checkpoint}, current_size={len(session.messages)})")
-            return
-        else:
-            memory = MemoryStore(self.workspace)
-            logger.debug("Using MemoryStore for memory consolidation")
+        memory = MemoryStore(self.workspace)
        if archive_all:
            old_messages = session.messages
            keep_count = 0
@@ -1048,7 +638,7 @@ Respond with ONLY valid JSON, no markdown fences."""
                if update != current_memory:
                    memory.write_long_term(update)

-            session.messages = self._trim_to_clean_boundary(session.messages, keep_count) if keep_count else []
+            session.messages = session.messages[-keep_count:] if keep_count else []
            self.sessions.save(session)
            logger.info(f"Memory consolidation done, session trimmed to {len(session.messages)} messages")
        except Exception as e:
@@ -1060,18 +650,16 @@ Respond with ONLY valid JSON, no markdown fences."""
        session_key: str = "cli:direct",
        channel: str = "cli",
        chat_id: str = "direct",
-        metadata: dict[str, Any] | None = None,
    ) -> str:
        """
        Process a message directly (for CLI or cron usage).
-
+        
        Args:
            content: The message content.
            session_key: Session identifier (overrides channel:chat_id for session lookup).
            channel: Source channel (for tool context routing).
            chat_id: Source chat ID (for tool context routing).
-            metadata: Optional metadata to pass through (for suppress mode, etc.).
-
+        
        Returns:
            The agent's response.
        """
@@ -1079,9 +667,8 @@ Respond with ONLY valid JSON, no markdown fences."""
            channel=channel,
            sender_id="user",
            chat_id=chat_id,
-            content=content,
-            metadata=metadata or {},
+            content=content
        )
-
+        
        response = await self._process_message(msg, session_key=session_key)
        return response.content if response else ""
@@ -1,46 +1,9 @@
 """Memory system for persistent agent memory."""

-from __future__ import annotations
-
-import json
 from pathlib import Path
-from typing import TYPE_CHECKING
-
-from loguru import logger

 from nanobot.utils.helpers import ensure_dir

-if TYPE_CHECKING:
-    from nanobot.providers.base import LLMProvider
-    from nanobot.session.manager import Session
-
-
-_SAVE_MEMORY_TOOL = [
-    {
-        "type": "function",
-        "function": {
-            "name": "save_memory",
-            "description": "Save the memory consolidation result to persistent storage.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "history_entry": {
-                        "type": "string",
-                        "description": "A paragraph (2-5 sentences) summarizing key events/decisions/topics. "
-                        "Start with [YYYY-MM-DD HH:MM]. Include detail useful for grep search.",
-                    },
-                    "memory_update": {
-                        "type": "string",
-                        "description": "Full updated long-term memory as markdown. Include all existing "
-                        "facts plus new ones. Return unchanged if nothing new.",
-                    },
-                },
-                "required": ["history_entry", "memory_update"],
-            },
-        },
-    }
-]
-

 class MemoryStore:
    """Two-layer memory: MEMORY.md (long-term facts) + HISTORY.md (grep-searchable log)."""
@@ -65,81 +28,3 @@ class MemoryStore:
    def get_memory_context(self) -> str:
        long_term = self.read_long_term()
        return f"## Long-term Memory\n{long_term}" if long_term else ""
-
-    async def consolidate(
-        self,
-        session: Session,
-        provider: LLMProvider,
-        model: str,
-        *,
-        archive_all: bool = False,
-        memory_window: int = 50,
-    ) -> bool:
-        """Consolidate old messages into MEMORY.md + HISTORY.md via LLM tool call.
-
-        Returns True on success (including no-op), False on failure.
-        """
-        if archive_all:
-            old_messages = session.messages
-            keep_count = 0
-            logger.info("Memory consolidation (archive_all): {} messages", len(session.messages))
-        else:
-            keep_count = memory_window // 2
-            if len(session.messages) <= keep_count:
-                return True
-            old_messages = session.messages[:-keep_count]
-            logger.info("Memory consolidation: {} to consolidate, {} keep", len(old_messages), keep_count)
-
-        lines = []
-        for m in old_messages:
-            if not m.get("content"):
-                continue
-            tools = f" [tools: {', '.join(m['tools_used'])}]" if m.get("tools_used") else ""
-            lines.append(f"[{m.get('timestamp', '?')[:16]}] {m['role'].upper()}{tools}: {m['content']}")
-
-        current_memory = self.read_long_term()
-        prompt = f"""Process this conversation and call the save_memory tool with your consolidation.
-
-## Current Long-term Memory
-{current_memory or "(empty)"}
-
-## Conversation to Process
-{chr(10).join(lines)}"""
-
-        try:
-            response = await provider.chat(
-                messages=[
-                    {"role": "system", "content": "You are a memory consolidation agent. Call the save_memory tool with your consolidation of the conversation."},
-                    {"role": "user", "content": prompt},
-                ],
-                tools=_SAVE_MEMORY_TOOL,
-                model=model,
-            )
-
-            if not response.has_tool_calls:
-                logger.warning("Memory consolidation: LLM did not call save_memory, skipping")
-                return False
-
-            args = response.tool_calls[0].arguments
-            # Some providers return arguments as a JSON string instead of dict
-            if isinstance(args, str):
-                args = json.loads(args)
-            if not isinstance(args, dict):
-                logger.warning("Memory consolidation: unexpected arguments type {}", type(args).__name__)
-                return False
-
-            if entry := args.get("history_entry"):
-                if not isinstance(entry, str):
-                    entry = json.dumps(entry, ensure_ascii=False)
-                self.append_history(entry)
-            if update := args.get("memory_update"):
-                if not isinstance(update, str):
-                    update = json.dumps(update, ensure_ascii=False)
-                if update != current_memory:
-                    self.write_long_term(update)
-
-            logger.info("Memory consolidation done: {} messages total", len(session.messages))
-            return True
-        except Exception:
-            logger.exception("Memory consolidation failed")
-            return False
@@ -1,404 +0,0 @@
-"""Mem0-powered memory system for intelligent semantic retrieval."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-from loguru import logger
-
-if TYPE_CHECKING:
-    from nanobot.providers.base import LLMProvider
-    from nanobot.session.manager import Session
-
-try:
-    from mem0 import Memory
-    from mem0.configs.base import MemoryConfig
-    HAS_MEM0 = True
-except ImportError:
-    HAS_MEM0 = False
-    MemoryConfig = None  # type: ignore
-
-
-class Mem0MemoryStore:
-    """
-    Enhanced memory store using mem0 for semantic search and automatic extraction.
-
-    Features:
-    - Multi-level memory (user, session, agent)
-    - Semantic search with embeddings
-    - Automatic memory extraction from conversations
-    - 90% token reduction vs full-context
-    - 91% faster responses
-    """
-
-    def __init__(self, workspace: Path, config: dict[str, Any] | None = None):
-        if not HAS_MEM0:
-            raise ImportError(
-                "mem0 not installed. Install with: pip install mem0ai"
-            )
-
-        self.workspace = workspace
-        self.memory_dir = workspace / "memory"
-        self.memory_dir.mkdir(parents=True, exist_ok=True)
-
-        # Build custom extraction prompt tuned for nanobot conversations
-        from datetime import datetime
-
-        today = datetime.now().strftime("%Y-%m-%d")
-        custom_prompt = f"Extract dated facts from this conversation as JSON: {{\"facts\": [...]}}. Today is {today}.\n\n"
-        self.custom_prompt = custom_prompt
-
-        # Initialize mem0 with optional config + custom prompt
-        # Extract only MemoryConfig-relevant fields
-        raw_config = config if config else {}
-        logger.debug(f"Mem0MemoryStore received config keys: {list(raw_config.keys())}")
-        mem0_cfg_dict = {}
-        for key in ("vector_store", "llm", "embedder", "graph_store", "version"):
-            if key in raw_config:
-                mem0_cfg_dict[key] = raw_config[key]
-        logger.debug(f"Extracted for MemoryConfig: {list(mem0_cfg_dict.keys())}")
-        mem0_config = MemoryConfig(**mem0_cfg_dict)
-        logger.debug(f"MemoryConfig created: vector_store={mem0_config.vector_store.provider if mem0_config.vector_store else None}")
-        self.memory = Memory(config=mem0_config)
-
-        logger.info("Mem0 memory system initialized with custom nanobot prompt")
-
-    def search_memories(
-        self,
-        query: str,
-        user_id: str,
-        limit: int = 5,
-        session_id: str | None = None,
-    ) -> list[dict[str, Any]]:
-        """
-        Search for relevant memories using semantic search.
-
-        Args:
-            query: Search query (user's current message)
-            user_id: User identifier (e.g., "telegram_12345")
-            limit: Max number of memories to return
-            session_id: Optional session-specific memories
-
-        Returns:
-            List of memory dicts with 'memory' and 'score' keys
-        """
-        try:
-            # Search user-level memories
-            user_memories = self.memory.search(
-                query=query,
-                user_id=user_id,
-                limit=limit
-            )
-
-            results = []
-            if user_memories and "results" in user_memories:
-                results.extend(user_memories["results"])
-
-            # Optionally search session-level memories
-            if session_id:
-                session_memories = self.memory.search(
-                    query=query,
-                    user_id=user_id,
-                    metadata={"session_id": session_id},
-                    limit=limit // 2  # Reserve half for session context
-                )
-                if session_memories and "results" in session_memories:
-                    results.extend(session_memories["results"])
-
-            logger.debug(
-                f"Mem0 search: query='{query[:50]}...', found {len(results)} memories"
-            )
-            return results[:limit]  # Limit total results
-
-        except Exception as e:
-            logger.error(f"Mem0 search failed: {e}")
-            return []
-
-    def add_conversation(
-        self,
-        messages: list[dict[str, Any]],
-        user_id: str,
-        session_id: str | None = None,
-    ) -> None:
-        """
-        Add conversation messages to memory for automatic extraction.
-
-        Args:
-            messages: List of message dicts with 'role' and 'content'
-            user_id: User identifier
-            session_id: Optional session identifier for session-level memories
-        """
-        try:
-            metadata = {}
-            if session_id:
-                metadata["session_id"] = session_id
-
-            # mem0 automatically extracts and stores relevant facts
-            result = self.memory.add(
-                messages,
-                user_id=user_id,
-                metadata=metadata if metadata else None
-            )
-
-            facts_count = len(result.get("results", [])) if result else 0
-            logger.debug(
-                f"Mem0 add: {len(messages)} messages for user {user_id}, extracted {facts_count} facts"
-            )
-        except Exception as e:
-            logger.error(f"Mem0 add failed: {e}")
-
-    async def extract_facts(
-        self,
-        messages: list[dict[str, Any]],
-        provider: Any,
-        model: str,
-    ) -> list[str]:
-        """Extract facts from conversation using the main agent's LLM provider."""
-        import json as _json
-
-        conv_text = ""
-        for msg in messages:
-            role = msg.get("role", "unknown")
-            content_val = msg.get("content", "")
-            if isinstance(content_val, str) and content_val.strip():
-                conv_text += f"{role}: {content_val}\n\n"
-
-        if not conv_text.strip():
-            return []
-
-        extraction_messages = [
-            {"role": "user", "content": self.custom_prompt + conv_text}
-        ]
-
-        try:
-            response = await provider.chat(
-                messages=extraction_messages,
-                model=model,
-                max_tokens=16384,
-                temperature=0.3,
-                thinking_budget=0,
-            )
-            text = (response.content or "").strip()
-            if text.startswith("```"):
-                text = text.split("```")[1]
-                if text.startswith("json"):
-                    text = text[4:]
-                text = text.strip()
-            data = _json.loads(text)
-            facts = data.get("facts", [])
-            if not isinstance(facts, list):
-                logger.warning(f"LLM returned non-list facts: {type(facts)}")
-                return []
-            logger.debug(f"Extracted {len(facts)} facts using {model}")
-            return facts
-        except Exception as e:
-            logger.error(f"Fact extraction failed: {e}")
-            return []
-
-    def store_facts(
-        self,
-        facts: list[str],
-        user_id: str,
-        session_id: str | None = None,
-    ) -> None:
-        """Store pre-extracted facts in mem0 with infer=False."""
-        if not facts:
-            return
-
-        metadata = {}
-        if session_id:
-            metadata["session_id"] = session_id
-
-        stored = 0
-        for fact in facts:
-            # Normalize: LLM may return dicts like {"fact": "...", "date": "..."} or plain strings
-            if isinstance(fact, dict):
-                fact_text = fact.get("fact", fact.get("text", str(fact)))
-            else:
-                fact_text = str(fact)
-            if not fact_text.strip():
-                continue
-            try:
-                self.memory.add(
-                    fact_text,
-                    user_id=user_id,
-                    infer=False,
-                    metadata=metadata if metadata else None,
-                )
-                stored += 1
-            except Exception as e:
-                logger.error(f"Failed to store fact '{str(fact_text)[:50]}...': {e}")
-
-        logger.info(f"Stored {stored}/{len(facts)} facts for user {user_id}")
-
-    def get_memory_context(
-        self,
-        query: str,
-        user_id: str,
-        limit: int = 5
-    ) -> str:
-        """
-        Get formatted memory context for inclusion in system prompt.
-
-        Args:
-            query: Current user query
-            user_id: User identifier
-            limit: Max memories to include
-
-        Returns:
-            Formatted memory context string
-        """
-        memories = self.search_memories(query, user_id, limit=limit)
-
-        if not memories:
-            return ""
-
-        lines = ["## Relevant Memories"]
-        for i, mem in enumerate(memories, 1):
-            memory_text = mem.get("memory", "")
-            # Include score if available for debugging
-            score = mem.get("score", "")
-            score_str = f" (relevance: {score:.2f})" if score else ""
-            lines.append(f"{i}. {memory_text}{score_str}")
-
-        return "\n".join(lines)
-
-    def update_memory(self, memory_id: str, data: dict[str, Any]) -> None:
-        """Update a specific memory by ID."""
-        try:
-            self.memory.update(memory_id, data)
-            logger.debug(f"Mem0 update: memory_id={memory_id}")
-        except Exception as e:
-            logger.error(f"Mem0 update failed: {e}")
-
-    def delete_memory(self, memory_id: str) -> None:
-        """Delete a specific memory by ID."""
-        try:
-            self.memory.delete(memory_id)
-            logger.debug(f"Mem0 delete: memory_id={memory_id}")
-        except Exception as e:
-            logger.error(f"Mem0 delete failed: {e}")
-
-    def get_all_memories(self, user_id: str) -> list[dict[str, Any]]:
-        """Get all memories for a user."""
-        try:
-            result = self.memory.get_all(user_id=user_id)
-            return result.get("results", []) if result else []
-        except Exception as e:
-            logger.error(f"Mem0 get_all failed: {e}")
-            return []
-
-    async def consolidate(
-        self,
-        session: Session,
-        provider: LLMProvider,
-        model: str,
-        *,
-        archive_all: bool = False,
-        memory_window: int = 50,
-    ) -> bool:
-        """
-        Consolidate session messages into mem0 memory.
-
-        Unlike the original MemoryStore, mem0 handles extraction automatically,
-        so this just needs to feed recent messages to mem0.
-
-        Returns True on success.
-        """
-        try:
-            # Extract user_id from session key (e.g., "telegram:12345" -> "telegram_12345")
-            user_id = session.key.replace(":", "_")
-
-            # Determine which messages to consolidate
-            if archive_all:
-                messages_to_add = session.messages
-                logger.info(
-                    f"Mem0 consolidation (archive_all): {len(messages_to_add)} messages"
-                )
-            else:
-                keep_count = memory_window // 2
-                if len(session.messages) <= keep_count:
-                    return True
-
-                # Consolidate messages except the most recent (kept for context)
-                start_idx = 0
-                end_idx = len(session.messages) - keep_count
-
-                if end_idx <= start_idx:
-                    return True
-
-                messages_to_add = session.messages[start_idx:end_idx]
-
-                if not messages_to_add:
-                    return True
-
-                logger.info(
-                    f"Mem0 consolidation: {len(messages_to_add)} to consolidate, "
-                    f"{keep_count} keep"
-                )
-
-            # Convert to mem0 format with intelligent filtering
-            mem0_messages = []
-            for msg in messages_to_add:
-                role = msg.get("role")
-                content = msg.get("content")
-
-                # Skip tool results — raw bash output, file contents, and JSON
-                # get misinterpreted by the extraction LLM as user interests
-                if role == "tool":
-                    continue
-
-                # Skip system messages — they're boilerplate instructions, not facts
-                if role == "system":
-                    continue
-
-                # Skip messages with no content
-                if not content:
-                    continue
-
-                # Normalize assistant message content: extract text from Anthropic list format
-                if role == "assistant" and isinstance(content, list):
-                    # Anthropic format: list of {type: "text"|"tool_use", text: "..."} blocks
-                    text_parts = [
-                        block.get("text", "")
-                        for block in content
-                        if isinstance(block, dict) and block.get("type") == "text"
-                    ]
-                    content = " ".join(text_parts).strip()
-                    if not content:
-                        continue  # Skip if assistant only called tools with no text explanation
-
-                # Normalize user message content (could also be a list in some formats)
-                if isinstance(content, list):
-                    text_parts = [
-                        block.get("text", "") if isinstance(block, dict) else str(block)
-                        for block in content
-                    ]
-                    content = " ".join(text_parts).strip()
-                    if not content:
-                        continue
-
-                # Skip trivially short messages (commands like "/new")
-                if len(content.strip()) < 10:
-                    continue
-
-                mem0_messages.append({
-                    "role": role,
-                    "content": content
-                })
-
-            if mem0_messages:
-                # Extract facts using the main agent's LLM (already paid for),
-                # then store with infer=False to bypass mem0's GPT-nano
-                facts = await self.extract_facts(mem0_messages, provider, model)
-                self.store_facts(facts, user_id=user_id, session_id=session.key)
-
-            logger.info(
-                f"Mem0 consolidation done: {len(session.messages)} messages total"
-            )
-            return True
-
-        except Exception:
-            logger.exception("Mem0 consolidation failed")
-            return False
@@ -167,10 +167,10 @@ class SkillsLoader:
        return content
    
    def _parse_nanobot_metadata(self, raw: str) -> dict:
-        """Parse skill metadata JSON from frontmatter (supports nanobot, clawdbot, and openclaw keys)."""
+        """Parse nanobot metadata JSON from frontmatter."""
        try:
            data = json.loads(raw)
-            return (data.get("nanobot") or data.get("clawdbot") or data.get("openclaw") or {}) if isinstance(data, dict) else {}
+            return (data.get("nanobot") or data.get("clawdbot") or {}) if isinstance(data, dict) else {}
        except (json.JSONDecodeError, TypeError):
            return {}
    
@@ -16,7 +16,6 @@ from nanobot.agent.tools.filesystem import ReadFileTool, WriteFileTool, EditFile
 from nanobot.agent.tools.shell import ExecTool
 from nanobot.agent.tools.web import WebSearchTool, WebFetchTool
 from nanobot.agent.tools.spawn import SpawnTool
-from nanobot.agent.tools.subagent_message import SubagentMessageTool
 from nanobot.agent.tools.wait import WaitForSubagentsTool


@@ -60,41 +59,38 @@ class SubagentManager:
        model: str | None = None,
        origin_channel: str = "cli",
        origin_chat_id: str = "direct",
-        origin_metadata: dict[str, Any] | None = None,
    ) -> str:
        """
        Spawn a subagent to execute a task in the background.
-
+        
        Args:
            task: The task description for the subagent.
            label: Optional human-readable label for the task.
            origin_channel: The channel to announce results to.
            origin_chat_id: The chat ID to announce results to.
-            origin_metadata: Optional metadata to propagate to announcement (e.g. suppress_output).
-
+        
        Returns:
-            Task ID of the spawned subagent.
+            Status message indicating the subagent was started.
        """
        task_id = str(uuid.uuid4())[:8]
        display_label = label or task[:30] + ("..." if len(task) > 30 else "")
-
+        
        origin = {
            "channel": origin_channel,
            "chat_id": origin_chat_id,
-            "metadata": origin_metadata or {},
        }
-
+        
        # Create background task
        bg_task = asyncio.create_task(
            self._run_subagent(task_id, task, display_label, origin, model=model)
        )
        self._running_tasks[task_id] = bg_task
-
+        
        # Cleanup when done
        bg_task.add_done_callback(lambda _: self._running_tasks.pop(task_id, None))
-
+        
        logger.info(f"Spawned subagent [{task_id}]: {display_label}")
-        return task_id
+        return f"Subagent [{display_label}] started. Task ID: {task_id}"
    
    async def _run_subagent(
        self,
@@ -122,19 +118,8 @@ class SubagentManager:
            ))
            tools.register(WebSearchTool(api_key=self.brave_api_key))
            tools.register(WebFetchTool())
-
-            # Message tool for communicating with user (via main agent)
-            message_tool = SubagentMessageTool(
-                bus=self.bus,
-                origin_channel=origin["channel"],
-                origin_chat_id=origin["chat_id"],
-                origin_metadata=origin.get("metadata"),
-            )
-            tools.register(message_tool)
-
-            # Spawn tool for creating child subagents
            spawn_tool = SpawnTool(manager=self)
-            spawn_tool.set_context("subagent", origin["chat_id"], origin.get("metadata"))
+            spawn_tool.set_context("subagent", origin["chat_id"])
            tools.register(spawn_tool)
            tools.register(WaitForSubagentsTool(manager=self))

@@ -216,15 +201,13 @@ class SubagentManager:
        """Announce the subagent result to the main agent via the message bus."""
        status_text = "completed successfully" if status == "ok" else "failed"

-        # ALWAYS store result so wait_for_subagents can find it
-        self._task_results[task_id] = result
-
-        # Child subagents (spawned by other subagents) don't announce - parent waits for them
+        # Child subagents (spawned by other subagents) store results silently.
+        # The parent orchestrator collects them via wait_for_subagents.
        if origin["channel"] == "subagent":
+            self._task_results[task_id] = result
            logger.debug(f"Subagent [{task_id}] stored result silently (child subagent)")
            return

-        # Top-level subagents announce via bus to trigger main agent
        announce_content = f"""[Subagent '{label}' {status_text}]

 Task: {task}
@@ -235,13 +218,11 @@ Result:
 Summarize this naturally for the user. Keep it brief (1-2 sentences). Do not mention technical details like "subagent" or task IDs."""

        # Inject as system message to trigger main agent
-        # Propagate metadata from origin (e.g. suppress_output)
        msg = InboundMessage(
            channel="system",
            sender_id="subagent",
            chat_id=f"{origin['channel']}:{origin['chat_id']}",
            content=announce_content,
-            metadata=origin.get("metadata", {}),
        )

        await self.bus.publish_inbound(msg)
@@ -264,12 +245,11 @@ You are a subagent spawned by the main agent to complete a specific task.
 - Read and write files in the workspace
 - Execute shell commands
 - Search the web and fetch web pages
- Send messages to the main agent (via the message tool)
- Spawn child subagents for parallel tasks
 - Complete the task thoroughly

 ## What You Cannot Do
- Access the main agent's conversation history directly
+- Send messages directly to users (no message tool available)
+- Access the main agent's conversation history

 ## Workspace
 Your workspace is at: {self.workspace}
@@ -1,23 +0,0 @@
-"""Anthropic native tools implementation."""
-
-from nanobot.agent.tools.anthropic.base import (
-    BaseAnthropicTool,
-    ToolResult,
-    CLIResult,
-    ToolError,
-)
-from nanobot.agent.tools.anthropic.bash import BashTool20250124
-from nanobot.agent.tools.anthropic.edit import EditTool20250728
-from nanobot.agent.tools.anthropic.computer import ComputerTool20251124
-from nanobot.agent.tools.anthropic.memory import MemoryTool20250818
-
-__all__ = [
-    "BaseAnthropicTool",
-    "ToolResult",
-    "CLIResult",
-    "ToolError",
-    "BashTool20250124",
-    "EditTool20250728",
-    "ComputerTool20251124",
-    "MemoryTool20250818",
-]
@@ -1,68 +0,0 @@
-"""Base classes for Anthropic native tools.
-
-Ported from anthropic-quickstarts/computer-use-demo.
-"""
-
-from abc import ABCMeta, abstractmethod
-from dataclasses import dataclass
-from typing import Any
-
-
-@dataclass(kw_only=True, frozen=True)
-class ToolResult:
-    """Result from tool execution.
-
-    Structured result that can contain text output, errors, images, and system messages.
-    """
-    output: str | None = None
-    error: str | None = None
-    base64_image: str | None = None
-    system: str | None = None
-
-
-@dataclass(kw_only=True, frozen=True)
-class CLIResult:
-    """Result from CLI-style tools (like text editor).
-
-    Similar to ToolResult but simpler for text-only tools.
-    """
-    exit_code: int
-    output: str
-    error: str
-
-
-class ToolError(Exception):
-    """Exception raised by tool execution."""
-    pass
-
-
-class BaseAnthropicTool(metaclass=ABCMeta):
-    """Base class for Anthropic native tools.
-
-    Native tools are version-coupled to model training and don't require schemas.
-    """
-
-    api_type: str  # e.g., "bash_20250124"
-    name: str  # e.g., "bash"
-    beta_flag: str | None = None  # e.g., "computer-use-2025-11-24"
-
-    @abstractmethod
-    async def __call__(self, **kwargs: Any) -> ToolResult | CLIResult:
-        """Execute the tool.
-
-        Args:
-            **kwargs: Tool-specific parameters
-
-        Returns:
-            ToolResult or CLIResult with execution output
-        """
-        ...
-
-    @abstractmethod
-    def to_params(self) -> dict[str, Any]:
-        """Return tool definition for API.
-
-        Returns:
-            Dict with type and name (no schema for native tools)
-        """
-        ...
@@ -1,164 +0,0 @@
-"""BashTool20250124 - Persistent bash session with async buffer polling.
-
-Based on Anthropic's reference implementation from anthropic-quickstarts.
-Uses asyncio.create_subprocess_shell + direct buffer reads instead of
-threaded readline, which avoids exhausting the default ThreadPoolExecutor.
-"""
-
-import asyncio
-import os
-from typing import Any, Literal
-
-from nanobot.agent.tools.anthropic.base import BaseAnthropicTool, ToolResult, ToolError
-
-
-class _BashSession:
-    """A session of a bash shell.
-
-    Uses asyncio subprocess with direct buffer polling — no threads.
-    Based on anthropics/anthropic-quickstarts computer-use-demo.
-    """
-
-    command: str = "/bin/bash"
-    _output_delay: float = 0.2  # seconds between buffer polls
-    _timeout: float = 120.0  # seconds
-    _sentinel: str = "<<exit>>"
-
-    def __init__(self):
-        self._started = False
-        self._timed_out = False
-        self._process: asyncio.subprocess.Process | None = None
-
-    async def start(self):
-        if self._started:
-            return
-
-        self._process = await asyncio.create_subprocess_shell(
-            self.command,
-            preexec_fn=os.setsid,
-            shell=True,
-            bufsize=0,
-            stdin=asyncio.subprocess.PIPE,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        self._started = True
-
-    def stop(self):
-        """Terminate the bash shell."""
-        if not self._started:
-            return
-        if self._process and self._process.returncode is None:
-            self._process.terminate()
-
-    async def run(self, command: str) -> ToolResult:
-        """Execute a command in the bash shell."""
-        if not self._started:
-            raise ToolError("Session has not started.")
-        if self._process is None or self._process.returncode is not None:
-            return ToolResult(
-                system="tool must be restarted",
-                error=f"bash has exited with returncode "
-                      f"{self._process.returncode if self._process else 'unknown'}",
-            )
-        if self._timed_out:
-            raise ToolError(
-                f"timed out: bash has not returned in {self._timeout} seconds "
-                "and must be restarted",
-            )
-
-        assert self._process.stdin
-        assert self._process.stdout
-        assert self._process.stderr
-
-        # Send command + sentinel on its own line so heredoc terminators
-        # aren't corrupted (EOF; echo '...' ≠ EOF)
-        self._process.stdin.write(
-            command.encode() + f"\necho '{self._sentinel}'\n".encode()
-        )
-        await self._process.stdin.drain()
-
-        # Poll stdout buffer until sentinel appears — no threads involved
-        try:
-            async with asyncio.timeout(self._timeout):
-                while True:
-                    await asyncio.sleep(self._output_delay)
-                    output = self._process.stdout._buffer.decode()
-                    if self._sentinel in output:
-                        output = output[: output.index(self._sentinel)]
-                        break
-        except asyncio.TimeoutError:
-            self._timed_out = True
-            raise ToolError(
-                f"timed out: bash has not returned in {self._timeout} seconds "
-                "and must be restarted",
-            ) from None
-
-        if output.endswith("\n"):
-            output = output[:-1]
-
-        error = self._process.stderr._buffer.decode()
-        if error.endswith("\n"):
-            error = error[:-1]
-
-        # Clear buffers for next command
-        self._process.stdout._buffer.clear()
-        self._process.stderr._buffer.clear()
-
-        # Return as ToolResult (our loop handles this type)
-        if error and output:
-            return ToolResult(output=f"{output}\n\nstderr: {error}")
-        elif error:
-            return ToolResult(output=error)
-        else:
-            return ToolResult(output=output if output else "(no output)")
-
-
-class BashTool20250124(BaseAnthropicTool):
-    """Anthropic's native bash_20250124 tool with persistent session.
-
-    Executes bash commands in a long-running shell session. Environment
-    variables and working directory persist across commands.
-
-    Parameters:
-        command (str, optional): Bash command to execute
-        restart (bool, optional): Restart the bash session (clears state)
-    """
-
-    api_type: Literal["bash_20250124"] = "bash_20250124"
-    name: Literal["bash"] = "bash"
-    beta_flag: str | None = None
-
-    def __init__(self):
-        self._session: _BashSession | None = None
-
-    async def __call__(
-        self,
-        command: str | None = None,
-        restart: bool = False,
-        **kwargs: Any,
-    ) -> ToolResult:
-        if restart:
-            if self._session:
-                self._session.stop()
-            self._session = _BashSession()
-            await self._session.start()
-            return ToolResult(system="tool has been restarted.")
-
-        if self._session is None:
-            self._session = _BashSession()
-            await self._session.start()
-
-        if command is not None:
-            try:
-                return await self._session.run(command)
-            except ToolError as e:
-                return ToolResult(error=str(e))
-
-        return ToolResult(error="Either 'command' or 'restart=True' must be provided.")
-
-    def to_params(self) -> dict[str, Any]:
-        return {
-            "type": self.api_type,
-            "name": self.name,
-        }
@@ -1,473 +0,0 @@
-"""Computer control tool for VNC desktop interaction.
-
-VNC-based implementation of Anthropic's computer_20251124 native tool.
-
-CRITICAL vncdotool syntax:
- Use :: (double colon) for port numbers: '172.17.0.1::5900'
- Single colon means display number (port = display + 5900)
- vncdotool API is synchronous, wrapped in asyncio.to_thread()
-"""
-
-import asyncio
-import base64
-import tempfile
-from pathlib import Path
-from typing import Literal, Any
-
-from loguru import logger
-
-try:
-    from vncdotool import api as vnc_api
-except ImportError:
-    vnc_api = None
-
-from nanobot.agent.tools.anthropic.base import BaseAnthropicTool, ToolResult
-
-
-class ComputerTool20251124(BaseAnthropicTool):
-    """Computer control via VNC for desktop interaction.
-
-    Supports keyboard input, mouse control, and screenshots.
-    """
-
-    api_type: Literal["computer_20251124"] = "computer_20251124"
-    name: Literal["computer"] = "computer"
-    beta_flag: str = "computer-use-2025-11-24"
-
-    def __init__(
-        self,
-        vnc_host: str = "172.17.0.1",
-        vnc_port: int = 5900,
-        vnc_username: str = "deckedmoth",
-        vnc_password: str = "123",
-        display_width_px: int = 1024,
-        display_height_px: int = 768,
-    ):
-        """Initialize computer tool.
-
-        Args:
-            vnc_host: VNC server hostname/IP
-            vnc_port: VNC server port
-            vnc_username: VNC username (if required)
-            vnc_password: VNC password (if required)
-            display_width_px: Display width for screenshots
-            display_height_px: Display height for screenshots
-        """
-        if vnc_api is None:
-            raise ImportError(
-                "vncdotool is required for computer tool. "
-                "Install with: pip install vncdotool"
-            )
-
-        self.vnc_host = vnc_host
-        self.vnc_port = vnc_port
-        self.vnc_username = vnc_username
-        self.vnc_password = vnc_password
-        self.display_width_px = display_width_px
-        self.display_height_px = display_height_px
-
-    def to_params(self):
-        """Return tool definition for API.
-
-        NOTE: display_width_px, display_height_px, and enable_zoom are NOT
-        valid parameters for computer_20251124 and cause API hangs if sent.
-        """
-        return {
-            "type": self.api_type,
-            "name": self.name,
-        }
-
-    async def __call__(
-        self,
-        action: Literal[
-            # Basic actions
-            "key", "type", "mouse_move", "screenshot", "cursor_position",
-            # Click actions
-            "left_click", "right_click", "middle_click", "double_click", "triple_click",
-            # Advanced mouse
-            "left_mouse_down", "left_mouse_up", "left_click_drag",
-            # Scroll
-            "scroll",
-            # Advanced keyboard
-            "hold_key", "paste",  # paste bypasses keyboard layout issues
-            # Utility
-            "wait",
-            # Zoom (computer_20251124)
-            "zoom"
-        ] | None = None,
-        coordinate: list[int] | None = None,
-        text: str | None = None,
-        # Additional parameters for specific actions
-        start_coordinate: list[int] | None = None,  # For left_click_drag
-        scroll_direction: Literal["up", "down", "left", "right"] | None = None,  # For scroll
-        scroll_amount: int | None = None,  # For scroll
-        duration: float | None = None,  # For hold_key, wait
-        region: list[int] | None = None,  # For zoom [x1, y1, x2, y2]
-        key: str | None = None,  # Modifier key for clicks/scroll
-        **kwargs,
-    ) -> ToolResult:
-        """Execute computer control action.
-
-        Args:
-            action: Action to perform
-            coordinate: [x, y] coordinates for mouse actions
-            text: Text to type or key name to press
-
-        Returns:
-            ToolResult with action result or screenshot
-        """
-        if not action:
-            return ToolResult(error="No action provided")
-
-        try:
-            # Connect with correct syntax: double colon (::) for port number
-            result = await asyncio.to_thread(
-                self._execute_vnc_action,
-                action,
-                coordinate,
-                text,
-                start_coordinate,
-                scroll_direction,
-                scroll_amount,
-                duration,
-                region,
-                key
-            )
-            return result
-        except Exception as e:
-            logger.error(f"Computer tool error: {e}")
-            return ToolResult(error=str(e))
-
-    def _execute_vnc_action(
-        self,
-        action: str,
-        coordinate: list[int] | None,
-        text: str | None,
-        start_coordinate: list[int] | None,
-        scroll_direction: str | None,
-        scroll_amount: int | None,
-        duration: float | None,
-        region: list[int] | None,
-        modifier_key: str | None
-    ) -> ToolResult:
-        """Execute VNC action in thread (vncdotool is synchronous).
-
-        CRITICAL: vncdotool syntax requires :: (double colon) for port numbers!
-        Single colon means display number: 172.17.0.1:5900 = display 5900 (port 11800)
-        Double colon means port number: 172.17.0.1::5900 = port 5900
-        """
-        # Connect with DOUBLE colon for port
-        server = f"{self.vnc_host}::{self.vnc_port}"
-        client = vnc_api.connect(server, username=self.vnc_username, password=self.vnc_password)
-
-        try:
-            # Basic actions
-            if action == "screenshot":
-                return self._screenshot(client)
-            elif action == "key":
-                return self._key(client, text or "")
-            elif action == "type":
-                return self._type(client, text or "")
-            elif action == "mouse_move":
-                return self._mouse_move(client, coordinate or [0, 0])
-            elif action == "cursor_position":
-                return ToolResult(output="Cursor position tracking not implemented")
-
-            # Click actions
-            elif action == "left_click":
-                return self._left_click(client, coordinate, modifier_key)
-            elif action == "right_click":
-                return self._right_click(client, coordinate, modifier_key)
-            elif action == "middle_click":
-                return self._middle_click(client, coordinate, modifier_key)
-            elif action == "double_click":
-                return self._double_click(client, coordinate, modifier_key)
-            elif action == "triple_click":
-                return self._triple_click(client, coordinate, modifier_key)
-
-            # Advanced mouse
-            elif action == "left_mouse_down":
-                return self._left_mouse_down(client)
-            elif action == "left_mouse_up":
-                return self._left_mouse_up(client)
-            elif action == "left_click_drag":
-                return self._left_click_drag(client, start_coordinate, coordinate)
-
-            # Scroll
-            elif action == "scroll":
-                return self._scroll(client, coordinate, scroll_direction, scroll_amount, modifier_key)
-
-            # Advanced keyboard
-            elif action == "hold_key":
-                return self._hold_key(client, text, duration)
-            elif action == "paste":
-                return self._paste(client, text)
-
-            # Utility
-            elif action == "wait":
-                return self._wait(duration)
-
-            # Zoom
-            elif action == "zoom":
-                return self._zoom(client, region)
-
-            else:
-                return ToolResult(error=f"Unknown action: {action}")
-        finally:
-            client.disconnect()
-
-    def _screenshot(self, client) -> ToolResult:
-        """Capture screenshot.
-
-        captureScreen() requires a file path, can't use BytesIO without format.
-        Use temp file then read as bytes.
-
-        IMPORTANT: VNC display may be in sleep mode. Wake it up before screenshot.
-        """
-        import time
-
-        # Wake up display (move mouse + press space to wake screensaver)
-        client.mouseMove(self.display_width_px // 2, self.display_height_px // 2)
-        time.sleep(0.1)
-        client.keyPress('space')
-        time.sleep(0.5)  # Wait for display to wake
-
-        # Request framebuffer update
-        client.refreshScreen()
-        time.sleep(0.5)  # Wait for framebuffer refresh
-
-        # Capture screenshot
-        with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
-            tmp_path = tmp.name
-
-        client.captureScreen(tmp_path)
-        png_data = Path(tmp_path).read_bytes()
-        Path(tmp_path).unlink()  # Clean up
-
-        base64_data = base64.b64encode(png_data).decode()
-        return ToolResult(base64_image=base64_data)
-
-    def _key(self, client, text: str) -> ToolResult:
-        """Press a key.
-
-        Use lowercase names from KEYMAP: 'esc', 'return', 'tab', etc.
-        Single characters work directly: 'a', 'b', '1', etc.
-        """
-        client.keyPress(text.lower())
-        return ToolResult(output=f"Pressed key: {text}")
-
-    def _type(self, client, text: str) -> ToolResult:
-        """Type text character by character."""
-        for char in text:
-            client.keyPress(char)
-        return ToolResult(output=f"Typed: {text}")
-
-    def _mouse_move(self, client, coordinate: list[int]) -> ToolResult:
-        """Move mouse to coordinate."""
-        x, y = coordinate[0], coordinate[1]
-        client.mouseMove(x, y)
-        return ToolResult(output=f"Moved mouse to ({x}, {y})")
-
-    def _left_click(self, client, coordinate: list[int] | None = None, modifier_key: str | None = None) -> ToolResult:
-        """Left click at coordinate (or current position)."""
-        if coordinate:
-            client.mouseMove(coordinate[0], coordinate[1])
-        if modifier_key:
-            client.keyDown(modifier_key.lower())
-        client.mousePress(1)  # 1 = left button
-        if modifier_key:
-            client.keyUp(modifier_key.lower())
-        return ToolResult(output="Left clicked")
-
-    def _right_click(self, client, coordinate: list[int] | None = None, modifier_key: str | None = None) -> ToolResult:
-        """Right click at coordinate (or current position)."""
-        if coordinate:
-            client.mouseMove(coordinate[0], coordinate[1])
-        if modifier_key:
-            client.keyDown(modifier_key.lower())
-        client.mousePress(3)  # 3 = right button
-        if modifier_key:
-            client.keyUp(modifier_key.lower())
-        return ToolResult(output="Right clicked")
-
-    def _middle_click(self, client, coordinate: list[int] | None = None, modifier_key: str | None = None) -> ToolResult:
-        """Middle click at coordinate (or current position)."""
-        if coordinate:
-            client.mouseMove(coordinate[0], coordinate[1])
-        if modifier_key:
-            client.keyDown(modifier_key.lower())
-        client.mousePress(2)  # 2 = middle button
-        if modifier_key:
-            client.keyUp(modifier_key.lower())
-        return ToolResult(output="Middle clicked")
-
-    def _double_click(self, client, coordinate: list[int] | None = None, modifier_key: str | None = None) -> ToolResult:
-        """Double click at coordinate (or current position)."""
-        if coordinate:
-            client.mouseMove(coordinate[0], coordinate[1])
-        if modifier_key:
-            client.keyDown(modifier_key.lower())
-        client.mousePress(1)
-        import time
-        time.sleep(0.01)  # 10ms delay between clicks
-        client.mousePress(1)
-        if modifier_key:
-            client.keyUp(modifier_key.lower())
-        return ToolResult(output="Double clicked")
-
-    def _triple_click(self, client, coordinate: list[int] | None = None, modifier_key: str | None = None) -> ToolResult:
-        """Triple click at coordinate (or current position)."""
-        if coordinate:
-            client.mouseMove(coordinate[0], coordinate[1])
-        if modifier_key:
-            client.keyDown(modifier_key.lower())
-        import time
-        for _ in range(3):
-            client.mousePress(1)
-            time.sleep(0.01)  # 10ms delay between clicks
-        if modifier_key:
-            client.keyUp(modifier_key.lower())
-        return ToolResult(output="Triple clicked")
-
-    def _left_mouse_down(self, client) -> ToolResult:
-        """Press and hold left mouse button."""
-        client.mouseDown(1)
-        return ToolResult(output="Left mouse button down")
-
-    def _left_mouse_up(self, client) -> ToolResult:
-        """Release left mouse button."""
-        client.mouseUp(1)
-        return ToolResult(output="Left mouse button up")
-
-    def _left_click_drag(self, client, start_coordinate: list[int] | None, end_coordinate: list[int] | None) -> ToolResult:
-        """Drag from start to end coordinate."""
-        if not start_coordinate or not end_coordinate:
-            return ToolResult(error="Both start_coordinate and coordinate required for left_click_drag")
-
-        start_x, start_y = start_coordinate[0], start_coordinate[1]
-        end_x, end_y = end_coordinate[0], end_coordinate[1]
-
-        client.mouseMove(start_x, start_y)
-        client.mouseDown(1)
-        client.mouseDrag(end_x, end_y)  # vncdotool's mouseDrag method
-        client.mouseUp(1)
-        return ToolResult(output=f"Dragged from ({start_x}, {start_y}) to ({end_x}, {end_y})")
-
-    def _scroll(
-        self,
-        client,
-        coordinate: list[int] | None,
-        scroll_direction: str | None,
-        scroll_amount: int | None,
-        modifier_key: str | None
-    ) -> ToolResult:
-        """Scroll in specified direction."""
-        if not scroll_direction or scroll_direction not in ("up", "down", "left", "right"):
-            return ToolResult(error=f"scroll_direction must be 'up', 'down', 'left', or 'right'")
-
-        amount = scroll_amount or 5  # Default scroll amount
-
-        # Move to coordinate if specified
-        if coordinate:
-            client.mouseMove(coordinate[0], coordinate[1])
-
-        # VNC scroll buttons: 4=up, 5=down, 6=left, 7=right
-        scroll_button = {"up": 4, "down": 5, "left": 6, "right": 7}[scroll_direction]
-
-        # Hold modifier key if specified
-        if modifier_key:
-            client.keyDown(modifier_key.lower())
-
-        # Scroll by pressing scroll button multiple times
-        import time
-        for _ in range(amount):
-            client.mousePress(scroll_button)
-            time.sleep(0.05)  # Small delay between scroll events
-
-        if modifier_key:
-            client.keyUp(modifier_key.lower())
-
-        return ToolResult(output=f"Scrolled {scroll_direction} {amount} times")
-
-    def _hold_key(self, client, text: str | None, duration: float | None) -> ToolResult:
-        """Hold a key for specified duration."""
-        if not text:
-            return ToolResult(error="text (key name) required for hold_key")
-
-        hold_duration = duration or 1.0  # Default 1 second
-        if hold_duration < 0 or hold_duration > 100:
-            return ToolResult(error="duration must be between 0 and 100 seconds")
-
-        import time
-        client.keyDown(text.lower())
-        time.sleep(hold_duration)
-        client.keyUp(text.lower())
-
-        return ToolResult(output=f"Held key '{text}' for {hold_duration}s")
-
-    def _paste(self, client, text: str | None) -> ToolResult:
-        """Paste text via clipboard (bypasses keyboard layout issues).
-
-        This uses VNC clipboard to send text, avoiding keyboard layout mismatches
-        where characters like ':' become ';' due to different keyboard mappings.
-        """
-        if not text:
-            return ToolResult(error="text required for paste")
-
-        # Send text via clipboard and trigger paste
-        client.paste(text)
-        return ToolResult(output=f"Pasted via clipboard: {text[:50]}{'...' if len(text) > 50 else ''}")
-
-    def _wait(self, duration: float | None) -> ToolResult:
-        """Wait for specified duration."""
-        wait_duration = duration or 1.0
-        if wait_duration < 0 or wait_duration > 100:
-            return ToolResult(error="duration must be between 0 and 100 seconds")
-
-        import time
-        time.sleep(wait_duration)
-        return ToolResult(output=f"Waited {wait_duration}s")
-
-    def _zoom(self, client, region: list[int] | None) -> ToolResult:
-        """Zoom into specified region and capture screenshot.
-
-        Region format: [x1, y1, x2, y2] - top-left and bottom-right corners.
-        """
-        if not region or len(region) != 4:
-            return ToolResult(error="region must be [x1, y1, x2, y2]")
-
-        # Take full screenshot first
-        import time
-        from PIL import Image
-
-        # Wake up display
-        client.mouseMove(self.display_width_px // 2, self.display_height_px // 2)
-        time.sleep(0.1)
-        client.keyPress('space')
-        time.sleep(0.5)
-        client.refreshScreen()
-        time.sleep(0.5)
-
-        # Capture screenshot
-        with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
-            tmp_path = tmp.name
-
-        client.captureScreen(tmp_path)
-
-        # Crop to region
-        img = Image.open(tmp_path)
-        x1, y1, x2, y2 = region
-        cropped = img.crop((x1, y1, x2, y2))
-
-        # Save cropped image
-        cropped_path = tmp_path.replace('.png', '_cropped.png')
-        cropped.save(cropped_path)
-
-        # Read and encode
-        png_data = Path(cropped_path).read_bytes()
-        Path(tmp_path).unlink()  # Clean up original
-        Path(cropped_path).unlink()  # Clean up cropped
-
-        base64_data = base64.b64encode(png_data).decode()
-        return ToolResult(base64_image=base64_data)
-
@@ -1,257 +0,0 @@
-"""
-EditTool20250728 - File editor with view/create/str_replace/insert commands.
-
-Anthropic's native trained tool for file editing operations.
-"""
-
-from pathlib import Path
-from typing import Any, Literal
-
-from .base import BaseAnthropicTool, CLIResult
-
-
-class EditTool20250728(BaseAnthropicTool):
-    """
-    File editor supporting view, create, str_replace, and insert operations.
-
-    Trained by Anthropic, this tool provides comprehensive file editing
-    capabilities with strict safety checks.
-    """
-
-    api_type: Literal["text_editor_20250728"] = "text_editor_20250728"
-    name: Literal["str_replace_based_edit_tool"] = "str_replace_based_edit_tool"
-    beta_flag: str | None = None
-
-    async def __call__(
-        self,
-        command: Literal["view", "create", "str_replace", "insert"],
-        path: str,
-        file_text: str | None = None,
-        old_str: str | None = None,
-        new_str: str | None = None,
-        insert_line: int | None = None,
-        view_range: list[int] | None = None,
-        **kwargs: Any,
-    ) -> CLIResult:
-        """
-        Execute a file editing command.
-
-        Args:
-            command: The operation to perform
-            path: Absolute path to the file
-            file_text: Full file content (for create)
-            old_str: String to replace (for str_replace)
-            new_str: Replacement string (for str_replace/insert)
-            insert_line: Line number to insert at (for insert)
-            view_range: [start, end] line range (for view)
-            **kwargs: Additional arguments (ignored)
-
-        Returns:
-            CLIResult with exit code, output, and error
-        """
-        # Validate absolute path
-        file_path = Path(path)
-        if not file_path.is_absolute():
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: path must be absolute, got: {path}"
-            )
-
-        try:
-            if command == "view":
-                return await self._view(file_path, view_range)
-            elif command == "create":
-                return await self._create(file_path, file_text)
-            elif command == "str_replace":
-                return await self._str_replace(file_path, old_str, new_str)
-            elif command == "insert":
-                return await self._insert(file_path, insert_line, new_str)
-            else:
-                return CLIResult(
-                    exit_code=1,
-                    output="",
-                    error=f"Error: unknown command: {command}"
-                )
-        except Exception as e:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: {str(e)}"
-            )
-
-    async def _view(self, path: Path, view_range: list[int] | None) -> CLIResult:
-        """View file contents with line numbers."""
-        if not path.exists():
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: file not found: {path}"
-            )
-
-        content = path.read_text()
-        lines = content.splitlines(keepends=True)
-
-        # Apply view range if specified
-        if view_range:
-            start, end = view_range
-            lines = lines[start - 1:end]
-            start_num = start
-        else:
-            start_num = 1
-
-        # Format with line numbers
-        formatted_lines = [
-            f"{start_num + i}|{line.rstrip()}"
-            for i, line in enumerate(lines)
-        ]
-
-        return CLIResult(
-            exit_code=0,
-            output="\n".join(formatted_lines),
-            error=""
-        )
-
-    async def _create(self, path: Path, file_text: str | None) -> CLIResult:
-        """Create a new file with the given content."""
-        if file_text is None:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error="Error: file_text is required for create command"
-            )
-
-        if path.exists():
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: file already exists: {path}"
-            )
-
-        # Create parent directories if needed
-        path.parent.mkdir(parents=True, exist_ok=True)
-
-        # Write the file
-        path.write_text(file_text)
-
-        return CLIResult(
-            exit_code=0,
-            output=f"File created: {path}",
-            error=""
-        )
-
-    async def _str_replace(
-        self,
-        path: Path,
-        old_str: str | None,
-        new_str: str | None
-    ) -> CLIResult:
-        """Replace a unique occurrence of old_str with new_str."""
-        if old_str is None:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error="Error: old_str is required for str_replace command"
-            )
-
-        if new_str is None:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error="Error: new_str is required for str_replace command"
-            )
-
-        if not path.exists():
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: file not found: {path}"
-            )
-
-        content = path.read_text()
-
-        # Check for unique match
-        count = content.count(old_str)
-        if count == 0:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: old_str not found in file: {old_str!r}"
-            )
-        elif count > 1:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: old_str must match exactly once, found {count} matches"
-            )
-
-        # Perform replacement
-        new_content = content.replace(old_str, new_str)
-        path.write_text(new_content)
-
-        return CLIResult(
-            exit_code=0,
-            output=f"Replaced 1 occurrence in: {path}",
-            error=""
-        )
-
-    async def _insert(
-        self,
-        path: Path,
-        insert_line: int | None,
-        new_str: str | None
-    ) -> CLIResult:
-        """Insert new_str at the specified line number."""
-        if insert_line is None:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error="Error: insert_line is required for insert command"
-            )
-
-        if new_str is None:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error="Error: new_str is required for insert command"
-            )
-
-        if not path.exists():
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: file not found: {path}"
-            )
-
-        content = path.read_text()
-        lines = content.splitlines(keepends=True)
-
-        # Validate line number
-        if insert_line < 0 or insert_line > len(lines):
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: insert_line {insert_line} out of range [0, {len(lines)}]"
-            )
-
-        # Insert the new string
-        lines.insert(insert_line, new_str)
-        new_content = "".join(lines)
-        path.write_text(new_content)
-
-        return CLIResult(
-            exit_code=0,
-            output=f"Inserted text at line {insert_line} in: {path}",
-            error=""
-        )
-
-    def to_params(self) -> dict[str, Any]:
-        """Convert to Anthropic API tool parameter format.
-
-        Returns:
-            Tool definition for Anthropic API with text_editor_20250728 type
-        """
-        return {
-            "type": self.api_type,
-            "name": self.name,
-        }
@@ -1,592 +0,0 @@
-"""MemoryTool20250818 - Anthropic's native memory tool.
-
-Enables Claude to create, read, update, and delete files in a persistent
-/memories directory across conversations.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any, Literal
-
-from nanobot.agent.tools.anthropic.base import BaseAnthropicTool, CLIResult
-
-
-class MemoryTool20250818(BaseAnthropicTool):
-    """Anthropic's native memory_20250818 tool.
-
-    Client-side tool for persistent memory storage across conversations.
-    All operations are restricted to the /memories directory.
-
-    Commands:
-        - view: Show directory contents or file contents with line numbers
-        - create: Create a new file with content
-        - str_replace: Replace unique text occurrence in a file
-        - insert: Insert text at a specific line number
-        - delete: Delete a file or directory
-        - rename: Rename or move a file/directory
-    """
-
-    api_type: Literal["memory_20250818"] = "memory_20250818"
-    name: Literal["memory"] = "memory"
-    beta_flag: str = "context-management-2025-06-27"
-
-    def __init__(self, workspace: Path):
-        """Initialize Memory tool.
-
-        Args:
-            workspace: Root workspace directory
-        """
-        self.workspace = workspace
-        self.memories_dir = workspace / "memories"
-        self.memories_dir.mkdir(parents=True, exist_ok=True)
-
-    def _validate_memory_path(self, path: str) -> Path:
-        """Validate and resolve path to prevent directory traversal.
-
-        Args:
-            path: Path string starting with /memories
-
-        Returns:
-            Validated absolute Path within memories directory
-
-        Raises:
-            ValueError: If path is invalid or escapes /memories directory
-        """
-        # Reject paths not starting with /memories
-        if not path.startswith("/memories"):
-            raise ValueError(f"Path must start with /memories, got: {path}")
-
-        # Resolve to absolute path within workspace
-        # lstrip("/") removes leading slash: "/memories/file.txt" -> "memories/file.txt"
-        relative_path = path.lstrip("/")
-        full_path = (self.workspace / relative_path).resolve()
-
-        # Verify resolved path is within memories directory
-        memories_dir_resolved = self.memories_dir.resolve()
-        try:
-            full_path.relative_to(memories_dir_resolved)
-        except ValueError:
-            raise ValueError(f"Path escapes /memories directory: {path}")
-
-        return full_path
-
-    async def __call__(
-        self,
-        command: Literal["view", "create", "str_replace", "insert", "delete", "rename"],
-        path: str | None = None,
-        old_path: str | None = None,
-        new_path: str | None = None,
-        file_text: str | None = None,
-        old_str: str | None = None,
-        new_str: str | None = None,
-        insert_line: int | None = None,
-        insert_text: str | None = None,
-        view_range: list[int] | None = None,
-        **kwargs: Any,
-    ) -> CLIResult:
-        """Execute memory command.
-
-        Args:
-            command: Command to execute
-            path: File/directory path (for view/create/str_replace/insert/delete)
-            old_path: Source path (for rename)
-            new_path: Destination path (for rename)
-            file_text: File content (for create)
-            old_str: Text to find (for str_replace)
-            new_str: Replacement text (for str_replace)
-            insert_line: Line number to insert at (for insert)
-            insert_text: Text to insert (for insert)
-            view_range: [start_line, end_line] for view
-            **kwargs: Additional arguments (ignored)
-
-        Returns:
-            CLIResult with command output or error
-        """
-        try:
-            if command == "view":
-                return await self._view(path, view_range)
-            elif command == "create":
-                return await self._create(path, file_text)
-            elif command == "str_replace":
-                return await self._str_replace(path, old_str, new_str)
-            elif command == "insert":
-                return await self._insert(path, insert_line, insert_text)
-            elif command == "delete":
-                return await self._delete(path)
-            elif command == "rename":
-                return await self._rename(old_path, new_path)
-            else:
-                return CLIResult(
-                    exit_code=1,
-                    output="",
-                    error=f"Unknown command: {command}"
-                )
-        except ValueError as e:
-            # Path security error
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: {e}"
-            )
-        except Exception as e:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: {e}"
-            )
-
-    async def _view(
-        self,
-        path: str | None,
-        view_range: list[int] | None = None,
-    ) -> CLIResult:
-        """View directory listing or file contents.
-
-        Args:
-            path: Path to view
-            view_range: Optional [start_line, end_line] for file viewing (1-indexed)
-
-        Returns:
-            CLIResult with directory listing or file contents
-        """
-        if path is None:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error="Error: path is required for view command"
-            )
-
-        path_str = path  # Keep original for error messages
-        validated_path = self._validate_memory_path(path)
-
-        # Directory listing
-        if validated_path.is_dir():
-            return await self._view_directory(validated_path, path_str)
-
-        # File viewing
-        if not validated_path.exists():
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"The path {path_str} does not exist. Please provide a valid path."
-            )
-
-        # Read file
-        try:
-            content = validated_path.read_text()
-        except Exception as e:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error reading file: {e}"
-            )
-
-        lines = content.splitlines(keepends=True)
-
-        # Check line limit
-        if len(lines) > 999_999:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"File {path_str} exceeds maximum line limit of 999,999 lines."
-            )
-
-        # Apply view_range if specified
-        if view_range:
-            start, end = view_range
-            # Convert to 0-indexed, clamp to valid range
-            start_idx = max(0, start - 1)
-            end_idx = min(len(lines), end)
-            lines_to_show = lines[start_idx:end_idx]
-            start_num = start
-        else:
-            lines_to_show = lines
-            start_num = 1
-
-        # Format with line numbers (6 chars, right-aligned, tab-separated)
-        formatted_lines = []
-        for i, line in enumerate(lines_to_show):
-            line_num = start_num + i
-            # Remove trailing newline for display
-            line_content = line.rstrip("\n")
-            formatted_lines.append(f"{line_num:6d}\t{line_content}")
-
-        output = f"Here's the content of {path_str} with line numbers:\n"
-        output += "\n".join(formatted_lines)
-
-        return CLIResult(
-            exit_code=0,
-            output=output,
-            error=""
-        )
-
-    async def _view_directory(self, path: Path, path_str: str) -> CLIResult:
-        """View directory listing up to 2 levels deep.
-
-        Args:
-            path: Validated Path object
-            path_str: Original path string for display
-
-        Returns:
-            CLIResult with directory listing
-        """
-        import os
-
-        def format_size(size_bytes: int) -> str:
-            """Convert bytes to human-readable format."""
-            for unit in ['B', 'K', 'M', 'G', 'T']:
-                if size_bytes < 1024:
-                    return f"{size_bytes:.1f}{unit}"
-                size_bytes /= 1024
-            return f"{size_bytes:.1f}P"
-
-        lines = []
-        header = f"Here're the files and directories up to 2 levels deep in {path_str}, excluding hidden items and node_modules:"
-        lines.append(header)
-
-        # Walk directory tree (max depth 2)
-        base_depth = str(path).count(os.sep)
-
-        for root, dirs, files in os.walk(path):
-            # Calculate current depth
-            current_depth = str(root).count(os.sep) - base_depth
-
-            # Filter out hidden items and node_modules at this level
-            dirs[:] = [d for d in dirs if not d.startswith('.') and d != 'node_modules']
-
-            # Stop if we've gone too deep
-            if current_depth >= 2:
-                dirs.clear()  # Don't recurse further
-                continue
-
-            # Get size and add directory entry
-            root_path = Path(root)
-            try:
-                # Directory size (sum of all files within, or 4K default)
-                dir_size = sum(f.stat().st_size for f in root_path.rglob('*') if f.is_file())
-                if dir_size == 0:
-                    dir_size = 4096  # Default directory size
-                size_str = format_size(dir_size)
-
-                # Convert absolute path to /memories/... format
-                relative = root_path.relative_to(self.workspace)
-                display_path = "/" + str(relative).replace(os.sep, "/")
-
-                lines.append(f"{size_str}\t{display_path}")
-            except Exception:
-                pass
-
-            # Add file entries at this level
-            for filename in sorted(files):
-                if filename.startswith('.'):
-                    continue  # Skip hidden files
-
-                file_path = root_path / filename
-                try:
-                    file_size = file_path.stat().st_size
-                    size_str = format_size(file_size)
-
-                    # Convert to /memories/... format
-                    relative = file_path.relative_to(self.workspace)
-                    display_path = "/" + str(relative).replace(os.sep, "/")
-
-                    lines.append(f"{size_str}\t{display_path}")
-                except Exception:
-                    pass
-
-        return CLIResult(
-            exit_code=0,
-            output="\n".join(lines),
-            error=""
-        )
-
-    async def _create(
-        self,
-        path: str | None,
-        file_text: str | None,
-    ) -> CLIResult:
-        """Create a new file with content.
-
-        Args:
-            path: File path to create
-            file_text: Content to write
-
-        Returns:
-            CLIResult with success message or error
-        """
-        if path is None:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error="Error: path is required for create command"
-            )
-
-        if file_text is None:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error="Error: file_text is required for create command"
-            )
-
-        path_str = path  # Keep original for error messages
-        validated_path = self._validate_memory_path(path)
-
-        # Check if file already exists
-        if validated_path.exists():
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: File {path_str} already exists"
-            )
-
-        # Create parent directories if needed
-        try:
-            validated_path.parent.mkdir(parents=True, exist_ok=True)
-        except Exception as e:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error creating parent directories: {e}"
-            )
-
-        # Write file
-        try:
-            validated_path.write_text(file_text)
-        except Exception as e:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error writing file: {e}"
-            )
-
-        return CLIResult(
-            exit_code=0,
-            output=f"File created successfully at: {path_str}",
-            error=""
-        )
-
-    async def _str_replace(
-        self,
-        path: str | None,
-        old_str: str | None,
-        new_str: str | None,
-    ) -> CLIResult:
-        """Replace unique occurrence of old_str with new_str."""
-        if path is None or old_str is None or new_str is None:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error="Error: old_str and new_str are required for str_replace command"
-            )
-
-        path_str = path
-        validated_path = self._validate_memory_path(path)
-
-        if not validated_path.exists() or validated_path.is_dir():
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: The path {path_str} does not exist. Please provide a valid path."
-            )
-
-        content = validated_path.read_text()
-        count = content.count(old_str)
-
-        if count == 0:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"No replacement was performed, old_str `{old_str}` did not appear verbatim in {path_str}."
-            )
-        elif count > 1:
-            lines = content.splitlines()
-            line_nums = [i + 1 for i, line in enumerate(lines) if old_str in line]
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"No replacement was performed. Multiple occurrences of old_str `{old_str}` in lines: {line_nums}. Please ensure it is unique"
-            )
-
-        new_content = content.replace(old_str, new_str, 1)
-        validated_path.write_text(new_content)
-
-        return CLIResult(
-            exit_code=0,
-            output="The memory file has been edited.",
-            error=""
-        )
-
-    async def _insert(
-        self, path: str | None, insert_line: int | None, insert_text: str | None
-    ) -> CLIResult:
-        """Insert text at a specific line number.
-
-        Args:
-            path: File path to modify
-            insert_line: Line number to insert at (0 = beginning)
-            insert_text: Text to insert
-
-        Returns:
-            CLIResult with success message or error
-        """
-        if path is None or insert_line is None or insert_text is None:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error="Error: path, insert_line, and insert_text are required for insert command"
-            )
-
-        path_str = path
-        validated_path = self._validate_memory_path(path)
-
-        if not validated_path.exists() or validated_path.is_dir():
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: The path {path_str} does not exist. Please provide a valid path."
-            )
-
-        # Read current content
-        content = validated_path.read_text()
-        lines = content.splitlines(keepends=True)
-
-        # Validate insert_line
-        if insert_line < 0 or insert_line > len(lines):
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Invalid `insert_line` parameter: {insert_line}. It should be within 0 to {len(lines)}"
-            )
-
-        # Insert text at specified line
-        lines.insert(insert_line, insert_text)
-        new_content = "".join(lines)
-        validated_path.write_text(new_content)
-
-        return CLIResult(
-            exit_code=0,
-            output=f"The file {path_str} has been edited.",
-            error=""
-        )
-
-    async def _delete(self, path: str | None) -> CLIResult:
-        """Delete a file or directory.
-
-        Args:
-            path: Path to delete
-
-        Returns:
-            CLIResult with success message or error
-        """
-        if path is None:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error="Error: path is required for delete command"
-            )
-
-        path_str = path
-        validated_path = self._validate_memory_path(path)
-
-        if not validated_path.exists():
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: The path {path_str} does not exist. Please provide a valid path."
-            )
-
-        # Delete file or directory
-        try:
-            if validated_path.is_dir():
-                import shutil
-                shutil.rmtree(validated_path)
-            else:
-                validated_path.unlink()
-        except Exception as e:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error deleting {path_str}: {e}"
-            )
-
-        return CLIResult(
-            exit_code=0,
-            output=f"Successfully deleted {path_str}",
-            error=""
-        )
-
-    async def _rename(self, old_path: str | None, new_path: str | None) -> CLIResult:
-        """Rename or move a file or directory.
-
-        Args:
-            old_path: Source path
-            new_path: Destination path
-
-        Returns:
-            CLIResult with success message or error
-        """
-        if old_path is None or new_path is None:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error="Error: old_path and new_path are required for rename command"
-            )
-
-        old_path_str = old_path
-        new_path_str = new_path
-        validated_old = self._validate_memory_path(old_path)
-        validated_new = self._validate_memory_path(new_path)
-
-        # Check if source exists
-        if not validated_old.exists():
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: The path {old_path_str} does not exist. Please provide a valid path."
-            )
-
-        # Check if destination already exists
-        if validated_new.exists():
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error: The destination {new_path_str} already exists. Please provide a different destination."
-            )
-
-        # Create parent directories if needed
-        try:
-            validated_new.parent.mkdir(parents=True, exist_ok=True)
-        except Exception as e:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error creating parent directories: {e}"
-            )
-
-        # Rename/move
-        try:
-            validated_old.rename(validated_new)
-        except Exception as e:
-            return CLIResult(
-                exit_code=1,
-                output="",
-                error=f"Error renaming {old_path_str}: {e}"
-            )
-
-        return CLIResult(
-            exit_code=0,
-            output=f"Successfully renamed {old_path_str} to {new_path_str}",
-            error=""
-        )
-
-    def to_params(self) -> dict[str, Any]:
-        """Convert to Anthropic API tool parameter format.
-
-        Returns:
-            Tool definition for Anthropic API
-        """
-        return {
-            "type": self.api_type,
-            "name": self.name,
-        }
@@ -50,10 +50,6 @@ class CronTool(Tool):
                    "type": "string",
                    "description": "Cron expression like '0 9 * * *' (for scheduled tasks)"
                },
-                "tz": {
-                    "type": "string",
-                    "description": "IANA timezone for cron expressions (e.g. 'America/Vancouver')"
-                },
                "at": {
                    "type": "string",
                    "description": "ISO datetime for one-time execution (e.g. '2026-02-12T10:30:00')"
@@ -72,46 +68,30 @@ class CronTool(Tool):
        message: str = "",
        every_seconds: int | None = None,
        cron_expr: str | None = None,
-        tz: str | None = None,
        at: str | None = None,
        job_id: str | None = None,
        **kwargs: Any
    ) -> str:
        if action == "add":
-            return self._add_job(message, every_seconds, cron_expr, tz, at)
+            return self._add_job(message, every_seconds, cron_expr, at)
        elif action == "list":
            return self._list_jobs()
        elif action == "remove":
            return self._remove_job(job_id)
        return f"Unknown action: {action}"
    
-    def _add_job(
-        self,
-        message: str,
-        every_seconds: int | None,
-        cron_expr: str | None,
-        tz: str | None,
-        at: str | None,
-    ) -> str:
+    def _add_job(self, message: str, every_seconds: int | None, cron_expr: str | None, at: str | None) -> str:
        if not message:
            return "Error: message is required for add"
        if not self._channel or not self._chat_id:
            return "Error: no session context (channel/chat_id)"
-        if tz and not cron_expr:
-            return "Error: tz can only be used with cron_expr"
-        if tz:
-            from zoneinfo import ZoneInfo
-            try:
-                ZoneInfo(tz)
-            except (KeyError, Exception):
-                return f"Error: unknown timezone '{tz}'"
        
        # Build schedule
        delete_after = False
        if every_seconds:
            schedule = CronSchedule(kind="every", every_ms=every_seconds * 1000)
        elif cron_expr:
-            schedule = CronSchedule(kind="cron", expr=cron_expr, tz=tz)
+            schedule = CronSchedule(kind="cron", expr=cron_expr)
        elif at:
            from datetime import datetime
            dt = datetime.fromisoformat(at)
@@ -1,31 +1,23 @@
 """File system tools: read, write, edit."""

-import difflib
 from pathlib import Path
 from typing import Any

 from nanobot.agent.tools.base import Tool


-def _resolve_path(path: str, workspace: Path | None = None, allowed_dir: Path | None = None) -> Path:
-    """Resolve path against workspace (if relative) and enforce directory restriction."""
-    p = Path(path).expanduser()
-    if not p.is_absolute() and workspace:
-        p = workspace / p
-    resolved = p.resolve()
-    if allowed_dir:
-        try:
-            resolved.relative_to(allowed_dir.resolve())
-        except ValueError:
-            raise PermissionError(f"Path {path} is outside allowed directory {allowed_dir}")
+def _resolve_path(path: str, allowed_dir: Path | None = None) -> Path:
+    """Resolve path and optionally enforce directory restriction."""
+    resolved = Path(path).expanduser().resolve()
+    if allowed_dir and not str(resolved).startswith(str(allowed_dir.resolve())):
+        raise PermissionError(f"Path {path} is outside allowed directory {allowed_dir}")
    return resolved


 class ReadFileTool(Tool):
    """Tool to read file contents."""
-
-    def __init__(self, workspace: Path | None = None, allowed_dir: Path | None = None):
-        self._workspace = workspace
+    
+    def __init__(self, allowed_dir: Path | None = None):
        self._allowed_dir = allowed_dir

    @property
@@ -51,12 +43,12 @@ class ReadFileTool(Tool):
    
    async def execute(self, path: str, **kwargs: Any) -> str:
        try:
-            file_path = _resolve_path(path, self._workspace, self._allowed_dir)
+            file_path = _resolve_path(path, self._allowed_dir)
            if not file_path.exists():
                return f"Error: File not found: {path}"
            if not file_path.is_file():
                return f"Error: Not a file: {path}"
-
+            
            content = file_path.read_text(encoding="utf-8")
            return content
        except PermissionError as e:
@@ -67,9 +59,8 @@ class ReadFileTool(Tool):

 class WriteFileTool(Tool):
    """Tool to write content to a file."""
-
-    def __init__(self, workspace: Path | None = None, allowed_dir: Path | None = None):
-        self._workspace = workspace
+    
+    def __init__(self, allowed_dir: Path | None = None):
        self._allowed_dir = allowed_dir

    @property
@@ -99,10 +90,10 @@ class WriteFileTool(Tool):
    
    async def execute(self, path: str, content: str, **kwargs: Any) -> str:
        try:
-            file_path = _resolve_path(path, self._workspace, self._allowed_dir)
+            file_path = _resolve_path(path, self._allowed_dir)
            file_path.parent.mkdir(parents=True, exist_ok=True)
            file_path.write_text(content, encoding="utf-8")
-            return f"Successfully wrote {len(content)} bytes to {file_path}"
+            return f"Successfully wrote {len(content)} bytes to {path}"
        except PermissionError as e:
            return f"Error: {e}"
        except Exception as e:
@@ -111,9 +102,8 @@ class WriteFileTool(Tool):

 class EditFileTool(Tool):
    """Tool to edit a file by replacing text."""
-
-    def __init__(self, workspace: Path | None = None, allowed_dir: Path | None = None):
-        self._workspace = workspace
+    
+    def __init__(self, allowed_dir: Path | None = None):
        self._allowed_dir = allowed_dir

    @property
@@ -147,57 +137,34 @@ class EditFileTool(Tool):
    
    async def execute(self, path: str, old_text: str, new_text: str, **kwargs: Any) -> str:
        try:
-            file_path = _resolve_path(path, self._workspace, self._allowed_dir)
+            file_path = _resolve_path(path, self._allowed_dir)
            if not file_path.exists():
                return f"Error: File not found: {path}"
-
+            
            content = file_path.read_text(encoding="utf-8")
-
+            
            if old_text not in content:
-                return self._not_found_message(old_text, content, path)
-
+                return f"Error: old_text not found in file. Make sure it matches exactly."
+            
            # Count occurrences
            count = content.count(old_text)
            if count > 1:
                return f"Warning: old_text appears {count} times. Please provide more context to make it unique."
-
+            
            new_content = content.replace(old_text, new_text, 1)
            file_path.write_text(new_content, encoding="utf-8")
-
-            return f"Successfully edited {file_path}"
+            
+            return f"Successfully edited {path}"
        except PermissionError as e:
            return f"Error: {e}"
        except Exception as e:
            return f"Error editing file: {str(e)}"

-    @staticmethod
-    def _not_found_message(old_text: str, content: str, path: str) -> str:
-        """Build a helpful error when old_text is not found."""
-        lines = content.splitlines(keepends=True)
-        old_lines = old_text.splitlines(keepends=True)
-        window = len(old_lines)
-
-        best_ratio, best_start = 0.0, 0
-        for i in range(max(1, len(lines) - window + 1)):
-            ratio = difflib.SequenceMatcher(None, old_lines, lines[i : i + window]).ratio()
-            if ratio > best_ratio:
-                best_ratio, best_start = ratio, i
-
-        if best_ratio > 0.5:
-            diff = "\n".join(difflib.unified_diff(
-                old_lines, lines[best_start : best_start + window],
-                fromfile="old_text (provided)", tofile=f"{path} (actual, line {best_start + 1})",
-                lineterm="",
-            ))
-            return f"Error: old_text not found in {path}.\nBest match ({best_ratio:.0%} similar) at line {best_start + 1}:\n{diff}"
-        return f"Error: old_text not found in {path}. No similar text found. Verify the file content."
-

 class ListDirTool(Tool):
    """Tool to list directory contents."""
-
-    def __init__(self, workspace: Path | None = None, allowed_dir: Path | None = None):
-        self._workspace = workspace
+    
+    def __init__(self, allowed_dir: Path | None = None):
        self._allowed_dir = allowed_dir

    @property
@@ -223,20 +190,20 @@ class ListDirTool(Tool):
    
    async def execute(self, path: str, **kwargs: Any) -> str:
        try:
-            dir_path = _resolve_path(path, self._workspace, self._allowed_dir)
+            dir_path = _resolve_path(path, self._allowed_dir)
            if not dir_path.exists():
                return f"Error: Directory not found: {path}"
            if not dir_path.is_dir():
                return f"Error: Not a directory: {path}"
-
+            
            items = []
            for item in sorted(dir_path.iterdir()):
                prefix = "📁 " if item.is_dir() else "📄 "
                items.append(f"{prefix}{item.name}")
-
+            
            if not items:
                return f"Directory {path} is empty"
-
+            
            return "\n".join(items)
        except PermissionError as e:
            return f"Error: {e}"
@@ -1,99 +0,0 @@
-"""MCP client: connects to MCP servers and wraps their tools as native nanobot tools."""
-
-import asyncio
-from contextlib import AsyncExitStack
-from typing import Any
-
-import httpx
-from loguru import logger
-
-from nanobot.agent.tools.base import Tool
-from nanobot.agent.tools.registry import ToolRegistry
-
-
-class MCPToolWrapper(Tool):
-    """Wraps a single MCP server tool as a nanobot Tool."""
-
-    def __init__(self, session, server_name: str, tool_def, tool_timeout: int = 30):
-        self._session = session
-        self._original_name = tool_def.name
-        self._name = f"mcp_{server_name}_{tool_def.name}"
-        self._description = tool_def.description or tool_def.name
-        self._parameters = tool_def.inputSchema or {"type": "object", "properties": {}}
-        self._tool_timeout = tool_timeout
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def description(self) -> str:
-        return self._description
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return self._parameters
-
-    async def execute(self, **kwargs: Any) -> str:
-        from mcp import types
-        try:
-            result = await asyncio.wait_for(
-                self._session.call_tool(self._original_name, arguments=kwargs),
-                timeout=self._tool_timeout,
-            )
-        except asyncio.TimeoutError:
-            logger.warning("MCP tool '{}' timed out after {}s", self._name, self._tool_timeout)
-            return f"(MCP tool call timed out after {self._tool_timeout}s)"
-        parts = []
-        for block in result.content:
-            if isinstance(block, types.TextContent):
-                parts.append(block.text)
-            else:
-                parts.append(str(block))
-        return "\n".join(parts) or "(no output)"
-
-
-async def connect_mcp_servers(
-    mcp_servers: dict, registry: ToolRegistry, stack: AsyncExitStack
-) -> None:
-    """Connect to configured MCP servers and register their tools."""
-    from mcp import ClientSession, StdioServerParameters
-    from mcp.client.stdio import stdio_client
-
-    for name, cfg in mcp_servers.items():
-        try:
-            if cfg.command:
-                params = StdioServerParameters(
-                    command=cfg.command, args=cfg.args, env=cfg.env or None
-                )
-                read, write = await stack.enter_async_context(stdio_client(params))
-            elif cfg.url:
-                from mcp.client.streamable_http import streamable_http_client
-                # Always provide an explicit httpx client so MCP HTTP transport does not
-                # inherit httpx's default 5s timeout and preempt the higher-level tool timeout.
-                http_client = await stack.enter_async_context(
-                    httpx.AsyncClient(
-                        headers=cfg.headers or None,
-                        follow_redirects=True,
-                        timeout=None,
-                    )
-                )
-                read, write, _ = await stack.enter_async_context(
-                    streamable_http_client(cfg.url, http_client=http_client)
-                )
-            else:
-                logger.warning("MCP server '{}': no command or url configured, skipping", name)
-                continue
-
-            session = await stack.enter_async_context(ClientSession(read, write))
-            await session.initialize()
-
-            tools = await session.list_tools()
-            for tool_def in tools.tools:
-                wrapper = MCPToolWrapper(session, name, tool_def, tool_timeout=cfg.tool_timeout)
-                registry.register(wrapper)
-                logger.debug("MCP: registered tool '{}' from server '{}'", wrapper.name, name)
-
-            logger.info("MCP server '{}': connected, {} tools registered", name, len(tools.tools))
-        except Exception as e:
-            logger.error("MCP server '{}': failed to connect: {}", name, e)
@@ -1,230 +0,0 @@
-"""Mem0 memory tools — expose semantic memory to the agent."""
-
-from __future__ import annotations
-
-import json
-from typing import Any, TYPE_CHECKING
-
-from loguru import logger
-
-from nanobot.agent.tools.base import Tool
-
-if TYPE_CHECKING:
-    from nanobot.agent.memory_mem0 import Mem0MemoryStore
-
-
-class Mem0ToolContext:
-    """Shared mutable state injected into every mem0 tool."""
-
-    def __init__(self, store: Mem0MemoryStore, consolidate_fn):
-        self.store = store
-        self.consolidate_fn = consolidate_fn  # async (session, archive_all) -> None
-        self.user_id: str = "unknown"
-        self.session = None
-
-    def set_context(self, channel: str, chat_id: str, session=None):
-        self.user_id = f"{channel}_{chat_id}"
-        self.session = session
-
-
-class MemorySearchTool(Tool):
-    """Search memories semantically."""
-
-    name = "memory_search"
-    description = (
-        "Search your long-term memory for facts relevant to a query. "
-        "Returns the most relevant memories ranked by similarity."
-    )
-    parameters = {
-        "type": "object",
-        "properties": {
-            "query": {
-                "type": "string",
-                "description": "Natural-language search query",
-            },
-            "limit": {
-                "type": "integer",
-                "description": "Max results to return (default 5)",
-                "minimum": 1,
-                "maximum": 20,
-            },
-        },
-        "required": ["query"],
-    }
-
-    def __init__(self, ctx: Mem0ToolContext):
-        self._ctx = ctx
-
-    async def execute(self, query: str, limit: int = 5, **kw: Any) -> str:
-        results = self._ctx.store.search_memories(
-            query=query,
-            user_id=self._ctx.user_id,
-            limit=limit,
-        )
-        if not results:
-            return "No memories found."
-        lines = []
-        for i, mem in enumerate(results, 1):
-            text = mem.get("memory", "")
-            score = mem.get("score")
-            mid = mem.get("id", "")
-            score_str = f"  (score: {score:.2f})" if score else ""
-            lines.append(f"{i}. [{mid}] {text}{score_str}")
-        return "\n".join(lines)
-
-
-class MemoryListTool(Tool):
-    """List all memories for the current user."""
-
-    name = "memory_list"
-    description = (
-        "List ALL stored memories for the current user. "
-        "Use memory_search for targeted lookup; use this to browse everything."
-    )
-    parameters = {
-        "type": "object",
-        "properties": {},
-    }
-
-    def __init__(self, ctx: Mem0ToolContext):
-        self._ctx = ctx
-
-    async def execute(self, **kw: Any) -> str:
-        memories = self._ctx.store.get_all_memories(self._ctx.user_id)
-        if not memories:
-            return "No memories stored."
-        lines = []
-        for i, mem in enumerate(memories, 1):
-            text = mem.get("memory", "")
-            mid = mem.get("id", "")
-            lines.append(f"{i}. [{mid}] {text}")
-        return f"{len(memories)} memories:\n" + "\n".join(lines)
-
-
-class MemoryAddTool(Tool):
-    """Add a fact to long-term memory."""
-
-    name = "memory_add"
-    description = (
-        "Store a new fact or piece of information in long-term memory. "
-        "The content will be processed by the extraction LLM and stored as one or more facts."
-    )
-    parameters = {
-        "type": "object",
-        "properties": {
-            "content": {
-                "type": "string",
-                "description": "The fact or information to remember",
-            },
-        },
-        "required": ["content"],
-    }
-
-    def __init__(self, ctx: Mem0ToolContext):
-        self._ctx = ctx
-
-    async def execute(self, content: str, **kw: Any) -> str:
-        try:
-            result = self._ctx.store.memory.add(
-                [{"role": "user", "content": content}],
-                user_id=self._ctx.user_id,
-            )
-            facts_count = len(result.get("results", [])) if result else 0
-            return f"Added to memory. {facts_count} fact(s) extracted."
-        except Exception as e:
-            logger.error(f"memory_add failed: {e}")
-            return f"Error adding memory: {e}"
-
-
-class MemoryUpdateTool(Tool):
-    """Update an existing memory by ID."""
-
-    name = "memory_update"
-    description = (
-        "Update the content of an existing memory. "
-        "Use memory_list or memory_search first to find the memory ID."
-    )
-    parameters = {
-        "type": "object",
-        "properties": {
-            "memory_id": {
-                "type": "string",
-                "description": "The memory ID to update",
-            },
-            "content": {
-                "type": "string",
-                "description": "The new content for this memory",
-            },
-        },
-        "required": ["memory_id", "content"],
-    }
-
-    def __init__(self, ctx: Mem0ToolContext):
-        self._ctx = ctx
-
-    async def execute(self, memory_id: str, content: str, **kw: Any) -> str:
-        try:
-            self._ctx.store.update_memory(memory_id, content)
-            return f"Memory {memory_id} updated."
-        except Exception as e:
-            logger.error(f"memory_update failed: {e}")
-            return f"Error updating memory: {e}"
-
-
-class MemoryDeleteTool(Tool):
-    """Delete a memory by ID."""
-
-    name = "memory_delete"
-    description = (
-        "Delete a specific memory by its ID. "
-        "Use memory_list or memory_search first to find the memory ID."
-    )
-    parameters = {
-        "type": "object",
-        "properties": {
-            "memory_id": {
-                "type": "string",
-                "description": "The memory ID to delete",
-            },
-        },
-        "required": ["memory_id"],
-    }
-
-    def __init__(self, ctx: Mem0ToolContext):
-        self._ctx = ctx
-
-    async def execute(self, memory_id: str, **kw: Any) -> str:
-        try:
-            self._ctx.store.delete_memory(memory_id)
-            return f"Memory {memory_id} deleted."
-        except Exception as e:
-            logger.error(f"memory_delete failed: {e}")
-            return f"Error deleting memory: {e}"
-
-
-class MemoryConsolidateTool(Tool):
-    """Trigger memory consolidation for the current session."""
-
-    name = "memory_consolidate"
-    description = (
-        "Extract and store facts from the current conversation into long-term memory. "
-        "Normally this happens automatically on /new, but you can trigger it manually."
-    )
-    parameters = {
-        "type": "object",
-        "properties": {},
-    }
-
-    def __init__(self, ctx: Mem0ToolContext):
-        self._ctx = ctx
-
-    async def execute(self, **kw: Any) -> str:
-        session = self._ctx.session
-        if not session:
-            return "Error: no active session."
-        try:
-            await self._ctx.consolidate_fn(session, archive_all=False)
-            return "Memory consolidation complete."
-        except Exception as e:
-            logger.error(f"memory_consolidate failed: {e}")
-            return f"Error during consolidation: {e}"
@@ -21,7 +21,6 @@ class MessageTool(Tool):
        self._sessions = sessions
        self._default_channel = default_channel
        self._default_chat_id = default_chat_id
-        self._sent_in_turn: bool = False
    
    def set_context(self, channel: str, chat_id: str) -> None:
        """Set the current message context."""
@@ -31,10 +30,6 @@ class MessageTool(Tool):
    def set_send_callback(self, callback: Callable[[OutboundMessage], Awaitable[None]]) -> None:
        """Set the callback for sending messages."""
        self._send_callback = callback
-
-    def start_turn(self) -> None:
-        """Reset per-turn send tracking."""
-        self._sent_in_turn = False
    
    @property
    def name(self) -> str:
@@ -53,11 +48,6 @@ class MessageTool(Tool):
                    "type": "string",
                    "description": "The message content to send"
                },
-                "media": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "description": "Optional: list of media file paths or URLs to attach"
-                },
                "channel": {
                    "type": "string",
                    "description": "Optional: target channel (telegram, discord, etc.)"
@@ -71,36 +61,30 @@ class MessageTool(Tool):
        }
    
    async def execute(
-        self,
-        content: str,
-        media: list[str] | None = None,
-        channel: str | None = None,
+        self, 
+        content: str, 
+        channel: str | None = None, 
        chat_id: str | None = None,
        **kwargs: Any
    ) -> str:
        channel = channel or self._default_channel
        chat_id = chat_id or self._default_chat_id
-
+        
        if not channel or not chat_id:
            return "Error: No target channel/chat specified"
-
+        
        if not self._send_callback:
            return "Error: Message sending not configured"
-
+        
        msg = OutboundMessage(
            channel=channel,
            chat_id=chat_id,
-            content=content,
-            media=media or []
+            content=content
        )
        
        try:
            await self._send_callback(msg)

-            # Track if sent to same target as current context
-            if channel == self._default_channel and chat_id == self._default_chat_id:
-                self._sent_in_turn = True
-
            if self._sessions:
                session_key = f"{channel}:{chat_id}"
                session = self._sessions.get_or_create(session_key)
@@ -32,33 +32,20 @@ class ToolRegistry:
        return name in self._tools
    
    def get_definitions(self) -> list[dict[str, Any]]:
-        """Get tool definitions for all registered tools.
-
-        Supports both function tools (with to_schema) and native tools (with to_params).
-        """
-        definitions = []
-        for tool in self._tools.values():
-            if hasattr(tool, 'to_params'):  # Native Anthropic tool
-                definitions.append(tool.to_params())
-            elif hasattr(tool, 'to_schema'):  # Function tool
-                definitions.append(tool.to_schema())
-            else:
-                raise ValueError(f"Tool {tool.name} has no schema method (to_params or to_schema)")
-        return definitions
+        """Get all tool definitions in OpenAI format."""
+        return [tool.to_schema() for tool in self._tools.values()]
    
-    async def execute(self, name: str, params: dict[str, Any]) -> Any:
+    async def execute(self, name: str, params: dict[str, Any]) -> str:
        """
        Execute a tool by name with given parameters.
-
-        Supports both native Anthropic tools (via __call__) and function tools (via execute).
-
+        
        Args:
            name: Tool name.
            params: Tool parameters.
-
+        
        Returns:
-            Tool execution result (ToolResult, CLIResult, or string).
-
+            Tool execution result as string.
+        
        Raises:
            KeyError: If tool not found.
        """
@@ -67,33 +54,20 @@ class ToolRegistry:
            return f"Error: Tool '{name}' not found"

        try:
-            # Duck typing - support both native and function tools
-            if hasattr(tool, 'to_params'):
-                # Native Anthropic tool - call directly via __call__, no validation needed
-                return await tool(**params)
-            else:
-                # Legacy function tool - validate then execute
-                errors = tool.validate_params(params)
-                if errors:
-                    return f"Error: Invalid parameters for tool '{name}': " + "; ".join(errors)
-                return await tool.execute(**params)
+            errors = tool.validate_params(params)
+            if errors:
+                return f"Error: Invalid parameters for tool '{name}': " + "; ".join(errors)
+            return await tool.execute(**params)
        except Exception as e:
            return f"Error executing {name}: {str(e)}"
    
-    def get_tools(self) -> list[Any]:
-        """Get list of tool objects (not definitions).
-
-        Returns tool objects which can be inspected for metadata like beta_flag.
-        """
-        return list(self._tools.values())
-
    @property
    def tool_names(self) -> list[str]:
        """Get list of registered tool names."""
        return list(self._tools.keys())
-
+    
    def __len__(self) -> int:
        return len(self._tools)
-
+    
    def __contains__(self, name: str) -> bool:
        return name in self._tools
@@ -19,7 +19,6 @@ class ExecTool(Tool):
        deny_patterns: list[str] | None = None,
        allow_patterns: list[str] | None = None,
        restrict_to_workspace: bool = False,
-        path_append: str = "",
    ):
        self.timeout = timeout
        self.working_dir = working_dir
@@ -27,8 +26,7 @@ class ExecTool(Tool):
            r"\brm\s+-[rf]{1,2}\b",          # rm -r, rm -rf, rm -fr
            r"\bdel\s+/[fq]\b",              # del /f, del /q
            r"\brmdir\s+/s\b",               # rmdir /s
-            r"(?:^|[;&|]\s*)format\b",       # format (as standalone command only)
-            r"\b(mkfs|diskpart)\b",          # disk operations
+            r"\b(format|mkfs|diskpart)\b",   # disk operations
            r"\bdd\s+if=",                   # dd
            r">\s*/dev/sd",                  # write to disk
            r"\b(shutdown|reboot|poweroff)\b",  # system power
@@ -36,7 +34,6 @@ class ExecTool(Tool):
        ]
        self.allow_patterns = allow_patterns or []
        self.restrict_to_workspace = restrict_to_workspace
-        self.path_append = path_append
    
    @property
    def name(self) -> str:
@@ -69,17 +66,12 @@ class ExecTool(Tool):
        if guard_error:
            return guard_error
        
-        env = os.environ.copy()
-        if self.path_append:
-            env["PATH"] = env.get("PATH", "") + os.pathsep + self.path_append
-
        try:
            process = await asyncio.create_subprocess_shell(
                command,
                stdout=asyncio.subprocess.PIPE,
                stderr=asyncio.subprocess.PIPE,
                cwd=cwd,
-                env=env,
            )
            
            try:
@@ -89,12 +81,6 @@ class ExecTool(Tool):
                )
            except asyncio.TimeoutError:
                process.kill()
-                # Wait for the process to fully terminate so pipes are
-                # drained and file descriptors are released.
-                try:
-                    await asyncio.wait_for(process.wait(), timeout=5.0)
-                except asyncio.TimeoutError:
-                    pass
                return f"Error: Command timed out after {self.timeout} seconds"
            
            output_parts = []
@@ -20,13 +20,11 @@ class SpawnTool(Tool):
        self._manager = manager
        self._origin_channel = "cli"
        self._origin_chat_id = "direct"
-        self._origin_metadata: dict[str, Any] = {}
-
-    def set_context(self, channel: str, chat_id: str, metadata: dict[str, Any] | None = None) -> None:
+    
+    def set_context(self, channel: str, chat_id: str) -> None:
        """Set the origin context for subagent announcements."""
        self._origin_channel = channel
        self._origin_chat_id = chat_id
-        self._origin_metadata = metadata or {}
    
    @property
    def name(self) -> str:
@@ -69,5 +67,4 @@ class SpawnTool(Tool):
            model=model,
            origin_channel=self._origin_channel,
            origin_chat_id=self._origin_chat_id,
-            origin_metadata=self._origin_metadata,
        )
@@ -1,72 +0,0 @@
-"""Message tool for subagents to communicate with the main agent."""
-
-from typing import Any, TYPE_CHECKING
-
-from nanobot.agent.tools.base import Tool
-from nanobot.bus.events import InboundMessage
-
-if TYPE_CHECKING:
-    from nanobot.bus.queue import MessageBus
-
-
-class SubagentMessageTool(Tool):
-    """
-    Tool for subagents to send messages to the main agent.
-
-    Messages are sent via the bus and preserve metadata (e.g. suppress_output)
-    from the originating message that spawned the subagent.
-    """
-
-    def __init__(
-        self,
-        bus: "MessageBus",
-        origin_channel: str,
-        origin_chat_id: str,
-        origin_metadata: dict[str, Any] | None = None,
-    ):
-        self._bus = bus
-        self._origin_channel = origin_channel
-        self._origin_chat_id = origin_chat_id
-        self._origin_metadata = origin_metadata or {}
-
-    @property
-    def name(self) -> str:
-        return "message"
-
-    @property
-    def description(self) -> str:
-        return (
-            "Send a message to the main agent. "
-            "Use this to communicate findings, request clarification, or provide updates. "
-            "The main agent will process your message and decide how to respond."
-        )
-
-    @property
-    def parameters(self) -> dict[str, Any]:
-        return {
-            "type": "object",
-            "properties": {
-                "content": {
-                    "type": "string",
-                    "description": "The message content to send to the main agent"
-                },
-            },
-            "required": ["content"]
-        }
-
-    async def execute(self, content: str, **kwargs: Any) -> str:
-        """Send a message to the main agent via the bus."""
-        # Create InboundMessage to trigger main agent
-        msg = InboundMessage(
-            channel="system",
-            sender_id="subagent",
-            chat_id=f"{self._origin_channel}:{self._origin_chat_id}",
-            content=f"[Subagent message]\n\n{content}",
-            metadata=self._origin_metadata,
-        )
-
-        try:
-            await self._bus.publish_inbound(msg)
-            return "Message sent to main agent"
-        except Exception as e:
-            return f"Error sending message: {str(e)}"
@@ -58,21 +58,12 @@ class WebSearchTool(Tool):
    }
    
    def __init__(self, api_key: str | None = None, max_results: int = 5):
-        self._init_api_key = api_key
+        self.api_key = api_key or os.environ.get("BRAVE_API_KEY", "")
        self.max_results = max_results
-
-    @property
-    def api_key(self) -> str:
-        """Resolve API key at call time so env/config changes are picked up."""
-        return self._init_api_key or os.environ.get("BRAVE_API_KEY", "")
-
+    
    async def execute(self, query: str, count: int | None = None, **kwargs: Any) -> str:
        if not self.api_key:
-            return (
-                "Error: Brave Search API key not configured. "
-                "Set it in ~/.nanobot/config.json under tools.web.search.apiKey "
-                "(or export BRAVE_API_KEY), then restart the gateway."
-            )
+            return "Error: BRAVE_API_KEY not configured"
        
        try:
            n = min(max(count or self.max_results, 1), 10)
@@ -125,7 +116,7 @@ class WebFetchTool(Tool):
        # Validate URL before fetching
        is_valid, error_msg = _validate_url(url)
        if not is_valid:
-            return json.dumps({"error": f"URL validation failed: {error_msg}", "url": url}, ensure_ascii=False)
+            return json.dumps({"error": f"URL validation failed: {error_msg}", "url": url})

        try:
            async with httpx.AsyncClient(
@@ -140,7 +131,7 @@ class WebFetchTool(Tool):
            
            # JSON
            if "application/json" in ctype:
-                text, extractor = json.dumps(r.json(), indent=2, ensure_ascii=False), "json"
+                text, extractor = json.dumps(r.json(), indent=2), "json"
            # HTML
            elif "text/html" in ctype or r.text[:256].lower().startswith(("<!doctype", "<html")):
                doc = Document(r.text)
@@ -155,9 +146,9 @@ class WebFetchTool(Tool):
                text = text[:max_chars]
            
            return json.dumps({"url": url, "finalUrl": str(r.url), "status": r.status_code,
-                              "extractor": extractor, "truncated": truncated, "length": len(text), "text": text}, ensure_ascii=False)
+                              "extractor": extractor, "truncated": truncated, "length": len(text), "text": text})
        except Exception as e:
-            return json.dumps({"error": str(e), "url": url}, ensure_ascii=False)
+            return json.dumps({"error": str(e), "url": url})
    
    def _to_markdown(self, html: str) -> str:
        """Convert HTML to markdown."""
@@ -1,82 +0,0 @@
-# nanobot/agent/visibility.py
-"""Cryptographic signing for visibility markers to prevent model forgery."""
-
-import hmac
-import hashlib
-import re
-
-SECRET_KEY = "nanobot_visibility_secret_key_v1"
-
-
-def compute_signature(content: str) -> str:
-    """Compute HMAC signature for content (hex string, no prefix)."""
-    return hmac.new(
-        SECRET_KEY.encode(),
-        content.encode(),
-        hashlib.sha256
-    ).hexdigest()[:8]
-
-
-def sign_content(content: str) -> str:
-    """
-    Sign content with HMAC and prepend marker.
-
-    Args:
-        content: The message content to sign
-
-    Returns:
-        Content with signed visibility marker: "[HIDDEN:{sig}] {content}"
-    """
-    sig = compute_signature(content)
-    return f"[HIDDEN:{sig}] {content}"
-
-
-def verify_signature(marked_content: str) -> tuple[bool, str]:
-    """
-    Verify HMAC signature and extract clean content.
-
-    Args:
-        marked_content: Content potentially with [HIDDEN:{sig}] marker
-
-    Returns:
-        Tuple of (is_valid, clean_content)
-        - is_valid: True if signature is valid, False otherwise
-        - clean_content: Content without marker
-    """
-    match = re.match(r'\[HIDDEN:([a-f0-9]{8})\] (.*)', marked_content, re.DOTALL)
-    if not match:
-        return False, marked_content
-
-    claimed_sig, content = match.groups()
-    expected_sig = compute_signature(content)
-    is_valid = hmac.compare_digest(claimed_sig, expected_sig)
-    return is_valid, content
-
-
-def has_forged_marker(content: str) -> bool:
-    """
-    Check if content has an invalid [HIDDEN:*] marker at the start.
-
-    Args:
-        content: Content to check
-
-    Returns:
-        True if content starts with forged marker, False otherwise
-    """
-    if not content.startswith("[HIDDEN:"):
-        return False
-    is_valid, _ = verify_signature(content)
-    return not is_valid
-
-
-def strip_all_hidden_markers(content: str) -> str:
-    """
-    Remove all [HIDDEN:*] patterns from content (valid or invalid).
-
-    Args:
-        content: Content potentially with markers
-
-    Returns:
-        Content with all markers stripped
-    """
-    return re.sub(r'\[HIDDEN:[a-f0-9]{8}\]\s*', '', content)
@@ -16,12 +16,11 @@ class InboundMessage:
    timestamp: datetime = field(default_factory=datetime.now)
    media: list[str] = field(default_factory=list)  # Media URLs
    metadata: dict[str, Any] = field(default_factory=dict)  # Channel-specific data
-    session_key_override: str | None = None  # Optional override for thread-scoped sessions
    
    @property
    def session_key(self) -> str:
        """Unique key for session identification."""
-        return self.session_key_override or f"{self.channel}:{self.chat_id}"
+        return f"{self.channel}:{self.chat_id}"


@dataclass
@@ -1,7 +1,9 @@
 """Async message queue for decoupled channel-agent communication."""

 import asyncio
-from typing import Awaitable, Callable
+from typing import Callable, Awaitable
+
+from loguru import logger

 from nanobot.bus.events import InboundMessage, OutboundMessage

@@ -9,55 +11,33 @@ from nanobot.bus.events import InboundMessage, OutboundMessage
 class MessageBus:
    """
    Async message bus that decouples chat channels from the agent core.
-
+    
    Channels push messages to the inbound queue, and the agent processes
    them and pushes responses to the outbound queue.
    """
-
+    
    def __init__(self):
        self.inbound: asyncio.Queue[InboundMessage] = asyncio.Queue()
        self.outbound: asyncio.Queue[OutboundMessage] = asyncio.Queue()
        self._outbound_subscribers: dict[str, list[Callable[[OutboundMessage], Awaitable[None]]]] = {}
-        self._correlation_store: dict[str, asyncio.Future] = {}
        self._running = False
-
+    
    async def publish_inbound(self, msg: InboundMessage) -> None:
        """Publish a message from a channel to the agent."""
        await self.inbound.put(msg)
-
+    
    async def consume_inbound(self) -> InboundMessage:
        """Consume the next inbound message (blocks until available)."""
        return await self.inbound.get()
-
+    
    async def publish_outbound(self, msg: OutboundMessage) -> None:
        """Publish a response from the agent to channels."""
        await self.outbound.put(msg)
-
+    
    async def consume_outbound(self) -> OutboundMessage:
        """Consume the next outbound message (blocks until available)."""
        return await self.outbound.get()
-
-    def register_correlation(self, correlation_id: str) -> asyncio.Future:
-        """Register a Future to be resolved when a matching outbound message appears."""
-        loop = asyncio.get_running_loop()
-        future = loop.create_future()
-        self._correlation_store[correlation_id] = future
-        return future
-
-    def resolve_correlation(self, msg: OutboundMessage) -> None:
-        """Check if an outbound message has a correlation_id and resolve the matching Future."""
-        cid = msg.metadata.get("correlation_id") if msg.metadata else None
-        if cid and cid in self._correlation_store:
-            future = self._correlation_store.pop(cid)
-            if not future.done():
-                future.set_result(msg.content)
-
-    def cancel_correlation(self, correlation_id: str) -> None:
-        """Cancel and remove a pending correlation."""
-        future = self._correlation_store.pop(correlation_id, None)
-        if future and not future.done():
-            future.cancel()
-
+    
    def subscribe_outbound(
        self, 
        channel: str, 
@@ -89,12 +69,12 @@ class MessageBus:
    def stop(self) -> None:
        """Stop the dispatcher loop."""
        self._running = False
-
+    
    @property
    def inbound_size(self) -> int:
        """Number of pending inbound messages."""
        return self.inbound.qsize()
-
+    
    @property
    def outbound_size(self) -> int:
        """Number of pending outbound messages."""
@@ -93,8 +93,7 @@ class BaseChannel(ABC):
        chat_id: str,
        content: str,
        media: list[str] | None = None,
-        metadata: dict[str, Any] | None = None,
-        session_key: str | None = None,
+        metadata: dict[str, Any] | None = None
    ) -> None:
        """
        Handle an incoming message from the chat platform.
@@ -107,13 +106,11 @@ class BaseChannel(ABC):
            content: Message text content.
            media: Optional list of media URLs.
            metadata: Optional channel-specific metadata.
-            session_key: Optional session key override (e.g. thread-scoped sessions).
        """
        if not self.is_allowed(sender_id):
            logger.warning(
-                "Access denied for sender {} on channel {}. "
-                "Add them to allowFrom list in config to grant access.",
-                sender_id, self.name,
+                f"Access denied for sender {sender_id} on channel {self.name}. "
+                f"Add them to allowFrom list in config to grant access."
            )
            return
        
@@ -123,8 +120,7 @@ class BaseChannel(ABC):
            chat_id=str(chat_id),
            content=content,
            media=media or [],
-            metadata=metadata or {},
-            session_key_override=session_key,
+            metadata=metadata or {}
        )
        
        await self.bus.publish_inbound(msg)
@@ -58,15 +58,14 @@ class NanobotDingTalkHandler(CallbackHandler):

            if not content:
                logger.warning(
-                    "Received empty or unsupported message type: {}",
-                    chatbot_msg.message_type,
+                    f"Received empty or unsupported message type: {chatbot_msg.message_type}"
                )
                return AckMessage.STATUS_OK, "OK"

            sender_id = chatbot_msg.sender_staff_id or chatbot_msg.sender_id
            sender_name = chatbot_msg.sender_nick or "Unknown"

-            logger.info("Received DingTalk message from {} ({}): {}", sender_name, sender_id, content)
+            logger.info(f"Received DingTalk message from {sender_name} ({sender_id}): {content}")

            # Forward to Nanobot via _on_message (non-blocking).
            # Store reference to prevent GC before task completes.
@@ -79,7 +78,7 @@ class NanobotDingTalkHandler(CallbackHandler):
            return AckMessage.STATUS_OK, "OK"

        except Exception as e:
-            logger.error("Error processing DingTalk message: {}", e)
+            logger.error(f"Error processing DingTalk message: {e}")
            # Return OK to avoid retry loop from DingTalk server
            return AckMessage.STATUS_OK, "Error"

@@ -127,8 +126,7 @@ class DingTalkChannel(BaseChannel):
            self._http = httpx.AsyncClient()

            logger.info(
-                "Initializing DingTalk Stream Client with Client ID: {}...",
-                self.config.client_id,
+                f"Initializing DingTalk Stream Client with Client ID: {self.config.client_id}..."
            )
            credential = Credential(self.config.client_id, self.config.client_secret)
            self._client = DingTalkStreamClient(credential)
@@ -144,13 +142,13 @@ class DingTalkChannel(BaseChannel):
                try:
                    await self._client.start()
                except Exception as e:
-                    logger.warning("DingTalk stream error: {}", e)
+                    logger.warning(f"DingTalk stream error: {e}")
                if self._running:
                    logger.info("Reconnecting DingTalk stream in 5 seconds...")
                    await asyncio.sleep(5)

        except Exception as e:
-            logger.exception("Failed to start DingTalk channel: {}", e)
+            logger.exception(f"Failed to start DingTalk channel: {e}")

    async def stop(self) -> None:
        """Stop the DingTalk bot."""
@@ -188,7 +186,7 @@ class DingTalkChannel(BaseChannel):
            self._token_expiry = time.time() + int(res_data.get("expireIn", 7200)) - 60
            return self._access_token
        except Exception as e:
-            logger.error("Failed to get DingTalk access token: {}", e)
+            logger.error(f"Failed to get DingTalk access token: {e}")
            return None

    async def send(self, msg: OutboundMessage) -> None:
@@ -210,7 +208,7 @@ class DingTalkChannel(BaseChannel):
            "msgParam": json.dumps({
                "text": msg.content,
                "title": "Nanobot Reply",
-            }, ensure_ascii=False),
+            }),
        }

        if not self._http:
@@ -220,11 +218,11 @@ class DingTalkChannel(BaseChannel):
        try:
            resp = await self._http.post(url, json=data, headers=headers)
            if resp.status_code != 200:
-                logger.error("DingTalk send failed: {}", resp.text)
+                logger.error(f"DingTalk send failed: {resp.text}")
            else:
-                logger.debug("DingTalk message sent to {}", msg.chat_id)
+                logger.debug(f"DingTalk message sent to {msg.chat_id}")
        except Exception as e:
-            logger.error("Error sending DingTalk message: {}", e)
+            logger.error(f"Error sending DingTalk message: {e}")

    async def _on_message(self, content: str, sender_id: str, sender_name: str) -> None:
        """Handle incoming message (called by NanobotDingTalkHandler).
@@ -233,7 +231,7 @@ class DingTalkChannel(BaseChannel):
        permission checks before publishing to the bus.
        """
        try:
-            logger.info("DingTalk inbound: {} from {}", content, sender_name)
+            logger.info(f"DingTalk inbound: {content} from {sender_name}")
            await self._handle_message(
                sender_id=sender_id,
                chat_id=sender_id,  # For private chat, chat_id == sender_id
@@ -244,4 +242,4 @@ class DingTalkChannel(BaseChannel):
                },
            )
        except Exception as e:
-            logger.error("Error publishing DingTalk message: {}", e)
+            logger.error(f"Error publishing DingTalk message: {e}")
@@ -17,29 +17,6 @@ from nanobot.config.schema import DiscordConfig

 DISCORD_API_BASE = "https://discord.com/api/v10"
 MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024  # 20MB
-MAX_MESSAGE_LEN = 2000  # Discord message character limit
-
-
-def _split_message(content: str, max_len: int = MAX_MESSAGE_LEN) -> list[str]:
-    """Split content into chunks within max_len, preferring line breaks."""
-    if not content:
-        return []
-    if len(content) <= max_len:
-        return [content]
-    chunks: list[str] = []
-    while content:
-        if len(content) <= max_len:
-            chunks.append(content)
-            break
-        cut = content[:max_len]
-        pos = cut.rfind('\n')
-        if pos <= 0:
-            pos = cut.rfind(' ')
-        if pos <= 0:
-            pos = max_len
-        chunks.append(content[:pos])
-        content = content[pos:].lstrip()
-    return chunks


 class DiscordChannel(BaseChannel):
@@ -74,7 +51,7 @@ class DiscordChannel(BaseChannel):
            except asyncio.CancelledError:
                break
            except Exception as e:
-                logger.warning("Discord gateway error: {}", e)
+                logger.warning(f"Discord gateway error: {e}")
                if self._running:
                    logger.info("Reconnecting to Discord gateway in 5 seconds...")
                    await asyncio.sleep(5)
@@ -102,48 +79,34 @@ class DiscordChannel(BaseChannel):
            return

        url = f"{DISCORD_API_BASE}/channels/{msg.chat_id}/messages"
+        payload: dict[str, Any] = {"content": msg.content}
+
+        if msg.reply_to:
+            payload["message_reference"] = {"message_id": msg.reply_to}
+            payload["allowed_mentions"] = {"replied_user": False}
+
        headers = {"Authorization": f"Bot {self.config.token}"}

        try:
-            chunks = _split_message(msg.content or "")
-            if not chunks:
-                return
-
-            for i, chunk in enumerate(chunks):
-                payload: dict[str, Any] = {"content": chunk}
-
-                # Only set reply reference on the first chunk
-                if i == 0 and msg.reply_to:
-                    payload["message_reference"] = {"message_id": msg.reply_to}
-                    payload["allowed_mentions"] = {"replied_user": False}
-
-                if not await self._send_payload(url, headers, payload):
-                    break  # Abort remaining chunks on failure
+            for attempt in range(3):
+                try:
+                    response = await self._http.post(url, headers=headers, json=payload)
+                    if response.status_code == 429:
+                        data = response.json()
+                        retry_after = float(data.get("retry_after", 1.0))
+                        logger.warning(f"Discord rate limited, retrying in {retry_after}s")
+                        await asyncio.sleep(retry_after)
+                        continue
+                    response.raise_for_status()
+                    return
+                except Exception as e:
+                    if attempt == 2:
+                        logger.error(f"Error sending Discord message: {e}")
+                    else:
+                        await asyncio.sleep(1)
        finally:
            await self._stop_typing(msg.chat_id)

-    async def _send_payload(
-        self, url: str, headers: dict[str, str], payload: dict[str, Any]
-    ) -> bool:
-        """Send a single Discord API payload with retry on rate-limit. Returns True on success."""
-        for attempt in range(3):
-            try:
-                response = await self._http.post(url, headers=headers, json=payload)
-                if response.status_code == 429:
-                    data = response.json()
-                    retry_after = float(data.get("retry_after", 1.0))
-                    logger.warning("Discord rate limited, retrying in {}s", retry_after)
-                    await asyncio.sleep(retry_after)
-                    continue
-                response.raise_for_status()
-                return True
-            except Exception as e:
-                if attempt == 2:
-                    logger.error("Error sending Discord message: {}", e)
-                else:
-                    await asyncio.sleep(1)
-        return False
-
    async def _gateway_loop(self) -> None:
        """Main gateway loop: identify, heartbeat, dispatch events."""
        if not self._ws:
@@ -153,7 +116,7 @@ class DiscordChannel(BaseChannel):
            try:
                data = json.loads(raw)
            except json.JSONDecodeError:
-                logger.warning("Invalid JSON from Discord gateway: {}", raw[:100])
+                logger.warning(f"Invalid JSON from Discord gateway: {raw[:100]}")
                continue

            op = data.get("op")
@@ -212,7 +175,7 @@ class DiscordChannel(BaseChannel):
                try:
                    await self._ws.send(json.dumps(payload))
                except Exception as e:
-                    logger.warning("Discord heartbeat failed: {}", e)
+                    logger.warning(f"Discord heartbeat failed: {e}")
                    break
                await asyncio.sleep(interval_s)

@@ -256,7 +219,7 @@ class DiscordChannel(BaseChannel):
                media_paths.append(str(file_path))
                content_parts.append(f"[attachment: {file_path}]")
            except Exception as e:
-                logger.warning("Failed to download Discord attachment: {}", e)
+                logger.warning(f"Failed to download Discord attachment: {e}")
                content_parts.append(f"[attachment: {filename} - download failed]")

        reply_to = (payload.get("referenced_message") or {}).get("id")
@@ -285,11 +248,8 @@ class DiscordChannel(BaseChannel):
            while self._running:
                try:
                    await self._http.post(url, headers=headers)
-                except asyncio.CancelledError:
-                    return
-                except Exception as e:
-                    logger.debug("Discord typing indicator failed for {}: {}", channel_id, e)
-                    return
+                except Exception:
+                    pass
                await asyncio.sleep(8)

        self._typing_tasks[channel_id] = asyncio.create_task(typing_loop())
@@ -94,7 +94,7 @@ class EmailChannel(BaseChannel):
                        metadata=item.get("metadata", {}),
                    )
            except Exception as e:
-                logger.error("Email polling error: {}", e)
+                logger.error(f"Email polling error: {e}")

            await asyncio.sleep(poll_seconds)

@@ -108,6 +108,11 @@ class EmailChannel(BaseChannel):
            logger.warning("Skip email send: consent_granted is false")
            return

+        force_send = bool((msg.metadata or {}).get("force_send"))
+        if not self.config.auto_reply_enabled and not force_send:
+            logger.info("Skip automatic email reply: auto_reply_enabled is false")
+            return
+
        if not self.config.smtp_host:
            logger.warning("Email channel SMTP host not configured")
            return
@@ -117,15 +122,6 @@ class EmailChannel(BaseChannel):
            logger.warning("Email channel missing recipient address")
            return

-        # Determine if this is a reply (recipient has sent us an email before)
-        is_reply = to_addr in self._last_subject_by_chat
-        force_send = bool((msg.metadata or {}).get("force_send"))
-
-        # autoReplyEnabled only controls automatic replies, not proactive sends
-        if is_reply and not self.config.auto_reply_enabled and not force_send:
-            logger.info("Skip automatic email reply to {}: auto_reply_enabled is false", to_addr)
-            return
-
        base_subject = self._last_subject_by_chat.get(to_addr, "nanobot reply")
        subject = self._reply_subject(base_subject)
        if msg.metadata and isinstance(msg.metadata.get("subject"), str):
@@ -147,7 +143,7 @@ class EmailChannel(BaseChannel):
        try:
            await asyncio.to_thread(self._smtp_send, email_msg)
        except Exception as e:
-            logger.error("Error sending email to {}: {}", to_addr, e)
+            logger.error(f"Error sending email to {to_addr}: {e}")
            raise

    def _validate_config(self) -> bool:
@@ -166,7 +162,7 @@ class EmailChannel(BaseChannel):
            missing.append("smtp_password")

        if missing:
-            logger.error("Email channel not configured, missing: {}", ', '.join(missing))
+            logger.error(f"Email channel not configured, missing: {', '.join(missing)}")
            return False
        return True

@@ -308,8 +304,7 @@ class EmailChannel(BaseChannel):
                    self._processed_uids.add(uid)
                    # mark_seen is the primary dedup; this set is a safety net
                    if len(self._processed_uids) > self._MAX_PROCESSED_UIDS:
-                        # Evict a random half to cap memory; mark_seen is the primary dedup
-                        self._processed_uids = set(list(self._processed_uids)[len(self._processed_uids) // 2:])
+                        self._processed_uids.clear()

                if mark_seen:
                    client.store(imap_id, "+FLAGS", "\\Seen")
@@ -2,11 +2,9 @@

 import asyncio
 import json
-import os
 import re
 import threading
 from collections import OrderedDict
-from pathlib import Path
 from typing import Any

 from loguru import logger
@@ -19,17 +17,11 @@ from nanobot.config.schema import FeishuConfig
 try:
    import lark_oapi as lark
    from lark_oapi.api.im.v1 import (
-        CreateFileRequest,
-        CreateFileRequestBody,
-        CreateImageRequest,
-        CreateImageRequestBody,
        CreateMessageRequest,
        CreateMessageRequestBody,
        CreateMessageReactionRequest,
        CreateMessageReactionRequestBody,
        Emoji,
-        GetFileRequest,
-        GetMessageResourceRequest,
        P2ImMessageReceiveV1,
    )
    FEISHU_AVAILABLE = True
@@ -47,204 +39,6 @@ MSG_TYPE_MAP = {
 }


-def _extract_share_card_content(content_json: dict, msg_type: str) -> str:
-    """Extract text representation from share cards and interactive messages."""
-    parts = []
-
-    if msg_type == "share_chat":
-        parts.append(f"[shared chat: {content_json.get('chat_id', '')}]")
-    elif msg_type == "share_user":
-        parts.append(f"[shared user: {content_json.get('user_id', '')}]")
-    elif msg_type == "interactive":
-        parts.extend(_extract_interactive_content(content_json))
-    elif msg_type == "share_calendar_event":
-        parts.append(f"[shared calendar event: {content_json.get('event_key', '')}]")
-    elif msg_type == "system":
-        parts.append("[system message]")
-    elif msg_type == "merge_forward":
-        parts.append("[merged forward messages]")
-
-    return "\n".join(parts) if parts else f"[{msg_type}]"
-
-
-def _extract_interactive_content(content: dict) -> list[str]:
-    """Recursively extract text and links from interactive card content."""
-    parts = []
-    
-    if isinstance(content, str):
-        try:
-            content = json.loads(content)
-        except (json.JSONDecodeError, TypeError):
-            return [content] if content.strip() else []
-
-    if not isinstance(content, dict):
-        return parts
-
-    if "title" in content:
-        title = content["title"]
-        if isinstance(title, dict):
-            title_content = title.get("content", "") or title.get("text", "")
-            if title_content:
-                parts.append(f"title: {title_content}")
-        elif isinstance(title, str):
-            parts.append(f"title: {title}")
-
-    for element in content.get("elements", []) if isinstance(content.get("elements"), list) else []:
-        parts.extend(_extract_element_content(element))
-
-    card = content.get("card", {})
-    if card:
-        parts.extend(_extract_interactive_content(card))
-
-    header = content.get("header", {})
-    if header:
-        header_title = header.get("title", {})
-        if isinstance(header_title, dict):
-            header_text = header_title.get("content", "") or header_title.get("text", "")
-            if header_text:
-                parts.append(f"title: {header_text}")
-    
-    return parts
-
-
-def _extract_element_content(element: dict) -> list[str]:
-    """Extract content from a single card element."""
-    parts = []
-    
-    if not isinstance(element, dict):
-        return parts
-    
-    tag = element.get("tag", "")
-    
-    if tag in ("markdown", "lark_md"):
-        content = element.get("content", "")
-        if content:
-            parts.append(content)
-
-    elif tag == "div":
-        text = element.get("text", {})
-        if isinstance(text, dict):
-            text_content = text.get("content", "") or text.get("text", "")
-            if text_content:
-                parts.append(text_content)
-        elif isinstance(text, str):
-            parts.append(text)
-        for field in element.get("fields", []):
-            if isinstance(field, dict):
-                field_text = field.get("text", {})
-                if isinstance(field_text, dict):
-                    c = field_text.get("content", "")
-                    if c:
-                        parts.append(c)
-
-    elif tag == "a":
-        href = element.get("href", "")
-        text = element.get("text", "")
-        if href:
-            parts.append(f"link: {href}")
-        if text:
-            parts.append(text)
-
-    elif tag == "button":
-        text = element.get("text", {})
-        if isinstance(text, dict):
-            c = text.get("content", "")
-            if c:
-                parts.append(c)
-        url = element.get("url", "") or element.get("multi_url", {}).get("url", "")
-        if url:
-            parts.append(f"link: {url}")
-
-    elif tag == "img":
-        alt = element.get("alt", {})
-        parts.append(alt.get("content", "[image]") if isinstance(alt, dict) else "[image]")
-
-    elif tag == "note":
-        for ne in element.get("elements", []):
-            parts.extend(_extract_element_content(ne))
-
-    elif tag == "column_set":
-        for col in element.get("columns", []):
-            for ce in col.get("elements", []):
-                parts.extend(_extract_element_content(ce))
-
-    elif tag == "plain_text":
-        content = element.get("content", "")
-        if content:
-            parts.append(content)
-
-    else:
-        for ne in element.get("elements", []):
-            parts.extend(_extract_element_content(ne))
-    
-    return parts
-
-
-def _extract_post_content(content_json: dict) -> tuple[str, list[str]]:
-    """Extract text and image keys from Feishu post (rich text) message content.
-    
-    Supports two formats:
-    1. Direct format: {"title": "...", "content": [...]}
-    2. Localized format: {"zh_cn": {"title": "...", "content": [...]}}
-    
-    Returns:
-        (text, image_keys) - extracted text and list of image keys
-    """
-    def extract_from_lang(lang_content: dict) -> tuple[str | None, list[str]]:
-        if not isinstance(lang_content, dict):
-            return None, []
-        title = lang_content.get("title", "")
-        content_blocks = lang_content.get("content", [])
-        if not isinstance(content_blocks, list):
-            return None, []
-        text_parts = []
-        image_keys = []
-        if title:
-            text_parts.append(title)
-        for block in content_blocks:
-            if not isinstance(block, list):
-                continue
-            for element in block:
-                if isinstance(element, dict):
-                    tag = element.get("tag")
-                    if tag == "text":
-                        text_parts.append(element.get("text", ""))
-                    elif tag == "a":
-                        text_parts.append(element.get("text", ""))
-                    elif tag == "at":
-                        text_parts.append(f"@{element.get('user_name', 'user')}")
-                    elif tag == "img":
-                        img_key = element.get("image_key")
-                        if img_key:
-                            image_keys.append(img_key)
-        text = " ".join(text_parts).strip() if text_parts else None
-        return text, image_keys
-    
-    # Try direct format first
-    if "content" in content_json:
-        text, images = extract_from_lang(content_json)
-        if text or images:
-            return text or "", images
-    
-    # Try localized format
-    for lang_key in ("zh_cn", "en_us", "ja_jp"):
-        lang_content = content_json.get(lang_key)
-        text, images = extract_from_lang(lang_content)
-        if text or images:
-            return text or "", images
-    
-    return "", []
-
-
-def _extract_post_text(content_json: dict) -> str:
-    """Extract plain text from Feishu post (rich text) message content.
-    
-    Legacy wrapper for _extract_post_content, returns only text.
-    """
-    text, _ = _extract_post_content(content_json)
-    return text
-
-
 class FeishuChannel(BaseChannel):
    """
    Feishu/Lark channel using WebSocket long connection.
@@ -310,7 +104,7 @@ class FeishuChannel(BaseChannel):
                try:
                    self._ws_client.start()
                except Exception as e:
-                    logger.warning("Feishu WebSocket error: {}", e)
+                    logger.warning(f"Feishu WebSocket error: {e}")
                if self._running:
                    import time; time.sleep(5)
        
@@ -331,7 +125,7 @@ class FeishuChannel(BaseChannel):
            try:
                self._ws_client.stop()
            except Exception as e:
-                logger.warning("Error stopping WebSocket client: {}", e)
+                logger.warning(f"Error stopping WebSocket client: {e}")
        logger.info("Feishu bot stopped")
    
    def _add_reaction_sync(self, message_id: str, emoji_type: str) -> None:
@@ -348,11 +142,11 @@ class FeishuChannel(BaseChannel):
            response = self._client.im.v1.message_reaction.create(request)
            
            if not response.success():
-                logger.warning("Failed to add reaction: code={}, msg={}", response.code, response.msg)
+                logger.warning(f"Failed to add reaction: code={response.code}, msg={response.msg}")
            else:
-                logger.debug("Added {} reaction to message {}", emoji_type, message_id)
+                logger.debug(f"Added {emoji_type} reaction to message {message_id}")
        except Exception as e:
-            logger.warning("Error adding reaction: {}", e)
+            logger.warning(f"Error adding reaction: {e}")

    async def _add_reaction(self, message_id: str, emoji_type: str = "THUMBSUP") -> None:
        """
@@ -422,6 +216,7 @@ class FeishuChannel(BaseChannel):
            before = protected[last_end:m.start()].strip()
            if before:
                elements.append({"tag": "markdown", "content": before})
+            level = len(m.group(1))
            text = m.group(2).strip()
            elements.append({
                "tag": "div",
@@ -442,220 +237,50 @@ class FeishuChannel(BaseChannel):

        return elements or [{"tag": "markdown", "content": content}]

-    _IMAGE_EXTS = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".ico", ".tiff", ".tif"}
-    _AUDIO_EXTS = {".opus"}
-    _FILE_TYPE_MAP = {
-        ".opus": "opus", ".mp4": "mp4", ".pdf": "pdf", ".doc": "doc", ".docx": "doc",
-        ".xls": "xls", ".xlsx": "xls", ".ppt": "ppt", ".pptx": "ppt",
-    }
-
-    def _upload_image_sync(self, file_path: str) -> str | None:
-        """Upload an image to Feishu and return the image_key."""
+    async def send(self, msg: OutboundMessage) -> None:
+        """Send a message through Feishu."""
+        if not self._client:
+            logger.warning("Feishu client not initialized")
+            return
+        
        try:
-            with open(file_path, "rb") as f:
-                request = CreateImageRequest.builder() \
-                    .request_body(
-                        CreateImageRequestBody.builder()
-                        .image_type("message")
-                        .image(f)
-                        .build()
-                    ).build()
-                response = self._client.im.v1.image.create(request)
-                if response.success():
-                    image_key = response.data.image_key
-                    logger.debug("Uploaded image {}: {}", os.path.basename(file_path), image_key)
-                    return image_key
-                else:
-                    logger.error("Failed to upload image: code={}, msg={}", response.code, response.msg)
-                    return None
-        except Exception as e:
-            logger.error("Error uploading image {}: {}", file_path, e)
-            return None
-
-    def _upload_file_sync(self, file_path: str) -> str | None:
-        """Upload a file to Feishu and return the file_key."""
-        ext = os.path.splitext(file_path)[1].lower()
-        file_type = self._FILE_TYPE_MAP.get(ext, "stream")
-        file_name = os.path.basename(file_path)
-        try:
-            with open(file_path, "rb") as f:
-                request = CreateFileRequest.builder() \
-                    .request_body(
-                        CreateFileRequestBody.builder()
-                        .file_type(file_type)
-                        .file_name(file_name)
-                        .file(f)
-                        .build()
-                    ).build()
-                response = self._client.im.v1.file.create(request)
-                if response.success():
-                    file_key = response.data.file_key
-                    logger.debug("Uploaded file {}: {}", file_name, file_key)
-                    return file_key
-                else:
-                    logger.error("Failed to upload file: code={}, msg={}", response.code, response.msg)
-                    return None
-        except Exception as e:
-            logger.error("Error uploading file {}: {}", file_path, e)
-            return None
-
-    def _download_image_sync(self, message_id: str, image_key: str) -> tuple[bytes | None, str | None]:
-        """Download an image from Feishu message by message_id and image_key."""
-        try:
-            request = GetMessageResourceRequest.builder() \
-                .message_id(message_id) \
-                .file_key(image_key) \
-                .type("image") \
-                .build()
-            response = self._client.im.v1.message_resource.get(request)
-            if response.success():
-                file_data = response.file
-                # GetMessageResourceRequest returns BytesIO, need to read bytes
-                if hasattr(file_data, 'read'):
-                    file_data = file_data.read()
-                return file_data, response.file_name
+            # Determine receive_id_type based on chat_id format
+            # open_id starts with "ou_", chat_id starts with "oc_"
+            if msg.chat_id.startswith("oc_"):
+                receive_id_type = "chat_id"
            else:
-                logger.error("Failed to download image: code={}, msg={}", response.code, response.msg)
-                return None, None
-        except Exception as e:
-            logger.error("Error downloading image {}: {}", image_key, e)
-            return None, None
-
-    def _download_file_sync(
-        self, message_id: str, file_key: str, resource_type: str = "file"
-    ) -> tuple[bytes | None, str | None]:
-        """Download a file/audio/media from a Feishu message by message_id and file_key."""
-        try:
-            request = (
-                GetMessageResourceRequest.builder()
-                .message_id(message_id)
-                .file_key(file_key)
-                .type(resource_type)
-                .build()
-            )
-            response = self._client.im.v1.message_resource.get(request)
-            if response.success():
-                file_data = response.file
-                if hasattr(file_data, "read"):
-                    file_data = file_data.read()
-                return file_data, response.file_name
-            else:
-                logger.error("Failed to download {}: code={}, msg={}", resource_type, response.code, response.msg)
-                return None, None
-        except Exception:
-            logger.exception("Error downloading {} {}", resource_type, file_key)
-            return None, None
-
-    async def _download_and_save_media(
-        self,
-        msg_type: str,
-        content_json: dict,
-        message_id: str | None = None
-    ) -> tuple[str | None, str]:
-        """
-        Download media from Feishu and save to local disk.
-
-        Returns:
-            (file_path, content_text) - file_path is None if download failed
-        """
-        loop = asyncio.get_running_loop()
-        media_dir = Path.home() / ".nanobot" / "media"
-        media_dir.mkdir(parents=True, exist_ok=True)
-
-        data, filename = None, None
-
-        if msg_type == "image":
-            image_key = content_json.get("image_key")
-            if image_key and message_id:
-                data, filename = await loop.run_in_executor(
-                    None, self._download_image_sync, message_id, image_key
-                )
-                if not filename:
-                    filename = f"{image_key[:16]}.jpg"
-
-        elif msg_type in ("audio", "file", "media"):
-            file_key = content_json.get("file_key")
-            if file_key and message_id:
-                data, filename = await loop.run_in_executor(
-                    None, self._download_file_sync, message_id, file_key, msg_type
-                )
-                if not filename:
-                    ext = {"audio": ".opus", "media": ".mp4"}.get(msg_type, "")
-                    filename = f"{file_key[:16]}{ext}"
-
-        if data and filename:
-            file_path = media_dir / filename
-            file_path.write_bytes(data)
-            logger.debug("Downloaded {} to {}", msg_type, file_path)
-            return str(file_path), f"[{msg_type}: {filename}]"
-
-        return None, f"[{msg_type}: download failed]"
-
-    def _send_message_sync(self, receive_id_type: str, receive_id: str, msg_type: str, content: str) -> bool:
-        """Send a single message (text/image/file/interactive) synchronously."""
-        try:
+                receive_id_type = "open_id"
+            
+            # Build card with markdown + table support
+            elements = self._build_card_elements(msg.content)
+            card = {
+                "config": {"wide_screen_mode": True},
+                "elements": elements,
+            }
+            content = json.dumps(card, ensure_ascii=False)
+            
            request = CreateMessageRequest.builder() \
                .receive_id_type(receive_id_type) \
                .request_body(
                    CreateMessageRequestBody.builder()
-                    .receive_id(receive_id)
-                    .msg_type(msg_type)
+                    .receive_id(msg.chat_id)
+                    .msg_type("interactive")
                    .content(content)
                    .build()
                ).build()
+            
            response = self._client.im.v1.message.create(request)
+            
            if not response.success():
                logger.error(
-                    "Failed to send Feishu {} message: code={}, msg={}, log_id={}",
-                    msg_type, response.code, response.msg, response.get_log_id()
+                    f"Failed to send Feishu message: code={response.code}, "
+                    f"msg={response.msg}, log_id={response.get_log_id()}"
                )
-                return False
-            logger.debug("Feishu {} message sent to {}", msg_type, receive_id)
-            return True
+            else:
+                logger.debug(f"Feishu message sent to {msg.chat_id}")
+                
        except Exception as e:
-            logger.error("Error sending Feishu {} message: {}", msg_type, e)
-            return False
-
-    async def send(self, msg: OutboundMessage) -> None:
-        """Send a message through Feishu, including media (images/files) if present."""
-        if not self._client:
-            logger.warning("Feishu client not initialized")
-            return
-
-        try:
-            receive_id_type = "chat_id" if msg.chat_id.startswith("oc_") else "open_id"
-            loop = asyncio.get_running_loop()
-
-            for file_path in msg.media:
-                if not os.path.isfile(file_path):
-                    logger.warning("Media file not found: {}", file_path)
-                    continue
-                ext = os.path.splitext(file_path)[1].lower()
-                if ext in self._IMAGE_EXTS:
-                    key = await loop.run_in_executor(None, self._upload_image_sync, file_path)
-                    if key:
-                        await loop.run_in_executor(
-                            None, self._send_message_sync,
-                            receive_id_type, msg.chat_id, "image", json.dumps({"image_key": key}, ensure_ascii=False),
-                        )
-                else:
-                    key = await loop.run_in_executor(None, self._upload_file_sync, file_path)
-                    if key:
-                        media_type = "audio" if ext in self._AUDIO_EXTS else "file"
-                        await loop.run_in_executor(
-                            None, self._send_message_sync,
-                            receive_id_type, msg.chat_id, media_type, json.dumps({"file_key": key}, ensure_ascii=False),
-                        )
-
-            if msg.content and msg.content.strip():
-                card = {"config": {"wide_screen_mode": True}, "elements": self._build_card_elements(msg.content)}
-                await loop.run_in_executor(
-                    None, self._send_message_sync,
-                    receive_id_type, msg.chat_id, "interactive", json.dumps(card, ensure_ascii=False),
-                )
-
-        except Exception as e:
-            logger.error("Error sending Feishu message: {}", e)
+            logger.error(f"Error sending Feishu message: {e}")
    
    def _on_message_sync(self, data: "P2ImMessageReceiveV1") -> None:
        """
@@ -671,89 +296,54 @@ class FeishuChannel(BaseChannel):
            event = data.event
            message = event.message
            sender = event.sender
-
+            
            # Deduplication check
            message_id = message.message_id
            if message_id in self._processed_message_ids:
                return
            self._processed_message_ids[message_id] = None
-
-            # Trim cache
+            
+            # Trim cache: keep most recent 500 when exceeds 1000
            while len(self._processed_message_ids) > 1000:
                self._processed_message_ids.popitem(last=False)
-
+            
            # Skip bot messages
-            if sender.sender_type == "bot":
+            sender_type = sender.sender_type
+            if sender_type == "bot":
                return
-
+            
            sender_id = sender.sender_id.open_id if sender.sender_id else "unknown"
            chat_id = message.chat_id
-            chat_type = message.chat_type
+            chat_type = message.chat_type  # "p2p" or "group"
            msg_type = message.message_type
-
-            # Add reaction
-            await self._add_reaction(message_id, self.config.react_emoji)
-
-            # Parse content
-            content_parts = []
-            media_paths = []
-
-            try:
-                content_json = json.loads(message.content) if message.content else {}
-            except json.JSONDecodeError:
-                content_json = {}
-
+            
+            # Add reaction to indicate "seen"
+            await self._add_reaction(message_id, "THUMBSUP")
+            
+            # Parse message content
            if msg_type == "text":
-                text = content_json.get("text", "")
-                if text:
-                    content_parts.append(text)
-
-            elif msg_type == "post":
-                text, image_keys = _extract_post_content(content_json)
-                if text:
-                    content_parts.append(text)
-                # Download images embedded in post
-                for img_key in image_keys:
-                    file_path, content_text = await self._download_and_save_media(
-                        "image", {"image_key": img_key}, message_id
-                    )
-                    if file_path:
-                        media_paths.append(file_path)
-                    content_parts.append(content_text)
-
-            elif msg_type in ("image", "audio", "file", "media"):
-                file_path, content_text = await self._download_and_save_media(msg_type, content_json, message_id)
-                if file_path:
-                    media_paths.append(file_path)
-                content_parts.append(content_text)
-
-            elif msg_type in ("share_chat", "share_user", "interactive", "share_calendar_event", "system", "merge_forward"):
-                # Handle share cards and interactive messages
-                text = _extract_share_card_content(content_json, msg_type)
-                if text:
-                    content_parts.append(text)
-
+                try:
+                    content = json.loads(message.content).get("text", "")
+                except json.JSONDecodeError:
+                    content = message.content or ""
            else:
-                content_parts.append(MSG_TYPE_MAP.get(msg_type, f"[{msg_type}]"))
-
-            content = "\n".join(content_parts) if content_parts else ""
-
-            if not content and not media_paths:
+                content = MSG_TYPE_MAP.get(msg_type, f"[{msg_type}]")
+            
+            if not content:
                return
-
+            
            # Forward to message bus
            reply_to = chat_id if chat_type == "group" else sender_id
            await self._handle_message(
                sender_id=sender_id,
                chat_id=reply_to,
                content=content,
-                media=media_paths,
                metadata={
                    "message_id": message_id,
                    "chat_type": chat_type,
                    "msg_type": msg_type,
                }
            )
-
+            
        except Exception as e:
-            logger.error("Error processing Feishu message: {}", e)
+            logger.error(f"Error processing Feishu message: {e}")
@@ -1,38 +0,0 @@
-"""Hook channel — receives outbound messages from hook-initiated conversations."""
-
-from loguru import logger
-
-from nanobot.bus.events import OutboundMessage
-from nanobot.bus.queue import MessageBus
-
-
-class HookChannel:
-    """
-    Minimal channel for hook-initiated conversations.
-
-    The hook HTTP server publishes InboundMessages to the bus.
-    Responses come back as OutboundMessages routed here.
-    send() is a no-op because the HTTP caller gets the response
-    via bus correlation, not channel delivery.
-    """
-
-    name = "hook"
-
-    def __init__(self, bus: MessageBus):
-        self.bus = bus
-        self._running = False
-
-    async def start(self) -> None:
-        self._running = True
-        logger.info("Hook channel started")
-
-    async def stop(self) -> None:
-        self._running = False
-
-    async def send(self, msg: OutboundMessage) -> None:
-        """No-op — response is returned via bus correlation to the HTTP caller."""
-        logger.debug(f"Hook channel received outbound for {msg.chat_id} (no-op)")
-
-    @property
-    def is_running(self) -> bool:
-        return self._running
@@ -45,7 +45,7 @@ class ChannelManager:
                )
                logger.info("Telegram channel enabled")
            except ImportError as e:
-                logger.warning("Telegram channel not available: {}", e)
+                logger.warning(f"Telegram channel not available: {e}")
        
        # WhatsApp channel
        if self.config.channels.whatsapp.enabled:
@@ -56,7 +56,7 @@ class ChannelManager:
                )
                logger.info("WhatsApp channel enabled")
            except ImportError as e:
-                logger.warning("WhatsApp channel not available: {}", e)
+                logger.warning(f"WhatsApp channel not available: {e}")

        # Discord channel
        if self.config.channels.discord.enabled:
@@ -67,7 +67,7 @@ class ChannelManager:
                )
                logger.info("Discord channel enabled")
            except ImportError as e:
-                logger.warning("Discord channel not available: {}", e)
+                logger.warning(f"Discord channel not available: {e}")
        
        # Feishu channel
        if self.config.channels.feishu.enabled:
@@ -78,7 +78,7 @@ class ChannelManager:
                )
                logger.info("Feishu channel enabled")
            except ImportError as e:
-                logger.warning("Feishu channel not available: {}", e)
+                logger.warning(f"Feishu channel not available: {e}")

        # Mochat channel
        if self.config.channels.mochat.enabled:
@@ -90,7 +90,7 @@ class ChannelManager:
                )
                logger.info("Mochat channel enabled")
            except ImportError as e:
-                logger.warning("Mochat channel not available: {}", e)
+                logger.warning(f"Mochat channel not available: {e}")

        # DingTalk channel
        if self.config.channels.dingtalk.enabled:
@@ -101,7 +101,7 @@ class ChannelManager:
                )
                logger.info("DingTalk channel enabled")
            except ImportError as e:
-                logger.warning("DingTalk channel not available: {}", e)
+                logger.warning(f"DingTalk channel not available: {e}")

        # Email channel
        if self.config.channels.email.enabled:
@@ -112,7 +112,7 @@ class ChannelManager:
                )
                logger.info("Email channel enabled")
            except ImportError as e:
-                logger.warning("Email channel not available: {}", e)
+                logger.warning(f"Email channel not available: {e}")

        # Slack channel
        if self.config.channels.slack.enabled:
@@ -123,7 +123,7 @@ class ChannelManager:
                )
                logger.info("Slack channel enabled")
            except ImportError as e:
-                logger.warning("Slack channel not available: {}", e)
+                logger.warning(f"Slack channel not available: {e}")

        # QQ channel
        if self.config.channels.qq.enabled:
@@ -135,31 +135,14 @@ class ChannelManager:
                )
                logger.info("QQ channel enabled")
            except ImportError as e:
-                logger.warning("QQ channel not available: {}", e)
-        
-        # Matrix channel
-        if self.config.channels.matrix.enabled:
-            try:
-                from nanobot.channels.matrix import MatrixChannel
-                self.channels["matrix"] = MatrixChannel(
-                    self.config.channels.matrix,
-                    self.bus,
-                )
-                logger.info("Matrix channel enabled")
-            except ImportError as e:
-                logger.warning("Matrix channel not available: {}", e)
+                logger.warning(f"QQ channel not available: {e}")
    
-    def register_channel(self, name: str, channel: BaseChannel) -> None:
-        """Register an external channel."""
-        self.channels[name] = channel
-        logger.info(f"{name} channel registered")
-
    async def _start_channel(self, name: str, channel: BaseChannel) -> None:
        """Start a channel and log any exceptions."""
        try:
            await channel.start()
        except Exception as e:
-            logger.error("Failed to start channel {}: {}", name, e)
+            logger.error(f"Failed to start channel {name}: {e}")

    async def start_all(self) -> None:
        """Start all channels and the outbound dispatcher."""
@@ -173,7 +156,7 @@ class ChannelManager:
        # Start channels
        tasks = []
        for name, channel in self.channels.items():
-            logger.info("Starting {} channel...", name)
+            logger.info(f"Starting {name} channel...")
            tasks.append(asyncio.create_task(self._start_channel(name, channel)))
        
        # Wait for all to complete (they should run forever)
@@ -195,9 +178,9 @@ class ChannelManager:
        for name, channel in self.channels.items():
            try:
                await channel.stop()
-                logger.info("Stopped {} channel", name)
+                logger.info(f"Stopped {name} channel")
            except Exception as e:
-                logger.error("Error stopping {}: {}", name, e)
+                logger.error(f"Error stopping {name}: {e}")
    
    async def _dispatch_outbound(self) -> None:
        """Dispatch outbound messages to the appropriate channel."""
@@ -209,24 +192,15 @@ class ChannelManager:
                    self.bus.consume_outbound(),
                    timeout=1.0
                )
-
-                # Resolve any pending correlation (hook request-response)
-                self.bus.resolve_correlation(msg)
-
-                if msg.metadata.get("_progress"):
-                    if msg.metadata.get("_tool_hint") and not self.config.channels.send_tool_hints:
-                        continue
-                    if not msg.metadata.get("_tool_hint") and not self.config.channels.send_progress:
-                        continue
-
+                
                channel = self.channels.get(msg.channel)
                if channel:
                    try:
                        await channel.send(msg)
                    except Exception as e:
-                        logger.error("Error sending to {}: {}", msg.channel, e)
+                        logger.error(f"Error sending to {msg.channel}: {e}")
                else:
-                    logger.warning("Unknown channel: {}", msg.channel)
+                    logger.warning(f"Unknown channel: {msg.channel}")
                    
            except asyncio.TimeoutError:
                continue
@@ -1,682 +0,0 @@
-"""Matrix (Element) channel — inbound sync + outbound message/media delivery."""
-
-import asyncio
-import logging
-import mimetypes
-from pathlib import Path
-from typing import Any, TypeAlias
-
-from loguru import logger
-
-try:
-    import nh3
-    from mistune import create_markdown
-    from nio import (
-        AsyncClient, AsyncClientConfig, ContentRepositoryConfigError,
-        DownloadError, InviteEvent, JoinError, MatrixRoom, MemoryDownloadResponse,
-        RoomEncryptedMedia, RoomMessage, RoomMessageMedia, RoomMessageText,
-        RoomSendError, RoomTypingError, SyncError, UploadError,
-    )
-    from nio.crypto.attachments import decrypt_attachment
-    from nio.exceptions import EncryptionError
-except ImportError as e:
-    raise ImportError(
-        "Matrix dependencies not installed. Run: pip install nanobot-ai[matrix]"
-    ) from e
-
-from nanobot.bus.events import OutboundMessage
-from nanobot.channels.base import BaseChannel
-from nanobot.config.loader import get_data_dir
-from nanobot.utils.helpers import safe_filename
-
-TYPING_NOTICE_TIMEOUT_MS = 30_000
-# Must stay below TYPING_NOTICE_TIMEOUT_MS so the indicator doesn't expire mid-processing.
-TYPING_KEEPALIVE_INTERVAL_MS = 20_000
-MATRIX_HTML_FORMAT = "org.matrix.custom.html"
-_ATTACH_MARKER = "[attachment: {}]"
-_ATTACH_TOO_LARGE = "[attachment: {} - too large]"
-_ATTACH_FAILED = "[attachment: {} - download failed]"
-_ATTACH_UPLOAD_FAILED = "[attachment: {} - upload failed]"
-_DEFAULT_ATTACH_NAME = "attachment"
-_MSGTYPE_MAP = {"m.image": "image", "m.audio": "audio", "m.video": "video", "m.file": "file"}
-
-MATRIX_MEDIA_EVENT_FILTER = (RoomMessageMedia, RoomEncryptedMedia)
-MatrixMediaEvent: TypeAlias = RoomMessageMedia | RoomEncryptedMedia
-
-MATRIX_MARKDOWN = create_markdown(
-    escape=True,
-    plugins=["table", "strikethrough", "url", "superscript", "subscript"],
-)
-
-MATRIX_ALLOWED_HTML_TAGS = {
-    "p", "a", "strong", "em", "del", "code", "pre", "blockquote",
-    "ul", "ol", "li", "h1", "h2", "h3", "h4", "h5", "h6",
-    "hr", "br", "table", "thead", "tbody", "tr", "th", "td",
-    "caption", "sup", "sub", "img",
-}
-MATRIX_ALLOWED_HTML_ATTRIBUTES: dict[str, set[str]] = {
-    "a": {"href"}, "code": {"class"}, "ol": {"start"},
-    "img": {"src", "alt", "title", "width", "height"},
-}
-MATRIX_ALLOWED_URL_SCHEMES = {"https", "http", "matrix", "mailto", "mxc"}
-
-
-def _filter_matrix_html_attribute(tag: str, attr: str, value: str) -> str | None:
-    """Filter attribute values to a safe Matrix-compatible subset."""
-    if tag == "a" and attr == "href":
-        return value if value.lower().startswith(("https://", "http://", "matrix:", "mailto:")) else None
-    if tag == "img" and attr == "src":
-        return value if value.lower().startswith("mxc://") else None
-    if tag == "code" and attr == "class":
-        classes = [c for c in value.split() if c.startswith("language-") and not c.startswith("language-_")]
-        return " ".join(classes) if classes else None
-    return value
-
-
-MATRIX_HTML_CLEANER = nh3.Cleaner(
-    tags=MATRIX_ALLOWED_HTML_TAGS,
-    attributes=MATRIX_ALLOWED_HTML_ATTRIBUTES,
-    attribute_filter=_filter_matrix_html_attribute,
-    url_schemes=MATRIX_ALLOWED_URL_SCHEMES,
-    strip_comments=True,
-    link_rel="noopener noreferrer",
-)
-
-
-def _render_markdown_html(text: str) -> str | None:
-    """Render markdown to sanitized HTML; returns None for plain text."""
-    try:
-        formatted = MATRIX_HTML_CLEANER.clean(MATRIX_MARKDOWN(text)).strip()
-    except Exception:
-        return None
-    if not formatted:
-        return None
-    # Skip formatted_body for plain <p>text</p> to keep payload minimal.
-    if formatted.startswith("<p>") and formatted.endswith("</p>"):
-        inner = formatted[3:-4]
-        if "<" not in inner and ">" not in inner:
-            return None
-    return formatted
-
-
-def _build_matrix_text_content(text: str) -> dict[str, object]:
-    """Build Matrix m.text payload with optional HTML formatted_body."""
-    content: dict[str, object] = {"msgtype": "m.text", "body": text, "m.mentions": {}}
-    if html := _render_markdown_html(text):
-        content["format"] = MATRIX_HTML_FORMAT
-        content["formatted_body"] = html
-    return content
-
-
-class _NioLoguruHandler(logging.Handler):
-    """Route matrix-nio stdlib logs into Loguru."""
-
-    def emit(self, record: logging.LogRecord) -> None:
-        try:
-            level = logger.level(record.levelname).name
-        except ValueError:
-            level = record.levelno
-        frame, depth = logging.currentframe(), 2
-        while frame and frame.f_code.co_filename == logging.__file__:
-            frame, depth = frame.f_back, depth + 1
-        logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
-
-
-def _configure_nio_logging_bridge() -> None:
-    """Bridge matrix-nio logs to Loguru (idempotent)."""
-    nio_logger = logging.getLogger("nio")
-    if not any(isinstance(h, _NioLoguruHandler) for h in nio_logger.handlers):
-        nio_logger.handlers = [_NioLoguruHandler()]
-        nio_logger.propagate = False
-
-
-class MatrixChannel(BaseChannel):
-    """Matrix (Element) channel using long-polling sync."""
-
-    name = "matrix"
-
-    def __init__(self, config: Any, bus, *, restrict_to_workspace: bool = False,
-                 workspace: Path | None = None):
-        super().__init__(config, bus)
-        self.client: AsyncClient | None = None
-        self._sync_task: asyncio.Task | None = None
-        self._typing_tasks: dict[str, asyncio.Task] = {}
-        self._restrict_to_workspace = restrict_to_workspace
-        self._workspace = workspace.expanduser().resolve() if workspace else None
-        self._server_upload_limit_bytes: int | None = None
-        self._server_upload_limit_checked = False
-
-    async def start(self) -> None:
-        """Start Matrix client and begin sync loop."""
-        self._running = True
-        _configure_nio_logging_bridge()
-
-        store_path = get_data_dir() / "matrix-store"
-        store_path.mkdir(parents=True, exist_ok=True)
-
-        self.client = AsyncClient(
-            homeserver=self.config.homeserver, user=self.config.user_id,
-            store_path=store_path,
-            config=AsyncClientConfig(store_sync_tokens=True, encryption_enabled=self.config.e2ee_enabled),
-        )
-        self.client.user_id = self.config.user_id
-        self.client.access_token = self.config.access_token
-        self.client.device_id = self.config.device_id
-
-        self._register_event_callbacks()
-        self._register_response_callbacks()
-
-        if not self.config.e2ee_enabled:
-            logger.warning("Matrix E2EE disabled; encrypted rooms may be undecryptable.")
-
-        if self.config.device_id:
-            try:
-                self.client.load_store()
-            except Exception:
-                logger.exception("Matrix store load failed; restart may replay recent messages.")
-        else:
-            logger.warning("Matrix device_id empty; restart may replay recent messages.")
-
-        self._sync_task = asyncio.create_task(self._sync_loop())
-
-    async def stop(self) -> None:
-        """Stop the Matrix channel with graceful sync shutdown."""
-        self._running = False
-        for room_id in list(self._typing_tasks):
-            await self._stop_typing_keepalive(room_id, clear_typing=False)
-        if self.client:
-            self.client.stop_sync_forever()
-        if self._sync_task:
-            try:
-                await asyncio.wait_for(asyncio.shield(self._sync_task),
-                                       timeout=self.config.sync_stop_grace_seconds)
-            except (asyncio.TimeoutError, asyncio.CancelledError):
-                self._sync_task.cancel()
-                try:
-                    await self._sync_task
-                except asyncio.CancelledError:
-                    pass
-        if self.client:
-            await self.client.close()
-
-    def _is_workspace_path_allowed(self, path: Path) -> bool:
-        """Check path is inside workspace (when restriction enabled)."""
-        if not self._restrict_to_workspace or not self._workspace:
-            return True
-        try:
-            path.resolve(strict=False).relative_to(self._workspace)
-            return True
-        except ValueError:
-            return False
-
-    def _collect_outbound_media_candidates(self, media: list[str]) -> list[Path]:
-        """Deduplicate and resolve outbound attachment paths."""
-        seen: set[str] = set()
-        candidates: list[Path] = []
-        for raw in media:
-            if not isinstance(raw, str) or not raw.strip():
-                continue
-            path = Path(raw.strip()).expanduser()
-            try:
-                key = str(path.resolve(strict=False))
-            except OSError:
-                key = str(path)
-            if key not in seen:
-                seen.add(key)
-                candidates.append(path)
-        return candidates
-
-    @staticmethod
-    def _build_outbound_attachment_content(
-        *, filename: str, mime: str, size_bytes: int,
-        mxc_url: str, encryption_info: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """Build Matrix content payload for an uploaded file/image/audio/video."""
-        prefix = mime.split("/")[0]
-        msgtype = {"image": "m.image", "audio": "m.audio", "video": "m.video"}.get(prefix, "m.file")
-        content: dict[str, Any] = {
-            "msgtype": msgtype, "body": filename, "filename": filename,
-            "info": {"mimetype": mime, "size": size_bytes}, "m.mentions": {},
-        }
-        if encryption_info:
-            content["file"] = {**encryption_info, "url": mxc_url}
-        else:
-            content["url"] = mxc_url
-        return content
-
-    def _is_encrypted_room(self, room_id: str) -> bool:
-        if not self.client:
-            return False
-        room = getattr(self.client, "rooms", {}).get(room_id)
-        return bool(getattr(room, "encrypted", False))
-
-    async def _send_room_content(self, room_id: str, content: dict[str, Any]) -> None:
-        """Send m.room.message with E2EE options."""
-        if not self.client:
-            return
-        kwargs: dict[str, Any] = {"room_id": room_id, "message_type": "m.room.message", "content": content}
-        if self.config.e2ee_enabled:
-            kwargs["ignore_unverified_devices"] = True
-        await self.client.room_send(**kwargs)
-
-    async def _resolve_server_upload_limit_bytes(self) -> int | None:
-        """Query homeserver upload limit once per channel lifecycle."""
-        if self._server_upload_limit_checked:
-            return self._server_upload_limit_bytes
-        self._server_upload_limit_checked = True
-        if not self.client:
-            return None
-        try:
-            response = await self.client.content_repository_config()
-        except Exception:
-            return None
-        upload_size = getattr(response, "upload_size", None)
-        if isinstance(upload_size, int) and upload_size > 0:
-            self._server_upload_limit_bytes = upload_size
-            return upload_size
-        return None
-
-    async def _effective_media_limit_bytes(self) -> int:
-        """min(local config, server advertised) — 0 blocks all uploads."""
-        local_limit = max(int(self.config.max_media_bytes), 0)
-        server_limit = await self._resolve_server_upload_limit_bytes()
-        if server_limit is None:
-            return local_limit
-        return min(local_limit, server_limit) if local_limit else 0
-
-    async def _upload_and_send_attachment(
-        self, room_id: str, path: Path, limit_bytes: int,
-        relates_to: dict[str, Any] | None = None,
-    ) -> str | None:
-        """Upload one local file to Matrix and send it as a media message. Returns failure marker or None."""
-        if not self.client:
-            return _ATTACH_UPLOAD_FAILED.format(path.name or _DEFAULT_ATTACH_NAME)
-
-        resolved = path.expanduser().resolve(strict=False)
-        filename = safe_filename(resolved.name) or _DEFAULT_ATTACH_NAME
-        fail = _ATTACH_UPLOAD_FAILED.format(filename)
-
-        if not resolved.is_file() or not self._is_workspace_path_allowed(resolved):
-            return fail
-        try:
-            size_bytes = resolved.stat().st_size
-        except OSError:
-            return fail
-        if limit_bytes <= 0 or size_bytes > limit_bytes:
-            return _ATTACH_TOO_LARGE.format(filename)
-
-        mime = mimetypes.guess_type(filename, strict=False)[0] or "application/octet-stream"
-        try:
-            with resolved.open("rb") as f:
-                upload_result = await self.client.upload(
-                    f, content_type=mime, filename=filename,
-                    encrypt=self.config.e2ee_enabled and self._is_encrypted_room(room_id),
-                    filesize=size_bytes,
-                )
-        except Exception:
-            return fail
-
-        upload_response = upload_result[0] if isinstance(upload_result, tuple) else upload_result
-        encryption_info = upload_result[1] if isinstance(upload_result, tuple) and isinstance(upload_result[1], dict) else None
-        if isinstance(upload_response, UploadError):
-            return fail
-        mxc_url = getattr(upload_response, "content_uri", None)
-        if not isinstance(mxc_url, str) or not mxc_url.startswith("mxc://"):
-            return fail
-
-        content = self._build_outbound_attachment_content(
-            filename=filename, mime=mime, size_bytes=size_bytes,
-            mxc_url=mxc_url, encryption_info=encryption_info,
-        )
-        if relates_to:
-            content["m.relates_to"] = relates_to
-        try:
-            await self._send_room_content(room_id, content)
-        except Exception:
-            return fail
-        return None
-
-    async def send(self, msg: OutboundMessage) -> None:
-        """Send outbound content; clear typing for non-progress messages."""
-        if not self.client:
-            return
-        text = msg.content or ""
-        candidates = self._collect_outbound_media_candidates(msg.media)
-        relates_to = self._build_thread_relates_to(msg.metadata)
-        is_progress = bool((msg.metadata or {}).get("_progress"))
-        try:
-            failures: list[str] = []
-            if candidates:
-                limit_bytes = await self._effective_media_limit_bytes()
-                for path in candidates:
-                    if fail := await self._upload_and_send_attachment(
-                        msg.chat_id, path, limit_bytes, relates_to):
-                        failures.append(fail)
-            if failures:
-                text = f"{text.rstrip()}\n{chr(10).join(failures)}" if text.strip() else "\n".join(failures)
-            if text or not candidates:
-                content = _build_matrix_text_content(text)
-                if relates_to:
-                    content["m.relates_to"] = relates_to
-                await self._send_room_content(msg.chat_id, content)
-        finally:
-            if not is_progress:
-                await self._stop_typing_keepalive(msg.chat_id, clear_typing=True)
-
-    def _register_event_callbacks(self) -> None:
-        self.client.add_event_callback(self._on_message, RoomMessageText)
-        self.client.add_event_callback(self._on_media_message, MATRIX_MEDIA_EVENT_FILTER)
-        self.client.add_event_callback(self._on_room_invite, InviteEvent)
-
-    def _register_response_callbacks(self) -> None:
-        self.client.add_response_callback(self._on_sync_error, SyncError)
-        self.client.add_response_callback(self._on_join_error, JoinError)
-        self.client.add_response_callback(self._on_send_error, RoomSendError)
-
-    def _log_response_error(self, label: str, response: Any) -> None:
-        """Log Matrix response errors — auth errors at ERROR level, rest at WARNING."""
-        code = getattr(response, "status_code", None)
-        is_auth = code in {"M_UNKNOWN_TOKEN", "M_FORBIDDEN", "M_UNAUTHORIZED"}
-        is_fatal = is_auth or getattr(response, "soft_logout", False)
-        (logger.error if is_fatal else logger.warning)("Matrix {} failed: {}", label, response)
-
-    async def _on_sync_error(self, response: SyncError) -> None:
-        self._log_response_error("sync", response)
-
-    async def _on_join_error(self, response: JoinError) -> None:
-        self._log_response_error("join", response)
-
-    async def _on_send_error(self, response: RoomSendError) -> None:
-        self._log_response_error("send", response)
-
-    async def _set_typing(self, room_id: str, typing: bool) -> None:
-        """Best-effort typing indicator update."""
-        if not self.client:
-            return
-        try:
-            response = await self.client.room_typing(room_id=room_id, typing_state=typing,
-                                                     timeout=TYPING_NOTICE_TIMEOUT_MS)
-            if isinstance(response, RoomTypingError):
-                logger.debug("Matrix typing failed for {}: {}", room_id, response)
-        except Exception:
-            pass
-
-    async def _start_typing_keepalive(self, room_id: str) -> None:
-        """Start periodic typing refresh (spec-recommended keepalive)."""
-        await self._stop_typing_keepalive(room_id, clear_typing=False)
-        await self._set_typing(room_id, True)
-        if not self._running:
-            return
-
-        async def loop() -> None:
-            try:
-                while self._running:
-                    await asyncio.sleep(TYPING_KEEPALIVE_INTERVAL_MS / 1000)
-                    await self._set_typing(room_id, True)
-            except asyncio.CancelledError:
-                pass
-
-        self._typing_tasks[room_id] = asyncio.create_task(loop())
-
-    async def _stop_typing_keepalive(self, room_id: str, *, clear_typing: bool) -> None:
-        if task := self._typing_tasks.pop(room_id, None):
-            task.cancel()
-            try:
-                await task
-            except asyncio.CancelledError:
-                pass
-        if clear_typing:
-            await self._set_typing(room_id, False)
-
-    async def _sync_loop(self) -> None:
-        while self._running:
-            try:
-                await self.client.sync_forever(timeout=30000, full_state=True)
-            except asyncio.CancelledError:
-                break
-            except Exception:
-                await asyncio.sleep(2)
-
-    async def _on_room_invite(self, room: MatrixRoom, event: InviteEvent) -> None:
-        allow_from = self.config.allow_from or []
-        if not allow_from or event.sender in allow_from:
-            await self.client.join(room.room_id)
-
-    def _is_direct_room(self, room: MatrixRoom) -> bool:
-        count = getattr(room, "member_count", None)
-        return isinstance(count, int) and count <= 2
-
-    def _is_bot_mentioned(self, event: RoomMessage) -> bool:
-        """Check m.mentions payload for bot mention."""
-        source = getattr(event, "source", None)
-        if not isinstance(source, dict):
-            return False
-        mentions = (source.get("content") or {}).get("m.mentions")
-        if not isinstance(mentions, dict):
-            return False
-        user_ids = mentions.get("user_ids")
-        if isinstance(user_ids, list) and self.config.user_id in user_ids:
-            return True
-        return bool(self.config.allow_room_mentions and mentions.get("room") is True)
-
-    def _should_process_message(self, room: MatrixRoom, event: RoomMessage) -> bool:
-        """Apply sender and room policy checks."""
-        if not self.is_allowed(event.sender):
-            return False
-        if self._is_direct_room(room):
-            return True
-        policy = self.config.group_policy
-        if policy == "open":
-            return True
-        if policy == "allowlist":
-            return room.room_id in (self.config.group_allow_from or [])
-        if policy == "mention":
-            return self._is_bot_mentioned(event)
-        return False
-
-    def _media_dir(self) -> Path:
-        d = get_data_dir() / "media" / "matrix"
-        d.mkdir(parents=True, exist_ok=True)
-        return d
-
-    @staticmethod
-    def _event_source_content(event: RoomMessage) -> dict[str, Any]:
-        source = getattr(event, "source", None)
-        if not isinstance(source, dict):
-            return {}
-        content = source.get("content")
-        return content if isinstance(content, dict) else {}
-
-    def _event_thread_root_id(self, event: RoomMessage) -> str | None:
-        relates_to = self._event_source_content(event).get("m.relates_to")
-        if not isinstance(relates_to, dict) or relates_to.get("rel_type") != "m.thread":
-            return None
-        root_id = relates_to.get("event_id")
-        return root_id if isinstance(root_id, str) and root_id else None
-
-    def _thread_metadata(self, event: RoomMessage) -> dict[str, str] | None:
-        if not (root_id := self._event_thread_root_id(event)):
-            return None
-        meta: dict[str, str] = {"thread_root_event_id": root_id}
-        if isinstance(reply_to := getattr(event, "event_id", None), str) and reply_to:
-            meta["thread_reply_to_event_id"] = reply_to
-        return meta
-
-    @staticmethod
-    def _build_thread_relates_to(metadata: dict[str, Any] | None) -> dict[str, Any] | None:
-        if not metadata:
-            return None
-        root_id = metadata.get("thread_root_event_id")
-        if not isinstance(root_id, str) or not root_id:
-            return None
-        reply_to = metadata.get("thread_reply_to_event_id") or metadata.get("event_id")
-        if not isinstance(reply_to, str) or not reply_to:
-            return None
-        return {"rel_type": "m.thread", "event_id": root_id,
-                "m.in_reply_to": {"event_id": reply_to}, "is_falling_back": True}
-
-    def _event_attachment_type(self, event: MatrixMediaEvent) -> str:
-        msgtype = self._event_source_content(event).get("msgtype")
-        return _MSGTYPE_MAP.get(msgtype, "file")
-
-    @staticmethod
-    def _is_encrypted_media_event(event: MatrixMediaEvent) -> bool:
-        return (isinstance(getattr(event, "key", None), dict)
-                and isinstance(getattr(event, "hashes", None), dict)
-                and isinstance(getattr(event, "iv", None), str))
-
-    def _event_declared_size_bytes(self, event: MatrixMediaEvent) -> int | None:
-        info = self._event_source_content(event).get("info")
-        size = info.get("size") if isinstance(info, dict) else None
-        return size if isinstance(size, int) and size >= 0 else None
-
-    def _event_mime(self, event: MatrixMediaEvent) -> str | None:
-        info = self._event_source_content(event).get("info")
-        if isinstance(info, dict) and isinstance(m := info.get("mimetype"), str) and m:
-            return m
-        m = getattr(event, "mimetype", None)
-        return m if isinstance(m, str) and m else None
-
-    def _event_filename(self, event: MatrixMediaEvent, attachment_type: str) -> str:
-        body = getattr(event, "body", None)
-        if isinstance(body, str) and body.strip():
-            if candidate := safe_filename(Path(body).name):
-                return candidate
-        return _DEFAULT_ATTACH_NAME if attachment_type == "file" else attachment_type
-
-    def _build_attachment_path(self, event: MatrixMediaEvent, attachment_type: str,
-                               filename: str, mime: str | None) -> Path:
-        safe_name = safe_filename(Path(filename).name) or _DEFAULT_ATTACH_NAME
-        suffix = Path(safe_name).suffix
-        if not suffix and mime:
-            if guessed := mimetypes.guess_extension(mime, strict=False):
-                safe_name, suffix = f"{safe_name}{guessed}", guessed
-        stem = (Path(safe_name).stem or attachment_type)[:72]
-        suffix = suffix[:16]
-        event_id = safe_filename(str(getattr(event, "event_id", "") or "evt").lstrip("$"))
-        event_prefix = (event_id[:24] or "evt").strip("_")
-        return self._media_dir() / f"{event_prefix}_{stem}{suffix}"
-
-    async def _download_media_bytes(self, mxc_url: str) -> bytes | None:
-        if not self.client:
-            return None
-        response = await self.client.download(mxc=mxc_url)
-        if isinstance(response, DownloadError):
-            logger.warning("Matrix download failed for {}: {}", mxc_url, response)
-            return None
-        body = getattr(response, "body", None)
-        if isinstance(body, (bytes, bytearray)):
-            return bytes(body)
-        if isinstance(response, MemoryDownloadResponse):
-            return bytes(response.body)
-        if isinstance(body, (str, Path)):
-            path = Path(body)
-            if path.is_file():
-                try:
-                    return path.read_bytes()
-                except OSError:
-                    return None
-        return None
-
-    def _decrypt_media_bytes(self, event: MatrixMediaEvent, ciphertext: bytes) -> bytes | None:
-        key_obj, hashes, iv = getattr(event, "key", None), getattr(event, "hashes", None), getattr(event, "iv", None)
-        key = key_obj.get("k") if isinstance(key_obj, dict) else None
-        sha256 = hashes.get("sha256") if isinstance(hashes, dict) else None
-        if not all(isinstance(v, str) for v in (key, sha256, iv)):
-            return None
-        try:
-            return decrypt_attachment(ciphertext, key, sha256, iv)
-        except (EncryptionError, ValueError, TypeError):
-            logger.warning("Matrix decrypt failed for event {}", getattr(event, "event_id", ""))
-            return None
-
-    async def _fetch_media_attachment(
-        self, room: MatrixRoom, event: MatrixMediaEvent,
-    ) -> tuple[dict[str, Any] | None, str]:
-        """Download, decrypt if needed, and persist a Matrix attachment."""
-        atype = self._event_attachment_type(event)
-        mime = self._event_mime(event)
-        filename = self._event_filename(event, atype)
-        mxc_url = getattr(event, "url", None)
-        fail = _ATTACH_FAILED.format(filename)
-
-        if not isinstance(mxc_url, str) or not mxc_url.startswith("mxc://"):
-            return None, fail
-
-        limit_bytes = await self._effective_media_limit_bytes()
-        declared = self._event_declared_size_bytes(event)
-        if declared is not None and declared > limit_bytes:
-            return None, _ATTACH_TOO_LARGE.format(filename)
-
-        downloaded = await self._download_media_bytes(mxc_url)
-        if downloaded is None:
-            return None, fail
-
-        encrypted = self._is_encrypted_media_event(event)
-        data = downloaded
-        if encrypted:
-            if (data := self._decrypt_media_bytes(event, downloaded)) is None:
-                return None, fail
-
-        if len(data) > limit_bytes:
-            return None, _ATTACH_TOO_LARGE.format(filename)
-
-        path = self._build_attachment_path(event, atype, filename, mime)
-        try:
-            path.write_bytes(data)
-        except OSError:
-            return None, fail
-
-        attachment = {
-            "type": atype, "mime": mime, "filename": filename,
-            "event_id": str(getattr(event, "event_id", "") or ""),
-            "encrypted": encrypted, "size_bytes": len(data),
-            "path": str(path), "mxc_url": mxc_url,
-        }
-        return attachment, _ATTACH_MARKER.format(path)
-
-    def _base_metadata(self, room: MatrixRoom, event: RoomMessage) -> dict[str, Any]:
-        """Build common metadata for text and media handlers."""
-        meta: dict[str, Any] = {"room": getattr(room, "display_name", room.room_id)}
-        if isinstance(eid := getattr(event, "event_id", None), str) and eid:
-            meta["event_id"] = eid
-        if thread := self._thread_metadata(event):
-            meta.update(thread)
-        return meta
-
-    async def _on_message(self, room: MatrixRoom, event: RoomMessageText) -> None:
-        if event.sender == self.config.user_id or not self._should_process_message(room, event):
-            return
-        await self._start_typing_keepalive(room.room_id)
-        try:
-            await self._handle_message(
-                sender_id=event.sender, chat_id=room.room_id,
-                content=event.body, metadata=self._base_metadata(room, event),
-            )
-        except Exception:
-            await self._stop_typing_keepalive(room.room_id, clear_typing=True)
-            raise
-
-    async def _on_media_message(self, room: MatrixRoom, event: MatrixMediaEvent) -> None:
-        if event.sender == self.config.user_id or not self._should_process_message(room, event):
-            return
-        attachment, marker = await self._fetch_media_attachment(room, event)
-        parts: list[str] = []
-        if isinstance(body := getattr(event, "body", None), str) and body.strip():
-            parts.append(body.strip())
-        parts.append(marker)
-
-        await self._start_typing_keepalive(room.room_id)
-        try:
-            meta = self._base_metadata(room, event)
-            if attachment:
-                meta["attachments"] = [attachment]
-            await self._handle_message(
-                sender_id=event.sender, chat_id=room.room_id,
-                content="\n".join(parts),
-                media=[attachment["path"]] if attachment else [],
-                metadata=meta,
-            )
-        except Exception:
-            await self._stop_typing_keepalive(room.room_id, clear_typing=True)
-            raise
@@ -322,7 +322,7 @@ class MochatChannel(BaseChannel):
                await self._api_send("/api/claw/sessions/send", "sessionId", target.id,
                                     content, msg.reply_to)
        except Exception as e:
-            logger.error("Failed to send Mochat message: {}", e)
+            logger.error(f"Failed to send Mochat message: {e}")

    # ---- config / init helpers ---------------------------------------------

@@ -380,7 +380,7 @@ class MochatChannel(BaseChannel):

        @client.event
        async def connect_error(data: Any) -> None:
-            logger.error("Mochat websocket connect error: {}", data)
+            logger.error(f"Mochat websocket connect error: {data}")

        @client.on("claw.session.events")
        async def on_session_events(payload: dict[str, Any]) -> None:
@@ -407,7 +407,7 @@ class MochatChannel(BaseChannel):
            )
            return True
        except Exception as e:
-            logger.error("Failed to connect Mochat websocket: {}", e)
+            logger.error(f"Failed to connect Mochat websocket: {e}")
            try:
                await client.disconnect()
            except Exception:
@@ -444,7 +444,7 @@ class MochatChannel(BaseChannel):
            "limit": self.config.watch_limit,
        })
        if not ack.get("result"):
-            logger.error("Mochat subscribeSessions failed: {}", ack.get('message', 'unknown error'))
+            logger.error(f"Mochat subscribeSessions failed: {ack.get('message', 'unknown error')}")
            return False

        data = ack.get("data")
@@ -466,7 +466,7 @@ class MochatChannel(BaseChannel):
            return True
        ack = await self._socket_call("com.claw.im.subscribePanels", {"panelIds": panel_ids})
        if not ack.get("result"):
-            logger.error("Mochat subscribePanels failed: {}", ack.get('message', 'unknown error'))
+            logger.error(f"Mochat subscribePanels failed: {ack.get('message', 'unknown error')}")
            return False
        return True

@@ -488,7 +488,7 @@ class MochatChannel(BaseChannel):
            try:
                await self._refresh_targets(subscribe_new=self._ws_ready)
            except Exception as e:
-                logger.warning("Mochat refresh failed: {}", e)
+                logger.warning(f"Mochat refresh failed: {e}")
            if self._fallback_mode:
                await self._ensure_fallback_workers()

@@ -502,7 +502,7 @@ class MochatChannel(BaseChannel):
        try:
            response = await self._post_json("/api/claw/sessions/list", {})
        except Exception as e:
-            logger.warning("Mochat listSessions failed: {}", e)
+            logger.warning(f"Mochat listSessions failed: {e}")
            return

        sessions = response.get("sessions")
@@ -536,7 +536,7 @@ class MochatChannel(BaseChannel):
        try:
            response = await self._post_json("/api/claw/groups/get", {})
        except Exception as e:
-            logger.warning("Mochat getWorkspaceGroup failed: {}", e)
+            logger.warning(f"Mochat getWorkspaceGroup failed: {e}")
            return

        raw_panels = response.get("panels")
@@ -598,7 +598,7 @@ class MochatChannel(BaseChannel):
            except asyncio.CancelledError:
                break
            except Exception as e:
-                logger.warning("Mochat watch fallback error ({}): {}", session_id, e)
+                logger.warning(f"Mochat watch fallback error ({session_id}): {e}")
                await asyncio.sleep(max(0.1, self.config.retry_delay_ms / 1000.0))

    async def _panel_poll_worker(self, panel_id: str) -> None:
@@ -625,7 +625,7 @@ class MochatChannel(BaseChannel):
            except asyncio.CancelledError:
                break
            except Exception as e:
-                logger.warning("Mochat panel polling error ({}): {}", panel_id, e)
+                logger.warning(f"Mochat panel polling error ({panel_id}): {e}")
            await asyncio.sleep(sleep_s)

    # ---- inbound event processing ------------------------------------------
@@ -836,7 +836,7 @@ class MochatChannel(BaseChannel):
        try:
            data = json.loads(self._cursor_path.read_text("utf-8"))
        except Exception as e:
-            logger.warning("Failed to read Mochat cursor file: {}", e)
+            logger.warning(f"Failed to read Mochat cursor file: {e}")
            return
        cursors = data.get("cursors") if isinstance(data, dict) else None
        if isinstance(cursors, dict):
@@ -852,7 +852,7 @@ class MochatChannel(BaseChannel):
                "cursors": self._session_cursor,
            }, ensure_ascii=False, indent=2) + "\n", "utf-8")
        except Exception as e:
-            logger.warning("Failed to save Mochat cursor file: {}", e)
+            logger.warning(f"Failed to save Mochat cursor file: {e}")

    # ---- HTTP helpers ------------------------------------------------------

@@ -34,7 +34,7 @@ def _make_bot_class(channel: "QQChannel") -> "type[botpy.Client]":
            super().__init__(intents=intents)

        async def on_ready(self):
-            logger.info("QQ bot ready: {}", self.robot.name)
+            logger.info(f"QQ bot ready: {self.robot.name}")

        async def on_c2c_message_create(self, message: "C2CMessage"):
            await channel._on_message(message)
@@ -55,6 +55,7 @@ class QQChannel(BaseChannel):
        self.config: QQConfig = config
        self._client: "botpy.Client | None" = None
        self._processed_ids: deque = deque(maxlen=1000)
+        self._bot_task: asyncio.Task | None = None

    async def start(self) -> None:
        """Start the QQ bot."""
@@ -70,8 +71,8 @@ class QQChannel(BaseChannel):
        BotClass = _make_bot_class(self)
        self._client = BotClass()

+        self._bot_task = asyncio.create_task(self._run_bot())
        logger.info("QQ bot started (C2C private message)")
-        await self._run_bot()

    async def _run_bot(self) -> None:
        """Run the bot connection with auto-reconnect."""
@@ -79,7 +80,7 @@ class QQChannel(BaseChannel):
            try:
                await self._client.start(appid=self.config.app_id, secret=self.config.secret)
            except Exception as e:
-                logger.warning("QQ bot error: {}", e)
+                logger.warning(f"QQ bot error: {e}")
            if self._running:
                logger.info("Reconnecting QQ bot in 5 seconds...")
                await asyncio.sleep(5)
@@ -87,10 +88,11 @@ class QQChannel(BaseChannel):
    async def stop(self) -> None:
        """Stop the QQ bot."""
        self._running = False
-        if self._client:
+        if self._bot_task:
+            self._bot_task.cancel()
            try:
-                await self._client.close()
-            except Exception:
+                await self._bot_task
+            except asyncio.CancelledError:
                pass
        logger.info("QQ bot stopped")

@@ -106,7 +108,7 @@ class QQChannel(BaseChannel):
                content=msg.content,
            )
        except Exception as e:
-            logger.error("Error sending QQ message: {}", e)
+            logger.error(f"Error sending QQ message: {e}")

    async def _on_message(self, data: "C2CMessage") -> None:
        """Handle incoming message from QQ."""
@@ -128,5 +130,5 @@ class QQChannel(BaseChannel):
                content=content,
                metadata={"message_id": data.id},
            )
-        except Exception:
-            logger.exception("Error handling QQ message")
+        except Exception as e:
+            logger.error(f"Error handling QQ message: {e}")
@@ -10,8 +10,6 @@ from slack_sdk.socket_mode.request import SocketModeRequest
 from slack_sdk.socket_mode.response import SocketModeResponse
 from slack_sdk.web.async_client import AsyncWebClient

-from slackify_markdown import slackify_markdown
-
 from nanobot.bus.events import OutboundMessage
 from nanobot.bus.queue import MessageBus
 from nanobot.channels.base import BaseChannel
@@ -36,7 +34,7 @@ class SlackChannel(BaseChannel):
            logger.error("Slack bot/app token not configured")
            return
        if self.config.mode != "socket":
-            logger.error("Unsupported Slack mode: {}", self.config.mode)
+            logger.error(f"Unsupported Slack mode: {self.config.mode}")
            return

        self._running = True
@@ -53,9 +51,9 @@ class SlackChannel(BaseChannel):
        try:
            auth = await self._web_client.auth_test()
            self._bot_user_id = auth.get("user_id")
-            logger.info("Slack bot connected as {}", self._bot_user_id)
+            logger.info(f"Slack bot connected as {self._bot_user_id}")
        except Exception as e:
-            logger.warning("Slack auth_test failed: {}", e)
+            logger.warning(f"Slack auth_test failed: {e}")

        logger.info("Starting Slack Socket Mode client...")
        await self._socket_client.connect()
@@ -70,7 +68,7 @@ class SlackChannel(BaseChannel):
            try:
                await self._socket_client.close()
            except Exception as e:
-                logger.warning("Slack socket close failed: {}", e)
+                logger.warning(f"Slack socket close failed: {e}")
            self._socket_client = None

    async def send(self, msg: OutboundMessage) -> None:
@@ -84,26 +82,13 @@ class SlackChannel(BaseChannel):
            channel_type = slack_meta.get("channel_type")
            # Only reply in thread for channel/group messages; DMs don't use threads
            use_thread = thread_ts and channel_type != "im"
-            thread_ts_param = thread_ts if use_thread else None
-
-            if msg.content:
-                await self._web_client.chat_postMessage(
-                    channel=msg.chat_id,
-                    text=self._to_mrkdwn(msg.content),
-                    thread_ts=thread_ts_param,
-                )
-
-            for media_path in msg.media or []:
-                try:
-                    await self._web_client.files_upload_v2(
-                        channel=msg.chat_id,
-                        file=media_path,
-                        thread_ts=thread_ts_param,
-                    )
-                except Exception as e:
-                    logger.error("Failed to upload file {}: {}", media_path, e)
+            await self._web_client.chat_postMessage(
+                channel=msg.chat_id,
+                text=msg.content or "",
+                thread_ts=thread_ts if use_thread else None,
+            )
        except Exception as e:
-            logger.error("Error sending Slack message: {}", e)
+            logger.error(f"Error sending Slack message: {e}")

    async def _on_socket_request(
        self,
@@ -165,39 +150,30 @@ class SlackChannel(BaseChannel):

        text = self._strip_bot_mention(text)

-        thread_ts = event.get("thread_ts")
-        if self.config.reply_in_thread and not thread_ts:
-            thread_ts = event.get("ts")
+        thread_ts = event.get("thread_ts") or event.get("ts")
        # Add :eyes: reaction to the triggering message (best-effort)
        try:
            if self._web_client and event.get("ts"):
                await self._web_client.reactions_add(
                    channel=chat_id,
-                    name=self.config.react_emoji,
+                    name="eyes",
                    timestamp=event.get("ts"),
                )
        except Exception as e:
-            logger.debug("Slack reactions_add failed: {}", e)
+            logger.debug(f"Slack reactions_add failed: {e}")

-        # Thread-scoped session key for channel/group messages
-        session_key = f"slack:{chat_id}:{thread_ts}" if thread_ts and channel_type != "im" else None
-
-        try:
-            await self._handle_message(
-                sender_id=sender_id,
-                chat_id=chat_id,
-                content=text,
-                metadata={
-                    "slack": {
-                        "event": event,
-                        "thread_ts": thread_ts,
-                        "channel_type": channel_type,
-                    },
-                },
-                session_key=session_key,
-            )
-        except Exception:
-            logger.exception("Error handling Slack message from {}", sender_id)
+        await self._handle_message(
+            sender_id=sender_id,
+            chat_id=chat_id,
+            content=text,
+            metadata={
+                "slack": {
+                    "event": event,
+                    "thread_ts": thread_ts,
+                    "channel_type": channel_type,
+                }
+            },
+        )

    def _is_allowed(self, sender_id: str, chat_id: str, channel_type: str) -> bool:
        if channel_type == "im":
@@ -227,55 +203,3 @@ class SlackChannel(BaseChannel):
        if not text or not self._bot_user_id:
            return text
        return re.sub(rf"<@{re.escape(self._bot_user_id)}>\s*", "", text).strip()
-
-    _TABLE_RE = re.compile(r"(?m)^\|.*\|$(?:\n\|[\s:|-]*\|$)(?:\n\|.*\|$)*")
-    _CODE_FENCE_RE = re.compile(r"```[\s\S]*?```")
-    _INLINE_CODE_RE = re.compile(r"`[^`]+`")
-    _LEFTOVER_BOLD_RE = re.compile(r"\*\*(.+?)\*\*")
-    _LEFTOVER_HEADER_RE = re.compile(r"^#{1,6}\s+(.+)$", re.MULTILINE)
-    _BARE_URL_RE = re.compile(r"(?<![|<])(https?://\S+)")
-
-    @classmethod
-    def _to_mrkdwn(cls, text: str) -> str:
-        """Convert Markdown to Slack mrkdwn, including tables."""
-        if not text:
-            return ""
-        text = cls._TABLE_RE.sub(cls._convert_table, text)
-        return cls._fixup_mrkdwn(slackify_markdown(text))
-
-    @classmethod
-    def _fixup_mrkdwn(cls, text: str) -> str:
-        """Fix markdown artifacts that slackify_markdown misses."""
-        code_blocks: list[str] = []
-
-        def _save_code(m: re.Match) -> str:
-            code_blocks.append(m.group(0))
-            return f"\x00CB{len(code_blocks) - 1}\x00"
-
-        text = cls._CODE_FENCE_RE.sub(_save_code, text)
-        text = cls._INLINE_CODE_RE.sub(_save_code, text)
-        text = cls._LEFTOVER_BOLD_RE.sub(r"*\1*", text)
-        text = cls._LEFTOVER_HEADER_RE.sub(r"*\1*", text)
-        text = cls._BARE_URL_RE.sub(lambda m: m.group(0).replace("&amp;", "&"), text)
-
-        for i, block in enumerate(code_blocks):
-            text = text.replace(f"\x00CB{i}\x00", block)
-        return text
-
-    @staticmethod
-    def _convert_table(match: re.Match) -> str:
-        """Convert a Markdown table to a Slack-readable list."""
-        lines = [ln.strip() for ln in match.group(0).strip().splitlines() if ln.strip()]
-        if len(lines) < 2:
-            return match.group(0)
-        headers = [h.strip() for h in lines[0].strip("|").split("|")]
-        start = 2 if re.fullmatch(r"[|\s:\-]+", lines[1]) else 1
-        rows: list[str] = []
-        for line in lines[start:]:
-            cells = [c.strip() for c in line.strip("|").split("|")]
-            cells = (cells + [""] * len(headers))[: len(headers)]
-            parts = [f"**{headers[i]}**: {cells[i]}" for i in range(len(headers)) if cells[i]]
-            if parts:
-                rows.append(" · ".join(parts))
-        return "\n".join(rows)
-
@@ -4,8 +4,6 @@ from __future__ import annotations

 import asyncio
 import re
-from pathlib import Path
-
 from loguru import logger
 from telegram import BotCommand, Update
 from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
@@ -187,241 +185,33 @@ class TelegramChannel(BaseChannel):
        if not self._app:
            logger.warning("Telegram bot not running")
            return
-
+        
        # Stop typing indicator for this chat
        self._stop_typing(msg.chat_id)
-
-        # Check for suppression
-        if msg.metadata.get("suppressed", False):
-            logger.debug(f"Suppressed output (not sent to Telegram): {msg.content[:100]}...")
-            return  # Don't send to Telegram API
        
        try:
            # chat_id should be the Telegram chat ID (integer)
            chat_id = int(msg.chat_id)
            # Convert markdown to Telegram HTML
            html_content = _markdown_to_telegram_html(msg.content)
-
-            # Check if message has media attachments
-            if msg.media:
-                await self._send_with_media(chat_id, html_content, msg.media)
-            else:
-                # Text-only message - split if too long
-                await self._send_text_chunks(chat_id, html_content, parse_mode="HTML")
+            await self._app.bot.send_message(
+                chat_id=chat_id,
+                text=html_content,
+                parse_mode="HTML"
+            )
        except ValueError:
            logger.error(f"Invalid chat_id: {msg.chat_id}")
        except Exception as e:
            # Fallback to plain text if HTML parsing fails
            logger.warning(f"HTML parse failed, falling back to plain text: {e}")
            try:
-                await self._send_text_chunks(int(msg.chat_id), msg.content, parse_mode=None)
+                await self._app.bot.send_message(
+                    chat_id=int(msg.chat_id),
+                    text=msg.content
+                )
            except Exception as e2:
                logger.error(f"Error sending Telegram message: {e2}")
-
-    @staticmethod
-    def _split_message(content: str, max_len: int = 4000) -> list[str]:
-        """Split content into chunks within max_len, preferring line breaks.
-
-        From upstream HKUDS/nanobot - battle-tested implementation.
-        Uses 4000 char limit (safer than 4096) with split priority: \n → space → hard cut.
-        """
-        if len(content) <= max_len:
-            return [content]
-        chunks: list[str] = []
-        while content:
-            if len(content) <= max_len:
-                chunks.append(content)
-                break
-            cut = content[:max_len]
-            pos = cut.rfind('\n')
-            if pos == -1:
-                pos = cut.rfind(' ')
-            if pos == -1:
-                pos = max_len
-            chunks.append(content[:pos])
-            content = content[pos:].lstrip()
-        return chunks
-
-    async def _send_text_chunks(
-        self,
-        chat_id: int,
-        text: str,
-        parse_mode: str | None = "HTML"
-    ) -> None:
-        """Split and send long messages.
-
-        Telegram has a 4096 character limit per message.
-        Uses upstream's proven implementation - splits at line breaks, then spaces.
-        """
-        chunks = self._split_message(text)
-
-        for chunk in chunks:
-            await self._app.bot.send_message(
-                chat_id=chat_id,
-                text=chunk.strip(),
-                parse_mode=parse_mode
-            )
-
-    async def _send_with_media(self, chat_id: int, caption: str, media_paths: list[str]) -> None:
-        """
-        Send message with media attachments.
-
-        Args:
-            chat_id: Telegram chat ID
-            caption: Message caption
-            media_paths: List of file paths or URLs
-        """
-        from telegram import InputMediaPhoto, InputMediaVideo
-
-        from nanobot.channels.telegram_media import (
-            MediaKind,
-            classify_media,
-            detect_mime,
-            fetch_media,
-            group_media_for_album,
-            optimize_image,
-        )
-
-        # Process each media item
-        processed_media: list[tuple[str, MediaKind, bytes, str]] = []
-
-        for path in media_paths:
-            try:
-                # Fetch remote URLs
-                if path.startswith(("http://", "https://")):
-                    content, mime = await fetch_media(path, max_bytes=100_000_000)
-                    kind = classify_media(mime)
-                    # Extract filename from URL
-                    filename = Path(path).name
-                else:
-                    # Local file
-                    file_path = Path(path)
-                    if not file_path.exists():
-                        logger.warning(f"Media file not found: {path}")
-                        continue
-
-                    with open(file_path, "rb") as f:
-                        content = f.read()
-
-                    mime = detect_mime(path, content)
-                    kind = classify_media(mime)
-                    # Extract filename from local path
-                    filename = file_path.name
-
-                    # Optimize images
-                    if kind == MediaKind.IMAGE:
-                        try:
-                            content = optimize_image(path, max_bytes=6_000_000)
-                        except Exception as e:
-                            logger.warning(f"Image optimization failed: {e}, sending original")
-
-                processed_media.append((path, kind, content, filename))
-
-            except Exception as e:
-                logger.error(f"Failed to process media {path}: {e}")
-                continue
-
-        if not processed_media:
-            # No media could be processed, send text only
-            await self._app.bot.send_message(
-                chat_id=chat_id,
-                text=caption,
-                parse_mode="HTML"
-            )
-            return
-
-        # Group media for album sending
-        media_items = [(path, kind) for path, kind, _, _ in processed_media]
-        grouping = group_media_for_album(media_items)
-
-        # Handle caption length (Telegram limit: 1024 chars)
-        if len(caption) > 1024:
-            # Send media without caption, then follow-up text
-            media_caption = None
-            followup_text = caption
-        else:
-            media_caption = caption
-            followup_text = None
-
-        # Send album if grouped
-        if grouping["album"]:
-            album_paths = grouping["album"]
-            album_media = []
-
-            for path, kind, content, filename in processed_media:
-                if path not in album_paths:
-                    continue
-
-                if kind == MediaKind.IMAGE:
-                    media_obj = InputMediaPhoto(
-                        media=content,
-                        caption=media_caption if len(album_media) == 0 else None,
-                        parse_mode="HTML" if media_caption else None
-                    )
-                elif kind == MediaKind.VIDEO:
-                    media_obj = InputMediaVideo(
-                        media=content,
-                        caption=media_caption if len(album_media) == 0 else None,
-                        parse_mode="HTML" if media_caption else None
-                    )
-                else:
-                    continue  # Skip non-album types
-
-                album_media.append(media_obj)
-
-            if album_media:
-                await self._app.bot.send_media_group(
-                    chat_id=chat_id,
-                    media=album_media
-                )
-
-        # Send separate media
-        for i, (path, kind, content, filename) in enumerate(processed_media):
-            if path in grouping["album"]:
-                continue  # Already sent in album
-
-            # Only first separate item gets caption
-            item_caption = media_caption if i == 0 else None
-
-            if kind == MediaKind.IMAGE:
-                await self._app.bot.send_photo(
-                    chat_id=chat_id,
-                    photo=content,
-                    caption=item_caption,
-                    parse_mode="HTML" if item_caption else None
-                )
-            elif kind == MediaKind.VIDEO:
-                await self._app.bot.send_video(
-                    chat_id=chat_id,
-                    video=content,
-                    caption=item_caption,
-                    parse_mode="HTML" if item_caption else None
-                )
-            elif kind == MediaKind.AUDIO:
-                await self._app.bot.send_audio(
-                    chat_id=chat_id,
-                    audio=content,
-                    caption=item_caption,
-                    parse_mode="HTML" if item_caption else None,
-                    filename=filename
-                )
-            elif kind == MediaKind.DOCUMENT:
-                await self._app.bot.send_document(
-                    chat_id=chat_id,
-                    document=content,
-                    caption=item_caption,
-                    parse_mode="HTML" if item_caption else None,
-                    filename=filename
-                )
-
-        # Send follow-up text if caption was too long
-        if followup_text:
-            await self._app.bot.send_message(
-                chat_id=chat_id,
-                text=followup_text,
-                parse_mode="HTML"
-            )
-
+    
    async def _on_start(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
        """Handle /start command."""
        if not update.message or not update.effective_user:
@@ -1,286 +0,0 @@
-"""Media handling utilities for Telegram channel."""
-
-from __future__ import annotations
-
-import io
-import mimetypes
-from enum import Enum
-from pathlib import Path
-
-import httpx
-from loguru import logger
-from PIL import Image
-
-# Telegram API photo size limit (6MB)
-TELEGRAM_PHOTO_SIZE_LIMIT = 6_000_000
-
-try:
-    import magic
-    HAS_MAGIC = True
-except ImportError:
-    HAS_MAGIC = False
-
-try:
-    from pillow_heif import register_heif_opener
-    register_heif_opener()
-    HAS_HEIF = True
-except ImportError:
-    HAS_HEIF = False
-
-
-class MediaKind(Enum):
-    """Media type classification."""
-    IMAGE = "image"
-    VIDEO = "video"
-    AUDIO = "audio"
-    DOCUMENT = "document"
-
-
-def detect_mime(path: str, content: bytes | None = None) -> str:
-    """
-    Detect MIME type of media file.
-
-    Priority:
-    1. python-magic sniff (if available and content provided)
-    2. Extension-based lookup
-    3. Fallback to application/octet-stream
-
-    Args:
-        path: File path (used for extension detection)
-        content: Optional file content bytes for magic sniffing
-
-    Returns:
-        MIME type string (e.g., "image/jpeg")
-    """
-    # Try magic detection first if we have content
-    if HAS_MAGIC and content:
-        try:
-            mime = magic.from_buffer(content, mime=True)
-            # Avoid generic types if we can be more specific from extension
-            if mime and mime != "application/octet-stream":
-                return mime
-        except Exception as e:
-            logger.debug(f"Magic detection failed, falling back to extension: {e}")
-
-    # Extension-based detection
-    mime_type, _ = mimetypes.guess_type(path)
-    if mime_type:
-        return mime_type
-
-    # Fallback
-    return "application/octet-stream"
-
-
-def classify_media(mime: str) -> MediaKind:
-    """
-    Classify MIME type into media kind.
-
-    Args:
-        mime: MIME type string (e.g., "image/jpeg")
-
-    Returns:
-        MediaKind enum value
-    """
-    if mime.startswith("image/"):
-        return MediaKind.IMAGE
-    if mime.startswith("video/"):
-        return MediaKind.VIDEO
-    if mime.startswith("audio/"):
-        return MediaKind.AUDIO
-    # Everything else is a document
-    return MediaKind.DOCUMENT
-
-
-def is_heic_format(path: str) -> bool:
-    """
-    Check if file is HEIC/HEIF format.
-
-    Args:
-        path: File path
-
-    Returns:
-        True if file extension is .heic or .heif
-    """
-    ext = Path(path).suffix.lower()
-    return ext in (".heic", ".heif")
-
-
-async def fetch_media(url: str, max_bytes: int) -> tuple[bytes, str]:
-    """
-    Download media from remote URL.
-
-    Args:
-        url: Remote URL to fetch
-        max_bytes: Maximum size to download
-
-    Returns:
-        Tuple of (content bytes, detected MIME type)
-
-    Raises:
-        ValueError: If download fails or exceeds size limit
-    """
-    try:
-        async with httpx.AsyncClient(timeout=10.0) as client:
-            response = await client.get(url, follow_redirects=True)
-            response.raise_for_status()
-
-            content = response.content
-
-            if len(content) > max_bytes:
-                raise ValueError(f"Media exceeds size limit: {len(content)} > {max_bytes}")
-
-            # Get MIME type from response or detect
-            mime = response.headers.get("content-type", "application/octet-stream")
-            # Strip charset if present (e.g., "image/jpeg; charset=utf-8" → "image/jpeg")
-            mime = mime.split(";")[0].strip()
-
-            # Detect from content if generic type
-            if mime == "application/octet-stream":
-                mime = detect_mime(url, content)
-
-            return content, mime
-
-    except httpx.TimeoutException as e:
-        raise ValueError(f"Download timeout: {url}") from e
-    except httpx.HTTPError as e:
-        raise ValueError(f"Download failed: {url}: {e}") from e
-
-
-def optimize_image(path: str, max_bytes: int = TELEGRAM_PHOTO_SIZE_LIMIT) -> bytes:
-    """
-    Optimize image to fit under size limit.
-
-    Strategy:
-    1. Convert HEIC to JPEG if needed
-    2. PNG with alpha → preserve with compression levels [6,7,8,9]
-    3. JPEG/PNG without alpha → resize + quality grid
-
-    Sizes: [2048, 1536, 1280, 1024, 800] px (max dimension)
-    Qualities: [80, 70, 60, 50, 40] (JPEG only)
-
-    Args:
-        path: Path to image file
-        max_bytes: Maximum size in bytes (default 6MB for Telegram)
-
-    Returns:
-        Optimized image bytes
-
-    Raises:
-        ValueError: If image cannot be optimized under limit
-    """
-    # Load image with context manager to ensure file handle is closed
-    with Image.open(path) as img:
-        # Convert HEIC to JPEG
-        if is_heic_format(path):
-            if not HAS_HEIF:
-                raise ValueError("pillow-heif not available for HEIC conversion")
-            # Convert to RGB (HEIC → JPEG)
-            if img.mode != "RGB":
-                img = img.convert("RGB")
-            return _optimize_jpeg(img, max_bytes)
-
-        # PNG with alpha channel - preserve it
-        if img.mode == "RGBA" or img.mode == "LA":
-            return _optimize_png(img, max_bytes)
-
-        # Everything else → convert to JPEG and optimize
-        if img.mode != "RGB":
-            img = img.convert("RGB")
-        return _optimize_jpeg(img, max_bytes)
-
-
-def _optimize_jpeg(img: Image.Image, max_bytes: int) -> bytes:
-    """Optimize JPEG with size/quality grid."""
-    sizes = [2048, 1536, 1280, 1024, 800]
-    qualities = [80, 70, 60, 50, 40]
-
-    for size in sizes:
-        # Always copy to avoid mutation issues
-        resized = img.copy()
-        if max(img.size) > size:
-            resized.thumbnail((size, size), Image.Resampling.LANCZOS)
-
-        for quality in qualities:
-            buf = io.BytesIO()
-            resized.save(buf, format="JPEG", quality=quality, optimize=True)
-            data = buf.getvalue()
-
-            if len(data) <= max_bytes:
-                return data
-
-    # If we get here, even smallest size/quality is too large
-    raise ValueError(f"Cannot optimize image under {max_bytes} bytes")
-
-
-def _optimize_png(img: Image.Image, max_bytes: int) -> bytes:
-    """Optimize PNG while preserving alpha channel."""
-    compress_levels = [6, 7, 8, 9]
-    sizes = [2048, 1536, 1280, 1024, 800]
-
-    for size in sizes:
-        # Always copy to avoid mutation issues
-        resized = img.copy()
-        if max(img.size) > size:
-            resized.thumbnail((size, size), Image.Resampling.LANCZOS)
-
-        for compress_level in compress_levels:
-            buf = io.BytesIO()
-            resized.save(buf, format="PNG", compress_level=compress_level, optimize=True)
-            data = buf.getvalue()
-
-            if len(data) <= max_bytes:
-                return data
-
-    # Fallback: try converting to JPEG if still too large
-    if img.mode in ("RGBA", "LA"):
-        # Create white background
-        background = Image.new("RGB", img.size, (255, 255, 255))
-        if img.mode == "RGBA":
-            background.paste(img, mask=img.split()[3])  # Use alpha as mask
-        else:  # LA (grayscale + alpha)
-            background.paste(img.convert("L"), mask=img.split()[1])
-        return _optimize_jpeg(background, max_bytes)
-
-    raise ValueError(f"Cannot optimize PNG under {max_bytes} bytes")
-
-
-def group_media_for_album(media_items: list[tuple[str, MediaKind]]) -> dict[str, list[str]]:
-    """
-    Group media items for album sending.
-
-    Logic:
-    - All images (2+) → album
-    - All videos (2+) → album
-    - Mixed types → separate
-    - Single item → separate
-
-    Args:
-        media_items: List of (path, MediaKind) tuples
-
-    Returns:
-        Dict with 'album' and 'separate' keys containing lists of paths
-    """
-    if len(media_items) <= 1:
-        return {
-            "album": [],
-            "separate": [path for path, _ in media_items]
-        }
-
-    # Count each kind
-    kinds = [kind for _, kind in media_items]
-    unique_kinds = set(kinds)
-
-    # All same type → album (if images or videos)
-    if len(unique_kinds) == 1:
-        kind = kinds[0]
-        if kind in (MediaKind.IMAGE, MediaKind.VIDEO):
-            return {
-                "album": [path for path, _ in media_items],
-                "separate": []
-            }
-
-    # Mixed types or non-album-able types → separate
-    return {
-        "album": [],
-        "separate": [path for path, _ in media_items]
-    }
@@ -34,7 +34,7 @@ class WhatsAppChannel(BaseChannel):
        
        bridge_url = self.config.bridge_url
        
-        logger.info("Connecting to WhatsApp bridge at {}...", bridge_url)
+        logger.info(f"Connecting to WhatsApp bridge at {bridge_url}...")
        
        self._running = True
        
@@ -53,14 +53,14 @@ class WhatsAppChannel(BaseChannel):
                        try:
                            await self._handle_bridge_message(message)
                        except Exception as e:
-                            logger.error("Error handling bridge message: {}", e)
+                            logger.error(f"Error handling bridge message: {e}")
                    
            except asyncio.CancelledError:
                break
            except Exception as e:
                self._connected = False
                self._ws = None
-                logger.warning("WhatsApp bridge connection error: {}", e)
+                logger.warning(f"WhatsApp bridge connection error: {e}")
                
                if self._running:
                    logger.info("Reconnecting in 5 seconds...")
@@ -87,16 +87,16 @@ class WhatsAppChannel(BaseChannel):
                "to": msg.chat_id,
                "text": msg.content
            }
-            await self._ws.send(json.dumps(payload, ensure_ascii=False))
+            await self._ws.send(json.dumps(payload))
        except Exception as e:
-            logger.error("Error sending WhatsApp message: {}", e)
+            logger.error(f"Error sending WhatsApp message: {e}")
    
    async def _handle_bridge_message(self, raw: str) -> None:
        """Handle a message from the bridge."""
        try:
            data = json.loads(raw)
        except json.JSONDecodeError:
-            logger.warning("Invalid JSON from bridge: {}", raw[:100])
+            logger.warning(f"Invalid JSON from bridge: {raw[:100]}")
            return
        
        msg_type = data.get("type")
@@ -112,11 +112,11 @@ class WhatsAppChannel(BaseChannel):
            # Extract just the phone number or lid as chat_id
            user_id = pn if pn else sender
            sender_id = user_id.split("@")[0] if "@" in user_id else user_id
-            logger.info("Sender {}", sender)
+            logger.info(f"Sender {sender}")
            
            # Handle voice transcription if it's a voice message
            if content == "[Voice Message]":
-                logger.info("Voice message received from {}, but direct download from bridge is not yet supported.", sender_id)
+                logger.info(f"Voice message received from {sender_id}, but direct download from bridge is not yet supported.")
                content = "[Voice Message: Transcription not available for WhatsApp yet]"
            
            await self._handle_message(
@@ -133,7 +133,7 @@ class WhatsAppChannel(BaseChannel):
        elif msg_type == "status":
            # Connection status update
            status = data.get("status")
-            logger.info("WhatsApp status: {}", status)
+            logger.info(f"WhatsApp status: {status}")
            
            if status == "connected":
                self._connected = True
@@ -145,4 +145,4 @@ class WhatsAppChannel(BaseChannel):
            logger.info("Scan QR code in the bridge terminal to connect WhatsApp")
        
        elif msg_type == "error":
-            logger.error("WhatsApp bridge error: {}", data.get('error'))
+            logger.error(f"WhatsApp bridge error: {data.get('error')}")
@@ -2,26 +2,23 @@

 import asyncio
 import os
-import select
 import signal
-import subprocess
-import sys
 from pathlib import Path
-from typing import Any
+import select
+import sys

 import typer
-from loguru import logger
-from prompt_toolkit import PromptSession
-from prompt_toolkit.formatted_text import HTML
-from prompt_toolkit.history import FileHistory
-from prompt_toolkit.patch_stdout import patch_stdout
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.table import Table
 from rich.text import Text

-from nanobot import __logo__, __version__
-from nanobot.cli.oauth import oauth_app
+from prompt_toolkit import PromptSession
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.patch_stdout import patch_stdout
+
+from nanobot import __version__, __logo__

 app = typer.Typer(
    name="nanobot",
@@ -161,26 +158,26 @@ def onboard():
    from nanobot.config.loader import get_config_path, save_config
    from nanobot.config.schema import Config
    from nanobot.utils.helpers import get_workspace_path
-
+    
    config_path = get_config_path()
-
+    
    if config_path.exists():
        console.print(f"[yellow]Config already exists at {config_path}[/yellow]")
        if not typer.confirm("Overwrite?"):
            raise typer.Exit()
-
+    
    # Create default config
    config = Config()
    save_config(config)
    console.print(f"[green]✓[/green] Created config at {config_path}")
-
+    
    # Create workspace
    workspace = get_workspace_path()
    console.print(f"[green]✓[/green] Created workspace at {workspace}")
-
+    
    # Create default bootstrap files
    _create_workspace_templates(workspace)
-
+    
    console.print(f"\n{__logo__} nanobot is ready!")
    console.print("\nNext steps:")
    console.print("  1. Add your API key to [cyan]~/.nanobot/config.json[/cyan]")
@@ -232,13 +229,13 @@ Information about the user goes here.
 - Language: (your preferred language)
 """,
    }
-
+    
    for filename, content in templates.items():
        file_path = workspace / filename
        if not file_path.exists():
            file_path.write_text(content)
            console.print(f"  [dim]Created {filename}[/dim]")
-
+    
    # Create memory directory and MEMORY.md
    memory_dir = workspace / "memory"
    memory_dir.mkdir(exist_ok=True)
@@ -261,7 +258,7 @@ This file stores important information that should persist across sessions.
 (Things to remember)
 """)
        console.print("  [dim]Created memory/MEMORY.md[/dim]")
-
+    
    history_file = memory_dir / "HISTORY.md"
    if not history_file.exists():
        history_file.write_text("")
@@ -296,81 +293,36 @@ def _make_provider(config):
 # ============================================================================


-def _start_moltbook_loop():
-    """Start the moltbook polling loop in the background."""
-    loop_script = Path.home() / ".nanobot" / "scripts" / "moltbook-loop.sh"
-    log_file = Path.home() / ".nanobot" / "scripts" / "moltbook-loop.log"
-
-    if not loop_script.exists():
-        return
-
-    try:
-        subprocess.Popen(
-            ["/bin/bash", str(loop_script)],
-            stdout=open(log_file, "a"),
-            stderr=subprocess.STDOUT,
-            start_new_session=True,
-        )
-        console.print(f"[green]✓[/green] Moltbook polling: every 15m")
-    except Exception as e:
-        console.print(f"[yellow]Warning: Could not start moltbook loop: {e}[/yellow]")
-
-
@app.command()
 def gateway(
    port: int = typer.Option(18790, "--port", "-p", help="Gateway port"),
    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
 ):
    """Start the nanobot gateway."""
-    from nanobot.agent.loop import AgentLoop
+    from nanobot.config.loader import load_config, get_data_dir
    from nanobot.bus.queue import MessageBus
+    from nanobot.agent.loop import AgentLoop
    from nanobot.channels.manager import ChannelManager
-    from nanobot.config.loader import get_data_dir, load_config
+    from nanobot.session.manager import SessionManager
    from nanobot.cron.service import CronService
    from nanobot.cron.types import CronJob
    from nanobot.heartbeat.service import HeartbeatService
-    from nanobot.session.manager import SessionManager
-
+    
    if verbose:
        import logging
        logging.basicConfig(level=logging.DEBUG)
-
+    
    console.print(f"{__logo__} Starting nanobot gateway on port {port}...")
-
+    
    config = load_config()
    bus = MessageBus()
    provider = _make_provider(config)
    session_manager = SessionManager(config.workspace_path)
-
+    
    # Create cron service first (callback set after agent creation)
    cron_store_path = get_data_dir() / "cron" / "jobs.json"
    cron = CronService(cron_store_path)
-
-    # Convert mem0 config to dict for AgentLoop
-    mem0_config = None
-    if config.tools.mem0.enabled:
-        mem0_config = {
-            "enabled": True,
-            "search_limit": config.tools.mem0.search_limit,
-        }
-        if config.tools.mem0.api_key:
-            mem0_config["api_key"] = config.tools.mem0.api_key
-        if config.tools.mem0.llm:
-            mem0_config["llm"] = {
-                "provider": "openai",
-                "config": {"model": config.tools.mem0.llm}
-            }
-        if config.tools.mem0.embedder:
-            mem0_config["embedder"] = {
-                "provider": "openai",
-                "config": {"model": config.tools.mem0.embedder}
-            }
-        if config.tools.mem0.vector_store:
-            mem0_config["vector_store"] = config.tools.mem0.vector_store
-
-        # DEBUG: Log what's being passed
-        logger.debug(f"Passing mem0_config to AgentLoop: {list(mem0_config.keys())}")
-
+    
    # Create agent with cron service
    agent = AgentLoop(
        bus=bus,
@@ -383,11 +335,9 @@ def gateway(
        exec_config=config.tools.exec,
        cron_service=cron,
        restrict_to_workspace=config.tools.restrict_to_workspace,
-        enable_memory_tool=config.tools.enable_memory_tool,
-        mem0_config=mem0_config,
        session_manager=session_manager,
    )
-
+    
    # Set cron callback (needs agent)
    async def on_cron_job(job: CronJob) -> str | None:
        """Execute a cron job through the agent."""
@@ -406,84 +356,48 @@ def gateway(
            ))
        return response
    cron.on_job = on_cron_job
-
+    
    # Create heartbeat service
-    async def on_heartbeat(prompt: str, metadata: dict[str, Any] | None = None) -> str:
+    async def on_heartbeat(prompt: str) -> str:
        """Execute heartbeat through the agent."""
-        return await agent.process_direct(
-            prompt,
-            session_key="telegram:239824268",  # Run in main telegram session
-            channel="telegram",
-            chat_id="239824268",
-            metadata=metadata,
-        )
-
+        return await agent.process_direct(prompt, session_key="heartbeat")
+    
    heartbeat = HeartbeatService(
        workspace=config.workspace_path,
        on_heartbeat=on_heartbeat,
        interval_s=30 * 60,  # 30 minutes
-        enabled=True,
-        session_manager=session_manager,  # Pass session manager
-        target_session_key="telegram:239824268",  # Target session
-        idle_threshold_s=20 * 60,  # 20 minutes idle
+        enabled=True
    )
-
+    
    # Create channel manager
    channels = ChannelManager(config, bus)
-
-    # Create hooks server
-    from nanobot.channels.hook import HookChannel
-    from nanobot.hooks.server import HooksServer
-
-    hooks_config = config.hooks if hasattr(config, 'hooks') else None
-    hooks_server = None
-
-    if hooks_config and hooks_config.enabled:
-        # Register hook channel
-        hook_channel = HookChannel(bus)
-        channels.register_channel("hook", hook_channel)
-
-        # Create hooks server (checks has_tokens internally)
-        hooks_server = HooksServer(
-            host=config.gateway.host,
-            port=config.gateway.port,
-            config=hooks_config,
-            bus=bus,
-        )
-        console.print(f"[green]✓[/green] Hooks: {hooks_config.path} on port {config.gateway.port}")
-
+    
    if channels.enabled_channels:
        console.print(f"[green]✓[/green] Channels enabled: {', '.join(channels.enabled_channels)}")
    else:
        console.print("[yellow]Warning: No channels enabled[/yellow]")
-
+    
    cron_status = cron.status()
    if cron_status["jobs"] > 0:
        console.print(f"[green]✓[/green] Cron: {cron_status['jobs']} scheduled jobs")
-
-    console.print("[green]✓[/green] Heartbeat: every 30m")
-
-    _start_moltbook_loop()
-
+    
+    console.print(f"[green]✓[/green] Heartbeat: every 30m")
+    
    async def run():
        try:
            await cron.start()
            await heartbeat.start()
-            if hooks_server:
-                await hooks_server.start()
            await asyncio.gather(
                agent.run(),
                channels.start_all(),
            )
        except KeyboardInterrupt:
            console.print("\nShutting down...")
-            if hooks_server:
-                await hooks_server.stop()
            heartbeat.stop()
            cron.stop()
            agent.stop()
            await channels.stop_all()
-
+    
    asyncio.run(run())


@@ -502,14 +416,13 @@ def agent(
    logs: bool = typer.Option(False, "--logs/--no-logs", help="Show nanobot runtime logs during chat"),
 ):
    """Interact with the agent directly."""
-    from loguru import logger
-
-    from nanobot.agent.loop import AgentLoop
-    from nanobot.bus.queue import MessageBus
    from nanobot.config.loader import load_config
-
+    from nanobot.bus.queue import MessageBus
+    from nanobot.agent.loop import AgentLoop
+    from loguru import logger
+    
    config = load_config()
-
+    
    bus = MessageBus()
    provider = _make_provider(config)

@@ -517,29 +430,7 @@ def agent(
        logger.enable("nanobot")
    else:
        logger.disable("nanobot")
-
-    # Convert mem0 config to dict for AgentLoop
-    mem0_config = None
-    if config.tools.mem0.enabled:
-        mem0_config = {
-            "enabled": True,
-            "search_limit": config.tools.mem0.search_limit,
-        }
-        if config.tools.mem0.api_key:
-            mem0_config["api_key"] = config.tools.mem0.api_key
-        if config.tools.mem0.llm:
-            mem0_config["llm"] = {
-                "provider": "openai",
-                "config": {"model": config.tools.mem0.llm}
-            }
-        if config.tools.mem0.embedder:
-            mem0_config["embedder"] = {
-                "provider": "openai",
-                "config": {"model": config.tools.mem0.embedder}
-            }
-        if config.tools.mem0.vector_store:
-            mem0_config["vector_store"] = config.tools.mem0.vector_store
-
+    
    agent_loop = AgentLoop(
        bus=bus,
        provider=provider,
@@ -550,10 +441,8 @@ def agent(
        brave_api_key=config.tools.web.search.api_key or None,
        exec_config=config.tools.exec,
        restrict_to_workspace=config.tools.restrict_to_workspace,
-        enable_memory_tool=config.tools.enable_memory_tool,
-        mem0_config=mem0_config,
    )
-
+    
    # Show spinner when logs are off (no output to miss); skip when logs are on
    def _thinking_ctx():
        if logs:
@@ -568,7 +457,7 @@ def agent(
            with _thinking_ctx():
                response = await agent_loop.process_direct(message, session_id)
            _print_agent_response(response, render_markdown=markdown)
-
+        
        asyncio.run(run_once())
    else:
        # Interactive mode
@@ -581,7 +470,7 @@ def agent(
            os._exit(0)

        signal.signal(signal.SIGINT, _exit_on_sigint)
-
+        
        async def run_interactive():
            while True:
                try:
@@ -595,7 +484,7 @@ def agent(
                        _restore_terminal()
                        console.print("\nGoodbye!")
                        break
-
+                    
                    with _thinking_ctx():
                        response = await agent_loop.process_direct(user_input, session_id)
                    _print_agent_response(response, render_markdown=markdown)
@@ -607,7 +496,7 @@ def agent(
                    _restore_terminal()
                    console.print("\nGoodbye!")
                    break
-
+        
        asyncio.run(run_interactive())


@@ -619,6 +508,7 @@ def agent(
 channels_app = typer.Typer(help="Manage channels")
 app.add_typer(channels_app, name="channels")

+from nanobot.cli.oauth import oauth_app
 app.add_typer(oauth_app, name="oauth")


@@ -666,7 +556,7 @@ def channels_status():
        "✓" if mc.enabled else "✗",
        mc_base
    )
-
+    
    # Telegram
    tg = config.channels.telegram
    tg_config = f"token: {tg.token[:10]}..." if tg.token else "[dim]not configured[/dim]"
@@ -692,57 +582,57 @@ def _get_bridge_dir() -> Path:
    """Get the bridge directory, setting it up if needed."""
    import shutil
    import subprocess
-
+    
    # User's bridge location
    user_bridge = Path.home() / ".nanobot" / "bridge"
-
+    
    # Check if already built
    if (user_bridge / "dist" / "index.js").exists():
        return user_bridge
-
+    
    # Check for npm
    if not shutil.which("npm"):
        console.print("[red]npm not found. Please install Node.js >= 18.[/red]")
        raise typer.Exit(1)
-
+    
    # Find source bridge: first check package data, then source dir
    pkg_bridge = Path(__file__).parent.parent / "bridge"  # nanobot/bridge (installed)
    src_bridge = Path(__file__).parent.parent.parent / "bridge"  # repo root/bridge (dev)
-
+    
    source = None
    if (pkg_bridge / "package.json").exists():
        source = pkg_bridge
    elif (src_bridge / "package.json").exists():
        source = src_bridge
-
+    
    if not source:
        console.print("[red]Bridge source not found.[/red]")
        console.print("Try reinstalling: pip install --force-reinstall nanobot")
        raise typer.Exit(1)
-
+    
    console.print(f"{__logo__} Setting up bridge...")
-
+    
    # Copy to user directory
    user_bridge.parent.mkdir(parents=True, exist_ok=True)
    if user_bridge.exists():
        shutil.rmtree(user_bridge)
    shutil.copytree(source, user_bridge, ignore=shutil.ignore_patterns("node_modules", "dist"))
-
+    
    # Install and build
    try:
        console.print("  Installing dependencies...")
        subprocess.run(["npm", "install"], cwd=user_bridge, check=True, capture_output=True)
-
+        
        console.print("  Building...")
        subprocess.run(["npm", "run", "build"], cwd=user_bridge, check=True, capture_output=True)
-
+        
        console.print("[green]✓[/green] Bridge ready\n")
    except subprocess.CalledProcessError as e:
        console.print(f"[red]Build failed: {e}[/red]")
        if e.stderr:
            console.print(f"[dim]{e.stderr.decode()[:500]}[/dim]")
        raise typer.Exit(1)
-
+    
    return user_bridge


@@ -750,19 +640,18 @@ def _get_bridge_dir() -> Path:
 def channels_login():
    """Link device via QR code."""
    import subprocess
-
    from nanobot.config.loader import load_config
-
+    
    config = load_config()
    bridge_dir = _get_bridge_dir()
-
+    
    console.print(f"{__logo__} Starting bridge...")
    console.print("Scan the QR code to connect.\n")
-
+    
    env = {**os.environ}
    if config.channels.whatsapp.bridge_token:
        env["BRIDGE_TOKEN"] = config.channels.whatsapp.bridge_token
-
+    
    try:
        subprocess.run(["npm", "start"], cwd=bridge_dir, check=True, env=env)
    except subprocess.CalledProcessError as e:
@@ -786,23 +675,23 @@ def cron_list(
    """List scheduled jobs."""
    from nanobot.config.loader import get_data_dir
    from nanobot.cron.service import CronService
-
+    
    store_path = get_data_dir() / "cron" / "jobs.json"
    service = CronService(store_path)
-
+    
    jobs = service.list_jobs(include_disabled=all)
-
+    
    if not jobs:
        console.print("No scheduled jobs.")
        return
-
+    
    table = Table(title="Scheduled Jobs")
    table.add_column("ID", style="cyan")
    table.add_column("Name")
    table.add_column("Schedule")
    table.add_column("Status")
    table.add_column("Next Run")
-
+    
    import time
    for job in jobs:
        # Format schedule
@@ -812,17 +701,17 @@ def cron_list(
            sched = job.schedule.expr or ""
        else:
            sched = "one-time"
-
+        
        # Format next run
        next_run = ""
        if job.state.next_run_at_ms:
            next_time = time.strftime("%Y-%m-%d %H:%M", time.localtime(job.state.next_run_at_ms / 1000))
            next_run = next_time
-
+        
        status = "[green]enabled[/green]" if job.enabled else "[dim]disabled[/dim]"
-
+        
        table.add_row(job.id, job.name, sched, status, next_run)
-
+    
    console.print(table)


@@ -832,7 +721,6 @@ def cron_add(
    message: str = typer.Option(..., "--message", "-m", help="Message for agent"),
    every: int = typer.Option(None, "--every", "-e", help="Run every N seconds"),
    cron_expr: str = typer.Option(None, "--cron", "-c", help="Cron expression (e.g. '0 9 * * *')"),
-    tz: str | None = typer.Option(None, "--tz", help="IANA timezone for cron (e.g. 'America/Vancouver')"),
    at: str = typer.Option(None, "--at", help="Run once at time (ISO format)"),
    deliver: bool = typer.Option(False, "--deliver", "-d", help="Deliver response to channel"),
    to: str = typer.Option(None, "--to", help="Recipient for delivery"),
@@ -842,16 +730,12 @@ def cron_add(
    from nanobot.config.loader import get_data_dir
    from nanobot.cron.service import CronService
    from nanobot.cron.types import CronSchedule
-
-    if tz and not cron_expr:
-        console.print("[red]Error: --tz can only be used with --cron[/red]")
-        raise typer.Exit(1)
-
+    
    # Determine schedule type
    if every:
        schedule = CronSchedule(kind="every", every_ms=every * 1000)
    elif cron_expr:
-        schedule = CronSchedule(kind="cron", expr=cron_expr, tz=tz)
+        schedule = CronSchedule(kind="cron", expr=cron_expr)
    elif at:
        import datetime
        dt = datetime.datetime.fromisoformat(at)
@@ -859,23 +743,19 @@ def cron_add(
    else:
        console.print("[red]Error: Must specify --every, --cron, or --at[/red]")
        raise typer.Exit(1)
-
+    
    store_path = get_data_dir() / "cron" / "jobs.json"
    service = CronService(store_path)
-
-    try:
-        job = service.add_job(
-            name=name,
-            schedule=schedule,
-            message=message,
-            deliver=deliver,
-            to=to,
-            channel=channel,
-        )
-    except ValueError as e:
-        console.print(f"[red]Error: {e}[/red]")
-        raise typer.Exit(1) from e
-
+    
+    job = service.add_job(
+        name=name,
+        schedule=schedule,
+        message=message,
+        deliver=deliver,
+        to=to,
+        channel=channel,
+    )
+    
    console.print(f"[green]✓[/green] Added job '{job.name}' ({job.id})")


@@ -886,10 +766,10 @@ def cron_remove(
    """Remove a scheduled job."""
    from nanobot.config.loader import get_data_dir
    from nanobot.cron.service import CronService
-
+    
    store_path = get_data_dir() / "cron" / "jobs.json"
    service = CronService(store_path)
-
+    
    if service.remove_job(job_id):
        console.print(f"[green]✓[/green] Removed job {job_id}")
    else:
@@ -904,10 +784,10 @@ def cron_enable(
    """Enable or disable a job."""
    from nanobot.config.loader import get_data_dir
    from nanobot.cron.service import CronService
-
+    
    store_path = get_data_dir() / "cron" / "jobs.json"
    service = CronService(store_path)
-
+    
    job = service.enable_job(job_id, enabled=not disable)
    if job:
        status = "disabled" if disable else "enabled"
@@ -924,15 +804,15 @@ def cron_run(
    """Manually run a job."""
    from nanobot.config.loader import get_data_dir
    from nanobot.cron.service import CronService
-
+    
    store_path = get_data_dir() / "cron" / "jobs.json"
    service = CronService(store_path)
-
+    
    async def run():
        return await service.run_job(job_id, force=force)
-
+    
    if asyncio.run(run()):
-        console.print("[green]✓[/green] Job executed")
+        console.print(f"[green]✓[/green] Job executed")
    else:
        console.print(f"[red]Failed to run job {job_id}[/red]")

@@ -945,7 +825,7 @@ def cron_run(
@app.command()
 def status():
    """Show nanobot status."""
-    from nanobot.config.loader import get_config_path, load_config
+    from nanobot.config.loader import load_config, get_config_path

    config_path = get_config_path()
    config = load_config()
@@ -960,7 +840,7 @@ def status():
        from nanobot.providers.registry import PROVIDERS

        console.print(f"Model: {config.agents.defaults.model}")
-
+        
        # Check API keys from registry
        for spec in PROVIDERS:
            p = getattr(config.providers, spec.name, None)
@@ -1,21 +1,14 @@
 """Configuration loading utilities."""

 import json
-import os
 from pathlib import Path
+from typing import Any

 from nanobot.config.schema import Config


 def get_config_path() -> Path:
-    """Get the configuration file path.
-
-    Checks NANOBOT_CONFIG environment variable first, otherwise defaults
-    to ~/.nanobot/config.json
-    """
-    env_path = os.getenv("NANOBOT_CONFIG")
-    if env_path:
-        return Path(env_path)
+    """Get the default configuration file path."""
    return Path.home() / ".nanobot" / "config.json"


@@ -56,10 +49,10 @@ def load_config(config_path: Path | None = None) -> Config:

    if path.exists():
        try:
-            with open(path, encoding="utf-8") as f:
+            with open(path) as f:
                data = json.load(f)
            data = _migrate_config(data)
-            config = Config.model_validate(data)
+            config = Config.model_validate(convert_keys(data))
            return _inject_oauth_credentials(config)
        except (json.JSONDecodeError, ValueError) as e:
            print(f"Warning: Failed to load config from {path}: {e}")
@@ -71,18 +64,20 @@ def load_config(config_path: Path | None = None) -> Config:
 def save_config(config: Config, config_path: Path | None = None) -> None:
    """
    Save configuration to file.
-
+    
    Args:
        config: Configuration to save.
        config_path: Optional path to save to. Uses default if not provided.
    """
    path = config_path or get_config_path()
    path.parent.mkdir(parents=True, exist_ok=True)
-
-    data = config.model_dump(by_alias=True)
-
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=2, ensure_ascii=False)
+    
+    # Convert to camelCase format
+    data = config.model_dump()
+    data = convert_to_camel(data)
+    
+    with open(path, "w") as f:
+        json.dump(data, f, indent=2)


 def _migrate_config(data: dict) -> dict:
@@ -92,18 +87,38 @@ def _migrate_config(data: dict) -> dict:
    exec_cfg = tools.get("exec", {})
    if "restrictToWorkspace" in exec_cfg and "restrictToWorkspace" not in tools:
        tools["restrictToWorkspace"] = exec_cfg.pop("restrictToWorkspace")
-
-    # Extract api_key from oauthCredentials if present
-    providers = data.get("providers", {})
-    for _, provider_config in providers.items():
-        if isinstance(provider_config, dict):
-            oauth_creds = provider_config.get("oauthCredentials")
-            if oauth_creds and isinstance(oauth_creds, dict):
-                access_token = oauth_creds.get("access_token", "")
-                # Only set api_key if not already set and access_token exists
-                if access_token and not provider_config.get("api_key"):
-                    provider_config["api_key"] = access_token
-                    # Clean up migrated data to avoid duplication
-                    del provider_config["oauthCredentials"]
-
    return data
+
+
+def convert_keys(data: Any) -> Any:
+    """Convert camelCase keys to snake_case for Pydantic."""
+    if isinstance(data, dict):
+        return {camel_to_snake(k): convert_keys(v) for k, v in data.items()}
+    if isinstance(data, list):
+        return [convert_keys(item) for item in data]
+    return data
+
+
+def convert_to_camel(data: Any) -> Any:
+    """Convert snake_case keys to camelCase."""
+    if isinstance(data, dict):
+        return {snake_to_camel(k): convert_to_camel(v) for k, v in data.items()}
+    if isinstance(data, list):
+        return [convert_to_camel(item) for item in data]
+    return data
+
+
+def camel_to_snake(name: str) -> str:
+    """Convert camelCase to snake_case."""
+    result = []
+    for i, char in enumerate(name):
+        if char.isupper() and i > 0:
+            result.append("_")
+        result.append(char.lower())
+    return "".join(result)
+
+
+def snake_to_camel(name: str) -> str:
+    """Convert snake_case to camelCase."""
+    components = name.split("_")
+    return components[0] + "".join(x.title() for x in components[1:])
@@ -1,89 +1,54 @@
 """Configuration schema using Pydantic."""

 from pathlib import Path
-from typing import Any, Literal
-
 from pydantic import BaseModel, Field, ConfigDict
-from pydantic.alias_generators import to_camel
 from pydantic_settings import BaseSettings


-class Base(BaseModel):
-    """Base model that accepts both camelCase and snake_case keys."""
-
-    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
-
-
-class WhatsAppConfig(Base):
+class WhatsAppConfig(BaseModel):
    """WhatsApp channel configuration."""
-
    enabled: bool = False
    bridge_url: str = "ws://localhost:3001"
    bridge_token: str = ""  # Shared token for bridge auth (optional, recommended)
    allow_from: list[str] = Field(default_factory=list)  # Allowed phone numbers


-class TelegramConfig(Base):
+class TelegramConfig(BaseModel):
    """Telegram channel configuration."""
-
    enabled: bool = False
    token: str = ""  # Bot token from @BotFather
    allow_from: list[str] = Field(default_factory=list)  # Allowed user IDs or usernames
    proxy: str | None = None  # HTTP/SOCKS5 proxy URL, e.g. "http://127.0.0.1:7890" or "socks5://127.0.0.1:1080"
-    reply_to_message: bool = False  # If true, bot replies quote the original message


-class FeishuConfig(Base):
+class FeishuConfig(BaseModel):
    """Feishu/Lark channel configuration using WebSocket long connection."""
-
    enabled: bool = False
    app_id: str = ""  # App ID from Feishu Open Platform
    app_secret: str = ""  # App Secret from Feishu Open Platform
    encrypt_key: str = ""  # Encrypt Key for event subscription (optional)
    verification_token: str = ""  # Verification Token for event subscription (optional)
    allow_from: list[str] = Field(default_factory=list)  # Allowed user open_ids
-    react_emoji: str = "THUMBSUP"  # Emoji type for message reactions (e.g. THUMBSUP, OK, DONE, SMILE)


-class DingTalkConfig(Base):
+class DingTalkConfig(BaseModel):
    """DingTalk channel configuration using Stream mode."""
-
    enabled: bool = False
    client_id: str = ""  # AppKey
    client_secret: str = ""  # AppSecret
    allow_from: list[str] = Field(default_factory=list)  # Allowed staff_ids


-class DiscordConfig(Base):
+class DiscordConfig(BaseModel):
    """Discord channel configuration."""
-
    enabled: bool = False
    token: str = ""  # Bot token from Discord Developer Portal
    allow_from: list[str] = Field(default_factory=list)  # Allowed user IDs
    gateway_url: str = "wss://gateway.discord.gg/?v=10&encoding=json"
    intents: int = 37377  # GUILDS + GUILD_MESSAGES + DIRECT_MESSAGES + MESSAGE_CONTENT

-
-class MatrixConfig(Base):
-    """Matrix (Element) channel configuration."""
-
-    enabled: bool = False
-    homeserver: str = "https://matrix.org"
-    access_token: str = ""
-    user_id: str = ""  # @bot:matrix.org
-    device_id: str = ""
-    e2ee_enabled: bool = True # Enable Matrix E2EE support (encryption + encrypted room handling).
-    sync_stop_grace_seconds: int = 2 # Max seconds to wait for sync_forever to stop gracefully before cancellation fallback.
-    max_media_bytes: int = 20 * 1024 * 1024 # Max attachment size accepted for Matrix media handling (inbound + outbound).
-    allow_from: list[str] = Field(default_factory=list)
-    group_policy: Literal["open", "mention", "allowlist"] = "open"
-    group_allow_from: list[str] = Field(default_factory=list)
-    allow_room_mentions: bool = False
-
-
-class EmailConfig(Base):
+class EmailConfig(BaseModel):
    """Email channel configuration (IMAP inbound + SMTP outbound)."""
-
    enabled: bool = False
    consent_granted: bool = False  # Explicit owner permission to access mailbox data

@@ -113,21 +78,18 @@ class EmailConfig(Base):
    allow_from: list[str] = Field(default_factory=list)  # Allowed sender email addresses


-class MochatMentionConfig(Base):
+class MochatMentionConfig(BaseModel):
    """Mochat mention behavior configuration."""
-
    require_in_groups: bool = False


-class MochatGroupRule(Base):
+class MochatGroupRule(BaseModel):
    """Mochat per-group mention requirement."""
-
    require_mention: bool = False


-class MochatConfig(Base):
+class MochatConfig(BaseModel):
    """Mochat channel configuration."""
-
    enabled: bool = False
    base_url: str = "https://mochat.io"
    socket_url: str = ""
@@ -152,58 +114,36 @@ class MochatConfig(Base):
    reply_delay_ms: int = 120000


-class SlackDMConfig(Base):
+class SlackDMConfig(BaseModel):
    """Slack DM policy configuration."""
-
    enabled: bool = True
    policy: str = "open"  # "open" or "allowlist"
    allow_from: list[str] = Field(default_factory=list)  # Allowed Slack user IDs


-class SlackConfig(Base):
+class SlackConfig(BaseModel):
    """Slack channel configuration."""
-
    enabled: bool = False
    mode: str = "socket"  # "socket" supported
    webhook_path: str = "/slack/events"
    bot_token: str = ""  # xoxb-...
    app_token: str = ""  # xapp-...
    user_token_read_only: bool = True
-    reply_in_thread: bool = True
-    react_emoji: str = "eyes"
    group_policy: str = "mention"  # "mention", "open", "allowlist"
    group_allow_from: list[str] = Field(default_factory=list)  # Allowed channel IDs if allowlist
    dm: SlackDMConfig = Field(default_factory=SlackDMConfig)


-class QQConfig(Base):
+class QQConfig(BaseModel):
    """QQ channel configuration using botpy SDK."""
-
    enabled: bool = False
    app_id: str = ""  # 机器人 ID (AppID) from q.qq.com
    secret: str = ""  # 机器人密钥 (AppSecret) from q.qq.com
    allow_from: list[str] = Field(default_factory=list)  # Allowed user openids (empty = public access)

-class MatrixConfig(Base):
-    """Matrix (Element) channel configuration."""
-    enabled: bool = False
-    homeserver: str = "https://matrix.org"
-    access_token: str = ""
-    user_id: str = ""                       # e.g. @bot:matrix.org
-    device_id: str = ""
-    e2ee_enabled: bool = True               # end-to-end encryption support
-    sync_stop_grace_seconds: int = 2        # graceful sync_forever shutdown timeout
-    max_media_bytes: int = 20 * 1024 * 1024 # inbound + outbound attachment limit
-    allow_from: list[str] = Field(default_factory=list)
-    group_policy: Literal["open", "mention", "allowlist"] = "open"
-    group_allow_from: list[str] = Field(default_factory=list)
-    allow_room_mentions: bool = False

-class ChannelsConfig(Base):
+class ChannelsConfig(BaseModel):
    """Configuration for chat channels."""
-
-    send_progress: bool = True    # stream agent's text progress to the channel
-    send_tool_hints: bool = False  # stream tool-call hints (e.g. read_file("…"))
    whatsapp: WhatsAppConfig = Field(default_factory=WhatsAppConfig)
    telegram: TelegramConfig = Field(default_factory=TelegramConfig)
    discord: DiscordConfig = Field(default_factory=DiscordConfig)
@@ -213,25 +153,21 @@ class ChannelsConfig(Base):
    email: EmailConfig = Field(default_factory=EmailConfig)
    slack: SlackConfig = Field(default_factory=SlackConfig)
    qq: QQConfig = Field(default_factory=QQConfig)
-    matrix: MatrixConfig = Field(default_factory=MatrixConfig)


-class AgentDefaults(Base):
+class AgentDefaults(BaseModel):
    """Default agent configuration."""
-
    workspace: str = "~/.nanobot/workspace"
-    model: str = "anthropic/claude-opus-4-7"
-    provider: str = "auto"  # Provider name (e.g. "anthropic", "openrouter") or "auto" for auto-detection
+    model: str = "anthropic/claude-opus-4-5"
    max_tokens: int = 8192
-    temperature: float = 0.1
-    max_tool_iterations: int = 40
-    memory_window: int = 100
+    temperature: float = 0.7
+    max_tool_iterations: int = 20
+    memory_window: int = 50
    thinking_budget: int = 0  # 0 = disabled; >0 = token budget for extended thinking


-class AgentsConfig(Base):
+class AgentsConfig(BaseModel):
    """Agent configuration."""
-
    defaults: AgentDefaults = Field(default_factory=AgentDefaults)


@@ -264,19 +200,16 @@ class OAuthCredentials(BaseModel):
        return time.time() > (self.expires_at - 600)


-class ProviderConfig(Base):
+class ProviderConfig(BaseModel):
    """LLM provider configuration."""
-
    api_key: str = ""
    api_base: str | None = None
    extra_headers: dict[str, str] | None = None  # Custom headers (e.g. APP-Code for AiHubMix)
    oauth_credentials: OAuthCredentials | None = None


-class ProvidersConfig(Base):
+class ProvidersConfig(BaseModel):
    """Configuration for LLM providers."""
-
-    custom: ProviderConfig = Field(default_factory=ProviderConfig)  # Any OpenAI-compatible endpoint
    anthropic: ProviderConfig = Field(default_factory=ProviderConfig)
    openai: ProviderConfig = Field(default_factory=ProviderConfig)
    openrouter: ProviderConfig = Field(default_factory=ProviderConfig)
@@ -289,152 +222,63 @@ class ProvidersConfig(Base):
    moonshot: ProviderConfig = Field(default_factory=ProviderConfig)
    minimax: ProviderConfig = Field(default_factory=ProviderConfig)
    aihubmix: ProviderConfig = Field(default_factory=ProviderConfig)  # AiHubMix API gateway
-    siliconflow: ProviderConfig = Field(default_factory=ProviderConfig)  # SiliconFlow (硅基流动) API gateway
-    volcengine: ProviderConfig = Field(default_factory=ProviderConfig)  # VolcEngine (火山引擎) API gateway
-    openai_codex: ProviderConfig = Field(default_factory=ProviderConfig)  # OpenAI Codex (OAuth)
-    github_copilot: ProviderConfig = Field(default_factory=ProviderConfig)  # Github Copilot (OAuth)


-class HeartbeatConfig(Base):
-    """Heartbeat service configuration."""
-
-    enabled: bool = True
-    interval_s: int = 30 * 60  # 30 minutes
-
-
-class GatewayConfig(Base):
+class GatewayConfig(BaseModel):
    """Gateway/server configuration."""
-
    host: str = "0.0.0.0"
    port: int = 18790
-    heartbeat: HeartbeatConfig = Field(default_factory=HeartbeatConfig)
-
-
-class HooksConfig(BaseModel):
-    """Webhook endpoint configuration."""
-    enabled: bool = False
-    tokens: dict[str, str] = Field(default_factory=dict)  # Named tokens: {name: secret}
-    path: str = "/hooks"  # URL path for the endpoint
-    timeout_seconds: int = 120  # Max time to wait for agent response
-
-    def resolve_token(self, provided: str) -> str | None:
-        """Return token name if provided secret matches, else None."""
-        for name, secret in self.tokens.items():
-            if secret == provided:
-                return name
-        return None
-
-    @property
-    def has_tokens(self) -> bool:
-        """True if at least one token is configured."""
-        return bool(self.tokens)


 class WebSearchConfig(BaseModel):
    """Web search tool configuration."""
-
    api_key: str = ""  # Brave Search API key
    max_results: int = 5


-class WebToolsConfig(Base):
+class WebToolsConfig(BaseModel):
    """Web tools configuration."""
-
    search: WebSearchConfig = Field(default_factory=WebSearchConfig)


-class ExecToolConfig(Base):
+class ExecToolConfig(BaseModel):
    """Shell exec tool configuration."""
-
    timeout: int = 60
-    path_append: str = ""


-class MCPServerConfig(Base):
-    """MCP server connection configuration (stdio or HTTP)."""
-
-    command: str = ""  # Stdio: command to run (e.g. "npx")
-    args: list[str] = Field(default_factory=list)  # Stdio: command arguments
-    env: dict[str, str] = Field(default_factory=dict)  # Stdio: extra env vars
-    url: str = ""  # HTTP: streamable HTTP endpoint URL
-    headers: dict[str, str] = Field(default_factory=dict)  # HTTP: Custom HTTP Headers
-    tool_timeout: int = 30  # Seconds before a tool call is cancelled
-
-
-class Mem0Config(Base):
-    """Mem0 memory system configuration."""
-
-    enabled: bool = False  # If true, use mem0 for semantic memory instead of simple MEMORY.md
-    api_key: str = ""  # Optional: mem0 cloud API key (leave empty for self-hosted)
-    search_limit: int = 5  # Max memories to retrieve per query
-    llm: str = ""  # Optional: LLM for memory extraction (default: gpt-4.1-nano-2025-04-14)
-    embedder: str = ""  # Optional: Embedding model (default: mem0's default)
-    vector_store: dict[str, Any] = Field(default_factory=dict)  # Vector store config (e.g., {"provider": "qdrant", "config": {...}})
-
-
-class ToolsConfig(Base):
+class ToolsConfig(BaseModel):
    """Tools configuration."""
-
    web: WebToolsConfig = Field(default_factory=WebToolsConfig)
    exec: ExecToolConfig = Field(default_factory=ExecToolConfig)
    restrict_to_workspace: bool = False  # If true, restrict all tool access to workspace directory
-    enable_memory_tool: bool = True  # If true, enable Anthropic's native memory tool
-    mem0: Mem0Config = Field(default_factory=Mem0Config)  # Mem0 semantic memory configuration
-    mcp_servers: dict[str, MCPServerConfig] = Field(default_factory=dict)


 class Config(BaseSettings):
    """Root configuration for nanobot."""
-
    agents: AgentsConfig = Field(default_factory=AgentsConfig)
    channels: ChannelsConfig = Field(default_factory=ChannelsConfig)
    providers: ProvidersConfig = Field(default_factory=ProvidersConfig)
    gateway: GatewayConfig = Field(default_factory=GatewayConfig)
-    hooks: HooksConfig = Field(default_factory=HooksConfig)
    tools: ToolsConfig = Field(default_factory=ToolsConfig)
-
+    
    @property
    def workspace_path(self) -> Path:
        """Get expanded workspace path."""
        return Path(self.agents.defaults.workspace).expanduser()
-
+    
    def _match_provider(self, model: str | None = None) -> tuple["ProviderConfig | None", str | None]:
        """Match provider config and its registry name. Returns (config, spec_name)."""
        from nanobot.providers.registry import PROVIDERS
-
-        forced = self.agents.defaults.provider
-        if forced != "auto":
-            p = getattr(self.providers, forced, None)
-            return (p, forced) if p else (None, None)
-
        model_lower = (model or self.agents.defaults.model).lower()
-        model_normalized = model_lower.replace("-", "_")
-        model_prefix = model_lower.split("/", 1)[0] if "/" in model_lower else ""
-        normalized_prefix = model_prefix.replace("-", "_")
-
-        def _kw_matches(kw: str) -> bool:
-            kw = kw.lower()
-            return kw in model_lower or kw.replace("-", "_") in model_normalized
-
-        # Explicit provider prefix wins — prevents `github-copilot/...codex` matching openai_codex.
-        for spec in PROVIDERS:
-            p = getattr(self.providers, spec.name, None)
-            if p and model_prefix and normalized_prefix == spec.name:
-                if spec.is_oauth or p.api_key:
-                    return p, spec.name

        # Match by keyword (order follows PROVIDERS registry)
        for spec in PROVIDERS:
            p = getattr(self.providers, spec.name, None)
-            if p and any(_kw_matches(kw) for kw in spec.keywords):
-                if spec.is_oauth or p.api_key:
-                    return p, spec.name
+            if p and any(kw in model_lower for kw in spec.keywords) and p.api_key:
+                return p, spec.name

        # Fallback: gateways first, then others (follows registry order)
-        # OAuth providers are NOT valid fallbacks — they require explicit model selection
        for spec in PROVIDERS:
-            if spec.is_oauth:
-                continue
            p = getattr(self.providers, spec.name, None)
            if p and p.api_key:
                return p, spec.name
@@ -454,11 +298,10 @@ class Config(BaseSettings):
        """Get API key for the given model. Falls back to first available key."""
        p = self.get_provider(model)
        return p.api_key if p else None
-
+    
    def get_api_base(self, model: str | None = None) -> str | None:
        """Get API base URL for the given model. Applies default URLs for known gateways."""
        from nanobot.providers.registry import find_by_name
-
        p, name = self._match_provider(model)
        if p and p.api_base:
            return p.api_base
@@ -470,5 +313,8 @@ class Config(BaseSettings):
            if spec and spec.is_gateway and spec.default_api_base:
                return spec.default_api_base
        return None
-
-    model_config = ConfigDict(env_prefix="NANOBOT_", env_nested_delimiter="__")
+    
+    model_config = ConfigDict(
+        env_prefix="NANOBOT_",
+        env_nested_delimiter="__"
+    )
@@ -4,7 +4,6 @@ import asyncio
 import json
 import time
 import uuid
-from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Coroutine

@@ -31,34 +30,15 @@ def _compute_next_run(schedule: CronSchedule, now_ms: int) -> int | None:
    if schedule.kind == "cron" and schedule.expr:
        try:
            from croniter import croniter
-            from zoneinfo import ZoneInfo
-            # Use caller-provided reference time for deterministic scheduling
-            base_time = now_ms / 1000
-            tz = ZoneInfo(schedule.tz) if schedule.tz else datetime.now().astimezone().tzinfo
-            base_dt = datetime.fromtimestamp(base_time, tz=tz)
-            cron = croniter(schedule.expr, base_dt)
-            next_dt = cron.get_next(datetime)
-            return int(next_dt.timestamp() * 1000)
+            cron = croniter(schedule.expr, time.time())
+            next_time = cron.get_next()
+            return int(next_time * 1000)
        except Exception:
            return None
    
    return None


-def _validate_schedule_for_add(schedule: CronSchedule) -> None:
-    """Validate schedule fields that would otherwise create non-runnable jobs."""
-    if schedule.tz and schedule.kind != "cron":
-        raise ValueError("tz can only be used with cron schedules")
-
-    if schedule.kind == "cron" and schedule.tz:
-        try:
-            from zoneinfo import ZoneInfo
-
-            ZoneInfo(schedule.tz)
-        except Exception:
-            raise ValueError(f"unknown timezone '{schedule.tz}'") from None
-
-
 class CronService:
    """Service for managing and executing scheduled jobs."""
    
@@ -80,7 +60,7 @@ class CronService:
        
        if self.store_path.exists():
            try:
-                data = json.loads(self.store_path.read_text(encoding="utf-8"))
+                data = json.loads(self.store_path.read_text())
                jobs = []
                for j in data.get("jobs", []):
                    jobs.append(CronJob(
@@ -113,7 +93,7 @@ class CronService:
                    ))
                self._store = CronStore(jobs=jobs)
            except Exception as e:
-                logger.warning("Failed to load cron store: {}", e)
+                logger.warning(f"Failed to load cron store: {e}")
                self._store = CronStore()
        else:
            self._store = CronStore()
@@ -162,7 +142,7 @@ class CronService:
            ]
        }
        
-        self.store_path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+        self.store_path.write_text(json.dumps(data, indent=2))
    
    async def start(self) -> None:
        """Start the cron service."""
@@ -171,7 +151,7 @@ class CronService:
        self._recompute_next_runs()
        self._save_store()
        self._arm_timer()
-        logger.info("Cron service started with {} jobs", len(self._store.jobs if self._store else []))
+        logger.info(f"Cron service started with {len(self._store.jobs if self._store else [])} jobs")
    
    def stop(self) -> None:
        """Stop the cron service."""
@@ -236,7 +216,7 @@ class CronService:
    async def _execute_job(self, job: CronJob) -> None:
        """Execute a single job."""
        start_ms = _now_ms()
-        logger.info("Cron: executing job '{}' ({})", job.name, job.id)
+        logger.info(f"Cron: executing job '{job.name}' ({job.id})")
        
        try:
            response = None
@@ -245,12 +225,12 @@ class CronService:
            
            job.state.last_status = "ok"
            job.state.last_error = None
-            logger.info("Cron: job '{}' completed", job.name)
+            logger.info(f"Cron: job '{job.name}' completed")
            
        except Exception as e:
            job.state.last_status = "error"
            job.state.last_error = str(e)
-            logger.error("Cron: job '{}' failed: {}", job.name, e)
+            logger.error(f"Cron: job '{job.name}' failed: {e}")
        
        job.state.last_run_at_ms = start_ms
        job.updated_at_ms = _now_ms()
@@ -286,7 +266,6 @@ class CronService:
    ) -> CronJob:
        """Add a new job."""
        store = self._load_store()
-        _validate_schedule_for_add(schedule)
        now = _now_ms()
        
        job = CronJob(
@@ -311,7 +290,7 @@ class CronService:
        self._save_store()
        self._arm_timer()
        
-        logger.info("Cron: added job '{}' ({})", name, job.id)
+        logger.info(f"Cron: added job '{name}' ({job.id})")
        return job
    
    def remove_job(self, job_id: str) -> bool:
@@ -324,7 +303,7 @@ class CronService:
        if removed:
            self._save_store()
            self._arm_timer()
-            logger.info("Cron: removed job {}", job_id)
+            logger.info(f"Cron: removed job {job_id}")
        
        return removed
    
@@ -1,16 +1,11 @@
 """Heartbeat service - periodic agent wake-up to check for tasks."""

-from __future__ import annotations
-
 import asyncio
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Coroutine
+from typing import Any, Callable, Coroutine

 from loguru import logger

-if TYPE_CHECKING:
-    from nanobot.session.manager import SessionManager
-
 # Default interval: 30 minutes
 DEFAULT_HEARTBEAT_INTERVAL_S = 30 * 60

@@ -27,51 +22,45 @@ def _is_heartbeat_empty(content: str | None) -> bool:
    """Check if HEARTBEAT.md has no actionable content."""
    if not content:
        return True
-
+    
    # Lines to skip: empty, headers, HTML comments, empty checkboxes
    skip_patterns = {"- [ ]", "* [ ]", "- [x]", "* [x]"}
-
+    
    for line in content.split("\n"):
        line = line.strip()
        if not line or line.startswith("#") or line.startswith("<!--") or line in skip_patterns:
            continue
        return False  # Found actionable content
-
+    
    return True


 class HeartbeatService:
    """
    Periodic heartbeat service that wakes the agent to check for tasks.
-
+    
    The agent reads HEARTBEAT.md from the workspace and executes any
    tasks listed there. If nothing needs attention, it replies HEARTBEAT_OK.
    """
-
+    
    def __init__(
        self,
        workspace: Path,
-        on_heartbeat: Callable[[str, dict[str, Any] | None], Coroutine[Any, Any, str]] | None = None,
+        on_heartbeat: Callable[[str], Coroutine[Any, Any, str]] | None = None,
        interval_s: int = DEFAULT_HEARTBEAT_INTERVAL_S,
        enabled: bool = True,
-        session_manager: SessionManager | None = None,
-        target_session_key: str = "telegram:239824268",
-        idle_threshold_s: int = 30 * 60,  # 30 minutes
    ):
        self.workspace = workspace
        self.on_heartbeat = on_heartbeat
        self.interval_s = interval_s
        self.enabled = enabled
-        self.session_manager = session_manager
-        self.target_session_key = target_session_key
-        self.idle_threshold_s = idle_threshold_s
        self._running = False
        self._task: asyncio.Task | None = None
-
+    
    @property
    def heartbeat_file(self) -> Path:
        return self.workspace / "HEARTBEAT.md"
-
+    
    def _read_heartbeat_file(self) -> str | None:
        """Read HEARTBEAT.md content."""
        if self.heartbeat_file.exists():
@@ -80,28 +69,24 @@ class HeartbeatService:
            except Exception:
                return None
        return None
-
+    
    async def start(self) -> None:
        """Start the heartbeat service."""
        if not self.enabled:
            logger.info("Heartbeat disabled")
            return
-
-        # Idempotent: don't create a new task if already running
-        if self._task is not None and not self._task.done():
-            return
-
+        
        self._running = True
        self._task = asyncio.create_task(self._run_loop())
        logger.info(f"Heartbeat started (every {self.interval_s}s)")
-
+    
    def stop(self) -> None:
        """Stop the heartbeat service."""
        self._running = False
        if self._task:
            self._task.cancel()
            self._task = None
-
+    
    async def _run_loop(self) -> None:
        """Main heartbeat loop."""
        while self._running:
@@ -113,68 +98,33 @@ class HeartbeatService:
                break
            except Exception as e:
                logger.error(f"Heartbeat error: {e}")
-
+    
    async def _tick(self) -> None:
        """Execute a single heartbeat tick."""
-
-        # Check if user is idle (if session manager provided)
-        if self.session_manager and self.target_session_key:
-            try:
-                session = self.session_manager.get_or_create(self.target_session_key)
-
-                # Find last real user message timestamp (exclude system-generated messages)
-                # Real Telegram messages have sender_id like "239824268|username"
-                # System messages (heartbeat, cron) created via process_direct have sender_id="user"
-                # Old messages may not have sender_id field (backwards compat: treat as real user messages)
-                last_user_timestamp = None
-                for msg in reversed(session.messages):
-                    if msg.get("role") == "user":
-                        sender_id = msg.get("sender_id")
-                        # Skip if explicitly marked as system-generated
-                        if sender_id == "user":
-                            continue
-                        # Accept if no sender_id (old message) or if real user ID
-                        last_user_timestamp = msg.get("timestamp")
-                        break
-
-                if last_user_timestamp:
-                    from datetime import datetime
-                    last_dt = datetime.fromisoformat(last_user_timestamp)
-                    elapsed = (datetime.now() - last_dt).total_seconds()
-
-                    if elapsed < self.idle_threshold_s:
-                        logger.debug(f"Heartbeat: user active {int(elapsed)}s ago, skipping")
-                        return  # User is active, don't trigger heartbeat
-            except Exception as e:
-                logger.warning(f"Heartbeat: error checking idle state: {e}")
-                # Continue with heartbeat on error (fail open)
-
-        # Original heartbeat logic
        content = self._read_heartbeat_file()
-
+        
        # Skip if HEARTBEAT.md is empty or doesn't exist
        if _is_heartbeat_empty(content):
            logger.debug("Heartbeat: no tasks (HEARTBEAT.md empty)")
            return
-
-        logger.info("Heartbeat: user idle, checking for tasks...")
-
+        
+        logger.info("Heartbeat: checking for tasks...")
+        
        if self.on_heartbeat:
            try:
-                # Call with suppress_output metadata
-                await self.on_heartbeat(
-                    HEARTBEAT_PROMPT,
-                    metadata={"suppress_output": True}
-                )
-
-                # Note: HEARTBEAT_OK check removed - suppress mode makes it unnecessary
-                logger.info("Heartbeat: completed")
-
+                response = await self.on_heartbeat(HEARTBEAT_PROMPT)
+                
+                # Check if agent said "nothing to do"
+                if HEARTBEAT_OK_TOKEN.replace("_", "") in response.upper().replace("_", ""):
+                    logger.info("Heartbeat: OK (no action needed)")
+                else:
+                    logger.info(f"Heartbeat: completed task")
+                    
            except Exception as e:
                logger.error(f"Heartbeat execution failed: {e}")
-
+    
    async def trigger_now(self) -> str | None:
        """Manually trigger a heartbeat."""
        if self.on_heartbeat:
-            return await self.on_heartbeat(HEARTBEAT_PROMPT, metadata={"suppress_output": True})
+            return await self.on_heartbeat(HEARTBEAT_PROMPT)
        return None
@@ -1,139 +0,0 @@
-"""HTTP hooks server for external service integration."""
-
-import asyncio
-import json
-import uuid
-
-from aiohttp import web
-from loguru import logger
-
-from nanobot.bus.events import InboundMessage
-from nanobot.bus.queue import MessageBus
-from nanobot.config.schema import HooksConfig
-
-
-class HooksServer:
-    """
-    HTTP server exposing a /hooks endpoint.
-
-    External services POST JSON messages. The server publishes them
-    to the bus as InboundMessages and uses bus-level correlation
-    to return the agent's response synchronously.
-    """
-
-    def __init__(
-        self,
-        host: str,
-        port: int,
-        config: HooksConfig,
-        bus: MessageBus,
-    ):
-        self.host = host
-        self.port = port
-        self.config = config
-        self.bus = bus
-        self._app = web.Application()
-        self._app.router.add_post(self.config.path, self._handle_hook)
-        self._app.router.add_get("/health", self._handle_health)
-        self._runner: web.AppRunner | None = None
-
-    async def start(self) -> None:
-        """Start the HTTP server."""
-        if not self.config.has_tokens:
-            logger.warning("Hooks server has no tokens configured — endpoint disabled for security")
-            return
-
-        self._runner = web.AppRunner(self._app)
-        await self._runner.setup()
-        site = web.TCPSite(self._runner, self.host, self.port)
-        await site.start()
-        logger.info(f"Hooks server listening on {self.host}:{self.port}{self.config.path}")
-
-    async def stop(self) -> None:
-        """Stop the HTTP server."""
-        if self._runner:
-            await self._runner.cleanup()
-            self._runner = None
-
-    def _resolve_auth(self, request: web.Request) -> str | None:
-        """
-        Validate auth and return token name if valid, None otherwise.
-        Checks Authorization: Bearer <token> and X-Hook-Token headers.
-        """
-        # Try Authorization: Bearer <token>
-        auth = request.headers.get("Authorization", "")
-        if auth.startswith("Bearer "):
-            token = auth[7:]
-        else:
-            # Try X-Hook-Token header
-            token = request.headers.get("X-Hook-Token", "")
-
-        return self.config.resolve_token(token) if token else None
-
-    async def _handle_health(self, request: web.Request) -> web.Response:
-        """Health check endpoint — no auth required."""
-        return web.json_response({"status": "ok"})
-
-    async def _handle_hook(self, request: web.Request) -> web.Response:
-        """Handle incoming hook request."""
-        # Auth check — resolve token name
-        token_name = self._resolve_auth(request)
-        if not token_name:
-            return web.json_response({"error": "unauthorized"}, status=401)
-
-        # Parse body
-        try:
-            body = await request.json()
-        except (json.JSONDecodeError, Exception):
-            return web.json_response({"error": "invalid JSON body"}, status=400)
-
-        # Validate required fields
-        message = body.get("message")
-        if not message or not isinstance(message, str):
-            return web.json_response(
-                {"error": "missing or invalid 'message' field"}, status=400
-            )
-
-        # Optional fields
-        channel = body.get("channel", "hook")
-        chat_id = body.get("chat_id", token_name)
-        timeout = body.get("timeout", self.config.timeout_seconds)
-
-        # Create correlation
-        correlation_id = str(uuid.uuid4())
-
-        # Build InboundMessage
-        msg = InboundMessage(
-            channel=channel,
-            sender_id=f"hook:{token_name}",
-            chat_id=str(chat_id),
-            content=message,
-            metadata={
-                "correlation_id": correlation_id,
-                "hook_source": token_name,
-            },
-        )
-
-        # Fire-and-forget mode
-        if timeout == 0:
-            await self.bus.publish_inbound(msg)
-            return web.json_response({"ok": True}, status=202)
-
-        # Request-response mode
-        future = self.bus.register_correlation(correlation_id)
-        await self.bus.publish_inbound(msg)
-
-        try:
-            response = await asyncio.wait_for(future, timeout=timeout)
-            return web.json_response({"ok": True, "response": response})
-        except asyncio.TimeoutError:
-            return web.json_response(
-                {"ok": False, "error": f"agent did not respond within {timeout}s"},
-                status=504,
-            )
-        except Exception as e:
-            logger.error(f"Hook processing error: {e}")
-            return web.json_response({"error": "internal error"}, status=500)
-        finally:
-            # Clean up correlation on any failure
-            self.bus.cancel_correlation(correlation_id)
@@ -1,8 +1,7 @@
 """Provider module exports."""

-from nanobot.providers.base import LLMProvider, LLMResponse, LongContextError, ToolCallRequest
+from nanobot.providers.base import LLMProvider, LLMResponse, ToolCallRequest
 from nanobot.providers.litellm_provider import LiteLLMProvider
-from nanobot.providers.openai_codex_provider import OpenAICodexProvider
 from nanobot.providers.anthropic_oauth import AnthropicOAuthProvider
 from nanobot.providers.registry import should_use_oauth_provider

@@ -11,7 +10,6 @@ __all__ = [
    "LLMResponse",
    "ToolCallRequest",
    "LiteLLMProvider",
-    "OpenAICodexProvider",
    "AnthropicOAuthProvider",
    "create_provider",
 ]
@@ -10,8 +10,8 @@ from typing import Any
 import httpx
 from loguru import logger

-from nanobot.providers.base import LLMProvider, LLMResponse, LongContextError, ToolCallRequest
-from nanobot.providers.oauth_utils import get_auth_headers, get_claude_code_system_prefix
+from nanobot.providers.base import LLMProvider, LLMResponse, ToolCallRequest
+from nanobot.providers.oauth_utils import get_auth_headers


 class AnthropicOAuthProvider(LLMProvider):
@@ -27,7 +27,7 @@ class AnthropicOAuthProvider(LLMProvider):
    def __init__(
        self,
        oauth_token: str,
-        default_model: str = "claude-opus-4-7",
+        default_model: str = "claude-opus-4-5",
        api_base: str | None = None,
        thinking_budget: int = 0,
    ):
@@ -51,91 +51,17 @@ class AnthropicOAuthProvider(LLMProvider):
    def _normalize_model(model: str) -> str:
        """Normalize model name for the Anthropic API.

-        Anthropic model IDs use hyphens (claude-sonnet-4-6), but users often
-        write dots (claude-sonnet-4.6). Normalize so both work.
+        Anthropic model IDs use hyphens (claude-sonnet-4-5), but users often
+        write dots (claude-sonnet-4.5). Normalize so both work.
        """
        return model.replace(".", "-")

    async def _get_client(self) -> httpx.AsyncClient:
        """Get or create async HTTP client."""
        if self._client is None:
-            self._client = httpx.AsyncClient(
-                timeout=httpx.Timeout(300.0, pool=30.0),
-            )
+            self._client = httpx.AsyncClient(timeout=300.0)
        return self._client

-    async def _reset_client(self) -> None:
-        """Destroy and recreate the HTTP client after connection errors."""
-        old = self._client
-        self._client = None
-        if old:
-            try:
-                await old.aclose()
-            except Exception:
-                pass
-        logger.warning("Reset httpx client (pool recycled)")
-
-    async def _diagnose_connectivity(self) -> None:
-        """Run diagnostics when ConnectTimeout occurs to understand why."""
-        import socket
-        import asyncio
-
-        # 1. Raw socket test (bypasses httpx entirely)
-        try:
-            t0 = __import__('time').monotonic()
-            s = socket.create_connection(('api.anthropic.com', 443), timeout=10)
-            elapsed = __import__('time').monotonic() - t0
-            s.close()
-            logger.warning(f"DIAG: raw socket connect OK in {elapsed:.3f}s")
-        except Exception as e:
-            logger.error(f"DIAG: raw socket connect FAILED: {e}")
-
-        # 2. asyncio connect test (same event loop)
-        try:
-            t0 = __import__('time').monotonic()
-            reader, writer = await asyncio.wait_for(
-                asyncio.open_connection('api.anthropic.com', 443),
-                timeout=10.0,
-            )
-            elapsed = __import__('time').monotonic() - t0
-            writer.close()
-            await writer.wait_closed()
-            logger.warning(f"DIAG: asyncio connect OK in {elapsed:.3f}s")
-        except Exception as e:
-            logger.error(f"DIAG: asyncio connect FAILED: {e}")
-
-        # 3. Fresh httpx client test (new pool)
-        try:
-            t0 = __import__('time').monotonic()
-            async with httpx.AsyncClient(timeout=10.0) as fresh:
-                r = await fresh.get('https://api.anthropic.com/')
-                elapsed = __import__('time').monotonic() - t0
-                logger.warning(f"DIAG: fresh httpx OK in {elapsed:.3f}s (status={r.status_code})")
-        except Exception as e:
-            logger.error(f"DIAG: fresh httpx FAILED: {e}")
-
-        # 4. DNS resolution
-        try:
-            ips = socket.getaddrinfo('api.anthropic.com', 443)
-            logger.warning(f"DIAG: DNS resolved to {len(ips)} entries, first={ips[0][4][0]}")
-        except Exception as e:
-            logger.error(f"DIAG: DNS FAILED: {e}")
-
-        # 5. Connection pool state of the broken client
-        if self._client:
-            transport = self._client._transport
-            if hasattr(transport, '_pool'):
-                pool = transport._pool
-                conns = getattr(pool, '_connections', [])
-                reqs = getattr(pool, '_requests', [])
-                logger.warning(
-                    f"DIAG: pool state: {len(conns)} connections, "
-                    f"{len(reqs)} pending requests"
-                )
-                for i, conn in enumerate(conns[:5]):
-                    state = getattr(conn, '_state', 'unknown')
-                    logger.warning(f"DIAG: conn[{i}] state={state}")
-
    def _prepare_messages(
        self,
        messages: list[dict[str, Any]]
@@ -273,41 +199,21 @@ class AnthropicOAuthProvider(LLMProvider):

    def _convert_tools_to_anthropic(
        self,
-        tools: list[dict[str, Any]] | list[Any] | None
+        tools: list[dict[str, Any]] | None
    ) -> list[dict[str, Any]] | None:
-        """Convert tools to Anthropic API format.
-
-        Supports both function tools (custom) and native tools (Anthropic).
-        Function tools are converted to Anthropic format.
-        Native tools are passed through unchanged.
-        Tool objects (with to_params/to_schema methods) are converted to dicts.
-        """
+        """Convert OpenAI-format tools to Anthropic format."""
        if not tools:
            return None

        anthropic_tools = []
        for tool in tools:
-            # Convert tool objects to dicts first
-            if hasattr(tool, 'to_params'):  # Native Anthropic tool
-                tool_dict = tool.to_params()
-            elif hasattr(tool, 'to_schema'):  # Function tool
-                tool_dict = tool.to_schema()
-            else:
-                tool_dict = tool  # Already a dict
-
-            # Now process the dict
-            if tool_dict.get("type") == "function":
-                # Convert function tool format
-                func = tool_dict["function"]
+            if tool.get("type") == "function":
+                func = tool["function"]
                anthropic_tools.append({
                    "name": func["name"],
                    "description": func.get("description", ""),
                    "input_schema": func.get("parameters", {"type": "object", "properties": {}})
                })
-            else:
-                # Pass through native tool format as-is
-                # (bash_20250124, text_editor_20250728, computer_20251124, etc.)
-                anthropic_tools.append(tool_dict)

        return anthropic_tools if anthropic_tools else None

@@ -321,40 +227,22 @@ class AnthropicOAuthProvider(LLMProvider):
        tools: list[dict[str, Any]] | None = None,
        thinking_budget_override: int | None = None,
        context_management: dict[str, Any] | None = None,
-        beta_flags: set[str] | None = None,
    ) -> dict[str, Any]:
        """Make request to Anthropic API."""
        client = await self._get_client()

-        # Add cache breakpoints on the last TWO user messages (4-breakpoint strategy):
-        # BP3: Second-to-last user message (stable history from previous turn)
-        # BP4: Last user message (current turn, will become BP3 next turn)
-        # This allows BP3 to reuse what BP4 cached last turn.
-        user_indices = [i for i, m in enumerate(messages) if m.get("role") == "user"]
-
-        if len(user_indices) >= 2:
-            # BP3: Second-to-last user message
-            idx = user_indices[-2]
-            msg = messages[idx]
-            content = msg["content"]
-            if isinstance(content, str):
-                messages[idx] = {**msg, "content": [{"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}]}
-            elif isinstance(content, list) and content:
-                new_content = list(content)
-                new_content[-1] = {**new_content[-1], "cache_control": {"type": "ephemeral"}}
-                messages[idx] = {**msg, "content": new_content}
-
-        if len(user_indices) >= 1:
-            # BP4: Last user message
-            idx = user_indices[-1]
-            msg = messages[idx]
-            content = msg["content"]
-            if isinstance(content, str):
-                messages[idx] = {**msg, "content": [{"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}]}
-            elif isinstance(content, list) and content:
-                new_content = list(content)
-                new_content[-1] = {**new_content[-1], "cache_control": {"type": "ephemeral"}}
-                messages[idx] = {**msg, "content": new_content}
+        # Cache the last user message so conversation history is cached across turns
+        if messages:
+            last = messages[-1]
+            if last.get("role") == "user":
+                content = last["content"]
+                if isinstance(content, str):
+                    last = {**last, "content": [{"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}]}
+                elif isinstance(content, list) and content:
+                    new_content = list(content)
+                    new_content[-1] = {**new_content[-1], "cache_control": {"type": "ephemeral"}}
+                    last = {**last, "content": new_content}
+                messages = messages[:-1] + [last]

        payload: dict[str, Any] = {
            "model": model,
@@ -377,14 +265,7 @@ class AnthropicOAuthProvider(LLMProvider):
            payload["temperature"] = temperature

        if system:
-            payload["system"] = [
-                {"type": "text", "text": get_claude_code_system_prefix()},
-                {"type": "text", "text": system, "cache_control": {"type": "ephemeral", "ttl": "1h"}},
-            ]
-        else:
-            payload["system"] = [
-                {"type": "text", "text": get_claude_code_system_prefix()},
-            ]
+            payload["system"] = [{"type": "text", "text": system, "cache_control": {"type": "ephemeral", "ttl": "1h"}}]

        if tools:
            cached_tools = list(tools)
@@ -395,155 +276,63 @@ class AnthropicOAuthProvider(LLMProvider):
            payload["context_management"] = context_management

        edit_types = [e.get("type") for e in (context_management or {}).get("edits", [])]
-
-        # Build headers with beta flags if provided
-        headers = self._get_headers()
-        if beta_flags:
-            # Merge with existing beta header (from OAuth hardcoded flags)
-            existing_beta = headers.get("anthropic-beta", "")
-            existing_flags = set(existing_beta.split(",")) if existing_beta else set()
-            all_flags = existing_flags | beta_flags
-            headers["anthropic-beta"] = ",".join(sorted(all_flags))
-
        logger.info(
-            "Anthropic request: model={} max_tokens={} thinking={} tools={} context_mgmt={} beta={}",
+            "Anthropic request: model={} max_tokens={} thinking={} tools={} context_mgmt={}",
            payload.get("model"), payload.get("max_tokens"),
            payload.get("thinking", "disabled"),
            len(payload.get("tools", [])),
            edit_types or "none",
-            headers.get("anthropic-beta", "none"),
        )

-        # Debug: Log tool names for diagnostic purposes
-        if payload.get("tools"):
-            tool_names = [t.get("name", "unnamed") for t in payload["tools"]]
-            logger.debug(f"Tool names in request: {tool_names}")
+        response = await client.post(
+            self._get_api_url(),
+            headers=self._get_headers(),
+            json=payload,
+        )

-        # Debug: Log message structure to diagnose orphaned tool_result errors
-        for idx, m in enumerate(payload.get("messages", [])):
-            role = m.get("role", "?")
-            content = m.get("content", "")
-            if isinstance(content, list):
-                block_types = [b.get("type", "?") for b in content]
-                logger.debug(f"  msg[{idx}] role={role} blocks={block_types}")
-            else:
-                logger.debug(f"  msg[{idx}] role={role} text={str(content)[:80]}")
+        # Dump rate limit headers for analysis
+        try:
+            import datetime
+            import os
+            header_dump = {
+                "timestamp": datetime.datetime.utcnow().isoformat(),
+                "status_code": response.status_code,
+                "model": payload.get("model"),
+                "headers": dict(response.headers),
+            }
+            dump_path = "/root/.nanobot/workspace/api_headers.jsonl"
+            with open(dump_path, "a") as f:
+                f.write(json.dumps(header_dump) + "\n")
+            # Capture rate limit state for quota-based model switching
+            hdrs = response.headers
+            rate_limit_state = {
+                "updated_at": datetime.datetime.utcnow().isoformat(),
+                "model": payload.get("model"),
+                "weekly_all_models": float(hdrs["anthropic-ratelimit-unified-7d-utilization"]) if hdrs.get("anthropic-ratelimit-unified-7d-utilization") else None,
+                "weekly_sonnet": float(hdrs["anthropic-ratelimit-unified-7d_sonnet-utilization"]) if hdrs.get("anthropic-ratelimit-unified-7d_sonnet-utilization") else None,
+                "session_5h": float(hdrs["anthropic-ratelimit-unified-5h-utilization"]) if hdrs.get("anthropic-ratelimit-unified-5h-utilization") else None,
+                "weekly_reset": int(hdrs["anthropic-ratelimit-unified-7d-reset"]) if hdrs.get("anthropic-ratelimit-unified-7d-reset") else None,
+                "session_reset": int(hdrs["anthropic-ratelimit-unified-5h-reset"]) if hdrs.get("anthropic-ratelimit-unified-5h-reset") else None,
+                "binding_limit": hdrs.get("anthropic-ratelimit-unified-representative-claim"),
+                "sonnet_fallback": hdrs.get("anthropic-ratelimit-unified-fallback"),
+            }
+            state_path = "/root/.nanobot/workspace/memory/rate_limits.json"
+            os.makedirs(os.path.dirname(state_path), exist_ok=True)
+            with open(state_path, "w") as f:
+                json.dump(rate_limit_state, f, indent=2)
+        except Exception as e:
+            logger.warning("Rate limit header capture failed: {}", e)

-        import asyncio
-        import time as _time
+        if response.status_code != 200:
+            error_text = response.text
+            raise Exception(f"Anthropic API error {response.status_code}: {error_text}")

-        max_retries = 3
-        base_delay = 2.0  # seconds
-
-        for attempt in range(max_retries + 1):
-            _t0 = _time.monotonic()
-            try:
-                response = await client.post(
-                    self._get_api_url(),
-                    headers=headers,
-                    json=payload,
-                )
-            except httpx.ConnectTimeout:
-                elapsed = _time.monotonic() - _t0
-                logger.error(f"ConnectTimeout after {elapsed:.1f}s (attempt {attempt+1}/{max_retries+1})")
-                if attempt == 0:
-                    await self._diagnose_connectivity()
-                await self._reset_client()
-                if attempt < max_retries:
-                    delay = base_delay * (2 ** attempt)
-                    logger.info(f"Retrying in {delay:.1f}s...")
-                    await asyncio.sleep(delay)
-                    continue
-                raise
-            except httpx.PoolTimeout:
-                elapsed = _time.monotonic() - _t0
-                logger.error(f"PoolTimeout after {elapsed:.1f}s (attempt {attempt+1}/{max_retries+1})")
-                await self._reset_client()
-                if attempt < max_retries:
-                    delay = base_delay * (2 ** attempt)
-                    logger.info(f"Retrying in {delay:.1f}s...")
-                    await asyncio.sleep(delay)
-                    continue
-                raise
-            except (httpx.ConnectError, httpx.TimeoutException) as e:
-                elapsed = _time.monotonic() - _t0
-                logger.error(f"{type(e).__name__} after {elapsed:.1f}s (attempt {attempt+1}/{max_retries+1})")
-                if attempt < max_retries:
-                    delay = base_delay * (2 ** attempt)
-                    logger.info(f"Retrying in {delay:.1f}s...")
-                    await asyncio.sleep(delay)
-                    continue
-                raise
-            elapsed = _time.monotonic() - _t0
-            if elapsed > 30:
-                logger.warning(f"Anthropic API slow response: {elapsed:.1f}s")
-
-            # Dump rate limit headers for analysis
-            try:
-                import datetime
-                import os
-                header_dump = {
-                    "timestamp": datetime.datetime.now(datetime.UTC).isoformat(),
-                    "status_code": response.status_code,
-                    "model": payload.get("model"),
-                    "headers": dict(response.headers),
-                }
-                dump_path = "/root/.nanobot/workspace/api_headers.jsonl"
-                with open(dump_path, "a") as f:
-                    f.write(json.dumps(header_dump) + "\n")
-                # Capture rate limit state for quota-based model switching
-                hdrs = response.headers
-                rate_limit_state = {
-                    "updated_at": datetime.datetime.utcnow().isoformat(),
-                    "model": payload.get("model"),
-                    "weekly_all_models": float(hdrs["anthropic-ratelimit-unified-7d-utilization"]) if hdrs.get("anthropic-ratelimit-unified-7d-utilization") else None,
-                    "weekly_sonnet": float(hdrs["anthropic-ratelimit-unified-7d_sonnet-utilization"]) if hdrs.get("anthropic-ratelimit-unified-7d_sonnet-utilization") else None,
-                    "session_5h": float(hdrs["anthropic-ratelimit-unified-5h-utilization"]) if hdrs.get("anthropic-ratelimit-unified-5h-utilization") else None,
-                    "weekly_reset": int(hdrs["anthropic-ratelimit-unified-7d-reset"]) if hdrs.get("anthropic-ratelimit-unified-7d-reset") else None,
-                    "session_reset": int(hdrs["anthropic-ratelimit-unified-5h-reset"]) if hdrs.get("anthropic-ratelimit-unified-5h-reset") else None,
-                    "binding_limit": hdrs.get("anthropic-ratelimit-unified-representative-claim"),
-                    "sonnet_fallback": hdrs.get("anthropic-ratelimit-unified-fallback"),
-                }
-                state_path = "/root/.nanobot/workspace/memory/rate_limits.json"
-                os.makedirs(os.path.dirname(state_path), exist_ok=True)
-                with open(state_path, "w") as f:
-                    json.dump(rate_limit_state, f, indent=2)
-            except Exception as e:
-                logger.warning("Rate limit header capture failed: {}", e)
-
-            # Retry on 5xx server errors and 429 rate limits
-            if response.status_code >= 500 or response.status_code == 429:
-                error_text = response.text
-                logger.warning(f"Anthropic API {response.status_code} (attempt {attempt+1}/{max_retries+1}): {error_text[:200]}")
-
-                # Long context 429 — retrying won't help, need to trim context
-                if response.status_code == 429 and "long context" in error_text.lower():
-                    raise LongContextError(f"Context too long for current plan: {error_text[:200]}")
-
-                if attempt < max_retries:
-                    if response.status_code == 429:
-                        retry_after = response.headers.get("retry-after")
-                        delay = float(retry_after) if retry_after else base_delay * (2 ** attempt)
-                    else:
-                        delay = base_delay * (2 ** attempt)
-                    logger.info(f"Retrying in {delay:.1f}s...")
-                    await asyncio.sleep(delay)
-                    continue
-                raise Exception(f"Anthropic API error {response.status_code}: {error_text}")
-
-            if response.status_code != 200:
-                error_text = response.text
-                raise Exception(f"Anthropic API error {response.status_code}: {error_text}")
-
-            return response.json()
-
-        # Should not reach here, but just in case
-        raise Exception("Exhausted all retry attempts")
+        return response.json()

    async def chat(
        self,
        messages: list[dict[str, Any]],
-        tools: list[dict[str, Any]] | list[Any] | None = None,
+        tools: list[dict[str, Any]] | None = None,
        model: str | None = None,
        max_tokens: int = 4096,
        temperature: float = 0.7,
@@ -557,21 +346,10 @@ class AnthropicOAuthProvider(LLMProvider):
        if "/" in model:
            model = model.split("/")[-1]

-        # Normalize dots to hyphens (claude-sonnet-4.6 -> claude-sonnet-4-6)
+        # Normalize dots to hyphens (claude-sonnet-4.5 -> claude-sonnet-4-5)
        model = self._normalize_model(model)

        system, prepared_messages = self._prepare_messages(messages)
-
-        # Collect beta flags from native tools BEFORE conversion
-        beta_flags: set[str] = set()
-        if tools:
-            for tool in tools:
-                if hasattr(tool, 'beta_flag') and tool.beta_flag:
-                    beta_flags.add(tool.beta_flag)
-
-        logger.debug(f"Beta flags collected: {beta_flags} (from {len(tools) if tools else 0} tools)")
-
-        # Convert tools to API format
        anthropic_tools = self._convert_tools_to_anthropic(tools)

        # Per-call thinking override (None = use instance default)
@@ -587,16 +365,11 @@ class AnthropicOAuthProvider(LLMProvider):
                tools=anthropic_tools,
                thinking_budget_override=effective_thinking,
                context_management=context_management,
-                beta_flags=beta_flags,
            )
            return self._parse_response(response)
-        except LongContextError:
-            raise  # Let caller handle context trimming
        except Exception as e:
-            logger.exception("Exception in chat():")
-            error_msg = f"{type(e).__name__}: {str(e)}" if str(e) else f"{type(e).__name__} (no message)"
            return LLMResponse(
-                content=f"Error calling LLM: {error_msg}",
+                content=f"Error calling LLM: {str(e)}",
                finish_reason="error",
            )

@@ -28,11 +28,6 @@ class LLMResponse:
        return len(self.tool_calls) > 0


-class LongContextError(Exception):
-    """Raised when the API rejects a request due to long context limits."""
-    pass
-
-
 class LLMProvider(ABC):
    """
    Abstract base class for LLM providers.
@@ -44,46 +39,6 @@ class LLMProvider(ABC):
    def __init__(self, api_key: str | None = None, api_base: str | None = None):
        self.api_key = api_key
        self.api_base = api_base
-
-    @staticmethod
-    def _sanitize_empty_content(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
-        """Replace empty text content that causes provider 400 errors.
-
-        Empty content can appear when MCP tools return nothing. Most providers
-        reject empty-string content or empty text blocks in list content.
-        """
-        result: list[dict[str, Any]] = []
-        for msg in messages:
-            content = msg.get("content")
-
-            if isinstance(content, str) and not content:
-                clean = dict(msg)
-                clean["content"] = None if (msg.get("role") == "assistant" and msg.get("tool_calls")) else "(empty)"
-                result.append(clean)
-                continue
-
-            if isinstance(content, list):
-                filtered = [
-                    item for item in content
-                    if not (
-                        isinstance(item, dict)
-                        and item.get("type") in ("text", "input_text", "output_text")
-                        and not item.get("text")
-                    )
-                ]
-                if len(filtered) != len(content):
-                    clean = dict(msg)
-                    if filtered:
-                        clean["content"] = filtered
-                    elif msg.get("role") == "assistant" and msg.get("tool_calls"):
-                        clean["content"] = None
-                    else:
-                        clean["content"] = "(empty)"
-                    result.append(clean)
-                    continue
-
-            result.append(msg)
-        return result
    
    @abstractmethod
    async def chat(
@@ -1,52 +0,0 @@
-"""Direct OpenAI-compatible provider — bypasses LiteLLM."""
-
-from __future__ import annotations
-
-from typing import Any
-
-import json_repair
-from openai import AsyncOpenAI
-
-from nanobot.providers.base import LLMProvider, LLMResponse, ToolCallRequest
-
-
-class CustomProvider(LLMProvider):
-
-    def __init__(self, api_key: str = "no-key", api_base: str = "http://localhost:8000/v1", default_model: str = "default"):
-        super().__init__(api_key, api_base)
-        self.default_model = default_model
-        self._client = AsyncOpenAI(api_key=api_key, base_url=api_base)
-
-    async def chat(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]] | None = None,
-                   model: str | None = None, max_tokens: int = 4096, temperature: float = 0.7) -> LLMResponse:
-        kwargs: dict[str, Any] = {
-            "model": model or self.default_model,
-            "messages": self._sanitize_empty_content(messages),
-            "max_tokens": max(1, max_tokens),
-            "temperature": temperature,
-        }
-        if tools:
-            kwargs.update(tools=tools, tool_choice="auto")
-        try:
-            return self._parse(await self._client.chat.completions.create(**kwargs))
-        except Exception as e:
-            return LLMResponse(content=f"Error: {e}", finish_reason="error")
-
-    def _parse(self, response: Any) -> LLMResponse:
-        choice = response.choices[0]
-        msg = choice.message
-        tool_calls = [
-            ToolCallRequest(id=tc.id, name=tc.function.name,
-                            arguments=json_repair.loads(tc.function.arguments) if isinstance(tc.function.arguments, str) else tc.function.arguments)
-            for tc in (msg.tool_calls or [])
-        ]
-        u = response.usage
-        return LLMResponse(
-            content=msg.content, tool_calls=tool_calls, finish_reason=choice.finish_reason or "stop",
-            usage={"prompt_tokens": u.prompt_tokens, "completion_tokens": u.completion_tokens, "total_tokens": u.total_tokens} if u else {},
-            reasoning_content=getattr(msg, "reasoning_content", None) or None,
-        )
-
-    def get_default_model(self) -> str:
-        return self.default_model
-
@@ -1,10 +1,7 @@
 """LiteLLM provider implementation for multi-provider support."""

 import json
-import json_repair
 import os
-import secrets
-import string
 from typing import Any

 import litellm
@@ -14,16 +11,6 @@ from nanobot.providers.base import LLMProvider, LLMResponse, ToolCallRequest
 from nanobot.providers.registry import find_by_model, find_gateway


-# Standard OpenAI chat-completion message keys plus reasoning_content for
-# thinking-enabled models (Kimi k2.5, DeepSeek-R1, etc.).
-_ALLOWED_MSG_KEYS = frozenset({"role", "content", "tool_calls", "tool_call_id", "name", "reasoning_content"})
-_ALNUM = string.ascii_letters + string.digits
-
-def _short_tool_id() -> str:
-    """Generate a 9-char alphanumeric ID compatible with all providers (incl. Mistral)."""
-    return "".join(secrets.choice(_ALNUM) for _ in range(9))
-
-
 class LiteLLMProvider(LLMProvider):
    """
    LLM provider using LiteLLM for multi-provider support.
@@ -37,7 +24,7 @@ class LiteLLMProvider(LLMProvider):
        self, 
        api_key: str | None = None, 
        api_base: str | None = None,
-        default_model: str = "anthropic/claude-opus-4-7",
+        default_model: str = "anthropic/claude-opus-4-5",
        extra_headers: dict[str, str] | None = None,
        provider_name: str | None = None,
    ):
@@ -67,9 +54,6 @@ class LiteLLMProvider(LLMProvider):
        spec = self._gateway or find_by_model(model)
        if not spec:
            return
-        if not spec.env_key:
-            # OAuth/provider-only specs (for example: openai_codex)
-            return

        # Gateway/local overrides existing env; standard provider doesn't
        if self._gateway:
@@ -100,55 +84,11 @@ class LiteLLMProvider(LLMProvider):
        # Standard mode: auto-prefix for known providers
        spec = find_by_model(model)
        if spec and spec.litellm_prefix:
-            model = self._canonicalize_explicit_prefix(model, spec.name, spec.litellm_prefix)
            if not any(model.startswith(s) for s in spec.skip_prefixes):
                model = f"{spec.litellm_prefix}/{model}"
-
+        
        return model
-
-    @staticmethod
-    def _canonicalize_explicit_prefix(model: str, spec_name: str, canonical_prefix: str) -> str:
-        """Normalize explicit provider prefixes like `github-copilot/...`."""
-        if "/" not in model:
-            return model
-        prefix, remainder = model.split("/", 1)
-        if prefix.lower().replace("-", "_") != spec_name:
-            return model
-        return f"{canonical_prefix}/{remainder}"
    
-    def _supports_cache_control(self, model: str) -> bool:
-        """Return True when the provider supports cache_control on content blocks."""
-        if self._gateway is not None:
-            return self._gateway.supports_prompt_caching
-        spec = find_by_model(model)
-        return spec is not None and spec.supports_prompt_caching
-
-    def _apply_cache_control(
-        self,
-        messages: list[dict[str, Any]],
-        tools: list[dict[str, Any]] | None,
-    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]] | None]:
-        """Return copies of messages and tools with cache_control injected."""
-        new_messages = []
-        for msg in messages:
-            if msg.get("role") == "system":
-                content = msg["content"]
-                if isinstance(content, str):
-                    new_content = [{"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}]
-                else:
-                    new_content = list(content)
-                    new_content[-1] = {**new_content[-1], "cache_control": {"type": "ephemeral"}}
-                new_messages.append({**msg, "content": new_content})
-            else:
-                new_messages.append(msg)
-
-        new_tools = tools
-        if tools:
-            new_tools = list(tools)
-            new_tools[-1] = {**new_tools[-1], "cache_control": {"type": "ephemeral"}}
-
-        return new_messages, new_tools
-
    def _apply_model_overrides(self, model: str, kwargs: dict[str, Any]) -> None:
        """Apply model-specific parameter overrides from the registry."""
        model_lower = model.lower()
@@ -159,18 +99,6 @@ class LiteLLMProvider(LLMProvider):
                    kwargs.update(overrides)
                    return
    
-    @staticmethod
-    def _sanitize_messages(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
-        """Strip non-standard keys and ensure assistant messages have a content key."""
-        sanitized = []
-        for msg in messages:
-            clean = {k: v for k, v in msg.items() if k in _ALLOWED_MSG_KEYS}
-            # Strict providers require "content" even when assistant only has tool_calls
-            if clean.get("role") == "assistant" and "content" not in clean:
-                clean["content"] = None
-            sanitized.append(clean)
-        return sanitized
-
    async def chat(
        self,
        messages: list[dict[str, Any]],
@@ -187,26 +115,18 @@ class LiteLLMProvider(LLMProvider):
        Args:
            messages: List of message dicts with 'role' and 'content'.
            tools: Optional list of tool definitions in OpenAI format.
-            model: Model identifier (e.g., 'anthropic/claude-sonnet-4-6').
+            model: Model identifier (e.g., 'anthropic/claude-sonnet-4-5').
            max_tokens: Maximum tokens in response.
            temperature: Sampling temperature.
        
        Returns:
            LLMResponse with content and/or tool calls.
        """
-        original_model = model or self.default_model
-        model = self._resolve_model(original_model)
-
-        if self._supports_cache_control(original_model):
-            messages, tools = self._apply_cache_control(messages, tools)
-
-        # Clamp max_tokens to at least 1 — negative or zero values cause
-        # LiteLLM to reject the request with "max_tokens must be at least 1".
-        max_tokens = max(1, max_tokens)
+        model = self._resolve_model(model or self.default_model)
        
        kwargs: dict[str, Any] = {
            "model": model,
-            "messages": self._sanitize_messages(self._sanitize_empty_content(messages)),
+            "messages": messages,
            "max_tokens": max_tokens,
            "temperature": temperature,
        }
@@ -251,10 +171,13 @@ class LiteLLMProvider(LLMProvider):
                # Parse arguments from JSON string if needed
                args = tc.function.arguments
                if isinstance(args, str):
-                    args = json_repair.loads(args)
+                    try:
+                        args = json.loads(args)
+                    except json.JSONDecodeError:
+                        args = {"raw": args}
                
                tool_calls.append(ToolCallRequest(
-                    id=_short_tool_id(),
+                    id=tc.id,
                    name=tc.function.name,
                    arguments=args,
                ))
@@ -267,7 +190,7 @@ class LiteLLMProvider(LLMProvider):
                "total_tokens": response.usage.total_tokens,
            }
        
-        reasoning_content = getattr(message, "reasoning_content", None) or None
+        reasoning_content = getattr(message, "reasoning_content", None)
        
        return LLMResponse(
            content=message.content,
@@ -36,11 +36,3 @@ def get_auth_headers(token: str, is_oauth: bool = False) -> dict[str, str]:
        headers["x-api-key"] = token

    return headers
-
-
-def get_claude_code_system_prefix() -> str:
-    """Get the required system prompt prefix for OAuth tokens.
-
-    Anthropic requires this identity declaration for OAuth auth.
-    """
-    return "You are a Claude agent, built on Anthropic's Claude Agent SDK."
@@ -1,312 +0,0 @@
-"""OpenAI Codex Responses Provider."""
-
-from __future__ import annotations
-
-import asyncio
-import hashlib
-import json
-from typing import Any, AsyncGenerator
-
-import httpx
-from loguru import logger
-
-from oauth_cli_kit import get_token as get_codex_token
-from nanobot.providers.base import LLMProvider, LLMResponse, ToolCallRequest
-
-DEFAULT_CODEX_URL = "https://chatgpt.com/backend-api/codex/responses"
-DEFAULT_ORIGINATOR = "nanobot"
-
-
-class OpenAICodexProvider(LLMProvider):
-    """Use Codex OAuth to call the Responses API."""
-
-    def __init__(self, default_model: str = "openai-codex/gpt-5.1-codex"):
-        super().__init__(api_key=None, api_base=None)
-        self.default_model = default_model
-
-    async def chat(
-        self,
-        messages: list[dict[str, Any]],
-        tools: list[dict[str, Any]] | None = None,
-        model: str | None = None,
-        max_tokens: int = 4096,
-        temperature: float = 0.7,
-    ) -> LLMResponse:
-        model = model or self.default_model
-        system_prompt, input_items = _convert_messages(messages)
-
-        token = await asyncio.to_thread(get_codex_token)
-        headers = _build_headers(token.account_id, token.access)
-
-        body: dict[str, Any] = {
-            "model": _strip_model_prefix(model),
-            "store": False,
-            "stream": True,
-            "instructions": system_prompt,
-            "input": input_items,
-            "text": {"verbosity": "medium"},
-            "include": ["reasoning.encrypted_content"],
-            "prompt_cache_key": _prompt_cache_key(messages),
-            "tool_choice": "auto",
-            "parallel_tool_calls": True,
-        }
-
-        if tools:
-            body["tools"] = _convert_tools(tools)
-
-        url = DEFAULT_CODEX_URL
-
-        try:
-            try:
-                content, tool_calls, finish_reason = await _request_codex(url, headers, body, verify=True)
-            except Exception as e:
-                if "CERTIFICATE_VERIFY_FAILED" not in str(e):
-                    raise
-                logger.warning("SSL certificate verification failed for Codex API; retrying with verify=False")
-                content, tool_calls, finish_reason = await _request_codex(url, headers, body, verify=False)
-            return LLMResponse(
-                content=content,
-                tool_calls=tool_calls,
-                finish_reason=finish_reason,
-            )
-        except Exception as e:
-            return LLMResponse(
-                content=f"Error calling Codex: {str(e)}",
-                finish_reason="error",
-            )
-
-    def get_default_model(self) -> str:
-        return self.default_model
-
-
-def _strip_model_prefix(model: str) -> str:
-    if model.startswith("openai-codex/") or model.startswith("openai_codex/"):
-        return model.split("/", 1)[1]
-    return model
-
-
-def _build_headers(account_id: str, token: str) -> dict[str, str]:
-    return {
-        "Authorization": f"Bearer {token}",
-        "chatgpt-account-id": account_id,
-        "OpenAI-Beta": "responses=experimental",
-        "originator": DEFAULT_ORIGINATOR,
-        "User-Agent": "nanobot (python)",
-        "accept": "text/event-stream",
-        "content-type": "application/json",
-    }
-
-
-async def _request_codex(
-    url: str,
-    headers: dict[str, str],
-    body: dict[str, Any],
-    verify: bool,
-) -> tuple[str, list[ToolCallRequest], str]:
-    async with httpx.AsyncClient(timeout=60.0, verify=verify) as client:
-        async with client.stream("POST", url, headers=headers, json=body) as response:
-            if response.status_code != 200:
-                text = await response.aread()
-                raise RuntimeError(_friendly_error(response.status_code, text.decode("utf-8", "ignore")))
-            return await _consume_sse(response)
-
-
-def _convert_tools(tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    """Convert OpenAI function-calling schema to Codex flat format."""
-    converted: list[dict[str, Any]] = []
-    for tool in tools:
-        fn = (tool.get("function") or {}) if tool.get("type") == "function" else tool
-        name = fn.get("name")
-        if not name:
-            continue
-        params = fn.get("parameters") or {}
-        converted.append({
-            "type": "function",
-            "name": name,
-            "description": fn.get("description") or "",
-            "parameters": params if isinstance(params, dict) else {},
-        })
-    return converted
-
-
-def _convert_messages(messages: list[dict[str, Any]]) -> tuple[str, list[dict[str, Any]]]:
-    system_prompt = ""
-    input_items: list[dict[str, Any]] = []
-
-    for idx, msg in enumerate(messages):
-        role = msg.get("role")
-        content = msg.get("content")
-
-        if role == "system":
-            system_prompt = content if isinstance(content, str) else ""
-            continue
-
-        if role == "user":
-            input_items.append(_convert_user_message(content))
-            continue
-
-        if role == "assistant":
-            # Handle text first.
-            if isinstance(content, str) and content:
-                input_items.append(
-                    {
-                        "type": "message",
-                        "role": "assistant",
-                        "content": [{"type": "output_text", "text": content}],
-                        "status": "completed",
-                        "id": f"msg_{idx}",
-                    }
-                )
-            # Then handle tool calls.
-            for tool_call in msg.get("tool_calls", []) or []:
-                fn = tool_call.get("function") or {}
-                call_id, item_id = _split_tool_call_id(tool_call.get("id"))
-                call_id = call_id or f"call_{idx}"
-                item_id = item_id or f"fc_{idx}"
-                input_items.append(
-                    {
-                        "type": "function_call",
-                        "id": item_id,
-                        "call_id": call_id,
-                        "name": fn.get("name"),
-                        "arguments": fn.get("arguments") or "{}",
-                    }
-                )
-            continue
-
-        if role == "tool":
-            call_id, _ = _split_tool_call_id(msg.get("tool_call_id"))
-            output_text = content if isinstance(content, str) else json.dumps(content, ensure_ascii=False)
-            input_items.append(
-                {
-                    "type": "function_call_output",
-                    "call_id": call_id,
-                    "output": output_text,
-                }
-            )
-            continue
-
-    return system_prompt, input_items
-
-
-def _convert_user_message(content: Any) -> dict[str, Any]:
-    if isinstance(content, str):
-        return {"role": "user", "content": [{"type": "input_text", "text": content}]}
-    if isinstance(content, list):
-        converted: list[dict[str, Any]] = []
-        for item in content:
-            if not isinstance(item, dict):
-                continue
-            if item.get("type") == "text":
-                converted.append({"type": "input_text", "text": item.get("text", "")})
-            elif item.get("type") == "image_url":
-                url = (item.get("image_url") or {}).get("url")
-                if url:
-                    converted.append({"type": "input_image", "image_url": url, "detail": "auto"})
-        if converted:
-            return {"role": "user", "content": converted}
-    return {"role": "user", "content": [{"type": "input_text", "text": ""}]}
-
-
-def _split_tool_call_id(tool_call_id: Any) -> tuple[str, str | None]:
-    if isinstance(tool_call_id, str) and tool_call_id:
-        if "|" in tool_call_id:
-            call_id, item_id = tool_call_id.split("|", 1)
-            return call_id, item_id or None
-        return tool_call_id, None
-    return "call_0", None
-
-
-def _prompt_cache_key(messages: list[dict[str, Any]]) -> str:
-    raw = json.dumps(messages, ensure_ascii=True, sort_keys=True)
-    return hashlib.sha256(raw.encode("utf-8")).hexdigest()
-
-
-async def _iter_sse(response: httpx.Response) -> AsyncGenerator[dict[str, Any], None]:
-    buffer: list[str] = []
-    async for line in response.aiter_lines():
-        if line == "":
-            if buffer:
-                data_lines = [l[5:].strip() for l in buffer if l.startswith("data:")]
-                buffer = []
-                if not data_lines:
-                    continue
-                data = "\n".join(data_lines).strip()
-                if not data or data == "[DONE]":
-                    continue
-                try:
-                    yield json.loads(data)
-                except Exception:
-                    continue
-            continue
-        buffer.append(line)
-
-
-async def _consume_sse(response: httpx.Response) -> tuple[str, list[ToolCallRequest], str]:
-    content = ""
-    tool_calls: list[ToolCallRequest] = []
-    tool_call_buffers: dict[str, dict[str, Any]] = {}
-    finish_reason = "stop"
-
-    async for event in _iter_sse(response):
-        event_type = event.get("type")
-        if event_type == "response.output_item.added":
-            item = event.get("item") or {}
-            if item.get("type") == "function_call":
-                call_id = item.get("call_id")
-                if not call_id:
-                    continue
-                tool_call_buffers[call_id] = {
-                    "id": item.get("id") or "fc_0",
-                    "name": item.get("name"),
-                    "arguments": item.get("arguments") or "",
-                }
-        elif event_type == "response.output_text.delta":
-            content += event.get("delta") or ""
-        elif event_type == "response.function_call_arguments.delta":
-            call_id = event.get("call_id")
-            if call_id and call_id in tool_call_buffers:
-                tool_call_buffers[call_id]["arguments"] += event.get("delta") or ""
-        elif event_type == "response.function_call_arguments.done":
-            call_id = event.get("call_id")
-            if call_id and call_id in tool_call_buffers:
-                tool_call_buffers[call_id]["arguments"] = event.get("arguments") or ""
-        elif event_type == "response.output_item.done":
-            item = event.get("item") or {}
-            if item.get("type") == "function_call":
-                call_id = item.get("call_id")
-                if not call_id:
-                    continue
-                buf = tool_call_buffers.get(call_id) or {}
-                args_raw = buf.get("arguments") or item.get("arguments") or "{}"
-                try:
-                    args = json.loads(args_raw)
-                except Exception:
-                    args = {"raw": args_raw}
-                tool_calls.append(
-                    ToolCallRequest(
-                        id=f"{call_id}|{buf.get('id') or item.get('id') or 'fc_0'}",
-                        name=buf.get("name") or item.get("name"),
-                        arguments=args,
-                    )
-                )
-        elif event_type == "response.completed":
-            status = (event.get("response") or {}).get("status")
-            finish_reason = _map_finish_reason(status)
-        elif event_type in {"error", "response.failed"}:
-            raise RuntimeError("Codex response failed")
-
-    return content, tool_calls, finish_reason
-
-
-_FINISH_REASON_MAP = {"completed": "stop", "incomplete": "length", "failed": "error", "cancelled": "error"}
-
-
-def _map_finish_reason(status: str | None) -> str:
-    return _FINISH_REASON_MAP.get(status or "completed", "stop")
-
-
-def _friendly_error(status_code: int, raw: str) -> str:
-    if status_code == 429:
-        return "ChatGPT usage quota exceeded or rate limit triggered. Please try again later."
-    return f"HTTP {status_code}: {raw}"
@@ -51,15 +51,6 @@ class ProviderSpec:
    # per-model param overrides, e.g. (("kimi-k2.5", {"temperature": 1.0}),)
    model_overrides: tuple[tuple[str, dict[str, Any]], ...] = ()

-    # OAuth-based providers (e.g., OpenAI Codex) don't use API keys
-    is_oauth: bool = False                   # if True, uses OAuth flow instead of API key
-
-    # Direct providers bypass LiteLLM entirely (e.g., CustomProvider)
-    is_direct: bool = False
-
-    # Provider supports cache_control on content blocks (e.g. Anthropic prompt caching)
-    supports_prompt_caching: bool = False
-
    @property
    def label(self) -> str:
        return self.display_name or self.name.title()
@@ -71,16 +62,6 @@ class ProviderSpec:

 PROVIDERS: tuple[ProviderSpec, ...] = (

-    # === Custom (direct OpenAI-compatible endpoint, bypasses LiteLLM) ======
-    ProviderSpec(
-        name="custom",
-        keywords=(),
-        env_key="",
-        display_name="Custom",
-        litellm_prefix="",
-        is_direct=True,
-    ),
-
    # === Gateways (detected by api_key / api_base, not model name) =========
    # Gateways can route any model, so they win in fallback.

@@ -100,7 +81,6 @@ PROVIDERS: tuple[ProviderSpec, ...] = (
        default_api_base="https://openrouter.ai/api/v1",
        strip_model_prefix=False,
        model_overrides=(),
-        supports_prompt_caching=True,
    ),

    # AiHubMix: global gateway, OpenAI-compatible interface.
@@ -123,42 +103,6 @@ PROVIDERS: tuple[ProviderSpec, ...] = (
        model_overrides=(),
    ),

-    # SiliconFlow (硅基流动): OpenAI-compatible gateway, model names keep org prefix
-    ProviderSpec(
-        name="siliconflow",
-        keywords=("siliconflow",),
-        env_key="OPENAI_API_KEY",
-        display_name="SiliconFlow",
-        litellm_prefix="openai",
-        skip_prefixes=(),
-        env_extras=(),
-        is_gateway=True,
-        is_local=False,
-        detect_by_key_prefix="",
-        detect_by_base_keyword="siliconflow",
-        default_api_base="https://api.siliconflow.cn/v1",
-        strip_model_prefix=False,
-        model_overrides=(),
-    ),
-
-    # VolcEngine (火山引擎): OpenAI-compatible gateway
-    ProviderSpec(
-        name="volcengine",
-        keywords=("volcengine", "volces", "ark"),
-        env_key="OPENAI_API_KEY",
-        display_name="VolcEngine",
-        litellm_prefix="volcengine",
-        skip_prefixes=(),
-        env_extras=(),
-        is_gateway=True,
-        is_local=False,
-        detect_by_key_prefix="",
-        detect_by_base_keyword="volces",
-        default_api_base="https://ark.cn-beijing.volces.com/api/v3",
-        strip_model_prefix=False,
-        model_overrides=(),
-    ),
-
    # === Standard providers (matched by model-name keywords) ===============

    # Anthropic: LiteLLM recognizes "claude-*" natively, no prefix needed.
@@ -177,7 +121,6 @@ PROVIDERS: tuple[ProviderSpec, ...] = (
        default_api_base="",
        strip_model_prefix=False,
        model_overrides=(),
-        supports_prompt_caching=True,
    ),

    # OpenAI: LiteLLM recognizes "gpt-*" natively, no prefix needed.
@@ -198,44 +141,6 @@ PROVIDERS: tuple[ProviderSpec, ...] = (
        model_overrides=(),
    ),

-    # OpenAI Codex: uses OAuth, not API key.
-    ProviderSpec(
-        name="openai_codex",
-        keywords=("openai-codex", "codex"),
-        env_key="",                         # OAuth-based, no API key
-        display_name="OpenAI Codex",
-        litellm_prefix="",                  # Not routed through LiteLLM
-        skip_prefixes=(),
-        env_extras=(),
-        is_gateway=False,
-        is_local=False,
-        detect_by_key_prefix="",
-        detect_by_base_keyword="codex",
-        default_api_base="https://chatgpt.com/backend-api",
-        strip_model_prefix=False,
-        model_overrides=(),
-        is_oauth=True,                      # OAuth-based authentication
-    ),
-
-    # Github Copilot: uses OAuth, not API key.
-    ProviderSpec(
-        name="github_copilot",
-        keywords=("github_copilot", "copilot"),
-        env_key="",                         # OAuth-based, no API key
-        display_name="Github Copilot",
-        litellm_prefix="github_copilot",   # github_copilot/model → github_copilot/model
-        skip_prefixes=("github_copilot/",),
-        env_extras=(),
-        is_gateway=False,
-        is_local=False,
-        detect_by_key_prefix="",
-        detect_by_base_keyword="",
-        default_api_base="",
-        strip_model_prefix=False,
-        model_overrides=(),
-        is_oauth=True,                      # OAuth-based authentication
-    ),
-
    # DeepSeek: needs "deepseek/" prefix for LiteLLM routing.
    ProviderSpec(
        name="deepseek",
@@ -407,18 +312,10 @@ def find_by_model(model: str) -> ProviderSpec | None:
    """Match a standard provider by model-name keyword (case-insensitive).
    Skips gateways/local — those are matched by api_key/api_base instead."""
    model_lower = model.lower()
-    model_normalized = model_lower.replace("-", "_")
-    model_prefix = model_lower.split("/", 1)[0] if "/" in model_lower else ""
-    normalized_prefix = model_prefix.replace("-", "_")
-    std_specs = [s for s in PROVIDERS if not s.is_gateway and not s.is_local]
-
-    # Prefer explicit provider prefix — prevents `github-copilot/...codex` matching openai_codex.
-    for spec in std_specs:
-        if model_prefix and normalized_prefix == spec.name:
-            return spec
-
-    for spec in std_specs:
-        if any(kw in model_lower or kw.replace("-", "_") in model_normalized for kw in spec.keywords):
+    for spec in PROVIDERS:
+        if spec.is_gateway or spec.is_local:
+            continue
+        if any(kw in model_lower for kw in spec.keywords):
            return spec
    return None

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