Merge branch 'moltbot:main' into main

2026-01-28 00:29:48 -05:00 · 2026-01-28 00:29:48 -05:00 · 860de1d751
commit 860de1d751
parent fd3e86ffe0 6fc3ca4996
32 changed files with 869 additions and 181 deletions
--- a/.github/workflows/auto-response.yml
+++ b/.github/workflows/auto-response.yml
@ -24,13 +24,26 @@ jobs:
        with:
          github-token: ${{ steps.app-token.outputs.token }}
          script: |
+            // Labels prefixed with "r:" are auto-response triggers.
            const rules = [
              {
-                label: "skill-clawdhub",
+                label: "r: skill",
                close: true,
                message:
                  "Thanks for the contribution! New skills should be published to Clawdhub for everyone to use. We’re keeping the core lean on skills, so I’m closing this out.",
              },
+              {
+                label: "r: support",
+                close: true,
+                message:
+                  "Please use our support server https://molt.bot/discord and ask in #help or #users-helping-users to resolve this, or follow the stuck FAQ at https://docs.molt.bot/help/faq#im-stuck-whats-the-fastest-way-to-get-unstuck.",
+              },
+              {
+                label: "r: third-party-extension",
+                close: true,
+                message:
+                  "This would be better made as a third-party extension with our SDK that you maintain yourself. Docs: https://docs.molt.bot/plugin.",
+              },
            ];

            const labelName = context.payload.label?.name;
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -51,6 +51,7 @@ Status: beta.
 - Telegram: support plugin sendPayload channelData (media/buttons) and validate plugin commands. (#1917) Thanks @JoshuaLelon.
 - Telegram: avoid block replies when streaming is disabled. (#1885) Thanks @ivancasco.
 - Docs: keep docs header sticky so navbar stays visible while scrolling. (#2445) Thanks @chenyuan99.
+- Docs: update exe.dev install instructions. (#https://github.com/moltbot/moltbot/pull/3047) Thanks @zackerthescar.
 - Security: use Windows ACLs for permission audits and fixes on Windows. (#1957)
 - Auth: show copyable Google auth URL after ASCII prompt. (#1787) Thanks @robbyczgw-cla.
 - Routing: precompile session key regexes. (#1697) Thanks @Ray0907.
@ -76,6 +77,13 @@ Status: beta.
 - macOS: auto-scroll to bottom when sending a new message while scrolled up. (#2471) Thanks @kennyklee.
 - Web UI: auto-expand the chat compose textarea while typing (with sensible max height). (#2950) Thanks @shivamraut101.
 - Gateway: prevent crashes on transient network errors (fetch failures, timeouts, DNS). Added fatal error detection to only exit on truly critical errors. Fixes #2895, #2879, #2873. (#2980) Thanks @elliotsecops.
+- Agents: guard channel tool listActions to avoid plugin crashes. (#2859) Thanks @mbelinky.
+- Discord: avoid resolving bare channel names to user DMs when a username matches. Thanks @thewilloftheshadow.
+- Discord: fix directory config type import for target resolution. Thanks @thewilloftheshadow.
+- Providers: update MiniMax API endpoint and compatibility mode. (#3064) Thanks @hlbbbbbbb.
+- Telegram: treat more network errors as recoverable in polling. (#3013) Thanks @ryancontent.
+- Discord: resolve usernames to user IDs for outbound messages. (#2649) Thanks @nonggialiang.
+- Providers: update Moonshot Kimi model references to kimi-k2.5. (#2762) Thanks @MarvinCui.
 - Gateway: suppress AbortError and transient network errors in unhandled rejections. (#2451) Thanks @Glucksberg.
 - TTS: keep /tts status replies on text-only commands and avoid duplicate block-stream audio. (#2451) Thanks @Glucksberg.
 - Security: pin npm overrides to keep tar@7.5.4 for install toolchains.
@ -89,6 +97,7 @@ Status: beta.
 - Agents: release session locks on process termination and cover more signals. (#2483) Thanks @janeexai.
 - Agents: skip cooldowned providers during model failover. (#2143) Thanks @YiWang24.
 - Telegram: harden polling + retry behavior for transient network errors and Node 22 transport issues. (#2420) Thanks @techboss.
+- Telegram: ignore non-forum group message_thread_id while preserving DM thread sessions. (#2731) Thanks @dylanneve1.
 - Telegram: wrap reasoning italics per line to avoid raw underscores. (#2181) Thanks @YuriNachos.
 - Telegram: centralize API error logging for delivery and bot calls. (#2492) Thanks @altryne.
 - Voice Call: enforce Twilio webhook signature verification for ngrok URLs; disable ngrok free tier bypass by default.
--- a/docs/concepts/model-providers.md
+++ b/docs/concepts/model-providers.md
@ -130,9 +130,10 @@ Moonshot uses OpenAI-compatible endpoints, so configure it as a custom provider:

 - Provider: `moonshot`
 - Auth: `MOONSHOT_API_KEY`
- Example model: `moonshot/kimi-k2-0905-preview`
+- Example model: `moonshot/kimi-k2.5`
 - Kimi K2 model IDs:
  {/* moonshot-kimi-k2-model-refs:start */}
+  - `moonshot/kimi-k2.5`
  - `moonshot/kimi-k2-0905-preview`
  - `moonshot/kimi-k2-turbo-preview`
  - `moonshot/kimi-k2-thinking`
@ -141,7 +142,7 @@ Moonshot uses OpenAI-compatible endpoints, so configure it as a custom provider:
 ```json5
 {
  agents: {
-    defaults: { model: { primary: "moonshot/kimi-k2-0905-preview" } }
+    defaults: { model: { primary: "moonshot/kimi-k2.5" } }
  },
  models: {
    mode: "merge",
@ -150,7 +151,7 @@ Moonshot uses OpenAI-compatible endpoints, so configure it as a custom provider:
        baseUrl: "https://api.moonshot.ai/v1",
        apiKey: "${MOONSHOT_API_KEY}",
        api: "openai-completions",
-        models: [{ id: "kimi-k2-0905-preview", name: "Kimi K2 0905 Preview" }]
+        models: [{ id: "kimi-k2.5", name: "Kimi K2.5" }]
      }
    }
  }
--- a/docs/gateway/configuration.md
+++ b/docs/gateway/configuration.md
@ -2396,8 +2396,8 @@ Use Moonshot's OpenAI-compatible endpoint:
  env: { MOONSHOT_API_KEY: "sk-..." },
  agents: {
    defaults: {
-      model: { primary: "moonshot/kimi-k2-0905-preview" },
-      models: { "moonshot/kimi-k2-0905-preview": { alias: "Kimi K2" } }
+      model: { primary: "moonshot/kimi-k2.5" },
+      models: { "moonshot/kimi-k2.5": { alias: "Kimi K2.5" } }
    }
  },
  models: {
@ -2409,8 +2409,8 @@ Use Moonshot's OpenAI-compatible endpoint:
        api: "openai-completions",
        models: [
          {
-            id: "kimi-k2-0905-preview",
-            name: "Kimi K2 0905 Preview",
+            id: "kimi-k2.5",
+            name: "Kimi K2.5",
            reasoning: false,
            input: ["text"],
            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
@ -2426,7 +2426,7 @@ Use Moonshot's OpenAI-compatible endpoint:

 Notes:
 - Set `MOONSHOT_API_KEY` in the environment or use `moltbot onboard --auth-choice moonshot-api-key`.
- Model ref: `moonshot/kimi-k2-0905-preview`.
+- Model ref: `moonshot/kimi-k2.5`.
 - Use `https://api.moonshot.cn/v1` if you need the China endpoint.

 ### Kimi Code
--- a/docs/platforms/exe-dev.md
+++ b/docs/platforms/exe-dev.md
@ -7,40 +7,47 @@ read_when:

 # exe.dev

-Goal: Moltbot Gateway running on an exe.dev VM, reachable from your laptop via:
- **exe.dev HTTPS proxy** (easy, no tunnel) or
- **SSH tunnel** (most secure; loopback-only Gateway)
+Goal: Moltbot Gateway running on an exe.dev VM, reachable from your laptop via: `https://<vm-name>.exe.xyz`

-This page assumes **Ubuntu/Debian**. If you picked a different distro, map packages accordingly.
-
-If you’re on any other Linux VPS, the same steps apply — you just won’t use the exe.dev proxy commands.
+This page assumes exe.dev's default **exeuntu** image. If you picked a different distro, map packages accordingly.

 ## Beginner quick path

-1) Create VM → install Node 22 → install Moltbot  
-2) Run `moltbot onboard --install-daemon`  
-3) Tunnel from laptop (`ssh -N -L 18789:127.0.0.1:18789 …`)  
-4) Open `http://127.0.0.1:18789/` and paste your token
+1) [https://exe.new/moltbot](https://exe.new/moltbot)
+2) Fill in your auth key/token as needed
+3) Click on "Agent" next to your VM, and wait...
+4) ???
+5) Profit

 ## What you need

- exe.dev account + `ssh exe.dev` working on your laptop
- SSH keys set up (your laptop → exe.dev)
- Model auth (OAuth or API key) you want to use
- Provider credentials (optional): WhatsApp QR scan, Telegram bot token, Discord bot token, …
+- exe.dev account
+- `ssh exe.dev` access to [exe.dev](https://exe.dev) virtual machines (optional)
+
+
+## Automated Install with Shelley
+
+Shelley, [exe.dev](https://exe.dev)'s agent, can install Moltbot instantly with our
+prompt. The prompt used is as below:
+
+```
+Set up Moltbot (https://docs.molt.bot/install) on this VM. Use the non-interactive and accept-risk flags for moltbot onboarding. Add the supplied auth or token as needed. Configure nginx to forward from the default port 18789 to the root location on the default enabled site config, making sure to enable Websocket support. Pairing is done by "moltbot devices list" and "moltbot device approve <request id>". Make sure the dashboard shows that Moltbot's health is OK. exe.dev handles forwarding from port 8000 to port 80/443 and HTTPS for us, so the final "reachable" should be <vm-name>.exe.xyz, without port specification.
+```
+
+## Manual installation

 ## 1) Create the VM

-From your laptop:
+From your device:

 ```bash
-ssh exe.dev new --name=moltbot
+ssh exe.dev new 
 ```

 Then connect:

 ```bash
-ssh moltbot.exe.xyz
+ssh <vm-name>.exe.xyz
 ```

 Tip: keep this VM **stateful**. Moltbot stores state under `~/.clawdbot/` and `~/clawd/`.
@ -52,130 +59,61 @@ sudo apt-get update
 sudo apt-get install -y git curl jq ca-certificates openssl
 ```

-### Node 22
-
-Install Node **>= 22.12** (any method is fine). Quick check:
-
-```bash
-node -v
-```
-
-If you don’t already have Node 22 on the VM, use your preferred Node manager (nvm/mise/asdf) or a distro package source that provides Node 22+.
-
-Common Ubuntu/Debian option (NodeSource):
-
-```bash
-curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
-sudo apt-get install -y nodejs
-```
-
 ## 3) Install Moltbot

-Recommended on servers: npm global install.
+Run the Moltbot install script:

 ```bash
-npm i -g moltbot@latest
-moltbot --version
+curl -fsSL https://molt.bot/install.sh | bash
 ```

-If native deps fail to install (rare; usually `sharp`), add build tools:
+## 4) Setup nginx to proxy Moltbot to port 8000
+
+Edit `/etc/nginx/sites-enabled/default` with

-```bash
-sudo apt-get install -y build-essential python3
 ```
+server {
+    listen 80 default_server;
+    listen [::]:80 default_server;
+    listen 8000;
+    listen [::]:8000;

-## 4) First-time setup (wizard)
+    server_name _;

-Run the onboarding wizard on the VM:
+    location / {
+        proxy_pass http://127.0.0.1:18789;
+        proxy_http_version 1.1;

-```bash
-moltbot onboard --install-daemon
-```
+        # WebSocket support
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";

-It can set up:
- `~/clawd` workspace bootstrap
- `~/.clawdbot/moltbot.json` config
- model auth profiles
- model provider config/login
- Linux systemd **user** service (service)
+        # Standard proxy headers
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;

-If you’re doing OAuth on a headless VM: do OAuth on a normal machine first, then copy the auth profile to the VM (see [Help](/help)).
-
-## 5) Remote access options
-
-### Option A (recommended): SSH tunnel (loopback-only)
-
-Keep Gateway on loopback (default) and tunnel it from your laptop:
-
-```bash
-ssh -N -L 18789:127.0.0.1:18789 moltbot.exe.xyz
-```
-
-Open locally:
- `http://127.0.0.1:18789/` (Control UI)
-
-Runbook: [Remote access](/gateway/remote)
-
-### Option B: exe.dev HTTPS proxy (no tunnel)
-
-To let exe.dev proxy traffic to the VM, bind the Gateway to the LAN interface and set a token:
-
-```bash
-export CLAWDBOT_GATEWAY_TOKEN="$(openssl rand -hex 32)"
-moltbot gateway --bind lan --port 8080 --token "$CLAWDBOT_GATEWAY_TOKEN"
-```
-
-For service runs, persist it in `~/.clawdbot/moltbot.json`:
-
-```json5
-{
-  gateway: {
-    mode: "local",
-    port: 8080,
-    bind: "lan",
-    auth: { mode: "token", token: "YOUR_TOKEN" }
-  }
+        # Timeout settings for long-lived connections
+        proxy_read_timeout 86400s;
+        proxy_send_timeout 86400s;
+    }
 }
 ```

-Notes:
- Non-loopback binds require `gateway.auth.token` (or `CLAWDBOT_GATEWAY_TOKEN`).
- `gateway.remote.token` is only for remote CLI calls; it does not enable local auth.
+## 5) Access Moltbot and grant privileges

-Then point exe.dev’s proxy at `8080` (or whatever port you chose) and open your VM’s HTTPS URL:
+Access `https://<vm-name>.exe.xyz/?token=YOUR-TOKEN-FROM-TERMINAL`. Approve
+devices with `moltbot devices list` and `moltbot device approve`. When in doubt,
+use Shelley from your browser!

-```bash
-ssh exe.dev share port moltbot 8080
-```
+## Remote Access

-Open:
- `https://moltbot.exe.xyz/`
+Remote access is handled by [exe.dev](https://exe.dev)'s authentication. By
+default, HTTP traffic from port 8000 is forwarded to `https://<vm-name>.exe.xyz`
+with email auth. 

-In the Control UI, paste the token (UI → Settings → token). The UI sends it as `connect.params.auth.token`.
-
-Notes:
- Prefer a **non-default** port (like `8080`) if your proxy expects an app port.
- Treat the token like a password.
-
-Control UI details: [Control UI](/web/control-ui)
-
-## 6) Keep it running (service)
-
-On Linux, Moltbot uses a systemd **user** service. After `--install-daemon`, verify:
-
-```bash
-systemctl --user status moltbot-gateway[-<profile>].service
-```
-
-If the service dies after logout, enable lingering:
-
-```bash
-sudo loginctl enable-linger "$USER"
-```
-
-More: [Linux](/platforms/linux)
-
-## 7) Updates
+## Updating

 ```bash
 npm i -g moltbot@latest
--- a/docs/providers/moonshot.md
+++ b/docs/providers/moonshot.md
@ -9,11 +9,12 @@ read_when:
 # Moonshot AI (Kimi)

 Moonshot provides the Kimi API with OpenAI-compatible endpoints. Configure the
-provider and set the default model to `moonshot/kimi-k2-0905-preview`, or use
+provider and set the default model to `moonshot/kimi-k2.5`, or use
 Kimi Code with `kimi-code/kimi-for-coding`.

 Current Kimi K2 model IDs:
 {/* moonshot-kimi-k2-ids:start */}
+- `kimi-k2.5`
 - `kimi-k2-0905-preview`
 - `kimi-k2-turbo-preview`
 - `kimi-k2-thinking`
@ -39,9 +40,10 @@ Note: Moonshot and Kimi Code are separate providers. Keys are not interchangeabl
  env: { MOONSHOT_API_KEY: "sk-..." },
  agents: {
    defaults: {
-      model: { primary: "moonshot/kimi-k2-0905-preview" },
+      model: { primary: "moonshot/kimi-k2.5" },
      models: {
        // moonshot-kimi-k2-aliases:start
+        "moonshot/kimi-k2.5": { alias: "Kimi K2.5" },
        "moonshot/kimi-k2-0905-preview": { alias: "Kimi K2" },
        "moonshot/kimi-k2-turbo-preview": { alias: "Kimi K2 Turbo" },
        "moonshot/kimi-k2-thinking": { alias: "Kimi K2 Thinking" },
@ -59,6 +61,15 @@ Note: Moonshot and Kimi Code are separate providers. Keys are not interchangeabl
        api: "openai-completions",
        models: [
          // moonshot-kimi-k2-models:start
+          {
+            id: "kimi-k2.5",
+            name: "Kimi K2.5",
+            reasoning: false,
+            input: ["text"],
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+            contextWindow: 256000,
+            maxTokens: 8192
+          },
          {
            id: "kimi-k2-0905-preview",
            name: "Kimi K2 0905 Preview",
--- a/skills/bitwarden/SKILL.md
+++ b/skills/bitwarden/SKILL.md
@ -0,0 +1,101 @@
+---
+name: bitwarden
+description: Manage passwords and credentials via Bitwarden CLI (bw). Use for storing, retrieving, creating, or updating logins, credit cards, secure notes, and identities. Trigger when automating authentication, filling payment forms, or managing secrets programmatically.
+---
+
+# Bitwarden CLI
+
+Full read/write vault access via `bw` command.
+
+## Prerequisites
+
+```bash
+brew install bitwarden-cli
+bw login <email>  # one-time, prompts for master password
+```
+
+## Session Management
+
+Bitwarden requires an unlocked session. Use the helper script:
+
+```bash
+source scripts/bw-session.sh <master_password>
+# Sets BW_SESSION env var
+```
+
+Or manually:
+```bash
+export BW_SESSION=$(echo '<password>' | bw unlock --raw)
+bw sync  # always sync after unlock
+```
+
+## Common Operations
+
+### Retrieve credentials
+```bash
+bw get password "Site Name"
+bw get username "Site Name"
+bw get item "Site Name" --pretty | jq '.login'
+```
+
+### Create login
+```bash
+bw get template item | jq '
+  .type = 1 |
+  .name = "Site Name" |
+  .login.username = "user@email.com" |
+  .login.password = "secret123" |
+  .login.uris = [{uri: "https://example.com"}]
+' | bw encode | bw create item
+```
+
+### Create credit card
+```bash
+bw get template item | jq '
+  .type = 3 |
+  .name = "Card Name" |
+  .card.cardholderName = "John Doe" |
+  .card.brand = "Visa" |
+  .card.number = "4111111111111111" |
+  .card.expMonth = "12" |
+  .card.expYear = "2030" |
+  .card.code = "123"
+' | bw encode | bw create item
+```
+
+### Get card for payment automation
+```bash
+bw get item "Card Name" | jq -r '.card | "\(.number) \(.expMonth)/\(.expYear) \(.code)"'
+```
+
+### List items
+```bash
+bw list items | jq -r '.[] | "\(.type)|\(.name)"'
+# Types: 1=login, 2=note, 3=card, 4=identity
+```
+
+### Search
+```bash
+bw list items --search "vilaviniteca" | jq '.[0]'
+```
+
+## Item Types
+
+| Type | Value | Use |
+|------|-------|-----|
+| Login | 1 | Website credentials |
+| Secure Note | 2 | Freeform text |
+| Card | 3 | Credit/debit cards |
+| Identity | 4 | Personal info |
+
+## References
+
+- [templates.md](references/templates.md) — Full jq templates for all item types
+- [Bitwarden CLI docs](https://bitwarden.com/help/cli/)
+
+## Tips
+
+1. **Always sync** after creating/editing items: `bw sync`
+2. **Session expires** — re-unlock if you get auth errors
+3. **Delete sensitive messages** after receiving credentials
+4. **Card numbers** may not import from other managers (security restriction)
--- a/skills/bitwarden/references/templates.md
+++ b/skills/bitwarden/references/templates.md
@ -0,0 +1,116 @@
+# Bitwarden Item Templates
+
+jq patterns for creating vault items via CLI.
+
+## Login (type=1)
+
+```bash
+bw get template item | jq '
+  .type = 1 |
+  .name = "Example Site" |
+  .notes = "Optional notes" |
+  .favorite = false |
+  .login.username = "user@example.com" |
+  .login.password = "secretPassword123" |
+  .login.totp = "otpauth://totp/..." |
+  .login.uris = [
+    {uri: "https://example.com", match: null},
+    {uri: "https://app.example.com", match: null}
+  ]
+' | bw encode | bw create item
+```
+
+## Credit Card (type=3)
+
+```bash
+bw get template item | jq '
+  .type = 3 |
+  .name = "Visa ending 1234" |
+  .notes = "Primary card" |
+  .card.cardholderName = "JOHN DOE" |
+  .card.brand = "Visa" |
+  .card.number = "4111111111111111" |
+  .card.expMonth = "12" |
+  .card.expYear = "2030" |
+  .card.code = "123"
+' | bw encode | bw create item
+```
+
+**Brands:** Visa, Mastercard, Amex, Discover, Diners Club, JCB, Maestro, UnionPay, Other
+
+## Secure Note (type=2)
+
+```bash
+bw get template item | jq '
+  .type = 2 |
+  .name = "API Keys" |
+  .notes = "OPENAI_KEY=sk-xxx\nANTHROPIC_KEY=sk-ant-xxx" |
+  .secureNote.type = 0
+' | bw encode | bw create item
+```
+
+## Identity (type=4)
+
+```bash
+bw get template item | jq '
+  .type = 4 |
+  .name = "Personal Info" |
+  .identity.title = "Mr" |
+  .identity.firstName = "John" |
+  .identity.lastName = "Doe" |
+  .identity.email = "john@example.com" |
+  .identity.phone = "+34612345678" |
+  .identity.address1 = "123 Main St" |
+  .identity.city = "Barcelona" |
+  .identity.state = "Catalunya" |
+  .identity.postalCode = "08001" |
+  .identity.country = "ES"
+' | bw encode | bw create item
+```
+
+## Edit Existing Item
+
+```bash
+# Get item, modify, update
+bw get item <id> | jq '.login.password = "newPassword"' | bw encode | bw edit item <id>
+```
+
+## Custom Fields
+
+```bash
+bw get template item | jq '
+  .type = 1 |
+  .name = "With Custom Fields" |
+  .fields = [
+    {name: "Security Question", value: "Pet name", type: 0},
+    {name: "PIN", value: "1234", type: 1}
+  ]
+' | bw encode | bw create item
+```
+
+**Field types:** 0=text, 1=hidden, 2=boolean
+
+## Retrieve Patterns
+
+```bash
+# Password only
+bw get password "Site Name"
+
+# Username only  
+bw get username "Site Name"
+
+# Full login object
+bw get item "Site Name" | jq '.login'
+
+# Card number
+bw get item "Card Name" | jq -r '.card.number'
+
+# All card fields for form filling
+bw get item "Card Name" | jq -r '.card | [.number, .expMonth, .expYear, .code] | @tsv'
+
+# Search by URL
+bw list items --url "example.com" | jq '.[0].login'
+
+# List all cards
+bw list items | jq '.[] | select(.type == 3) | .name'
+```
--- a/skills/bitwarden/scripts/bw-session.sh
+++ b/skills/bitwarden/scripts/bw-session.sh
@ -0,0 +1,33 @@
+#!/bin/bash
+# Unlock Bitwarden vault and export session key
+# Usage: source bw-session.sh <master_password>
+# Or:    source bw-session.sh (prompts for password)
+
+set -e
+
+if [ -n "$1" ]; then
+    MASTER_PW="$1"
+else
+    read -sp "Bitwarden master password: " MASTER_PW
+    echo
+fi
+
+# Check if already logged in
+if ! bw login --check &>/dev/null; then
+    echo "Not logged in. Run: bw login <email>"
+    return 1
+fi
+
+# Unlock and get session
+export BW_SESSION=$(echo "$MASTER_PW" | bw unlock --raw 2>/dev/null)
+
+if [ -z "$BW_SESSION" ]; then
+    echo "Failed to unlock vault"
+    return 1
+fi
+
+# Sync to get latest
+bw sync &>/dev/null
+
+echo "✓ Vault unlocked and synced"
+echo "Session valid for this shell"
--- a/src/agents/channel-tools.test.ts
+++ b/src/agents/channel-tools.test.ts
@ -0,0 +1,53 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { MoltbotConfig } from "../config/config.js";
+import type { ChannelPlugin } from "../channels/plugins/types.js";
+import { setActivePluginRegistry } from "../plugins/runtime.js";
+import { createTestRegistry } from "../test-utils/channel-plugins.js";
+import { defaultRuntime } from "../runtime.js";
+import { __testing, listAllChannelSupportedActions } from "./channel-tools.js";
+
+describe("channel tools", () => {
+  const errorSpy = vi.spyOn(defaultRuntime, "error").mockImplementation(() => undefined);
+
+  beforeEach(() => {
+    const plugin: ChannelPlugin = {
+      id: "test",
+      meta: {
+        id: "test",
+        label: "Test",
+        selectionLabel: "Test",
+        docsPath: "/channels/test",
+        blurb: "test plugin",
+      },
+      capabilities: { chatTypes: ["direct"] },
+      config: {
+        listAccountIds: () => [],
+        resolveAccount: () => ({}),
+      },
+      actions: {
+        listActions: () => {
+          throw new Error("boom");
+        },
+      },
+    };
+
+    __testing.resetLoggedListActionErrors();
+    errorSpy.mockClear();
+    setActivePluginRegistry(createTestRegistry([{ pluginId: "test", source: "test", plugin }]));
+  });
+
+  afterEach(() => {
+    setActivePluginRegistry(createTestRegistry([]));
+    errorSpy.mockClear();
+  });
+
+  it("skips crashing plugins and logs once", () => {
+    const cfg = {} as MoltbotConfig;
+    expect(listAllChannelSupportedActions({ cfg })).toEqual([]);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+
+    expect(listAllChannelSupportedActions({ cfg })).toEqual([]);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+});
--- a/src/agents/channel-tools.ts
+++ b/src/agents/channel-tools.ts
@ -1,8 +1,13 @@
 import { getChannelDock } from "../channels/dock.js";
 import { getChannelPlugin, listChannelPlugins } from "../channels/plugins/index.js";
 import { normalizeAnyChannelId } from "../channels/registry.js";
-import type { ChannelAgentTool, ChannelMessageActionName } from "../channels/plugins/types.js";
+import type {
+  ChannelAgentTool,
+  ChannelMessageActionName,
+  ChannelPlugin,
+} from "../channels/plugins/types.js";
 import type { MoltbotConfig } from "../config/config.js";
+import { defaultRuntime } from "../runtime.js";

 /**
 * Get the list of supported message actions for a specific channel.
@ -16,7 +21,7 @@ export function listChannelSupportedActions(params: {
  const plugin = getChannelPlugin(params.channel as Parameters<typeof getChannelPlugin>[0]);
  if (!plugin?.actions?.listActions) return [];
  const cfg = params.cfg ?? ({} as MoltbotConfig);
-  return plugin.actions.listActions({ cfg });
+  return runPluginListActions(plugin, cfg);
 }

 /**
@ -29,7 +34,7 @@ export function listAllChannelSupportedActions(params: {
  for (const plugin of listChannelPlugins()) {
    if (!plugin.actions?.listActions) continue;
    const cfg = params.cfg ?? ({} as MoltbotConfig);
-    const channelActions = plugin.actions.listActions({ cfg });
+    const channelActions = runPluginListActions(plugin, cfg);
    for (const action of channelActions) {
      actions.add(action);
    }
@ -64,3 +69,35 @@ export function resolveChannelMessageToolHints(params: {
    .map((entry) => entry.trim())
    .filter(Boolean);
 }
+
+const loggedListActionErrors = new Set<string>();
+
+function runPluginListActions(
+  plugin: ChannelPlugin,
+  cfg: MoltbotConfig,
+): ChannelMessageActionName[] {
+  if (!plugin.actions?.listActions) return [];
+  try {
+    const listed = plugin.actions.listActions({ cfg });
+    return Array.isArray(listed) ? listed : [];
+  } catch (err) {
+    logListActionsError(plugin.id, err);
+    return [];
+  }
+}
+
+function logListActionsError(pluginId: string, err: unknown) {
+  const message = err instanceof Error ? err.message : String(err);
+  const key = `${pluginId}:${message}`;
+  if (loggedListActionErrors.has(key)) return;
+  loggedListActionErrors.add(key);
+  const stack = err instanceof Error && err.stack ? err.stack : null;
+  const details = stack ?? message;
+  defaultRuntime.error?.(`[channel-tools] ${pluginId}.actions.listActions failed: ${details}`);
+}
+
+export const __testing = {
+  resetLoggedListActionErrors() {
+    loggedListActionErrors.clear();
+  },
+};
--- a/src/agents/models-config.providers.ts
+++ b/src/agents/models-config.providers.ts
@ -17,7 +17,7 @@ import { discoverVeniceModels, VENICE_BASE_URL } from "./venice-models.js";
 type ModelsConfig = NonNullable<MoltbotConfig["models"]>;
 export type ProviderConfig = NonNullable<ModelsConfig["providers"]>[string];

-const MINIMAX_API_BASE_URL = "https://api.minimax.io/anthropic";
+const MINIMAX_API_BASE_URL = "https://api.minimax.chat/v1";
 const MINIMAX_DEFAULT_MODEL_ID = "MiniMax-M2.1";
 const MINIMAX_DEFAULT_VISION_MODEL_ID = "MiniMax-VL-01";
 const MINIMAX_DEFAULT_CONTEXT_WINDOW = 200000;
@ -31,7 +31,7 @@ const MINIMAX_API_COST = {
 };

 const MOONSHOT_BASE_URL = "https://api.moonshot.ai/v1";
-const MOONSHOT_DEFAULT_MODEL_ID = "kimi-k2-0905-preview";
+const MOONSHOT_DEFAULT_MODEL_ID = "kimi-k2.5";
 const MOONSHOT_DEFAULT_CONTEXT_WINDOW = 256000;
 const MOONSHOT_DEFAULT_MAX_TOKENS = 8192;
 const MOONSHOT_DEFAULT_COST = {
@ -244,7 +244,7 @@ export function normalizeProviders(params: {
 function buildMinimaxProvider(): ProviderConfig {
  return {
    baseUrl: MINIMAX_API_BASE_URL,
-    api: "anthropic-messages",
+    api: "openai-completions",
    models: [
      {
        id: MINIMAX_DEFAULT_MODEL_ID,
@ -275,7 +275,7 @@ function buildMoonshotProvider(): ProviderConfig {
    models: [
      {
        id: MOONSHOT_DEFAULT_MODEL_ID,
-        name: "Kimi K2 0905 Preview",
+        name: "Kimi K2.5",
        reasoning: false,
        input: ["text"],
        cost: MOONSHOT_DEFAULT_COST,
--- a/src/agents/transcript-policy.ts
+++ b/src/agents/transcript-policy.ts
@ -51,7 +51,8 @@ function isOpenAiProvider(provider?: string | null): boolean {
 function isAnthropicApi(modelApi?: string | null, provider?: string | null): boolean {
  if (modelApi === "anthropic-messages") return true;
  const normalized = normalizeProviderId(provider ?? "");
-  return normalized === "anthropic" || normalized === "minimax";
+  // MiniMax now uses openai-completions API, not anthropic-messages
+  return normalized === "anthropic";
 }

 function isMistralModel(params: { provider?: string | null; modelId?: string | null }): boolean {
--- a/src/cli/banner.ts
+++ b/src/cli/banner.ts
@ -65,12 +65,12 @@ export function formatCliBannerLine(version: string, options: BannerOptions = {}
 }

 const LOBSTER_ASCII = [
-  "░████░█░░░░░█████░█░░░█░███░░████░░████░░▀█▀",
-  "█░░░░░█░░░░░█░░░█░█░█░█░█░░█░█░░░█░█░░░█░░█░",
-  "█░░░░░█░░░░░█████░█░█░█░█░░█░████░░█░░░█░░█░",
-  "█░░░░░█░░░░░█░░░█░█░█░█░█░░█░█░░█░░█░░░█░░█░",
-  "░████░█████░█░░░█░░█░█░░███░░████░░░███░░░█░",
-  "              🦞 FRESH DAILY 🦞",
+  "▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄",
+  "██░▄▀▄░██░▄▄▄░██░████▄▄░▄▄██░▄▄▀██░▄▄▄░█▄▄░▄▄██",
+  "██░█░█░██░███░██░██████░████░▄▄▀██░███░███░████",
+  "██░███░██░▀▀▀░██░▀▀░███░████░▀▀░██░▀▀▀░███░████",
+  "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀",
+  "               🦞 FRESH DAILY 🦞               ",
 ];

 export function formatCliBannerArt(options: BannerOptions = {}): string {
--- a/src/commands/onboard-helpers.ts
+++ b/src/commands/onboard-helpers.ts
@ -64,12 +64,12 @@ export function randomToken(): string {

 export function printWizardHeader(runtime: RuntimeEnv) {
  const header = [
-    "░████░█░░░░░█████░█░░░█░███░░████░░████░░▀█▀",
-    "█░░░░░█░░░░░█░░░█░█░█░█░█░░█░█░░░█░█░░░█░░█░",
-    "█░░░░░█░░░░░█████░█░█░█░█░░█░████░░█░░░█░░█░",
-    "█░░░░░█░░░░░█░░░█░█░█░█░█░░█░█░░█░░█░░░█░░█░",
-    "░████░█████░█░░░█░░█░█░░███░░████░░░███░░░█░",
-    "              🦞 FRESH DAILY 🦞",
+    "▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄▄",
+    "██░▄▀▄░██░▄▄▄░██░████▄▄░▄▄██░▄▄▀██░▄▄▄░█▄▄░▄▄██",
+    "██░█░█░██░███░██░██████░████░▄▄▀██░███░███░████",
+    "██░███░██░▀▀▀░██░▀▀░███░████░▀▀░██░▀▀▀░███░████",
+    "▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀",
+    "               🦞 FRESH DAILY 🦞               ",
  ].join("\n");
  runtime.log(header);
 }
--- a/src/config/paths.test.ts
+++ b/src/config/paths.test.ts
@ -5,6 +5,7 @@ import { describe, expect, it, vi } from "vitest";

 import {
  resolveDefaultConfigCandidates,
+  resolveConfigPath,
  resolveOAuthDir,
  resolveOAuthPath,
  resolveStateDir,
@ -69,6 +70,9 @@ describe("state + config path candidates", () => {
  it("CONFIG_PATH prefers existing legacy filename when present", async () => {
    const root = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-config-"));
    const previousHome = process.env.HOME;
+    const previousUserProfile = process.env.USERPROFILE;
+    const previousHomeDrive = process.env.HOMEDRIVE;
+    const previousHomePath = process.env.HOMEPATH;
    const previousMoltbotConfig = process.env.MOLTBOT_CONFIG_PATH;
    const previousClawdbotConfig = process.env.CLAWDBOT_CONFIG_PATH;
    const previousMoltbotState = process.env.MOLTBOT_STATE_DIR;
@ -80,6 +84,12 @@ describe("state + config path candidates", () => {
      await fs.writeFile(legacyPath, "{}", "utf-8");

      process.env.HOME = root;
+      if (process.platform === "win32") {
+        process.env.USERPROFILE = root;
+        const parsed = path.win32.parse(root);
+        process.env.HOMEDRIVE = parsed.root.replace(/\\$/, "");
+        process.env.HOMEPATH = root.slice(parsed.root.length - 1);
+      }
      delete process.env.MOLTBOT_CONFIG_PATH;
      delete process.env.CLAWDBOT_CONFIG_PATH;
      delete process.env.MOLTBOT_STATE_DIR;
@ -94,6 +104,12 @@ describe("state + config path candidates", () => {
      } else {
        process.env.HOME = previousHome;
      }
+      if (previousUserProfile === undefined) delete process.env.USERPROFILE;
+      else process.env.USERPROFILE = previousUserProfile;
+      if (previousHomeDrive === undefined) delete process.env.HOMEDRIVE;
+      else process.env.HOMEDRIVE = previousHomeDrive;
+      if (previousHomePath === undefined) delete process.env.HOMEPATH;
+      else process.env.HOMEPATH = previousHomePath;
      if (previousMoltbotConfig === undefined) delete process.env.MOLTBOT_CONFIG_PATH;
      else process.env.MOLTBOT_CONFIG_PATH = previousMoltbotConfig;
      if (previousClawdbotConfig === undefined) delete process.env.CLAWDBOT_CONFIG_PATH;
@ -106,4 +122,21 @@ describe("state + config path candidates", () => {
      vi.resetModules();
    }
  });
+
+  it("respects state dir overrides when config is missing", async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "moltbot-config-override-"));
+    try {
+      const legacyDir = path.join(root, ".clawdbot");
+      await fs.mkdir(legacyDir, { recursive: true });
+      const legacyConfig = path.join(legacyDir, "moltbot.json");
+      await fs.writeFile(legacyConfig, "{}", "utf-8");
+
+      const overrideDir = path.join(root, "override");
+      const env = { MOLTBOT_STATE_DIR: overrideDir } as NodeJS.ProcessEnv;
+      const resolved = resolveConfigPath(env, overrideDir, () => root);
+      expect(resolved).toBe(path.join(overrideDir, "moltbot.json"));
+    } finally {
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
 });
--- a/src/config/paths.ts
+++ b/src/config/paths.ts
@ -113,6 +113,7 @@ export function resolveConfigPath(
 ): string {
  const override = env.MOLTBOT_CONFIG_PATH?.trim() || env.CLAWDBOT_CONFIG_PATH?.trim();
  if (override) return resolveUserPath(override);
+  const stateOverride = env.MOLTBOT_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
  const candidates = [
    path.join(stateDir, CONFIG_FILENAME),
    path.join(stateDir, LEGACY_CONFIG_FILENAME),
@ -125,6 +126,7 @@ export function resolveConfigPath(
    }
  });
  if (existing) return existing;
+  if (stateOverride) return path.join(stateDir, CONFIG_FILENAME);
  const defaultStateDir = resolveStateDir(env, homedir);
  if (path.resolve(stateDir) === path.resolve(defaultStateDir)) {
    return resolveConfigPathCandidate(env, homedir);
--- a/src/discord/send.outbound.ts
+++ b/src/discord/send.outbound.ts
@ -13,7 +13,7 @@ import {
  createDiscordClient,
  normalizeDiscordPollInput,
  normalizeStickerIds,
-  parseRecipient,
+  parseAndResolveRecipient,
  resolveChannelId,
  sendDiscordMedia,
  sendDiscordText,
@ -49,7 +49,7 @@ export async function sendMessageDiscord(
  const chunkMode = resolveChunkMode(cfg, "discord", accountInfo.accountId);
  const textWithTables = convertMarkdownTables(text ?? "", tableMode);
  const { token, rest, request } = createDiscordClient(opts, cfg);
-  const recipient = parseRecipient(to);
+  const recipient = await parseAndResolveRecipient(to, opts.accountId);
  const { channelId } = await resolveChannelId(rest, recipient, request);
  let result: { id: string; channel_id: string } | { id: string | null; channel_id: string };
  try {
@ -104,7 +104,7 @@ export async function sendStickerDiscord(
 ): Promise<DiscordSendResult> {
  const cfg = loadConfig();
  const { rest, request } = createDiscordClient(opts, cfg);
-  const recipient = parseRecipient(to);
+  const recipient = await parseAndResolveRecipient(to, opts.accountId);
  const { channelId } = await resolveChannelId(rest, recipient, request);
  const content = opts.content?.trim();
  const stickers = normalizeStickerIds(stickerIds);
@ -131,7 +131,7 @@ export async function sendPollDiscord(
 ): Promise<DiscordSendResult> {
  const cfg = loadConfig();
  const { rest, request } = createDiscordClient(opts, cfg);
-  const recipient = parseRecipient(to);
+  const recipient = await parseAndResolveRecipient(to, opts.accountId);
  const { channelId } = await resolveChannelId(rest, recipient, request);
  const content = opts.content?.trim();
  const payload = normalizeDiscordPollInput(poll);
--- a/src/discord/send.shared.ts
+++ b/src/discord/send.shared.ts
@ -13,7 +13,7 @@ import type { ChunkMode } from "../auto-reply/chunk.js";
 import { chunkDiscordTextWithMode } from "./chunk.js";
 import { fetchChannelPermissionsDiscord, isThreadChannelType } from "./send.permissions.js";
 import { DiscordSendError } from "./send.types.js";
-import { parseDiscordTarget } from "./targets.js";
+import { parseDiscordTarget, resolveDiscordTarget } from "./targets.js";
 import { normalizeDiscordToken } from "./token.js";

 const DISCORD_TEXT_LIMIT = 2000;
@ -101,6 +101,44 @@ function parseRecipient(raw: string): DiscordRecipient {
  return { kind: target.kind, id: target.id };
 }

+/**
+ * Parse and resolve Discord recipient, including username lookup.
+ * This enables sending DMs by username (e.g., "john.doe") by querying
+ * the Discord directory to resolve usernames to user IDs.
+ *
+ * @param raw - The recipient string (username, ID, or known format)
+ * @param accountId - Discord account ID to use for directory lookup
+ * @returns Parsed DiscordRecipient with resolved user ID if applicable
+ */
+export async function parseAndResolveRecipient(
+  raw: string,
+  accountId?: string,
+): Promise<DiscordRecipient> {
+  const cfg = loadConfig();
+  const accountInfo = resolveDiscordAccount({ cfg, accountId });
+
+  // First try to resolve using directory lookup (handles usernames)
+  const resolved = await resolveDiscordTarget(raw, {
+    cfg,
+    accountId: accountInfo.accountId,
+  });
+
+  if (resolved) {
+    return { kind: resolved.kind, id: resolved.id };
+  }
+
+  // Fallback to standard parsing (for channels, etc.)
+  const parsed = parseDiscordTarget(raw, {
+    ambiguousMessage: `Ambiguous Discord recipient "${raw.trim()}". Use "user:${raw.trim()}" for DMs or "channel:${raw.trim()}" for channel messages.`,
+  });
+
+  if (!parsed) {
+    throw new Error("Recipient is required for Discord sends");
+  }
+
+  return { kind: parsed.kind, id: parsed.id };
+}
+
 function normalizeStickerIds(raw: string[]) {
  const ids = raw.map((entry) => entry.trim()).filter(Boolean);
  if (ids.length === 0) {
--- a/src/discord/targets.test.ts
+++ b/src/discord/targets.test.ts
@ -1,7 +1,13 @@
-import { describe, expect, it } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";

+import type { ClawdbotConfig } from "../config/config.js";
 import { normalizeDiscordMessagingTarget } from "../channels/plugins/normalize/discord.js";
-import { parseDiscordTarget, resolveDiscordChannelId } from "./targets.js";
+import { listDiscordDirectoryPeersLive } from "./directory-live.js";
+import { parseDiscordTarget, resolveDiscordChannelId, resolveDiscordTarget } from "./targets.js";
+
+vi.mock("./directory-live.js", () => ({
+  listDiscordDirectoryPeersLive: vi.fn(),
+}));

 describe("parseDiscordTarget", () => {
  it("parses user mention and prefixes", () => {
@ -68,6 +74,38 @@ describe("resolveDiscordChannelId", () => {
  });
 });

+describe("resolveDiscordTarget", () => {
+  const cfg = { channels: { discord: {} } } as ClawdbotConfig;
+  const listPeers = vi.mocked(listDiscordDirectoryPeersLive);
+
+  beforeEach(() => {
+    listPeers.mockReset();
+  });
+
+  it("returns a resolved user for usernames", async () => {
+    listPeers.mockResolvedValueOnce([{ kind: "user", id: "user:999", name: "Jane" } as const]);
+
+    await expect(
+      resolveDiscordTarget("jane", { cfg, accountId: "default" }),
+    ).resolves.toMatchObject({ kind: "user", id: "999", normalized: "user:999" });
+  });
+
+  it("falls back to parsing when lookup misses", async () => {
+    listPeers.mockResolvedValueOnce([]);
+    await expect(
+      resolveDiscordTarget("general", { cfg, accountId: "default" }),
+    ).resolves.toMatchObject({ kind: "channel", id: "general" });
+  });
+
+  it("does not call directory lookup for explicit user ids", async () => {
+    listPeers.mockResolvedValueOnce([]);
+    await expect(
+      resolveDiscordTarget("user:123", { cfg, accountId: "default" }),
+    ).resolves.toMatchObject({ kind: "user", id: "123" });
+    expect(listPeers).not.toHaveBeenCalled();
+  });
+});
+
 describe("normalizeDiscordMessagingTarget", () => {
  it("defaults raw numeric ids to channels", () => {
    expect(normalizeDiscordMessagingTarget("123")).toBe("channel:123");
--- a/src/discord/targets.ts
+++ b/src/discord/targets.ts
@ -7,6 +7,11 @@ import {
  type MessagingTargetParseOptions,
 } from "../channels/targets.js";

+import type { DirectoryConfigParams } from "../channels/plugins/directory-config.js";
+
+import { listDiscordDirectoryPeersLive } from "./directory-live.js";
+import { resolveDiscordAccount } from "./accounts.js";
+
 export type DiscordTargetKind = MessagingTargetKind;

 export type DiscordTarget = MessagingTarget;
@ -60,3 +65,77 @@ export function resolveDiscordChannelId(raw: string): string {
  const target = parseDiscordTarget(raw, { defaultKind: "channel" });
  return requireTargetKind({ platform: "Discord", target, kind: "channel" });
 }
+
+/**
+ * Resolve a Discord username to user ID using the directory lookup.
+ * This enables sending DMs by username instead of requiring explicit user IDs.
+ *
+ * @param raw - The username or raw target string (e.g., "john.doe")
+ * @param options - Directory configuration params (cfg, accountId, limit)
+ * @returns Parsed MessagingTarget with user ID, or undefined if not found
+ */
+export async function resolveDiscordTarget(
+  raw: string,
+  options: DirectoryConfigParams,
+): Promise<MessagingTarget | undefined> {
+  const trimmed = raw.trim();
+  if (!trimmed) return undefined;
+
+  const shouldLookup = isExplicitUserLookup(trimmed, options);
+  const directParse = safeParseDiscordTarget(trimmed, options);
+  if (directParse && directParse.kind !== "channel") {
+    return directParse;
+  }
+  if (!shouldLookup) {
+    return directParse ?? parseDiscordTarget(trimmed, options);
+  }
+
+  // Try to resolve as a username via directory lookup
+  try {
+    const directoryEntries = await listDiscordDirectoryPeersLive({
+      ...options,
+      query: trimmed,
+      limit: 1,
+    });
+
+    const match = directoryEntries[0];
+    if (match && match.kind === "user") {
+      // Extract user ID from the directory entry (format: "user:<id>")
+      const userId = match.id.replace(/^user:/, "");
+      return buildMessagingTarget("user", userId, trimmed);
+    }
+  } catch (error) {
+    // Directory lookup failed - fall through to parse as-is
+    // This preserves existing behavior for channel names
+  }
+
+  // Fallback to original parsing (for channels, etc.)
+  return parseDiscordTarget(trimmed, options);
+}
+
+function safeParseDiscordTarget(
+  input: string,
+  options: DiscordTargetParseOptions,
+): MessagingTarget | undefined {
+  try {
+    return parseDiscordTarget(input, options);
+  } catch {
+    return undefined;
+  }
+}
+
+function isExplicitUserLookup(input: string, options: DiscordTargetParseOptions): boolean {
+  if (/^<@!?(\d+)>$/.test(input)) {
+    return true;
+  }
+  if (/^(user:|discord:)/.test(input)) {
+    return true;
+  }
+  if (input.startsWith("@")) {
+    return true;
+  }
+  if (/^\d+$/.test(input)) {
+    return options.defaultKind === "user";
+  }
+  return false;
+}
--- a/src/telegram/bot-message-context.dm-threads.test.ts
+++ b/src/telegram/bot-message-context.dm-threads.test.ts
@ -70,3 +70,102 @@ describe("buildTelegramMessageContext dm thread sessions", () => {
    expect(ctx?.ctxPayload?.SessionKey).toBe("agent:main:main");
  });
 });
+
+describe("buildTelegramMessageContext group sessions without forum", () => {
+  const baseConfig = {
+    agents: { defaults: { model: "anthropic/claude-opus-4-5", workspace: "/tmp/clawd" } },
+    channels: { telegram: {} },
+    messages: { groupChat: { mentionPatterns: [] } },
+  } as never;
+
+  const buildContext = async (message: Record<string, unknown>) =>
+    await buildTelegramMessageContext({
+      primaryCtx: {
+        message,
+        me: { id: 7, username: "bot" },
+      } as never,
+      allMedia: [],
+      storeAllowFrom: [],
+      options: { forceWasMentioned: true },
+      bot: {
+        api: {
+          sendChatAction: vi.fn(),
+          setMessageReaction: vi.fn(),
+        },
+      } as never,
+      cfg: baseConfig,
+      account: { accountId: "default" } as never,
+      historyLimit: 0,
+      groupHistories: new Map(),
+      dmPolicy: "open",
+      allowFrom: [],
+      groupAllowFrom: [],
+      ackReactionScope: "off",
+      logger: { info: vi.fn() },
+      resolveGroupActivation: () => true,
+      resolveGroupRequireMention: () => false,
+      resolveTelegramGroupConfig: () => ({
+        groupConfig: { requireMention: false },
+        topicConfig: undefined,
+      }),
+    });
+
+  it("ignores message_thread_id for regular groups (not forums)", async () => {
+    // When someone replies to a message in a non-forum group, Telegram sends
+    // message_thread_id but this should NOT create a separate session
+    const ctx = await buildContext({
+      message_id: 1,
+      chat: { id: -1001234567890, type: "supergroup", title: "Test Group" },
+      date: 1700000000,
+      text: "@bot hello",
+      message_thread_id: 42, // This is a reply thread, NOT a forum topic
+      from: { id: 42, first_name: "Alice" },
+    });
+
+    expect(ctx).not.toBeNull();
+    // Session key should NOT include :topic:42
+    expect(ctx?.ctxPayload?.SessionKey).toBe("agent:main:telegram:group:-1001234567890");
+    // MessageThreadId should be undefined (not a forum)
+    expect(ctx?.ctxPayload?.MessageThreadId).toBeUndefined();
+  });
+
+  it("keeps same session for regular group with and without message_thread_id", async () => {
+    const ctxWithThread = await buildContext({
+      message_id: 1,
+      chat: { id: -1001234567890, type: "supergroup", title: "Test Group" },
+      date: 1700000000,
+      text: "@bot hello",
+      message_thread_id: 42,
+      from: { id: 42, first_name: "Alice" },
+    });
+
+    const ctxWithoutThread = await buildContext({
+      message_id: 2,
+      chat: { id: -1001234567890, type: "supergroup", title: "Test Group" },
+      date: 1700000001,
+      text: "@bot world",
+      from: { id: 42, first_name: "Alice" },
+    });
+
+    expect(ctxWithThread).not.toBeNull();
+    expect(ctxWithoutThread).not.toBeNull();
+    // Both messages should use the same session key
+    expect(ctxWithThread?.ctxPayload?.SessionKey).toBe(ctxWithoutThread?.ctxPayload?.SessionKey);
+  });
+
+  it("uses topic session for forum groups with message_thread_id", async () => {
+    const ctx = await buildContext({
+      message_id: 1,
+      chat: { id: -1001234567890, type: "supergroup", title: "Test Forum", is_forum: true },
+      date: 1700000000,
+      text: "@bot hello",
+      message_thread_id: 99,
+      from: { id: 42, first_name: "Alice" },
+    });
+
+    expect(ctx).not.toBeNull();
+    // Session key SHOULD include :topic:99 for forums
+    expect(ctx?.ctxPayload?.SessionKey).toBe("agent:main:telegram:group:-1001234567890:topic:99");
+    expect(ctx?.ctxPayload?.MessageThreadId).toBe(99);
+  });
+});
--- a/src/telegram/bot-message-context.ts
+++ b/src/telegram/bot-message-context.ts
@ -173,7 +173,8 @@ export const buildTelegramMessageContext = async ({
    },
  });
  const baseSessionKey = route.sessionKey;
-  const dmThreadId = !isGroup ? resolvedThreadId : undefined;
+  // DMs: use raw messageThreadId for thread sessions (not resolvedThreadId which is for forums)
+  const dmThreadId = !isGroup ? messageThreadId : undefined;
  const threadKeys =
    dmThreadId != null
      ? resolveThreadSessionKeys({ baseSessionKey, threadId: String(dmThreadId) })
@ -601,7 +602,8 @@ export const buildTelegramMessageContext = async ({
    Sticker: allMedia[0]?.stickerMetadata,
    ...(locationData ? toLocationContext(locationData) : undefined),
    CommandAuthorized: commandAuthorized,
-    MessageThreadId: resolvedThreadId,
+    // For groups: use resolvedThreadId (forum topics only); for DMs: use raw messageThreadId
+    MessageThreadId: isGroup ? resolvedThreadId : messageThreadId,
    IsForum: isForum,
    // Originating channel for reply routing.
    OriginatingChannel: "telegram" as const,
--- a/src/telegram/bot-native-commands.ts
+++ b/src/telegram/bot-native-commands.ts
@ -322,7 +322,7 @@ export const registerTelegramNativeCommands = ({
  ];

  if (allCommands.length > 0) {
-    void withTelegramApiErrorLogging({
+    withTelegramApiErrorLogging({
      operation: "setMyCommands",
      runtime,
      fn: () => bot.api.setMyCommands(allCommands),
@ -360,6 +360,8 @@ export const registerTelegramNativeCommands = ({
            topicConfig,
            commandAuthorized,
          } = auth;
+          const messageThreadId = (msg as { message_thread_id?: number }).message_thread_id;
+          const threadIdForSend = isGroup ? resolvedThreadId : messageThreadId;

          const commandDefinition = findCommandByNativeName(command.name, "telegram");
          const rawText = ctx.match?.trim() ?? "";
@ -406,7 +408,7 @@ export const registerTelegramNativeCommands = ({
              fn: () =>
                bot.api.sendMessage(chatId, title, {
                  ...(replyMarkup ? { reply_markup: replyMarkup } : {}),
-                  ...(resolvedThreadId != null ? { message_thread_id: resolvedThreadId } : {}),
+                  ...(threadIdForSend != null ? { message_thread_id: threadIdForSend } : {}),
                }),
            });
            return;
@ -421,7 +423,8 @@ export const registerTelegramNativeCommands = ({
            },
          });
          const baseSessionKey = route.sessionKey;
-          const dmThreadId = !isGroup ? resolvedThreadId : undefined;
+          // DMs: use raw messageThreadId for thread sessions (not resolvedThreadId which is for forums)
+          const dmThreadId = !isGroup ? messageThreadId : undefined;
          const threadKeys =
            dmThreadId != null
              ? resolveThreadSessionKeys({ baseSessionKey, threadId: String(dmThreadId) })
@ -466,7 +469,7 @@ export const registerTelegramNativeCommands = ({
            CommandSource: "native" as const,
            SessionKey: `telegram:slash:${senderId || chatId}`,
            CommandTargetSessionKey: sessionKey,
-            MessageThreadId: resolvedThreadId,
+            MessageThreadId: threadIdForSend,
            IsForum: isForum,
            // Originating context for sub-agent announce routing
            OriginatingChannel: "telegram" as const,
@ -493,7 +496,7 @@ export const registerTelegramNativeCommands = ({
                  bot,
                  replyToMode,
                  textLimit,
-                  messageThreadId: resolvedThreadId,
+                  messageThreadId: threadIdForSend,
                  tableMode,
                  chunkMode,
                  linkPreview: telegramCfg.linkPreview,
@ -541,7 +544,9 @@ export const registerTelegramNativeCommands = ({
            requireAuth: match.command.requireAuth !== false,
          });
          if (!auth) return;
-          const { resolvedThreadId, senderId, commandAuthorized } = auth;
+          const { resolvedThreadId, senderId, commandAuthorized, isGroup } = auth;
+          const messageThreadId = (msg as { message_thread_id?: number }).message_thread_id;
+          const threadIdForSend = isGroup ? resolvedThreadId : messageThreadId;

          const result = await executePluginCommand({
            command: match.command,
@ -567,7 +572,7 @@ export const registerTelegramNativeCommands = ({
            bot,
            replyToMode,
            textLimit,
-            messageThreadId: resolvedThreadId,
+            messageThreadId: threadIdForSend,
            tableMode,
            chunkMode,
            linkPreview: telegramCfg.linkPreview,
@ -576,7 +581,7 @@ export const registerTelegramNativeCommands = ({
      }
    }
  } else if (nativeDisabledExplicit) {
-    void withTelegramApiErrorLogging({
+    withTelegramApiErrorLogging({
      operation: "setMyCommands",
      runtime,
      fn: () => bot.api.setMyCommands([]),
--- a/src/telegram/bot.create-telegram-bot.installs-grammy-throttler.test.ts
+++ b/src/telegram/bot.create-telegram-bot.installs-grammy-throttler.test.ts
@ -238,12 +238,17 @@ describe("createTelegramBot", () => {
    expect(getTelegramSequentialKey({ message: { chat: { id: 123 } } })).toBe("telegram:123");
    expect(
      getTelegramSequentialKey({
-        message: { chat: { id: 123 }, message_thread_id: 9 },
+        message: { chat: { id: 123, type: "private" }, message_thread_id: 9 },
      }),
    ).toBe("telegram:123:topic:9");
    expect(
      getTelegramSequentialKey({
-        message: { chat: { id: 123, is_forum: true } },
+        message: { chat: { id: 123, type: "supergroup" }, message_thread_id: 9 },
+      }),
+    ).toBe("telegram:123");
+    expect(
+      getTelegramSequentialKey({
+        message: { chat: { id: 123, type: "supergroup", is_forum: true } },
      }),
    ).toBe("telegram:123:topic:1");
    expect(
--- a/src/telegram/bot.test.ts
+++ b/src/telegram/bot.test.ts
@ -340,12 +340,17 @@ describe("createTelegramBot", () => {
    expect(getTelegramSequentialKey({ message: { chat: { id: 123 } } })).toBe("telegram:123");
    expect(
      getTelegramSequentialKey({
-        message: { chat: { id: 123 }, message_thread_id: 9 },
+        message: { chat: { id: 123, type: "private" }, message_thread_id: 9 },
      }),
    ).toBe("telegram:123:topic:9");
    expect(
      getTelegramSequentialKey({
-        message: { chat: { id: 123, is_forum: true } },
+        message: { chat: { id: 123, type: "supergroup" }, message_thread_id: 9 },
+      }),
+    ).toBe("telegram:123");
+    expect(
+      getTelegramSequentialKey({
+        message: { chat: { id: 123, type: "supergroup", is_forum: true } },
      }),
    ).toBe("telegram:123:topic:1");
    expect(
--- a/src/telegram/bot.ts
+++ b/src/telegram/bot.ts
@ -94,11 +94,12 @@ export function getTelegramSequentialKey(ctx: {
    if (typeof chatId === "number") return `telegram:${chatId}:control`;
    return "telegram:control";
  }
+  const isGroup = msg?.chat?.type === "group" || msg?.chat?.type === "supergroup";
+  const messageThreadId = msg?.message_thread_id;
  const isForum = (msg?.chat as { is_forum?: boolean } | undefined)?.is_forum;
-  const threadId = resolveTelegramForumThreadId({
-    isForum,
-    messageThreadId: msg?.message_thread_id,
-  });
+  const threadId = isGroup
+    ? resolveTelegramForumThreadId({ isForum, messageThreadId })
+    : messageThreadId;
  if (typeof chatId === "number") {
    return threadId != null ? `telegram:${chatId}:topic:${threadId}` : `telegram:${chatId}`;
  }
@ -427,7 +428,8 @@ export function createTelegramBot(opts: TelegramBotOptions) {
        peer: { kind: isGroup ? "group" : "dm", id: peerId },
      });
      const baseSessionKey = route.sessionKey;
-      const dmThreadId = !isGroup ? resolvedThreadId : undefined;
+      // DMs: use raw messageThreadId for thread sessions (not resolvedThreadId which is for forums)
+      const dmThreadId = !isGroup ? messageThreadId : undefined;
      const threadKeys =
        dmThreadId != null
          ? resolveThreadSessionKeys({ baseSessionKey, threadId: String(dmThreadId) })
--- a/src/telegram/bot/helpers.test.ts
+++ b/src/telegram/bot/helpers.test.ts
@ -3,8 +3,30 @@ import {
  buildTelegramThreadParams,
  buildTypingThreadParams,
  normalizeForwardedContext,
+  resolveTelegramForumThreadId,
 } from "./helpers.js";

+describe("resolveTelegramForumThreadId", () => {
+  it("returns undefined for non-forum groups even with messageThreadId", () => {
+    // Reply threads in regular groups should not create separate sessions
+    expect(resolveTelegramForumThreadId({ isForum: false, messageThreadId: 42 })).toBeUndefined();
+  });
+
+  it("returns undefined for non-forum groups without messageThreadId", () => {
+    expect(resolveTelegramForumThreadId({ isForum: false, messageThreadId: undefined })).toBeUndefined();
+    expect(resolveTelegramForumThreadId({ isForum: undefined, messageThreadId: 99 })).toBeUndefined();
+  });
+
+  it("returns General topic (1) for forum groups without messageThreadId", () => {
+    expect(resolveTelegramForumThreadId({ isForum: true, messageThreadId: undefined })).toBe(1);
+    expect(resolveTelegramForumThreadId({ isForum: true, messageThreadId: null })).toBe(1);
+  });
+
+  it("returns the topic id for forum groups with messageThreadId", () => {
+    expect(resolveTelegramForumThreadId({ isForum: true, messageThreadId: 99 })).toBe(99);
+  });
+});
+
 describe("buildTelegramThreadParams", () => {
  it("omits General topic thread id for message sends", () => {
    expect(buildTelegramThreadParams(1)).toBeUndefined();
--- a/src/telegram/bot/helpers.ts
+++ b/src/telegram/bot/helpers.ts
@ -13,14 +13,25 @@ import type {

 const TELEGRAM_GENERAL_TOPIC_ID = 1;

+/**
+ * Resolve the thread ID for Telegram forum topics.
+ * For non-forum groups, returns undefined even if messageThreadId is present
+ * (reply threads in regular groups should not create separate sessions).
+ * For forum groups, returns the topic ID (or General topic ID=1 if unspecified).
+ */
 export function resolveTelegramForumThreadId(params: {
  isForum?: boolean;
  messageThreadId?: number | null;
 }) {
-  if (params.isForum && params.messageThreadId == null) {
+  // Non-forum groups: ignore message_thread_id (reply threads are not real topics)
+  if (!params.isForum) {
+    return undefined;
+  }
+  // Forum groups: use the topic ID, defaulting to General topic
+  if (params.messageThreadId == null) {
    return TELEGRAM_GENERAL_TOPIC_ID;
  }
-  return params.messageThreadId ?? undefined;
+  return params.messageThreadId;
 }

 /**
--- a/src/telegram/monitor.ts
+++ b/src/telegram/monitor.ts
@ -74,6 +74,23 @@ const isGetUpdatesConflict = (err: unknown) => {
  return haystack.includes("getupdates");
 };

+const NETWORK_ERROR_SNIPPETS = [
+  "fetch failed",
+  "network",
+  "timeout",
+  "socket",
+  "econnreset",
+  "econnrefused",
+  "undici",
+];
+
+const isNetworkRelatedError = (err: unknown) => {
+  if (!err) return false;
+  const message = formatErrorMessage(err).toLowerCase();
+  if (!message) return false;
+  return NETWORK_ERROR_SNIPPETS.some((snippet) => message.includes(snippet));
+};
+
 export async function monitorTelegramProvider(opts: MonitorTelegramOpts = {}) {
  const cfg = opts.config ?? loadConfig();
  const account = resolveTelegramAccount({
@ -158,7 +175,8 @@ export async function monitorTelegramProvider(opts: MonitorTelegramOpts = {}) {
      }
      const isConflict = isGetUpdatesConflict(err);
      const isRecoverable = isRecoverableTelegramNetworkError(err, { context: "polling" });
-      if (!isConflict && !isRecoverable) {
+      const isNetworkError = isNetworkRelatedError(err);
+      if (!isConflict && !isRecoverable && !isNetworkError) {
        throw err;
      }
      restartAttempts += 1;
--- a/src/telegram/network-errors.test.ts
+++ b/src/telegram/network-errors.test.ts
@ -8,6 +8,13 @@ describe("isRecoverableTelegramNetworkError", () => {
    expect(isRecoverableTelegramNetworkError(err)).toBe(true);
  });

+  it("detects additional recoverable error codes", () => {
+    const aborted = Object.assign(new Error("aborted"), { code: "ECONNABORTED" });
+    const network = Object.assign(new Error("network"), { code: "ERR_NETWORK" });
+    expect(isRecoverableTelegramNetworkError(aborted)).toBe(true);
+    expect(isRecoverableTelegramNetworkError(network)).toBe(true);
+  });
+
  it("detects AbortError names", () => {
    const err = Object.assign(new Error("The operation was aborted"), { name: "AbortError" });
    expect(isRecoverableTelegramNetworkError(err)).toBe(true);
@ -19,6 +26,11 @@ describe("isRecoverableTelegramNetworkError", () => {
    expect(isRecoverableTelegramNetworkError(err)).toBe(true);
  });

+  it("detects expanded message patterns", () => {
+    expect(isRecoverableTelegramNetworkError(new Error("TypeError: fetch failed"))).toBe(true);
+    expect(isRecoverableTelegramNetworkError(new Error("Undici: socket failure"))).toBe(true);
+  });
+
  it("skips message matches for send context", () => {
    const err = new TypeError("fetch failed");
    expect(isRecoverableTelegramNetworkError(err, { context: "send" })).toBe(false);
--- a/src/telegram/network-errors.ts
+++ b/src/telegram/network-errors.ts
@ -15,6 +15,8 @@ const RECOVERABLE_ERROR_CODES = new Set([
  "UND_ERR_BODY_TIMEOUT",
  "UND_ERR_SOCKET",
  "UND_ERR_ABORTED",
+  "ECONNABORTED",
+  "ERR_NETWORK",
 ]);

 const RECOVERABLE_ERROR_NAMES = new Set([
@ -27,6 +29,8 @@ const RECOVERABLE_ERROR_NAMES = new Set([

 const RECOVERABLE_MESSAGE_SNIPPETS = [
  "fetch failed",
+  "typeerror: fetch failed",
+  "undici",
  "network error",
  "network request",
  "client network socket disconnected",