@link-assistant/hive-mind 1.74.4 → 1.74.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @link-assistant/hive-mind
 
+## 1.74.6
+
+### Patch Changes
+
+- e07b243: Split oversized Telegram text messages in the safe reply/edit helper so localized `/help` output cannot exceed Telegram's 4096-character limit.
+
+## 1.74.5
+
+### Patch Changes
+
+- c20c2ec: Stop auto-restart-until-mergeable from restarting on CodeRabbit review quota/credit failures, and report them as Ready for review with skipped checks instead.
+
 ## 1.74.4
 
 ### Patch Changes

package/README.hi.md

@@ -29,14 +29,19 @@ Hive Mind एक **सामान्यवादी AI** (मिनी-AGI) ह
 | **पूर्व-स्थापित टूलचेन**           | 25GB+ तैयार: 10 भाषा रनटाइम, 2 थ्योरम प्रूवर, बिल्ड टूल्स। और इंस्टॉल कर सकते हैं।                                                                                                  |
 | **टोकन दक्षता**                    | नियमित कार्य कोड में स्वचालित, ताकि AI टोकन रचनात्मक समस्या-समाधान पर केंद्रित रहें।                                                                                                |
 | **समय की स्वतंत्रता**              | जो काम मनुष्यों को 2-8 घंटे लगता है, AI प्रत्येक कार्य सत्र में 10-25 मिनट में पूरा करता है। रिपॉजिटरी में कार्यों का बड़े पैमाने पर निष्पादन संभव है। "सोते समय कोड लिखा जाता है।" |
-| **ऑर्केस्ट्रेशन के साथ स्केल**     | समानांतर वर्कर डेवलपर्स की एक टीम की तरह महसूस होते हैं, सभी ~$200/माह में।                                                                                                         |
+| **ऑर्केस्ट्रेशन के साथ स्केल**     | समानांतर वर्कर डेवलपर्स की एक टीम की तरह महसूस होते हैं। Claude MAX और ChatGPT Pro (प्रत्येक $200) को जोड़कर दो स्वतंत्र लगभग असीमित बजट मिलते हैं।                                 |
 | **मानव नियंत्रण**                  | AI ड्राफ्ट PR बनाता है - आप तय करते हैं क्या मर्ज होगा। जहाँ मायने रखता है वहाँ गुणवत्ता द्वार।                                                                                     |
 | **किसी भी डिवाइस से प्रोग्रामिंग** | Telegram बॉट के माध्यम से `/solve` और `/hive` से किसी भी डिवाइस से AI प्रबंधित करें। कोई PC, IDE या लैपटॉप की आवश्यकता नहीं।                                                        |
 | **100% ओपन सोर्स**                 | Unlicense (पब्लिक डोमेन)। पूर्ण पारदर्शिता, कोई वेंडर लॉक-इन नहीं।                                                                                                                  |
 
-> _"$200 के Codex की तुलना में, यह समाधान शानदार है।"_ - उपयोगकर्ता प्रतिक्रिया
+**लागत**: Hive Mind दो $200/माह सदस्यताओं को पूर्ण-फीचर वाले लगभग "unlimited" विकल्पों के रूप में समर्थन देता है:
 
-**लागत**: Claude MAX सदस्यता (~$200/माह, वर्तमान में 50% छूट = $400 मूल्य) Hive Mind के लिए लगभग असीमित उपयोग प्रदान करती है - बाजार में सबसे अच्छा मूल्य/गुणवत्ता संतुलन।
+| सदस्यता                                                          | `--tool` के साथ     | डिफ़ॉल्ट मॉडल | किसके लिए बेहतर है                                |
+| ---------------------------------------------------------------- | ------------------- | ------------- | ------------------------------------------------- |
+| **Anthropic Claude MAX** (~$200/माह, अक्सर 50% छूट = $400 मूल्य) | `claude` (डिफ़ॉल्ट) | Sonnet/Haiku  | उच्चतम रचनात्मकता, मजबूत सामान्य कोड रीजनिंग      |
+| **OpenAI ChatGPT Pro** ($200/माह, Codex शामिल)                   | `codex`             | `gpt-5.5`     | भरोसेमंद deterministic refactors और तेज iteration |
+
+दोनों टूल एक ही hive में साथ उपयोग किए जा सकते हैं। Worker अलग-अलग टूल समानांतर चला सकते हैं, और `/codex` या `/solve --tool codex` कार्यों को ChatGPT Pro पर भेजता है जबकि डिफ़ॉल्ट Claude MAX पर जाता है। किसी एक को चुनना आवश्यक नहीं है: किसी भी एक सदस्यता से संचालन संभव है, और दोनों का उपयोग per-tool/model concurrency mode (#1474) खोलता है।
 
 Hive Mind में औसत प्रोग्रामर से अलग न पहचानी जा सकने वाली उच्च रचनात्मकता है। यदि आवश्यकताएँ अस्पष्ट हों तो यह प्रश्न पूछता है, और आप PR टिप्पणियों के माध्यम से चलते-चलते स्पष्ट कर सकते हैं।
 
@@ -48,7 +53,7 @@ Hive Mind में औसत प्रोग्रामर से अलग
 
 इंस्टॉलेशन के लिए Docker का उपयोग करना अनुशंसित है (स्थानीय और सर्वर दोनों पर)। नीचे [Docker इंस्टॉलेशन](#using-docker) अनुभाग देखें।
 
-यह सॉफ़्टवेयर Claude Code के पूर्ण स्वायत्त मोड का उपयोग करता है, जिसका अर्थ है कि यह जो भी उचित समझे वह कमांड निष्पादित करने के लिए स्वतंत्र है।
+यह सॉफ़्टवेयर Claude Code और Codex जैसे समर्थित AI टूल को पूर्ण स्वायत्त मोड में चलाता है, जिसका अर्थ है कि वे जो भी उचित समझें वे कमांड निष्पादित करने के लिए स्वतंत्र हैं।
 
 इसका मतलब है कि इससे अप्रत्याशित दुष्प्रभाव हो सकते हैं।
 
@@ -60,7 +65,7 @@ Hive Mind में औसत प्रोग्रामर से अलग
 
 इंटरनेट से जुड़ी वर्चुअल मशीन से टोकन निकालने के असंख्य तरीके हैं। इसमें शामिल हैं लेकिन इन तक सीमित नहीं:
 
-- **Claude MAX टोकन** - AI संचालन के लिए आवश्यक
+- **Claude MAX टोकन** और/या **ChatGPT Pro (Codex) टोकन** - AI संचालन के लिए आवश्यक; आप इनमें से किसी एक या दोनों के साथ चला सकते हैं
 - **GitHub टोकन** - रिपॉजिटरी एक्सेस के लिए आवश्यक
 - **API keys और क्रेडेंशियल** - सिस्टम पर कोई भी संवेदनशील डेटा
 
@@ -161,7 +166,7 @@ docker exec -it hive-mind /bin/bash
 # Inside the container, authenticate with GitHub
 gh-setup-git-identity
 
-# Authenticate with Claude
+# Authenticate with Claude (if you have Claude MAX)
 claude
 
 # Optionally set configuration like this:
@@ -174,6 +179,14 @@ claude
 # Optionally test Claude connection
 claude -p hi --model haiku
 
+# Authenticate with Codex (if you have ChatGPT Pro)
+codex login --device-auth
+
+# Optionally test Codex connection. codex exec refuses to run unless
+# either cwd is a git repo it trusts or --skip-git-repo-check is passed.
+# It prints the refusal to STDOUT but still exits 0, so do not skip the flag.
+codex exec --skip-git-repo-check --model gpt-5.4-mini "reply with only OK"
+
 # You might need to update hive-mind and agent to latest versions:
 bun install -g @link-assistant/hive-mind
 bun install -g @link-assistant/agent

package/README.md

@@ -29,14 +29,19 @@ Hive Mind is a **generalist AI** (mini-AGI) capable of working on a wide range o
 | **Pre-installed Toolchain**  | 25GB+ ready: 10 language runtimes, 2 theorem provers, build tools. Can install more.                                                                                       |
 | **Token Efficiency**         | Routine tasks automated in code, so AI tokens focus on creative problem-solving.                                                                                           |
 | **Time Freedom**             | What takes humans 2-8 hours, AI completes each working session in 10-25 minutes. Mass execution of tasks in repository is possible. "The code is written while you sleep." |
-| **Scale with Orchestration** | Parallel workers feel like a team of developers, all for ~$200/month.                                                                                                      |
+| **Scale with Orchestration** | Parallel workers feel like a team of developers. Pair Claude MAX and ChatGPT Pro ($200 each) for two independent unlimited budgets.                                        |
 | **Human Control**            | AI creates draft PRs - you decide what merges. Quality gates where they matter.                                                                                            |
 | **Any Device Programming**   | Manage AI from any device with `/solve` and `/hive` via Telegram bot. No PC, IDE, or laptop required.                                                                      |
 | **100% Open Source**         | Unlicense (public domain). Full transparency, no vendor lock-in.                                                                                                           |
 
-> _"Compared to Codex for $200, this solution is fire."_ - User feedback
+**Cost**: Hive Mind supports two $200/month subscriptions as full-featured "unlimited" options:
 
-**Cost**: Claude MAX subscription (~$200/month, currently 50% off = $400 value) provides almost unlimited usage for Hive Mind - the best value/quality balance on the market.
+| Subscription                                                       | Pairs with `--tool` | Default model | Best for                                                |
+| ------------------------------------------------------------------ | ------------------- | ------------- | ------------------------------------------------------- |
+| **Anthropic Claude MAX** (~$200/month, often 50% off = $400 value) | `claude` (default)  | Sonnet/Haiku  | Highest creativity, strongest general code reasoning    |
+| **OpenAI ChatGPT Pro** ($200/month, includes Codex)                | `codex`             | `gpt-5.5`     | Strong deterministic refactors and fast iteration loops |
+
+Both tools can be combined in the same hive. Workers can run different tools in parallel, and `/codex` or `/solve --tool codex` routes tasks to ChatGPT Pro while the default routes to Claude MAX. There is no requirement to pick one: either single subscription is enough to operate, and using both unlocks per-tool/model concurrency mode (#1474).
 
 Hive Mind has high creativity indistinguishable from average programmers. It asks questions if requirements are unclear, and you can clarify on the go via PR comments.
 
@@ -48,7 +53,7 @@ It is UNSAFE to run this software on your developer machine.
 
 It is recommended to use Docker for installation (both locally and on servers). See the [Docker installation](#using-docker) section below.
 
-This software uses full autonomous mode of Claude Code, that means it is free to execute any commands it sees fit.
+This software runs supported AI tools such as Claude Code and Codex in full autonomous mode, which means they are free to execute any commands they see fit.
 
 That means it can lead to unexpected side effects.
 
@@ -60,7 +65,7 @@ There is also a known issue of space leakage. So you need to make sure you are a
 
 There are infinite ways to extract tokens from a virtual machine connected to the internet. This includes but is not limited to:
 
-- **Claude MAX tokens** - Required for AI operations
+- **Claude MAX tokens** and/or **ChatGPT Pro (Codex) tokens** - Required for AI operations; you can run with either or both
 - **GitHub tokens** - Required for repository access
 - **API keys and credentials** - Any sensitive data on the system
 
@@ -161,7 +166,7 @@ docker exec -it hive-mind /bin/bash
 # Inside the container, authenticate with GitHub
 gh-setup-git-identity
 
-# Authenticate with Claude
+# Authenticate with Claude (if you have Claude MAX)
 claude
 
 # Optionally set configuration like this:
@@ -174,6 +179,14 @@ claude
 # Optionally test Claude connection
 claude -p hi --model haiku
 
+# Authenticate with Codex (if you have ChatGPT Pro)
+codex login --device-auth
+
+# Optionally test Codex connection. codex exec refuses to run unless
+# either cwd is a git repo it trusts or --skip-git-repo-check is passed.
+# It prints the refusal to STDOUT but still exits 0, so do not skip the flag.
+codex exec --skip-git-repo-check --model gpt-5.4-mini "reply with only OK"
+
 # Verify Playwright MCP is registered for both CLIs in this container image
 claude mcp list | grep playwright
 codex mcp list | grep playwright

package/README.ru.md

@@ -21,22 +21,27 @@
 
 Hive Mind — это **универсальный ИИ** (мини-AGI), способный работать над широким спектром задач, а не только над программированием. Практически всё, что можно сделать с файлами в репозитории, поддаётся автоматизации.
 
-| Возможность                              | Что это означает для вас                                                                                                                                           |
-| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| **Без постоянного контроля**             | Полный автономный режим с правами sudo. ИИ обладает творческой свободой, как настоящий программист.                                                                |
-| **Изоляция в облаке**                    | Работает на выделенных виртуальных машинах или в Docker. Легко восстановить в случае поломки.                                                                      |
-| **Полный доступ к интернету + Sudo**     | ИИ может устанавливать пакеты, получать документацию и настраивать систему по мере необходимости.                                                                  |
-| **Предустановленный инструментарий**     | Более 25 ГБ готово к работе: 10 языковых сред выполнения, 2 средства доказательства теорем, инструменты сборки. Можно установить дополнительные.                   |
-| **Эффективность токенов**                | Рутинные задачи автоматизированы в коде, поэтому токены ИИ сосредоточены на творческом решении проблем.                                                            |
-| **Свобода времени**                      | То, что занимает у людей 2–8 часов, ИИ выполняет за 10–25 минут за рабочую сессию. Возможно массовое выполнение задач в репозитории. «Код пишется, пока вы спите». |
-| **Масштабирование с оркестрацией**       | Параллельные воркеры ощущаются как команда разработчиков — всё примерно за $200 в месяц.                                                                           |
-| **Контроль со стороны человека**         | ИИ создаёт черновые PR — вы решаете, что вливать. Контроль качества там, где это важно.                                                                            |
-| **Программирование с любого устройства** | Управляйте ИИ с любого устройства через `/solve` и `/hive` посредством Telegram-бота. ПК, IDE или ноутбук не нужны.                                                |
-| **100% открытый исходный код**           | Лицензия Unlicense (общественное достояние). Полная прозрачность, без привязки к поставщику.                                                                       |
-
-> _«По сравнению с Codex за $200, это решение — огонь.»_ — отзыв пользователя
-
-**Стоимость**: подписка Claude MAX (~$200 в месяц, сейчас со скидкой 50% = ценность $400) обеспечивает практически неограниченное использование для Hive Mind — лучшее соотношение цены и качества на рынке.
+| Возможность                              | Что это означает для вас                                                                                                                                               |
+| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Без постоянного контроля**             | Полный автономный режим с правами sudo. ИИ обладает творческой свободой, как настоящий программист.                                                                    |
+| **Изоляция в облаке**                    | Работает на выделенных виртуальных машинах или в Docker. Легко восстановить в случае поломки.                                                                          |
+| **Полный доступ к интернету + Sudo**     | ИИ может устанавливать пакеты, получать документацию и настраивать систему по мере необходимости.                                                                      |
+| **Предустановленный инструментарий**     | Более 25 ГБ готово к работе: 10 языковых сред выполнения, 2 средства доказательства теорем, инструменты сборки. Можно установить дополнительные.                       |
+| **Эффективность токенов**                | Рутинные задачи автоматизированы в коде, поэтому токены ИИ сосредоточены на творческом решении проблем.                                                                |
+| **Свобода времени**                      | То, что занимает у людей 2–8 часов, ИИ выполняет за 10–25 минут за рабочую сессию. Возможно массовое выполнение задач в репозитории. «Код пишется, пока вы спите».     |
+| **Масштабирование с оркестрацией**       | Параллельные воркеры ощущаются как команда разработчиков. Свяжите Claude MAX и ChatGPT Pro (по $200 каждый), чтобы получить два независимых почти безлимитных бюджета. |
+| **Контроль со стороны человека**         | ИИ создаёт черновые PR — вы решаете, что вливать. Контроль качества там, где это важно.                                                                                |
+| **Программирование с любого устройства** | Управляйте ИИ с любого устройства через `/solve` и `/hive` посредством Telegram-бота. ПК, IDE или ноутбук не нужны.                                                    |
+| **100% открытый исходный код**           | Лицензия Unlicense (общественное достояние). Полная прозрачность, без привязки к поставщику.                                                                           |
+
+**Стоимость**: Hive Mind поддерживает две подписки по $200 в месяц как полнофункциональные почти «безлимитные» варианты:
+
+| Подписка                                                          | Используется с `--tool` | Модель по умолчанию | Лучше всего подходит для                                   |
+| ----------------------------------------------------------------- | ----------------------- | ------------------- | ---------------------------------------------------------- |
+| **Anthropic Claude MAX** (~$200 в месяц, часто скидка 50% = $400) | `claude` (по умолчанию) | Sonnet/Haiku        | Максимальная креативность и сильное общее кодовое мышление |
+| **OpenAI ChatGPT Pro** ($200 в месяц, включает Codex)             | `codex`                 | `gpt-5.5`           | Надёжные детерминированные рефакторинги и быстрые итерации |
+
+Оба инструмента можно сочетать в одном hive. Воркеры могут параллельно запускать разные инструменты, а `/codex` или `/solve --tool codex` направляет задачи в ChatGPT Pro, тогда как маршрут по умолчанию идёт в Claude MAX. Выбирать только один вариант не требуется: любой одной подписки достаточно для работы, а использование обеих открывает режим параллелизма по инструментам/моделям (#1474).
 
 Hive Mind обладает высоким уровнем творчества, неотличимым от среднего программиста. Он задаёт вопросы, если требования неясны, и вы можете уточнять их на ходу через комментарии к PR.
 
@@ -48,7 +53,7 @@ Hive Mind обладает высоким уровнем творчества,
 
 Рекомендуется использовать Docker для установки (как локально, так и на серверах). Смотрите раздел [Установка через Docker](#использование-docker) ниже.
 
-Это программное обеспечение использует полностью автономный режим Claude Code, а значит, оно может выполнять любые команды по своему усмотрению.
+Это программное обеспечение запускает поддерживаемые ИИ-инструменты, такие как Claude Code и Codex, в полностью автономном режиме, а значит, они могут выполнять любые команды по своему усмотрению.
 
 Это может привести к непредвиденным побочным эффектам.
 
@@ -60,7 +65,7 @@ Hive Mind обладает высоким уровнем творчества,
 
 Существует бесконечное множество способов извлечь токены с виртуальной машины, подключённой к интернету. Это включает, но не ограничивается:
 
-- **Токены Claude MAX** — необходимы для работы ИИ
+- **Токены Claude MAX** и/или **токены ChatGPT Pro (Codex)** — необходимы для работы ИИ; можно запускать с любым из них или с обоими
 - **Токены GitHub** — необходимы для доступа к репозиториям
 - **API-ключи и учётные данные** — любые конфиденциальные данные в системе
 
@@ -161,7 +166,7 @@ docker exec -it hive-mind /bin/bash
 # Inside the container, authenticate with GitHub
 gh-setup-git-identity
 
-# Authenticate with Claude
+# Authenticate with Claude (if you have Claude MAX)
 claude
 
 # Optionally set configuration like this:
@@ -174,6 +179,14 @@ claude
 # Optionally test Claude connection
 claude -p hi --model haiku
 
+# Authenticate with Codex (if you have ChatGPT Pro)
+codex login --device-auth
+
+# Optionally test Codex connection. codex exec refuses to run unless
+# either cwd is a git repo it trusts or --skip-git-repo-check is passed.
+# It prints the refusal to STDOUT but still exits 0, so do not skip the flag.
+codex exec --skip-git-repo-check --model gpt-5.4-mini "reply with only OK"
+
 # You might need to update hive-mind and agent to latest versions:
 bun install -g @link-assistant/hive-mind
 bun install -g @link-assistant/agent

package/README.zh.md

@@ -29,14 +29,19 @@ Hive Mind 是一款**通用 AI**（迷你 AGI），能够处理广泛的任务
 | **预装工具链**             | 25GB+ 开箱即用：10 种语言运行时、2 个定理证明器、构建工具，还可继续安装更多。                                 |
 | **高效利用 Token**         | 常规任务通过代码自动化完成，让 AI Token 专注于创造性问题解决。                                                |
 | **节省时间**               | 人类需要 2~8 小时的工作，AI 每个工作会话仅需 10~25 分钟完成。可批量执行仓库中的任务。"代码在你睡觉时已写好。" |
-| **编排式扩展**             | 并行工作进程犹如一支开发团队，每月仅需约 $200。                                                               |
+| **编排式扩展**             | 并行工作进程犹如一支开发团队。可将 Claude MAX 和 ChatGPT Pro（各 $200）配对，获得两份独立的近乎无限预算。     |
 | **人工控制**               | AI 创建草稿 PR——由您决定是否合并。在关键节点设置质量把关。                                                    |
 | **任意设备编程**           | 通过 Telegram 机器人使用 `/solve` 和 `/hive` 命令，在任意设备上管理 AI，无需 PC、IDE 或笔记本电脑。           |
 | **100% 开源**              | Unlicense（公共领域）。完全透明，无供应商锁定。                                                               |
 
-> _"与 $200 的 Codex 相比，这个解决方案简直是神器。"_ - 用户反馈
+**费用**：Hive Mind 支持两种 $200/月订阅作为功能完整、近乎“无限”的选项：
 
-**费用**：Claude MAX 订阅（约 $200/月，目前五折优惠 = 价值 $400）可为 Hive Mind 提供几乎无限的使用量——市场上最佳的性价比。
+| 订阅                                                             | 搭配 `--tool`    | 默认模型     | 最适合场景                   |
+| ---------------------------------------------------------------- | ---------------- | ------------ | ---------------------------- |
+| **Anthropic Claude MAX**（约 $200/月，常有五折优惠 = 价值 $400） | `claude`（默认） | Sonnet/Haiku | 最高创造力、最强通用代码推理 |
+| **OpenAI ChatGPT Pro**（$200/月，包含 Codex）                    | `codex`          | `gpt-5.5`    | 稳定确定性的重构和快速迭代   |
+
+两个工具可以在同一个 hive 中组合使用。Worker 可以并行运行不同工具，`/codex` 或 `/solve --tool codex` 会将任务路由到 ChatGPT Pro，而默认路由到 Claude MAX。无需二选一：任意单一订阅都足以运行，同时使用两者可解锁按工具/模型划分的并发模式（#1474）。
 
 Hive Mind 具备与普通程序员无异的高度创造力。当需求不明确时，它会主动提问，您也可以随时通过 PR 评论进行说明补充。
 
@@ -48,7 +53,7 @@ Hive Mind 具备与普通程序员无异的高度创造力。当需求不明确
 
 建议使用 Docker 进行安装（本地和服务器均适用）。请参阅下方的 [Docker 安装](#使用-docker) 部分。
 
-本软件使用 Claude Code 的完全自主模式，这意味着它可以自由执行任何它认为合适的命令。
+本软件会以完全自主模式运行 Claude Code、Codex 等受支持的 AI 工具，这意味着它们可以自由执行任何它们认为合适的命令。
 
 这可能导致意想不到的副作用。
 
@@ -60,7 +65,7 @@ Hive Mind 具备与普通程序员无异的高度创造力。当需求不明确
 
 从连接互联网的虚拟机中提取 Token 的方式多种多样，包括但不限于：
 
-- **Claude MAX Token** - AI 操作所必需
+- **Claude MAX Token** 和/或 **ChatGPT Pro (Codex) Token** - AI 操作所必需；您可以使用其中任意一种或同时使用两者
 - **GitHub Token** - 仓库访问所必需
 - **API 密钥和凭证** - 系统上的任何敏感数据
 
@@ -161,7 +166,7 @@ docker exec -it hive-mind /bin/bash
 # Inside the container, authenticate with GitHub
 gh-setup-git-identity
 
-# Authenticate with Claude
+# Authenticate with Claude (if you have Claude MAX)
 claude
 
 # Optionally set configuration like this:
@@ -174,6 +179,14 @@ claude
 # Optionally test Claude connection
 claude -p hi --model haiku
 
+# Authenticate with Codex (if you have ChatGPT Pro)
+codex login --device-auth
+
+# Optionally test Codex connection. codex exec refuses to run unless
+# either cwd is a git repo it trusts or --skip-git-repo-check is passed.
+# It prints the refusal to STDOUT but still exits 0, so do not skip the flag.
+codex exec --skip-git-repo-check --model gpt-5.4-mini "reply with only OK"
+
 # You might need to update hive-mind and agent to latest versions:
 bun install -g @link-assistant/hive-mind
 bun install -g @link-assistant/agent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.74.4",
+  "version": "1.74.6",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/external-review-limit.lib.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+/**
+ * Helpers for external review services whose checks fail because the service
+ * could not run, not because repository code failed.
+ */
+
+const EXTERNAL_REVIEW_SERVICE_PATTERNS = [/coderabbit/i, /code\s*rabbit/i];
+
+const EXTERNAL_REVIEW_LIMIT_PATTERNS = [/insufficient\s+(?:review\s+)?credits?/i, /review\s+limit\s+reached/i, /rate\s+limit(?:ed|s)?/i, /run\s+out\s+of\s+usage\s+credits?/i, /out\s+of\s+usage\s+credits?/i, /usage\s+credits?\s+(?:exhausted|reached|insufficient)/i, /insufficient\s+(?:balance|limits?)/i, /no\s+(?:credits?|balance)\s+(?:left|remaining)/i];
+
+const checkText = check => {
+  if (!check || typeof check !== 'object') return '';
+  return [check.name, check.context, check.description, check.summary, check.text, check.html_url, check.details_url].filter(Boolean).join('\n');
+};
+
+export const isExternalReviewLimitCheck = check => {
+  const text = checkText(check);
+  if (!text) return false;
+  return EXTERNAL_REVIEW_SERVICE_PATTERNS.some(pattern => pattern.test(text)) && EXTERNAL_REVIEW_LIMIT_PATTERNS.some(pattern => pattern.test(text));
+};
+
+export const splitExternalReviewLimitChecks = checks => {
+  const limitedChecks = [];
+  const actionableFailedChecks = [];
+
+  for (const check of checks || []) {
+    if (isExternalReviewLimitCheck(check)) {
+      limitedChecks.push(check);
+    } else {
+      actionableFailedChecks.push(check);
+    }
+  }
+
+  return { limitedChecks, actionableFailedChecks };
+};
+
+export const formatExternalReviewLimitCheck = check => {
+  const name = check?.name || check?.context || 'External review';
+  const description = check?.description && check.description !== name ? ` — ${check.description}` : '';
+  const url = check?.html_url || check?.details_url;
+  return `${name}${description}${url ? ` — ${url}` : ''}`;
+};
+
+const formatList = items => items.map(item => `- ${item}`).join('\n');
+
+export const buildReadyForReviewComment = ({ blocker, ciStatus } = {}) => {
+  const skippedChecks = blocker?.details?.length ? blocker.details : (blocker?.checks || []).map(formatExternalReviewLimitCheck);
+  const skippedList = skippedChecks.length > 0 ? skippedChecks : ['External review check — blocked by service credits/rate limits'];
+  const passedChecks = (ciStatus?.passedChecks || []).map(formatExternalReviewLimitCheck);
+  const passedSection = passedChecks.length > 0 ? `\n\n**Checks completed successfully:**\n${formatList(passedChecks)}` : '';
+
+  return `## 🟡 Ready for review
+
+Hive Mind stopped automatic restart because the remaining failed check is an external review quota/credit limit, not a code failure it can fix.
+
+**Checks not executed:**
+${formatList(skippedList)}${passedSection}
+
+**Action required:**
+- Restore the external review credits/rate limit and rerun the review, or decide manually whether this PR can proceed.
+- No new AI session was started for this blocker.
+
+---
+*Monitored by hive-mind with --auto-restart-until-mergeable flag.*`;
+};

package/src/github-merge.lib.mjs

@@ -346,12 +346,14 @@ export async function checkPRCIStatus(owner, repo, prNumber, verbose = false) {
         status: check.status,
         conclusion: check.conclusion,
         type: 'check_run',
+        description: check.output?.title || check.output?.summary || null,
       })),
       ...statuses.map(status => ({
         name: status.context,
         status: status.state === 'pending' ? 'in_progress' : 'completed',
         conclusion: status.state === 'pending' ? null : status.state === 'success' ? 'success' : status.state === 'failure' ? 'failure' : status.state,
         type: 'status',
+        description: status.description || null,
       })),
     ];
 
@@ -375,7 +377,7 @@ export async function checkPRCIStatus(owner, repo, prNumber, verbose = false) {
 
     const hasPending = allChecks.some(c => c.status !== 'completed' || c.conclusion === null);
     const allPassed = !hasPending && allChecks.every(c => c.conclusion === 'success' || c.conclusion === 'skipped' || c.conclusion === 'neutral');
-    const hasFailed = allChecks.some(c => c.conclusion === 'failure' || c.conclusion === 'cancelled' || c.conclusion === 'timed_out');
+    const hasFailed = allChecks.some(c => c.conclusion === 'failure' || c.conclusion === 'error' || c.conclusion === 'cancelled' || c.conclusion === 'timed_out');
 
     let status;
     if (hasPending) {
@@ -1126,6 +1128,7 @@ export async function getDetailedCIStatus(owner, repo, prNumber, verbose = false
         conclusion: check.conclusion, // success, failure, cancelled, timed_out, skipped, neutral, action_required, stale, null
         type: 'check_run',
         id: check.id,
+        description: check.output?.title || check.output?.summary || null,
         html_url: check.html_url || check.details_url || null,
       })),
       ...statuses.map(status => ({
@@ -1134,6 +1137,7 @@ export async function getDetailedCIStatus(owner, repo, prNumber, verbose = false
         conclusion: status.state === 'pending' ? null : status.state === 'success' ? 'success' : status.state === 'failure' ? 'failure' : status.state,
         type: 'status',
         id: null,
+        description: status.description || null,
         html_url: status.target_url || null,
       })),
     ];
@@ -1173,7 +1177,7 @@ export async function getDetailedCIStatus(owner, repo, prNumber, verbose = false
     // neutral, action_required, stale, null (not yet completed)
     // GitHub check run statuses include: queued, in_progress, completed, waiting, requested, pending
     const passedChecks = allChecks.filter(c => c.conclusion === 'success' || c.conclusion === 'skipped' || c.conclusion === 'neutral');
-    const failedChecks = allChecks.filter(c => c.conclusion === 'failure' || c.conclusion === 'timed_out' || c.conclusion === 'action_required');
+    const failedChecks = allChecks.filter(c => c.conclusion === 'failure' || c.conclusion === 'error' || c.conclusion === 'timed_out' || c.conclusion === 'action_required');
     const cancelledChecks = allChecks.filter(c => c.conclusion === 'cancelled');
     const staleChecks = allChecks.filter(c => c.conclusion === 'stale');
     const pendingChecks = allChecks.filter(c => (c.status === 'in_progress' || c.status === 'waiting' || c.status === 'requested' || c.status === 'pending') && c.conclusion === null);

package/src/solve.auto-merge-helpers.lib.mjs

@@ -78,6 +78,9 @@ const formatRunLine = run => {
 const toolComments = await import('./tool-comments.lib.mjs');
 const { SESSION_ENDING_MARKERS, isToolGeneratedComment, isToolTrackedCommentId, trackToolCommentId } = toolComments;
 
+const externalReviewLimitLib = await import('./external-review-limit.lib.mjs');
+const { formatExternalReviewLimitCheck, splitExternalReviewLimitChecks } = externalReviewLimitLib;
+
 /**
  * Issue #1323: Check if a comment with specific content already exists on the PR
  * This prevents duplicate status comments when multiple processes or restarts occur
@@ -798,11 +801,22 @@ export const getMergeBlockers = async (owner, repo, prNumber, verbose = false, c
           sha: ciStatus.sha,
         });
       }
-      blockers.push({
-        type: 'ci_failure',
-        message: 'CI/CD checks are failing',
-        details: ciStatus.failedChecks.map(c => c.name),
-      });
+      const { limitedChecks, actionableFailedChecks } = splitExternalReviewLimitChecks(ciStatus.failedChecks);
+      if (limitedChecks.length > 0) {
+        blockers.push({
+          type: 'external_review_limit',
+          message: 'External review check was not executed because credits/rate limits are exhausted',
+          details: limitedChecks.map(formatExternalReviewLimitCheck),
+          checks: limitedChecks,
+        });
+      }
+      if (actionableFailedChecks.length > 0) {
+        blockers.push({
+          type: 'ci_failure',
+          message: 'CI/CD checks are failing',
+          details: actionableFailedChecks.map(c => c.name),
+        });
+      }
     }
   } else if (ciStatus.status === 'unknown') {
     // Unable to determine CI status - treat as pending to be safe

package/src/solve.auto-merge.lib.mjs

@@ -61,7 +61,10 @@ const { buildCancelledCIReviewComment, getRetriggerableWorkflowRuns, shouldStopF
 
 // Issue #1625: Shared marker constants + posting/tracking helpers
 const toolComments = await import('./tool-comments.lib.mjs');
-const { READY_TO_MERGE_MARKER, AUTO_RESTART_MARKER, AUTO_MERGED_MARKER, postTrackedComment } = toolComments;
+const { READY_TO_MERGE_MARKER, READY_FOR_REVIEW_MARKER, AUTO_RESTART_MARKER, AUTO_MERGED_MARKER, postTrackedComment } = toolComments;
+
+const externalReviewLimitLib = await import('./external-review-limit.lib.mjs');
+const { buildReadyForReviewComment } = externalReviewLimitLib;
 
 // Issue #1728: Per-iteration working session summary attachment helper
 // Issue #1763: Per-iteration PR ↔ issue link verification (so a clobbered
@@ -517,7 +520,44 @@ Once the billing issue is resolved, you can re-run the CI checks or push a new c
 
       // Reason 2: CI failures (only if NOT a billing limit issue and NOT just cancelled)
       // Only restart AI when we have genuine code failures (real feedback to act on)
+      const externalReviewLimitBlocker = blockers.find(b => b.type === 'external_review_limit');
       const ciBlocker = blockers.find(b => b.type === 'ci_failure');
+      const hasMergeConflictBlocker = blockers.some(b => b.type === 'not_mergeable' && b.message?.includes('conflicts'));
+      if (externalReviewLimitBlocker && !ciBlocker && !billingBlocker && !cancelledBlocker && !hasNewComments && !hasUncommittedChanges && !hasMergeConflictBlocker) {
+        await log('');
+        await log(formatAligned('🟡', 'READY FOR REVIEW', 'External review quota/credit limit requires human decision'));
+        for (const detail of externalReviewLimitBlocker.details || []) {
+          await log(formatAligned('', 'Check not executed:', detail, 2));
+        }
+        await log(formatAligned('', 'Action:', 'Stopping auto-restart without starting another AI session', 2));
+
+        try {
+          const commentSignature = `## 🟡 ${READY_FOR_REVIEW_MARKER}`;
+          const hasExistingReadyForReviewComment = await checkForExistingComment(owner, repo, prNumber, commentSignature, argv.verbose);
+          if (hasExistingReadyForReviewComment) {
+            await log(formatAligned('', `Skipping duplicate "${READY_FOR_REVIEW_MARKER}" comment (already posted by another process)`, '', 2));
+          } else {
+            const commentBody = buildReadyForReviewComment({
+              blocker: externalReviewLimitBlocker,
+              ciStatus,
+            });
+            await postTrackedComment({ $, owner, repo, targetNumber: prNumber, body: commentBody });
+            await log(formatAligned('', '💬 Posted ready-for-review notification to PR', '', 2));
+          }
+        } catch (commentError) {
+          reportError(commentError, {
+            context: 'post_external_review_limit_comment',
+            owner,
+            repo,
+            prNumber,
+            operation: 'comment_on_pr',
+          });
+          await log(formatAligned('', '⚠️  Could not post ready-for-review comment to PR', '', 2));
+        }
+
+        return { success: false, reason: 'external_review_limit', latestSessionId, latestAnthropicCost };
+      }
+
       if (ciBlocker && !billingBlocker) {
         shouldRestart = true;
         restartReason = restartReason ? `${restartReason}; CI failures` : 'CI failures detected';

package/src/telegram-bot.mjs

@@ -40,7 +40,7 @@ const { applySolveToolAlias, getFirstParsedPositionalArg, getSolveCommandNameFro
 const { executeStartScreen: executeStartScreenCommand, buildExecuteAndUpdateMessage } = await import('./telegram-command-execution.lib.mjs');
 const { isChatStopped, getChatStopInfo, getStoppedChatRejectMessage, DEFAULT_STOP_REASON } = await import('./telegram-start-stop-command.lib.mjs');
 const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized: _isChatAuthorized, isForwardedOrReply: _isForwardedOrReply, extractCommandFromText, extractGitHubUrl: _extractGitHubUrl } = await import('./telegram-message-filters.lib.mjs');
-const { installTelegramFormattingFallback, safeEditMessageText, safeReply } = await import('./telegram-safe-reply.lib.mjs');
+const { installTelegramFormattingFallback, isTelegramFormattingError, isTelegramMessageTooLongError, safeEditMessageText, safeReply, TELEGRAM_TEXT_LIMIT } = await import('./telegram-safe-reply.lib.mjs');
 const { registerTerminalWatchCommand, startAutoTerminalWatchForSession } = await import('./telegram-terminal-watch-command.lib.mjs');
 const { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
 const { trackSession, startSessionMonitoring, hasActiveSessionForUrlAsync } = await import('./session-monitor.lib.mjs');
@@ -1214,15 +1214,17 @@ bot.catch((error, ctx) => {
 
   // Try to notify the user about the error with more details
   if (ctx?.reply) {
-    const isTelegramParsingError = error.message && (error.message.includes("can't parse entities") || error.message.includes("Can't parse entities") || error.message.includes("can't find end of") || (error.message.includes('Bad Request') && error.message.includes('400')));
+    const isTelegramParsingError = isTelegramFormattingError(error);
+    const isTelegramTextLimitError = isTelegramMessageTooLongError(error);
 
     let errorMessage;
 
-    if (isTelegramParsingError) {
+    if (isTelegramParsingError || isTelegramTextLimitError) {
       // Issue #1460: Log detailed context for root cause analysis (always logged, not just in verbose mode)
       const userInfo = ctx.from ? { id: ctx.from.id, username: ctx.from.username, first_name: ctx.from.first_name, last_name: ctx.from.last_name } : 'unknown';
-      console.error(`[telegram-bot] Parsing error: ${error.message}`);
-      console.error(`[telegram-bot] Parsing error context - user: ${JSON.stringify(userInfo)}, command: ${ctx.message?.text?.split(' ')[0] || 'unknown'}`);
+      const errorKind = isTelegramTextLimitError ? 'Message length error' : 'Parsing error';
+      console.error(`[telegram-bot] ${errorKind}: ${error.message}`);
+      console.error(`[telegram-bot] ${errorKind} context - user: ${JSON.stringify(userInfo)}, command: ${ctx.message?.text?.split(' ')[0] || 'unknown'}`);
       console.error(`[telegram-bot] User input text: ${ctx.message?.text || 'none'}`);
       if (ctx.message?.text) {
         const visibleInput = makeSpecialCharsVisible(ctx.message.text, { maxLength: 500 });
@@ -1233,8 +1235,11 @@ bot.catch((error, ctx) => {
         }
       }
 
-      // Issue #1460: Show user a simple, non-confusing message — all details are in the logs
-      errorMessage = `❌ Failed to send formatted message. Please try your command again.\n\nIf the issue persists, contact support with Update ID: ${ctx.update.update_id}`;
+      if (isTelegramTextLimitError) {
+        errorMessage = `❌ Telegram rejected an oversized bot message.\n\nThe bot splits messages above ${TELEGRAM_TEXT_LIMIT} characters automatically. Please try your command again.\n\nIf the issue persists, contact support with Update ID: ${ctx.update.update_id}`;
+      } else {
+        errorMessage = `❌ Telegram rejected a formatted bot message, and the fallback handler could not recover automatically.\n\nPlease try your command again.\n\nIf the issue persists, contact support with Update ID: ${ctx.update.update_id}`;
+      }
     } else {
       errorMessage = '❌ An error occurred while processing your request.\n\n';
       if (error.message) {
@@ -1251,20 +1256,13 @@ bot.catch((error, ctx) => {
       if (VERBOSE) errorMessage += `\n\n🔍 Debug info: Update ID: ${ctx.update.update_id}`;
     }
 
-    // Issue #1460: For parsing errors send plain text; otherwise try Markdown first
-    if (isTelegramParsingError) {
-      ctx.reply(errorMessage).catch(fallbackError => {
-        console.error('Failed to send plain text error message:', fallbackError);
+    safeReply(ctx, errorMessage, { fallbackLocale: resolveLocaleFromTelegramCtx(ctx), verbose: VERBOSE }).catch(replyError => {
+      console.error('Failed to send error message to user:', replyError);
+      const plainMessage = `An error occurred while processing your request. Please try again or contact support.\n\nError: ${error.message || 'Unknown error'}`;
+      ctx.reply(plainMessage).catch(fallbackError => {
+        console.error('Failed to send fallback error message:', fallbackError);
       });
-    } else {
-      ctx.reply(errorMessage, { parse_mode: 'Markdown' }).catch(replyError => {
-        console.error('Failed to send error message to user:', replyError);
-        const plainMessage = `An error occurred while processing your request. Please try again or contact support.\n\nError: ${error.message || 'Unknown error'}`;
-        ctx.reply(plainMessage).catch(fallbackError => {
-          console.error('Failed to send fallback error message:', fallbackError);
-        });
-      });
-    }
+    });
   }
 });
 

package/src/telegram-safe-reply.lib.mjs

@@ -2,6 +2,7 @@ import { normalizeLocale, t } from './i18n.lib.mjs';
 
 const FORMATTING_FALLBACK_INSTALLED = Symbol.for('hiveMind.telegramFormattingFallbackInstalled');
 const DEFAULT_FORMATTING_FALLBACK_WARNING = '⚠️ Formatting error detected. Showing plain text fallback.';
+export const TELEGRAM_TEXT_LIMIT = 4096;
 const FORMATTING_FALLBACK_WARNINGS = {
   en: DEFAULT_FORMATTING_FALLBACK_WARNING,
   ru: '⚠️ Обнаружена ошибка форматирования. Показываю обычный текст.',
@@ -18,9 +19,18 @@ function splitOptions(options = {}) {
   };
 }
 
+function getTelegramErrorMessage(error) {
+  return error?.description || error?.message || String(error || '');
+}
+
 export function isTelegramFormattingError(error) {
-  const message = error?.description || error?.message || String(error || '');
-  return /can't parse entities/i.test(message) || /can't find end of/i.test(message) || /entity.*parse/i.test(message) || (/bad request/i.test(message) && /400|parse|entity/i.test(message));
+  const message = getTelegramErrorMessage(error);
+  return /can't parse entities/i.test(message) || /can't find end of/i.test(message) || /entity.*parse/i.test(message) || /parse.*entity/i.test(message) || /character .* is reserved/i.test(message) || /unsupported start tag/i.test(message);
+}
+
+export function isTelegramMessageTooLongError(error) {
+  const message = getTelegramErrorMessage(error);
+  return /message is too long/i.test(message) || /message text is too long/i.test(message) || /text is too long/i.test(message) || /message_too_long/i.test(message) || (/bad request/i.test(message) && /too long/i.test(message) && /(message|text|caption)/i.test(message));
 }
 
 export function stripTelegramMarkdown(text) {
@@ -36,6 +46,45 @@ export function stripTelegramMarkdown(text) {
     .replace(/`([^`]+)`/g, '$1');
 }
 
+function findTelegramSplitIndex(text, limit) {
+  const minUsefulSplit = Math.floor(limit * 0.45);
+  const separators = ['\n\n', '\n', '. ', '; ', ', ', ' '];
+
+  for (const separator of separators) {
+    const searchEnd = Math.max(0, limit - separator.length);
+    const index = text.lastIndexOf(separator, searchEnd);
+    if (index >= minUsefulSplit) {
+      return index + separator.length;
+    }
+  }
+
+  return limit;
+}
+
+export function splitTelegramMessageText(text, limit = TELEGRAM_TEXT_LIMIT) {
+  const source = String(text ?? '');
+  if (source.length <= limit) return [source];
+
+  const chunks = [];
+  let remaining = source;
+
+  while (remaining.length > limit) {
+    let splitAt = findTelegramSplitIndex(remaining, limit);
+    let chunk = remaining.slice(0, splitAt).trimEnd();
+
+    if (!chunk) {
+      splitAt = limit;
+      chunk = remaining.slice(0, splitAt);
+    }
+
+    chunks.push(chunk);
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+
+  if (remaining) chunks.push(remaining);
+  return chunks;
+}
+
 function getFormattingFallbackWarning(locale) {
   const key = 'telegram.formatting_fallback_warning';
   const normalizedLocale = normalizeLocale(locale);
@@ -50,7 +99,7 @@ export function buildTelegramFormattingFallbackText(text, options = {}) {
 }
 
 function logFormattingFailure(scope, error, text, verbose = false, fallbackText = null) {
-  const message = error?.description || error?.message || String(error || '');
+  const message = getTelegramErrorMessage(error);
   console.error(`[telegram-bot] ${scope}: formatted Telegram message failed: ${message}`);
   if (verbose) {
     const originalBytes = Buffer.byteLength(String(text ?? ''), 'utf-8');
@@ -76,54 +125,241 @@ function logFormattingFailure(scope, error, text, verbose = false, fallbackText
   }
 }
 
+function logMessageTooLongFailure(scope, error, text, verbose = false, fallbackText = null) {
+  const message = getTelegramErrorMessage(error);
+  console.error(`[telegram-bot] ${scope}: Telegram message exceeded ${TELEGRAM_TEXT_LIMIT} character limit: ${message}`);
+  if (verbose) {
+    const original = String(text ?? '');
+    console.error(`[telegram-bot] ${scope}: Oversized message (${original.length} chars, ${Buffer.byteLength(original, 'utf-8')} bytes): ${original}`);
+    if (fallbackText !== null) {
+      const fallback = String(fallbackText ?? '');
+      console.error(`[telegram-bot] ${scope}: Plain text fallback (${fallback.length} chars, ${Buffer.byteLength(fallback, 'utf-8')} bytes): ${fallback}`);
+    }
+  }
+}
+
+function logChunking(scope, text, chunks, verbose = false) {
+  if (chunks.length <= 1) return;
+  const source = String(text ?? '');
+  console.warn(`[telegram-bot] ${scope}: Telegram text is ${source.length} chars (${Buffer.byteLength(source, 'utf-8')} bytes), splitting into ${chunks.length} messages (limit ${TELEGRAM_TEXT_LIMIT}).`);
+  if (verbose) {
+    chunks.forEach((chunk, index) => {
+      console.error(`[telegram-bot] ${scope}: Chunk ${index + 1}/${chunks.length} (${chunk.length} chars, ${Buffer.byteLength(chunk, 'utf-8')} bytes): ${chunk}`);
+    });
+  }
+}
+
+function getPlainTextOptions(telegramOptions) {
+  return { ...telegramOptions, parse_mode: undefined, entities: undefined };
+}
+
+async function sendPlainTextChunks({ text, telegramOptions, scope, verbose, sendChunk }) {
+  const plainOptions = getPlainTextOptions(telegramOptions);
+  const chunks = splitTelegramMessageText(text);
+  logChunking(`${scope}:plainText`, text, chunks, verbose);
+
+  let firstResult;
+  for (const chunk of chunks) {
+    const result = await sendChunk(chunk, plainOptions);
+    if (firstResult === undefined) firstResult = result;
+  }
+  return firstResult;
+}
+
+async function sendTelegramTextChunks({ text, telegramOptions, fallbackLocale, verbose, scope, sendChunk }) {
+  const chunks = splitTelegramMessageText(text);
+  logChunking(scope, text, chunks, verbose);
+
+  let firstResult;
+  for (const chunk of chunks) {
+    try {
+      const result = await sendChunk(chunk, telegramOptions);
+      if (firstResult === undefined) firstResult = result;
+    } catch (error) {
+      let fallbackText;
+      if (isTelegramFormattingError(error)) {
+        fallbackText = buildTelegramFormattingFallbackText(chunk, { fallbackLocale });
+        logFormattingFailure(scope, error, chunk, verbose, fallbackText);
+      } else if (isTelegramMessageTooLongError(error)) {
+        fallbackText = stripTelegramMarkdown(chunk);
+        logMessageTooLongFailure(scope, error, chunk, verbose, fallbackText);
+      } else {
+        throw error;
+      }
+
+      const result = await sendPlainTextChunks({
+        text: fallbackText,
+        telegramOptions,
+        scope,
+        verbose,
+        sendChunk,
+      });
+      if (firstResult === undefined) firstResult = result;
+    }
+  }
+
+  return firstResult;
+}
+
+async function sendRemainingEditChunks({ chunks, telegramOptions, fallbackLocale, verbose, scope, sendFollowUpChunk }) {
+  if (chunks.length === 0) return undefined;
+  if (!sendFollowUpChunk) {
+    console.error(`[telegram-bot] ${scope}: cannot send ${chunks.length} remaining chunk(s) after edit because chat_id is unavailable.`);
+    return undefined;
+  }
+
+  return await sendTelegramTextChunks({
+    text: chunks.join('\n'),
+    telegramOptions,
+    fallbackLocale,
+    verbose,
+    scope: `${scope}:followUp`,
+    sendChunk: sendFollowUpChunk,
+  });
+}
+
+async function sendPlainRemainingEditChunks({ chunks, telegramOptions, verbose, scope, sendFollowUpChunk }) {
+  if (chunks.length === 0) return undefined;
+  if (!sendFollowUpChunk) {
+    console.error(`[telegram-bot] ${scope}: cannot send ${chunks.length} plain-text fallback chunk(s) after edit because chat_id is unavailable.`);
+    return undefined;
+  }
+
+  return await sendPlainTextChunks({
+    text: chunks.join('\n'),
+    telegramOptions,
+    scope: `${scope}:followUp`,
+    verbose,
+    sendChunk: sendFollowUpChunk,
+  });
+}
+
+async function editTelegramTextChunks({ text, telegramOptions, fallbackLocale, verbose, scope, editChunk, sendFollowUpChunk }) {
+  const chunks = splitTelegramMessageText(text);
+  logChunking(scope, text, chunks, verbose);
+
+  const [firstChunk, ...remainingChunks] = chunks;
+  try {
+    const result = await editChunk(firstChunk, telegramOptions);
+    await sendRemainingEditChunks({
+      chunks: remainingChunks,
+      telegramOptions,
+      fallbackLocale,
+      verbose,
+      scope,
+      sendFollowUpChunk,
+    });
+    return result;
+  } catch (error) {
+    let fallbackText;
+    if (isTelegramFormattingError(error)) {
+      fallbackText = buildTelegramFormattingFallbackText(firstChunk, { fallbackLocale });
+      logFormattingFailure(scope, error, firstChunk, verbose, fallbackText);
+    } else if (isTelegramMessageTooLongError(error)) {
+      fallbackText = stripTelegramMarkdown(firstChunk);
+      logMessageTooLongFailure(scope, error, firstChunk, verbose, fallbackText);
+    } else {
+      throw error;
+    }
+
+    const plainOptions = getPlainTextOptions(telegramOptions);
+    const fallbackChunks = splitTelegramMessageText(fallbackText);
+    logChunking(`${scope}:plainText`, fallbackText, fallbackChunks, verbose);
+    const [firstFallbackChunk, ...remainingFallbackChunks] = fallbackChunks;
+    const result = await editChunk(firstFallbackChunk, plainOptions);
+    await sendPlainRemainingEditChunks({
+      chunks: [...remainingFallbackChunks, ...remainingChunks.map(stripTelegramMarkdown)],
+      telegramOptions,
+      verbose,
+      scope,
+      sendFollowUpChunk,
+    });
+    return result;
+  }
+}
+
 // Issue #1460/#1497/#1788: try Markdown first, fall back to localized plain text on parsing errors.
 export async function safeReply(ctx, text, options = {}) {
   const { telegramOptions, fallbackLocale, verbose } = splitOptions(options);
   const firstOptions = { parse_mode: 'Markdown', ...telegramOptions };
-  try {
-    return await ctx.reply(text, firstOptions);
-  } catch (error) {
-    if (!isTelegramFormattingError(error)) throw error;
-    const fallbackText = buildTelegramFormattingFallbackText(text, { fallbackLocale });
-    logFormattingFailure('safeReply', error, text, verbose, fallbackText);
-    return await ctx.reply(fallbackText, { ...telegramOptions, parse_mode: undefined });
-  }
+  return await sendTelegramTextChunks({
+    text,
+    telegramOptions: firstOptions,
+    fallbackLocale,
+    verbose,
+    scope: 'safeReply',
+    sendChunk: (chunk, chunkOptions) => ctx.reply(chunk, chunkOptions),
+  });
 }
 
 export async function safeEditMessageText(telegram, chatId, messageId, inlineMessageId, text, options = {}) {
   const { telegramOptions, fallbackLocale, verbose } = splitOptions(options);
   const firstOptions = { parse_mode: 'Markdown', ...telegramOptions };
-  try {
-    return await telegram.editMessageText(chatId, messageId, inlineMessageId, text, firstOptions);
-  } catch (error) {
-    if (!isTelegramFormattingError(error)) throw error;
-    const fallbackText = buildTelegramFormattingFallbackText(text, { fallbackLocale });
-    logFormattingFailure('safeEditMessageText', error, text, verbose, fallbackText);
-    return await telegram.editMessageText(chatId, messageId, inlineMessageId, fallbackText, { ...telegramOptions, parse_mode: undefined });
-  }
+  return await editTelegramTextChunks({
+    text,
+    telegramOptions: firstOptions,
+    fallbackLocale,
+    verbose,
+    scope: 'safeEditMessageText',
+    editChunk: (chunk, chunkOptions) => telegram.editMessageText(chatId, messageId, inlineMessageId, chunk, chunkOptions),
+    sendFollowUpChunk: chatId !== undefined && chatId !== null && typeof telegram.sendMessage === 'function' ? (chunk, chunkOptions) => telegram.sendMessage(chatId, chunk, chunkOptions) : null,
+  });
 }
 
-function wrapTelegramMethod(telegram, methodName, textIndex, optionsIndex, defaults = {}) {
-  const original = telegram?.[methodName];
+function wrapTelegramSendMessage(telegram, defaults = {}) {
+  const original = telegram?.sendMessage;
   if (typeof original !== 'function') return;
 
-  telegram[methodName] = async function wrappedTelegramMessageMethod(...args) {
-    const text = args[textIndex];
-    const originalOptions = args[optionsIndex] || {};
+  telegram.sendMessage = async function wrappedTelegramSendMessage(...args) {
+    const text = args[1];
+    const originalOptions = args[2] || {};
     const { telegramOptions, fallbackLocale, verbose } = splitOptions(originalOptions);
-    args[optionsIndex] = telegramOptions;
+    args[2] = telegramOptions;
 
-    try {
-      return await original.apply(this, args);
-    } catch (error) {
-      if (!isTelegramFormattingError(error) || typeof text !== 'string') throw error;
-      const fallbackText = buildTelegramFormattingFallbackText(text, { fallbackLocale: fallbackLocale || defaults.fallbackLocale });
-      logFormattingFailure(methodName, error, text, verbose || defaults.verbose, fallbackText);
-      const retryArgs = [...args];
-      retryArgs[textIndex] = fallbackText;
-      retryArgs[optionsIndex] = { ...telegramOptions, parse_mode: undefined };
-      return await original.apply(this, retryArgs);
-    }
+    if (typeof text !== 'string') return await original.apply(this, args);
+
+    return await sendTelegramTextChunks({
+      text,
+      telegramOptions,
+      fallbackLocale: fallbackLocale || defaults.fallbackLocale,
+      verbose: verbose || defaults.verbose,
+      scope: 'sendMessage',
+      sendChunk: (chunk, chunkOptions) => {
+        const chunkArgs = [...args];
+        chunkArgs[1] = chunk;
+        chunkArgs[2] = chunkOptions;
+        return original.apply(this, chunkArgs);
+      },
+    });
+  };
+}
+
+function wrapTelegramEditMessageText(telegram, defaults = {}) {
+  const original = telegram?.editMessageText;
+  if (typeof original !== 'function') return;
+
+  telegram.editMessageText = async function wrappedTelegramEditMessageText(...args) {
+    const text = args[3];
+    const originalOptions = args[4] || {};
+    const { telegramOptions, fallbackLocale, verbose } = splitOptions(originalOptions);
+    args[4] = telegramOptions;
+
+    if (typeof text !== 'string') return await original.apply(this, args);
+
+    return await editTelegramTextChunks({
+      text,
+      telegramOptions,
+      fallbackLocale: fallbackLocale || defaults.fallbackLocale,
+      verbose: verbose || defaults.verbose,
+      scope: 'editMessageText',
+      editChunk: (chunk, chunkOptions) => {
+        const chunkArgs = [...args];
+        chunkArgs[3] = chunk;
+        chunkArgs[4] = chunkOptions;
+        return original.apply(this, chunkArgs);
+      },
+      sendFollowUpChunk: args[0] !== undefined && args[0] !== null && typeof this.sendMessage === 'function' ? (chunk, chunkOptions) => this.sendMessage(args[0], chunk, chunkOptions) : null,
+    });
   };
 }
 
@@ -135,8 +371,8 @@ export function installTelegramFormattingFallback(telegram, options = {}) {
     verbose: Boolean(options.verbose),
   };
 
-  wrapTelegramMethod(telegram, 'sendMessage', 1, 2, defaults);
-  wrapTelegramMethod(telegram, 'editMessageText', 3, 4, defaults);
+  wrapTelegramSendMessage(telegram, defaults);
+  wrapTelegramEditMessageText(telegram, defaults);
   telegram[FORMATTING_FALLBACK_INSTALLED] = true;
   return telegram;
 }

package/src/tool-comments.lib.mjs

@@ -49,6 +49,9 @@ export const AUTO_RESTART_UNTIL_MERGEABLE_LOG_MARKER = 'Auto-restart-until-merge
 // solve.auto-merge.lib.mjs — "ready to merge" status comments
 export const READY_TO_MERGE_MARKER = 'Ready to merge';
 
+// solve.auto-merge.lib.mjs — external review quota/credit stop comments
+export const READY_FOR_REVIEW_MARKER = 'Ready for review';
+
 // solve.auto-merge.lib.mjs — "auto-merged successfully" status comments
 export const AUTO_MERGED_MARKER = 'Auto-merged';
 
@@ -107,7 +110,7 @@ export const USAGE_LIMIT_REACHED_MARKER = 'Usage Limit Reached';
  * named constants above so that adding a new marker only requires adding
  * the constant and appending it here.
  */
-export const TOOL_GENERATED_COMMENT_MARKERS = [AI_WORK_SESSION_STARTED_MARKER, AI_WORK_SESSION_COMPLETED_MARKER, AI_WORK_SESSION_RESUMED_MARKER, AUTO_RESUME_ON_LIMIT_RESET_MARKER, AUTO_RESTART_ON_LIMIT_RESET_MARKER, SOLUTION_DRAFT_LOG_MARKER, AUTO_RESTART_MARKER, AUTO_RESTART_UNTIL_MERGEABLE_LOG_MARKER, READY_TO_MERGE_MARKER, AUTO_MERGED_MARKER, BILLING_LIMIT_MARKER, CANCELLED_CI_REVIEW_MARKER, MAINTAINER_ACCESS_REQUEST_MARKER, LIVE_PROGRESS_SECTION_START_MARKER, SESSION_FORCE_KILLED_MARKER, REPOSITORY_INITIALIZATION_REQUIRED_MARKER, INTERACTIVE_SESSION_STARTED_MARKER, INTERACTIVE_SESSION_ENDED_MARKER, NOW_WORKING_SESSION_IS_ENDED_MARKER, SOLUTION_DRAFT_FAILED_MARKER, SOLUTION_DRAFT_FINISHED_WITH_ERRORS_MARKER, USAGE_LIMIT_REACHED_MARKER, WORKING_SESSION_SUMMARY_AUTOMATION_MARKER];
+export const TOOL_GENERATED_COMMENT_MARKERS = [AI_WORK_SESSION_STARTED_MARKER, AI_WORK_SESSION_COMPLETED_MARKER, AI_WORK_SESSION_RESUMED_MARKER, AUTO_RESUME_ON_LIMIT_RESET_MARKER, AUTO_RESTART_ON_LIMIT_RESET_MARKER, SOLUTION_DRAFT_LOG_MARKER, AUTO_RESTART_MARKER, AUTO_RESTART_UNTIL_MERGEABLE_LOG_MARKER, READY_TO_MERGE_MARKER, READY_FOR_REVIEW_MARKER, AUTO_MERGED_MARKER, BILLING_LIMIT_MARKER, CANCELLED_CI_REVIEW_MARKER, MAINTAINER_ACCESS_REQUEST_MARKER, LIVE_PROGRESS_SECTION_START_MARKER, SESSION_FORCE_KILLED_MARKER, REPOSITORY_INITIALIZATION_REQUIRED_MARKER, INTERACTIVE_SESSION_STARTED_MARKER, INTERACTIVE_SESSION_ENDED_MARKER, NOW_WORKING_SESSION_IS_ENDED_MARKER, SOLUTION_DRAFT_FAILED_MARKER, SOLUTION_DRAFT_FINISHED_WITH_ERRORS_MARKER, USAGE_LIMIT_REACHED_MARKER, WORKING_SESSION_SUMMARY_AUTOMATION_MARKER];
 
 /**
  * Markers that indicate the end of a working session. Used by