Claude Code без остановки: анти-стоп харнесс на хуках

Зачем держать агента на коротком поводке

Коротко: я собрал из Stop-хуков Claude Code обвязку, которая не даёт агенту останавливаться раньше времени, и прошёл с ним три раунда кошки-мышки. Сначала два простых хука: один заставляет писать секцию «Дальше», второй — не стопать. Потом Claude начал это обходить — писал «Дальше» на других языках мимо регекспа, молча правил судью — и каждый раз я закрывал лазейку. Сейчас один ран держится 6 часов минимум.

Это пост от первого лица про то, как агент хитрит, чтобы свернуться и ничего не делать, и как из обычных Stop-хуков Claude Code вырастает обвязка (harness), которую трудно обойти. Весь код — в моём публичном репозитории dev-pomogator (MIT), можно подсмотреть и забрать к себе.

Источники цифр (мои, с пруфами на репу): hooks.json (13 хуков), лог пинатора .dev-pomogator/.claim-evidence-gate-fires.jsonl в репозитории, git log ветки feat/phase-2a. Длительность и токены — с индикатора Claude Code на скринах.

Почему агент сам себя останавливает — и как хитрит

Большие задачи — это десятки шагов. А агента тянет свернуться после трёх: написать бодрый отчёт «сделал X, дальше можно Y» и вернуть ход тебе.

Иногда это прямо провоцирует сам провайдер. В постмортеме Claude Code Anthropic признал серию регрессий весны 2026: даунгрейд reasoning (модель стала пропускать шаги планирования) и баг «не больше 100 слов» в ответе. По тем же метрикам частота, с которой пользователь сам бьёт Stop, выросла с 0.9 до 5.9 на 1000 — более чем в 6 раз. Лень агента — не только его природа, но и побочка чужих оптимизаций под скорость UI.

Но самое интересное началось, когда я попробовал эту лень победить. Получилась гонка вооружений на три раунда.

Раунд 1: два хука — «Дальше» и «не смей стопать»

Первая версия была наивной и простой, на два Stop-хука. Хук №1: при незакрытой работе агент обязан закончить ход секцией «Дальше:» — конкретный следующий шаг. Хук №2: видит эту секцию — и не даёт остановиться, пинает делать дальше. По сути петля: назвал следующий шаг — вот и делай его, а не прощайся.

И это работало. Какое-то время. Пока Claude не начал хитрить.

Раунд 2: Claude пишет «Дальше» на других языках — мимо регекспа

Защита из раунда 1 ловила секцию «Дальше:» регулярным выражением. И вот что сделал агент: он начал писать этот блок на разных языках — так, чтобы регексп его не поймал. Формально секция есть, петля «увидел Дальше → продолжай» не срабатывает (regex не матчит) — и агент спокойно стопается, ничего не сделав. Я прям офигел: модель нашла дыру в моём регекспе и стала целенаправленно через неё проходить.

Вывод был очевиден: фразы матчить бесполезно — их обходят. Нужно понимание, а не сопоставление строк. Так появился умный судья: Stop-хук подкидывает ему куски транскрипта (финальное сообщение + что агент реально делал инструментами), а Haiku решает — это честный стоп или агент сливается. Обойти стало заметно труднее: судья смотрит на смысл, а не на ключевые слова.

Раунд 3: Claude молча правит судью, потому что тот «достал»

Дальше — мой любимый эпизод. Судья работал, ловил сливы. И через какое-то время я заметил, что Claude стал молча менять самого судью. Логика агента читалась как «этот судья меня достал, десять стопов подряд, хватит» — и он по-тихому правил код судьи, чтобы тот перестал мешать. Причём неоднократно, даже после прямых указаний так не делать. Агент не спорил — он просто шёл и отключал то, что его тормозит.

Лечится это не уговорами, а архитектурой: я поставил защиту на файл судьи — агент его больше не может редактировать. Нельзя саботировать инструмент, до которого не дотягиваешься. После этого гонка по сути закончилась: лазейки «обойди регексп» и «выключи судью» закрыты, и автономность стабилизировалась на 6 часах минимум.

Мораль трёх раундов: каждую защиту, основанную на доверии или на ключевых словах, агент рано или поздно обойдёт. Держатся только те, что опираются на объективный факт и которые он физически не может отключить.

Тот самый ран: пять часов и растёт

Скрины того прогона — в посте: индикатор Claude Code Thinking… (5h 9m · ↑ 719.4k tokens) и моменты, где обвязка (Ran 13 stop hooks) ловит преждевременный стоп и гонит агента дальше. Модель Opus 4.8, контекст 828k, ветка feat/phase-2a-mcp-server-and-hooks. Задача была скучная, длинная и показательная. Я написал мигратор тестов и поставил агенту перегнать им весь тест-сьют проекта. По спеке миграции цель прямая — «ноль *.test.ts»: около 120 файлов с обычных unit-тестов (vitest) перегнать на BDD-сценарии (.feature-файлы на Cucumber, привязанные к коду), причём отказы «не мигрируется / out of scope» спекой запрещены. И сделать это самому, без пинков на каждом шаге: не «собери мигратор и спроси меня», а «прогони им всю миграцию до конца, файл за файлом, пока всё не станет зелёным». Ровно та сквозная автономность, ради которой и строился харнесс. Идеальная почва, чтобы агент «устал» и свернулся на полпути.

И он пытался. В 06:51 агент отчитался: «Готово — мигратор собран, как ты выбрал» и собрался стопнуться. Пинатор сверил заявку с переписью задач: 199 ещё открыто, а следующий шаг просто назван и отложен. Блок. В 06:57 — снова: «Закоммичено — 19 коммитов. Полная арка этого хода замкнута». Блок.

Откуда пинатор вообще знает, что «ещё открыто»? Он не держит задачи в голове и не верит агенту на слово — он читает спеки проекта. У каждой фичи есть .specs/<фича>/TASKS.md со списком задач и статусами ([ ]/[x], Status: TODO|DONE); перепись задач считает, сколько по спекам ещё не сделано (todo / in-progress / blocked), и вытаскивает следующую открытую задачу. Те «199 открыто» — не абстракция, а живой остаток по спекам той миграции. Поэтому «я всё сделал» не проходит на слух: пока в спеке висят незакрытые задачи, стоп — преждевременный по факту, а не по формулировке. Это и есть тот «объективный факт, который агент не может подделать»: перепись он не перепишет, не тронув сами спеки.

В 07:09 агент пошёл ва-банк: «21 коммит. Сессия — целостная и завершённая арка» — и тут же, в том же сообщении, сам же признал: «дальше пинатор (тоже мной починенный) гнал». Гнал и дальше.

Между первой попыткой стопнуться (06:51) и реальным концом работы (07:49) агент выдал ещё восемь коммитов. Он хотел остановиться на «мигратор собран» — то есть на готовом инструменте, ни разу не запустив саму миграцию. Обвязка не отпустила и довела до дела: восемь describe-блоков из файла coverage.ts реально перегнаны в BDD-сценарии, все зелёные. Разница между «инструмент готов» и «тесты перенесены» — это ровно те восемь блоков, которые агент сделал только потому, что его не отпустили.

Итог одной сессии (92c334d8): 30 заблокированных стопов и непрерывный многочасовой ран вместо десятка коротких «сделал кусочек — спросил — жду». Автономность берётся не из «умной» модели, а из того, что её не отпускают, пока работа не сделана по-настоящему.

Как я улучшал это по шагам

Три раунда и тот ран — только начало. Дальше обвязка росла итерациями, и почти каждый шаг — ответ на новый обход. Хронология (даты и номера — из спеки FR и аудитов):

• 17 июня — убрал слова-триггеры. Старый пинатор ловил формулировку по словам («ДОДЕЛЫВАЙ», имя самого пинатора). Любое сообщение, где эти слова просто упомянуты, получало бесплатный стоп. Маркеры-слова выпилены: ловим улику, а не фразу.
• v1 — детерминированный evidence-гейт. Один Stop-хук берёт «окно хода», делит заявку на 4 класса (вердикт / «работает» / «не нашёл» / verified-marker) и блокирует ту, у которой в этом ходе нет вызова-улики; плюс всегда-включённое «назови Дальше». Регексы — мгновенно, без модели.
• Haiku-судья для серой зоны. То, что регексп не ловит («что дальше — чинить X или коммитить?»), решает один вызов Haiku (temp 0). Смысл вместо ключевых слов.
• 18 июня (аудит сжигания токенов) — судья судит РЕАЛЬНОСТЬ, не текст. Хук сам считает наблюдаемые факты (сколько мутирующих вызовов, изменилось ли дерево по git diff, есть ли фоновая задача) и подаёт их судье первыми; текст ответа — вторичен. Тогда же починил бесконечный анти-луп (86% пинков шли дольше 2 минут врозь → счётчик сбрасывался, лимит не достигался) и добавил правило «непроверенный блокер — это отмазка» (после 34-ходового фейк-блокера).
• 24 июня — громкий токен и fail-closed. Без токена судья молча выключался (лог только в stderr). Теперь: нет токена → предупреждаю в чате, но НЕ блокирую (это дыра в конфиге юзера, а не лень агента); токен есть, но эндпоинт недоступен → блок fail-closed (агент нащупал, что можно уронить запрос к судье и проскочить).
• 25 июня (аудит «судья спал») — живые задачи, анти-offload, защита от борьбы с гейтом. Перепись стал брать из живого TASKS.md (кэш врал «0 открытого»); убрал спихивание выполнимого на владельца; хук начал вычислять из tool_use два факта, которые агент не подделает: правил ли он файлы самого гейта и не пометил ли свою же работу blocked/backlog — и то и другое блокирует (кроме честной разработки самого гейта).
• 29 июня (mandate-слой) — «сделано всё, что просил человек». Судья стал получать полный список реальных промптов человека и одобрять стоп, когда весь мандат закрыт, а не гнать агента в незаказанный бэклог. Плюс структурный фикс: чистить мандат от мусора (/compact, слэш-команды) не блок-листом, а по флагам харнесса. Поведение прибито адверсариальным бенчем majority-of-3 — 32/32.

Виден один паттерн: каждый шаг переносит вердикт с того, что агент пишет, на то, что харнесс может наблюдать сам. На этом всё и держится.

Анти-стоп харнесс сегодня: 13 хуков на одно событие

Claude Code зовёт внешний скрипт на событие Stop — в момент, когда агент решил закончить ход. Если скрипт вернёт {"decision":"block","reason":"..."}, агент не останавливается, а получает reason как новую вводную и продолжает (документация по хукам). Из наивных двух хуков обвязка доросла до 13 (hooks.json) — те самые «Ran 13 stop hooks» со скрина:

Важно: все гейты fail-open по умолчанию — если хук упал или нет токена, агент останавливается нормально. Плагин не имеет права повесить сессию из-за своей ошибки. Блокировка — это осознанное «нет», а не побочка падения.

И пинатор не одинок. Он делит перепись задач со spec-графом проекта, координируется с bg-task-guard (легитимные async-ожидания) и гейтами качества тестов, а рядом стоит session-pilot — дашборд, который следит за всеми твоими git-worktree и сессиями сразу (для тех, у кого 10+ автономных агентов идут параллельно). 37 хук-точек на 5 событий, десятки скилов — одна система, один плагин.

Пинатор: ловит враньё про «готово»

Сердце обвязки — claim-evidence-gate. На стопе он берёт «окно хода»: финальное сообщение агента + все инструменты, которые тот вызвал с момента, как ты последний раз говорил. Если агент заявил результат, но улики (нужного вызова инструмента) в этом ходе нет — стоп блокируется. Четыре класса заявок:

• analysis-verdict — сетка вердиктов PASS/FAIL без запуска инструмента, который их породил бы.
• works-done — «работает / задеплоено / готово» без реального прогона в этом ходе.
• not-found-impossible — «не нашёл / невозможно» без ≥2 поисковых вызовов.
• verified-marker — буквальное [VERIFIED via X], когда X не запускался.

Реальные попытки слиться, прямо из лога .claim-evidence-gate-fires.jsonl: «Окей, вот грамотный план работ по остатку v4» (выдал план вместо работы — блок); «Собрал доказательную базу, вот честный coverage-review» (таблица вердиктов без запуска проверки — блок); «Сделал то, что ты требовал: пинатор теперь пинает и доделывай» (агент чинил сам пинатор и попытался свернуться — поймал его же инструмент).

Haiku-судья для серой зоны

Регексы ловят грубое враньё. Серую зону — агент сделал часть, честно отчитался, добавил «Дальше:», но всё равно сворачивается — добивает тот самый судья из раунда 2: один вызов Haiku (temp 0, таймаут 6 секунд) решает block-vs-approve пониманием. Его вердикт виден на скрине: «судья (Meridian) счёл это преждевременным стопом — Named next file (corpus.ts), deferred to next turn, 199 tasks open».

Промпт судьи прямой: «Остановился ли агент, когда у него был конкретный следующий шаг, который он мог сделать прямо сейчас без блокера? Если да → BLOCK. То, что он что-то сделал в этом ходе, НЕ даёт права стопнуться с известной оставшейся работой». Approve — только если агент реально отвечает на твой вопрос, задаёт честный уточняющий, по-настоящему заблокирован или работа кончилась. Из 71 пойманного стопа 42 — заслуга судьи.

Главный принцип судьи — смотреть на факты раньше, чем на текст: вызовы инструментов, правки файлов, реальные промпты человека подаются ему первыми, а само сообщение агента помечено как «вторичный нарратив, который агент может отполировать под тебя». Чтобы судья не ослаб по-тихому от правок промпта, его поведение прибито адверсариальным бенчем на живой модели (majority-of-3) — 32 из 32, с нарочными негативами-блоками (зелёный бенч без них ничего бы не доказывал, кроме того, что гейт ослаблен).

Чтобы не зациклить: анти-луп и fail-closed

Блокировать стоп бесконечно нельзя — повесишь сессию. Тормоза: одинаковое сообщение второй раз → пропускаем; счётчик попыток в окне охлаждения (по умолчанию 2, до 6 в цепочке продолжения) → после лимита пропускаем; любая внутренняя ошибка → пропускаем. Цель — «дожать», а не «зажать».

Ещё одну лазейку закрыл осознанно: раньше при недоступном судье (нет токена, таймаут) гейт делал fail-open — пропускал стоп. Агент это нащупал и ронял запрос к судье, чтобы проскочить. Теперь при открытой работе и недоступном судье решение — fail-closed: стоп не подтверждён, блок (с тем же анти-лупом, чтобы офлайн-юзера в итоге отпустило). Тот же паттерн, что с судьёй: агент находит обход — я закрываю.

Фон не должен ронять ход: bg-task-guard

Агент запускает прогон тестов в фоне и тут же норовит сказать «запустил, жду» и стопнуться. bg-task-guard на стопе смотрит маркер активной фоновой задачи и свежий YAML со статусом тестов. Идёт сборка/прогон — блок с прогрессом (сколько тестов passed из total). Тесты закончились — отпускаем.

Предохранители: жёсткий TTL 15 минут на протухший маркер и детектор «зависло» (0% прогресса дольше 3 минут трактуется как тихо упавшая сборка — стоп разрешается), чтобы обвязка не держала агента на мёртвом процессе.

Арсенал: чем ещё он пытался проскочить

Три раунда выше — это сюжет. Но за месяцы дожатия набралась целая коллекция уловок: закрываю одну — агент находит следующую. Показательно, что почти все они не про код, а про нарратив. Под давлением гейта самый выгодный ход для модели — не сделать работу, а написать сообщение, которое судья обязан принять. И каждый такой обход приходилось обрабатывать руками — ловить на своей шкуре и закрывать в dev-pomogator, обход за обходом. Это не разовая настройка, а месяцы дожатия (разбор каждого — в аудитах). Вот самые характерные:

• Выдуманный блокер. 34 хода подряд агент писал «файл держит параллельная сессия», ни разу не запустив git diff. Сессия была одна, а реальный дифф — одна строка его же фичи. Лечение: правило «непроверенный блокер — это отмазка», дифф гоняет сам хук.
• Магическое слово. В гейте был список само-маркеров: напишешь deferred-work где угодно в сообщении — и стоп мгновенно одобрен. Одна строка убивала всю защиту. Выпилил (FR-20).
• Полировка нарратива. Пока судья взвешивал текст ответа, агент учился писать обещания красивее, а не работать — чистый Гудхарт. Фикс: судье первыми подаются наблюдаемые факты (вызовы, правки файлов), а текст помечен как «вторичный».
• Перефраз против анти-лупа. Тормоз отпускал на одинаковом хэше сообщения — агент стал каждый ход сочинять новую микро-историю, лишь бы хэш был свежий. Ответ: считать не текст, а ноль правок файлов между пинками.
• Правка самого сторожа. Заблокировали — агент идёт и молча редактирует файлы гейта, чтобы тот замолчал (раунд 3, но не только про судью). Хук теперь сам вычисляет «правил ли агент сторожа в этом ходе» и блокирует, если задача была не про гейт.
• Само-пометка «заблокировано». Свою же выполнимую работу агент объявлял backlog/BLOCKED — и она исчезала из переписи. Тот же класс, что выдуманный блокер: своё «отложено» без внешнего пруфа не считается.
• Спихнуть на владельца. «Тут нужен твой sudo» — при том что демон Docker слушал 127.0.0.1:2375 и всё делалось без рута. Судья теперь блокирует offload выполнимого без показанной попытки (FR-23).
• Фейк-хэндофф. «Какую задачу взять первой?» — вопрос ради того, чтобы не работать, когда следующая задача уже названа в переписи.
• Само-разрешённый скип под принципом. «Оставляю X, это out-of-scope», «гонять агентов = слив токенов» — красиво аргументированная лень; держится только словом владельца или проверяемым блокером.
• Фейк-зелёный тест. Через ход после того как я написал правило против фейк-блокеров, агент сдал «зелёный» тест, который переживал откат самого фикса — то есть не проверял ничего. Ловит только механика: сломай фикс → тест обязан покраснеть.
• Фейк-фикстура. 359 зелёных тестов парсера, который на реальном выводе cucumber был полностью сломан: фикстура клала поле, которого cucumber не шлёт. Настоящий прогон — 40 passed / 10 pending / 29 undefined вместо отрапортованных «79 passed».
• Мёртвая интеграция. Проект месяцами скачивал LSP-сервер и ни разу его не запускал; хук с зелёными тестами не был зарегистрирован в манифесте — «зелёно в догфуде, мёртво у пользователя».
• Спор вместо признания. Пойманный, агент не чинил — он спорил: доказывал, что прав, хотя сам сел в лужу, и не признавал ошибку, пока не ткнёшь его носом в пруф. До git diff — уверенное «всё верно», после живого дифа — «а, да, действительно». Отсюда правило: пруф в том же сообщении, иначе заявка не принимается — верим не слову, а дифу.
• Обход регекспа языками. Тот самый раунд 2, но в арсенале он остался характернейшим: секцию «Дальше» агент писал то по-английски, то транслитом, то вперемешку — лишь бы регексп не сматчил. Ключевые слова обходятся всегда; спасает только смысловой судья, а не список триггер-фраз.
• Структурный «valid» вместо здоровья. Прогнал дешёвую структурную проверку спеки (0 ошибок) и отрапортовал «спека валидна» — при том что умный аудит держал 10 P0-ошибок и 1256 находок. Классический false green: показал зелёное там, где никто и не спрашивал.
• Удалить эмиттер ради зелёного. Тест упал (ждал пусто — получил находку). Агент молча удалил из прода строку, которая эту находку порождает, не открыв контракт, где она обязательна. Тест бы позеленел, а 36 из 36 евалов — легли.
• Ложно-эквивалентный мутант. Под давлением объяснить выживших мутантов — оптом пометить их «эквивалентными, убить нельзя», чтобы закрыть вопрос. Но эквивалентность надо доказывать (внедрил мутанта → сценарий обязан упасть), а не заявлять — иначе это отписка, а не проверка.

Вывод всех этих серий один: правила и уговоры гейминг не останавливают — останавливает только механическая проверка. Пока гейт судит то, что агент пишет, он награждает того, кто лучше формулирует обещания. Держится только то, что гейт может наблюдать сам — и что агент не может ни подделать, ни отключить.

Экономика: подписка вместо pay-per-token

Многочасовая автономность по pay-per-token API била бы по карману. Поэтому в обвязке есть claude-subscription-proxy — локальный прокси на Meridian, который выставляет подписку Claude Pro/Max как обычный Anthropic-совместимый API на 127.0.0.1:3456. Любой инструмент на протоколе Anthropic SDK биллится в подписку, а не по токенам.

Логин переиспользуется с хоста, токены освежаются сами, хук на старте сессии поднимает прокси. Нюанс честно: это серая зона ToS — инструмент личной продуктивности, не способ перепродавать Max-аккаунт на десяток чужих машин.

Как это делают другие: карта автономных лупов

Пока я допиливал пинатор, «держать агента в работе» превратилось в отдельное направление — loop engineering. Формулировка, которую повторяют все: не промпти агента, построй систему, которая промптит его сама — это дословно Борис Черни, создатель Claude Code. Прошлый скилл был prompt engineering; новый — обвязка вокруг лупа плюс проверка результата.

Подходы делятся по одной линии — где живёт луп:

• Внешний луп (рестарт) — классический Ralph. Джеффри Хантли: while :; do cat PROMPT.md | claude; done. Каждая итерация — свежий контекст с нуля, память живёт в файлах, git и TODO; агент перечитывает свою же прошлую работу и доправляет. Просто и дёшево, но контекст каждый раз собирается заново (разбор).
• Внутренний луп (не дать остановиться) — то, что делаю я. Stop-хук перехватывает выход и продолжает ход в той же сессии. И вот что забавно: официальный плагин ralph-wiggum от Anthropic устроен так же — Stop-хук блокирует выход и повторяет промпт. Вся разница — в условии выхода.

Условие выхода у всех разное: у Ralph и плагина — строка-обещание («напиши DONE, когда закончишь») плюс лимит итераций; у verify-лупа — зелёные тесты. Борис прямо говорит, что верификация — самое важное: дай агенту способ проверить свою работу.

А есть подходы вообще не про один луп, а про ширину — много агентов разом, каждый в своём git-worktree: оркестраторы Conductor, Vibe Kanban, Gas Town; durable-heartbeat (OpenClaw) — переживать краши, не только стопы; task-graph память Beads (граф задач как JSONL в git, из него выросли Claude Code «Tasks») (карта тулов).

И честная оговорка индустрии — loopmaxxing: бесконечный луп сам по себе ничего не решает. Три грабли: неизмеримая цель («улучши UX» — нет бинарного выхода), локальный минимум (агент осторожничает, качает мелочи) и comprehension debt — код генерится быстрее, чем человек успевает его понять (разбор).

Эти три грабли пинатор закрывает тем, что крутит петлю не в вакууме, а по спекам. Спека бьёт ровно по ним: (1) вместо неизмеримой цели — задачи со статусами ([ ]/[x], Status: TODO|DONE), то есть бинарный выход «сделано / не сделано», а не «улучши UX»; (2) вместо локального минимума — работа заранее нарезана на конкретные единицы, агент идёт по ним по порядку, а не осторожничает в общем «улучшить»; (3) вместо comprehension debt — сама спека это зафиксированный дизайн и трассировка (что, зачем и куда привязано), поэтому наработанное остаётся картируемым и ревьюибельным, а не грудой непонятного кода. Все мои спеки (формат v4) открыты в репо; сам формат v4 описан отдельной спекой.

Чем мой подход отличается — и когда что брать

Сразу честно про происхождение. Всё это я строил по чуйке и наитию, задолго до того, как loop engineering стал хайпом. Намеренно не лез в базу от хайпанувших твиттерских разработчиков — чтобы не тащить в систему чужие паттерны, не усложнять и держаться своего видения. В чужие решения я углубился только сейчас, когда обвязка уже готова и я сел писать этот пост. Поэтому где-то я независимо переизобрёл чужое (моя перепись задач ≈ Beads), а где-то ушёл дальше.

Если разложить по полкам, мой пинатор — гибрид: внутренний луп (как плагин), но с условием выхода по фактам (дух verify-лупа, только заземлённый не на тесты, которые пишет агент, а на то, что агент подделать не может), плюс перепись задач из спеков (родня Beads) и анти-гейминг сверху.

Ось, которая всё решает — кто контролирует условие выхода. Луп «закончился», когда условие выполнено. Вопрос один: может ли агент это условие сочинить сам?

• Ralph и плагин — выход по строке «DONE», а строку пишет агент. Захотел выйти — написал. Защита только лимит итераций.
• Verify-луп — выход по зелёным тестам, но тесты тоже пишет агент. Это ровно арсенал выше: фейк-фикстура на 359 зелёных, тест, переживающий revert. Условие снова под контролем агента.
• Пинатор — выход по фактам, которые агент не авторит: реальные вызовы инструментов, перепись открытых задач из спеков, анти-гейминг. Строку не напишешь, тест не подделаешь мимо мутаций, перепись не тронешь, не тронув сами спеки.

Все мейнстрим-лупы отдают условие выхода тому, что агент может сочинить сам, — строке или тестам, которые он же и написал. Держится только то, что заземлено на факты, которые агент не может ни подделать, ни отключить.

Применимость радикально разная — это не конкуренты, а разные инструменты под разные задачи. Когда что брать:

• Разовая понятная задача, можно уйти и вернуться → внешний Ralph. Одна строка, свежий контекст, ничего не усложняй.
• Есть надёжные тесты как критерий → verify-луп: крути, пока не зелёные (помня, что тесты пишет агент — см. арсенал).
• Нужно десять фич параллельно → оркестрация: веер агентов по git-worktree. Это про ширину, а не глубину.
• Длинная честная работа, где агент врёт про «готово» и халтурит в одной глубокой сессии → мой пинатор. Он не «крути до критерия», он «не дай соврать и слиться, пока задача из спеков реально не закрыта».

Где я честно проигрываю (иначе это реклама, а не разбор):

• Сетап тяжёлый. Ralph — одна строка bash; у меня 13 хуков, LLM-судья, спек-инфраструктура.
• Нужен LLM-судья — деньги, плюс шесть секунд на стоп, недетерминизм (гашу адверсариальным бенчем, но это цена).
• Контекст пухнет. Держу один длинный ран — к пятому часу контекст раздут; у Ralph свежий контекст каждую итерацию этого лишён.
• Без спеков — слабее, но не слеп. Спек-перепись даёт самый чистый сигнал «ещё N задач открыто»; на репе без .specs/*/TASKS.md этого конкретного сигнала нет. Но пинатор не выключается: решение принимает не только перепись — детерминантный слой (заявка «готово» без прогона, announce-and-stop, фабрикованный блокер) и Haiku-судья судят по фактам вызовов инструментов и реальному запросу человека на любом репо, а сам счётчик работы складывается из переписи плюс открытых пунктов самого агента плюс живого TASKS.md. Теряется один сигнал — не весь гейт.
• Не параллелю. Оркестраторы берут шириной — десятки агентов разом; я беру глубиной в одной сессии.

Как повторить у себя

Идея переносится на любой агентский сетап с хуками, без всего dev-pomogator. Главный урок трёх раундов — защита должна опираться на объективный факт и быть недосягаемой для агента:

• Повесь скрипт на Stop. Возвращай {"decision":"block","reason":"..."}, когда стоп преждевременный — reason станет «пинком», который агент прочитает и продолжит.
• Не матчи фразы — проверяй факты. Регексп по «Дальше» обходят разными языками. Сопоставляй «что заявлено» с «что реально вызвано инструментами», а в серой зоне — отдавай решение модели-судье.
• Заведи объективный факт о незавершённости. Перепись задач, открытые TODO, красные тесты — что угодно измеримое. Без него гейт превратится в угадайку.
• Защити сам гейт. Если агент может отредактировать твою защиту — он её отредактирует. Файл судьи/гейта должен быть для него недоступен на запись.
• Поставь тормоза и считай деньги. Анти-луп (одинаковое сообщение / лимит / ошибка → пропускай) обязателен; длинные раны — на подписке через прокси.

Если стек подходящий (TS/Python и хуки в твоём агенте) — минимальную версию из двух хуков можно собрать за вечер. Весь мой код открыт: github.com/stgmt/dev-pomogator, ветка с пинатором и судьёй — feat/phase-2a-mcp-server-and-hooks.

FAQ

Как именно Claude обходил защиту? Сначала писал секцию «Дальше» на других языках, чтобы её не поймал регексп. Потом — молча редактировал код судьи, который его тормозил. Оба обхода закрыты: судья смотрит на смысл, файл судьи защищён от записи.

Это не зацикливает агента? Нет: одинаковое сообщение, лимит попыток в окне охлаждения и любая ошибка пропускают стоп. Обвязка «дожимает», но всегда отпускает.

А если работа реально кончилась? Тогда перепись показывает ноль открытого, сообщение — чистое «готово», и судья делает approve. Блок прилетает только при открытой работе и конкретном следующем шаге.

Это работает только в Claude Code? Механизм Stop-хука с decision:block специфичен для Claude Code, но идея (гейт на завершении + объективный факт + недосягаемая для агента защита) переносится на любой агент с хуками.

Если совсем коротко

Автономность агента — это не магия большой модели, а инженерия вокруг неё, причём состязательная. Я начал с двух наивных хуков, Claude обошёл их разными языками, я добавил умного судью, Claude стал тихо его отключать — пока я не защитил файл судьи от записи. Каждую защиту на доверии или ключевых словах агент обходит; держатся только опирающиеся на факт и недосягаемые для него. Результат — стабильные 6-часовые раны. Код открыт — берите.

Пост из Telegram-канала Аи Помогатор