openclacky 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32e7797fb57aaa140bb53070def7de2588a6a98816cc0b7ce7ed4457385f5ce1
-  data.tar.gz: 8b6ad8e808f725debfae7803fadc527ce48da56660e7242cebddee8aa93ffab1
+  metadata.gz: 597ea8fc84ca69641339dbacf724e114d4fc7c5c43bcafb81767bcb83da89edd
+  data.tar.gz: 23f576f36023978f37dfe68e12ec942e3cedd591bec1cd098a5829a8d9057a24
 SHA512:
-  metadata.gz: 425fbfa12f4d2e2cc10c33a325406a5ff8df8db54c8888656b49230730f67304f2a35b6b4541d033a59a315448326d42b0dd3b886055dce104796df4fdc7bf30
-  data.tar.gz: f24a8c62187e47196330fcd28550101bd7074f33387c3df297210c69f9c211f37178ec20a8b66bce829a1a8dc73d8e11a074f5611b1a00336c5e8c655556c3fb
+  metadata.gz: 0fed807f559eee7d3df5508bbef61d45f75a0943c5d76ac17cbf9a334bfc75be729ad6ab03485211c532de186b1f41aa27c54267f2e36efa7c191699e3fcca2e
+  data.tar.gz: c8943553c4cd0f721515e0ffad5aa554dcdffc0305aca6d7ac403a02762b59db63273415d452965767b0bd2157ab835c946b081e99b0ce5a8574a3bf622e6aa1

data/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.5] - 2026-05-12
+
+### Added
+- **Telegram channel adapter.** New IM channel adapter that connects openclacky to Telegram via the Bot API. Setup is just a bot token from @BotFather — no browser automation, no QR. Mirrors the existing Feishu / WeCom / Weixin contract: HTTPS long-poll inbound, `sendMessage` / `sendPhoto` / `sendDocument` outbound, photo + document download routed through the standard FileProcessor + vision pipeline, group `@-mention` filtering and `allowed_users` whitelist. `base_url` is configurable to support self-hosted Bot API servers (https://github.com/tdlib/telegram-bot-api) for networks where `api.telegram.org` is unreachable. Frontend Channels panel, `channel-setup` skill, English/Chinese i18n, and `app.css` logo class added. 32 new specs in `spec/clacky/server/channel/adapters/telegram/`.
+- **Discord channel adapter.** Full Discord integration via REST API + Gateway (WebSocket), with channel-setup support, Web UI Channels panel entry, and i18n strings. Connect Clacky to Discord servers for bot interactions through slash commands and message events.
+- **OpenRouter curated model list.** The OpenRouter provider now ships with a curated dropdown of mainstream Claude and GPT models (Sonnet, Opus, Haiku, GPT-5.5/5.4), so users can pick from the list instead of typing model IDs manually. Full catalogue still accessible by typing any model ID.
+- **OpenRouter lite model pairing.** Subagents on OpenRouter now automatically get a sensible cheap/fast sidekick — Claude family pairs with Haiku, GPT family pairs with the mini variant — matching the behavior already available on the native OpenAI and OpenClacky providers.
+- **MiMo 2.5 Pro (Xiaomi) model support.** Added `mimo-v2.5-pro` to the MiMo provider preset alongside existing MiMo models.
+- **AI key setup guide link.** New users and those configuring API keys now see a "New to AI keys? See the guide →" link on both onboarding and settings pages, pointing to the official documentation.
+
+### Improved
+- **Default model upgraded to claude-sonnet-4-6.** The OpenClacky provider now defaults to the latest Claude Sonnet model for better performance out of the box.
+
+### Fixed
+- **Linux server restart stability.** Fixed an inherited socket cleanup bug where WEBrick's shutdown would propagate `SHUT_RDWR` to the shared kernel socket, breaking subsequent `accept()` calls on Linux. The server now detaches inherited sockets before shutdown so worker restarts work reliably.
+- **Upgrade failure recovery UI.** When an in-app upgrade restart fails, the UI now shows both tray icon and CLI recovery paths (`gem update ...`) instead of leaving users stranded. Also added branded CLI command info to the version check API for white-label builds.
+
 ## [1.0.4] - 2026-05-11
 
 ### Added

data/lib/clacky/default_skills/channel-setup/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: channel-setup
 description: |
-  Configure IM platform channels (Feishu, WeCom, Weixin) for openclacky.
+  Configure IM platform channels (Feishu, WeCom, Weixin, Discord, Telegram) for openclacky.
   Uses browser automation for navigation; guides the user to paste credentials and perform UI steps.
-  Trigger on: "channel setup", "setup feishu", "setup wecom", "setup weixin", "setup wechat", "channel config",
-  "channel status", "channel enable", "channel disable", "channel reconfigure", "channel doctor",
-  "send message to weixin", "send message to feishu", "send message to wecom".
+  Trigger on: "channel setup", "setup feishu", "setup wecom", "setup weixin", "setup wechat", "setup discord", "setup telegram",
+  "channel config", "channel status", "channel enable", "channel disable", "channel reconfigure", "channel doctor",
+  "send message to weixin", "send message to feishu", "send message to wecom", "send message to discord", "send message to telegram".
   Subcommands: setup, status, enable <platform>, disable <platform>, reconfigure, doctor, send.
 argument-hint: "setup | status | enable <platform> | disable <platform> | reconfigure | doctor | send <platform> <message>"
 allowed-tools:
@@ -28,13 +28,13 @@ Configure IM platform channels for openclacky.
 
 | User says | Subcommand |
 |---|---|
-| `channel setup`, `setup feishu`, `setup wecom`, `setup weixin`, `setup wechat` | setup |
+| `channel setup`, `setup feishu`, `setup wecom`, `setup weixin`, `setup wechat`, `setup discord`, `setup telegram` | setup |
 | `channel status` | status |
-| `channel enable feishu/wecom/weixin` | enable |
-| `channel disable feishu/wecom/weixin` | disable |
+| `channel enable feishu/wecom/weixin/discord/telegram` | enable |
+| `channel disable feishu/wecom/weixin/discord/telegram` | disable |
 | `channel reconfigure` | reconfigure |
 | `channel doctor` | doctor |
-| `send <message> to weixin/feishu/wecom` | send |
+| `send <message> to weixin/feishu/wecom/discord/telegram` | send |
 
 ---
 
@@ -51,7 +51,9 @@ Response shape (example):
 {"channels":[
   {"platform":"feishu","enabled":true,"running":true,"has_config":true,"app_id":"cli_xxx","domain":"https://open.feishu.cn","allowed_users":[]},
   {"platform":"wecom","enabled":false,"running":false,"has_config":false,"bot_id":""},
-  {"platform":"weixin","enabled":true,"running":true,"has_config":true,"has_token":true,"base_url":"https://ilinkai.weixin.qq.com","allowed_users":[]}
+  {"platform":"weixin","enabled":true,"running":true,"has_config":true,"has_token":true,"base_url":"https://ilinkai.weixin.qq.com","allowed_users":[]},
+  {"platform":"discord","enabled":true,"running":true,"has_config":true,"has_token":true,"allowed_users":[]}
+  {"platform":"telegram","enabled":true,"running":true,"has_config":true,"has_token":true,"base_url":"https://api.telegram.org","parse_mode":"Markdown","allowed_users":[]}
 ]}
 ```
 
@@ -64,12 +66,16 @@ Platform   Enabled   Running   Details
 feishu     ✅ yes    ✅ yes    app_id: cli_xxx...
 wecom      ❌ no     ❌ no     (not configured)
 weixin     ✅ yes    ✅ yes    has_token: true
+discord    ✅ yes    ✅ yes    has_token: true
+telegram   ✅ yes    ✅ yes    has_token: true
 ─────────────────────────────────────────────────────
 ```
 
 - Feishu: show `app_id` (truncated to 12 chars)
 - WeCom: show `bot_id` if present
 - Weixin: show `has_token: true/false` (token value is never displayed)
+- Discord: show `has_token: true/false` (token value is never displayed)
+- Telegram: show `has_token: true/false` (bot token is never displayed)
 
 If the API is unreachable or returns an empty list: "No channels configured yet. Run `/channel-setup setup` to get started."
 
@@ -83,6 +89,8 @@ Ask:
 > 1. Feishu
 > 2. WeCom (Enterprise WeChat)
 > 3. Weixin (Personal WeChat via iLink QR login)
+> 4. Discord
+> 5. Telegram (Bot API)
 
 ---
 
@@ -344,6 +352,105 @@ Tell the user while waiting:
 
 ---
 
+### Discord setup
+
+Discord requires manual portal interaction (hCaptcha gates Application creation). The browser just navigates the user to the portal; the user clicks through and pastes the bot token + app id back.
+
+#### Step 1 — Open the developer portal
+
+Get the portal URL from the script and open it in the browser:
+
+```bash
+PORTAL_URL=$(ruby "SKILL_DIR/discord_setup.rb" --portal-url)
+```
+
+Open it: `browser(action="navigate", url="<PORTAL_URL>")`. If the browser tool is not configured, invoke `browser-setup` first, then retry.
+
+#### Step 2 — Guide the user through the portal (one round-trip)
+
+Tell the user **all** of the following in a single message, then call `request_user_feedback` to collect the values in one reply:
+
+> In the Discord Developer Portal I just opened:
+>
+> 1. Click **New Application** (top-right). Name it whatever you like (e.g. "Open Clacky"), check the ToS box, click **Create**.
+> 2. In the left nav click **Bot**.
+> 3. Scroll down to **Privileged Gateway Intents** and turn on **MESSAGE CONTENT INTENT**, then click **Save Changes**.
+> 4. Scroll up, click **Reset Token** → **Yes, do it!**. Click **Copy** to copy the bot token. (This is the only time the token is shown — don't navigate away before copying.)
+> 5. In the left nav click **General Information**. Copy the **Application ID**.
+>
+> Paste both values back here in this format (one line):
+>
+> `token=YOUR_BOT_TOKEN app_id=YOUR_APPLICATION_ID`
+
+If the user is chatting in a non-English language, append the localized label in parens after each bolded English button name (e.g. `**Bot**（机器人）`). The English label stays primary — it's what they physically click in the portal.
+
+Use `request_user_feedback` to collect the reply. Parse with tolerant regex (`token=\S+`, `app_id=\d+`).
+
+If the reply is malformed (missing either field), apologise briefly and ask again with the exact same format reminder. Up to 3 retries; after that, surface the original message and stop.
+
+#### Step 3 — Validate, save, invite, wait
+
+1. Validate the token and save credentials:
+   ```bash
+   ruby "SKILL_DIR/discord_setup.rb" --validate "<BOT_TOKEN>"
+   ```
+   On success the script prints `{"bot_id":"...","username":"..."}` and the adapter starts.
+
+2. Generate the invite URL using the application id from Step 2:
+   ```bash
+   ruby "SKILL_DIR/discord_setup.rb" --invite-url "<APP_ID>"
+   ```
+   Open it: `browser(action="navigate", url="<INVITE_URL>")`. Tell the user:
+   > Pick your server from the dropdown → **Continue** → **Authorize**. I'll detect when the bot joins.
+   >
+   > If the dropdown is empty, you don't have a server yet — open <https://discord.com/channels/@me>, click **Add a Server** (the **+** button on the left sidebar) → **Create My Own** → **For me and my friends** → name it → **Create**, then re-open the invite link.
+
+3. Wait for the bot to join a guild (long-poll, 10 min timeout). Run with `timeout: 620`:
+   ```bash
+   ruby "SKILL_DIR/discord_setup.rb" --watch-guild
+   ```
+   On exit 0: "✅ Discord channel configured! Bot is in `<guild_name>`. Mention it or DM it from any channel."
+   On timeout: offer to re-open the invite URL — the bot token stays valid.
+
+### Telegram setup (Bot API)
+
+Telegram setup is by far the simplest — no browser automation, no QR. The user creates a bot via @BotFather and pastes the token here.
+
+#### Step 1 — Create a bot via @BotFather
+
+Tell the user:
+
+> Open Telegram and start a chat with **@BotFather** (https://t.me/BotFather). Send `/newbot`, choose a display name and a username ending in `bot`. BotFather will reply with an HTTP API token that looks like `123456789:ABCdefGhIJKlmNoPQRsTUVwxyZ`. Paste the token here.
+>
+> Optional: if your network blocks `api.telegram.org`, also tell me the base URL of your self-hosted Bot API server (e.g. `https://my-tg-proxy.example.com`). Otherwise leave it blank.
+
+Wait for the user's reply. Parse the token (matches `^\d+:[\w-]{30,}$`).
+
+#### Step 2 — Save credentials and validate
+
+Call the server API. It calls `getMe` against the Bot API to validate the token before persisting:
+
+```bash
+curl -s -X POST http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/channels/telegram \
+  -H "Content-Type: application/json" \
+  -d '{"bot_token":"<TOKEN>","base_url":"<BASE_URL_OR_OMIT>"}'
+```
+
+- `200 { "ok": true }` — token validated and saved. The adapter starts long-polling immediately.
+- `422 { "ok": false, "error": "..." }` — show the error (commonly "Unauthorized" → wrong token) and offer to retry.
+
+On success:
+
+> ✅ Telegram channel configured. Open your bot in Telegram and send any message to start chatting. In group chats, the bot only replies when you @-mention it.
+
+#### Notes
+
+- **Group chats**: Telegram bots respond only when @-mentioned or directly replied to (matches Feishu behaviour). For unrestricted reading in groups, the bot owner must disable "Group Privacy" in @BotFather (`/mybots → Bot Settings → Group Privacy → Turn off`), but `@-mention only` is recommended to avoid spam.
+- **Self-hosted Bot API**: set `base_url` when `api.telegram.org` is unreachable. See https://github.com/tdlib/telegram-bot-api for the official self-hosted server.
+- **`allowed_users`**: restrict which Telegram user IDs the bot will respond to. Find a user's numeric ID by messaging @userinfobot.
+
+---
+
 ## `enable`
 
 Call the server API to re-enable the platform (this reads from disk, sets enabled, saves, and hot-reloads):
@@ -391,15 +498,30 @@ Check each item, report ✅ / ❌ with remediation:
    - Feishu: `app_id`, `app_secret` present and non-empty
    - WeCom: `bot_id`, `secret` present and non-empty
    - Weixin: `token` present and non-empty in `channels.yml`
+   - Discord: `bot_token` present and non-empty in `channels.yml`
+   - Telegram: `bot_token` present and non-empty
 3. **Feishu credentials** (if enabled) — run the token API call, check `code=0`.
 4. **Weixin token** (if enabled) — call `GET /api/channels` and check `has_token: true` for the weixin entry.
-5. **WeCom credentials** (if enabled) — search today's log:
+5. **Telegram credentials** (if enabled) — call `getMe` against the Bot API:
+   ```bash
+   BOT_TOKEN=$(ruby -ryaml -e 'puts (YAML.load_file(File.expand_path("~/.clacky/channels.yml"))["channels"]["telegram"]["bot_token"] rescue "")')
+   BASE_URL=$(ruby -ryaml -e 'puts (YAML.load_file(File.expand_path("~/.clacky/channels.yml"))["channels"]["telegram"]["base_url"] || "https://api.telegram.org" rescue "https://api.telegram.org")')
+   curl -s "$BASE_URL/bot$BOT_TOKEN/getMe" | grep -q '"ok":true' && echo "✅ Telegram OK" || echo "❌ Telegram credentials rejected by getMe"
+   ```
+6. **WeCom credentials** (if enabled) — search today's log:
    ```bash
    grep -iE "wecom adapter loop started|WeCom authentication failed|WeCom WS error response|WecomAdapter" \
      ~/.clacky/logger/clacky-$(date +%Y-%m-%d).log
    ```
    - `WeCom authentication failed` or non-zero errcode → ❌ "WeCom credentials incorrect"
    - `adapter loop started` with no auth error → ✅
+6. **Discord credentials** (if enabled) — call `GET /api/channels` and check `has_token: true`. Search today's log:
+   ```bash
+   grep -iE "DiscordAdapter|discord-gateway|/users/@me failed" \
+     ~/.clacky/logger/clacky-$(date +%Y-%m-%d).log
+   ```
+   - `/users/@me failed` → ❌ "Discord token invalid or revoked — re-run setup"
+   - `authenticated as` with no error → ✅
 
 ---
 
@@ -410,7 +532,7 @@ Proactively send a message to a user via an IM channel adapter.
 ### Parse the request
 
 Extract two things from the user's instruction:
-- **platform** — one of `weixin`, `feishu`, `wecom`
+- **platform** — one of `weixin`, `feishu`, `wecom`, `discord`, `telegram`
 - **message** — the text content to send
 
 If the platform cannot be inferred, ask the user to clarify.
@@ -450,7 +572,7 @@ curl -s -X POST http://${CLACKY_SERVER_HOST}:${CLACKY_SERVER_PORT}/api/channels/
 ### Constraints & notes
 
 - **Weixin (iLink protocol)**: Every outbound message requires a `context_token` that is obtained from the most recent inbound message from that user. The token is cached in memory and reset on server restart. If the server was restarted since the user last wrote, the token is gone and the send will fail — the user must message the bot again.
-- **Feishu / WeCom**: No token required. As long as the adapter is running and the `user_id` / `chat_id` is valid, the message will be delivered.
+- **Feishu / WeCom / Discord / Telegram**: No per-message token required. As long as the adapter is running and the `user_id` / `chat_id` (or Discord channel/user id) is valid, the message will be delivered. For Telegram specifically, the `user_id` must be a Telegram chat_id that the bot can write to — the user must have sent at least one message to the bot first.
 - This feature is intended for **proactive notifications** (e.g. task completion, reminders). It is not a replacement for the normal reply flow triggered by inbound messages.
 
 ---

data/lib/clacky/default_skills/channel-setup/discord_setup.rb

@@ -0,0 +1,199 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# discord_setup.rb — Discord channel setup helper.
+#
+# Discord's developer portal requires manual interaction (hCaptcha + private API), so the
+# Agent uses the browser only as a container — it navigates to the portal and the user
+# creates the App manually, then pastes back the bot token and application id. This
+# script handles everything a shell can do: emit the portal URL, validate the token
+# against /users/@me, save to the clacky server, generate the OAuth2 invite URL, and
+# poll until the bot is in at least one guild.
+#
+# Modes:
+#   --portal-url                Print the Discord developer portal URL (stdout, single line)
+#   --validate <token>          Validate bot_token via /users/@me, then POST to server
+#   --invite-url <client_id>    Print the OAuth2 invite URL (stdout, single line)
+#   --watch-guild               Long-poll /users/@me/guilds via the saved token
+#                               until at least one guild appears (or timeout)
+#   --bot-info <token>          Print {id, username} JSON for an unsaved token
+#
+# Environment:
+#   CLACKY_SERVER_HOST  default 127.0.0.1
+#   CLACKY_SERVER_PORT  default 7070
+
+require "json"
+require "net/http"
+require "net/https"
+require "uri"
+require "openssl"
+require "cgi"
+require "yaml"
+
+DISCORD_API_BASE      = "https://discord.com/api/v10"
+DISCORD_OAUTH_BASE    = "https://discord.com/oauth2/authorize"
+DISCORD_PORTAL_URL    = "https://discord.com/developers/applications"
+DEFAULT_BOT_PERMS     = "274877990912"
+DEFAULT_BOT_SCOPES    = "bot applications.commands"
+WATCH_GUILD_DEADLINE  = 10 * 60
+WATCH_GUILD_INTERVAL  = 3
+USER_AGENT            = "DiscordBot (https://github.com/clackyai/openclacky, 1.0)"
+
+CLACKY_SERVER_URL = begin
+  host = ENV.fetch("CLACKY_SERVER_HOST", "127.0.0.1")
+  port = ENV.fetch("CLACKY_SERVER_PORT", "7070")
+  "http://#{host}:#{port}"
+end
+
+def step(msg);  $stderr.puts("[discord-setup] #{msg}"); end
+def ok(msg);    $stderr.puts("[discord-setup] #{msg}"); end
+def warn!(msg); $stderr.puts("[discord-setup] #{msg}"); end
+
+def fail!(msg, json: false)
+  if json
+    $stdout.puts(JSON.generate({ error: msg }))
+  else
+    $stderr.puts("[discord-setup] #{msg}")
+  end
+  exit 1
+end
+
+def discord_get(path, bot_token:, timeout: 15)
+  uri  = URI("#{DISCORD_API_BASE}#{path}")
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.use_ssl      = true
+  http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
+  http.read_timeout = timeout
+  http.open_timeout = 10
+
+  req = Net::HTTP::Get.new(uri.request_uri)
+  req["Authorization"] = "Bot #{bot_token}"
+  req["User-Agent"]    = USER_AGENT
+  req["Accept"]        = "application/json"
+
+  res    = http.request(req)
+  body   = res.body.to_s
+  parsed = (JSON.parse(body) rescue nil)
+
+  unless res.is_a?(Net::HTTPSuccess)
+    msg = parsed.is_a?(Hash) ? (parsed["message"] || body.slice(0, 200)) : body.slice(0, 200)
+    raise "Discord HTTP #{res.code} #{path}: #{msg}"
+  end
+  parsed
+end
+
+def saved_bot_token
+  yml_path = File.expand_path("~/.clacky/channels.yml")
+  return nil unless File.exist?(yml_path)
+  data = YAML.safe_load_file(yml_path, permitted_classes: [Symbol], aliases: true) rescue nil
+  data&.dig("channels", "discord", "bot_token") || data&.dig(:channels, :discord, :bot_token)
+end
+
+def save_to_server(bot_token:)
+  uri  = URI("#{CLACKY_SERVER_URL}/api/channels/discord")
+  body = JSON.generate({ bot_token: bot_token })
+
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.read_timeout = 30
+  http.open_timeout = 5
+
+  req = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
+  req.body = body
+
+  res  = http.request(req)
+  data = JSON.parse(res.body) rescue {}
+
+  unless res.is_a?(Net::HTTPSuccess) && data["ok"]
+    fail!("Failed to save Discord config: #{data["error"] || res.body.slice(0, 200)}")
+  end
+end
+
+mode_idx = ARGV.index { |a| a.start_with?("--") }
+mode     = mode_idx ? ARGV[mode_idx] : nil
+arg      = mode_idx ? ARGV[mode_idx + 1] : nil
+
+case mode
+when "--portal-url"
+  $stdout.puts(DISCORD_PORTAL_URL)
+  exit 0
+
+when "--validate"
+  fail!("--validate requires <bot_token>") if arg.to_s.strip.empty?
+  bot_token = arg.strip
+  step("Validating bot token against Discord API...")
+  begin
+    me = discord_get("/users/@me", bot_token: bot_token)
+  rescue => e
+    fail!("Token validation failed: #{e.message}")
+  end
+
+  bot_id   = me["id"].to_s
+  username = me["username"].to_s
+  fail!("Empty bot id from /users/@me") if bot_id.empty?
+
+  ok("Authenticated as #{username} (id=#{bot_id})")
+  step("Saving credentials via clacky server...")
+  save_to_server(bot_token: bot_token)
+  ok("Discord channel configured")
+
+  $stdout.puts(JSON.generate({ bot_id: bot_id, username: username }))
+  exit 0
+
+when "--bot-info"
+  fail!("--bot-info requires <bot_token>", json: true) if arg.to_s.strip.empty?
+  begin
+    me = discord_get("/users/@me", bot_token: arg.strip)
+  rescue => e
+    fail!(e.message, json: true)
+  end
+  $stdout.puts(JSON.generate({ bot_id: me["id"], username: me["username"] }))
+  exit 0
+
+when "--invite-url"
+  fail!("--invite-url requires <client_id>") if arg.to_s.strip.empty?
+  client_id = arg.strip
+  url = "#{DISCORD_OAUTH_BASE}?client_id=#{CGI.escape(client_id)}" \
+        "&permissions=#{DEFAULT_BOT_PERMS}" \
+        "&scope=#{CGI.escape(DEFAULT_BOT_SCOPES)}"
+  $stdout.puts(url)
+  exit 0
+
+when "--watch-guild"
+  bot_token = saved_bot_token
+  fail!("No saved bot_token in ~/.clacky/channels.yml — run --validate first") if bot_token.to_s.empty?
+
+  step("Waiting for the bot to be added to a guild (timeout: #{WATCH_GUILD_DEADLINE / 60} min)...")
+  deadline = Time.now + WATCH_GUILD_DEADLINE
+
+  loop do
+    fail!("Timed out waiting for the bot to join a guild. Open the invite URL again to retry.") if Time.now > deadline
+
+    begin
+      guilds = discord_get("/users/@me/guilds", bot_token: bot_token)
+    rescue => e
+      warn!("Poll error (will retry): #{e.message}")
+      sleep WATCH_GUILD_INTERVAL
+      next
+    end
+
+    if guilds.is_a?(Array) && !guilds.empty?
+      g = guilds.first
+      ok("Bot added to guild: #{g["name"]} (id=#{g["id"]})")
+      $stdout.puts(JSON.generate({ guild_id: g["id"], guild_name: g["name"], total: guilds.length }))
+      exit 0
+    end
+
+    sleep WATCH_GUILD_INTERVAL
+  end
+
+else
+  $stderr.puts(<<~USAGE)
+    Usage:
+      ruby discord_setup.rb --portal-url
+      ruby discord_setup.rb --validate <bot_token>
+      ruby discord_setup.rb --bot-info <bot_token>
+      ruby discord_setup.rb --invite-url <client_id>
+      ruby discord_setup.rb --watch-guild
+  USAGE
+  exit 1
+end

data/lib/clacky/providers.rb

@@ -29,7 +29,7 @@ module Clacky
         "name" => "OpenClacky",
         "base_url" => "https://api.openclacky.com",
         "api" => "bedrock",
-        "default_model" => "abs-claude-sonnet-4-5",
+        "default_model" => "abs-claude-sonnet-4-6",
         "models" => [
           "abs-claude-opus-4-7",
           "abs-claude-opus-4-6",
@@ -80,7 +80,32 @@ module Clacky
         "base_url" => "https://openrouter.ai/api/v1",
         "api" => "openai-responses",
         "default_model" => "anthropic/claude-sonnet-4-6",
-        "models" => [],  # Dynamic - fetched from API
+        # Curated default lineup. OpenRouter's full catalogue is enormous
+        # (hundreds of models) and the live /models endpoint isn't always
+        # reachable from every region — shipping a small list of the
+        # mainstream Claude + GPT entries gives users a working dropdown
+        # out of the box. Users can still type any other OpenRouter model
+        # ID manually; this list only seeds the picker.
+        "models" => [
+          "anthropic/claude-sonnet-4-6",
+          "anthropic/claude-opus-4-7",
+          "anthropic/claude-opus-4-6",
+          "anthropic/claude-haiku-4-5",
+          "openai/gpt-5.5",
+          "openai/gpt-5.4",
+          "openai/gpt-5.4-mini"
+        ],
+        # Per-primary lite pairing — Claude family pairs with Haiku, GPT
+        # family pairs with the mini variant. Mirrors the openclacky and
+        # openai presets above so subagents on OpenRouter get a sensible
+        # cheap/fast sidekick automatically.
+        "lite_models" => {
+          "anthropic/claude-sonnet-4-6" => "anthropic/claude-haiku-4-5",
+          "anthropic/claude-opus-4-7"   => "anthropic/claude-haiku-4-5",
+          "anthropic/claude-opus-4-6"   => "anthropic/claude-haiku-4-5",
+          "openai/gpt-5.5"              => "openai/gpt-5.4-mini",
+          "openai/gpt-5.4"              => "openai/gpt-5.4-mini"
+        },
         # Per-model API type overrides. Matched by Regexp against the model name.
         # Why this exists: OpenRouter proxies Claude via both its OpenAI-compatible
         # /chat/completions endpoint AND a native Anthropic /v1/messages endpoint.
@@ -243,8 +268,8 @@ module Clacky
         "name" => "MiMo (Xiaomi)",
         "base_url" => "https://api.xiaomimimo.com/v1",
         "api" => "openai-completions",
-        "default_model" => "mimo-v2-pro",
-        "models" => ["mimo-v2-pro", "mimo-v2-omni"],
+        "default_model" => "mimo-v2.5-pro",
+        "models" => ["mimo-v2.5-pro", "mimo-v2-pro", "mimo-v2-omni"],
         # MiMo-V2-Pro is text-only; MiMo-V2-Omni supports vision (omni = multimodal).
         "capabilities" => { "vision" => false }.freeze,
         "model_capabilities" => {