From c081a5b6ff656ad3e033b87648c4f5b64bba02bd Mon Sep 17 00:00:00 2001 From: Slava Date: Tue, 16 Jun 2026 02:21:05 +0300 Subject: [PATCH 01/16] docs: init ORCH-116 business request --- docs/work-items/ORCH-116/00-business-request.md | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 docs/work-items/ORCH-116/00-business-request.md diff --git a/docs/work-items/ORCH-116/00-business-request.md b/docs/work-items/ORCH-116/00-business-request.md new file mode 100644 index 0000000..628d487 --- /dev/null +++ b/docs/work-items/ORCH-116/00-business-request.md @@ -0,0 +1,7 @@ +# Business Request: ORCH: replace LLM tester with deterministic test runner + +Work Item ID: ORCH-116 + +## Description + +TBD From 9e543551aa2d00b1f45d30fdd329daa11be3f009 Mon Sep 17 00:00:00 2001 From: claude-bot Date: Tue, 16 Jun 2026 02:29:50 +0300 Subject: [PATCH 02/16] analyst(ET): auto-commit from analyst run_id=738 --- docs/work-items/ORCH-116/01-brd.md | 224 ++++++++++++++++++ docs/work-items/ORCH-116/02-trz.md | 195 +++++++++++++++ .../ORCH-116/03-acceptance-criteria.md | 216 +++++++++++++++++ docs/work-items/ORCH-116/04-test-plan.yaml | 116 +++++++++ 4 files changed, 751 insertions(+) create mode 100644 docs/work-items/ORCH-116/01-brd.md create mode 100644 docs/work-items/ORCH-116/02-trz.md create mode 100644 docs/work-items/ORCH-116/03-acceptance-criteria.md create mode 100644 docs/work-items/ORCH-116/04-test-plan.yaml diff --git a/docs/work-items/ORCH-116/01-brd.md b/docs/work-items/ORCH-116/01-brd.md new file mode 100644 index 0000000..ef412b1 --- /dev/null +++ b/docs/work-items/ORCH-116/01-brd.md @@ -0,0 +1,224 @@ +--- +work_item: ORCH-116 +stage: analysis +author_agent: analyst +status: ready-for-review +created_at: 2026-06-16 +model_used: claude-opus-4-8 +--- + +# 01 — BRD (бизнес-требования): ORCH-116 — заменить LLM-тестера детерминированным test-раннером + +Work Item: **ORCH-116** · Repo: **orchestrator** · Стадия: analysis + +## 1. Бизнес-контекст и проблема + +Стадия `testing` сейчас исполняется **LLM-агентом `tester`** (`src/stages.py:17`, +`STAGE_TRANSITIONS["review"]["agent"] = "tester"` — tester запускается при входе в `testing`). +Фактическая работа агента на этой стадии в happy-path — **в основном детерминированная** +(`.openclaw/agents/tester.md`): прогнать регресс `pytest tests/ -v --tb=short` в worktree ветки, +сделать read-only smoke (`/health`, `/status`, `/queue` + наличие блока `serial_gate`), +собрать exit-код, записать `13-test-report.md` с машинным frontmatter `result: PASS|FAIL`. Гейт +`check_tests_passed` (`src/qg/checks.py:182` → `_parse_tests_verdict:226`) читает **только** ключ +`result:` из frontmatter — **не** прозу и **не** покрытие TC. + +Это **avoidable LLM control path** по нормативной политике (`docs/architecture/llm-usage-policy.md`): +(i) это **C-консультация** — вердикт `result:` потребляется гейтом `check_tests_passed`, и +(ii) вердикт PASS/FAIL **деривируем** из exit-кода `pytest` + smoke (детерминированные сигналы). +Карта вызовов (`docs/architecture/llm-call-sites.md`, строка **A5**) классифицирует tester как +**`needs-hybrid-fallback`**, а roadmap (`docs/architecture/llm-determinization-roadmap.md`, машинный +блок §4) ставит его **rank 2** с `hybrid_needed = yes`, `first_slice = no`. Это **второй срез** +determinization-roadmap — после реализованного первого среза **ORCH-115** (детерминированный +`staging_runner`, deployer на `deploy-staging`). + +**Гибридная природа (ключевое отличие от ORCH-115).** Tester — `needs-hybrid-fallback`, не +`replace-deterministic-now`: его **PASS/FAIL-ядро** полностью детерминируемо (exit-код pytest + +smoke), но часть работы прежнего промпта — **триаж падений**, **анализ пробелов покрытия +AC**, **сопоставление TC ↔ критерии приёмки** и **человекочитаемая диагностика** — это настоящее +суждение. ORCH-116 выносит из потока управления **только PASS/FAIL-исполнителя** (его делает +детерминированный код); опциональный LLM-аналитик допустим как **off-control-path** триаж/ +диагностика после детерминированного провала, но **никогда** как первичный исполнитель вердикта +гейта (BR-8 / NFR-7). + +**Боль / риск, который закрываем:** +- **Недетерминизм в потоке управления.** Решение «advance на `deploy-staging` или rollback на + `development`» на стадии `testing` зависит от LLM-сессии (стоимость, латентность, риск + галлюцинации/неверного вердикта), хотя сводится к exit-коду pytest + smoke. +- **Стоимость и латентность.** Каждый прогон tester'а тратит токены/время opus-агента (оценка по + `agent_runs`: tester-строки ~60–150k токенов / 5–20 мин на прогон; точное число — `GET /metrics`) + ради действия, которое выполняется одним прогоном pytest + несколькими read-only GET. +- **Избыточность с уже-зелёным сигналом.** Регресс уже прогоняется в CI (`check_ci_green` гейтит + `development → review`, `src/qg/checks.py:82`), повторно в merge-gate re-test (ORCH-043/110) и в + coverage-gate (ORCH-027). Повторный прогон pytest на стадии `testing` — подтверждение факта, а не + суждение → естественный кандидат на детерминизацию. +- **Класс инцидентов «LLM принял решение, которое есть исполнение фиксированных команд + маппинг + результата»** — тот же RCA-трек, что ORCH-110/111/112/113/114/117/115. + +Установленные факты (не изобретать): +- Гейт `check_tests_passed`/`_parse_tests_verdict` читает **только** `result:` (плюс legacy-поля + `verdict:`/`status:`, ORCH-047) из frontmatter `13-test-report.md`; покрытие TC / сопоставление с + AC гейтом **не парсится** (это была нагрузка промпта, не требование гейта). Значит замена + *продюсера* `result:` детерминированным кодом сохраняет контракт гейта байт-в-байт. +- Детерминированный прецедент замены агента **до `_spawn`** уже работает и проверен: `launch_job` + перехватывает `deploy-finalizer` (D1, `src/agents/launcher.py:397`), `post-deploy-monitor` + (D2, `:402`) и **staging-runner** (ORCH-115, `:405-408`) до `_spawn`; `src/staging_runner.py` — + готовый эталон leaf-раннера (two-level outcome, never-raise, kill-switch, proc_group). +- Изоляция спавненного pytest уже решена: `src/proc_group.py::run_in_process_group` (ORCH-110) + даёт tree-kill (`os.killpg`, каскад SIGTERM→grace→SIGKILL) — корень CPU-голодания от + осиротевших pytest (инцидент ORCH-109/111) закрыт; раннер обязан использовать его. +- Маппинг exit-кода — тривиальная pure-функция (`0 → PASS`, иначе `FAIL`), зеркало + `self_deploy.map_exit_code_to_status` (но в токенах `PASS`/`FAIL`, а не `SUCCESS`/`FAILED`). + +## 2. Объём (scope) + +### В объёме (Phase 1) +- **Детерминированный test-раннер** для стадии `testing` репо `orchestrator` (self-hosting): + исполняет «тест-контракт» (сконфигурированные test/smoke-команды) в worktree ветки задачи, + маппит exit-код в `result: PASS|FAIL`, пишет `13-test-report.md`, инициирует существующий гейт + `check_tests_passed` — **без** запуска LLM-агента `tester`. +- **Тест-контракт** — сконфигурированный набор команд: обязательная регресс-команда + (`pytest tests/`, переиспользуя конвенцию `merge_retest_target`) + опциональные read-only + smoke-проверки (зеркало шага 3 промпта tester: `/health`, `/status`, `/queue` + наличие блока + `serial_gate`). Для self-hosting `orchestrator` контракт известен по умолчанию. +- Раннер активируется через **перехват в `launch_job` до `_spawn`** (прецедент D1/D2/ORCH-115), + **без правки `src/stages.py`/`STAGE_TRANSITIONS`** (роль `tester` в словаре остаётся; меняется лишь + *кто* обрабатывает джоб на стадии `testing` для in-scope репо с тест-контрактом). +- После выпуска вердикта раннер инициирует **существующую** оценку exit-гейта `check_tests_passed` + ровно как завершившийся LLM-tester (`advance_stage(finished_agent="tester")`): PASS → `deploy-staging` + (и далее под-гейты ORCH-022/043/027/058 на ребре `deploy-staging → deploy`); FAIL → существующий + откат `testing → development` + developer-retry (`src/stage_engine.py:849`). +- Two-level outcome (анти-ORCH-110, по образцу `staging_runner`): сюита **исполнилась** → вердикт → + advance; сюита **не исполнилась** (tool-error: spawn-error/таймаут/`returncode None`) → bounded + DEFER, на исчерпании → fail-closed `FAIL` + advance + alert. Инфра-сбой **не жжёт** developer-retry. +- Kill-switch + скоуп-CSV + **тест-контракт** (паттерн ORCH-022/027/043/089/090/115): `*_enabled` + (откат к LLM-пути), `*_repos` (пусто → self-hosting only), backward-compat: репо без тест-контракта + → раннер не применяется → прежний LLM-tester. +- Наблюдаемость: read-only блок в `GET /queue` + структурный лог вердикта. + +### Вне объёма (явно НЕ делаем в ORCH-116) +- **ORCH-115 (детерминированный deploy/staging-раннер)** — **по явной границе задачи не смешиваем**: + ORCH-116 не модифицирует `src/staging_runner.py` и не трогает ребро `deploy-staging`/`deploy`. +- **LLM-роли `reviewer` и `developer`** — **остаются без изменений** (граница задачи). reviewer — + control-path-но-keep (вердикт `verdict:` не деривируем из tool-сигнала, `llm-call-sites.md`). +- **Реализация опционального off-control-path LLM-триажа/диагностики после FAIL** — не делается в + этом срезе (forward-looking, §6 BRD и §8 TRZ). Архитектура раннера **не должна запрещать** её + (NFR-7), но и не реализует. +- **Сопоставление TC ↔ критерии приёмки / анализ пробелов покрытия AC как условие гейта** — гейт + `check_tests_passed` его не требует (читает только `result:`); в потоке управления его нет. Это + off-control-path диагностика (см. выше). +- **Любая правка `STAGE_TRANSITIONS` / реестра и имён `QG_CHECKS` / семантики `check_tests_passed` / + `_parse_tests_verdict` / machine-verdict-ключей (`result:`/`verdict:`/`status:`) / схемы БД** + (см. NFR-1). +- **Замена/правка `check_ci_green` / merge-gate re-test / coverage-gate** — они продолжают работать + как есть; ORCH-116 меняет только продюсера `13-test-report.md`. + +## 3. Заинтересованные стороны + +- **Заказчик / Owner** (`homenet542@gmail.com`) — инициатор детерминизации LLM-control-path'ов. +- **Платформа orchestrator (self-hosting)** — прямой потребитель: дешевле/быстрее/детерминированнее + собственная стадия `testing`. +- **Другие проекты на общем инстансе** (enduro-trails) — НЕ затронуты в Phase 1 (скоуп self-hosting + + backward-compat для репо без тест-контракта); выигрывают позже от Phase 2 (project test contract). +- **Reviewer / Developer-роли конвейера** — принимают результат через неизменные гейты; их LLM-роли + не трогаются. + +## 4. Бизнес-требования (BR) + +- **BR-1 — Детерминированный PASS/FAIL без LLM.** На стадии `testing` для in-scope репо с + тест-контрактом вердикт `result:` производится детерминированным кодом (исполнение тест-контракта + + маппинг exit-кода), **без** консультации LLM. Happy-path `testing` не вызывает `_spawn`. +- **BR-2 — Контракт артефакта неизменен.** Раннер пишет тот же `13-test-report.md` с тем же + frontmatter-ключом `result: PASS|FAIL`, который читает `check_tests_passed`/`_parse_tests_verdict`. + Гейт и парсер байт-в-байт не меняются. +- **BR-3 — Эквивалентность маршрутизации.** PASS → продвижение на `deploy-staging` через + существующий путь; FAIL → существующий откат `testing → development` + инкремент developer-retry + (тот же путь и cap `MAX_DEVELOPER_RETRIES`, что у FAIL-вердикта LLM-tester'а, `src/stage_engine.py:849`). + Никаких новых рёбер/исходов. +- **BR-4 — Переиспользование существующей инфраструктуры.** Раннер исполняет pytest через + `proc_group.run_in_process_group` (ORCH-110, tree-kill), переиспользует exit-code→verdict-маппинг + (зеркало `self_deploy.map_exit_code_to_status`, в токенах `PASS`/`FAIL`) и конвенцию таргета + (`merge_retest_target`/`tests/`). Не плодит второй несогласованный маппинг/механизм. +- **BR-5 — Обратимость одним флагом.** Глобальный kill-switch возвращает прежний LLM-tester-путь на + `testing` байт-в-байт; скоуп-CSV ограничивает раннер in-scope репо (пусто → только `orchestrator`). +- **BR-6 — Наблюдаемость.** Исход раннера (запущен / PASS / FAIL / tool-error / defer) виден в + `GET /queue` и в структурном логе; «код упал» (детерминированный FAIL) и «инструмент недоступен» + (tool-error) различимы. +- **BR-7 — Self-hosting safety.** Раннер на `testing` **никогда** не рестартит прод-контейнер 8500, + не трогает `main` force-push'ем, не правит `.env`/`docker-compose.yml`. Он лишь читает, исполняет + тест-контракт в worktree (pytest) и read-only smoke против 8500, пишет лог и best-effort пушит лог + в фичеветку (merge в `main` — штатным merge-gate-путём). +- **BR-8 — Гибрид: LLM только off-control-path.** Детерминированный раннер — **единственный** + исполнитель вердикта `result:`. LLM на стадии `testing` допустим лишь как опциональный + off-control-path триаж/диагностика после детерминированного FAIL и **не** выносит/не переопределяет + машинный вердикт гейта. В Phase 1 он не реализуется (NFR-7), но архитектурно не запрещён. +- **BR-9 — Backward-compatibility для репо без тест-контракта.** Репо, для которого тест-контракт не + сконфигурирован/не резолвится, раннер **не перехватывает** → стадию `testing` ведёт прежний + LLM-tester (fail-safe). enduro-trails и любые будущие репо без контракта — 1:1 как до ORCH-116. + +## 5. Нефункциональные требования (NFR) + +- **NFR-1 — Скоуп-инвариант (анти-дрейф).** `STAGE_TRANSITIONS` (`src/stages.py`), реестр и имена + `QG_CHECKS`/`check_tests_passed`/`_parse_tests_verdict` (`src/qg/checks.py`), machine-verdict-ключи + (`result:`/`verdict:`/`status:`/`staging_status:`/`deploy_status:`/`security_status:`/`coverage_status:`), + схема БД — **байт-в-байт не тронуты**. Это замена *продюсера* артефакта, не гейта. +- **NFR-2 — never-raise / fail-safe.** Любая ошибка раннера (pytest не запустился, таймаут, I/O) → + безопасный детерминированный исход без падения воркера: либо `FAIL` (fail-closed, никогда ложный + green), либо штатный bounded requeue/defer — **не** «тихий advance». Сбой раннера не клинит очередь + всех проектов. **Tool-error ≠ code-fail:** инфра-сбой не жжёт developer-retry (анти-ORCH-110). +- **NFR-3 — Изоляция процесса / таймаут.** Спавненный pytest исполняется через `proc_group` + (tree-kill, ORCH-110); сирот pytest не оставляет; ограниченный таймаут. +- **NFR-4 — Сквозные бюджеты времени.** Таймаут раннера согласован со сквозным инвариантом + ORCH-065/109/110 (`reaper_max_running_s` > Σ(работ на ребре) + grace) — **без** правки + `reaper_max_running_s`. Ребро `testing` отдельно от ребра `deploy-staging`; бюджет ≤ окна, которое + раннер замещает (прежний tester шёл под `agent_timeout_seconds`). +- **NFR-5 — Совместимость с не-self репо.** Для репо вне скоупа / без тест-контракта `testing` ведёт + себя 1:1 как до ORCH-116 (LLM-tester). enduro-trails не затронут. +- **NFR-6 — Соответствие политике LLM.** Изменение снимает LLM-консультацию A5 из потока управления; + карта `docs/architecture/llm-call-sites.md` (A5) / `llm-determinization-roadmap.md` (rank 2) / + `llm-usage-policy.md` и анти-дрейф-тесты обновляются **в том же PR** (норматив сопровождения ORCH-118). +- **NFR-7 — Не запрещать будущий off-control-path LLM-триаж.** Архитектура раннера не должна + архитектурно исключать опциональный LLM debug/triage-аналитик после детерминированного FAIL + (будущее улучшение); в ORCH-116 он не реализуется. + +## 6. Допущения и ограничения + +- **Допущение А1.** Регресс-сюита `orchestrator` (`pytest tests/`) исполняема в worktree ветки задачи + и её exit-код — авторитетный сигнал PASS/FAIL (как уже трактуют CI / merge-gate re-test / coverage-gate). +- **Допущение А2.** Для self-hosting `orchestrator` тест-контракт известен по умолчанию + (pytest + read-only smoke против 8500). Для прочих репо контракт отсутствует, пока не сконфигурирован + (Phase 2) → раннер их не перехватывает (BR-9). +- **Допущение А3.** Перехват «до `_spawn`» по имени джоб-роли (`tester`) + стадии задачи (`testing`) + — достаточный механизм диспетчеризации (как D1/D2/ORCH-115); конкретный механизм финализирует + архитектор (06-adr). +- **Ограничение О1.** Граница задачи: не смешивать с ORCH-115 (его код не модифицируется); LLM-роли + `reviewer`/`developer` не трогаются; код ORCH-112/114 не модифицируется. +- **Ограничение О2.** Phase 2 (project test contract для не-self репо + опциональный off-control-path + LLM-триаж) — отдельный follow-up; ORCH-116 закрывает только Phase 1. + +## 7. Критерии успеха + +Стадия `testing` для `orchestrator` проходит без запуска LLM-агента `tester`: детерминированный +раннер исполняет тест-контракт (pytest + smoke), пишет корректный `13-test-report.md` (`result: +PASS|FAIL`), инициирует неизменный гейт `check_tests_passed`, и конвейер продвигается +(`testing → deploy-staging`) / откатывается (`testing → development` + developer-retry) ровно как +раньше — при неизменных `STAGE_TRANSITIONS`/`QG_CHECKS`/гейтах/схеме БД, под kill-switch с откатом к +прежнему LLM-поведению, с backward-compat для репо без тест-контракта. Детальные PASS/FAIL — +`03-acceptance-criteria.md`. + +## 8. Риски + +Краткий перечень (детали — `10-tech-risks.md`, заполняет архитектор): +- **R-1** — точка диспетчеризации «до `_spawn`» должна корректно отличать testing-tester от любого + иного джоба (по роли + стадии задачи), иначе можно перехватить не тот джоб. +- **R-2** — после выпуска вердикта нужно надёжно инициировать `advance_stage(finished_agent="tester")`, + иначе задача зависнет на `testing` (нет «финиша агента», который раньше триггерил гейт). +- **R-3** — таймаут/изоляция pytest-subprocess; утечка процессов (корень инцидента ORCH-109/110/111) — + обязателен `proc_group` tree-kill. +- **R-4** — корректность two-level outcome: tool-error не должен жечь developer-retry (анти-ORCH-110), + но и не давать ложный green/тихий advance. +- **R-5** — корректность отката FAIL (developer-retry cap, встраивание `extract_test_failures`) — + должна совпасть с LLM-путём `src/stage_engine.py:849`. +- **R-6** — гибрид: не протащить LLM обратно в поток управления вердикта (BR-8); off-control-path + триаж — отдельная роль/джоб, не выносящая `result:`. +- **R-7** — backward-compat: репо без тест-контракта обязаны откатываться на LLM-tester (BR-9), иначе + enduro/новый репо «застрянет» без продюсера отчёта. diff --git a/docs/work-items/ORCH-116/02-trz.md b/docs/work-items/ORCH-116/02-trz.md new file mode 100644 index 0000000..9edfa8d --- /dev/null +++ b/docs/work-items/ORCH-116/02-trz.md @@ -0,0 +1,195 @@ +--- +work_item: ORCH-116 +stage: analysis +author_agent: analyst +status: ready-for-review +created_at: 2026-06-16 +model_used: claude-opus-4-8 +--- + +# 02 — ТЗ (TRZ): ORCH-116 — детерминированный test-раннер вместо LLM-тестера + +Work Item: **ORCH-116** · Repo: **orchestrator** · Стадия: analysis + +> ТЗ описывает **конкретные изменения к реализации**, выведенные из BRD и фактического кода. +> Архитектурное обоснование (точный механизм перехвата, размещение раннера, способ инициации +> `advance_stage`, форма тест-контракта, лестница таймаутов, two-level outcome) — задача +> архитектора (`06-adr/`). Здесь — требования и привязка к реальным модулям `src/`. + +## 1. Сводка изменения + +Заменить **LLM-агента `tester`** на стадии `testing` (для self-hosting `orchestrator`) +**детерминированным test-раннером**, перехватываемым в `launch_job` **до `_spawn`** (прецедент +`deploy-finalizer`/`post-deploy-monitor`/`staging_runner`, `src/agents/launcher.py:397/402/405`). +Раннер исполняет «тест-контракт» (регресс `pytest tests/` через `proc_group.run_in_process_group` ++ опциональные read-only smoke-проверки), маппит exit-код в `result:` (`0→PASS`, иначе `FAIL`), +пишет `13-test-report.md`, best-effort пушит лог в фичеветку, затем инициирует **существующую** +оценку exit-гейта `check_tests_passed` ровно как завершившийся LLM-tester. Контракт артефакта, гейт, +`STAGE_TRANSITIONS`, схема БД — **неизменны**. Под kill-switch + скоуп-CSV + тест-контракт; +never-raise; fail-closed; two-level outcome (анти-ORCH-110). Эталон реализации — `src/staging_runner.py` +(ORCH-115). + +## 2. Задействованные модули / пути + +| Путь | Действие | Назначение | +|------|----------|------------| +| `src/test_runner.py` *(новый leaf)* | создать | Детерминированный раннер: `applies(repo)` (kill-switch + скоуп + наличие тест-контракта), `should_intercept(job)` (роль `tester` + стадия `testing`), исполнение тест-контракта (`pytest` через `proc_group`, опц. smoke), маппинг exit-кода → `result:`, запись `13-test-report.md`, best-effort push в фичеветку, инициация гейта через `advance_stage(finished_agent="tester")`, two-level outcome (tool-error DEFER), снапшот для `/queue`. Leaf-чистота по образцу `staging_runner.py`/`self_deploy.py`: на импорте только `config`/`logging`/`proc_group`; `db`/`git_worktree`/`self_deploy`/`qg.checks`/`stage_engine`/`notifications` — лениво внутри функций; never-raise. | +| `src/agents/launcher.py` | изменить | В `launch_job` добавить перехват **до `_spawn`** (рядом с D1/D2/ORCH-115): `if job.get("agent")=="tester": from .. import test_runner; if test_runner.should_intercept(job): return self._run_test_runner_job(job)`. Новый метод `_run_test_runner_job(job)` — зеркало `_run_staging_runner_job`: синхронно ведёт `jobs`-строку через `mark_job(done|failed)`, возвращает `None` (нет `agent_runs`). | +| `src/config.py` | изменить | Добавить ключи (зеркало `staging_runner_*`/`merge_retest_*`): `test_runner_enabled: bool = True` (env `ORCH_TEST_RUNNER_ENABLED`), `test_runner_repos: str = ""` (env `ORCH_TEST_RUNNER_REPOS`; пусто → self-hosting only), `test_runner_target: str = "tests/"` (pytest-таргет тест-контракта, конвенция `merge_retest_target`), `test_runner_timeout_s: int = 900` (см. FR-2/NFR-4), `test_runner_smoke_enabled: bool = True` (опц. read-only smoke), `test_runner_infra_max_retries: int = 2`, `test_runner_infra_retry_delay_s: int = 30`. Дефолты = боевое; пустой `.env` ⇒ поведение для in-scope. | +| `src/main.py` (`GET /queue`) | изменить | Read-only блок `test_runner` (флаг/скоуп/таргет/счётчики исходов) — наблюдаемость BR-6 (зеркало блока `staging_runner`). | +| `.openclaw/agents/tester.md` | изменить (docs) | Отметить, что на `testing` для in-scope репо с тест-контрактом стадию ведёт детерминированный код (зеркало формулировки `deployer.md` про staging-runner ORCH-115); LLM-ветвь `testing` остаётся fallback'ом под выключенным флагом / для репо без тест-контракта. Канон промпта 52d (5 секций, ключ `result:`) — байт-в-байт. | +| `docs/architecture/llm-call-sites.md`, `llm-determinization-roadmap.md`, `llm-usage-policy.md` | изменить (docs) | Норматив сопровождения ORCH-118 (NFR-6): отразить реализацию A5 (tester) — обновить инвентарь/политику/roadmap (rank 2 → реализовано, инвариант «ровно один `first_slice = yes`» НЕ нарушать) в том же PR; синхронно поправить `tests/test_llm_call_site_inventory.py` / `tests/test_llm_determinization_docs.py` (машинные блоки). | +| `docs/architecture/README.md`, `CLAUDE.md`, `CHANGELOG.md`, `docs/overview/` | изменить (docs) | Компонент-карта/паспорт/чейнджлог/витрина — правило для агентов №2 + витрина ORCH-011. | +| `tests/test_orch116_test_runner.py` *(новый)* | создать | Покрытие (см. `04-test-plan.yaml`). | + +> **Не трогать (NFR-1):** `src/stages.py::STAGE_TRANSITIONS`; имена/семантику `QG_CHECKS`/ +> `check_tests_passed`/`_parse_tests_verdict`/прочих `check_*` в `src/qg/checks.py`; machine-verdict-ключи +> (`result:`/`verdict:`/`status:`/…); `src/staging_runner.py` (ORCH-115); LLM-роли `reviewer`/`developer` +> (`.openclaw/agents/reviewer.md`/`developer.md`); `src/transition_lease.py` (ORCH-114); +> `src/checkout_hygiene.py` (ORCH-112); `src/proc_group.py` (переиспользуем как есть); схему БД. + +## 3. Функциональные требования + +### FR-1 — Детерминированный перехват на `testing` (без `_spawn`) +В `launch_job` (`src/agents/launcher.py`) **до** вызова `_spawn`, по образцу D1/D2/ORCH-115: если +`job.agent == "tester"` **и** `test_runner.should_intercept(job)` истинно → не вызывать `_spawn`, а +исполнить раннер синхронно (`_run_test_runner_job`). Контракт: возвращает `None` (нет `agent_runs`), +сам ведёт `jobs`-строку (`mark_job(done|failed)`) как `_run_staging_runner_job`. +- `should_intercept(job)`: `job.agent == "tester"` **И** `applies(job.repo)` **И** стадия задачи + (`tasks.stage` по `job.task_id`) == `testing`. Роль `tester` исполняет **только** стадию `testing` + (единственный `agent` для входа в `testing`, `STAGE_TRANSITIONS["review"]["agent"]`), поэтому + коллизии стадий нет; гард по стадии — defense-in-depth (R-1). never-raise → `False` (DB-сбой → + fall-through к `_spawn`, fail-safe к LLM-пути). +- `applies(repo)`: `test_runner_enabled=False` → `False` (откат к LLM-пути); непустой + `test_runner_repos` → membership; пустой CSV → `is_self_hosting_repo(repo)`; **и** тест-контракт + для репо резолвится (BR-9: иначе `False` → LLM-tester). Никакой сети, проверяется **первым** + (нулевой оверхед при выключенном флаге). never-raise → `False` (fail-safe к LLM-пути). + +### FR-2 — Исполнение тест-контракта (pytest + опц. smoke) через `proc_group` +Раннер исполняет регресс-команду тест-контракта — `python -m pytest ` (дефолт +`tests/`) — **в worktree ветки задачи** (`git_worktree.get_worktree_path(repo, branch)`, НЕ в общем +`/repos/orchestrator`: анти-checkout-гонка, как требовал промпт tester шаг 2) через +`proc_group.run_in_process_group` (ORCH-110: отдельная группа процессов, tree-kill SIGTERM→grace→SIGKILL, +grace = `agent_kill_grace_seconds`; `subprocess_tree_kill_enabled`). Таймаут — `test_runner_timeout_s` +(дефолт 900; малформ/непозитив → дефолт + WARNING, never-break — зеркало +`merge_gate._resolve_retest_timeout`/`staging_runner._resolve_timeout`). Захватывает exit-код и stdout +(для тела отчёта/observability). +- **Опциональный smoke** (`test_runner_smoke_enabled`, зеркало шага 3 промпта tester): read-only GET + `http://localhost:/health`, `/status`, `/queue` + проверка наличия блока `serial_gate` в + `/queue`. Любой провал smoke → итоговый `FAIL` (детерминированно). Smoke — строго read-only + (BR-7/AC-8): никаких мутирующих запросов к 8500. + +### FR-3 — Маппинг exit-кода → `result:` +`0 → "PASS"`, любой ненулевой / отсутствие кода / ошибка запуска → `"FAIL"` (fail-closed, никогда +ложный green). Pure-функция, согласованная по контракту с `self_deploy.map_exit_code_to_status`, но в +токенах `PASS`/`FAIL` (`result:` использует их, а не `SUCCESS`/`FAILED`; `_TESTS_POSITIVE_TOKENS`/ +`_TESTS_NEGATIVE_TOKENS`, `src/qg/checks.py:222-223`). Если архитектор предпочтёт единый маппер с +параметризованными токенами — допустимо, но **второй несогласованный маппинг не плодить** (BR-4). + +### FR-4 — Запись и push `13-test-report.md` +Раннер пишет `docs/work-items//13-test-report.md` в worktree фичеветки с frontmatter: +`result: PASS|FAIL` (UPPERCASE) + обязательная 52c-схема (`work_item`/`stage: testing`/`author_agent`/ +`status`/`created_at`/`model_used`) + информативное тело (таблица результата pytest / хвост stdout / +smoke-итог) — зеркало `staging_runner.build_staging_log`/`write_staging_log`. `author_agent: test-runner`, +`model_used: n/a` честно отражают **детерминированный** продюсер; ключ `result:` и его UPPERCASE-значение +**не** меняются. Best-effort `git add/commit/push` лога в **фичеветку** (та же git-identity ORCH-101, +актор `test-runner`; **без** отдельного PR-merge в `main` — гейт читает worktree → origin/main fallback, +`check_tests_passed`→`_repo_path`). Самостоятельный merge лога в `main` НЕ делать (усиливает BR-7/AC-8). + +### FR-5 — Инициация существующего гейта после вердикта +После записи (и best-effort push) раннер инициирует ту же оценку exit-гейта, что триггерил +завершившийся LLM-tester: `stage_engine.advance_stage(task_id, current_stage="testing", repo, +work_item_id, branch, finished_agent="tester")`. Это запускает `check_tests_passed` (`_parse_tests_verdict` +читает `result:` из `13-test-report.md`) — на PASS продвигает `testing → deploy-staging`; на FAIL +запускает **существующий** откат `testing → development` + developer-retry (cap `MAX_DEVELOPER_RETRIES`, +встраивание `extract_test_failures`, `src/stage_engine.py:849-892`). **Никакой новой ветви +маршрутизации.** Lease ORCH-114 берётся внутри `advance_stage` как сейчас — раннер его не трогает +(граница задачи О1). never-raise. + +### FR-6 — Two-level outcome (tool-error DEFER, анти-ORCH-110) +По образцу `staging_runner.run_staging_gate`: +- Сюита **исполнилась** (`returncode is not None` и не `timed_out`) → довериться exit-коду (FR-3) → + записать `result:` → инициировать гейт (FR-5). FAIL → существующий rollback (FR-5). +- Сюита **не исполнилась** (tool-error: spawn-error / таймаут / `returncode None`) → **инфра-сбой, НЕ + код-фейл** → bounded DEFER: re-queue свежий `tester`-джоб с задержкой `test_runner_infra_retry_delay_s` + + restart-safe маркер (`test-runner infra-retry` в `task_content`, зеркало + `staging_runner._INFRA_RETRY_MARKER`/`stage_engine._merge_infra_retry_count`); счётчик из persisted + `jobs`. На исчерпании `test_runner_infra_max_retries` → fail-closed `result: FAIL` + запись лога + + инициация гейта (существующий rollback) + один INFRA-alert (явно «НЕ дефект кода», кликабельный + номер). **Никогда** тихий advance/ложный green; **никогда** не клинит очередь; **не** жжёт + developer-retry на транзиентной инфре. + +### FR-7 — Kill-switch, скоуп, тест-контракт (обратимость + backward-compat) +`test_runner_enabled=False` → перехват не срабатывает → на `testing` запускается прежний LLM-tester +(`_spawn`) **байт-в-байт** как до ORCH-116. `test_runner_repos` ограничивает скоуп (пусто → только +`orchestrator`). Репо без резолвимого тест-контракта → `applies==False` → LLM-tester (BR-9). Переключение +флага туда-сюда не оставляет несовместимого состояния (артефакт/гейт неизменны). + +### FR-8 — Наблюдаемость +- Read-only блок `test_runner` в `GET /queue`: `enabled`, `repos`, `target`, `timeout_s`, + `infra_max_retries`, счётчики `runs`/`pass`/`fail`/`tool_error`/`deferred` (in-process, паттерн + `staging_runner._STAGING_RUNNER_COUNTERS`). +- Один структурный лог-вердикт на прогон (`work_item`/`repo`/`exit_code`/`result`/`duration_s`/`outcome`), + различающий «код упал» (`FAIL` от сюиты) и «инструмент недоступен» (tool-error). + +### FR-9 — Гибрид: LLM строго off-control-path (BR-8 / NFR-7) +В Phase 1 LLM на стадии `testing` **отсутствует** в потоке управления вердикта (детерминированный +раннер — единственный продюсер `result:`). Архитектура раннера не должна архитектурно исключать +будущий **опциональный off-control-path** LLM-триаж/диагностику после детерминированного FAIL +(отдельная роль/джоб, **не** выносящая и **не** переопределяющая `result:`). В этом срезе он не +реализуется и **не** добавляется в `STAGE_TRANSITIONS`. + +## 4. Изменения API + +- **`GET /queue`** — добавить read-only ключ `test_runner` (наблюдаемость). Существующие поля ответа + не меняются. +- Опционально (на усмотрение архитектора, по образцу `POST /coverage/baseline`): обязательного нового + мутирующего эндпоинта нет. Откат — через env-флаг. +- Новых вебхуков нет. + +## 5. Изменения схемы БД + +**Нет.** Раннер использует существующие таблицы (`tasks` для стадии/branch/work_item_id, `jobs` для +статуса джоба и restart-safe счётчика infra-retry по маркеру в `task_content`) и worktree-механику. +Никаких новых таблиц/колонок/миграций (NFR-1). Счётчики `/queue` — in-process (паттерн +`_STAGING_RUNNER_COUNTERS`/`_MERGE_GATE_COUNTERS`), не БД. + +## 6. Требования к новым/изменённым QG checks + +**Нет новых QG и нет изменений существующих.** `check_tests_passed` / `_parse_tests_verdict` / ключ +`result:` (+ legacy `verdict:`/`status:`) (`src/qg/checks.py:182/226`) и состав `QG_CHECKS` — +**байт-в-байт неизменны**. ORCH-116 меняет только *продюсера* `13-test-report.md` (детерминированный +код вместо LLM); гейт, читающий артефакт, остаётся прежним. Это критический инвариант (NFR-1) — +reviewer ловит любое изменение имени/семантики гейта/парсера/токенов как finding ≥P1. + +## 7. Совместимость / регресс + +- **Обратная совместимость:** `test_runner_enabled=False` → прежний LLM-tester-путь байт-в-байт; + репо без тест-контракта / вне скоупа → LLM-tester (BR-9). enduro-trails не затронут (NFR-5). +- **Kill-switch / область раската:** флаг `test_runner_enabled` + CSV `test_runner_repos` (пусто → + self-hosting only). Откат = `ORCH_TEST_RUNNER_ENABLED=false`. +- **Обратимость:** полностью обратимо флагом; артефакт и гейт неизменны, переключение туда-сюда не + оставляет несовместимого состояния. +- **never-raise / fail-safe (NFR-2):** ошибка раннера → `FAIL` (fail-closed) или bounded requeue, не + «тихий advance»; tool-error не жжёт developer-retry (анти-ORCH-110). Self-hosting safety (BR-7): + никаких рестартов 8500 / force-push в `main` / правок инфры; smoke строго read-only. +- **Изоляция (NFR-3):** pytest через `proc_group` tree-kill (ORCH-110) — без сирот; таймаут согласован + со сквозным бюджетом ORCH-065/109/110 без правки `reaper_max_running_s` (NFR-4). +- **Граница (О1):** код ORCH-115 (`staging_runner`), ORCH-112 (checkout hygiene), ORCH-114 (transition + lease) и LLM-роли `reviewer`/`developer` не модифицируются. +- **Норматив сопровождения (NFR-6):** в том же PR обновить `docs/architecture/llm-call-sites.md` (A5) / + `llm-determinization-roadmap.md` (rank 2) / `llm-usage-policy.md` + анти-дрейф-тесты + (`tests/test_llm_call_site_inventory.py`, `tests/test_llm_determinization_docs.py`); `CLAUDE.md` / + `docs/architecture/README.md` / `CHANGELOG.md` / `docs/overview/`. + +## 8. Phase 2 (forward-looking, вне приёмки ORCH-116) + +Зафиксировано для преемственности — **не реализуется в этой задаче**, заводится отдельным follow-up: +- **Project test contract** для не-self репо (enduro-trails): декларативный per-repo контракт + `test` / `smoke` (команды + ожидаемые коды/эндпоинты), исполняемый тем же детерминированным + раннер-паттерном (run → map exit code → `result:` → artifact → gate). +- **Опциональный off-control-path LLM-триаж** после детерминированного FAIL: human-readable + диагностика причин падений, анализ пробелов покрытия AC, сопоставление TC ↔ критерии приёмки — + как обогащение отчёта/комментария, **не** как продюсер вердикта `result:` (NFR-7). +- Зависимость: устойчивый Phase 1 (этот work item) как доказанный паттерн перехвата + маппинга + + two-level outcome. diff --git a/docs/work-items/ORCH-116/03-acceptance-criteria.md b/docs/work-items/ORCH-116/03-acceptance-criteria.md new file mode 100644 index 0000000..cad16b4 --- /dev/null +++ b/docs/work-items/ORCH-116/03-acceptance-criteria.md @@ -0,0 +1,216 @@ +--- +work_item: ORCH-116 +stage: analysis +author_agent: analyst +status: ready-for-review +created_at: 2026-06-16 +model_used: claude-opus-4-8 +--- + +# 03 — Критерии приёмки (Acceptance Criteria): ORCH-116 — детерминированный test-раннер + +Work Item: **ORCH-116** · Repo: **orchestrator** · Стадия: analysis + +Формат: каждый критерий имеет **PASS** (что должно быть истинно для приёмки) и **FAIL** +(что считается провалом). Любой машинный/ручной reviewer проверяет их буквально по файлам +репозитория. + +--- + +## AC-1 — Детерминированный перехват на `testing` (нет `_spawn`/LLM) + +**Условие:** При включённом флаге и in-scope репо с тест-контрактом джоб `tester` на стадии +`testing` обрабатывается раннером, а не LLM-агентом. +- **PASS:** `launch_job` (`src/agents/launcher.py`) перехватывает джоб **до** `_spawn` (рядом с + D1/D2/ORCH-115) при `agent=="tester"` + `test_runner.should_intercept(job)` (стадия задачи + `testing` + `applies(repo)`); `_spawn` не вызывается; не создаётся строка `agent_runs`; джоб + ведётся `mark_job(...)` самим раннером (`_run_test_runner_job` → `None`). Тест воспроизводит это + без живого Claude CLI. +- **FAIL:** На `testing` для in-scope репо при включённом флаге всё ещё вызывается `_spawn` / + создаётся `agent_runs`-строка LLM-tester'а. + +--- + +## AC-2 — Контракт артефакта `13-test-report.md` неизменен + +**Условие:** Раннер пишет тот же артефакт с тем же machine-key, что читает гейт. +- **PASS:** Создаётся `docs/work-items//13-test-report.md` с frontmatter + `result: PASS|FAIL` (UPPERCASE) + обязательная 52c-схема (`work_item`/`stage: testing`/ + `author_agent`/`status`/`created_at`/`model_used`). **Неизменённый** `_parse_tests_verdict` читает + его и возвращает корректный вердикт. +- **FAIL:** Изменено имя/регистр/токены ключа `result:` (или legacy `verdict:`/`status:`), + отсутствует frontmatter, вердикт записан только прозой; либо парсер `_parse_tests_verdict` пришлось + менять. + +--- + +## AC-3 — Корректный exit-code → verdict маппинг + +**Условие:** Exit-код тест-контракта детерминированно маппится в вердикт. +- **PASS:** `0 → PASS`; любой ненулевой / None / ошибка запуска → `FAIL` (fail-closed). Маппинг — + pure-функция, согласованная по контракту с `self_deploy.map_exit_code_to_status` (токены `PASS`/ + `FAIL`), покрыта unit-тестом на каждый класс входа. Второй несогласованный маппинг не вводится. +- **FAIL:** Ненулевой код даёт `PASS`; ошибка/None даёт `PASS` (ложный green); раннер вводит второй + несогласованный маппинг или нестандартные токены. + +--- + +## AC-4 — Эквивалентность маршрутизации (PASS / FAIL) + +**Условие:** После вердикта конвейер ведёт себя ровно как при завершившемся LLM-tester'е. +- **PASS:** PASS → раннер инициирует `advance_stage(finished_agent="tester")` → `check_tests_passed` + → продвижение `testing → deploy-staging`. FAIL → существующий откат `testing → development` с + инкрементом developer-retry и встраиванием `extract_test_failures` (`src/stage_engine.py:849-892`), + тот же исход и cap `MAX_DEVELOPER_RETRIES`, что у FAIL-вердикта LLM. +- **FAIL:** Задача зависает на `testing` (гейт не инициирован); или FAIL не откатывает / откатывает + иначе; или появляется новое ребро/исход. + +--- + +## AC-5 — Two-level outcome: tool-error ≠ code-fail (анти-ORCH-110) + +**Условие:** Невозможность исполнить сюиту трактуется как инфра-сбой, не как провал кода. +- **PASS:** Сюита исполнилась (реальный exit-код) → вердикт → advance (FAIL → существующий rollback + + developer-retry). Сюита НЕ исполнилась (spawn-error / таймаут / `returncode None`) → bounded DEFER + (re-queue `tester`-джоба + restart-safe маркер `test-runner infra-retry`, счётчик из persisted + `jobs`), **без** отката на `development` и **без** расхода developer-retry; на исчерпании + `test_runner_infra_max_retries` → fail-closed `result: FAIL` + advance + INFRA-alert (явно «НЕ дефект + кода»). +- **FAIL:** Tool-error немедленно откатывает на `development` и жжёт developer-retry; либо tool-error + даёт `PASS`/тихий advance; либо DEFER бесконечен (не клинит, но и не сходится к fail-closed). + +--- + +## AC-6 — Инвариант скоупа: гейты/стадии/схема БД не тронуты (анти-дрейф) + +**Условие:** Изменена только сторона *продюсера*, не контракт конвейера. +- **PASS:** `git diff` не затрагивает `src/stages.py::STAGE_TRANSITIONS`; имена/семантику + `QG_CHECKS`/`check_tests_passed`/`_parse_tests_verdict`/прочих `check_*` в `src/qg/checks.py`; + machine-verdict-ключи и токены (`result:`/`verdict:`/`status:`/`staging_status:`/`deploy_status:`/ + `security_status:`/`coverage_status:`); схему БД (нет новых таблиц/колонок/миграций). Анти-дрейф-тест + это подтверждает. +- **FAIL:** Любой из перечисленных артефактов изменён по имени/семантике/структуре. + +--- + +## AC-7 — Kill-switch и скоуп (обратимость) + +**Условие:** Флаг возвращает прежнее поведение; скоуп ограничивает раннер. +- **PASS:** `test_runner_enabled=False` → на `testing` запускается прежний LLM-tester через `_spawn` + (байт-в-байт до ORCH-116). Пустой `test_runner_repos` → раннер активен только для `orchestrator`. + Покрыто тестом для обоих значений флага. +- **FAIL:** При выключенном флаге раннер всё равно перехватывает; либо не-self репо из скоупа + перехватывается ошибочно. + +--- + +## AC-8 — Backward-compatibility для репо без тест-контракта + +**Условие:** Репо без резолвимого тест-контракта обслуживается прежним LLM-tester'ом. +- **PASS:** `applies(repo)` → `False`, когда тест-контракт для репо не сконфигурирован/не резолвится + (вне скоупа или нет команды) → `should_intercept` → `False` → `_spawn` (LLM-tester). enduro-trails и + любой репо без контракта — 1:1 как до ORCH-116. Покрыто тестом. +- **FAIL:** Репо без тест-контракта перехватывается раннером и остаётся без продюсера `13-test-report.md` + / зависает. + +--- + +## AC-9 — never-raise / fail-safe (инструмент недоступен) + +**Условие:** Любая ошибка раннера приводит к безопасному детерминированному исходу. +- **PASS:** pytest не запустился / worktree-ошибка / I/O / таймаут → раннер не роняет воркер; исход — + `FAIL` (fail-closed) **или** bounded DEFER (AC-5), **никогда** тихий advance/ложный green. Все + публичные функции `test_runner.py` — never-raise; `applies()`/`should_intercept()` при ошибке → + `False` (fall-through к `_spawn`). Очередь всех проектов не клинится. +- **FAIL:** Ошибка раннера роняет воркер/клинит очередь; либо ошибка/таймаут даёт `PASS`. + +--- + +## AC-10 — Self-hosting safety + +**Условие:** Раннер на `testing` не выполняет опасных для прода действий. +- **PASS:** Раннер не рестартит контейнер 8500, не выполняет `docker compose up -d orchestrator`/ + `--build`, не пушит force в `main`, не правит `.env`/`.env.staging`/`docker-compose.yml`. Smoke — + строго read-only GET (`/health`/`/status`/`/queue`). Лог пушится только в фичеветку (merge в `main` + — штатным merge-gate-путём). Подтверждается ревью кода раннера + тестом отсутствия запрещённых + литералов в его командах. +- **FAIL:** Раннер содержит путь, рестартящий 8500 / force-push в `main` / правящий инфру / мутирующий + smoke-запрос. + +--- + +## AC-11 — Изоляция процесса и таймаут (proc_group / tree-kill) + +**Условие:** pytest-subprocess ограничен по времени и не оставляет сирот. +- **PASS:** Раннер запускает pytest **в worktree ветки** через `proc_group.run_in_process_group` + (отдельная группа процессов, tree-kill при таймауте, grace = `agent_kill_grace_seconds`) с таймаутом + `test_runner_timeout_s` (согласован со сквозным бюджетом ORCH-065/109/110, без правки + `reaper_max_running_s`); малформ/непозитив таймаут → дефолт + WARNING; осиротевших pytest-процессов + не остаётся. +- **FAIL:** Нет таймаута / зависший subprocess клинит воркер; pytest бежит в общем `/repos/orchestrator` + (checkout-гонка); остаются сироты процессов; правится `reaper_max_running_s`. + +--- + +## AC-12 — Гибрид: LLM не в потоке управления вердикта + +**Условие:** Детерминированный раннер — единственный исполнитель `result:`. +- **PASS:** В Phase 1 на стадии `testing` (in-scope) вердикт `result:` производит **только** + детерминированный код; LLM не вызывается в happy-path и в fail-path для вынесения/переопределения + `result:`. Если добавлен off-control-path триаж — он не пишет/не меняет `result:` и не добавляет + ребро в `STAGE_TRANSITIONS`. +- **FAIL:** LLM вызывается для вынесения/переопределения машинного вердикта гейта; либо триаж-роль + гейтит продвижение. + +--- + +## AC-13 — Наблюдаемость + +**Условие:** Исход раннера виден и различим. +- **PASS:** `GET /queue` содержит read-only блок `test_runner` (`enabled`/`repos`/`target`/`timeout_s`/ + счётчики `runs`/`pass`/`fail`/`tool_error`/`deferred`); на каждый прогон — один структурный + лог-вердикт (`work_item`/`repo`/`exit_code`/`result`/`duration_s`/`outcome`), различающий код-фейл и + tool-error. +- **FAIL:** Нет блока в `/queue`; исход раннера не логируется/не различим. + +--- + +## AC-14 — Норматив сопровождения LLM-карты/политики/витрины + +**Условие:** Документация обновлена в том же PR (правило агентов №2 + норматив ORCH-118). +- **PASS:** `docs/architecture/llm-call-sites.md` (строка A5) / `llm-determinization-roadmap.md` + (rank 2) / `llm-usage-policy.md` отражают реализацию детерминированного tester (инвариант «ровно один + `first_slice = yes`» НЕ нарушен); анти-дрейф-тесты (`tests/test_llm_call_site_inventory.py`, + `tests/test_llm_determinization_docs.py`) зелёные; `.openclaw/agents/tester.md`, + `docs/architecture/README.md`, `CLAUDE.md`, `CHANGELOG.md`, `docs/overview/` обновлены. +- **FAIL:** Карта/политика/roadmap/витрина не обновлены; анти-дрейф-тесты красные (reviewer: ≥P1). + +--- + +## AC-15 — Полный регресс зелёный + +**Условие:** Существующий конвейер не сломан. +- **PASS:** `pytest tests/ -q` зелёный; новый `tests/test_orch116_test_runner.py` зелёный; + зелёные анти-дрейф LLM-тесты. +- **FAIL:** Любой ранее зелёный тест становится красным; новые тесты падают. + +--- + +## Сводная матрица AC ↔ FR/BR +| AC | Покрывает | +|----|-----------| +| AC-1 | BR-1 / FR-1 | +| AC-2 | BR-2 / FR-4 | +| AC-3 | BR-4 / FR-2 / FR-3 | +| AC-4 | BR-3 / FR-5 | +| AC-5 | NFR-2 / FR-6 | +| AC-6 | NFR-1 / FR-7 | +| AC-7 | BR-5 / FR-7 | +| AC-8 | BR-9 / FR-1 / FR-7 | +| AC-9 | NFR-2 / FR-1 / FR-6 | +| AC-10 | BR-7 / FR-2 / FR-4 | +| AC-11 | NFR-3 / NFR-4 / FR-2 | +| AC-12 | BR-8 / NFR-7 / FR-9 | +| AC-13 | BR-6 / FR-8 | +| AC-14 | NFR-6 | +| AC-15 | NFR-5 / NFR-1 | diff --git a/docs/work-items/ORCH-116/04-test-plan.yaml b/docs/work-items/ORCH-116/04-test-plan.yaml new file mode 100644 index 0000000..350f890 --- /dev/null +++ b/docs/work-items/ORCH-116/04-test-plan.yaml @@ -0,0 +1,116 @@ +work_item: ORCH-116 +stage: analysis +author_agent: analyst +status: ready-for-review +created_at: 2026-06-16 +model_used: claude-opus-4-8 +title: "Детерминированный test-раннер вместо LLM-тестера (стадия testing)" +framework: pytest +scope: > + Покрывает Phase 1: перехват tester-джоба на стадии testing до _spawn, исполнение + тест-контракта (pytest через proc_group + опц. read-only smoke), маппинг exit-кода + в result: PASS|FAIL, запись/push 13-test-report.md, инициацию существующего гейта + check_tests_passed, two-level outcome (tool-error DEFER, анти-ORCH-110), kill-switch/ + скоуп/backward-compat для репо без тест-контракта, never-raise/fail-safe, изоляцию + процесса/таймаут (tree-kill), гибрид (LLM не в control-path вердикта), наблюдаемость, + и анти-дрейф инвариант (STAGE_TRANSITIONS/QG_CHECKS/check_tests_passed/_parse_tests_verdict/ + схема БД не тронуты). Вне покрытия: Phase 2 (project test contract для не-self репо, + off-control-path LLM-триаж), ORCH-115 staging/deploy-раннер, LLM-роли reviewer/developer, + живой Claude CLI и живой прод-стенд (мокируются). +notes: > + Тесты не требуют живого Claude CLI или сети: subprocess/pytest-run (proc_group) и + advance_stage мокируются; пьюр-маппинг и рендер frontmatter тестируются напрямую; + smoke-GET мокируются. Полный регресс tests/ должен оставаться зелёным. Анти-дрейф + (TC-09) защищает критический инвариант NFR-1. Эталон реализации/покрытия — + tests/test_orch115_staging_runner.py (ORCH-115). + +tests: + - id: TC-01 + type: unit + description: "applies(repo): enabled=False -> False (откат к LLM); пустой CSV -> True только для orchestrator; непустой CSV -> membership; репо без резолвимого тест-контракта -> False (BR-9 backward-compat); ошибка -> False (never-raise, fail-safe)." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-02 + type: unit + description: "Маппинг exit-кода: 0 -> PASS; 1/2/любой ненулевой -> FAIL; None/нечисло/ошибка запуска -> FAIL (fail-closed). Токены PASS/FAIL согласованы с _parse_tests_verdict; второй несогласованный маппинг не вводится." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-03 + type: unit + description: "Рендер 13-test-report.md: frontmatter содержит result: PASS|FAIL (UPPERCASE) + 52c-схему (work_item/stage=testing/author_agent=test-runner/status/created_at/model_used=n/a); хвост stdout pytest и smoke-итог копируются в тело." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-04 + type: integration + description: "Сгенерированный раннером 13-test-report.md читается НЕИЗМЕНЁННЫМ _parse_tests_verdict -> корректный (bool, reason) для PASS и FAIL (контракт артефакта/гейта check_tests_passed неизменен)." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-05 + type: integration + description: "launch_job перехватывает tester-джоб на стадии testing для in-scope репо ДО _spawn (как D1/D2/ORCH-115): _spawn НЕ вызывается, agent_runs не создаётся, возвращается None, jobs-строка ведётся mark_job. _spawn мокирован." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-06 + type: integration + description: "Дискриминатор: tester-джоб на стадии НЕ testing (защита) и любой не-tester джоб НЕ перехватываются раннером; should_intercept never-raise -> False при DB-сбое (fall-through к _spawn)." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-07 + type: integration + description: "После PASS-вердикта раннер инициирует advance_stage(finished_agent='tester') ровно как завершившийся LLM-tester (advance_stage мокирован/наблюдается) -> check_tests_passed -> testing->deploy-staging; после FAIL — существующий откат testing->development + developer-retry (stage_engine.py:849)." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-08 + type: integration + description: "Kill-switch: test_runner_enabled=False -> на testing для orchestrator вызывается _spawn (прежний LLM-путь байт-в-байт), раннер не активируется." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-09 + type: unit + description: "Анти-дрейф NFR-1: STAGE_TRANSITIONS (src/stages.py), реестр/имена QG_CHECKS, check_tests_passed/_parse_tests_verdict и токены result:/verdict:/status: неизменны; в схеме БД нет новой таблицы/колонки от ORCH-116. Структурная проверка." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-10 + type: integration + description: "Two-level outcome (анти-ORCH-110): сюита НЕ исполнилась (spawn-error/таймаут/returncode None) -> bounded DEFER (re-queue tester-джоба + restart-safe маркер), БЕЗ отката на development и БЕЗ расхода developer-retry; на исчерпании test_runner_infra_max_retries -> fail-closed FAIL + advance + INFRA-alert. Никогда тихий advance/ложный green." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-11 + type: unit + description: "never-raise/fail-safe: pytest-run бросает/таймаутит/worktree-ошибка -> раннер не падает, исход FAIL (fail-closed) или bounded DEFER, никогда тихий advance/ложный green; воркер/очередь не клинятся. Все публичные функции test_runner.py never-raise." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-12 + type: unit + description: "Изоляция/таймаут: pytest исполняется в worktree ветки задачи через proc_group.run_in_process_group (tree-kill); test_runner_timeout_s применяется; малформ/непозитив -> дефолт 900 + WARNING (never-break); reaper_max_running_s не правится." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-13 + type: unit + description: "Self-hosting safety: в командах раннера нет запрещённых литералов (рестарт 8500 / docker compose up orchestrator / --build / force-push main / правки .env); smoke-запросы строго read-only GET (/health,/status,/queue); лог пушится только в фичеветку." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-14 + type: integration + description: "Наблюдаемость + гибрид: GET /queue содержит блок test_runner (enabled/repos/target/счётчики runs/pass/fail/tool_error/deferred); на прогон пишется один структурный лог-вердикт, различающий код-фейл и tool-error; LLM не вызывается для вынесения result: в happy/fail-path." + module: tests/test_orch116_test_runner.py + expected: PASS + + - id: TC-15 + type: integration + description: "Анти-дрейф LLM-карты: llm-call-sites.md (A5)/roadmap (rank 2)/policy обновлены под реализацию (инвариант 'ровно один first_slice=yes' цел); tests/test_llm_call_site_inventory.py и tests/test_llm_determinization_docs.py остаются зелёными после правок." + module: tests/test_llm_call_site_inventory.py + expected: PASS From 74f53b522aca848446fdd101c3ae7cd3630db0ea Mon Sep 17 00:00:00 2001 From: claude-bot Date: Tue, 16 Jun 2026 02:41:50 +0300 Subject: [PATCH 03/16] architect(ET): auto-commit from architect run_id=739 --- .../adr/adr-0049-deterministic-test-runner.md | 115 +++++ .../ADR-001-deterministic-test-runner.md | 471 ++++++++++++++++++ .../ORCH-116/07-infra-requirements.md | 69 +++ .../ORCH-116/08-data-requirements.md | 54 ++ docs/work-items/ORCH-116/10-tech-risks.md | 47 ++ 5 files changed, 756 insertions(+) create mode 100644 docs/architecture/adr/adr-0049-deterministic-test-runner.md create mode 100644 docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md create mode 100644 docs/work-items/ORCH-116/07-infra-requirements.md create mode 100644 docs/work-items/ORCH-116/08-data-requirements.md create mode 100644 docs/work-items/ORCH-116/10-tech-risks.md diff --git a/docs/architecture/adr/adr-0049-deterministic-test-runner.md b/docs/architecture/adr/adr-0049-deterministic-test-runner.md new file mode 100644 index 0000000..c1c878a --- /dev/null +++ b/docs/architecture/adr/adr-0049-deterministic-test-runner.md @@ -0,0 +1,115 @@ +--- +work_item: ORCH-116 +stage: architecture +author_agent: architect +status: proposed +created_at: 2026-06-16 +model_used: claude-opus-4-8 +--- + +# adr-0049: Детерминированный test-раннер — второй реализованный срез determinization-roadmap (tester-гибрид) + +> **Сквозной (cross-cutting) ADR.** Агрегирует решение ORCH-116, влияющее на **весь** +> оркестратор: вводит новый компонент-leaf `src/test_runner.py`, снимает вторую avoidable +> LLM-консультацию из потока управления (`tester`/`result:`, A5) и переводит rank-2 +> determinization-roadmap из «план» в «реализовано». Локальная детализация (все решения +> D1–D12, включая tester-специфичную анти-коллизию `status:` D6.1) — +> `docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md`. + +## Статус +Proposed + +## Контекст + +ORCH-118 ([adr-0047](adr-0047-llm-usage-policy-and-call-site-map.md)) зафиксировал нормативную +политику и карту LLM-консультаций и назвал **avoidable LLM control paths = `{tester, deployer}`**. +Первый срез — **deployer (staging-status, rank 1)** — реализован **ORCH-115** +([adr-0048](adr-0048-deterministic-staging-runner.md)). Второй кандидат — **tester (rank 2, +`needs-hybrid-fallback`, `hybrid_needed = yes`, `first_slice = no`)**. ORCH-116 — его фактическая +реализация. + +Вердикт `result:` на стадии `testing` сейчас эмитит LLM-агент `tester`, но **PASS/FAIL-ядро** есть +**чистый маппинг** exit-кода `pytest` + read-only smoke, а гейт `check_tests_passed` +(`_parse_tests_verdict`) детерминирован и читает **только** frontmatter `result:` (+ legacy +`verdict:`/`status:`). Это удовлетворяет обоим условиям «avoidable»: C-консультация **и** +деривируемый вердикт. **Гибрид-нюанс:** прежний промпт нёс ещё и настоящее суждение (триаж падений, +маппинг TC↔критерии) — поэтому ORCH-116 выносит из потока управления **только PASS/FAIL-исполнителя**, +оставляя LLM допустимым лишь как будущий **off-control-path** триаж (Phase 2, не control-path). + +Прецедент детерминированной замены агента (`launch_job`-перехват до `_spawn`, D1/D2 + +**рабочий эталон `src/staging_runner.py`** ORCH-115) и эталон «детерминированный джоб → `advance_stage`» +уже в проде — архитектурный риск замены снят. + +## Решение + +**Новый leaf `src/test_runner.py` + перехват в `launch_job` до `_spawn`** (рядом с D1/D2/ORCH-115). +На `testing` для in-scope репо с резолвимым тест-контрактом джоб `tester` обрабатывает раннер: +исполняет регресс `pytest ` **в worktree ветки** через `proc_group` (tree-kill, ORCH-110) + +опциональный read-only smoke, маппит exit-код единым контрактом `self_deploy.map_exit_code_to_status` +(транслируя токены в `PASS`/`FAIL`), пишет `13-test-report.md` (тот же machine-key `result:`), +best-effort пушит лог в фичеветку, вызывает **существующий** `advance_stage(current_stage="testing", +finished_agent="tester")`. + +Кросс-каттинговые инварианты (сохранены **байт-в-байт**): +- `STAGE_TRANSITIONS` (`src/stages.py`), реестр и имена `QG_CHECKS`/`check_tests_passed`/ + `_parse_tests_verdict`/прочих `check_*`/`_parse_*`, machine-verdict-ключи (`result:`/`verdict:`/ + `status:`/`staging_status:`/`deploy_status:`/`security_status:`/`coverage_status:`), **схема БД** — + не тронуты. Это замена *продюсера* артефакта, не гейта/стадии. +- Единственный транспорт LLM-консультации (`launcher._spawn`/S0, + [llm-usage-policy.md](../llm-usage-policy.md) §5) — соблюдён: раннер **не зовёт LLM**; второй + транспорт не вводится; будущий off-control-path триаж — вне control-path (не контр-пример политике). +- Сквозной бюджет времени ORCH-065/109/110 (`reaper_max_running_s` (5400) > Σ(работ на ребре)) — + соблюдён **без** правки `reaper_max_running_s`: ребро `testing` отдельно от `deploy-staging`, окно + раннера ≤900s ≤ прежнего LLM-окна `agent_timeout_seconds` (1800s). +- Граница ORCH-112/ORCH-114/ORCH-115: transition-lease берётся **внутри** `advance_stage`; раннер + lease/гигиену/`staging_runner` не модифицирует. + +Скоуп — **self-hosting only** (`test_runner_repos=""` → `is_self_hosting_repo` + резолв +тест-контракта `_has_test_contract`, в Phase 1 = self-hosting), под kill-switch +`test_runner_enabled` (off → `_spawn` LLM-tester'а байт-в-байт). never-raise во всех публичных +функциях; **двухуровневый исход** (verdict при исполнившейся сюите; bounded defer → fail-closed на +tool-error/таймауте) убирает с `testing`-ребра RCA-класс ORCH-110 (инфра ≠ код-фейл). +**Backward-compat (BR-9):** репо без резолвимого тест-контракта → `applies==False` → прежний +LLM-tester (enduro-trails не затронут). + +**Tester-специфичная анти-коллизия (D6.1 локального ADR, отсутствует в ORCH-115):** +`_parse_tests_verdict` читает вердикт из **трёх** полей (`verdict:`/**`status:`**/`result:`) с +negative-token-priority — поэтому обязательное 52c-поле `status:` раннера **жёстко выровнено** по +вердикту (`success` для PASS / `failed` для FAIL), иначе негативный токен в `status:` при `result: +PASS` дал бы ложный FAIL. Зафиксировано unit-тестом через неизменённый парсер. + +**Эволюция карты LLM (норматив сопровождения, в том же PR — D12 локального ADR):** +`llm-call-sites.md` (A5 → реализовано детерминированно, но `avoidable=yes`/`axis=C`/ +`needs-hybrid-fallback` сохранены — LLM-ветвь как fallback / будущий off-control-path триаж), +`llm-determinization-roadmap.md` (rank 2 tester → реализован; **инвариант «ровно один +`first_slice = yes`» цел** — `first_slice` остаётся у rank 1/deployer, у tester — `no`), +`llm-usage-policy.md` (§5 — транспорт не нарушен), плюс анти-дрейф-тесты +(`test_llm_call_site_inventory.py`/`test_llm_determinization_docs.py`). Эти правки коуплены к коду → +применяются в development атомарно с реализацией, не в architecture-стадии (как ORCH-115). + +## Последствия + +- **+** Минус ещё один avoidable LLM control path; второй доказанный раннер-паттерн (теперь и для + `needs-hybrid-fallback`-кандидата, не только `replace-deterministic-now`). +- **+** Дешевле/быстрее/детерминированнее собственный `testing`; нет токенов/латентности LLM в точке + ветвления `testing → deploy-staging` / `testing → development`. +- **+** Паттерн остаётся переиспользуемым: leaf + перехват до `_spawn` + `advance_stage` — шаблон для + Phase 2 (project test contract не-self репо + опциональный off-control-path LLM-триаж). +- **+** Гибрид-граница (D11 локального ADR): архитектура не закрывает будущий off-control-path триаж, + не пуская LLM обратно в поток управления вердикта. +- **−** Новый компонент + врезка + defer-механика + tester-специфичная анти-коллизия `status:`. + Митигейшн: never-raise leaf, kill-switch (fail-safe к LLM), без схемы БД, инвариант выравнивания + `status:` + структурное покрытие `tests/test_orch116_test_runner.py`. +- **Откат:** `ORCH_TEST_RUNNER_ENABLED=false` → прежний LLM-путь на `testing` байт-в-байт. + +## Ссылки +- Локальный ADR: `docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md` +- Первый срез: [adr-0048](adr-0048-deterministic-staging-runner.md) (ORCH-115, `src/staging_runner.py`) +- Политика/карта/roadmap: [llm-usage-policy.md](../llm-usage-policy.md), + [llm-call-sites.md](../llm-call-sites.md) (A5), + [llm-determinization-roadmap.md](../llm-determinization-roadmap.md) (rank 2), + [adr-0047](adr-0047-llm-usage-policy-and-call-site-map.md) +- Прецеденты: D1/D2 (`launcher.py:397/402`), `_run_staging_runner_job` (`launcher.py:438`), + `run_staging_gate` (`staging_runner.py`), `proc_group` (ORCH-110, + [adr-0042](adr-0042-merge-gate-retest-infra-tolerance-and-tree-kill.md)), + transition-lease (ORCH-114, [adr-0045](adr-0045-transition-ownership-lease-and-stage-cas.md)) diff --git a/docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md b/docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md new file mode 100644 index 0000000..2f682fd --- /dev/null +++ b/docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md @@ -0,0 +1,471 @@ +--- +work_item: ORCH-116 +stage: architecture +author_agent: architect +status: proposed +created_at: 2026-06-16 +model_used: claude-opus-4-8 +--- + +# ADR-001: Детерминированный test-раннер вместо LLM-тестера на стадии `testing` + +Work Item: **ORCH-116** — заменить LLM-агента `tester` на стадии `testing` +(self-hosting `orchestrator`) детерминированным test-раннером (второй срез +determinization-roadmap, **rank 2 / tester-гибрид**). +Стадия: **architecture** +Сквозная регистрация: **`docs/architecture/adr/adr-0049-deterministic-test-runner.md`** +(решение кросс-каттинговое — вводит новый компонент-leaf `src/test_runner.py` и реализует +второй срез determinization-roadmap; влияет на карту LLM-консультаций всего оркестратора). + +## Статус +Proposed + +## Контекст + +Стадию `testing` сейчас исполняет **LLM-агент `tester`**. Маршрутизация (сверено по коду +`src/stages.py:17-18`): + +```python +"review": {"next": "testing", "agent": "tester", "qg": "check_reviewer_verdict"}, +"testing": {"next": "deploy-staging", "agent": "deployer", "qg": "check_tests_passed"}, +``` + +То есть `tester` — **единственный** агент, запускаемый при входе в `testing` (поле `agent` +ребра `review → testing`); гейт выхода из `testing` — `check_tests_passed`. Фактическая работа +агента на этой стадии в happy-path — **в основном детерминированная** (`.openclaw/agents/tester.md`): +прогнать регресс `pytest tests/` в worktree ветки, сделать read-only smoke (`/health`, `/status`, +`/queue` + наличие блока `serial_gate`), смаппить exit-код, записать `13-test-report.md` с +машинным frontmatter `result: PASS|FAIL`. + +Вердикт `result:` потребляется **детерминированным** гейтом `check_tests_passed` +(`src/qg/checks.py:182` → `_parse_tests_verdict:226`), который читает **только** YAML-frontmatter +(`result:` канонический + legacy `verdict:`/`status:`, ORCH-047) — **не** прозу и **не** покрытие +TC. По нормативной политике (`docs/architecture/llm-usage-policy.md`) это **avoidable LLM control +path**: (i) C-консультация (вердикт `result:` ветвит гейт) **и** (ii) вердикт **деривируем** из +exit-кода `pytest` + smoke. Карта (`docs/architecture/llm-call-sites.md`, строка **A5**) +классифицирует tester как **`needs-hybrid-fallback`**; roadmap +(`llm-determinization-roadmap.md`, машинный блок §4) ставит его **rank 2** (`hybrid_needed = yes`, +`first_slice = no`). ORCH-116 — реализация этого второго среза (первый, **ORCH-115/deployer**, +уже реализован — `src/staging_runner.py`). + +**Гибридная природа (ключевое отличие от ORCH-115).** Tester — `needs-hybrid-fallback`, не +`replace-deterministic-now`: его **PASS/FAIL-ядро** полностью детерминируемо (exit-код pytest + +smoke), но прежний промпт нёс ещё и **настоящее суждение** — триаж падений, анализ пробелов +покрытия AC, сопоставление TC ↔ критерии приёмки, человекочитаемую диагностику. ORCH-116 выносит +из потока управления **только PASS/FAIL-исполнителя** (его делает детерминированный код); LLM на +стадии `testing` остаётся допустимым лишь как **off-control-path** триаж/диагностика **после** +детерминированного провала и **никогда** как первичный исполнитель вердикта гейта (BR-8 / NFR-7). +В Phase 1 off-control-path-триаж **не реализуется**, но архитектура его **не запрещает**. + +**Установленные факты (сверено по коду, не изобретать):** +- Детерминированный прецедент замены агента **до `_spawn`** работает в проде: `launch_job` + перехватывает `deploy-finalizer` (D1, `src/agents/launcher.py:397`), `post-deploy-monitor` + (D2, `:402`) и **staging-runner** (ORCH-115, `:404-408`) до `_spawn`; `_run_staging_runner_job` + (`:438`) — тонкая обёртка, синхронно ведущая `jobs`-строку через `mark_job` и возвращающая `None`. +- **Эталон leaf-раннера** — `src/staging_runner.py` (ORCH-115): two-level outcome, never-raise, + kill-switch + скоуп-CSV, `proc_group`, маппинг exit-кода единым контрактом, best-effort push в + фичеветку, инициация гейта через `advance_stage`, in-process счётчики. ORCH-116 — его зеркало для + роли `tester` / стадии `testing`. +- Гейт `check_tests_passed` (`src/qg/checks.py:182`) читает `13-test-report.md` через + `_repo_path(repo, branch)` (`:15`), который **читает per-branch worktree первым** (если каталог + существует), иначе — общий клон. Значит worktree-записанный файл читается напрямую — **отдельный + merge лога в `main` не нужен**. +- FAIL-маршрут существует и зафиксирован: `src/stage_engine.py:849` — + `if agent == "tester" and qg_name == "check_tests_passed"` → откат `testing → development` + + `extract_test_failures` + `enqueue_job("developer", …)` (cap `MAX_DEVELOPER_RETRIES=3`, + `:862-892`). Ветвь матчит по `agent == "tester"` — раннер обязан инициировать гейт с + `finished_agent="tester"`. +- Tree-kill subprocess'а под таймаутом готов: `proc_group.run_in_process_group` (ORCH-110, + stdlib-only, never-raise, fallback к `subprocess.run`). pytest уже исполняется в worktree через + него в coverage-gate (ORCH-027) и merge-gate re-test (ORCH-110) — тот же контейнер, без новых + зависимостей образа. +- Пьюр-маппинг exit-кода готов: `self_deploy.map_exit_code_to_status` (`0→SUCCESS`, иначе/None/ + нечисло→`FAILED`, fail-closed, unit-tested). ORCH-116 переиспользует его, транслируя токены в + `PASS`/`FAIL`. + +«Как есть» не годится: каждый прогон tester'а тратит токены/время opus-агента (по `agent_runs`: +~60–150k / 5–20 мин на прогон) ради действия = один прогон pytest + несколько read-only GET, +встраивает недетерминизм LLM в точку ветвления `testing → deploy-staging` / `testing → development` +и принадлежит к RCA-классу «LLM принял решение, которое есть исполнение фиксированных команд + +маппинг результата» (ORCH-110/111/112/113/114/117/115). + +## Решение + +### Сводка + +Ввести **новый leaf `src/test_runner.py`** (never-raise, по образцу `staging_runner.py`/ +`self_deploy.py`/`proc_group.py`) и **перехват в `launch_job` до `_spawn`** (рядом с D1/D2/ORCH-115). +Когда на стадии `testing` для in-scope репо с тест-контрактом к запуску приходит джоб `tester`, его +обрабатывает раннер: исполняет «тест-контракт» (регресс `pytest ` в worktree ветки через +`proc_group` + опциональный read-only smoke), маппит exit-код в `result:` (`0→PASS`, иначе `FAIL`), +пишет `13-test-report.md`, best-effort пушит лог в фичеветку, и вызывает **существующий** +`advance_stage(current_stage="testing", finished_agent="tester")` — ровно как завершившийся +LLM-tester. Контракт артефакта, гейт `check_tests_passed`/`_parse_tests_verdict`, `STAGE_TRANSITIONS`, +схема БД — **байт-в-байт неизменны** (это замена *продюсера* артефакта, не гейта). Под kill-switch + +скоуп-CSV + резолв тест-контракта; never-raise; fail-closed; two-level outcome (анти-ORCH-110); +fail-safe к прежнему LLM-пути. + +### D1 — Точка диспетчеризации: перехват в `launch_job` **до** `_spawn` (FR-1 / AC-1) + +В `launcher.launch_job`, рядом с врезками D1/D2/ORCH-115, **до** `_spawn`: + +```python +if job.get("agent") == "tester": + from .. import test_runner + if test_runner.should_intercept(job): + return self._run_test_runner_job(job) +``` + +- **Дискриминатор перехвата — роль `tester` + стадия задачи + `applies(repo)`.** + `should_intercept(job)` истинно ⇔ `agent == "tester"` **И** `applies(job["repo"])` **И** + `tasks.stage` (по `job["task_id"]`) `== "testing"`. +- **Отличие от ORCH-115 (важно, R-1).** Роль `deployer` была **общей** для `deploy-staging` и + `deploy`, поэтому гард по стадии у staging-раннера был обязателен для дизамбигуации «staging vs + prod». Роль `tester` исполняет **только** стадию `testing` (единственный `agent` входа в `testing`, + `STAGE_TRANSITIONS["review"]["agent"]`), коллизии стадий нет — но гард `tasks.stage == "testing"` + сохраняется как **defense-in-depth** (симметрия с ORCH-115 + защита от перехвата случайного + будущего `tester`-джоба вне `testing`). +- `should_intercept` / `applies` — **never-raise → False**: любая ошибка (DB-lookup упал) → провал в + `_spawn` (fail-safe к прежнему LLM-пути). +- `_run_test_runner_job(job)` — тонкая обёртка-зеркало `_run_staging_runner_job` (`:438`): + синхронно зовёт `test_runner.run_test_gate(job)`, затем `mark_job(job["id"], "done")`; любое + исключение → `mark_job(..., "failed", error=…)`; возвращает `None` (нет `agent_runs`-строки, + `_spawn` не вызывается, токены LLM не тратятся). + +### D2 — Размещение логики: чистый leaf `src/test_runner.py` (зеркало `staging_runner`) + +`run_test_gate(job)` живёт в leaf'е и владеет полным детерминированным потоком (зеркало +`staging_runner.run_staging_gate`): +1. поднять `work_item_id`/`branch` по `task_id`; +2. исполнить тест-контракт (D3) → `ProcResult` (pytest) + smoke-итог; +3. определить исход (D5); +4. на verdict-исходе: записать `13-test-report.md` (D6) и вызвать + `advance_stage(finished_agent="tester")` (D7); +5. на tool-error-исходе: bounded DEFER (D5); +6. учесть счётчики + структурный лог (D10). + +**Чистота leaf'а:** импортирует на уровне модуля только `config`, `logging` (+ `proc_group`); +лениво (внутри функций) — `db`/`git_worktree`/`self_deploy.map_exit_code_to_status`/ +`qg.checks.is_self_hosting_repo`/`stage_engine.advance_stage`/`notifications`. Лениво — чтобы не +тащить тяжёлый `stage_engine` на импорте и не плодить цикл (паттерн `staging_runner`/ +`transition_lease`/`merge_gate`). Все публичные функции — **never-raise** (AC-9). + +### D3 — Исполнение тест-контракта: pytest (в worktree) + опц. smoke через `proc_group` (FR-2 / NFR-3 / AC-10 / AC-11) + +**Тест-контракт = (обязательная регресс-команда) + (опциональный read-only smoke).** + +- **Регресс:** `python -m pytest ` (дефолт `tests/`, конвенция + `merge_retest_target`) исполняется **в worktree ветки задачи** — + `git_worktree.get_worktree_path(repo, branch)`, **НЕ** в общем `/repos/orchestrator` (анти + checkout-гонка, как требовал промпт tester шаг 2; тот же контекст, что coverage-gate/merge-gate + re-test) — через `proc_group.run_in_process_group(argv, cwd=, timeout=, + grace_s=agent_kill_grace_seconds, tree_kill=subprocess_tree_kill_enabled)` → SIGTERM→grace→SIGKILL + всего дерева на таймауте, без сирот pytest (корень ORCH-109/110/111 закрыт). Захватывает exit-код и + stdout (для тела отчёта/observability). +- **Опциональный smoke** (`test_runner_smoke_enabled`, дефолт `True`; зеркало шага 3 промпта tester): + read-only `GET` против запущенного оркестратора (base URL из config — host-параметризация ORCH-101, + без host-хардкодов): `/health`, `/status`, `/queue` + проверка **наличия** блока `serial_gate` в + ответе `/queue`. **Smoke строго read-only** (BR-7/AC-10): никаких мутирующих запросов. +- **Итоговый verdict-токен** = `PASS` ⇔ (exit-код pytest == 0 по маппингу D4) **И** smoke прошёл + (если включён); иначе `FAIL`. Smoke-провал → `FAIL` (детерминированно, FR-2). +- **Анти-флап smoke (уточнение архитектора):** транзиентная **недостижимость** smoke-эндпоинта + (connection refused / таймаут на единичном GET) ретраится **ограниченно** внутри smoke-шага + (несколько быстрых GET с коротким backoff) перед выводом `FAIL`; «достижимо, но форма неверна» + (не-200 / нет блока `serial_gate`) → немедленный `FAIL`. Это снижает риск, что разовый блип + прод-8500 откатит здоровую ветку, не вводя нового исхода (на исчерпании smoke-ретраев — обычный + `FAIL`, поглощаемый developer-retry-cap). Гард `test_runner_smoke_enabled` позволяет отключить + smoke, если он окажется шумным, без отката всего раннера. + +**Self-hosting safety (BR-7 / AC-10):** в argv раннера нет литералов рестарта 8500 / +`docker compose up … orchestrator` / `--build` / force-push / правок `.env`/`docker-compose.yml`. +Раннер только исполняет pytest в worktree и делает read-only GET. Покрывается тестом запрета +литералов в его командах (зеркало TC ORCH-115). + +### D4 — Маппинг exit-кода → `result:`: переиспользовать единый контракт (FR-3 / AC-3) + +`result`-токен = трансляция `self_deploy.map_exit_code_to_status(returncode)`: +`SUCCESS → "PASS"`, `FAILED → "FAIL"` (т.е. `0 → PASS`; ненулевой / None / нечисло → `FAIL`, +fail-closed). **Второй несогласованный маппинг не вводится** — переиспользуется тот же пьюр-контракт +(`0→SUCCESS`-семантика, unit-tested), что у deploy-finalizer и staging-runner (BR-4). Разница лишь в +токенах (`result:` использует `PASS`/`FAIL`, а не `SUCCESS`/`FAILED`; `_TESTS_POSITIVE_TOKENS`/ +`_TESTS_NEGATIVE_TOKENS`, `src/qg/checks.py:222-223`) — тонкая обёртка-транслятор поверх единого +маппера, не дубль логики. Smoke-результат **AND**-ится в итог отдельно (D3), exit-маппинг остаётся +чистой функцией одного входа (покрыт unit-тестом на каждый класс: `0`/≠0/`None`/нечисло). + +### D5 — Двухуровневый исход: verdict vs tool-error (NFR-2 / AC-5 / R-4) — **ключевое решение** + +Выбран **двухуровневый исход** (зеркало `staging_runner` D5, анти-ORCH-110): + +- **Сюита ИСПОЛНИЛАСЬ** (`returncode is not None` и **не** `timed_out`) → доверяем коду: маппинг D4 + (+ smoke D3) → `result:` → инициировать гейт (D7). `PASS → testing → deploy-staging`; + `FAIL → существующий откат testing → development` + developer-retry (тот же путь и cap + `MAX_DEVELOPER_RETRIES`, что у FAIL-вердикта LLM — `stage_engine.py:849-892`; R-5/AC-4). +- **Сюита НЕ исполнилась** (tool-error: spawn-error / таймаут / `returncode is None`) — это + **инфра-сбой, а не код-фейл**. Раннер делает **ограниченный DEFER**: re-queue свежего **`tester`**-джоба + с задержкой `test_runner_infra_retry_delay_s` и **restart-safe маркером** `test-runner infra-retry` + в `task_content` (счётчик — `COUNT(*)` маркера в persisted `jobs`, зеркало + `staging_runner._infra_retry_count` / `stage_engine._merge_infra_retry_count`; **без правки схемы + БД**, NFR-1). На **исчерпании** бюджета (`test_runner_infra_max_retries`) — **fail-closed**: + записать `result: FAIL` + `advance_stage` (существующий откат) + один INFRA-alert (кликабельный + номер, явно «инфра, НЕ дефект кода»). Так раннер **никогда** не делает тихий advance / ложный green + и **никогда** не клинит очередь навсегда, но **не жжёт developer-retry на транзиентной инфре**. + +**Почему не «tool-error → немедленный FAIL-откат»:** это в точности анти-паттерн ORCH-110 +(инфра-таймаут, ошибочно маршрутизированный как код-фейл → откат на `development` + расход +developer-retry; на следующем retry падает так же → ручное вмешательство). Пьюр-маппинг D4 остаётся +fail-closed (None→FAIL) — это терминальный fallback **на исчерпании** defer, а не реакция на первый +же tool-error. **DEFER re-queue'ит `tester`-джоб** (не `deployer`!) — он повторно входит в этот же +раннер. + +### D6 — Артефакт `13-test-report.md`: зеркало `write_staging_log` (FR-4 / AC-2 / AC-10) + +Раннер пишет `docs/work-items//13-test-report.md` в worktree фичеветки +(`git_worktree.get_worktree_path`) литеральным блоком (как `staging_runner.build_staging_log`), +чтобы машинно-читаемый frontmatter был байт-точным: + +```markdown +--- +result: PASS # или FAIL — UPPERCASE, имя/регистр/токены ключа НЕ меняются +work_item: +stage: testing +author_agent: test-runner +status: success # или failed — ВЫРОВНЕН по result (см. D6.1!) +created_at: +model_used: n/a +exit_code: +smoke: +--- + +# Test Gate Log (deterministic runner, ORCH-116) + +``` + +- `author_agent: test-runner` / `model_used: n/a` честно отражают **детерминированного** продюсера; + **machine-key `result:` и его UPPERCASE-значения/токены не меняются** (AC-2), читается + неизменённым `_parse_tests_verdict`. +- Обязательная 52c-схема присутствует (`work_item`/`stage: testing`/`author_agent`/`status`/ + `created_at`/`model_used`). +- **Best-effort `git add/commit/push` в ФИЧЕВЕТКУ** (git-identity ORCH-101, актор `test-runner`, + `_GIT_TIMEOUT`). Гейт читает worktree **первым** (`_repo_path:22-25`), поэтому **отдельный + PR-merge лога в `main` НЕ выполняется** — исключение любой прямой работы с `main` усиливает + AC-10/BR-7. Итоговый мерж фичеветки в `main` идёт штатным merge-gate/merge-verify-путём позже. + +#### D6.1 — Анти-коллизия 52c-`status:` ↔ парсер вердикта (**специфично для tester, отсутствует в ORCH-115**) + +**Сверено по коду:** `_parse_tests_verdict` (`src/qg/checks.py:263-277`) читает вердикт из **трёх** +равноранговых полей — `verdict:`, **`status:`** и `result:` — и применяет **negative-token-priority**: +любой негативный токен (`BLOCKED`/`FAILED`/`FAIL`/`REQUEST_CHANGES`/`REJECT`/`RED`) в `f"{verdict} +{status} {result}"` делает вердикт `False` авторитетно. У staging-гейта (ORCH-115) такой коллизии +**не было**: `_parse_staging_status` читает только `staging_status:`, а 52c-`status:` ему безразличен. +Здесь 52c-обязательное поле `status:` **читается тем же парсером, что и `result:`**. + +**Следствие-мина:** если 52c-`status:` принимает значение, чей UPPERCASE содержит негативный токен +(например `status: failed` → `"FAILED"`), при `result: PASS` парсер вернёт `False` (негативный токен +авторитетнее) — **ложный FAIL** здорового прогона. + +**Решение (инвариант):** 52c-`status:` раннера **ВСЕГДА выровнен по вердикту** и **никогда не +противоречит** `result:`: +- `result: PASS` → `status: success` (`"SUCCESS"` — не позитивный и **не** негативный токен; + положительный токен `PASS` берётся из `result:` → парсер даёт `True`); +- `result: FAIL` → `status: failed` (`"FAILED"` — негативный токен, согласован с `FAIL` → `False`). + +Это **тот же приём**, что `staging_runner.build_staging_log` (`status: success|failed` выровнен по +verdict'у) — но здесь он **обязателен по корректности**, а не косметика. Анти-дрейф: unit-тест, +проверяющий `_parse_tests_verdict(<тело раннера для PASS>) == (True, …)` и +`(<тело для FAIL>) == (False, …)` **через неизменённый парсер** (фиксирует, что 52c-`status:` не +ломает вердикт). Reviewer ловит любой `status:`-литерал с негативным токеном при `result: PASS` как +finding ≥P1. + +### D7 — Инициация существующего гейта (FR-5 / AC-4 / R-2, граница O1) + +После записи (и best-effort push) раннер вызывает: +```python +advance_stage(task_id, current_stage="testing", repo, work_item_id, branch, + finished_agent="tester") +``` +Это запускает `check_tests_passed` (`_parse_tests_verdict` читает `result:` из `13-test-report.md`): +- `PASS` → продвижение `testing → deploy-staging` (и далее под-гейты ORCH-022/043/027/058 на ребре + `deploy-staging → deploy` — **их раннер не трогает**); +- `FAIL` → существующий откат `testing → development` + developer-retry (`stage_engine.py:849`). + +**`finished_agent="tester"` обязателен** (R-2): FAIL-ветвь матчит по `agent == "tester" and +qg_name == "check_tests_passed"` (`:849`); иной/`None` агент не запустит откат. **Никакой новой +ветви маршрутизации, никаких новых рёбер/исходов** (AC-4). **Граница O1:** transition-lease ORCH-114 +берётся **внутри** `advance_stage` на side-effectful переходе — раннер его **не трогает**; +serial-gate ORCH-088 не взаимодействует (гейтит analyst-job claim). Код ORCH-112/ORCH-114/ORCH-115 +(`staging_runner`) **не модифицируется**. never-raise. + +### D8 — Kill-switch, скоуп и резолв тест-контракта: обратимость + backward-compat (FR-7 / AC-7 / AC-8 / BR-5 / BR-9) + +`config.py` (паттерн `staging_runner_*`/`coverage_gate_*`): +- `test_runner_enabled: bool = True` (env `ORCH_TEST_RUNNER_ENABLED`). +- `test_runner_repos: str = ""` (env `ORCH_TEST_RUNNER_REPOS`; CSV; **пусто → self-hosting only** + через `is_self_hosting_repo`). +- `test_runner_target: str = "tests/"` (env `ORCH_TEST_RUNNER_TARGET`; pytest-таргет, конвенция + `merge_retest_target`). +- `test_runner_timeout_s: int = 900` (env `ORCH_TEST_RUNNER_TIMEOUT_S`; см. D9). +- `test_runner_smoke_enabled: bool = True` (env `ORCH_TEST_RUNNER_SMOKE_ENABLED`). +- `test_runner_infra_max_retries: int = 2`, `test_runner_infra_retry_delay_s: int = 30` + (defer-бюджет D5; зеркало `staging_runner_infra_*`). + +`applies(repo)` (локально, без сети, **never-raise → False**) — **проверяется первым** в +`should_intercept` (нулевой оверхед при выключенном флаге): +```text +1. test_runner_enabled == False -> False (откат к LLM-пути) +2. in_scope = (membership в test_runner_repos) если CSV непуст + = is_self_hosting_repo(repo) если CSV пуст + not in_scope -> False +3. _has_test_contract(repo) -> резолв тест-контракта (BR-9) +``` +**`_has_test_contract(repo)` (BR-9 / AC-8) — отличие от ORCH-115.** У staging-раннера тест-контракт +был неявно self-hosting-bound (staging-контейнер существует только для `orchestrator`), отдельной +проверки не требовалось. Здесь резолв контракта вынесен явно: в **Phase 1** контракт известен по +умолчанию **только** для self-hosting (`return is_self_hosting_repo(repo)` — pytest+smoke); +для прочих репо контракта нет, пока не сконфигурирован (Phase 2) → `applies == False` → +**прежний LLM-tester** (fail-safe). Это делает AC-8 проверяемым: даже если в `test_runner_repos` +руками добавить не-self репо (`enduro-trails`), `_has_test_contract` вернёт `False` → раннер его не +перехватит → LLM-tester. enduro-trails и любой репо без контракта — 1:1 как до ORCH-116. + +Откат = `ORCH_TEST_RUNNER_ENABLED=false` → `applies()` → `False` → `should_intercept` → `False` → +штатный `_spawn` прежнего LLM-tester'а на `testing` **байт-в-байт**. + +### D9 — Бюджет времени (NFR-4 / AC-11, сквозной инвариант ORCH-065/109/110) + +`test_runner_timeout_s = 900` (дефолт; малформ/непозитив → дефолт + WARNING, never-break — зеркало +`staging_runner._resolve_timeout` / `merge_gate._resolve_retest_timeout`). Обоснование **без правки +`reaper_max_running_s` (5400)**: + +- **Ребро `testing` отдельно от ребра `deploy-staging`.** Гейт выхода из `testing` — + `check_tests_passed` (читает файл, мгновенно). Окно «running» одного `tester`-джоба = только + pytest+smoke (≤900s); тяжёлые под-гейты (security/merge re-test/coverage/image-freshness) живут на + ребре `deploy-staging → deploy`, **не** на `testing`. +- **Σ(работ на ребре `testing`) НЕ растёт.** Прежний LLM-tester шёл под `agent_timeout_seconds` + (сверено `config.py:159` = **1800s**; tester не имеет выделенного per-role ключа, в отличие от + developer=3600/reviewer=3000). Раннер заменяет ≤1800s LLM-окно ограниченными ≤900s → + `reaper_max_running_s (5400) > 900 + grace` сохранён **без** изменения reaper'а. Выбор 900s + согласован с фактической длительностью регресс-сюиты (~517s, инцидент ORCH-110) и даёт ~74% запаса — + тот же запас, что merge-retest-бюджет ORCH-110. + +### D10 — Наблюдаемость (FR-8 / AC-13 / BR-6) + +In-process счётчики `_TEST_RUNNER_COUNTERS` (зеркало `_STAGING_RUNNER_COUNTERS` / +`_MERGE_GATE_COUNTERS`): `runs`/`pass`/`fail`/`tool_error`/`deferred`. Read-only блок `test_runner` в +`GET /queue` (`enabled`/`repos`/`target`/`timeout_s`/`infra_max_retries`/счётчики) — `src/main.py`, +аддитивно, существующие ключи не трогаются. Один структурный лог-вердикт на прогон: +`work_item`/`repo`/`exit_code`/`result`/`duration_s`/`outcome` — различает «код упал» (`FAIL` от +сюиты/smoke) и «инструмент недоступен» (`tool_error`/`deferred`). Новых мутирующих эндпоинтов нет; +откат — через env-флаг. + +### D11 — Гибрид: LLM строго off-control-path (BR-8 / NFR-7 / FR-9 / AC-12) + +В Phase 1 на стадии `testing` (in-scope) вердикт `result:` производит **только** детерминированный +раннер; LLM **не вызывается** в потоке управления вердикта (ни happy-path, ни fail-path). Архитектура +раннера **не запрещает** будущий **опциональный off-control-path** LLM-триаж/диагностику **после** +детерминированного FAIL — но он будет **отдельной ролью/джобом**, который **не пишет и не +переопределяет** `result:` и **не добавляет ребро** в `STAGE_TRANSITIONS`. В этом срезе он **не +реализуется**. Это сохраняет `needs-hybrid-fallback`-природу A5: детерминированное ядро + (будущий) +LLM-фолбэк только на суждение. + +### D12 — Норматив сопровождения LLM-карты/политики/витрины (NFR-6 / AC-14) — спека для developer + +Карта/политика/roadmap и их анти-дрейф-тесты **связаны с состоянием кода**, поэтому правятся +**в development-стадии атомарно с кодом** (иначе тесты покраснеют на полу-готовой ветке — это же +причина, по которой ORCH-115 не правил их в architecture; зеркало ORCH-115 D11). README/internals/ +паспорт/чейнджлог/витрина — там же. Архитектура фиксирует **точную спеку** правок (developer +применяет в том же PR): + +- `docs/architecture/llm-call-sites.md` — строка **A5** и машинный `ORCH-118-INVENTORY-BLOCK`: + tester на `testing` для in-scope репо больше не консультирует LLM в потоке управления; отразить + реализованное детерминированное состояние (раннер-перехват до `_spawn`, как D1/D2), **сохранив** + `avoidable=yes`/`axis=C`/`classification=needs-hybrid-fallback` (LLM-ветвь жива как fallback под + выключенным флагом / для не-self репо / как будущий off-control-path триаж) — **зеркало** того, как + ORCH-115 обновил A6/deployer. Заголовок таблицы и `output_consumer = _parse_tests_verdict` не + менять (имя гейта/парсера неизменно). +- `docs/architecture/llm-determinization-roadmap.md` — §2 (tester) и машинный + `ORCH-118-ROADMAP-BLOCK` rank 2: «второй кандидат» → «реализован (ORCH-116)». **Инвариант «ровно + один `first_slice = yes`» держать корректным** — `first_slice` остаётся `yes` у **rank 1 + (deployer)**, у rank 2 (tester) — `no`; **не переключать** (см. + `test_llm_determinization_docs.py`). `hybrid_needed = yes` у tester сохраняется (гибрид-природа). +- `docs/architecture/llm-usage-policy.md` — §5: единственный транспорт LLM-консультации + (`_spawn`/S0) не нарушен; раннер LLM не зовёт; будущий off-control-path триаж — **не** новый + транспорт control-path-консультации (он вне control-path). +- Анти-дрейф `tests/test_llm_call_site_inventory.py` / `tests/test_llm_determinization_docs.py` — + обновить ожидания синхронно, держать зелёными (AC-14). +- Прочие docs того же PR (правило агентов №2 + витрина ORCH-011): `.openclaw/agents/tester.md` + (пометка, что на `testing` для in-scope репо стадию ведёт детерминированный код; LLM-ветвь — + fallback под выключенным флагом / для репо без контракта; канон промпта 52d — 5 секций, ключ + `result:` — байт-в-байт), `docs/architecture/README.md` (новый компонент **Test-runner** в + карте — зеркало записи **Staging-runner** + отметка «второй срез реализован» в блоке roadmap), + `docs/architecture/internals.md` (примечание о перехвате на `testing`, рядом с ORCH-115), + `CLAUDE.md`, `CHANGELOG.md`, `docs/overview/`. + +**Обоснование против `llm-usage-policy.md` §5:** ORCH-116 **снимает** C-консультацию с деривируемым +PASS/FAIL-ядром (A5/tester) — это разрешённая реализация `needs-hybrid-fallback`, не ввод новой +LLM-консультации; политика соблюдена. + +## Альтернативы + +- **Новая стадия / новый QG для детерминированного testing** — отвергнуто: нарушает NFR-1 + (`STAGE_TRANSITIONS`/`QG_CHECKS` байт-в-байт). Меняется только *продюсер* артефакта; гейт и ребро + прежние. +- **tool-error → немедленный `FAIL`-откат на `development`** — отвергнуто: анти-паттерн ORCH-110 + (инфра-сбой как код-фейл → расход developer-retry → петля). Выбран двухуровневый исход D5. +- **Свой второй exit-code→verdict маппинг** — отвергнуто: переиспользуем + `self_deploy.map_exit_code_to_status` (BR-4, единый контракт), тонкий транслятор токенов поверх. +- **52c-`status:` произвольным значением (как чисто описательное поле)** — отвергнуто: `status:` + **читается** `_parse_tests_verdict` с negative-token-priority → негативный токен в `status:` при + `result: PASS` даёт ложный FAIL. Выбрано жёсткое выравнивание `status:` по вердикту (D6.1). +- **Прогон pytest в общем `/repos/orchestrator`** — отвергнуто: checkout-гонка с другими задачами + (мина, закрытая ORCH-112); раннер исполняет pytest **в worktree ветки** (как coverage/merge-gate). +- **Merge лога отдельным PR в `main`** (как прежний tester) — отвергнуто: гейт читает worktree первым + (`_repo_path`) → достаточно push в фичеветку; исключение прямой работы с `main` усиливает + AC-10/BR-7. +- **Логика раннера прямо в `launcher.py`** — отвергнуто: нарушает разделение транспорт/решение; leaf + тестируем без живого CLI (зеркало `staging_runner`/`coverage_gate`). +- **LLM-триаж как control-path-продюсер `result:`** — отвергнуто: BR-8/AC-12 (детерминированный + раннер — единственный исполнитель вердикта; триаж — off-control-path, Phase 2). +- **Править `llm-call-sites.md`/roadmap/policy/README в architecture-стадии** — отвергнуто: + анти-дрейф-тесты коуплены к коду; правки идут атомарно с кодом (D12, как ORCH-115). +- **DEFER через re-queue `deployer`-джоба** (копипаст из staging-раннера) — отвергнуто: DEFER должен + re-queue'ить **`tester`**-джоб (он повторно входит в этот раннер на стадии `testing`). + +## Последствия + +- **+** На `testing` для `orchestrator` исчезает LLM-консультация в потоке управления вердикта: + дешевле/быстрее/детерминированнее; минус один avoidable LLM control path (второй срез roadmap, + rank 2). +- **+** Happy-path не вызывает `_spawn` (нет `agent_runs`-строки, нет токенов LLM на стадии `testing`). +- **+** Полная обратимость одним флагом; артефакт/гейт/ребро/схема БД неизменны → переключение + туда-сюда не оставляет несовместимого состояния. +- **+** Двухуровневый исход (D5) убирает класс ORCH-110 (инфра ≠ код-фейл) с `testing`-ребра. +- **+** Гибрид-граница сохранена (D11): архитектура не закрывает путь к будущему off-control-path + LLM-триажу, не пуская LLM обратно в поток управления. +- **−** Новый leaf + врезка в `launch_job` + defer-механика — рост поверхности кода. Митигейшн: leaf + never-raise + kill-switch (fail-safe к LLM), тонкая врезка-зеркало D1/D2/ORCH-115, defer-счётчик без + схемы БД (маркер в `task_content`), покрытие `tests/test_orch116_test_runner.py`. +- **−** Smoke зависит от достижимости запущенного оркестратора (8500) — разовый блип мог бы дать + `FAIL`. Митигейшн: D3 (bounded smoke-ретрай транзиентной недостижимости + config-gate + `test_runner_smoke_enabled` + developer-retry-cap); pytest остаётся первичным сигналом. +- **−** Тонкая мина 52c-`status:` ↔ парсер (D6.1) специфична для tester. Митигейшн: жёсткий инвариант + выравнивания + unit-тест через неизменённый парсер; reviewer-ось ≥P1. +- **Откат:** `ORCH_TEST_RUNNER_ENABLED=false` → штатный `_spawn` LLM-tester'а на `testing` + **байт-в-байт** до ORCH-116. + +## Ссылки +- BRD: `docs/work-items/ORCH-116/01-brd.md` +- TRZ: `docs/work-items/ORCH-116/02-trz.md` +- Acceptance: `docs/work-items/ORCH-116/03-acceptance-criteria.md` +- Тест-план: `docs/work-items/ORCH-116/04-test-plan.yaml` +- Инфра: `docs/work-items/ORCH-116/07-infra-requirements.md`; + Данные: `08-data-requirements.md`; Риски: `10-tech-risks.md` +- Сквозной ADR: `docs/architecture/adr/adr-0049-deterministic-test-runner.md` +- Эталон реализации: `src/staging_runner.py` (ORCH-115), + `docs/work-items/ORCH-115/06-adr/ADR-001-deterministic-staging-runner.md` +- Сверено по коду: `src/agents/launcher.py:397/404/438`, `src/stages.py:17-18`, + `src/qg/checks.py:15/182/222-223/226/263-277/528`, `src/stage_engine.py:849-892`, + `src/self_deploy.py` (`map_exit_code_to_status`), `src/proc_group.py`, `src/config.py:159/162` + (`agent_timeout_seconds`/`reaper_max_running_s`) +- Политика/карта/roadmap: `docs/architecture/llm-usage-policy.md`, + `docs/architecture/llm-call-sites.md` (A5), `docs/architecture/llm-determinization-roadmap.md` + (rank 2) diff --git a/docs/work-items/ORCH-116/07-infra-requirements.md b/docs/work-items/ORCH-116/07-infra-requirements.md new file mode 100644 index 0000000..111546c --- /dev/null +++ b/docs/work-items/ORCH-116/07-infra-requirements.md @@ -0,0 +1,69 @@ +--- +work_item: ORCH-116 +stage: architecture +author_agent: architect +status: proposed +created_at: 2026-06-16 +model_used: claude-opus-4-8 +--- + +# 07 — Инфраструктурные требования: ORCH-116 — детерминированный test-раннер + +Work Item: **ORCH-116** · Repo: **orchestrator** · Стадия: architecture + +> Топология **не меняется** (всё в Docker на одном сервере mva154, SQLite, собственная очередь). +> Раздел фиксирует **рантайм-предусловия** детерминированного раннера и подтверждает отсутствие +> новых компонентов/портов/зависимостей образа. + +## 1. Топология — без изменений + +Новых контейнеров / сервисов / портов / сетей **нет**. Раннер исполняется **внутри уже работающего +прод-контейнера `orchestrator` (8500)** как синхронный обработчик джоба `tester` (перехват в +`launch_job` до `_spawn`) — там же, где сейчас стартует LLM-tester. Staging-контур (8501) для +ORCH-116 **не используется** (в отличие от ORCH-115) — это ребро `testing`, а не `deploy-staging`. + +## 2. Рантайм-предусловия (предсуществующие, проверить) + +| # | Предусловие | Статус | Обоснование | +|---|-------------|--------|-------------| +| P-1 | `python -m pytest` исполним внутри прод/staging-образа | **уже выполнено** | pytest уже гоняется в worktree внутри этого же образа coverage-gate (ORCH-027) и merge-gate re-test (ORCH-110). Новых pip-зависимостей **нет** (в отличие от `pytest-cov` ORCH-027 — он не требуется: ORCH-116 читает только exit-код, не покрытие). | +| P-2 | Per-branch worktree ветки задачи материализуем (`git_worktree.get_worktree_path`) | **уже выполнено** | механика worktree используется всеми гейтами/раннерами; раннер исполняет pytest **в worktree ветки** (анти checkout-гонка, ORCH-112), не в общем `/repos/orchestrator`. | +| P-3 | `proc_group.run_in_process_group` (tree-kill) доступен на POSIX-хосте | **уже выполнено** | ORCH-110; fallback к `subprocess.run` на не-POSIX (`subprocess_tree_kill_enabled`). | +| P-4 | Read-only smoke: запущенный оркестратор отвечает на `GET /health`, `/status`, `/queue` по config-резолвнутому base URL | **уже выполнено** | те же эндпоинты read-only опрашивал LLM-tester (шаг 3 промпта). Base URL — из config (host-параметризация ORCH-101, без host-хардкодов). Smoke **строго read-only**; опционален (`test_runner_smoke_enabled`). | +| P-5 | git-identity актора `test-runner` для best-effort push лога в фичеветку | **уже выполнено** | HOME + email-домен из `settings` (ORCH-101), как у `staging-runner`. Push **только в фичеветку**, никогда в `main`/force-push. | + +## 3. Конфигурация (env, дефолт = боевое; пустой `.env` ⇒ поведение для in-scope) + +| Ключ | env | Дефолт | Назначение | +|------|-----|--------|------------| +| `test_runner_enabled` | `ORCH_TEST_RUNNER_ENABLED` | `True` | kill-switch (off → LLM-tester байт-в-байт) | +| `test_runner_repos` | `ORCH_TEST_RUNNER_REPOS` | `""` | CSV-скоуп; пусто → self-hosting only | +| `test_runner_target` | `ORCH_TEST_RUNNER_TARGET` | `tests/` | pytest-таргет тест-контракта | +| `test_runner_timeout_s` | `ORCH_TEST_RUNNER_TIMEOUT_S` | `900` | таймаут pytest (D9; согласован со сквозным бюджетом ORCH-065/109/110 без правки `reaper_max_running_s`) | +| `test_runner_smoke_enabled` | `ORCH_TEST_RUNNER_SMOKE_ENABLED` | `True` | опц. read-only smoke | +| `test_runner_infra_max_retries` | `ORCH_TEST_RUNNER_INFRA_MAX_RETRIES` | `2` | бюджет tool-error DEFER (D5) | +| `test_runner_infra_retry_delay_s` | `ORCH_TEST_RUNNER_INFRA_RETRY_DELAY_S` | `30` | задержка DEFER-re-queue | + +> `.env.example` пополнить этими ключами (канон старта, норматив ORCH-101). Изменений +> `docker-compose.yml` / `Dockerfile` / образа **нет**. + +## 4. Сквозной бюджет времени (NFR-4) + +Ребро `testing` отдельно от `deploy-staging`. Окно «running» `tester`-джоба = только pytest+smoke +(≤`test_runner_timeout_s`=900s); тяжёлые под-гейты (security/merge/coverage/image-freshness) живут на +ребре `deploy-staging → deploy`. Прежний LLM-tester шёл под `agent_timeout_seconds`=1800s +(`config.py:159`; tester без выделенного per-role ключа). 900 < 1800 → Σ(работ на ребре `testing`) +**не растёт** → инвариант `reaper_max_running_s (5400) > Σ + grace` сохранён **без** правки reaper'а. + +## 5. Self-hosting safety (BR-7 / AC-10) + +Раннер на `testing` **никогда** не рестартит контейнер 8500, не выполняет `docker compose up -d +orchestrator`/`--build`, не пушит force в `main`, не правит `.env`/`.env.staging`/`docker-compose.yml`. +Он лишь исполняет pytest в worktree, делает read-only GET и пишет/пушит лог в фичеветку. Деплой-решений +ORCH-116 не принимает (это стадия `testing`, до прод-деплоя) — staging-гейт остаётся обязательной +страховкой на последующих рёбрах. + +## 6. Вывод + +Инфраструктурных изменений **нет** (топология/порты/образ/зависимости — без правок). Все предусловия +P-1…P-5 предсуществуют. Эскалация `arch:major-change` **не требуется**. diff --git a/docs/work-items/ORCH-116/08-data-requirements.md b/docs/work-items/ORCH-116/08-data-requirements.md new file mode 100644 index 0000000..1a15000 --- /dev/null +++ b/docs/work-items/ORCH-116/08-data-requirements.md @@ -0,0 +1,54 @@ +--- +work_item: ORCH-116 +stage: architecture +author_agent: architect +status: proposed +created_at: 2026-06-16 +model_used: claude-opus-4-8 +--- + +# 08 — Требования к данным: ORCH-116 — детерминированный test-раннер + +Work Item: **ORCH-116** · Repo: **orchestrator** · Стадия: architecture + +## 1. Изменения схемы БД — НЕТ (NFR-1) + +Новых таблиц / колонок / индексов / миграций **нет**. Раннер использует **существующие** структуры: + +| Структура | Использование | Запись? | +|-----------|---------------|---------| +| `tasks` (`stage`, `branch`, `work_item_id`) | резолв полей задачи по `task_id`; гард стадии `testing` в `should_intercept`; продвижение/откат — через **существующий** `advance_stage` (он же пишет стадию под transition-lease ORCH-114) | раннер сам стадию **не** пишет — только через `advance_stage` | +| `jobs` (`status`, `task_content`) | `mark_job(done\|failed)` для строки джоба (через `_run_test_runner_job`); restart-safe счётчик tool-error DEFER — `COUNT(*)` по маркеру `test-runner infra-retry` в `task_content` re-queued джоба | да (`mark_job`, `enqueue_job` — существующие API) | +| `agent_runs` | **НЕ создаётся** — детерминированный раннер не спавнит LLM (happy-path без `_spawn`) | нет | +| `transition_lease` (ORCH-114) | берётся/освобождается **внутри** `advance_stage` на side-effectful переходе | раннер **не трогает** | + +## 2. Restart-safe счётчик DEFER — без колонки (зеркало ORCH-115/110) + +Бюджет tool-error DEFER (D5) считается **из persisted очереди `jobs`** подсчётом маркера +`test-runner infra-retry` в `task_content` re-queued джоба (зеркало +`staging_runner._infra_retry_count` / `stage_engine._merge_infra_retry_count`). Это переживает +рестарт сервиса **без** новой колонки/таблицы — намеренно, ради NFR-1 (схема БД байт-в-байт). + +## 3. Артефакт `13-test-report.md` — контракт frontmatter неизменен (AC-2) + +Раннер пишет тот же файл с тем же machine-key, что читает гейт: +- `result: PASS|FAIL` (UPPERCASE) — канонический ключ `_parse_tests_verdict` (`src/qg/checks.py:265`); + имя/регистр/токены **не меняются**. +- Обязательная 52c-схема: `work_item` / `stage: testing` / `author_agent: test-runner` / + `status: success|failed` / `created_at` / `model_used: n/a`. +- **Инвариант D6.1 (данные):** `status:` **читается** тем же парсером (`verdict:`/`status:`/`result:`, + negative-token-priority) → значение `status:` **обязано** быть выровнено по вердикту + (`success`↔PASS, `failed`↔FAIL); иначе негативный токен в `status:` при `result: PASS` исказит + вердикт. Это требование к **значению данных**, не к схеме. + +## 4. Счётчики наблюдаемости — in-process, не БД + +Блок `test_runner` в `GET /queue` питается **in-process** счётчиками `_TEST_RUNNER_COUNTERS` +(`runs`/`pass`/`fail`/`tool_error`/`deferred`) — паттерн `_STAGING_RUNNER_COUNTERS`/ +`_MERGE_GATE_COUNTERS`. В БД **не** персистятся (обнуляются при рестарте — приемлемо для +оперативной наблюдаемости). + +## 5. Вывод + +Требований к изменению данных/схемы **нет**. Совместимость с общей БД (self-hosting + enduro-trails) +сохранена: аддитивных объектов не вводится, существующие read/write идут через существующие API. diff --git a/docs/work-items/ORCH-116/10-tech-risks.md b/docs/work-items/ORCH-116/10-tech-risks.md new file mode 100644 index 0000000..3668d78 --- /dev/null +++ b/docs/work-items/ORCH-116/10-tech-risks.md @@ -0,0 +1,47 @@ +--- +work_item: ORCH-116 +stage: architecture +author_agent: architect +status: proposed +created_at: 2026-06-16 +model_used: claude-opus-4-8 +--- + +# 10 — Технические риски: ORCH-116 — детерминированный test-раннер + +Work Item: **ORCH-116** · Repo: **orchestrator** · Стадия: architecture + +> Информационный (гейтом не парсится). Покрывает риски BRD §8 (R-1…R-7) + риски, выявленные +> архитектором по коду (TR-8…TR-11, специфичные для роли `tester` / стадии `testing`). + +## Реестр рисков + +| ID | Риск | Вер. | Влия. | Митигейшн | +|----|------|------|-------|-----------| +| TR-1 (R-1) | Точка диспетчеризации «до `_spawn`» перехватывает не тот джоб | Низ. | Выс. | `should_intercept` = `agent=="tester"` **И** `applies(repo)` **И** `tasks.stage=="testing"` (D1). Роль `tester` исполняет ТОЛЬКО `testing` (`STAGE_TRANSITIONS["review"]["agent"]`) → коллизии стадий нет; гард по стадии — defense-in-depth. never-raise → `False` → `_spawn`. Покрыто тестом перехвата/не-перехвата. | +| TR-2 (R-2) | После вердикта гейт не инициирован → задача зависает на `testing` | Низ. | Выс. | D7: раннер вызывает `advance_stage(current_stage="testing", finished_agent="tester")` в `run_test_gate` (never-raise). **`finished_agent="tester"` обязателен** — FAIL-ветвь `stage_engine.py:849` матчит по `agent=="tester"`. Покрыто тестом PASS-advance и FAIL-rollback. | +| TR-3 (R-3) | Таймаут/изоляция pytest; утечка процессов (корень ORCH-109/110/111) | Сред. | Выс. | D3: pytest через `proc_group.run_in_process_group` (tree-kill SIGTERM→grace→SIGKILL); таймаут `test_runner_timeout_s`=900 (малформ→дефолт+WARNING); прогон **в worktree ветки**, не в общем клоне. Покрыто тестом изоляции/таймаута. | +| TR-4 (R-4) | Two-level outcome неверен: tool-error жжёт developer-retry (регресс ORCH-110) ИЛИ ложный green | Сред. | Выс. | D5: сюита исполнилась → verdict→advance; сюита НЕ исполнилась (spawn-error/таймаут/`None`) → bounded DEFER (re-queue `tester`-джоба, restart-safe маркер) → на исчерпании fail-closed `FAIL`+advance+alert. Никогда тихий advance/ложный green; не жжёт developer-retry на инфре. Покрыто тестом обоих уровней. | +| TR-5 (R-5) | Откат FAIL не совпадает с LLM-путём (developer-retry cap / `extract_test_failures`) | Низ. | Сред. | D7 переиспользует **существующий** откат `stage_engine.py:849-892` (тот же `MAX_DEVELOPER_RETRIES`, `extract_test_failures`, `enqueue_job("developer", …)`). Новой ветви маршрутизации нет. Покрыто тестом эквивалентности. | +| TR-6 (R-6) | LLM протаскивается обратно в поток управления вердикта (нарушение BR-8) | Низ. | Сред. | D11: детерминированный раннер — единственный продюсер `result:`; off-control-path триаж не реализуется и не добавляет ребро в `STAGE_TRANSITIONS`. Анти-дрейф LLM-карты (D12) + reviewer-ось AC-12. | +| TR-7 (R-7) | Backward-compat: репо без тест-контракта зависает без продюсера отчёта | Низ. | Выс. | D8: `_has_test_contract(repo)` (Phase 1 = self-hosting) — `applies==False` для не-self/без-контракта → `should_intercept==False` → прежний LLM-tester (fail-safe). Покрыто тестом для не-self репо. | +| **TR-8** | **52c-`status:` ↔ парсер: ложный FAIL.** `_parse_tests_verdict` читает вердикт из `verdict:`/**`status:`**/`result:` с negative-token-priority. 52c-`status: failed` (`"FAILED"`) при `result: PASS` → негативный токен авторитетен → ложный FAIL здорового прогона. **(Отсутствует в ORCH-115 — там гейт читает только `staging_status:`.)** | Сред. | Выс. | D6.1: `status:` ВСЕГДА выровнен по вердикту (`success`↔PASS / `failed`↔FAIL); `"SUCCESS"` — не негативный/не позитивный токен, позитив берётся из `result: PASS`. **Обязательный** unit-тест: `_parse_tests_verdict(<тело раннера PASS>)==(True,…)` и `(FAIL)==(False,…)` через **неизменённый** парсер. Reviewer: `status:`-литерал с негативным токеном при `result: PASS` → ≥P1. | +| **TR-9** | **Smoke против прод-8500 флапает.** Разовый блип запущенного оркестратора (connection refused/таймаут) → `FAIL` → откат здоровой ветки + расход developer-retry. | Сред. | Сред. | D3: bounded smoke-ретрай **транзиентной недостижимости** (несколько быстрых GET с коротким backoff) перед `FAIL`; «достижимо, но форма неверна» → немедленный `FAIL`. `test_runner_smoke_enabled` позволяет отключить smoke без отката раннера. pytest — первичный сигнал; developer-retry-cap поглощает остаточный шум. | +| **TR-10** | **DEFER re-queue'ит не тот агент.** Копипаст из `staging_runner` мог бы re-queue'ить `deployer`-джоб → задача уйдёт в чужой обработчик. | Низ. | Выс. | D5: DEFER re-queue'ит **`tester`**-джоб (`enqueue_job("tester", …)`), повторно входящий в этот раннер на стадии `testing`. Покрыто тестом DEFER (проверка роли re-queued джоба). | +| **TR-11** | **Дрейф LLM-карты/политики/витрины** при реализации (NFR-6): инвариант «ровно один `first_slice=yes`» нарушен / `avoidable=yes` снят с tester / анти-дрейф-тесты красные. | Сред. | Сред. | D12: точная спека правок (A5 → реализовано, но `avoidable=yes`/`axis=C`/`needs-hybrid-fallback` СОХРАНЯЮТСЯ; rank 2 tester → реализован, `first_slice` НЕ переключать — остаётся у rank 1/deployer). Правки атомарно с кодом в development + зелёные `test_llm_call_site_inventory.py`/`test_llm_determinization_docs.py`. Reviewer-ось AC-14 ≥P1. | +| TR-12 | Скоуп-дрейф: правка `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_tests_passed`/`_parse_tests_verdict`/machine-verdict/схемы БД | Низ. | Выс. | NFR-1: замена только *продюсера*. Анти-дрейф-тест на неизменность гейта/токенов/схемы (AC-6). Reviewer ловит как ≥P1. | + +## Сводный вывод + +Доминирующий класс — **корректность интеграции детерминированного раннера в существующий гейт** +(`finished_agent="tester"`, two-level outcome, эквивалентность отката) и **две tester-специфичные +мины, которых не было в ORCH-115**: (TR-8) коллизия 52c-`status:` с `_parse_tests_verdict` и +(TR-9) флап smoke против прод-8500. Обе закрыты архитектурно (D6.1 — жёсткое выравнивание `status:` ++ unit-тест через неизменённый парсер; D3 — bounded smoke-ретрай + config-gate). Остаточный риск для +прод-конвейера (self-hosting) — **низкий**: leaf never-raise + kill-switch (мгновенный откат к +LLM-tester байт-в-байт), без правки гейта/стадии/схемы БД, граница с ORCH-112/114/115 соблюдена, +сквозной бюджет времени сохранён без правки `reaper_max_running_s`. + +Эскалация `arch:major-change` **не требуется** (нет новой стадии/QG/смены БД; новый компонент-leaf — +аддитивный, под kill-switch, по доказанному прецеденту ORCH-115). Возврат в анализ **не требуется** +(ТЗ удовлетворяется без нарушения принципов архитектуры). From 9d16ee473a506378724bf04f3cbe9a8c1b6808c0 Mon Sep 17 00:00:00 2001 From: claude-bot Date: Tue, 16 Jun 2026 02:59:51 +0300 Subject: [PATCH 04/16] feat(testing): deterministic test-runner replacing LLM tester on the testing stage (ORCH-116) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Second realised slice of the determinization-roadmap (ORCH-118 A5, needs-hybrid-fallback): on the `testing` stage for the self-hosting `orchestrator` repo the LLM `tester` agent is replaced by a deterministic test-runner (src/test_runner.py), intercepted in launch_job BEFORE _spawn (deploy-finalizer / post-deploy-monitor / staging-runner precedent). It runs the regression `python -m pytest ` in the task worktree via proc_group (tree-kill) + an optional read-only smoke (/health, /status, /queue + serial_gate), maps the exit-code -> result: PASS|FAIL via the existing self_deploy.map_exit_code_to_status contract, writes 13-test-report.md and initiates the EXISTING check_tests_passed gate exactly as a finished LLM-tester. Invariant (NFR-1): only the *producer* changes — the artifact contract (13-test-report.md / result:), the gate check_tests_passed / _parse_tests_verdict, STAGE_TRANSITIONS and the DB schema are byte-for-byte UNCHANGED. Additive, under a kill-switch (test_runner_enabled), never-raise, fail-closed, self-hosting scope, two-level outcome (tool-error DEFER, anti ORCH-110), hybrid (LLM strictly off-control-path). 52c-`status:` is aligned with the verdict (D6.1) so the three-field _parse_tests_verdict never false-negatives a PASS. Docs (ORCH-118 NFR-6, atomic with code): llm-call-sites.md (A5 implemented), llm-determinization-roadmap.md (rank 2 implemented), llm-usage-policy.md, README/internals/overview, tester.md, CLAUDE.md, CHANGELOG.md. Coverage: tests/test_orch116_test_runner.py (TC-01..TC-14); LLM anti-drift tests green. Full suite: 2137 passed. Refs: ORCH-116 Co-Authored-By: Claude Opus 4.8 --- .openclaw/agents/tester.md | 11 + .task-dev.md | 4 +- CLAUDE.md | 57 ++ docs/architecture/README.md | 10 +- docs/architecture/internals.md | 13 + docs/architecture/llm-call-sites.md | 10 +- .../llm-determinization-roadmap.md | 16 +- docs/architecture/llm-usage-policy.md | 7 + docs/overview/tech-agents.md | 8 + docs/overview/tech-pipeline.md | 11 + docs/overview/tech-quality-security.md | 5 +- src/agents/launcher.py | 33 + src/config.py | 51 ++ src/main.py | 6 + src/test_runner.py | 705 ++++++++++++++++++ tests/test_orch116_test_runner.py | 560 ++++++++++++++ 16 files changed, 1499 insertions(+), 8 deletions(-) create mode 100644 src/test_runner.py create mode 100644 tests/test_orch116_test_runner.py diff --git a/.openclaw/agents/tester.md b/.openclaw/agents/tester.md index c149c83..b0d9474 100644 --- a/.openclaw/agents/tester.md +++ b/.openclaw/agents/tester.md @@ -29,6 +29,17 @@ tools: ТОЛЬКО потом выноси вердикт. Любой FAIL/смок-сбой → `result: FAIL`; всё зелёное → `result: PASS`. +> **ORCH-116 — детерминированный раннер ведёт эту стадию для in-scope репо.** На `testing` для +> self-hosting `orchestrator` (репо с тест-контрактом) стадию теперь ведёт **детерминированный код** +> (`src/test_runner.py`, перехват в `launch_job` **до** `_spawn`, как `deploy-finalizer`/ +> `staging-runner`) — он исполняет тот же регресс `pytest tests/` в worktree ветки + read-only smoke +> (`/health`, `/status`, `/queue` + блок `serial_gate`), маппит exit-код в `result:` тем же +> контрактом `0 → PASS / иначе → FAIL`, пишет `13-test-report.md` и инициирует неизменный гейт +> `check_tests_passed`. LLM-шаги ниже остаются **fallback'ом** под выключенным kill-switch +> (`ORCH_TEST_RUNNER_ENABLED=false`) или для репо без тест-контракта. Контракт артефакта / гейт / +> machine-key `result:` — неизменны. Детали: +> `docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md`. + **Алгоритм:** 1. **Окружение:** `curl -s http://localhost:8500/health`. 2. **Тесты — в worktree ветки задачи, НЕ в общем `/repos/orchestrator`.** Прогоняй `pytest` из diff --git a/.task-dev.md b/.task-dev.md index 75f0fd3..69f6747 100644 --- a/.task-dev.md +++ b/.task-dev.md @@ -1,4 +1,4 @@ -Work item: ORCH-115 +Work item: ORCH-116 Repo: orchestrator -Branch: feature/ORCH-115-orch-replace-llm-deployer-with +Branch: feature/ORCH-116-orch-replace-llm-tester-with-d Stage: development \ No newline at end of file diff --git a/CLAUDE.md b/CLAUDE.md index 62b1fde..da41afd 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -493,6 +493,63 @@ Plane, **не** Quality Gate и **не** стадия). Детали — `docs/work-items/ORCH-123/06-adr/ADR-001-host-side-staging-execution-and-env-classification.md`, сквозной `docs/architecture/adr/adr-0049-host-side-docker-execution-boundary.md`. +## Детерминированный test-раннер вместо LLM-тестера (ORCH-116) +Второй реализованный срез determinization-roadmap (ORCH-118 A5, `needs-hybrid-fallback`): на стадии +`testing` для self-hosting `orchestrator` **LLM-агент `tester` заменён детерминированным кодом** +(`src/test_runner.py`). PASS/FAIL-ядро было деривируемо (регресс `pytest` + read-only smoke) — теперь +его делает leaf, перехватываемый в `launch_job` **до `_spawn`** (прецедент `deploy-finalizer`/ +`post-deploy-monitor`/`staging-runner`, `launcher.py:397/402/405`). **Инвариант (NFR-1):** замена +*продюсера* артефакта, **не** гейта — контракт `13-test-report.md`, гейт/`_parse_tests_verdict`/имя +`check_tests_passed`, `STAGE_TRANSITIONS`, machine-verdict `result:` (+ legacy `verdict:`/`status:`), +схема БД — **байт-в-байт не тронуты**. Аддитивно, под kill-switch, never-raise, fail-closed, гибрид +(LLM строго off-control-path). +- **Перехват (D1):** `launch_job` — `if job.agent=="tester" and test_runner.should_intercept(job)` + → `_run_test_runner_job` (зеркало `_run_staging_runner_job`): синхронно ведёт `jobs`-строку через + `mark_job`, возвращает `None` (нет `agent_runs`). Дискриминатор — роль `tester` **И** стадия задачи + `testing` (defense-in-depth: `tester` — единственный агент входа в `testing`, коллизии стадий нет, в + отличие от общей роли `deployer`/ORCH-115) **И** `applies(repo)`; `should_intercept` never-raise → + `False` → штатный `_spawn` (fail-safe к LLM-пути). +- **Раннер (D2-D7):** leaf по образцу `staging_runner`/`self_deploy`/`proc_group` (на импорте только + `config`/`proc_group`; `db`/`git_worktree`/`self_deploy`/`qg.checks`/`stage_engine`/`notifications` + — лениво). `applies` = kill-switch `test_runner_enabled` + скоуп `test_runner_repos` (пусто → + self-hosting only) **И** резолв тест-контракта `_has_test_contract` (BR-9: репо без контракта → + LLM-tester, enduro-trails 1:1 даже если руками в CSV). Исполняет `python -m pytest + ` **в worktree ветки** (анти checkout-гонка) через `proc_group` + (tree-kill, таймаут `test_runner_timeout_s=900`) + опц. read-only smoke (`/health`/`/status`/`/queue` + + блок `serial_gate`, stdlib `urllib`; транзиент → ограниченный ретрай, не-200/нет блока → немедленный + FAIL; `test_runner_smoke_enabled`); маппит exit-код **единым** `self_deploy.map_exit_code_to_status` + в токенах `result:` (`0→PASS`/иначе/None→`FAIL`, fail-closed; smoke-провал AND-ится в `FAIL`); пишет + `13-test-report.md` (`author_agent: test-runner`/`model_used: n/a`, 52c-схема) + best-effort push в + фичеветку; вызывает **существующий** `advance_stage(current_stage="testing", finished_agent="tester")` + — без новых рёбер/исходов (lease ORCH-114 берётся внутри `advance_stage`). +- **Анти-коллизия 52c-`status:` ↔ парсер (D6.1, специфично для tester):** `_parse_tests_verdict` читает + вердикт из **трёх** равноранговых полей (`verdict:`/`status:`/`result:`) с negative-token-priority → + 52c-обязательное `status:` раннера **ВСЕГДА выровнено** по вердикту (`PASS → status: success`, `FAIL + → status: failed`), иначе негативный токен в `status:` при `result: PASS` дал бы ложный FAIL. Прибито + unit-тестом через неизменённый парсер. +- **Двухуровневый исход (D5, анти-ORCH-110):** сюита **исполнилась** (реальный exit-код) → verdict→ + advance (FAIL → тот же откат `testing → development` + developer-retry, что у LLM); сюита **не + исполнилась** (tool-error: spawn-error/таймаут/`returncode None`) → инфра-сбой ≠ код-фейл → bounded + **DEFER** (re-queue **`tester`**-джоба + restart-safe маркер `test-runner infra-retry` в + `task_content`, без правки схемы БД), на исчерпании `test_runner_infra_max_retries` → fail-closed + `FAIL` + advance + alert. Никогда тихий advance/ложный green; не клинит очередь; не жжёт + developer-retry на транзиентной инфре. +- **Флаги** (`config.py`, дефолт = боевое): `test_runner_enabled` (kill-switch, env + `ORCH_TEST_RUNNER_ENABLED`), `test_runner_repos` (CSV; **пусто → self-hosting only**), + `test_runner_target=tests/`, `test_runner_timeout_s=900`, `test_runner_smoke_enabled`, + `test_runner_infra_max_retries=2`, `test_runner_infra_retry_delay_s=30`. Откат = + `ORCH_TEST_RUNNER_ENABLED=false` → на `testing` снова LLM-`tester` через `_spawn` **байт-в-байт**. + Наблюдаемость — in-process счётчики + read-only блок `test_runner` в `GET /queue` + один структурный + лог-вердикт на прогон (различает код-фейл и tool-error). **Гибрид (BR-8/NFR-7):** LLM строго + off-control-path — детерминированный раннер единственный продюсер `result:`; будущий триаж падений не + выносит/не переопределяет вердикт и не добавляет ребро в `STAGE_TRANSITIONS` (Phase 1 не реализован). + Норматив сопровождения ORCH-118: обновлены `llm-call-sites.md`/`llm-determinization-roadmap.md`/ + `llm-usage-policy.md` (A5/rank 2 — реализован, машинные блоки/инвариант «ровно один `first_slice`» + целы) + `tester.md` (LLM-ветвь — fallback). Покрытие — `tests/test_orch116_test_runner.py` + (TC-01…TC-14) + зелёные LLM-анти-дрейф тесты (TC-15). Детали — + `docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md`, сквозной + `docs/architecture/adr/adr-0049-deterministic-test-runner.md`. + ## Машинный журнал уроков (ORCH-098) Шаг 1 («Фундамент», F2) эпика саморазвития: формализует свободнотекстовые «уроки» из `memory/` в **машинную структурированную таблицу отклонений конвейера** `lessons`, фундамент для будущих diff --git a/docs/architecture/README.md b/docs/architecture/README.md index d52f5b9..171e987 100644 --- a/docs/architecture/README.md +++ b/docs/architecture/README.md @@ -11,6 +11,7 @@ - **Quality Gates** (`src/qg/checks.py`) — проверки выхода со стадии, реестр `QG_CHECKS`. - **Agent Launcher** (`src/agents/launcher.py`) — запуск Claude CLI агентов в изолированном git worktree, мониторинг, auto-advance. Модель/эффорт каждого агента резолвятся из config (`resolve_agent_model`/`resolve_agent_effort`, ORCH-41), а не из frontmatter промпта. **ORCH-74:** имя модели валидируется форматом `^claude-…$` (`is_valid_model`) перед `--model`; невалидное → лог + откат на следующий уровень/CLI-дефолт (never-break, как `VALID_EFFORTS` для эффорта). Тот же предикат гардит inline-чтение `--fallback-model`. **ORCH-109 ([adr-0040](adr/adr-0040-agent-timeout-budgets-and-launch-model-stamp.md)):** (1) резолвенная **модель стампится в `agent_runs.model` в момент launch** (`_spawn`, объединённый `UPDATE … SET model=?, effort=?` рядом со стампом эффорта ORCH-087; пустой резолв → `NULL`; never-raise) → модель видна не-`null` при любом исходе прогона, включая timeout-kill (`exit_code=-9`), и in-flight в `GET /metrics`/`GET /queue` (`get_running_agents` уже отдаёт `model`); постфактум `record_usage` (`model=COALESCE(?, model)`) остаётся **обогащением**, не единственным источником истины. (2) **Per-role wall-clock бюджеты** через выделенные ключи `agent_timeout_developer_s=3600`/`agent_timeout_reviewer_s=3000` (лестница `_resolve_timeout`: `agent_timeout_overrides_json` → выделенный ключ роли → `agent_timeout_seconds=1800`; прочие роли — байт-в-байт; малформный/вне-диапазонный конфиг → дефолт + WARNING). Инвариант reaper ORCH-065 сохранён синхронным поднятием `reaper_max_running_s` 3600→**5400** (`5400 > max(timeout)3600 + grace20`). FR-5 анти-salvage — структурно: продвижение гейтится `if exit_code==0`, timeout-kill → `_finalize_job` (retry/fail), не advance. `STAGE_TRANSITIONS`/`QG_CHECKS`/схема БД не тронуты. - **Staging-runner** (`src/staging_runner.py`, ORCH-115 — [adr-0048](adr/adr-0048-deterministic-staging-runner.md)) — чистый **never-raise** leaf (паттерн `self_deploy`/`proc_group`/`staging_verdict`), заменяющий **LLM-агента `deployer` на стадии `deploy-staging`** детерминированным кодом (первый реализованный срез determinization-roadmap, A6/`replace-deterministic-now`). Перехват в `launch_job` **до `_spawn`** (рядом с D1/D2 `deploy-finalizer`/`post-deploy-monitor`): дискриминатор — **стадия задачи** `deploy-staging` **И** `applies(repo)` (kill-switch `staging_runner_enabled` + скоуп `staging_runner_repos`, пусто → self-hosting only), `should_intercept` never-raise → `False` → штатный `_spawn` (fail-safe к LLM). Раннер (зеркало `run_deploy_finalizer`) исполняет ту же staging-сюиту (`docker exec orchestrator-staging … staging_check.py`) через `proc_group` (tree-kill, таймаут `staging_runner_timeout_s=600`), маппит exit-код единым контрактом `self_deploy.map_exit_code_to_status` (`0→SUCCESS`/иначе→`FAILED`; ORCH-061 infra-tolerance остаётся внутри `staging_check.py`), пишет `15-staging-log.md` (тот же machine-key `staging_status:`, `author_agent: staging-runner`/`model_used: n/a`) + best-effort push в фичеветку, и вызывает **существующий** `advance_stage(current_stage="deploy-staging", finished_agent="deployer")` — без новых рёбер/исходов; transition-lease ORCH-114 берётся внутри `advance_stage` (раннер не трогает). **Двухуровневый исход (анти-ORCH-110):** сюита исполнилась → verdict→advance (FAILED → тот же откат `deploy-staging → development` + developer-retry, что у LLM); tool-error/таймаут → bounded defer (`staging_runner_infra_max_retries`) → fail-closed `FAILED` + alert на исчерпании (инфра ≠ код-фейл, никогда тихий advance/ложный green). `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_staging_status`/`_parse_staging_status`/machine-verdict/схема БД — **байт-в-байт не тронуты** (замена *продюсера*, не гейта). Наблюдаемость — in-process счётчики + блок `staging_runner` в `GET /queue`. Откат — `ORCH_STAGING_RUNNER_ENABLED=false` (прежний LLM-deployer-путь байт-в-байт). Детали — `docs/work-items/ORCH-115/06-adr/ADR-001-deterministic-staging-runner.md`. **ORCH-123 (фикс стратегии исполнения — [adr-0049](adr/adr-0049-host-side-docker-execution-boundary.md)):** раннер ORCH-115 вызывал `docker exec` **изнутри** прод-контейнера, где **нет docker CLI** (образ несёт только `openssh-client git curl`, `Dockerfile:11`) → `FileNotFoundError` → постоянный environment-дефект ложно откатывался как код-фейл `deploy-staging → development` (инцидент ORCH-116). Фикс: `build_staging_command` теперь исполняет ту же `docker exec … staging_check.py … --mode stub` **host-side** через доверенный ssh-канал `ssh ''` (зеркало `self_deploy`/`image_freshness`, флаг `ORCH_STAGING_RUNNER_EXEC_HOST_SIDE=true`, дефолт; меняется **инициатор/канал**, не сама сюита — она по-прежнему бежит внутри `orchestrator-staging` 8501). Двухуровневый исход ORCH-115 заменён **трёхсторонней классификацией** (`classify_staging_outcome`): `suite-ran` (распознанный exit-код без env-маркера в stderr → доверяем коду: `0→SUCCESS`/`≠0→FAILED`+прежний откат, анти-over-tolerance), `permanent-env` (spawn-error/нет ssh-target/126-127/env-маркер `No such container`/`Cannot connect to the Docker daemon` → **немедленный infra-HOLD**: без отката, без developer-retry, DEFER пропускается), `transient-infra` (timeout/ssh 255 → bounded DEFER, на исчерпании → infra-HOLD, **не** прежний fail-closed FAILED+откат). Корневой инвариант: «сюита **не** исполнилась» (environment ИЛИ инфра) **никогда** не оканчивается код-фейл-откатом — закрывает RCA-класс ORCH-110 на staging-ребре. Plus prod-like preflight host-side канала в `main.lifespan` (best-effort, never-blocks). `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_staging_status`/machine-verdict/схема БД — байт-в-байт не тронуты. Детали — `docs/work-items/ORCH-123/06-adr/ADR-001-host-side-staging-execution-and-env-classification.md`. +- **Test-runner** (`src/test_runner.py`, ORCH-116 — [adr-0049](adr/adr-0049-deterministic-test-runner.md)) — чистый **never-raise** leaf (зеркало `staging_runner`), заменяющий **LLM-агента `tester` на стадии `testing`** детерминированным кодом (**второй** реализованный срез determinization-roadmap, A5/`needs-hybrid-fallback`). Перехват в `launch_job` **до `_spawn`** (рядом с D1/D2/ORCH-115): дискриминатор — роль `tester` **И** стадия задачи `testing` (defense-in-depth: `tester` — единственный агент входа в `testing`) **И** `applies(repo)` (kill-switch `test_runner_enabled` + скоуп `test_runner_repos`, пусто → self-hosting only, **И** резолв тест-контракта `_has_test_contract` — репо без контракта → LLM-tester, BR-9). `should_intercept` never-raise → `False` → штатный `_spawn` (fail-safe к LLM). Раннер (зеркало `run_staging_gate`) исполняет регресс `python -m pytest ` **в worktree ветки** (анти checkout-гонка) через `proc_group` (tree-kill, таймаут `test_runner_timeout_s=900`) + опц. **read-only smoke** (`/health`/`/status`/`/queue` + блок `serial_gate`, `test_runner_smoke_enabled`; транзиентная недостижимость — ограниченный ретрай, не-200/нет блока — немедленный FAIL), маппит exit-код единым контрактом `self_deploy.map_exit_code_to_status` в токенах `result:` (`0→PASS`/иначе→`FAIL`; smoke-провал AND-ится в `FAIL`), пишет `13-test-report.md` (тот же machine-key `result:`, `author_agent: test-runner`/`model_used: n/a`; **52c-`status:` ВСЕГДА выровнен по вердикту** `success`/`failed` — иначе негативный токен в `status:` при `result: PASS` дал бы ложный FAIL через `_parse_tests_verdict`, D6.1) + best-effort push в фичеветку, и вызывает **существующий** `advance_stage(current_stage="testing", finished_agent="tester")` — без новых рёбер/исходов; transition-lease ORCH-114 берётся внутри `advance_stage` (раннер не трогает). **Двухуровневый исход (анти-ORCH-110):** сюита исполнилась → verdict→advance (FAIL → тот же откат `testing → development` + developer-retry, что у LLM); tool-error/таймаут (сюита НЕ исполнилась) → bounded defer (re-queue **`tester`**-джоба, `test_runner_infra_max_retries`) → fail-closed `FAIL` + INFRA-alert на исчерпании (инфра ≠ код-фейл, никогда тихий advance/ложный green, не жжёт developer-retry на транзиентной инфре). **Гибрид (BR-8/NFR-7):** LLM строго off-control-path — детерминированный раннер единственный продюсер `result:`; будущий off-control-path триаж падений не выносит/не переопределяет вердикт и не добавляет ребро в `STAGE_TRANSITIONS` (в Phase 1 не реализован). `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_tests_passed`/`_parse_tests_verdict`/machine-verdict/схема БД — **байт-в-байт не тронуты** (замена *продюсера*, не гейта). Наблюдаемость — in-process счётчики + блок `test_runner` в `GET /queue`. Откат — `ORCH_TEST_RUNNER_ENABLED=false` (прежний LLM-tester-путь байт-в-байт). Детали — `docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md`. - **Queue** (`src/queue_worker.py`, ORCH-1) — персистентная очередь задач (SQLite `jobs`), atomic claim, max_concurrency, ретраи, restart-safe. **ORCH-026:** `claim_next_job` гейтит задачи с незавершёнными зависимостями (`job_deps`, `NOT EXISTS`) без занятия слота; декларации/циклы — leaf `src/task_deps.py`. - **Job-reaper** (`src/job_reaper.py`, ORCH-065 — [adr-0011](adr/adr-0011-job-reaper-lease-reclaim.md)) — фоновый daemon-поток (каркас `reconciler`), стартует/останавливается в `main.lifespan` (после `reconciler.start()` / перед `worker.stop()`). Детектирует «мёртвый» `running`-job **без рестарта** процесса (Tier-1 мёртвый `jobs.pid` после `reaper_dead_ticks` тиков; Tier-2 `agent_runs.exit_code` записан, а job ещё `running`; Tier-3 backstop `reaper_max_running_s`) и приводит строку к корректному статусу через те же контракты (`_try_advance_stage`/`_finalize_job`, gate-driven; exit≠0/неизвестно → `attempts`. `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_*`/machine-verdict/схемы существующих таблиц — байт-в-байт. Подробнее ниже (§ «Единое владение side-effectful переходами»). Детали — `docs/work-items/ORCH-114/06-adr/ADR-001-transition-ownership-lease-and-stage-cas.md`. @@ -447,7 +448,14 @@ ORCH-079 синхронизирует витрину с кодом и закры (перехват в `launch_job` до `_spawn`, как D1/D2) — A6 переходит из «план» в «реализовано». Карта `llm-call-sites.md` (A6), `llm-determinization-roadmap.md` (rank 1, инвариант «ровно один `first_slice`») и анти-дрейф-тесты обновляются **атомарно с кодом** в development (норматив - сопровождения NFR-6). Второй кандидат — `tester`-гибрид (rank 2) — остаётся планом. + сопровождения NFR-6). +- **Второй срез реализован (ORCH-116 — [adr-0049](adr/adr-0049-deterministic-test-runner.md)):** + rank-2 кандидат **tester (`result:`)** заменён детерминированным `src/test_runner.py` (тем же + перехватом до `_spawn`) — A5 переходит из «план» в «реализовано». `needs-hybrid-fallback`-природа + сохранена: детерминированное ядро (exit-код `pytest` + smoke) вынесено в раннер, LLM-ветвь жива как + fallback / будущий off-control-path триаж (не продюсер `result:`). Машинные блоки карты/roadmap + держат `first_slice=yes` у rank 1 (deployer) и `no`/`hybrid_needed=yes` у rank 2 (tester) — инвариант + не нарушен; правки атомарны с кодом (NFR-6). - ADR: [adr-0047](adr/adr-0047-llm-usage-policy-and-call-site-map.md); детально — `docs/work-items/ORCH-118/06-adr/ADR-001-llm-call-site-map-and-determinization-roadmap.md`. diff --git a/docs/architecture/internals.md b/docs/architecture/internals.md index 781743f..43f905b 100644 --- a/docs/architecture/internals.md +++ b/docs/architecture/internals.md @@ -109,6 +109,19 @@ LLM). Leaf `src/staging_runner.py` (зеркало `run_deploy_finalizer`) ис `self_deploy.map_exit_code_to_status`, пишет `15-staging-log.md` (тот же machine-key `staging_status:`) и вызывает существующий `advance_stage(finished_agent="deployer")` (см. §5). Так LLM-агент `deployer` на `deploy-staging` исчезает из happy-path; `STAGE_TRANSITIONS`/`QG_CHECKS`/схема БД не тронуты. +**ORCH-116 ([adr-0049](adr/adr-0049-deterministic-test-runner.md)):** тем же паттерном (рядом с +ORCH-115) перехватывается джоб `tester` на стадии `testing` для in-scope репо с тест-контрактом +(дискриминатор — роль `tester` **И** `tasks.stage == "testing"` **И** `test_runner.applies(repo)` под +kill-switch `test_runner_enabled`, скоуп `test_runner_repos`, резолв `_has_test_contract`; пусто → +self-hosting only; `should_intercept` never-raise → `False` → штатный `_spawn`, fail-safe к LLM). Leaf +`src/test_runner.py` (зеркало `run_staging_gate`) исполняет регресс `pytest ` **в worktree +ветки** через `proc_group` (tree-kill, таймаут `test_runner_timeout_s`) + read-only smoke, маппит +exit-код `self_deploy.map_exit_code_to_status` в токенах `result:` (`0→PASS`/иначе→`FAIL`), пишет +`13-test-report.md` (тот же machine-key `result:`; 52c-`status:` выровнен по вердикту — D6.1) и вызывает +существующий `advance_stage(finished_agent="tester")` (см. §5). Двухуровневый исход (анти-ORCH-110): +сюита НЕ исполнилась → bounded defer re-queue **`tester`**-джоба, не код-фейл-откат. Так LLM-агент +`tester` на `testing` исчезает из happy-path; `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_tests_passed`/схема +БД не тронуты. ### 5. Auto-advance (`launcher._try_advance_stage`) diff --git a/docs/architecture/llm-call-sites.md b/docs/architecture/llm-call-sites.md index 4c361c2..b4f2a1f 100644 --- a/docs/architecture/llm-call-sites.md +++ b/docs/architecture/llm-call-sites.md @@ -57,7 +57,7 @@ | **A2** | `.openclaw/agents/architect.md` | стадия `architecture` | architect | `06-adr/`, `07` | — | `check_architecture_done:62` (наличие 06-adr/07) | ~80–200k / 5–20 мин | да (через S0) | **P** | `keep-LLM` | архитектурное решение / ADR — настоящее суждение | | **A3** | `.openclaw/agents/developer.md` | стадия `development` | developer | код + PR | — | `check_ci_green:82` (+ `check_branch_mergeable:657`) — CI/merge | ~150–400k / 10–40 мин | да (через S0) | **P** | `keep-LLM` | написание кода — настоящее суждение; гейт судит CI/merge, не самоотчёт | | **A4** | `.openclaw/agents/reviewer.md` | стадия `review` | reviewer | `12-review.md` | `verdict:` | `check_reviewer_verdict:336` (`verdict:`) | ~100–300k / 5–25 мин | да (через S0) | **C** | `keep-LLM` | control path, но вердикт «приемлемость кода/решения» **НЕ деривируем** из exit-кода — настоящее суждение | -| **A5** | `.openclaw/agents/tester.md` | стадия `testing` | tester | `13-test-report.md` | `result:` | `check_tests_passed:182` → `_parse_tests_verdict:226` (`result:`) | ~60–150k / 5–20 мин | да (через S0) | **C** | `needs-hybrid-fallback` | **avoidable**: PASS/FAIL = exit-code `pytest`+smoke (деривируем); LLM нужен лишь на триаж падений / маппинг TC↔критерии | +| **A5** | `.openclaw/agents/tester.md` | стадия `testing` | tester | `13-test-report.md` | `result:` | `check_tests_passed:182` → `_parse_tests_verdict:226` (`result:`) | ~60–150k / 5–20 мин | да (через S0; для in-scope репо на `testing` — **нет**, перехват до `_spawn`) | **C** | `needs-hybrid-fallback` | **avoidable, СРЕЗ РЕАЛИЗОВАН (ORCH-116):** на `testing` для self-hosting `orchestrator` (репо с тест-контрактом) вердикт `result:` производит детерминированный `src/test_runner.py` (перехват в `launch_job` до `_spawn`, как D1/D2) — exit-код `pytest` в worktree + read-only smoke. LLM-ветвь остаётся **fallback'ом** под выключенным флагом / для репо без контракта / как будущий **off-control-path** триаж падений (маппинг TC↔критерии), который НЕ выносит и НЕ переопределяет `result:` (гибрид-природа `needs-hybrid-fallback` сохранена) | | **A6** | `.openclaw/agents/deployer.md` | стадии `deploy-staging` / `deploy` | deployer | `15-staging-log.md` / `14-deploy-log.md` | `staging_status:` / `deploy_status:` | `check_staging_status:599` → `_parse_staging_status:538` (`staging_status:`); `check_deploy_status:473` → `_parse_deploy_status:413` (`deploy_status:`) | ~40–120k / 3–15 мин | да (через S0; для in-scope репо на `deploy-staging` — **нет**, перехват до `_spawn`) | **C** | `replace-deterministic-now` | **avoidable, СРЕЗ РЕАЛИЗОВАН (ORCH-115):** на `deploy-staging` для self-hosting `orchestrator` вердикт `staging_status:` производит детерминированный `src/staging_runner.py` (перехват в `launch_job` до `_spawn`, как D1/D2) — маппинг exit-кода `staging_check.py`; прод уже детерминирован Phase A/B/C (ORCH-036). LLM-ветвь остаётся fallback'ом под выключенным флагом / для не-self репо | | **D1** | `src/agents/launcher.py:389` (перехват в `launch_job` **до** `_spawn`; «Not an LLM spawn» `407`) | post-deploy edge | deploy-finalizer | jobs-row | — | — | — (детерминированный) | **нет** (слот, перехват до `_spawn`) | — | `already-deterministic` (эталон) | Занимает слот агента, но LLM не консультируется — рабочий прецедент замены | | **D2** | `src/agents/launcher.py:394` (перехват в `launch_job` **до** `_spawn`; «Not an LLM spawn» `428`) | post-deploy observation | post-deploy-monitor | jobs-row | — | — | — (детерминированный) | **нет** (слот, перехват до `_spawn`) | — | `already-deterministic` (эталон) | Тик наблюдения; LLM не консультируется | @@ -154,7 +154,13 @@ `replace-deterministic-now` без ввода второго транспорта (раннер LLM не зовёт) — карта/инвариант «единственный транспорт S0» соблюдены. Машинный `ORCH-118-INVENTORY-BLOCK` сохраняет deployer как `avoidable=yes`/`axis=C` (LLM-ветвь жива как fallback под выключенным флагом / для не-self репо). - Второй кандидат (`tester`) остаётся follow-up'ом по роли. + **Второй срез — tester (`result:`)** — реализован **ORCH-116** (`src/test_runner.py`, тем же + перехватом до `_spawn`): на `testing` для in-scope репо вердикт `result:` производит + детерминированный код (exit-код `pytest` в worktree + read-only smoke), не LLM. Это + `needs-hybrid-fallback`, тоже без второго транспорта (раннер LLM не зовёт). Машинный + `ORCH-118-INVENTORY-BLOCK` сохраняет tester как `avoidable=yes`/`axis=C`/ + `classification=needs-hybrid-fallback` — LLM-ветвь жива как fallback (выключенный флаг / репо без + контракта) и как будущий **off-control-path** триаж, который не выносит `result:`. - **Анти-дрейф тесты:** `tests/test_llm_call_site_inventory.py` (TC-01…TC-06, TC-09, TC-12, TC-13, TC-14) и `tests/test_llm_determinization_docs.py` (TC-07/08/11). Дискриминатор всех проверок — **«консультирует LLM», а не «спавнит subprocess»**. diff --git a/docs/architecture/llm-determinization-roadmap.md b/docs/architecture/llm-determinization-roadmap.md index 3f6579a..329f861 100644 --- a/docs/architecture/llm-determinization-roadmap.md +++ b/docs/architecture/llm-determinization-roadmap.md @@ -39,12 +39,24 @@ замены агента уже снят рабочим паттерном. 4. **`replace-deterministic-now`, без hybrid-fallback** (в отличие от tester). -## 2. Второй кандидат — **tester (гибрид)** +## 2. Второй кандидат — **tester (гибрид)** — ✅ РЕАЛИЗОВАН (ORCH-116) + +> **Статус: реализовано.** Срез выполнен в **ORCH-116** — `src/test_runner.py` (перехват в +> `launch_job` до `_spawn`, как `D1`/`D2`/ORCH-115): на стадии `testing` для self-hosting +> `orchestrator` вердикт `result:` производит детерминированный код (exit-код `pytest tests/` в +> worktree ветки + read-only smoke `/health`/`/status`/`/queue`+`serial_gate`, маппинг через +> `self_deploy.map_exit_code_to_status` в токенах `PASS`/`FAIL`), а не LLM. Под kill-switch +> `test_runner_enabled` + скоуп `test_runner_repos` (пусто → self-hosting only) + резолв тест-контракта +> (репо без контракта → LLM-tester, fail-safe). Контракт артефакта/гейта `check_tests_passed`/ +> `STAGE_TRANSITIONS`/схема БД — не тронуты. Запись `rank 2` в машинном блоке §4 сохраняется +> (`first_slice = no`, `hybrid_needed = yes` — инвариант карты) как фиксация второго среза. Детерминированное ядро (`pytest` + smoke даёт PASS/FAIL по exit-коду) покрывает основной вердикт; LLM-фолбэк сохраняется **только** на суждение, не сводимое к exit-коду: **триаж падений** и **маппинг TC ↔ критерии приёмки**. Поэтому `needs-hybrid-fallback`, а не `replace-deterministic-now`: поверхность -суждения шире и объём работы больше. +суждения шире и объём работы больше. В Phase 1 (ORCH-116) детерминированное ядро вынесено в раннер; +off-control-path LLM-триаж (он **не** выносит и **не** переопределяет `result:`, **не** добавляет ребро +в `STAGE_TRANSITIONS`) зафиксирован как Phase 2 follow-up по роли и в этом срезе не реализуется. ## 3. Общие требования к каждому follow-up'у diff --git a/docs/architecture/llm-usage-policy.md b/docs/architecture/llm-usage-policy.md index c4b40a0..f0bccd6 100644 --- a/docs/architecture/llm-usage-policy.md +++ b/docs/architecture/llm-usage-policy.md @@ -99,3 +99,10 @@ Call-site является **avoidable LLM control path** тогда и толь детерминированный `src/staging_runner.py` производит `staging_status:` без `_spawn` (перехват до него, как `D1`/`D2`) — раннер **LLM не зовёт** и **второй транспорт не вводит**, поэтому инвариант «единственный транспорт S0» соблюдён (TC-12 зелёный). Это образец для последующих срезов roadmap'а. +- **Реализованный срез (ORCH-116).** ORCH-116 снял A5/tester тем же паттерном: детерминированный + `src/test_runner.py` производит `result:` на `testing` для in-scope репо без `_spawn` (перехват до + него, как `D1`/`D2`) — exit-код `pytest` в worktree + read-only smoke. Это `needs-hybrid-fallback` + (детерминированное ядро вынесено; LLM-фолбэк на не-деривируемое суждение — триаж падений / маппинг + TC↔критерии — остаётся **off-control-path** и **не** производит `result:`). Раннер **LLM не зовёт** и + **второй транспорт не вводит** → инвариант «единственный транспорт S0» соблюдён (TC-12 зелёный). + Будущий off-control-path триаж — **не** новый транспорт control-path-консультации (он вне control-path). diff --git a/docs/overview/tech-agents.md b/docs/overview/tech-agents.md index 7d919ed..05f3f31 100644 --- a/docs/overview/tech-agents.md +++ b/docs/overview/tech-agents.md @@ -54,6 +54,14 @@ Machine-verdict ключи читаются гейтами **только из Y под выключенным флагом / для не-self репо и продолжает вести прод-стадию `deploy`. Подробнее — [конвейер](tech-pipeline.md) и [карта LLM-консультаций](../architecture/llm-call-sites.md). +Особенность (ORCH-116): на стадии `testing` для self-hosting `orchestrator` LLM-`tester` заменён +**детерминированным test-раннером** (`src/test_runner.py`) — его PASS/FAIL-ядро деривируемо (exit-код +`pytest` в worktree + read-only smoke), вердикт `result:` производит детерминированный код. Это +гибрид (`needs-hybrid-fallback`): LLM-промпт `tester` остаётся fallback'ом под выключенным флагом / для +репо без тест-контракта, а будущий off-control-path триаж падений не выносит и не переопределяет +`result:`. Подробнее — [конвейер](tech-pipeline.md) и +[карта LLM-консультаций](../architecture/llm-call-sites.md). + ## Человек как седьмая роль Человек не пишет артефакты конвейера, но принимает два решения, которые не делегированы diff --git a/docs/overview/tech-pipeline.md b/docs/overview/tech-pipeline.md index a4d35e5..b7c678c 100644 --- a/docs/overview/tech-pipeline.md +++ b/docs/overview/tech-pipeline.md @@ -44,6 +44,17 @@ created → analysis → architecture → development → review → testing → > на стадии снова работает LLM-`deployer` байт-в-байт. Это первый реализованный срез > determinization-roadmap (см. `docs/architecture/llm-determinization-roadmap.md`). +> **Детерминированный test-раннер (ORCH-116).** На стадии `testing` для self-hosting `orchestrator` +> работу ведёт **детерминированный код** (`src/test_runner.py`), а не LLM-агент `tester`: он +> перехватывается в `launch_job` до запуска агента (тем же паттерном, что staging-раннер), исполняет +> регресс `pytest` в worktree ветки + read-only smoke, маппит exit-код в `result:` и инициирует **тот +> же** гейт `check_tests_passed`. Это замена *продюсера* артефакта, а не гейта: контракт +> `13-test-report.md`, имя/семантика `check_tests_passed`/`_parse_tests_verdict`, `STAGE_TRANSITIONS` +> — не изменились. Под kill-switch `test_runner_enabled` (скоуп `test_runner_repos`, пусто → +> self-hosting only; репо без тест-контракта → LLM-tester); при выключении снова работает LLM-`tester` +> байт-в-байт. Это второй реализованный срез determinization-roadmap (гибрид: LLM-фолбэк остаётся на +> off-control-path триаж, не на вынесение `result:`). + ## Под-гейты деплойного ребра — врезки, не стадии На переходе `deploy-staging → deploy` исполняются четыре под-гейта в нормативном порядке diff --git a/docs/overview/tech-quality-security.md b/docs/overview/tech-quality-security.md index abcae9c..602e319 100644 --- a/docs/overview/tech-quality-security.md +++ b/docs/overview/tech-quality-security.md @@ -53,7 +53,10 @@ control-path и его вердикт деривируем из exit-кодов анти-дрейф тестами. **Первый срез реализован (ORCH-115):** на `deploy-staging` для self-hosting `orchestrator` LLM-`deployer` заменён детерминированным `src/staging_runner.py` (вердикт `staging_status:` = маппинг exit-кода staging-сюиты); LLM-ветвь остаётся fallback'ом, гейт -`check_staging_status` не тронут. Замена второго кандидата (`tester`) — follow-up по роли. +`check_staging_status` не тронут. **Второй срез реализован (ORCH-116):** на `testing` для self-hosting +`orchestrator` LLM-`tester` заменён детерминированным `src/test_runner.py` (вердикт `result:` = exit-код +`pytest` + read-only smoke); это гибрид (`needs-hybrid-fallback`) — LLM-ветвь остаётся fallback'ом / +будущим off-control-path триажем, гейт `check_tests_passed`/`_parse_tests_verdict` не тронут. - Карта вызовов LLM: [`../architecture/llm-call-sites.md`](../architecture/llm-call-sites.md) - Нормативная политика: [`../architecture/llm-usage-policy.md`](../architecture/llm-usage-policy.md) diff --git a/src/agents/launcher.py b/src/agents/launcher.py index 015eefd..643a4e5 100644 --- a/src/agents/launcher.py +++ b/src/agents/launcher.py @@ -406,6 +406,17 @@ class AgentLauncher: from .. import staging_runner if staging_runner.should_intercept(job): return self._run_staging_runner_job(job) + # ORCH-116: deterministic test-runner intercept (BEFORE _spawn). The LLM + # ``tester`` on the ``testing`` stage (self-hosting scope, repo with a + # test-contract) is replaced by a DETERMINISTIC test-runner (same precedent + # as deploy-finalizer / post-deploy-monitor / staging-runner). ``tester`` is + # the only agent entering ``testing``; the stage guard is defense-in-depth. + # Kill-switch off / out of scope / no contract -> should_intercept False -> + # the prior LLM tester runs via _spawn byte-for-byte. + if job.get("agent") == "tester": + from .. import test_runner + if test_runner.should_intercept(job): + return self._run_test_runner_job(job) return self._spawn( job["agent"], job["repo"], @@ -457,6 +468,28 @@ class AgentLauncher: pass return None + def _run_test_runner_job(self, job: dict): + """ORCH-116: run the deterministic test gate for a tester job on `testing`. + + Not an LLM spawn — there is no subprocess/monitor of an agent, so we mark the + jobs row done/failed here (mirror of _run_staging_runner_job). The runner + never-raises, but we guard anyway so a runner fault can't wedge the worker. + Returns None (no agent_run row, _spawn not called). + """ + from ..db import mark_job + from .. import test_runner + try: + test_runner.run_test_gate(job) + mark_job(job["id"], "done") + logger.info(f"test-runner job {job['id']} done") + except Exception as e: + logger.error(f"test-runner job {job['id']} failed: {e}") + try: + mark_job(job["id"], "failed", error=f"test-runner error: {e}") + except Exception: + pass + return None + def _run_post_deploy_monitor_job(self, job: dict): """ORCH-021: run one deterministic post-deploy monitor tick for a job. diff --git a/src/config.py b/src/config.py index 5c7d9f8..b754f5b 100644 --- a/src/config.py +++ b/src/config.py @@ -475,6 +475,57 @@ class Settings(BaseSettings): staging_runner_infra_retry_delay_s: int = 30 staging_runner_exec_host_side: bool = True + # ORCH-116: deterministic test-runner replacing the LLM `tester` agent on the + # `testing` stage for the self-hosting orchestrator (second realised slice of the + # determinization-roadmap, A5/tester needs-hybrid-fallback; first was ORCH-115/ + # deployer). A new leaf src/test_runner.py (never-raise) is intercepted in + # launch_job BEFORE _spawn (mirroring the deploy-finalizer / post-deploy-monitor / + # staging-runner precedent, launcher.py:397/402/405): it runs the SAME regression + # `python -m pytest ` in the task worktree via proc_group (tree-kill) + + # the read-only smoke (/health,/status,/queue + serial_gate block), maps the + # exit-code -> result: PASS|FAIL via the existing self_deploy.map_exit_code_to_status + # contract, writes 13-test-report.md, and initiates the EXISTING check_tests_passed + # gate exactly as a finished LLM-tester would. The artifact contract, the gate, + # STAGE_TRANSITIONS and the DB schema are byte-for-byte UNCHANGED — this only + # replaces the *producer* of the artifact. Pattern = staging_runner_* / coverage_gate_*. + # See docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md and + # docs/architecture/adr/adr-0049-deterministic-test-runner.md. + # test_runner_enabled -> SINGLE kill-switch (env ORCH_TEST_RUNNER_ENABLED). + # False -> the intercept never fires -> the prior + # LLM tester runs on testing via _spawn byte-for-byte + # as before ORCH-116 (D8/AC-7). + # test_runner_repos -> CSV scope (env ORCH_TEST_RUNNER_REPOS). Empty -> + # self-hosting only (orchestrator) via + # is_self_hosting_repo; non-empty -> membership. + # A repo with no resolvable test-contract is never + # intercepted even if listed (BR-9, _has_test_contract). + # test_runner_target -> pytest target of the test-contract (env + # ORCH_TEST_RUNNER_TARGET; convention merge_retest_target). + # test_runner_timeout_s -> wall-clock budget for the pytest regression (env + # ORCH_TEST_RUNNER_TIMEOUT_S). Malformed/non-positive -> + # default + WARNING (never-break). Aligned with the + # cross-cutting budget invariant ORCH-065/109/110 WITHOUT + # touching reaper_max_running_s (D9): it replaces the + # <=1800s LLM testing window (agent_timeout_seconds) with a + # bounded <=900s deterministic one (Σ on the edge does not grow). + # test_runner_smoke_enabled -> optional read-only smoke (env ORCH_TEST_RUNNER_SMOKE_ENABLED). + # False -> pytest exit-code is the sole signal (smoke skipped). + # test_runner_infra_max_retries -> tool-error (suite did NOT execute: spawn-error / timeout / + # returncode None) bounded DEFER budget before a fail-closed + # FAIL (env ORCH_TEST_RUNNER_INFRA_MAX_RETRIES). Mirrors + # staging_runner_infra_max_retries — infra hiccup is NOT a + # code-fault, so it never burns a developer-retry until the + # budget is exhausted (D5, anti ORCH-110). + # test_runner_infra_retry_delay_s-> delay before the re-queued tester job (env + # ORCH_TEST_RUNNER_INFRA_RETRY_DELAY_S). + test_runner_enabled: bool = True + test_runner_repos: str = "" + test_runner_target: str = "tests/" + test_runner_timeout_s: int = 900 + test_runner_smoke_enabled: bool = True + test_runner_infra_max_retries: int = 2 + test_runner_infra_retry_delay_s: int = 30 + # ORCH-098 (FND/F2): machine lessons-journal — additive `lessons` table + leaf # src/lessons.py (never-raise observer, by образцу serial_gate/coverage_gate/ # metrics). The journal is an OBSERVER, never a Quality Gate: writing a lesson diff --git a/src/main.py b/src/main.py index 9655e91..874c29c 100644 --- a/src/main.py +++ b/src/main.py @@ -251,6 +251,7 @@ async def queue(): from . import checkout_hygiene from . import transition_lease from . import staging_runner + from . import test_runner from .disk_watchdog import disk_watchdog from .build_cache_pruner import build_cache_pruner return { @@ -304,6 +305,11 @@ async def queue(): # failed/tool_error/deferred counters, so a code-fail FAILED is distinguishable # from an infra tool-error. Additive block; never-raise. "staging_runner": staging_runner.snapshot(), + # ORCH-116 (FR-8 / AC-13): deterministic test-runner observability (read-only) + # — kill-switch, scope, target, timeout/smoke/infra budget + run/pass/fail/ + # tool_error/deferred counters, so a code-fail FAIL is distinguishable from an + # infra tool-error. Additive block; never-raise. + "test_runner": test_runner.snapshot(), # ORCH-098 (FR-4 / AC-4): lessons-journal observability (read-only) — # kill-switch + counts by type/status + last N lessons. Additive block; # never-raise (snapshot() returns {"enabled": ...} minimum on error). diff --git a/src/test_runner.py b/src/test_runner.py new file mode 100644 index 0000000..fd80970 --- /dev/null +++ b/src/test_runner.py @@ -0,0 +1,705 @@ +"""Deterministic test-runner (ORCH-116). + +The ``testing`` stage for the self-hosting ``orchestrator`` repo was driven by the +LLM ``tester`` agent, but its PASS/FAIL core is purely deterministic +(``.openclaw/agents/tester.md`` steps 1-3): run the regression ``pytest tests/`` in +the task worktree, do a read-only smoke (``/health`` / ``/status`` / ``/queue`` + +``serial_gate`` block), map the exit-code to a verdict (``0 -> PASS``, else ``FAIL``) +and write ``13-test-report.md`` with the machine frontmatter ``result: PASS|FAIL``. +This leaf replaces that LLM consultation with deterministic code, intercepted in +``launcher.launch_job`` BEFORE ``_spawn`` (the ``deploy-finalizer`` / +``post-deploy-monitor`` / ``staging-runner`` reserved-agent precedent, +``launcher.py:397/402/405``). It is the second realised slice of the +determinization-roadmap (A5/tester, ``needs-hybrid-fallback``; the first was +ORCH-115/deployer — ``src/staging_runner.py``). + +Hybrid nature (the key difference from ORCH-115): tester is +``needs-hybrid-fallback``, not ``replace-deterministic-now``. Its PASS/FAIL core is +fully derivable (pytest exit-code + smoke) and that is what this deterministic runner +owns; a future OPTIONAL **off-control-path** LLM triage/diagnosis after a +deterministic FAIL stays allowed (a separate role/job that never writes/overrides +``result:`` and never adds a STAGE_TRANSITIONS edge). Phase 1 does NOT implement the +triage but the architecture does not forbid it (D11/FR-9/AC-12). + +What is and is NOT changed (NFR-1, the critical invariant): + * UNCHANGED — the artifact contract (``13-test-report.md`` with ``result: + PASS|FAIL``), the gate ``check_tests_passed`` / ``_parse_tests_verdict``, + ``STAGE_TRANSITIONS``, the DB schema. This module replaces only the *producer* of + the artifact, never the gate that reads it. + * NEW — a deterministic producer + a launch_job intercept. Under a kill-switch + + repo-scope CSV + a test-contract resolve; fail-safe back to the LLM path when off + / out of scope / no contract. + +This module is a **leaf** (mirror of ``staging_runner`` / ``self_deploy`` / +``proc_group``): it imports only ``config`` / ``logging`` / ``proc_group`` at module +load; ``db`` / ``git_worktree`` / ``self_deploy.map_exit_code_to_status`` / +``qg.checks`` / ``stage_engine.advance_stage`` / ``notifications`` are imported LAZILY +inside functions so the heavy ``stage_engine`` is never pulled at import and no import +cycle forms. Every public function honours a **never-raise** contract (AC-9): a test +infra hiccup can never crash the worker / wedge the queue. + +Two-level outcome (D5 — the key safety decision, anti ORCH-110): + * the suite EXECUTED (a real exit-code, 0 or non-zero) -> trust the code: + ``0 -> PASS -> advance``; ``!=0 -> FAIL -> the existing rollback testing -> + development`` (same developer-retry path as a FAIL LLM verdict). A smoke failure + AND-s into ``FAIL`` (deterministic), it is NOT a tool-error. + * the suite did NOT execute (tool-error: spawn-error / timeout / ``returncode is + None``) -> an infra fault, NOT a code fault -> a bounded DEFER (re-queue a fresh + ``tester`` job with a delay + a restart-safe marker). On budget exhaustion -> + fail-closed ``FAIL`` + advance + alert. So the runner NEVER does a silent advance + / false green, and NEVER wedges the queue, but does NOT burn a developer-retry on + transient infra. +""" + +import logging +import time +import urllib.error +import urllib.request + +from .config import settings +from . import proc_group + +logger = logging.getLogger("orchestrator.test_runner") + +# Default wall-clock budget for the pytest regression (D9). Kept <= the LLM testing +# window it replaces (agent_timeout_seconds=1800) so Σ(work on the testing edge) does +# not grow and the cross-cutting reaper invariant (ORCH-065/109/110) holds WITHOUT +# touching reaper_max_running_s. 900s = ~74% headroom over the ~517s regression suite. +_DEFAULT_TIMEOUT_S = 900 + +_GIT_TIMEOUT = 60 + +# Read-only smoke knobs (D3). Transient unreachability (connection refused / timeout) +# is retried briefly before a FAIL so a single prod-8500 blip does not roll back a +# healthy branch; a reachable-but-wrong-form response (non-200 / no serial_gate block) +# is an immediate FAIL. +_SMOKE_TIMEOUT_S = 5 +_SMOKE_MAX_ATTEMPTS = 3 +_SMOKE_BACKOFF_S = 1.0 + +# Restart-safe DEFER marker (counted from the persisted jobs queue, mirror of +# staging_runner._INFRA_RETRY_MARKER / stage_engine._merge_infra_retry_count). Embedded +# verbatim in the re-queued job's task_content so a service restart never resets the +# infra-retry budget. +_INFRA_RETRY_MARKER = "test-runner infra-retry" + +# In-process observability counters (mirror staging_runner._STAGING_RUNNER_COUNTERS). +_TEST_RUNNER_COUNTERS: dict = { + "runs": 0, # run_test_gate entered + "pass": 0, # suite ran, exit 0 + smoke ok -> PASS + "fail": 0, # suite ran non-zero / smoke failed, OR infra budget exhausted -> FAIL + "tool_error": 0, # suite did NOT execute (spawn-error / timeout / None) + "deferred": 0, # bounded infra DEFER (re-queued) +} + + +def _bump(key: str) -> None: + """Increment an observability counter. Never raises.""" + try: + _TEST_RUNNER_COUNTERS[key] += 1 + except Exception: # noqa: BLE001 - observability must never break a decision + pass + + +# --------------------------------------------------------------------------- +# Conditionality (D8 / FR-7 / AC-7 / AC-8) +# --------------------------------------------------------------------------- +def _has_test_contract(repo: str) -> bool: + """Whether a test-contract (regression + smoke) is resolvable for ``repo`` (BR-9). + + In Phase 1 the contract is known by default ONLY for the self-hosting repo + (``orchestrator`` — ``pytest tests/`` + the read-only smoke); for every other repo + there is no contract yet (Phase 2 project test-contract) -> ``applies`` is False -> + the prior LLM-tester runs (fail-safe, AC-8). This makes AC-8 checkable: even if a + non-self repo (e.g. ``enduro-trails``) is hand-added to ``test_runner_repos``, + ``_has_test_contract`` returns False -> it is never intercepted. never-raise. + """ + try: + from .qg.checks import is_self_hosting_repo + return is_self_hosting_repo(repo) + except Exception as e: # noqa: BLE001 - never-raise contract + logger.warning("test_runner._has_test_contract error for %s: %s", repo, e) + return False + + +def applies(repo: str) -> bool: + """Whether the deterministic test-runner is REAL for ``repo``. + + Mirrors ``staging_runner.applies`` / ``coverage_gate``: + * ``test_runner_enabled=False`` -> always False (global kill-switch); the legacy + LLM-tester path runs on ``testing`` via ``_spawn``. + * ``test_runner_repos`` (CSV) non-empty -> only the listed repos. + * empty CSV -> only the self-hosting repo (``orchestrator``). + * AND a test-contract is resolvable for the repo (BR-9, ``_has_test_contract``). + Checked FIRST in ``should_intercept`` (local, no network, no DB) so a disabled flag + costs nothing. never-raise -> False (fail-safe to the prior LLM path). + """ + try: + if not settings.test_runner_enabled: + return False + raw = (settings.test_runner_repos or "").strip() + if raw: + allowed = {r.strip().lower() for r in raw.split(",") if r.strip()} + in_scope = (repo or "").strip().lower() in allowed + else: + # Lazy import keeps this module a leaf (no qg import at module load). + from .qg.checks import is_self_hosting_repo + in_scope = is_self_hosting_repo(repo) + if not in_scope: + return False + return _has_test_contract(repo) + except Exception as e: # noqa: BLE001 - never-raise contract + logger.warning("test_runner.applies error for %s: %s", repo, e) + return False + + +def should_intercept(job: dict) -> bool: + """True iff this ``tester`` job is the deterministic test-suite job (D1). + + ``tester`` is the ONLY agent that enters the ``testing`` stage + (``STAGE_TRANSITIONS["review"]["agent"]``), so there is no stage collision as + there was for the shared ``deployer`` role (ORCH-115); the + ``tasks.stage == "testing"`` guard is kept as defense-in-depth (R-1) — it stops a + stray future ``tester`` job outside ``testing`` from being intercepted. Intercept + iff ``agent == "tester"`` AND ``applies(repo)`` AND ``tasks.stage == "testing"``. + + never-raise -> False (a DB-lookup failure falls through to ``_spawn``, fail-safe to + the prior LLM path). + """ + try: + if (job.get("agent") or "") != "tester": + return False + # applies() FIRST (local, no DB): disabled flag -> zero DB overhead. + if not applies(job.get("repo")): + return False + task_id = job.get("task_id") + if task_id is None: + return False + from .db import get_db + conn = get_db() + row = conn.execute("SELECT stage FROM tasks WHERE id=?", (task_id,)).fetchone() + conn.close() + if not row: + return False + return (row[0] or "") == "testing" + except Exception as e: # noqa: BLE001 - never-raise contract + logger.warning("test_runner.should_intercept error: %s", e) + return False + + +# --------------------------------------------------------------------------- +# Suite execution (D3 / FR-2 / NFR-3 / AC-9 / AC-11) +# --------------------------------------------------------------------------- +def build_test_command() -> list[str]: + """Build the canonical regression argv (the same command the LLM-tester ran). + + ``python -m pytest -q`` (default ``tests/``, convention + ``merge_retest_target``). Self-hosting safety (BR-7 / AC-10 / TC-13): NO restart of + 8500, NO ``docker compose up orchestrator`` / ``--build``, NO force-push, NO + ``.env`` edit — the runner only executes pytest in the task worktree and does + read-only GETs. + """ + target = (settings.test_runner_target or "tests/").strip() or "tests/" + return ["python", "-m", "pytest", target, "-q"] + + +def _resolve_timeout() -> int: + """Resolve ``test_runner_timeout_s`` (malformed/non-positive -> default + WARNING, + never-break — mirror of ``staging_runner._resolve_timeout`` / + ``merge_gate._resolve_retest_timeout``).""" + raw = getattr(settings, "test_runner_timeout_s", _DEFAULT_TIMEOUT_S) + try: + t = int(raw) + if t > 0: + return t + logger.warning( + "test_runner_timeout_s non-positive (%r) -> default %ds", raw, _DEFAULT_TIMEOUT_S + ) + except (TypeError, ValueError): + logger.warning( + "test_runner_timeout_s malformed (%r) -> default %ds", raw, _DEFAULT_TIMEOUT_S + ) + return _DEFAULT_TIMEOUT_S + + +def run_test_suite(repo: str, branch: str) -> proc_group.ProcResult: + """Execute the pytest regression IN THE TASK WORKTREE, tree-killed on timeout. + + Runs in ``git_worktree.get_worktree_path(repo, branch)`` (NOT the shared + ``/repos/orchestrator`` — anti checkout-race, the same context coverage-gate / + merge-gate re-test use) through ``proc_group.run_in_process_group`` (ORCH-110) so a + hung pytest subtree is killed whole (no orphans, AC-11). Never raises (proc_group + degrades any OS error to a safe ``ProcResult``; a missing worktree -> a ProcResult + with ``returncode is None`` -> the tool-error DEFER path). + """ + cmd = build_test_command() + timeout = _resolve_timeout() + try: + grace = float(getattr(settings, "agent_kill_grace_seconds", 5) or 5) + except (TypeError, ValueError): + grace = 5.0 + try: + from .git_worktree import get_worktree_path + wt = get_worktree_path(repo, branch) + except Exception as e: # noqa: BLE001 - never-raise -> tool-error DEFER + logger.error("run_test_suite: worktree error for %s/%s: %s", repo, branch, e) + return proc_group.ProcResult(returncode=None, stdout="", stderr=str(e), timed_out=False) + return proc_group.run_in_process_group( + cmd, + cwd=wt, + timeout=timeout, + grace_s=grace, + tree_kill=bool(getattr(settings, "subprocess_tree_kill_enabled", True)), + ) + + +# --------------------------------------------------------------------------- +# Read-only smoke (D3 / FR-2 / AC-10) — stdlib urllib, never-raise +# --------------------------------------------------------------------------- +def _http_get(url: str) -> tuple[int, str]: + """GET ``url`` -> (http_code, body). Network/timeout -> (0, ""). Never raises. + + Mirror of ``post_deploy._http_status`` (stdlib only, no httpx import at module + load — keeps the leaf pure). ``urllib`` raises ``HTTPError`` for >=400 responses; + that is treated as a real status code (so a 5xx is observed, not swallowed).""" + try: + with urllib.request.urlopen(url, timeout=_SMOKE_TIMEOUT_S) as resp: # noqa: S310 + body = resp.read(8192).decode("utf-8", "replace") + return int(getattr(resp, "status", resp.getcode())), body + except urllib.error.HTTPError as e: + try: + body = e.read(8192).decode("utf-8", "replace") + except Exception: # noqa: BLE001 + body = "" + return int(e.code), body + except Exception as e: # noqa: BLE001 - URLError / socket timeout / anything + logger.warning("test_runner smoke GET error for %s: %s", url, e) + return 0, "" + + +def run_smoke() -> tuple[bool, str]: + """Read-only smoke against the running orchestrator (D3). Returns (ok, detail). + + Strictly read-only GETs (BR-7/AC-10): ``/health`` (HTTP 200), ``/status`` (HTTP + 200), ``/queue`` (HTTP 200 AND the ``serial_gate`` block present, ORCH-088). A + transient unreachability (code 0 = connection refused / timeout) is retried up to + ``_SMOKE_MAX_ATTEMPTS`` with a short backoff before FAIL (anti-flap, so a single + prod blip does not roll back a healthy branch); a reachable-but-wrong-form response + (non-200 / missing serial_gate) is an immediate FAIL. never-raise -> (False, detail) + on any unexpected error.""" + try: + base = (settings.post_deploy_base_url or "http://localhost:8500").rstrip("/") + except Exception as e: # noqa: BLE001 - never-raise + logger.warning("test_runner.run_smoke: base url error: %s", e) + return False, f"smoke base-url error: {e}" + + # (path, validator(code, body) -> (ok, immediate_fail, note)) + def _ok_200(code: int, body: str) -> tuple[bool, bool, str]: + if code == 200: + return True, False, "" + if code == 0: + return False, False, "unreachable" # transient -> retryable + return False, True, f"HTTP {code}" # reachable wrong form -> immediate FAIL + + def _queue_ok(code: int, body: str) -> tuple[bool, bool, str]: + if code == 0: + return False, False, "unreachable" + if code != 200: + return False, True, f"HTTP {code}" + if "serial_gate" not in (body or ""): + return False, True, "no serial_gate block" + return True, False, "" + + checks = (("/health", _ok_200), ("/status", _ok_200), ("/queue", _queue_ok)) + for path, validator in checks: + url = base + path + note = "unreachable" + for attempt in range(1, _SMOKE_MAX_ATTEMPTS + 1): + code, body = _http_get(url) + ok, immediate_fail, note = validator(code, body) + if ok: + break + if immediate_fail: + return False, f"smoke {path} failed: {note}" + # transient (unreachable) -> bounded retry before declaring FAIL. + if attempt < _SMOKE_MAX_ATTEMPTS: + time.sleep(_SMOKE_BACKOFF_S) + else: + return False, f"smoke {path} {note} after {_SMOKE_MAX_ATTEMPTS} attempts" + return True, "smoke ok (/health, /status, /queue + serial_gate)" + + +# --------------------------------------------------------------------------- +# exit-code -> result: (D4 / FR-3 / AC-3) — reuse the single contract, no 2nd mapping +# --------------------------------------------------------------------------- +def map_exit_code_to_result(exit_code) -> str: + """``0 -> PASS``; non-zero / None / non-int -> ``FAIL`` (fail-closed). + + A thin token-translator over ``self_deploy.map_exit_code_to_status`` — the SAME + pure, unit-tested ``0->SUCCESS`` contract the deploy-finalizer / staging-runner use + (BR-4: no second, drifting mapping). Only the tokens differ (``result:`` uses + ``PASS``/``FAIL``, the ``_TESTS_POSITIVE_TOKENS`` / ``_TESTS_NEGATIVE_TOKENS`` the + gate reads), not the logic.""" + from .self_deploy import map_exit_code_to_status as _map + return "PASS" if _map(exit_code) == "SUCCESS" else "FAIL" + + +# --------------------------------------------------------------------------- +# Artifact 13-test-report.md (D6 / FR-4 / AC-2) — mirror write_staging_log +# --------------------------------------------------------------------------- +def build_test_report( + work_item_id: str, exit_code, result: str, stdout: str = "", + smoke: str = "skipped", *, tool_error: bool = False, +) -> str: + """Render a ``13-test-report.md`` body whose ``result:`` frontmatter is the verdict + ``check_tests_passed`` / ``_parse_tests_verdict`` reads (contract UNCHANGED, AC-2). + Carries the mandatory 52c schema; ``author_agent: test-runner`` / ``model_used: + n/a`` honestly reflect the DETERMINISTIC producer. The machine key ``result:`` and + its UPPERCASE value are NOT changed. + + D6.1 (the tester-specific mine, absent in ORCH-115): ``_parse_tests_verdict`` reads + the verdict from THREE equal-rank fields — ``verdict:`` / ``status:`` / ``result:`` + — with negative-token priority. The 52c-mandatory ``status:`` is therefore read by + the SAME parser, so it MUST be aligned with the verdict and never contradict + ``result:``: ``PASS -> status: success`` (``SUCCESS`` is neither a positive nor a + negative token; the positive ``PASS`` comes from ``result:`` -> the parser gives + True); ``FAIL -> status: failed`` (``FAILED`` is a negative token, consistent with + ``FAIL`` -> False). A ``status:`` literal carrying a negative token at ``result: + PASS`` would be a false FAIL of a healthy run (reviewer ≥P1). + + Written as a literal block (mirror of ``staging_runner.build_staging_log``) so the + machine-read frontmatter is byte-exact; only the frontmatter is machine-read, the + body is informational.""" + import datetime + created = datetime.date.today().isoformat() + sub_status = "success" if result == "PASS" else "failed" + + tail = "" + if stdout: + tail_text = stdout.strip()[-1500:] + if tail_text: + tail = f"\npytest stdout (tail):\n```\n{tail_text}\n```\n" + + note = ( + "Regression suite did NOT execute (tool-error) and the infra-retry budget was " + "exhausted -> fail-closed FAIL." + if tool_error + else f"pytest exit-code `{exit_code}` -> `result: {result}` (smoke: {smoke})." + ) + + return ( + "---\n" + f"result: {result}\n" + f"work_item: {work_item_id}\n" + "stage: testing\n" + "author_agent: test-runner\n" + f"status: {sub_status}\n" + f"created_at: {created}\n" + "model_used: n/a\n" + f"exit_code: {exit_code}\n" + f"smoke: {smoke}\n" + "---\n\n" + "# Test Gate Log (deterministic runner, ORCH-116)\n\n" + f"{note}\n\n" + "Вердикт зафиксирован детерминированным test-раннером (ORCH-116), не LLM. " + "PASS/FAIL = exit-код `pytest` + read-only smoke (`/health`, `/status`, " + "`/queue` + блок `serial_gate`).\n" + f"{tail}" + ) + + +def write_test_report( + repo: str, work_item_id: str, branch: str, exit_code, result: str, + stdout: str = "", smoke: str = "skipped", *, tool_error: bool = False, +) -> bool: + """Write ``13-test-report.md`` into the task worktree (so ``check_tests_passed`` + reads it) and best-effort commit+push it to the FEATURE BRANCH. Returns True iff + the file was written. Never raises. + + Mirror of ``staging_runner.write_staging_log``: the actor name is ``test-runner`` + and the log is pushed only to the feature branch — there is NO separate PR-merge of + the log into ``main`` (the gate reads the worktree first via ``_repo_path``; + excluding any direct work on ``main`` strengthens AC-10 / BR-7). The feature branch + is merged into ``main`` later by the normal merge-gate path.""" + import os + import subprocess + from .git_worktree import get_worktree_path + + rel = f"docs/work-items/{work_item_id}/13-test-report.md" + try: + wt = get_worktree_path(repo, branch) + except Exception as e: # noqa: BLE001 - never-raise + logger.error("write_test_report: worktree error for %s/%s: %s", repo, branch, e) + return False + + path = os.path.join(wt, rel) + content = build_test_report( + work_item_id, exit_code, result, stdout, smoke, tool_error=tool_error + ) + try: + os.makedirs(os.path.dirname(path), exist_ok=True) + with open(path, "w", encoding="utf-8") as f: + f.write(content) + except OSError as e: + logger.error("write_test_report: write error at %s: %s", path, e) + return False + + # Best-effort commit + push to the feature branch (the gate also falls back to + # origin/main). ORCH-101: HOME + email domain from Settings; the actor NAME stays + # the platform literal `test-runner` (deterministic system-actor commits). + _email = f"test-runner@{settings.git_email_domain}" + git_env = { + **os.environ, + "HOME": settings.agent_home_dir, + "GIT_AUTHOR_NAME": "test-runner", + "GIT_AUTHOR_EMAIL": _email, + "GIT_COMMITTER_NAME": "test-runner", + "GIT_COMMITTER_EMAIL": _email, + } + try: + subprocess.run(["git", "-C", wt, "add", rel], + capture_output=True, timeout=_GIT_TIMEOUT, env=git_env) + commit = subprocess.run( + ["git", "-C", wt, "commit", "-m", + f"test(ORCH-116): test gate {result} for {work_item_id}"], + capture_output=True, text=True, timeout=_GIT_TIMEOUT, env=git_env, + ) + if commit.returncode == 0: + subprocess.run(["git", "-C", wt, "push", "origin", branch], + capture_output=True, timeout=_GIT_TIMEOUT, env=git_env) + except (subprocess.SubprocessError, OSError) as e: + logger.warning("write_test_report: git commit/push best-effort failed: %s", e) + return True + + +# --------------------------------------------------------------------------- +# Existing-gate initiation (D7 / FR-5 / AC-4) — no new routing branch +# --------------------------------------------------------------------------- +def _advance(task_id, repo: str, work_item_id: str, branch: str) -> None: + """Initiate the SAME ``advance_stage`` evaluation a finished LLM-tester would + (``finished_agent="tester"`` on ``testing``): PASS -> ``testing -> deploy-staging``; + FAIL -> the existing rollback ``testing -> development`` + developer-retry + (``stage_engine.py:849``, matched by ``agent == "tester" and qg_name == + "check_tests_passed"`` — ``finished_agent="tester"`` is MANDATORY, R-2). No new + routing branch. The transition-lease (ORCH-114) is taken INSIDE advance_stage on + the side-effectful edge — the runner never touches it (task boundary O1). + never-raise.""" + try: + from . import stage_engine + stage_engine.advance_stage( + task_id=task_id, + current_stage="testing", + repo=repo, + work_item_id=work_item_id, + branch=branch, + finished_agent="tester", + ) + except Exception as e: # noqa: BLE001 - never-raise into the worker + logger.error( + "test_runner._advance: advance_stage failed for task %s (%s): %s", + task_id, work_item_id, e, + ) + + +# --------------------------------------------------------------------------- +# Two-level outcome (D5) — tool-error DEFER bookkeeping +# --------------------------------------------------------------------------- +def _infra_retry_count(task_id) -> int: + """How many times this task was re-queued by the tool-error DEFER path + (restart-safe; counted from the persisted jobs queue by the marker — mirror of + ``staging_runner._infra_retry_count``). Never raises -> 0 on error.""" + try: + from .db import get_db + conn = get_db() + n = conn.execute( + "SELECT COUNT(*) FROM jobs WHERE task_id=? AND task_content LIKE ?", + (task_id, f"%{_INFRA_RETRY_MARKER}%"), + ).fetchone()[0] + conn.close() + return int(n) + except Exception as e: # noqa: BLE001 - never-raise + logger.warning("test_runner._infra_retry_count error for %s: %s", task_id, e) + return 0 + + +def _handle_tool_error( + task_id, repo: str, work_item_id: str, branch: str, result: proc_group.ProcResult +) -> None: + """Suite did NOT execute (tool-error) -> bounded DEFER, then fail-closed (D5). + + Anti ORCH-110: an infra fault is NOT a code fault, so we re-queue a fresh + ``tester`` job (which re-enters this runner on the still-``testing`` task) with a + delay instead of an immediate FAIL-rollback that would burn a developer-retry. On + budget exhaustion -> write ``result: FAIL`` + advance (the existing rollback) + an + INFRA-specific alert (explicitly "not a code defect"). Never a silent advance / + false green; never wedges the queue. never-raise.""" + retries = _infra_retry_count(task_id) + try: + max_retries = int(settings.test_runner_infra_max_retries) + except (TypeError, ValueError): + max_retries = 2 + try: + delay = int(settings.test_runner_infra_retry_delay_s) + except (TypeError, ValueError): + delay = 30 + + if retries < max_retries: + _bump("deferred") + reason = "timeout" if result.timed_out else "suite did not execute (tool-error)" + task_desc = ( + f"Work item: {work_item_id}\nRepo: {repo}\nBranch: {branch}\n" + f"Stage: testing\nNote: {_INFRA_RETRY_MARKER} " + f"(attempt {retries + 1}/{max_retries}) — {reason}, retrying after {delay}s." + ) + try: + from .db import enqueue_job + new_job = enqueue_job( + "tester", repo, task_desc, task_id=task_id, available_at_delay_s=delay, + ) + logger.warning( + "Task %s (%s): regression suite did not execute (%s) -> infra-DEFER " + "(job_id=%s, attempt %d/%d)", + task_id, work_item_id, reason, new_job, retries + 1, max_retries, + ) + except Exception as e: # noqa: BLE001 - never-raise + logger.error("test_runner: infra-DEFER enqueue failed for %s: %s", task_id, e) + return + + # Budget exhausted -> fail-closed FAIL (terminal, never a false green). + _bump("fail") + logger.error( + "Task %s (%s): test tool-error DEFER budget exhausted (%d) -> fail-closed FAIL", + task_id, work_item_id, max_retries, + ) + write_test_report(repo, work_item_id, branch, result.returncode, "FAIL", + result.stdout, "skipped", tool_error=True) + _alert_infra_exhausted(work_item_id, max_retries) + _advance(task_id, repo, work_item_id, branch) + + +def _alert_infra_exhausted(work_item_id: str, max_retries: int) -> None: + """Best-effort Telegram alert that the regression suite never executed (infra, NOT + a code defect) after the retry budget. never-raise.""" + try: + from .notifications import send_telegram, link_for + send_telegram( + f"\U0001f6a8 {link_for(work_item_id)}: регресс-сюита не запустилась " + f"(инфра, НЕ дефект кода) после {max_retries} попыток — fail-closed FAIL, " + f"откат на development. Нужно проверить тест-окружение." + ) + except Exception as e: # noqa: BLE001 - never-raise + logger.warning("test_runner: infra-exhausted alert failed for %s: %s", work_item_id, e) + + +# --------------------------------------------------------------------------- +# Entry point (D2) — owns the full deterministic flow, mirror run_staging_gate +# --------------------------------------------------------------------------- +def run_test_gate(job: dict) -> None: + """Deterministic test gate for a ``tester`` job on ``testing``. + + Flow (mirror of ``staging_runner.run_staging_gate``): + 1. resolve ``work_item_id`` / ``branch`` by ``task_id``; + 2. execute the regression suite in the worktree (D3) -> ProcResult; + 3. suite EXECUTED -> map exit-code (+ smoke) -> ``result:``, write + ``13-test-report.md``, initiate the existing gate via ``advance_stage`` (D7); + 4. suite did NOT execute (tool-error) -> bounded DEFER / fail-closed (D5); + 5. observability counters + one structured verdict log (D10). + Never raises into the caller (the launcher marks the job done/failed).""" + started = time.time() + _bump("runs") + task_id = job.get("task_id") + repo = job.get("repo") + + # 1. resolve task fields. + work_item_id, branch = None, None + try: + from .db import get_db + conn = get_db() + row = conn.execute( + "SELECT work_item_id, branch FROM tasks WHERE id=?", (task_id,) + ).fetchone() + conn.close() + if row: + work_item_id, branch = row[0], row[1] + except Exception as e: # noqa: BLE001 - never-raise + logger.error("test_runner: task lookup failed for task_id=%s: %s", task_id, e) + if not work_item_id or not branch: + logger.error( + "test_runner: missing work_item_id/branch for task_id=%s — aborting", task_id + ) + return + + # 2-4. execute + classify + route — guarded so AC-9 (never-raise) holds even if an + # unexpected error escapes a sub-step (the worker must never crash on test infra; + # the task is left on testing for the reconciler/reaper to re-drive). + try: + result = run_test_suite(repo, branch) + duration_s = round(time.time() - started, 1) + suite_ran = (result.returncode is not None) and (not result.timed_out) + + if suite_ran: + # 3. trust the exit-code; AND-in the read-only smoke (D3). + exit_verdict = map_exit_code_to_result(result.returncode) + smoke_state = "skipped" + verdict = exit_verdict + if exit_verdict == "PASS" and bool(getattr(settings, "test_runner_smoke_enabled", True)): + smoke_ok, smoke_detail = run_smoke() + smoke_state = "ok" if smoke_ok else "failed" + if not smoke_ok: + verdict = "FAIL" + logger.warning( + "test_runner: pytest green but smoke FAILED for %s: %s", + work_item_id, smoke_detail, + ) + _bump("pass" if verdict == "PASS" else "fail") + logger.info( + "test_runner verdict: work_item=%s repo=%s exit_code=%s result=%s " + "smoke=%s duration_s=%s outcome=%s", + work_item_id, repo, result.returncode, verdict, smoke_state, duration_s, + "code-pass" if verdict == "PASS" else "code-fail", + ) + write_test_report(repo, work_item_id, branch, result.returncode, verdict, + result.stdout, smoke_state) + _advance(task_id, repo, work_item_id, branch) + return + + # 4. tool-error (suite did not execute) -> DEFER / fail-closed (D5). + _bump("tool_error") + logger.warning( + "test_runner verdict: work_item=%s repo=%s exit_code=%s result=%s " + "duration_s=%s outcome=tool-error (timed_out=%s)", + work_item_id, repo, result.returncode, "TOOL-ERROR", duration_s, result.timed_out, + ) + _handle_tool_error(task_id, repo, work_item_id, branch, result) + except Exception as e: # noqa: BLE001 - never-raise into the worker (AC-9) + logger.error( + "test_runner.run_test_gate: unexpected error for task %s (%s): %s", + task_id, work_item_id, e, + ) + + +# --------------------------------------------------------------------------- +# Observability (D10 / FR-8 / AC-13) +# --------------------------------------------------------------------------- +def snapshot() -> dict: + """Read-only test-runner summary for ``GET /queue`` (FR-8 / AC-13). + + Additive block; existing ``/queue`` keys are untouched. never-raise: any error -> + a minimal dict with the kill-switch state.""" + try: + return { + "enabled": bool(settings.test_runner_enabled), + "repos": getattr(settings, "test_runner_repos", "") or "", + "target": getattr(settings, "test_runner_target", "tests/") or "tests/", + "timeout_s": getattr(settings, "test_runner_timeout_s", _DEFAULT_TIMEOUT_S), + "smoke_enabled": bool(getattr(settings, "test_runner_smoke_enabled", True)), + "infra_max_retries": getattr(settings, "test_runner_infra_max_retries", 2), + "runs": _TEST_RUNNER_COUNTERS["runs"], + "pass": _TEST_RUNNER_COUNTERS["pass"], + "fail": _TEST_RUNNER_COUNTERS["fail"], + "tool_error": _TEST_RUNNER_COUNTERS["tool_error"], + "deferred": _TEST_RUNNER_COUNTERS["deferred"], + } + except Exception as e: # noqa: BLE001 - never-raise -> minimal dict + logger.warning("test_runner.snapshot error: %s", e) + return {"enabled": False} diff --git a/tests/test_orch116_test_runner.py b/tests/test_orch116_test_runner.py new file mode 100644 index 0000000..9a5b236 --- /dev/null +++ b/tests/test_orch116_test_runner.py @@ -0,0 +1,560 @@ +"""ORCH-116 — deterministic test-runner replacing the LLM tester on the `testing` +stage (self-hosting orchestrator). + +Covers Phase 1 (04-test-plan.yaml TC-01…TC-14): the launch_job intercept BEFORE +_spawn, the exit-code -> result: PASS|FAIL mapping, 13-test-report.md render + the +UNCHANGED gate contract (incl. the tester-specific D6.1 52c-`status:`↔parser +anti-collision), advance_stage initiation, kill-switch / scope / backward-compat for a +repo without a test-contract, never-raise / fail-safe, the bounded tool-error DEFER +(anti ORCH-110), process timeout (proc_group / worktree), read-only smoke, self-hosting +safety, the anti-drift invariant (STAGE_TRANSITIONS / QG_CHECKS / check_tests_passed / +_parse_tests_verdict / DB schema untouched), and the /queue observability block. + +No live Claude CLI, network or worktree git: the pytest subprocess, the smoke GETs and +advance_stage are mocked; the pure mapping/render is tested directly. (TC-15 — the LLM +call-site map anti-drift — lives in tests/test_llm_call_site_inventory.py / +test_llm_determinization_docs.py and is asserted green here too.) +""" +import os +import tempfile + +import pytest + +_test_db = os.path.join(tempfile.gettempdir(), "test_orch116_test_runner.db") +os.environ["ORCH_DB_PATH"] = _test_db +os.environ["ORCH_REPOS_DIR"] = tempfile.gettempdir() +os.environ.setdefault("ORCH_GITEA_TOKEN", "test-token") +os.environ.setdefault("ORCH_PLANE_API_TOKEN", "test-token") + +from unittest.mock import MagicMock # noqa: E402 + +import src.db as _db # noqa: E402 +from src.db import init_db, get_db, enqueue_job # noqa: E402 +from src import test_runner # noqa: E402 +from src import stage_engine # noqa: E402 +from src import config as cfg # noqa: E402 +from src.proc_group import ProcResult # noqa: E402 +from src.agents.launcher import AgentLauncher # noqa: E402 + + +# --------------------------------------------------------------------------- +# Fixtures +# --------------------------------------------------------------------------- +@pytest.fixture(autouse=True) +def fresh_db(monkeypatch, tmp_path): + monkeypatch.setattr(_db.settings, "db_path", _test_db) + if os.path.exists(_test_db): + os.unlink(_test_db) + init_db() + # Worktree artefacts land in tmp; git commit/push degrade gracefully (no repo). + monkeypatch.setattr("src.git_worktree.settings.worktrees_dir", str(tmp_path), raising=False) + # Runner ON, self-hosting scope (default). Smoke OFF by default so the PASS path + # does not hit the network; the dedicated smoke tests re-enable + mock it. + monkeypatch.setattr(cfg.settings, "test_runner_enabled", True, raising=False) + monkeypatch.setattr(cfg.settings, "test_runner_repos", "", raising=False) + monkeypatch.setattr(cfg.settings, "test_runner_smoke_enabled", False, raising=False) + monkeypatch.setattr(cfg.settings, "test_runner_infra_max_retries", 2, raising=False) + # Reset in-process counters between tests. + for k in test_runner._TEST_RUNNER_COUNTERS: + test_runner._TEST_RUNNER_COUNTERS[k] = 0 + yield + + +def _make_task(stage, repo="orchestrator", wi="ORCH-116", branch="feature/ORCH-116-x"): + conn = get_db() + cur = conn.execute( + "INSERT INTO tasks (plane_id, work_item_id, repo, branch, stage) VALUES (?, ?, ?, ?, ?)", + (f"plane-{wi}", wi, repo, branch, stage), + ) + tid = cur.lastrowid + conn.commit() + conn.close() + return tid + + +def _make_job(agent, repo, task_id, content="x"): + return enqueue_job(agent, repo, content, task_id=task_id) + + +def _job_dict(job_id, agent, repo, task_id): + return {"id": job_id, "agent": agent, "repo": repo, "task_id": task_id, "task_content": "x"} + + +def _read_report(repo, branch, wi): + from src.git_worktree import get_worktree_path + p = os.path.join(get_worktree_path(repo, branch), f"docs/work-items/{wi}/13-test-report.md") + with open(p, "r", encoding="utf-8") as f: + return f.read() + + +# --------------------------------------------------------------------------- +# TC-01 — applies(): kill-switch / scope / contract / fail-safe (FR-7 / AC-6/AC-7/AC-8) +# --------------------------------------------------------------------------- +def test_tc01_applies_killswitch_scope_and_contract(monkeypatch): + # enabled=False -> False (fall back to the LLM path) regardless of repo. + monkeypatch.setattr(cfg.settings, "test_runner_enabled", False) + assert test_runner.applies("orchestrator") is False + + # enabled, empty CSV -> self-hosting only (and a test-contract resolves for it). + monkeypatch.setattr(cfg.settings, "test_runner_enabled", True) + monkeypatch.setattr(cfg.settings, "test_runner_repos", "") + assert test_runner.applies("orchestrator") is True + assert test_runner.applies("enduro-trails") is False + assert test_runner.applies("") is False + + # BR-9 backward-compat: even hand-adding a non-self repo to the CSV -> False, + # because _has_test_contract is unresolved for it (Phase 1 = self only). + monkeypatch.setattr(cfg.settings, "test_runner_repos", "enduro-trails, orchestrator") + assert test_runner.applies("ENDURO-TRAILS") is False # no contract -> LLM-tester + assert test_runner.applies("orchestrator") is True # in scope + contract + assert test_runner.applies("other-repo") is False + + +def test_tc01_applies_never_raises(monkeypatch): + class Boom: + @property + def test_runner_enabled(self): + raise RuntimeError("boom") + monkeypatch.setattr(test_runner, "settings", Boom()) + assert test_runner.applies("orchestrator") is False + + +# --------------------------------------------------------------------------- +# TC-02 — exit-code -> verdict, single shared contract (FR-3 / AC-3) +# --------------------------------------------------------------------------- +def test_tc02_map_exit_code(): + from src import self_deploy + assert test_runner.map_exit_code_to_result(0) == "PASS" + for bad in (1, 2, 137, -9): + assert test_runner.map_exit_code_to_result(bad) == "FAIL" + for noncode in (None, "x", object()): + assert test_runner.map_exit_code_to_result(noncode) == "FAIL" + # Same underlying contract as the deploy-finalizer / staging-runner (no 2nd mapping): + # PASS iff SUCCESS, FAIL iff FAILED. + for v in (0, 1, None, "garbage"): + expect = "PASS" if self_deploy.map_exit_code_to_status(v) == "SUCCESS" else "FAIL" + assert test_runner.map_exit_code_to_result(v) == expect + + +# --------------------------------------------------------------------------- +# TC-03 — 13-test-report.md render: machine key + 52c schema + status alignment (FR-4 / AC-2) +# --------------------------------------------------------------------------- +def test_tc03_report_render_schema_and_status_alignment(): + body = test_runner.build_test_report("ORCH-116", 0, "PASS", "23 passed", smoke="ok") + assert "result: PASS" in body # UPPERCASE machine key + for field in ("work_item: ORCH-116", "stage: testing", + "author_agent: test-runner", "status: success", + "created_at:", "model_used: n/a"): + assert field in body, f"missing 52c field: {field}" + assert "smoke: ok" in body + assert "23 passed" in body # stdout tail copied into the body + + failed = test_runner.build_test_report("ORCH-116", 1, "FAIL", "boom", smoke="skipped") + assert "result: FAIL" in failed + # D6.1: status MUST be aligned with the verdict (failed, never `success`). + assert "status: failed" in failed + + +# --------------------------------------------------------------------------- +# TC-04 — generated report read by the UNCHANGED _parse_tests_verdict (AC-2 / D6.1) +# --------------------------------------------------------------------------- +def test_tc04_gate_parser_unchanged(): + from src.qg.checks import _parse_tests_verdict + ok, reason = _parse_tests_verdict( + test_runner.build_test_report("ORCH-116", 0, "PASS", "", smoke="ok")) + assert ok is True and "PASS" in reason + bad, reason2 = _parse_tests_verdict( + test_runner.build_test_report("ORCH-116", 2, "FAIL", "", smoke="skipped")) + assert bad is False and "FAIL" in reason2 + + +def test_tc04_status_field_never_false_negatives_a_pass(): + """The D6.1 mine: the 52c-mandatory `status:` is read by _parse_tests_verdict with + negative-token priority. A PASS report must NOT carry a status whose UPPERCASE is a + negative token (else a healthy run reads as FAIL).""" + from src.qg.checks import _parse_tests_verdict, _TESTS_NEGATIVE_TOKENS + body = test_runner.build_test_report("ORCH-116", 0, "PASS", "", smoke="ok") + # Extract the status: line from the frontmatter and assert it is token-safe. + status_line = next(ln for ln in body.splitlines() if ln.startswith("status:")) + status_val = status_line.split(":", 1)[1].strip().upper() + for neg in _TESTS_NEGATIVE_TOKENS: + assert neg not in status_val, f"PASS report status carries negative token {neg!r}" + assert _parse_tests_verdict(body)[0] is True + + +# --------------------------------------------------------------------------- +# TC-05 — launch_job intercepts tester on testing BEFORE _spawn (AC-1) +# --------------------------------------------------------------------------- +def test_tc05_launch_job_intercepts_before_spawn(monkeypatch): + tid = _make_task("testing") + jid = _make_job("tester", "orchestrator", tid) + lr = AgentLauncher() + spawn = MagicMock(return_value=999) + monkeypatch.setattr(lr, "_spawn", spawn) + run_gate = MagicMock() + monkeypatch.setattr(test_runner, "run_test_gate", run_gate) + + ret = lr.launch_job(_job_dict(jid, "tester", "orchestrator", tid)) + + assert ret is None # no agent_runs row + spawn.assert_not_called() # LLM path NOT taken + run_gate.assert_called_once() # deterministic runner ran + conn = get_db() + status = conn.execute("SELECT status FROM jobs WHERE id=?", (jid,)).fetchone()[0] + conn.close() + assert status == "done" + + +# --------------------------------------------------------------------------- +# TC-06 — discriminator: tester off-`testing` / non-tester / never-raise (AC-1 / R-1) +# --------------------------------------------------------------------------- +def test_tc06_stage_discriminator_off_testing_not_intercepted(monkeypatch): + tid = _make_task("development") # tester job but not the testing stage + jid = _make_job("tester", "orchestrator", tid) + assert test_runner.should_intercept(_job_dict(jid, "tester", "orchestrator", tid)) is False + # and launch_job falls through to _spawn for it. + lr = AgentLauncher() + spawn = MagicMock(return_value=42) + monkeypatch.setattr(lr, "_spawn", spawn) + ret = lr.launch_job(_job_dict(jid, "tester", "orchestrator", tid)) + assert ret == 42 + spawn.assert_called_once() + + +def test_tc06_non_tester_not_intercepted(): + tid = _make_task("testing") + jid = _make_job("developer", "orchestrator", tid) + assert test_runner.should_intercept(_job_dict(jid, "developer", "orchestrator", tid)) is False + + +def test_tc06_non_self_repo_not_intercepted(): + tid = _make_task("testing", repo="enduro-trails", wi="ET-9", branch="feature/ET-9-x") + jid = _make_job("tester", "enduro-trails", tid) + assert test_runner.should_intercept(_job_dict(jid, "tester", "enduro-trails", tid)) is False + + +def test_tc06_should_intercept_never_raises(monkeypatch): + # applies() True, but the DB lookup explodes -> should_intercept False (fall-through). + monkeypatch.setattr(test_runner, "applies", lambda repo: True) + monkeypatch.setattr(test_runner, "get_db", None, raising=False) + + def boom_get_db(): + raise RuntimeError("db down") + import src.db as dbmod + monkeypatch.setattr(dbmod, "get_db", boom_get_db) + assert test_runner.should_intercept( + {"agent": "tester", "repo": "orchestrator", "task_id": 1}) is False + + +# --------------------------------------------------------------------------- +# TC-07 — routing equivalence: PASS -> advance; FAIL -> same path (AC-4) +# --------------------------------------------------------------------------- +@pytest.mark.parametrize("rc,expected", [(0, "PASS"), (1, "FAIL")]) +def test_tc07_advance_initiated_like_llm(monkeypatch, rc, expected): + tid = _make_task("testing") + monkeypatch.setattr(test_runner, "run_test_suite", + lambda repo, branch: ProcResult(returncode=rc, stdout="out", stderr="", timed_out=False)) + advance = MagicMock() + monkeypatch.setattr(stage_engine, "advance_stage", advance) + + test_runner.run_test_gate(_job_dict(1, "tester", "orchestrator", tid)) + + advance.assert_called_once() + kwargs = advance.call_args.kwargs + assert kwargs["current_stage"] == "testing" + assert kwargs["finished_agent"] == "tester" + assert kwargs["work_item_id"] == "ORCH-116" + assert f"result: {expected}" in _read_report("orchestrator", "feature/ORCH-116-x", "ORCH-116") + + +# --------------------------------------------------------------------------- +# TC-08 — kill-switch: enabled=False -> LLM path via _spawn (AC-7) +# --------------------------------------------------------------------------- +def test_tc08_killswitch_falls_back_to_spawn(monkeypatch): + monkeypatch.setattr(cfg.settings, "test_runner_enabled", False) + tid = _make_task("testing") + jid = _make_job("tester", "orchestrator", tid) + lr = AgentLauncher() + spawn = MagicMock(return_value=7) + monkeypatch.setattr(lr, "_spawn", spawn) + run_gate = MagicMock() + monkeypatch.setattr(test_runner, "run_test_gate", run_gate) + + ret = lr.launch_job(_job_dict(jid, "tester", "orchestrator", tid)) + + assert ret == 7 + spawn.assert_called_once() # byte-for-byte the prior LLM-tester path + run_gate.assert_not_called() + + +# --------------------------------------------------------------------------- +# TC-09 — anti-drift NFR-1: STAGE_TRANSITIONS / QG_CHECKS / schema untouched (AC-6) +# --------------------------------------------------------------------------- +def test_tc09_pipeline_contract_unchanged(): + from src.stages import STAGE_TRANSITIONS + from src.qg.checks import QG_CHECKS + # The review->testing edge (tester) and testing->deploy-staging gate are byte-for-byte. + assert STAGE_TRANSITIONS["review"] == { + "next": "testing", "agent": "tester", "qg": "check_reviewer_verdict" + } + assert STAGE_TRANSITIONS["testing"] == { + "next": "deploy-staging", "agent": "deployer", "qg": "check_tests_passed" + } + assert "check_tests_passed" in QG_CHECKS + # No new ORCH-116 table: only the existing tables exist. + conn = get_db() + tables = {r[0] for r in conn.execute( + "SELECT name FROM sqlite_master WHERE type='table'").fetchall()} + conn.close() + assert not any("test_runner" in t for t in tables) + # The machine key is not renamed: the runner emits `result:`. + assert "result:" in test_runner.build_test_report("ORCH-116", 0, "PASS") + + +# --------------------------------------------------------------------------- +# TC-10 / TC-11 — two-level outcome + never-raise (anti ORCH-110, AC-5/AC-9) +# --------------------------------------------------------------------------- +def test_tc10_nonzero_exit_is_fail_and_advances(monkeypatch): + tid = _make_task("testing") + monkeypatch.setattr(test_runner, "run_test_suite", + lambda repo, branch: ProcResult(returncode=3, stdout="fail", stderr="", timed_out=False)) + advance = MagicMock() + monkeypatch.setattr(stage_engine, "advance_stage", advance) + test_runner.run_test_gate(_job_dict(1, "tester", "orchestrator", tid)) + advance.assert_called_once() + assert "result: FAIL" in _read_report("orchestrator", "feature/ORCH-116-x", "ORCH-116") + + +def test_tc10_timeout_defers_without_advance(monkeypatch): + tid = _make_task("testing") + monkeypatch.setattr(cfg.settings, "test_runner_infra_max_retries", 2) + monkeypatch.setattr(test_runner, "run_test_suite", + lambda repo, branch: ProcResult(returncode=None, stdout="", stderr="", timed_out=True)) + advance = MagicMock() + monkeypatch.setattr(stage_engine, "advance_stage", advance) + + test_runner.run_test_gate(_job_dict(1, "tester", "orchestrator", tid)) + + advance.assert_not_called() # NO silent advance / false green on infra hiccup + conn = get_db() + n = conn.execute( + "SELECT COUNT(*) FROM jobs WHERE task_id=? AND task_content LIKE ?", + (tid, f"%{test_runner._INFRA_RETRY_MARKER}%"), + ).fetchone()[0] + # The re-queued job must be a `tester` job (re-enters this runner), not a deployer. + agent = conn.execute( + "SELECT agent FROM jobs WHERE task_id=? AND task_content LIKE ?", + (tid, f"%{test_runner._INFRA_RETRY_MARKER}%"), + ).fetchone()[0] + conn.close() + assert n == 1 + assert agent == "tester" + assert test_runner._TEST_RUNNER_COUNTERS["deferred"] == 1 + assert test_runner._TEST_RUNNER_COUNTERS["tool_error"] == 1 + + +def test_tc10_tool_error_budget_exhausted_fails_closed(monkeypatch): + tid = _make_task("testing") + monkeypatch.setattr(cfg.settings, "test_runner_infra_max_retries", 0) # exhausted immediately + monkeypatch.setattr(test_runner, "run_test_suite", + lambda repo, branch: ProcResult(returncode=None, stdout="", stderr="", timed_out=True)) + advance = MagicMock() + monkeypatch.setattr(stage_engine, "advance_stage", advance) + alert = MagicMock() + monkeypatch.setattr(test_runner, "_alert_infra_exhausted", alert) + + test_runner.run_test_gate(_job_dict(1, "tester", "orchestrator", tid)) + + advance.assert_called_once() # fail-closed: write FAIL + advance (existing rollback) + alert.assert_called_once() + assert "result: FAIL" in _read_report("orchestrator", "feature/ORCH-116-x", "ORCH-116") + + +def test_tc11_run_gate_never_raises(monkeypatch): + tid = _make_task("testing") + + def boom(repo, branch): + raise RuntimeError("pytest exploded") + monkeypatch.setattr(test_runner, "run_test_suite", boom) + # Must NOT raise (AC-9): the worker is protected even on an unexpected error. + test_runner.run_test_gate(_job_dict(1, "tester", "orchestrator", tid)) + + +def test_tc11_launcher_contains_runner_fault(monkeypatch): + tid = _make_task("testing") + jid = _make_job("tester", "orchestrator", tid) + lr = AgentLauncher() + monkeypatch.setattr(lr, "_spawn", MagicMock()) + monkeypatch.setattr(test_runner, "run_test_gate", + MagicMock(side_effect=RuntimeError("kaboom"))) + ret = lr.launch_job(_job_dict(jid, "tester", "orchestrator", tid)) + assert ret is None + conn = get_db() + status = conn.execute("SELECT status FROM jobs WHERE id=?", (jid,)).fetchone()[0] + conn.close() + assert status == "failed" + + +# --------------------------------------------------------------------------- +# TC-12 — timeout resolution + worktree cwd + tree-kill (NFR-3/NFR-4 / AC-11) +# --------------------------------------------------------------------------- +def test_tc12_resolve_timeout_default_on_bad_value(monkeypatch): + monkeypatch.setattr(cfg.settings, "test_runner_timeout_s", 1234) + assert test_runner._resolve_timeout() == 1234 + for bad in (0, -5, "abc", None): + monkeypatch.setattr(cfg.settings, "test_runner_timeout_s", bad) + assert test_runner._resolve_timeout() == test_runner._DEFAULT_TIMEOUT_S + + +def test_tc12_pytest_runs_in_worktree_via_proc_group(monkeypatch): + monkeypatch.setattr(cfg.settings, "test_runner_timeout_s", 321) + monkeypatch.setattr(cfg.settings, "subprocess_tree_kill_enabled", True) + captured = {} + + def fake_run(cmd, *, cwd, timeout, grace_s, tree_kill): + captured.update(cmd=cmd, cwd=cwd, timeout=timeout, tree_kill=tree_kill) + return ProcResult(returncode=0, stdout="", stderr="", timed_out=False) + monkeypatch.setattr(test_runner.proc_group, "run_in_process_group", fake_run) + + test_runner.run_test_suite("orchestrator", "feature/ORCH-116-x") + from src.git_worktree import get_worktree_path + assert captured["cwd"] == get_worktree_path("orchestrator", "feature/ORCH-116-x") + assert captured["timeout"] == 321 + assert captured["tree_kill"] is True + assert captured["cmd"][:3] == ["python", "-m", "pytest"] + + +# --------------------------------------------------------------------------- +# TC-13 — self-hosting safety: no forbidden literals; smoke read-only (AC-10) +# --------------------------------------------------------------------------- +def test_tc13_command_has_no_dangerous_literals(): + cmd = " ".join(test_runner.build_test_command()) + forbidden = ("compose", "up -d", "--build", "8500", "force", "push", ".env", + "rm ", "restart", "docker") + for token in forbidden: + assert token not in cmd, f"forbidden literal {token!r} in runner command: {cmd}" + assert "pytest" in cmd + + +def test_tc13_smoke_is_read_only_and_checks_serial_gate(monkeypatch): + monkeypatch.setattr(cfg.settings, "test_runner_smoke_enabled", True) + monkeypatch.setattr(test_runner, "_SMOKE_BACKOFF_S", 0) + calls = [] + + def fake_get(url): + calls.append(url) + if url.endswith("/queue"): + return 200, '{"serial_gate": {"enabled": true}}' + return 200, "ok" + monkeypatch.setattr(test_runner, "_http_get", fake_get) + + ok, detail = test_runner.run_smoke() + assert ok is True + # All three read-only endpoints hit; serial_gate verified in /queue body. + assert any(u.endswith("/health") for u in calls) + assert any(u.endswith("/status") for u in calls) + assert any(u.endswith("/queue") for u in calls) + + +def test_tc13_smoke_missing_serial_gate_fails(monkeypatch): + monkeypatch.setattr(cfg.settings, "test_runner_smoke_enabled", True) + monkeypatch.setattr(test_runner, "_SMOKE_BACKOFF_S", 0) + monkeypatch.setattr(test_runner, "_http_get", + lambda url: (200, "{}")) # 200 but no serial_gate block + ok, detail = test_runner.run_smoke() + assert ok is False + assert "serial_gate" in detail + + +def test_tc13_smoke_unreachable_retries_then_fails(monkeypatch): + monkeypatch.setattr(cfg.settings, "test_runner_smoke_enabled", True) + monkeypatch.setattr(test_runner, "_SMOKE_BACKOFF_S", 0) + attempts = {"n": 0} + + def fake_get(url): + attempts["n"] += 1 + return 0, "" # always unreachable + monkeypatch.setattr(test_runner, "_http_get", fake_get) + ok, detail = test_runner.run_smoke() + assert ok is False + # bounded retry: more than one attempt was made before declaring FAIL. + assert attempts["n"] >= test_runner._SMOKE_MAX_ATTEMPTS + + +def test_tc13_pytest_green_but_smoke_fail_is_fail(monkeypatch): + tid = _make_task("testing") + monkeypatch.setattr(cfg.settings, "test_runner_smoke_enabled", True) + monkeypatch.setattr(test_runner, "run_test_suite", + lambda repo, branch: ProcResult(returncode=0, stdout="ok", stderr="", timed_out=False)) + monkeypatch.setattr(test_runner, "run_smoke", lambda: (False, "smoke /queue failed")) + advance = MagicMock() + monkeypatch.setattr(stage_engine, "advance_stage", advance) + + test_runner.run_test_gate(_job_dict(1, "tester", "orchestrator", tid)) + + advance.assert_called_once() # FAIL still advances (existing rollback) + body = _read_report("orchestrator", "feature/ORCH-116-x", "ORCH-116") + assert "result: FAIL" in body + assert "smoke: failed" in body + + +# --------------------------------------------------------------------------- +# TC-14 — observability + hybrid: /queue block + structured verdict log (AC-12/AC-13) +# --------------------------------------------------------------------------- +def test_tc14_snapshot_shape(): + snap = test_runner.snapshot() + for k in ("enabled", "repos", "target", "timeout_s", "smoke_enabled", + "infra_max_retries", "runs", "pass", "fail", "tool_error", "deferred"): + assert k in snap, f"snapshot missing key {k}" + + +def test_tc14_queue_endpoint_includes_block(): + import asyncio + from src import main + payload = asyncio.run(main.queue()) + assert "test_runner" in payload + assert "enabled" in payload["test_runner"] + + +def test_tc14_structured_verdict_log_distinguishes_outcomes(monkeypatch, caplog): + tid = _make_task("testing") + monkeypatch.setattr(stage_engine, "advance_stage", MagicMock()) + # code-pass + monkeypatch.setattr(test_runner, "run_test_suite", + lambda repo, branch: ProcResult(returncode=0, stdout="", stderr="", timed_out=False)) + with caplog.at_level("INFO", logger="orchestrator.test_runner"): + test_runner.run_test_gate(_job_dict(1, "tester", "orchestrator", tid)) + assert any("outcome=code-pass" in r.message for r in caplog.records) + + caplog.clear() + # tool-error + monkeypatch.setattr(cfg.settings, "test_runner_infra_max_retries", 2) + monkeypatch.setattr(test_runner, "run_test_suite", + lambda repo, branch: ProcResult(returncode=None, stdout="", stderr="", timed_out=True)) + with caplog.at_level("WARNING", logger="orchestrator.test_runner"): + test_runner.run_test_gate(_job_dict(1, "tester", "orchestrator", tid)) + assert any("outcome=tool-error" in r.message for r in caplog.records) + + +def test_tc14_snapshot_never_raises(monkeypatch): + class Boom: + def __getattr__(self, name): + raise RuntimeError("boom") + monkeypatch.setattr(test_runner, "settings", Boom()) + snap = test_runner.snapshot() + assert snap["enabled"] is False + + +# --------------------------------------------------------------------------- +# TC-15 — anti-drift of the LLM call-site map / roadmap stays green after our edits. +# --------------------------------------------------------------------------- +def test_tc15_llm_map_anti_drift_green(): + from tests import test_llm_call_site_inventory as inv + from tests import test_llm_determinization_docs as docs + # tester stays avoidable=yes / axis=C / needs-hybrid-fallback (LLM-branch = fallback). + inv.test_tc14_avoidable_set_fixed() + inv.test_tc13_control_path_axis_correct() + inv.test_tc04_classification_total_and_axis_consistent() + # roadmap: exactly one first_slice=yes (deployer); tester rank 2 hybrid. + docs.test_tc07_roadmap_completeness_and_first_slice() + docs.test_tc11_no_fabricated_followup_ids() From e386130fd16aeddf0e18b1c32875c6fbf4ae0332 Mon Sep 17 00:00:00 2001 From: claude-bot Date: Tue, 16 Jun 2026 03:07:41 +0300 Subject: [PATCH 05/16] reviewer(ET): auto-commit from reviewer run_id=741 --- docs/work-items/ORCH-116/12-review.md | 135 ++++++++++++++++++++++++++ 1 file changed, 135 insertions(+) create mode 100644 docs/work-items/ORCH-116/12-review.md diff --git a/docs/work-items/ORCH-116/12-review.md b/docs/work-items/ORCH-116/12-review.md new file mode 100644 index 0000000..120ec1f --- /dev/null +++ b/docs/work-items/ORCH-116/12-review.md @@ -0,0 +1,135 @@ +--- +verdict: APPROVED +work_item: ORCH-116 +stage: review +author_agent: reviewer +status: approved +created_at: 2026-06-16 +model_used: claude-opus-4-8 +type: review +work_item_id: ORCH-116 +version: 1 +--- + +# Review ORCH-116 — детерминированный test-раннер вместо LLM-тестера + +## Summary + +PR заменяет LLM-агента `tester` на стадии `testing` (self-hosting `orchestrator`) +детерминированным leaf `src/test_runner.py`, перехватываемым в `launch_job` **до `_spawn`** — +точное зеркало уже работающего в проде ORCH-115/`staging_runner`. Проверено по всем четырём осям: +соответствие ТЗ/AC, соответствие ADR, качество кода, документация. **Все 15 критериев приёмки +выполнены**, критический инвариант NFR-1 («замена *продюсера* артефакта, не гейта») соблюдён +байт-в-байт, документация (включая витрину `docs/overview/` и LLM-карту/roadmap/политику) обновлена +в том же PR. Полный регресс зелёный (`2137 passed`), новый `tests/test_orch116_test_runner.py` +зелёный (32 теста), LLM-анти-дрейф зелёный. **P0/P1 findings отсутствуют → `APPROVED`.** + +## Оси проверки + +### 1. Соответствие ТЗ / Acceptance Criteria — PASS + +Верифицировано по коду + тестам каждое AC: +- **AC-1** (перехват до `_spawn`) — `launcher.launch_job`: `if job.get("agent")=="tester" and + test_runner.should_intercept(job): return self._run_test_runner_job(job)`; `_run_test_runner_job` + ведёт `jobs` через `mark_job`, возвращает `None` (нет `agent_runs`). TC-05 воспроизводит без живого CLI. +- **AC-2** (контракт `13-test-report.md`) — `build_test_report` эмитит `result: PASS|FAIL` UPPERCASE + + полную 52c-схему; читается **неизменённым** `_parse_tests_verdict` (TC-04). +- **AC-3** (exit→verdict) — `map_exit_code_to_result` — тонкий транслятор над единым + `self_deploy.map_exit_code_to_status` (`0→PASS`, иначе/None/нечисло→`FAIL`); второй маппинг не введён (TC-02). +- **AC-4** (эквивалентность маршрутизации) — `_advance(finished_agent="tester", current_stage="testing")`, + без новых рёбер; PASS→advance, FAIL→существующий откат `testing→development` (TC-07/TC-10). +- **AC-5** (two-level outcome) — `run_test_gate`: `suite_ran = returncode is not None and not timed_out`; + tool-error → bounded DEFER re-queue **`tester`**-джоба, не код-фейл-откат (TC-10). +- **AC-6** (анти-дрейф) — `git diff` по `src/` затрагивает только `launcher.py`/`config.py`/`main.py`/ + `test_runner.py`; `src/stages.py` (STAGE_TRANSITIONS) и `src/qg/checks.py` (`check_tests_passed`/ + `_parse_tests_verdict`) **не тронуты**; новых таблиц нет (TC-09). +- **AC-7/AC-8** (kill-switch / backward-compat) — `applies()` гасит при `enabled=False`, скоупит CSV, + и `_has_test_contract` → `False` для не-self репо даже при ручном добавлении в CSV (TC-01/TC-08). +- **AC-9** (never-raise) — все публичные функции в `try/except`; `run_test_gate` не роняет воркер (TC-11). +- **AC-10** (self-hosting safety) — `build_test_command` без литералов рестарта/compose/build/force-push/ + `.env`; smoke строго read-only GET (TC-13). +- **AC-11** (proc_group/worktree/timeout) — pytest в `get_worktree_path` через `run_in_process_group`, + `_resolve_timeout` дефолтит на малформе (TC-12). +- **AC-12/AC-13/AC-14/AC-15** — гибрид off-control-path, блок `test_runner` в `/queue`, обновление + LLM-карты/политики/витрины, полный регресс — все зелёные. + +### 2. Соответствие ADR — PASS + +Реализация дословно следует ADR-001 (D1–D12) и сквозному adr-0049. Ключевые места сверены: +- **D6.1 (анти-коллизия 52c-`status:` ↔ `_parse_tests_verdict`)** — корректно: `PASS → status: success` + (`SUCCESS` не позитивный и не негативный токен, позитив `PASS` берётся из `result:`), `FAIL → status: + failed` (`FAILED` — негативный токен, согласован). Прибито TC-04/`test_tc04_status_field_never_false_ + negatives_a_pass` через неизменённый парсер. Это была самая тонкая мина задачи — снята верно. +- **D5 DEFER** — побайтовое зеркало `staging_runner._handle_tool_error`, но re-queue **`tester`**-джоба + (не `deployer`) — проверено TC-10 (`assert agent == "tester"`). Счётчик restart-safe по маркеру в + `task_content`, без правки схемы БД. +- **Трассировка маркеров (TRACEABILITY):** правки рядом с ORCH-115 (`launcher`), ORCH-114 + (`advance_stage`/transition-lease — берётся **внутри** `advance_stage`, раннер не трогает, граница O1), + ORCH-110 (`proc_group` переиспользуется как есть) — ни один зафиксированный инвариант не сломан. +- Глобальные ADR (INV-4 «мерж только через PR», запрет рестарта прод-контейнера) — соблюдены: лог + пушится только в фичеветку, никакой работы с `main`. + +### 3. Качество кода — PASS + +- Docstrings на всех публичных функциях; контракт never-raise выдержан сквозно (каждый внешний вызов + обёрнут, наблюдательные счётчики через `_bump` не ломают решение). +- Тесты содержательные (32 TC, не тривиальные): покрыты kill-switch/scope/contract, маппинг по классам + входа, рендер+парсер, перехват, two-level outcome, never-raise, timeout, smoke read-only, + анти-дрейф, наблюдаемость. +- Сигнатуры зависимостей сверены: `db.enqueue_job(..., available_at_delay_s=)`, `db.mark_job`, + `self_deploy.map_exit_code_to_status`, `config.post_deploy_base_url` (дефолт `http://localhost:8500`) + — все существуют, AttributeError-риск smoke отсутствует. +- Security: smoke — только `urllib` GET к локальному оркестратору; мутирующих запросов нет. +- Это **не** багфикс-трек (стадия `architecture` отработана, full-cycle) → требование регресс-фиксатора + ORCH-019/BR-4 неприменимо; тем не менее покрытие исчерпывающее. + +### 4. Документация — PASS (обязательная проверка) + +`src/` изменён → документация обновлена **в том же PR**, проверено явно: +- **Паспорт** `CLAUDE.md` — новый раздел «Детерминированный test-раннер (ORCH-116)». +- **Компонент-карта** `docs/architecture/README.md` — запись **Test-runner** + блок roadmap «второй + срез реализован». +- **Внутренности** `docs/architecture/internals.md` — примечание о перехвате на `testing`. +- **LLM-карта/политика/roadmap** — `llm-call-sites.md` (A5), `llm-determinization-roadmap.md` (rank 2 ✅), + `llm-usage-policy.md` (§5); инвариант «ровно один `first_slice=yes`» цел; анти-дрейф-тесты зелёные. +- **Витрина системы `docs/overview/` (ORCH-011)** — обновлены `tech-pipeline.md`, `tech-agents.md`, + `tech-quality-security.md`; `tests/test_system_docs.py` зелёный. +- **Промпт** `.openclaw/agents/tester.md` — врезка «детерминированный раннер ведёт стадию; LLM — fallback». +- **`CHANGELOG.md`** — запись `[Unreleased]`. +- **ADR** заведён (`06-adr/ADR-001` + сквозной `adr-0049`). + +Обзорные доки / «Известные ограничения» README не затронуты этим PR (раннер — новая способность, не +закрытие документированного ограничения) → дополнительных правок не требуется. + +## Findings + +### P0 — Blocker +- Нет. + +### P1 — Must fix +- Нет. + +### P2 — Should fix +- Нет. + +### P3 — Nice-to-have (не блокирует) +- [ ] `_http_get` читает только первые 8192 байта тела (`resp.read(8192)`), а smoke проверяет наличие + `serial_gate` в ответе `/queue`. Эмпирически `serial_gate` лежит на офсете ~1481 байт (запас ~6.7 КБ + до границы) — **сейчас корректно**, но при будущем разрастании блоков `/queue` *перед* `serial_gate` + это латентная хрупкость (ложный smoke-FAIL здорового прогона). Опционально: поднять лимит чтения для + `/queue` или искать ключ потоково. Не блокирует — текущий запас комфортный. +- [ ] `build_test_command` добавляет флаг `-q`, отсутствующий в литеральной команде ADR (`python -m + pytest `). Безвредно и согласовано с прежним промптом tester (`pytest tests/ -q`); фиксирую + лишь как расхождение текст↔код. + +## Документация +Обновлена в полном объёме в том же PR (см. ось 4): `CLAUDE.md`, `docs/architecture/README.md`, +`internals.md`, `llm-call-sites.md`, `llm-determinization-roadmap.md`, `llm-usage-policy.md`, +`docs/overview/{tech-pipeline,tech-agents,tech-quality-security}.md`, `.openclaw/agents/tester.md`, +`CHANGELOG.md`, ADR-001 + сквозной adr-0049. Анти-дрейф-тесты документации (`test_llm_call_site_ +inventory.py`, `test_llm_determinization_docs.py`, `test_system_docs.py`) — зелёные. Требований к +обновлению документации, оставшихся невыполненными, **нет**. + +## Вердикт +Нет P0/P1 findings; критический инвариант NFR-1 соблюдён байт-в-байт; документация = golden source +обновлена синхронно с кодом; полный регресс зелёный. **`verdict: APPROVED`.** From b1e00c0a7d337ff0520ff6ca54417a1d5f97aa1a Mon Sep 17 00:00:00 2001 From: claude-bot Date: Tue, 16 Jun 2026 03:10:23 +0300 Subject: [PATCH 06/16] tester(ET): auto-commit from tester run_id=742 --- docs/work-items/ORCH-116/13-test-report.md | 72 ++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 docs/work-items/ORCH-116/13-test-report.md diff --git a/docs/work-items/ORCH-116/13-test-report.md b/docs/work-items/ORCH-116/13-test-report.md new file mode 100644 index 0000000..c5b6eb4 --- /dev/null +++ b/docs/work-items/ORCH-116/13-test-report.md @@ -0,0 +1,72 @@ +--- +result: PASS +work_item: ORCH-116 +stage: testing +author_agent: tester +status: pass +created_at: 2026-06-16 +model_used: claude-opus-4-8 +type: test-report +work_item_id: ORCH-116 +--- + +# Test Report — ORCH-116 + +Детерминированный test-раннер вместо LLM-тестера (стадия `testing`). + +## Окружение +- Python: 3.12.13 +- pytest: 8.3.3 (plugins: cov-5.0.0, anyio-4.14.0, asyncio-0.23.8) +- Worktree: `/repos/_wt/orchestrator/feature_ORCH-116-orch-replace-llm-tester-with-d` +- Ветка: `feature/ORCH-116-orch-replace-llm-tester-with-d` +- Дата: 2026-06-16 + +## Smoke API (read-only) +- `GET /health` → `{"status":"ok","service":"orchestrator"}` — **OK** +- `GET /status` → активные задачи отданы (ORCH-116 на `testing`) — **OK** +- `GET /queue` → отдан; блок `serial_gate` присутствует (ORCH-088), блок `auto_labels` присутствует, + блок `test_runner` присутствует (ORCH-116 наблюдаемость) — **OK** + +## Результаты по тест-плану (04-test-plan.yaml) + +| TC ID | Описание | Тест(ы) | Результат | +|-------|----------|---------|-----------| +| TC-01 | `applies(repo)`: kill-switch/скоуп/тест-контракт (BR-9), never-raise | `test_tc01_applies_killswitch_scope_and_contract`, `test_tc01_applies_never_raises` | PASS | +| TC-02 | Маппинг exit-кода 0→PASS / иначе/None→FAIL (fail-closed, единый контракт) | `test_tc02_map_exit_code` | PASS | +| TC-03 | Рендер `13-test-report.md`: `result:` UPPERCASE + 52c-схема + хвост stdout/smoke | `test_tc03_report_render_schema_and_status_alignment` | PASS | +| TC-04 | Артефакт читается неизменённым `_parse_tests_verdict` для PASS/FAIL | `test_tc04_gate_parser_unchanged`, `test_tc04_status_field_never_false_negatives_a_pass` | PASS | +| TC-05 | `launch_job` перехватывает tester-джоб до `_spawn`; `agent_runs` не создаётся, None | `test_tc05_launch_job_intercepts_before_spawn` | PASS | +| TC-06 | Дискриминатор: не-`testing`/не-tester/не-self не перехватываются; never-raise→False | `test_tc06_*` (4 теста) | PASS | +| TC-07 | PASS→advance(`tester`)→`deploy-staging`; FAIL→откат `testing→development` + retry | `test_tc07_advance_initiated_like_llm[0-PASS]`, `[1-FAIL]` | PASS | +| TC-08 | Kill-switch `test_runner_enabled=False` → `_spawn` (LLM-путь байт-в-байт) | `test_tc08_killswitch_falls_back_to_spawn` | PASS | +| TC-09 | Анти-дрейф NFR-1: `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_tests_passed`/токены/схема БД целы | `test_tc09_pipeline_contract_unchanged` | PASS | +| TC-10 | Two-level (анти-ORCH-110): tool-error→bounded DEFER; исчерпание→fail-closed FAIL+alert | `test_tc10_nonzero_exit_is_fail_and_advances`, `test_tc10_timeout_defers_without_advance`, `test_tc10_tool_error_budget_exhausted_fails_closed` | PASS | +| TC-11 | never-raise/fail-safe: pytest-бросок/таймаут/worktree-ошибка → FAIL/DEFER, не клинит | `test_tc11_run_gate_never_raises`, `test_tc11_launcher_contains_runner_fault` | PASS | +| TC-12 | Изоляция/таймаут: proc_group tree-kill в worktree; малформ→дефолт 900+WARNING | `test_tc12_resolve_timeout_default_on_bad_value`, `test_tc12_pytest_runs_in_worktree_via_proc_group` | PASS | +| TC-13 | Self-hosting safety: нет опасных литералов; smoke строго read-only GET; push в фичеветку | `test_tc13_*` (5 тестов) | PASS | +| TC-14 | Наблюдаемость+гибрид: блок `test_runner` в `/queue`; структурный лог; LLM вне control-path | `test_tc14_*` (4 теста) | PASS | +| TC-15 | Анти-дрейф LLM-карты: `llm-call-sites`/roadmap/policy зелёные после правок | `test_tc15_llm_map_anti_drift_green`, `test_llm_call_site_inventory.py`, `test_llm_determinization_docs.py` | PASS | + +Каждый TC из `04-test-plan.yaml` выполнен и сопоставлен с критериями `03-acceptance-criteria.md`. + +## Вывод pytest + +### Полный регресс +``` +$ python -m pytest tests/ -q --tb=short +........................................................................ [ 97%] +................................................. [100%] +2137 passed, 1 warning in 84.57s (0:01:24) +``` +(единственный warning — несвязанный Pydantic V2 deprecation в `src/config.py:8`) + +### Тесты ORCH-116 (verbose) +``` +$ python -m pytest tests/test_orch116_test_runner.py tests/test_llm_call_site_inventory.py tests/test_llm_determinization_docs.py -v +45 passed, 1 warning in 2.20s +``` + +## Итог +PASS — полный регресс зелёный (2137 passed), smoke read-only OK (`/health`/`/status`/`/queue`, +блок `serial_gate` присутствует), все 15 TC выполнены и сопоставлены с критериями приёмки. +Задача переходит на `deploy-staging`. From 024e1bfceb2841f15d8d47709abce4d049f742ec Mon Sep 17 00:00:00 2001 From: staging-runner Date: Tue, 16 Jun 2026 03:11:25 +0300 Subject: [PATCH 07/16] staging(ORCH-115): staging gate FAILED for ORCH-116 --- docs/work-items/ORCH-116/15-staging-log.md | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 docs/work-items/ORCH-116/15-staging-log.md diff --git a/docs/work-items/ORCH-116/15-staging-log.md b/docs/work-items/ORCH-116/15-staging-log.md new file mode 100644 index 0000000..f6e1ee1 --- /dev/null +++ b/docs/work-items/ORCH-116/15-staging-log.md @@ -0,0 +1,17 @@ +--- +staging_status: FAILED +work_item: ORCH-116 +stage: deploy-staging +author_agent: staging-runner +status: failed +created_at: 2026-06-16 +model_used: n/a +exit_code: None +base_url: http://localhost:8501 +--- + +# Staging Gate Log (deterministic runner, ORCH-115) + +Staging suite did NOT execute (tool-error) and the infra-retry budget was exhausted -> fail-closed FAILED. + +Вердикт зафиксирован детерминированным staging-раннером (ORCH-115), не LLM. infra-tolerance (ORCH-061) уже учтена внутри `staging_check.py` — раннер её не пересуживает. From a3ea56c751b7bb0eb556be703235b61b9c2bdc77 Mon Sep 17 00:00:00 2001 From: claude-bot Date: Tue, 16 Jun 2026 07:25:33 +0300 Subject: [PATCH 08/16] reviewer(ET): auto-commit from reviewer run_id=743 --- docs/work-items/ORCH-116/12-review.md | 138 +++++++++++++++----------- 1 file changed, 80 insertions(+), 58 deletions(-) diff --git a/docs/work-items/ORCH-116/12-review.md b/docs/work-items/ORCH-116/12-review.md index 120ec1f..bd80613 100644 --- a/docs/work-items/ORCH-116/12-review.md +++ b/docs/work-items/ORCH-116/12-review.md @@ -8,93 +8,105 @@ created_at: 2026-06-16 model_used: claude-opus-4-8 type: review work_item_id: ORCH-116 -version: 1 +version: 2 --- # Review ORCH-116 — детерминированный test-раннер вместо LLM-тестера ## Summary -PR заменяет LLM-агента `tester` на стадии `testing` (self-hosting `orchestrator`) -детерминированным leaf `src/test_runner.py`, перехватываемым в `launch_job` **до `_spawn`** — -точное зеркало уже работающего в проде ORCH-115/`staging_runner`. Проверено по всем четырём осям: -соответствие ТЗ/AC, соответствие ADR, качество кода, документация. **Все 15 критериев приёмки -выполнены**, критический инвариант NFR-1 («замена *продюсера* артефакта, не гейта») соблюдён -байт-в-байт, документация (включая витрину `docs/overview/` и LLM-карту/roadmap/политику) обновлена -в том же PR. Полный регресс зелёный (`2137 passed`), новый `tests/test_orch116_test_runner.py` -зелёный (32 теста), LLM-анти-дрейф зелёный. **P0/P1 findings отсутствуют → `APPROVED`.** +PR заменяет LLM-агента `tester` на стадии `testing` (self-hosting `orchestrator`) детерминированным +leaf `src/test_runner.py`, перехватываемым в `launch_job` **до `_spawn`** — точное зеркало уже +работающего в проде ORCH-115/`staging_runner`. Проверено независимо по всем четырём осям +(соответствие ТЗ/AC, соответствие ADR, качество кода, документация) с самостоятельным прогоном +тестов. **Все 15 критериев приёмки выполнены**; критический инвариант NFR-1 («замена *продюсера* +артефакта, не гейта») соблюдён байт-в-байт (только 4 файла в `src/`, `stages.py`/`qg/checks.py` не +тронуты); документация = golden source обновлена в том же PR. Полный регресс **проверен лично**: +`pytest tests/ -q` → **2137 passed**; ORCH-116 + LLM-анти-дрейф + system-docs → 74 passed. **P0/P1 +findings отсутствуют → `APPROVED`.** ## Оси проверки ### 1. Соответствие ТЗ / Acceptance Criteria — PASS -Верифицировано по коду + тестам каждое AC: +Верифицировано по коду + тестам + личному прогону каждое AC: - **AC-1** (перехват до `_spawn`) — `launcher.launch_job`: `if job.get("agent")=="tester" and test_runner.should_intercept(job): return self._run_test_runner_job(job)`; `_run_test_runner_job` - ведёт `jobs` через `mark_job`, возвращает `None` (нет `agent_runs`). TC-05 воспроизводит без живого CLI. -- **AC-2** (контракт `13-test-report.md`) — `build_test_report` эмитит `result: PASS|FAIL` UPPERCASE + - полную 52c-схему; читается **неизменённым** `_parse_tests_verdict` (TC-04). + ведёт `jobs` через `mark_job`, возвращает `None` (нет `agent_runs`). TC-05 воспроизводит без CLI. +- **AC-2** (контракт `13-test-report.md`) — `build_test_report` эмитит `result: PASS|FAIL` UPPERCASE + + полную 52c-схему; читается **неизменённым** `_parse_tests_verdict` (TC-04, лично подтверждено). - **AC-3** (exit→verdict) — `map_exit_code_to_result` — тонкий транслятор над единым - `self_deploy.map_exit_code_to_status` (`0→PASS`, иначе/None/нечисло→`FAIL`); второй маппинг не введён (TC-02). -- **AC-4** (эквивалентность маршрутизации) — `_advance(finished_agent="tester", current_stage="testing")`, - без новых рёбер; PASS→advance, FAIL→существующий откат `testing→development` (TC-07/TC-10). -- **AC-5** (two-level outcome) — `run_test_gate`: `suite_ran = returncode is not None and not timed_out`; - tool-error → bounded DEFER re-queue **`tester`**-джоба, не код-фейл-откат (TC-10). -- **AC-6** (анти-дрейф) — `git diff` по `src/` затрагивает только `launcher.py`/`config.py`/`main.py`/ - `test_runner.py`; `src/stages.py` (STAGE_TRANSITIONS) и `src/qg/checks.py` (`check_tests_passed`/ - `_parse_tests_verdict`) **не тронуты**; новых таблиц нет (TC-09). + `self_deploy.map_exit_code_to_status` (`0→PASS`, иначе/None/нечисло→`FAIL`); второй маппинг не + введён (TC-02). +- **AC-4** (эквивалентность маршрутизации) — `_advance(finished_agent="tester", + current_stage="testing")`, без новых рёбер; PASS→advance, FAIL→существующий откат + `testing→development` (TC-07/TC-10). +- **AC-5** (two-level outcome) — `run_test_gate`: `suite_ran = returncode is not None and not + timed_out`; tool-error → bounded DEFER re-queue **`tester`**-джоба (TC-10 проверяет `agent == + "tester"`), не код-фейл-откат, не жжёт developer-retry. +- **AC-6** (анти-дрейф) — `git diff` по `src/` затрагивает только + `launcher.py`/`config.py`/`main.py`/`test_runner.py`; `src/stages.py` и `src/qg/checks.py` + **байт-в-байт не тронуты** (проверено `git diff` лично); новых таблиц нет (TC-09). - **AC-7/AC-8** (kill-switch / backward-compat) — `applies()` гасит при `enabled=False`, скоупит CSV, и `_has_test_contract` → `False` для не-self репо даже при ручном добавлении в CSV (TC-01/TC-08). -- **AC-9** (never-raise) — все публичные функции в `try/except`; `run_test_gate` не роняет воркер (TC-11). -- **AC-10** (self-hosting safety) — `build_test_command` без литералов рестарта/compose/build/force-push/ - `.env`; smoke строго read-only GET (TC-13). -- **AC-11** (proc_group/worktree/timeout) — pytest в `get_worktree_path` через `run_in_process_group`, - `_resolve_timeout` дефолтит на малформе (TC-12). +- **AC-9** (never-raise) — все публичные функции в `try/except`; `run_test_gate` не роняет воркер + (TC-11). +- **AC-10** (self-hosting safety) — `build_test_command` без литералов + рестарта/compose/build/force-push/`.env`; smoke строго read-only GET (TC-13). +- **AC-11** (proc_group/worktree/timeout) — pytest в `get_worktree_path` через + `run_in_process_group`, `_resolve_timeout` дефолтит на малформе (TC-12). - **AC-12/AC-13/AC-14/AC-15** — гибрид off-control-path, блок `test_runner` в `/queue`, обновление - LLM-карты/политики/витрины, полный регресс — все зелёные. + LLM-карты/политики/витрины, полный регресс — все зелёные (AC-15 проверен личным прогоном). ### 2. Соответствие ADR — PASS Реализация дословно следует ADR-001 (D1–D12) и сквозному adr-0049. Ключевые места сверены: -- **D6.1 (анти-коллизия 52c-`status:` ↔ `_parse_tests_verdict`)** — корректно: `PASS → status: success` - (`SUCCESS` не позитивный и не негативный токен, позитив `PASS` берётся из `result:`), `FAIL → status: - failed` (`FAILED` — негативный токен, согласован). Прибито TC-04/`test_tc04_status_field_never_false_ - negatives_a_pass` через неизменённый парсер. Это была самая тонкая мина задачи — снята верно. -- **D5 DEFER** — побайтовое зеркало `staging_runner._handle_tool_error`, но re-queue **`tester`**-джоба - (не `deployer`) — проверено TC-10 (`assert agent == "tester"`). Счётчик restart-safe по маркеру в +- **D6.1 (анти-коллизия 52c-`status:` ↔ `_parse_tests_verdict`)** — корректно и проверено против + **неизменённого** парсера (`src/qg/checks.py:263-277`): `result: PASS → status: success` + (конкатенация `"SUCCESS PASS"` — нет негативного токена, позитив `PASS` из `result:` → `True`); + `result: FAIL → status: failed` (`"FAILED FAIL"` — негативный токен → `False`). В `build_test_report` + жёстко: `sub_status = "success" if result == "PASS" else "failed"`. Прибито + TC-04/`test_tc04_status_field_never_false_negatives_a_pass`. Самая тонкая мина задачи — снята верно. +- **D5 DEFER** — зеркало `staging_runner._handle_tool_error`, но re-queue **`tester`**-джоба (не + `deployer`) — проверено TC-10. Счётчик restart-safe по маркеру `test-runner infra-retry` в `task_content`, без правки схемы БД. - **Трассировка маркеров (TRACEABILITY):** правки рядом с ORCH-115 (`launcher`), ORCH-114 - (`advance_stage`/transition-lease — берётся **внутри** `advance_stage`, раннер не трогает, граница O1), - ORCH-110 (`proc_group` переиспользуется как есть) — ни один зафиксированный инвариант не сломан. + (transition-lease берётся **внутри** `advance_stage` — раннер не трогает, граница O1), ORCH-110 + (`proc_group` переиспользуется как есть) — ни один зафиксированный инвариант не сломан. - Глобальные ADR (INV-4 «мерж только через PR», запрет рестарта прод-контейнера) — соблюдены: лог пушится только в фичеветку, никакой работы с `main`. ### 3. Качество кода — PASS - Docstrings на всех публичных функциях; контракт never-raise выдержан сквозно (каждый внешний вызов - обёрнут, наблюдательные счётчики через `_bump` не ломают решение). -- Тесты содержательные (32 TC, не тривиальные): покрыты kill-switch/scope/contract, маппинг по классам - входа, рендер+парсер, перехват, two-level outcome, never-raise, timeout, smoke read-only, - анти-дрейф, наблюдаемость. -- Сигнатуры зависимостей сверены: `db.enqueue_job(..., available_at_delay_s=)`, `db.mark_job`, - `self_deploy.map_exit_code_to_status`, `config.post_deploy_base_url` (дефолт `http://localhost:8500`) - — все существуют, AttributeError-риск smoke отсутствует. + обёрнут; наблюдательные счётчики через `_bump` не ломают решение). +- Тесты содержательные (32 тест-функции, не тривиальные): kill-switch/scope/contract, маппинг по + классам входа, рендер+парсер, перехват, two-level outcome, never-raise, timeout, smoke read-only + (включая транзиент-ретрай и missing-serial_gate), анти-дрейф, наблюдаемость. +- **Сигнатуры зависимостей сверены лично** (риск latent false-FAIL устранён): + `db.enqueue_job(..., task_id=, available_at_delay_s=)`, `db.mark_job`, + `self_deploy.map_exit_code_to_status`, `git_worktree.get_worktree_path(repo, branch)`, + `qg.checks.is_self_hosting_repo`, `config.post_deploy_base_url` (дефолт `http://localhost:8500`) — + все существуют ровно как используются. - Security: smoke — только `urllib` GET к локальному оркестратору; мутирующих запросов нет. -- Это **не** багфикс-трек (стадия `architecture` отработана, full-cycle) → требование регресс-фиксатора - ORCH-019/BR-4 неприменимо; тем не менее покрытие исчерпывающее. +- Это **не** багфикс-трек (стадия `architecture` отработана, full-cycle) → требование + регресс-фиксатора ORCH-019/BR-4 неприменимо; тем не менее покрытие исчерпывающее. ### 4. Документация — PASS (обязательная проверка) -`src/` изменён → документация обновлена **в том же PR**, проверено явно: +`src/` изменён → документация обновлена **в том же PR**, проверено явно по `git diff`: - **Паспорт** `CLAUDE.md` — новый раздел «Детерминированный test-раннер (ORCH-116)». - **Компонент-карта** `docs/architecture/README.md` — запись **Test-runner** + блок roadmap «второй срез реализован». - **Внутренности** `docs/architecture/internals.md` — примечание о перехвате на `testing`. -- **LLM-карта/политика/roadmap** — `llm-call-sites.md` (A5), `llm-determinization-roadmap.md` (rank 2 ✅), - `llm-usage-policy.md` (§5); инвариант «ровно один `first_slice=yes`» цел; анти-дрейф-тесты зелёные. +- **LLM-карта/политика/roadmap** — `llm-call-sites.md` (A5), `llm-determinization-roadmap.md` + (rank 2 ✅), `llm-usage-policy.md` (§5); инвариант «ровно один `first_slice=yes`» цел (у rank 1 + deployer); анти-дрейф-тесты `test_llm_call_site_inventory.py`/`test_llm_determinization_docs.py` — + зелёные (лично прогнаны). - **Витрина системы `docs/overview/` (ORCH-011)** — обновлены `tech-pipeline.md`, `tech-agents.md`, - `tech-quality-security.md`; `tests/test_system_docs.py` зелёный. -- **Промпт** `.openclaw/agents/tester.md` — врезка «детерминированный раннер ведёт стадию; LLM — fallback». + `tech-quality-security.md`; `tests/test_system_docs.py` зелёный (лично прогнан). +- **Промпт** `.openclaw/agents/tester.md` — врезка «детерминированный раннер ведёт стадию; LLM — + fallback». - **`CHANGELOG.md`** — запись `[Unreleased]`. - **ADR** заведён (`06-adr/ADR-001` + сквозной `adr-0049`). @@ -114,22 +126,32 @@ PR заменяет LLM-агента `tester` на стадии `testing` (self- ### P3 — Nice-to-have (не блокирует) - [ ] `_http_get` читает только первые 8192 байта тела (`resp.read(8192)`), а smoke проверяет наличие - `serial_gate` в ответе `/queue`. Эмпирически `serial_gate` лежит на офсете ~1481 байт (запас ~6.7 КБ - до границы) — **сейчас корректно**, но при будущем разрастании блоков `/queue` *перед* `serial_gate` - это латентная хрупкость (ложный smoke-FAIL здорового прогона). Опционально: поднять лимит чтения для - `/queue` или искать ключ потоково. Не блокирует — текущий запас комфортный. + `serial_gate` в ответе `/queue`. `serial_gate` — 11-й ключ ответа (`src/main.py:261`), идёт **до** + основной массы аддитивных блоков (coverage/fs_ownership/auto_labels/stop/bug_fast_track/ + checkout_hygiene/transition_lease/staging_runner/test_runner/lessons) → запас комфортный, **сейчас + корректно**. Латентная хрупкость при разрастании ранних блоков — опционально поднять лимит чтения + для `/queue` или искать ключ потоково. Не блокирует. - [ ] `build_test_command` добавляет флаг `-q`, отсутствующий в литеральной команде ADR (`python -m pytest `). Безвредно и согласовано с прежним промптом tester (`pytest tests/ -q`); фиксирую лишь как расхождение текст↔код. +### Контекст (не finding) +- В истории ветки присутствует `15-staging-log.md` со `staging_status: FAILED` (`exit_code: None` — + staging-сюита **не исполнилась**, tool-error/инфра, бюджет инфра-ретраев исчерпан → fail-closed). + Это исход **deploy-staging** стадии (downstream от review), относится к staging-раннеру ORCH-115 и + является **инфра-сбоем, а не дефектом кода ORCH-116** — вне осей код-ревью. Поведение гейта + корректно (fail-closed на исчерпании инфра-бюджета); правок в коде задачи не требует. Отмечено как + контекст для последующих стадий. + ## Документация Обновлена в полном объёме в том же PR (см. ось 4): `CLAUDE.md`, `docs/architecture/README.md`, `internals.md`, `llm-call-sites.md`, `llm-determinization-roadmap.md`, `llm-usage-policy.md`, `docs/overview/{tech-pipeline,tech-agents,tech-quality-security}.md`, `.openclaw/agents/tester.md`, -`CHANGELOG.md`, ADR-001 + сквозной adr-0049. Анти-дрейф-тесты документации (`test_llm_call_site_ -inventory.py`, `test_llm_determinization_docs.py`, `test_system_docs.py`) — зелёные. Требований к -обновлению документации, оставшихся невыполненными, **нет**. +`CHANGELOG.md`, ADR-001 + сквозной adr-0049. Анти-дрейф-тесты документации +(`test_llm_call_site_inventory.py`, `test_llm_determinization_docs.py`, `test_system_docs.py`) — +зелёные. Невыполненных требований к обновлению документации **нет**. ## Вердикт -Нет P0/P1 findings; критический инвариант NFR-1 соблюдён байт-в-байт; документация = golden source -обновлена синхронно с кодом; полный регресс зелёный. **`verdict: APPROVED`.** +Нет P0/P1 findings; критический инвариант NFR-1 соблюдён байт-в-байт (`stages.py`/`qg/checks.py` не +тронуты); документация = golden source обновлена синхронно с кодом; полный регресс зелёный лично +проверен (2137 passed). **`verdict: APPROVED`.** From 4c7b2345b7ed7aa7c98f707a518c9e9c11117695 Mon Sep 17 00:00:00 2001 From: claude-bot Date: Tue, 16 Jun 2026 09:20:21 +0300 Subject: [PATCH 09/16] reviewer(ET): auto-commit from reviewer run_id=754 --- docs/work-items/ORCH-116/12-review.md | 178 ++++++++++++++------------ 1 file changed, 97 insertions(+), 81 deletions(-) diff --git a/docs/work-items/ORCH-116/12-review.md b/docs/work-items/ORCH-116/12-review.md index bd80613..edd1868 100644 --- a/docs/work-items/ORCH-116/12-review.md +++ b/docs/work-items/ORCH-116/12-review.md @@ -8,7 +8,7 @@ created_at: 2026-06-16 model_used: claude-opus-4-8 type: review work_item_id: ORCH-116 -version: 2 +version: 3 --- # Review ORCH-116 — детерминированный test-раннер вместо LLM-тестера @@ -17,101 +17,117 @@ version: 2 PR заменяет LLM-агента `tester` на стадии `testing` (self-hosting `orchestrator`) детерминированным leaf `src/test_runner.py`, перехватываемым в `launch_job` **до `_spawn`** — точное зеркало уже -работающего в проде ORCH-115/`staging_runner`. Проверено независимо по всем четырём осям -(соответствие ТЗ/AC, соответствие ADR, качество кода, документация) с самостоятельным прогоном -тестов. **Все 15 критериев приёмки выполнены**; критический инвариант NFR-1 («замена *продюсера* -артефакта, не гейта») соблюдён байт-в-байт (только 4 файла в `src/`, `stages.py`/`qg/checks.py` не -тронуты); документация = golden source обновлена в том же PR. Полный регресс **проверен лично**: -`pytest tests/ -q` → **2137 passed**; ORCH-116 + LLM-анти-дрейф + system-docs → 74 passed. **P0/P1 -findings отсутствуют → `APPROVED`.** +работающего в проде ORCH-115/`staging_runner`. Ревью выполнено **независимо** по всем четырём осям +(ТЗ/AC · ADR · качество кода · документация) с личным прогоном тестов и сверкой сигнатур +зависимостей. Критический инвариант **NFR-1** («замена *продюсера* артефакта, не гейта») соблюдён +байт-в-байт: `src/stages.py`, `src/qg/checks.py`, `src/staging_runner.py`, `src/transition_lease.py`, +`src/proc_group.py` — **не тронуты** (подтверждено `git diff --stat`); в `src/` изменены только +`test_runner.py` (новый), `launcher.py`/`config.py`/`main.py` (аддитивно). Документация = golden +source обновлена в том же PR (8 doc-файлов + CHANGELOG + ADR-001/adr-0049). Полный регресс +**проверен лично**: `pytest tests/ -q` → **2137 passed**; ORCH-116 + LLM-анти-дрейф + system-docs → +**74 passed**. **P0/P1/P2 findings отсутствуют → `APPROVED`.** ## Оси проверки ### 1. Соответствие ТЗ / Acceptance Criteria — PASS Верифицировано по коду + тестам + личному прогону каждое AC: -- **AC-1** (перехват до `_spawn`) — `launcher.launch_job`: `if job.get("agent")=="tester" and - test_runner.should_intercept(job): return self._run_test_runner_job(job)`; `_run_test_runner_job` - ведёт `jobs` через `mark_job`, возвращает `None` (нет `agent_runs`). TC-05 воспроизводит без CLI. +- **AC-1** (перехват до `_spawn`) — `launcher.launch_job`: `if job.get("agent")=="tester":` → + `if test_runner.should_intercept(job): return self._run_test_runner_job(job)` вставлено **перед** + `return self._spawn(...)`; `_run_test_runner_job` ведёт `jobs` через `mark_job(done|failed)`, + возвращает `None` (нет `agent_runs`). TC-05 воспроизводит без живого CLI (`spawn.assert_not_called`). - **AC-2** (контракт `13-test-report.md`) — `build_test_report` эмитит `result: PASS|FAIL` UPPERCASE - + полную 52c-схему; читается **неизменённым** `_parse_tests_verdict` (TC-04, лично подтверждено). + + полную 52c-схему; читается **неизменённым** `_parse_tests_verdict` (TC-04, лично подтверждено + прогоном через реальный парсер). - **AC-3** (exit→verdict) — `map_exit_code_to_result` — тонкий транслятор над единым - `self_deploy.map_exit_code_to_status` (`0→PASS`, иначе/None/нечисло→`FAIL`); второй маппинг не - введён (TC-02). -- **AC-4** (эквивалентность маршрутизации) — `_advance(finished_agent="tester", - current_stage="testing")`, без новых рёбер; PASS→advance, FAIL→существующий откат - `testing→development` (TC-07/TC-10). -- **AC-5** (two-level outcome) — `run_test_gate`: `suite_ran = returncode is not None and not - timed_out`; tool-error → bounded DEFER re-queue **`tester`**-джоба (TC-10 проверяет `agent == - "tester"`), не код-фейл-откат, не жжёт developer-retry. + `self_deploy.map_exit_code_to_status` (`0→PASS`, иначе/None/нечисло→`FAIL`, fail-closed); второй + маппинг не введён (TC-02 сверяет с базовым контрактом). +- **AC-4** (эквивалентность маршрутизации) — `_advance(current_stage="testing", + finished_agent="tester")`, без новых рёбер; PASS→advance, FAIL→существующий откат + `testing→development` (TC-07 параметризован [PASS/FAIL]). +- **AC-5** (two-level outcome, анти-ORCH-110) — `suite_ran = (returncode is not None) and (not + timed_out)`; tool-error → bounded DEFER re-queue **`tester`**-джоба (TC-10 проверяет `agent == + "tester"`), не код-фейл-откат, не жжёт developer-retry; исчерпание бюджета → fail-closed FAIL + + alert. - **AC-6** (анти-дрейф) — `git diff` по `src/` затрагивает только - `launcher.py`/`config.py`/`main.py`/`test_runner.py`; `src/stages.py` и `src/qg/checks.py` - **байт-в-байт не тронуты** (проверено `git diff` лично); новых таблиц нет (TC-09). -- **AC-7/AC-8** (kill-switch / backward-compat) — `applies()` гасит при `enabled=False`, скоупит CSV, - и `_has_test_contract` → `False` для не-self репо даже при ручном добавлении в CSV (TC-01/TC-08). -- **AC-9** (never-raise) — все публичные функции в `try/except`; `run_test_gate` не роняет воркер - (TC-11). + `launcher.py`/`config.py`/`main.py`/`test_runner.py`; `src/stages.py`, `src/qg/checks.py` + **байт-в-байт не тронуты** (проверено `git diff --stat` лично); новых таблиц нет (TC-09). +- **AC-7/AC-8** (kill-switch / backward-compat) — `applies()` гасит при `enabled=False`, скоупит CSV; + `_has_test_contract` → `False` для не-self репо даже при ручном добавлении в CSV (TC-01/TC-08). +- **AC-9** (never-raise) — все публичные функции в `try/except`; `run_test_gate` имеет внешний + guard; `_run_test_runner_job` дополнительно оборачивает (TC-11: воркер не падает / не клинит). - **AC-10** (self-hosting safety) — `build_test_command` без литералов - рестарта/compose/build/force-push/`.env`; smoke строго read-only GET (TC-13). -- **AC-11** (proc_group/worktree/timeout) — pytest в `get_worktree_path` через - `run_in_process_group`, `_resolve_timeout` дефолтит на малформе (TC-12). + рестарта/compose/build/force-push/`.env`; smoke строго read-only GET; лог пушится только в + фичеветку, никакой прямой работы с `main` (TC-13). +- **AC-11** (proc_group/worktree/timeout) — pytest в `get_worktree_path(repo, branch)` через + `run_in_process_group` (tree-kill), `_resolve_timeout` дефолтит на малформе + WARNING; без правки + `reaper_max_running_s` (TC-12). - **AC-12/AC-13/AC-14/AC-15** — гибрид off-control-path, блок `test_runner` в `/queue`, обновление - LLM-карты/политики/витрины, полный регресс — все зелёные (AC-15 проверен личным прогоном). + LLM-карты/политики/roadmap/витрины, полный регресс — все зелёные (AC-15: 2137 passed, проверено + лично). ### 2. Соответствие ADR — PASS -Реализация дословно следует ADR-001 (D1–D12) и сквозному adr-0049. Ключевые места сверены: -- **D6.1 (анти-коллизия 52c-`status:` ↔ `_parse_tests_verdict`)** — корректно и проверено против - **неизменённого** парсера (`src/qg/checks.py:263-277`): `result: PASS → status: success` - (конкатенация `"SUCCESS PASS"` — нет негативного токена, позитив `PASS` из `result:` → `True`); - `result: FAIL → status: failed` (`"FAILED FAIL"` — негативный токен → `False`). В `build_test_report` - жёстко: `sub_status = "success" if result == "PASS" else "failed"`. Прибито - TC-04/`test_tc04_status_field_never_false_negatives_a_pass`. Самая тонкая мина задачи — снята верно. +Реализация дословно следует ADR-001 (D1–D12) и сквозному adr-0049. Сверено критическое: +- **D6.1 (анти-коллизия 52c-`status:` ↔ `_parse_tests_verdict`)** — самая тонкая мина задачи. + Сверено по **неизменённому** парсеру (`src/qg/checks.py:226-282`): он читает вердикт из ТРЁХ + равноранговых полей `verdict:`/`status:`/`result:` c negative-token-priority. `build_test_report` + жёстко выравнивает `sub_status = "success" if result=="PASS" else "failed"`: для PASS конкатенация + `"SUCCESS PASS"` не содержит ни одного из `_TESTS_NEGATIVE_TOKENS` + (`BLOCKED/FAILED/FAIL/REQUEST_CHANGES/REJECT/RED`), позитив `PASS` из `result:` → `True`; для FAIL + `"FAILED FAIL"` → негативный токен → `False`. Прибито TC-04 + (`test_tc04_status_field_never_false_negatives_a_pass`) через реальный парсер. Мина снята верно. - **D5 DEFER** — зеркало `staging_runner._handle_tool_error`, но re-queue **`tester`**-джоба (не - `deployer`) — проверено TC-10. Счётчик restart-safe по маркеру `test-runner infra-retry` в - `task_content`, без правки схемы БД. -- **Трассировка маркеров (TRACEABILITY):** правки рядом с ORCH-115 (`launcher`), ORCH-114 + `deployer`!), счётчик restart-safe по маркеру `test-runner infra-retry` в `task_content` (без + правки схемы БД). Проверено TC-10. +- **D4 единый маппинг** — переиспользован `self_deploy.map_exit_code_to_status` (BR-4), второй + несогласованный маппинг не введён. +- **Трассировка маркеров (TRACEABILITY):** правки рядом с ORCH-115 (`launcher` врезка), ORCH-114 (transition-lease берётся **внутри** `advance_stage` — раннер не трогает, граница O1), ORCH-110 (`proc_group` переиспользуется как есть) — ни один зафиксированный инвариант не сломан. -- Глобальные ADR (INV-4 «мерж только через PR», запрет рестарта прод-контейнера) — соблюдены: лог - пушится только в фичеветку, никакой работы с `main`. +- **Глобальные ADR** (INV-4 «мерж только через PR», запрет рестарта прод-контейнера) — соблюдены: + лог пушится только в фичеветку (`git push origin `, не force, не `main`); смоук read-only. ### 3. Качество кода — PASS -- Docstrings на всех публичных функциях; контракт never-raise выдержан сквозно (каждый внешний вызов - обёрнут; наблюдательные счётчики через `_bump` не ломают решение). -- Тесты содержательные (32 тест-функции, не тривиальные): kill-switch/scope/contract, маппинг по - классам входа, рендер+парсер, перехват, two-level outcome, never-raise, timeout, smoke read-only - (включая транзиент-ретрай и missing-serial_gate), анти-дрейф, наблюдаемость. +- **Docstrings** на всех публичных функциях; контракт **never-raise** выдержан сквозно (каждый + внешний вызов обёрнут; счётчики через `_bump` не ломают решение). - **Сигнатуры зависимостей сверены лично** (риск latent false-FAIL устранён): - `db.enqueue_job(..., task_id=, available_at_delay_s=)`, `db.mark_job`, + `db.enqueue_job(agent, repo, task_content, task_id=, available_at_delay_s=)`, `db.mark_job`, `self_deploy.map_exit_code_to_status`, `git_worktree.get_worktree_path(repo, branch)`, - `qg.checks.is_self_hosting_repo`, `config.post_deploy_base_url` (дефолт `http://localhost:8500`) — - все существуют ровно как используются. -- Security: smoke — только `urllib` GET к локальному оркестратору; мутирующих запросов нет. -- Это **не** багфикс-трек (стадия `architecture` отработана, full-cycle) → требование - регресс-фиксатора ORCH-019/BR-4 неприменимо; тем не менее покрытие исчерпывающее. + `qg.checks.is_self_hosting_repo`, `config.post_deploy_base_url` (дефолт `http://localhost:8500`), + `notifications.send_telegram`/`link_for`, `proc_group.run_in_process_group`/`ProcResult` — все + существуют ровно как используются. +- **Тесты содержательные** (TC-01…TC-15, ~32 тест-функции, не тривиальные): kill-switch/scope/contract, + маппинг по классам входа, рендер+неизменённый парсер, перехват до `_spawn`, two-level outcome, + never-raise, timeout-resolve, smoke read-only (включая транзиент-ретрай и missing-`serial_gate`), + анти-дрейф конвейера, наблюдаемость, структурный лог. +- **Security:** smoke — только `urllib` GET к локальному оркестратору; мутирующих запросов нет. +- **Багфикс-трек неприменим:** это **не** `Bug`-задача (full-cycle, стадия `architecture` отработана, + есть ADR) → требование регресс-фиксатора ORCH-019/BR-4 не применяется; покрытие тем не менее + исчерпывающее. ### 4. Документация — PASS (обязательная проверка) -`src/` изменён → документация обновлена **в том же PR**, проверено явно по `git diff`: -- **Паспорт** `CLAUDE.md` — новый раздел «Детерминированный test-раннер (ORCH-116)». -- **Компонент-карта** `docs/architecture/README.md` — запись **Test-runner** + блок roadmap «второй - срез реализован». -- **Внутренности** `docs/architecture/internals.md` — примечание о перехвате на `testing`. +`src/` изменён → документация обновлена **в том же PR**, проверено явно по `git diff` (наличие +правок подтверждено по каждому файлу): +- **Паспорт** `CLAUDE.md` — новый раздел «Детерминированный test-раннер вместо LLM-тестера (ORCH-116)». +- **Компонент-карта** `docs/architecture/README.md` (3 hits) + **внутренности** `internals.md` + (5 hits) — перехват на `testing` рядом с ORCH-115. - **LLM-карта/политика/roadmap** — `llm-call-sites.md` (A5), `llm-determinization-roadmap.md` - (rank 2 ✅), `llm-usage-policy.md` (§5); инвариант «ровно один `first_slice=yes`» цел (у rank 1 - deployer); анти-дрейф-тесты `test_llm_call_site_inventory.py`/`test_llm_determinization_docs.py` — - зелёные (лично прогнаны). + (rank 2 ✅ реализован; инвариант «ровно один `first_slice=yes`» цел — `yes` у rank 1 deployer, + `no`/`hybrid_needed=yes` у rank 2 tester), `llm-usage-policy.md` (§5); анти-дрейф-тесты + `test_llm_call_site_inventory.py`/`test_llm_determinization_docs.py` — **зелёные (лично прогнаны)**. - **Витрина системы `docs/overview/` (ORCH-011)** — обновлены `tech-pipeline.md`, `tech-agents.md`, - `tech-quality-security.md`; `tests/test_system_docs.py` зелёный (лично прогнан). + `tech-quality-security.md`; `tests/test_system_docs.py` — **зелёный (лично прогнан)**. - **Промпт** `.openclaw/agents/tester.md` — врезка «детерминированный раннер ведёт стадию; LLM — - fallback». -- **`CHANGELOG.md`** — запись `[Unreleased]`. -- **ADR** заведён (`06-adr/ADR-001` + сквозной `adr-0049`). + fallback под выключенным флагом / для репо без контракта»; канон 52d (5 секций, ключ `result:`) цел. +- **`CHANGELOG.md`** — развёрнутая запись `[Unreleased]`. +- **ADR** заведён (`06-adr/ADR-001-deterministic-test-runner.md` + сквозной + `adr/adr-0049-deterministic-test-runner.md`). -Обзорные доки / «Известные ограничения» README не затронуты этим PR (раннер — новая способность, не -закрытие документированного ограничения) → дополнительных правок не требуется. +Обзорные доки / README «Известные ограничения» (ORCH-079): раннер — **новая способность**, не +закрытие документированного ограничения → дополнительных правок README не требуется. ## Findings @@ -125,20 +141,20 @@ findings отсутствуют → `APPROVED`.** - Нет. ### P3 — Nice-to-have (не блокирует) -- [ ] `_http_get` читает только первые 8192 байта тела (`resp.read(8192)`), а smoke проверяет наличие - `serial_gate` в ответе `/queue`. `serial_gate` — 11-й ключ ответа (`src/main.py:261`), идёт **до** - основной массы аддитивных блоков (coverage/fs_ownership/auto_labels/stop/bug_fast_track/ - checkout_hygiene/transition_lease/staging_runner/test_runner/lessons) → запас комфортный, **сейчас - корректно**. Латентная хрупкость при разрастании ранних блоков — опционально поднять лимит чтения - для `/queue` или искать ключ потоково. Не блокирует. -- [ ] `build_test_command` добавляет флаг `-q`, отсутствующий в литеральной команде ADR (`python -m - pytest `). Безвредно и согласовано с прежним промптом tester (`pytest tests/ -q`); фиксирую - лишь как расхождение текст↔код. +- [ ] `_http_get` читает первые 8192 байта тела; smoke ищет `serial_gate` в ответе `/queue`. **Лично + измерено:** `serial_gate` на смещении **1471 байт** при полном ответе ~3.6 КБ → запас огромный, + **сейчас корректно**. Латентная хрупкость лишь при экстремальном разрастании ранних блоков; можно + опционально поднять лимит чтения для `/queue` или искать ключ потоково. +- [ ] `build_test_command` добавляет `-q`, отсутствующий в литеральной команде ADR/CHANGELOG (`python + -m pytest `). Безвредно (exit-код, а не парс вывода, формирует вердикт; согласовано с прежним + промптом `pytest tests/ -q`); фиксирую лишь как расхождение текст↔код. +- [ ] Tracked-scratch `.task-dev.md` перезаписан с ORCH-115 на ORCH-116 (нормальная churn dev-раннера, + предсуществующий паттерн, не введён этим PR; вне осей ревью). ### Контекст (не finding) - В истории ветки присутствует `15-staging-log.md` со `staging_status: FAILED` (`exit_code: None` — staging-сюита **не исполнилась**, tool-error/инфра, бюджет инфра-ретраев исчерпан → fail-closed). - Это исход **deploy-staging** стадии (downstream от review), относится к staging-раннеру ORCH-115 и + Это исход стадии **deploy-staging** (downstream от review), относится к staging-раннеру ORCH-115 и является **инфра-сбоем, а не дефектом кода ORCH-116** — вне осей код-ревью. Поведение гейта корректно (fail-closed на исчерпании инфра-бюджета); правок в коде задачи не требует. Отмечено как контекст для последующих стадий. @@ -149,9 +165,9 @@ findings отсутствуют → `APPROVED`.** `docs/overview/{tech-pipeline,tech-agents,tech-quality-security}.md`, `.openclaw/agents/tester.md`, `CHANGELOG.md`, ADR-001 + сквозной adr-0049. Анти-дрейф-тесты документации (`test_llm_call_site_inventory.py`, `test_llm_determinization_docs.py`, `test_system_docs.py`) — -зелёные. Невыполненных требований к обновлению документации **нет**. +зелёные (лично прогнаны). Невыполненных требований к обновлению документации **нет**. ## Вердикт -Нет P0/P1 findings; критический инвариант NFR-1 соблюдён байт-в-байт (`stages.py`/`qg/checks.py` не -тронуты); документация = golden source обновлена синхронно с кодом; полный регресс зелёный лично -проверен (2137 passed). **`verdict: APPROVED`.** +Нет P0/P1/P2 findings; критический инвариант NFR-1 соблюдён байт-в-байт (`stages.py`/`qg/checks.py` +не тронуты — проверено лично); документация = golden source обновлена синхронно с кодом; полный +регресс зелёный лично проверен (2137 passed). **`verdict: APPROVED`.** From 4b14b010ded52f3f5287d59366405e0c1ce44f5e Mon Sep 17 00:00:00 2001 From: staging-runner Date: Tue, 16 Jun 2026 09:25:08 +0300 Subject: [PATCH 10/16] staging(ORCH-115): staging gate SUCCESS for ORCH-116 --- docs/work-items/ORCH-116/15-staging-log.md | 37 +++++++++++++++++++--- 1 file changed, 33 insertions(+), 4 deletions(-) diff --git a/docs/work-items/ORCH-116/15-staging-log.md b/docs/work-items/ORCH-116/15-staging-log.md index f6e1ee1..a8e1f27 100644 --- a/docs/work-items/ORCH-116/15-staging-log.md +++ b/docs/work-items/ORCH-116/15-staging-log.md @@ -1,17 +1,46 @@ --- -staging_status: FAILED +staging_status: SUCCESS work_item: ORCH-116 stage: deploy-staging author_agent: staging-runner -status: failed +status: success created_at: 2026-06-16 model_used: n/a -exit_code: None +exit_code: 0 base_url: http://localhost:8501 --- # Staging Gate Log (deterministic runner, ORCH-115) -Staging suite did NOT execute (tool-error) and the infra-retry budget was exhausted -> fail-closed FAILED. +Staging suite exit-code `0` -> `staging_status: SUCCESS`. Вердикт зафиксирован детерминированным staging-раннером (ORCH-115), не LLM. infra-tolerance (ORCH-061) уже учтена внутри `staging_check.py` — раннер её не пересуживает. + +INFRA-WAIVED lines (ORCH-061, copied for observability): +- INFRA-WAIVED: C9a Branch appears in orchestrator-sandbox, C9b Analyst job enqueued in staging queue (known sandbox-infra; real checks green) + +Staging suite stdout (tail): +``` + (waiting for analyst job in queue) + · waiting... (waiting for analyst job in queue) + · waiting... (waiting for analyst job in queue) + · waiting... (waiting for analyst job in queue) + · waiting... (waiting for analyst job in queue) + · waiting... (waiting for analyst job in queue) + ✗ FAIL C9b Analyst job enqueued in staging queue + +[CLEANUP] + · CLEANUP: no branch to delete + ✓ PASS CLEANUP: deleted Plane issue 90c81fdc-d61f-47f3-8e2e-1fec3860513d (HTTP 204) + · CLEANUP DB: no task row found for plane_id=90c81fdc-d61f-47f3-8e2e-1fec3860513d + · CLEANUP DB dedup: no such table: events_dedup + +============================================================ + RESULT: 8/10 checks PASS + REAL failed : none + SANDBOX_INFRA failed: ['C9a Branch appears in orchestrator-sandbox', 'C9b Analyst job enqueued in staging queue'] +============================================================ + · tolerance: staging_infra_tolerance_enabled=True +INFRA-WAIVED: C9a Branch appears in orchestrator-sandbox, C9b Analyst job enqueued in staging queue (known sandbox-infra; real checks green) +VERDICT: SUCCESS (exit 0) — SUCCESS (infra-waived): ['C9a Branch appears in orchestrator-sandbox', 'C9b Analyst job enqueued in staging queue'] are known sandbox-infra checks; all real checks green +``` From 74fccf3a0957ce99adc4d713ba8610ebdb9621ec Mon Sep 17 00:00:00 2001 From: claude-bot Date: Tue, 16 Jun 2026 09:56:47 +0300 Subject: [PATCH 11/16] fix(testing): reconcile ORCH-116 with merged ORCH-123 (ADR renumber, CHANGELOG, env parity) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Recovery from the merge-gate rebase-conflict bounce. The feature branch was rebased onto origin/main (which had merged ORCH-123). The single conflicting hunk — docs/architecture/README.md — was resolved during the rebase: kept ORCH-123's host-side staging-runner line AND the ORCH-116 test-runner bullet. This follow-up commit reconciles the remainder: - Renumber the global sweeping ADR adr-0049 -> adr-0050. ORCH-123 took adr-0049 (adr-0049-host-side-docker-execution-boundary.md) on main while ORCH-116 was in flight, so ORCH-116 yields to the merged task and moves to the next free number. Mechanical cross-reference reconciliation only (git mv + title + every test-runner reference across README/internals/CLAUDE/CHANGELOG/config.py + 06-adr/ADR-001 + 12-review). Main's adr-0049 host-side references are left byte-for-byte untouched. No design/verdict content was altered. - Restore the ORCH-116 CHANGELOG entry that the CHANGELOG auto-merge silently dropped (both ORCH-123 and ORCH-116 inserted at the same [Unreleased] anchor; git kept only ORCH-123). - Add the missing ORCH_TEST_RUNNER_* keys to .env.example (parity with the ORCH_STAGING_RUNNER_* block; ORCH-101 canon of start keys). Refs: ORCH-116 Co-Authored-By: Claude Opus 4.8 --- .env.example | 28 +++++++++++++++++++ CHANGELOG.md | 7 +++++ CLAUDE.md | 2 +- docs/architecture/README.md | 4 +-- ... => adr-0050-deterministic-test-runner.md} | 2 +- docs/architecture/internals.md | 2 +- .../ADR-001-deterministic-test-runner.md | 4 +-- docs/work-items/ORCH-116/12-review.md | 8 +++--- src/config.py | 2 +- 9 files changed, 47 insertions(+), 12 deletions(-) rename docs/architecture/adr/{adr-0049-deterministic-test-runner.md => adr-0050-deterministic-test-runner.md} (99%) diff --git a/.env.example b/.env.example index a4d4bb1..ebe44ca 100644 --- a/.env.example +++ b/.env.example @@ -585,6 +585,34 @@ ORCH_STAGING_RUNNER_INFRA_MAX_RETRIES=2 ORCH_STAGING_RUNNER_INFRA_RETRY_DELAY_S=30 ORCH_STAGING_RUNNER_EXEC_HOST_SIDE=true +# ORCH-116: deterministic test-runner replacing the LLM `tester` agent on the +# `testing` stage for the self-hosting orchestrator (2nd determinization slice, +# mirror of the ORCH-115 staging-runner). A leaf src/test_runner.py is intercepted +# in launch_job BEFORE _spawn: it runs the SAME regression `python -m pytest ` +# in the task worktree (+ optional read-only smoke), maps the exit-code -> result: +# PASS|FAIL, writes 13-test-report.md and initiates the UNCHANGED check_tests_passed +# gate. Replaces only the producer of the artifact; the gate / STAGE_TRANSITIONS / DB +# schema are byte-for-byte unchanged. See ADR-001-deterministic-test-runner.md / adr-0050. +# TEST_RUNNER_ENABLED -> kill-switch; false -> the prior LLM tester runs on +# testing via _spawn 1:1. +# TEST_RUNNER_REPOS -> CSV scope; empty -> self-hosting only. A repo with +# no resolvable test-contract is never intercepted (BR-9). +# TEST_RUNNER_TARGET -> pytest target of the test-contract (default tests/). +# TEST_RUNNER_TIMEOUT_S -> wall-clock budget for the pytest regression +# (malformed/non-positive -> default 900 + WARNING). +# TEST_RUNNER_SMOKE_ENABLED -> optional read-only smoke (/health,/status,/queue + +# serial_gate block); false -> pytest exit-code is the sole signal. +# TEST_RUNNER_INFRA_MAX_RETRIES -> tool-error (suite did NOT execute) bounded DEFER +# budget before a fail-closed FAIL (anti ORCH-110). +# TEST_RUNNER_INFRA_RETRY_DELAY_S-> delay before the re-queued tester job. +ORCH_TEST_RUNNER_ENABLED=true +ORCH_TEST_RUNNER_REPOS= +ORCH_TEST_RUNNER_TARGET=tests/ +ORCH_TEST_RUNNER_TIMEOUT_S=900 +ORCH_TEST_RUNNER_SMOKE_ENABLED=true +ORCH_TEST_RUNNER_INFRA_MAX_RETRIES=2 +ORCH_TEST_RUNNER_INFRA_RETRY_DELAY_S=30 + # ORCH-057 (follow-up ORCH-040): legacy root-owned ownership detect + actionable # worktree error. After the uid migration (user: "1000:1000") legacy root:root files # in /repos broke worktree creation under uid 1000 with a raw "Permission denied". diff --git a/CHANGELOG.md b/CHANGELOG.md index b64b721..6c74080 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,13 @@ Формат: [Keep a Changelog](https://keepachangelog.com/). Записи — на смысловой PR/задачу. ## [Unreleased] +- **Детерминированный test-раннер вместо LLM-тестера на `testing`** (ORCH-116, `feat`): второй реализованный срез determinization-roadmap (ORCH-118 A5, `needs-hybrid-fallback`) — на стадии `testing` для self-hosting `orchestrator` **LLM-агент `tester` заменён детерминированным кодом** (`src/test_runner.py`). PASS/FAIL-ядро агента было деривируемым (регресс `pytest` + read-only smoke → `result:`); каждый прогон жёг токены/время opus-агента (~60–150k / 5–20 мин) и встраивал недетерминизм LLM в точку ветвления `testing → deploy-staging` / `testing → development`. **Инвариант (NFR-1):** это замена *продюсера* артефакта, **не** гейта — контракт `13-test-report.md`, гейт `check_tests_passed`/`_parse_tests_verdict`, `STAGE_TRANSITIONS`, machine-verdict `result:` (+ legacy `verdict:`/`status:`), схема БД — **байт-в-байт не тронуты**. Аддитивно, под kill-switch, never-raise, fail-closed, скоуп self-hosting, гибрид (LLM строго off-control-path). Эталон — `src/staging_runner.py` (ORCH-115). ADR: `docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md`, сквозной `docs/architecture/adr/adr-0050-deterministic-test-runner.md`. + - **Перехват в `launch_job` до `_spawn` (D1):** `if job.agent=="tester" and test_runner.should_intercept(job)` → `_run_test_runner_job` (зеркало `_run_staging_runner_job`, прецедент `deploy-finalizer`/`post-deploy-monitor`/`staging-runner` `launcher.py:397/402/405`): синхронно ведёт `jobs`-строку через `mark_job`, возвращает `None` (нет `agent_runs`, нет токенов). Дискриминатор — роль `tester` **И** стадия задачи `testing` (defense-in-depth: `tester` — единственный агент входа в `testing`, коллизии стадий нет, в отличие от общей роли `deployer`) **И** `applies(repo)`; `should_intercept` never-raise → `False` → штатный `_spawn` (fail-safe к LLM-пути). + - **Leaf `src/test_runner.py` (новый, чистый never-raise):** по образцу `staging_runner`/`self_deploy`/`proc_group` (на импорте только `config`/`proc_group`; `db`/`git_worktree`/`self_deploy`/`qg.checks`/`stage_engine`/`notifications` — лениво). `applies(repo)` = kill-switch `test_runner_enabled` + скоуп `test_runner_repos` (пусто → self-hosting only) **И** резолв тест-контракта `_has_test_contract` (BR-9: репо без контракта → `False` → LLM-tester — enduro-trails 1:1 как до ORCH-116, даже если руками добавлен в CSV). Исполняет регресс `python -m pytest ` **в worktree ветки** (`git_worktree.get_worktree_path`, анти checkout-гонка ORCH-112) через `proc_group.run_in_process_group` (tree-kill, таймаут `test_runner_timeout_s=900`, малформ/непозитив → дефолт + WARNING) + опц. **read-only smoke** (`/health`/`/status`/`/queue` + блок `serial_gate`, stdlib `urllib`; транзиентная недостижимость — ограниченный ретрай, не-200/нет блока — немедленный FAIL; `test_runner_smoke_enabled`). Маппит exit-код **единым** контрактом `self_deploy.map_exit_code_to_status` в токенах `result:` (`0→PASS`/иначе/None→`FAIL`, fail-closed; smoke-провал AND-ится в `FAIL`); пишет `13-test-report.md` (тот же machine-key `result:` UPPERCASE + 52c-схема, `author_agent: test-runner`/`model_used: n/a`) + best-effort push в **фичеветку**; вызывает **существующий** `advance_stage(current_stage="testing", finished_agent="tester")` — без новых рёбер/исходов (transition-lease ORCH-114 берётся внутри `advance_stage` — граница O1). + - **Анти-коллизия 52c-`status:` ↔ парсер (D6.1, специфично для tester):** `_parse_tests_verdict` читает вердикт из **трёх** равноранговых полей (`verdict:`/`status:`/`result:`) с negative-token-priority. 52c-обязательное `status:` поэтому читается тем же парсером → раннер **ВСЕГДА выравнивает** `status:` по вердикту (`PASS → status: success`, `FAIL → status: failed`) — иначе негативный токен в `status:` при `result: PASS` дал бы ложный FAIL здорового прогона. Прибито unit-тестом через **неизменённый** парсер. + - **Двухуровневый исход (D5, анти-ORCH-110):** сюита **исполнилась** (реальный exit-код) → verdict→advance (FAIL → тот же откат `testing → development` + developer-retry, что у FAIL-вердикта LLM, `stage_engine.py:849`); сюита **не исполнилась** (tool-error: spawn-error/таймаут/`returncode None`) → инфра-сбой ≠ код-фейл → bounded **DEFER** (re-queue **`tester`**-джоба с задержкой + restart-safe маркер `test-runner infra-retry` в `task_content`, счётчик подсчётом маркера — без правки схемы БД), на исчерпании `test_runner_infra_max_retries=2` → fail-closed `FAIL` + advance + INFRA-alert. Раннер **никогда** не делает тихий advance/ложный green, **никогда** не клинит очередь, **не** жжёт developer-retry на транзиентной инфре. + - **Гибрид (D11/BR-8/NFR-7):** в Phase 1 на `testing` (in-scope) вердикт `result:` производит **только** детерминированный раннер; LLM **не** вызывается в потоке управления вердикта. Архитектура не запрещает будущий **off-control-path** LLM-триаж падений / маппинг TC↔критерии после детерминированного FAIL (отдельная роль/джоб, **не** выносит и **не** переопределяет `result:`, **не** добавляет ребро в `STAGE_TRANSITIONS`) — в этом срезе не реализуется. Self-hosting safety: в командах раннера нет рестарта 8500 / `docker compose up orchestrator` / `--build` / force-push / правок `.env`; smoke строго read-only. Наблюдаемость — in-process счётчики (`runs`/`pass`/`fail`/`tool_error`/`deferred`) + read-only блок `test_runner` в `GET /queue` + один структурный лог-вердикт на прогон (различает код-фейл и tool-error). Флаги (`config.py`, дефолт = боевое): `test_runner_enabled`/`test_runner_repos`/`test_runner_target`/`test_runner_timeout_s`/`test_runner_smoke_enabled`/`test_runner_infra_max_retries`/`test_runner_infra_retry_delay_s` (env `ORCH_TEST_RUNNER_*`). Откат = `ORCH_TEST_RUNNER_ENABLED=false` → на `testing` снова LLM-`tester` через `_spawn` **байт-в-байт**. + - **Норматив сопровождения ORCH-118 (NFR-6):** обновлены `docs/architecture/llm-call-sites.md` (A5 — реализован; машинный `ORCH-118-INVENTORY-BLOCK` сохраняет tester как `avoidable=yes`/`axis=C`/`needs-hybrid-fallback`), `llm-determinization-roadmap.md` (rank 2 tester — ✅ реализован; инвариант «ровно один `first_slice = yes`» у rank 1 deployer цел), `llm-usage-policy.md` (§5 — единственный транспорт S0 не нарушен, раннер LLM не зовёт), `.openclaw/agents/tester.md` (LLM-ветвь `testing` — fallback), `docs/architecture/README.md`/`internals.md`, витрина `docs/overview/tech-pipeline.md`/`tech-agents.md`/`tech-quality-security.md`. Покрытие — `tests/test_orch116_test_runner.py` (TC-01…TC-14) + зелёные `tests/test_llm_call_site_inventory.py`/`test_llm_determinization_docs.py` (TC-15). - **Host-side исполнение staging-раннера + классификация environment-дефекта** (ORCH-123, `fix`, bug→escalate full-cycle): устранён инцидент **ORCH-116** — детерминированный staging-раннер (ORCH-115) вызывал `docker exec` **изнутри** прод-контейнера `orchestrator`, где **нет бинаря `docker`** (образ несёт только `openssh-client git curl`, `Dockerfile:11`; `/var/run/docker.sock` смонтирован, но клиента нет) → `Popen(["docker", …])` падал `FileNotFoundError` → ветка tool-error → инфра-DEFER×2 → fail-closed `FAILED` → **ложный** откат `deploy-staging → development` (как код-фейл, с расходом developer-retry). Так до фикса **любая** self-hosting задача, дойдя до `deploy-staging`, была обречена на ложный откат. Аддитивно, под флагами, never-raise, скоуп self-hosting; `STAGE_TRANSITIONS` / реестр `QG_CHECKS` / семантика и имена `check_staging_status`/`_parse_staging_status` / machine-verdict-ключи (`staging_status:`/`deploy_status:`) / схема БД — **байт-в-байт не тронуты** (замена *стратегии исполнения продюсера* `15-staging-log.md`, **не** гейта/стадии; зеркало инварианта ORCH-115 NFR-1). ADR: `docs/work-items/ORCH-123/06-adr/ADR-001-host-side-staging-execution-and-env-classification.md`, сквозной `docs/architecture/adr/adr-0049-host-side-docker-execution-boundary.md`. - **Host-side ssh-стратегия (D1):** `staging_runner.build_staging_command()` теперь обёртывает ту же `docker exec orchestrator-staging python3 … staging_check.py … --mode stub` в `ssh -o StrictHostKeyChecking=no @ ''` (зеркало `self_deploy.build_deploy_command` / `image_freshness.image_revision(ssh_target=…)`); канал — существующий доверенный (`ORCH_DEPLOY_SSH_HOST=127.0.0.1`, ssh-ключ смонтирован `:ro`, `openssh-client` в образе) → **новых секретов/привилегий не вводится** (NFR-3). Меняется **инициатор/канал** запуска, **не** сама сюита (она по-прежнему бежит **внутри** `orchestrator-staging` 8501). **Security (D2):** docker CLI/SDK в контейнер **не добавляется**, `docker.sock` **не используется изнутри** — это было бы root-эквивалентным расширением поверхности атаки (доступным и LLM-агентам); host-side ssh достигает цели без расширения привилегий. - **Трёхсторонняя классификация исхода (D3, чистая `classify_staging_outcome`, зеркало `merge_gate.classify_retest_failure`):** `suite-ran` (распознанный exit-код, кроме 255, **без** env-маркера в stderr → доверяем коду: `0→SUCCESS`/`≠0→FAILED`; анти-over-tolerance BR-3 — реальный фейл сюиты **никогда** не реклассифицируется в инфру), `permanent-env` (spawn-error `rc=None` без таймаута / нет ssh-target / `rc∈{126,127}` / env-маркер `No such container`/`Cannot connect to the Docker daemon`/`command not found` → ретрай бессмыслен), `transient-infra` (timeout / ssh transport `rc=255` / неизвестный сигнал → ретрай осмыслен). Дизамбигуация коллизии `exit=1` (`docker exec` «No such container»=1 vs суита fail=1) — **скан stderr на env-маркеры**, не голый exit-код; fail-safe при неоднозначности → `transient-infra` (DEFER), никогда тихий `suite-ran`. diff --git a/CLAUDE.md b/CLAUDE.md index da41afd..0b6809b 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -548,7 +548,7 @@ Plane, **не** Quality Gate и **не** стадия). целы) + `tester.md` (LLM-ветвь — fallback). Покрытие — `tests/test_orch116_test_runner.py` (TC-01…TC-14) + зелёные LLM-анти-дрейф тесты (TC-15). Детали — `docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md`, сквозной - `docs/architecture/adr/adr-0049-deterministic-test-runner.md`. + `docs/architecture/adr/adr-0050-deterministic-test-runner.md`. ## Машинный журнал уроков (ORCH-098) Шаг 1 («Фундамент», F2) эпика саморазвития: формализует свободнотекстовые «уроки» из `memory/` в diff --git a/docs/architecture/README.md b/docs/architecture/README.md index 171e987..4f41179 100644 --- a/docs/architecture/README.md +++ b/docs/architecture/README.md @@ -11,7 +11,7 @@ - **Quality Gates** (`src/qg/checks.py`) — проверки выхода со стадии, реестр `QG_CHECKS`. - **Agent Launcher** (`src/agents/launcher.py`) — запуск Claude CLI агентов в изолированном git worktree, мониторинг, auto-advance. Модель/эффорт каждого агента резолвятся из config (`resolve_agent_model`/`resolve_agent_effort`, ORCH-41), а не из frontmatter промпта. **ORCH-74:** имя модели валидируется форматом `^claude-…$` (`is_valid_model`) перед `--model`; невалидное → лог + откат на следующий уровень/CLI-дефолт (never-break, как `VALID_EFFORTS` для эффорта). Тот же предикат гардит inline-чтение `--fallback-model`. **ORCH-109 ([adr-0040](adr/adr-0040-agent-timeout-budgets-and-launch-model-stamp.md)):** (1) резолвенная **модель стампится в `agent_runs.model` в момент launch** (`_spawn`, объединённый `UPDATE … SET model=?, effort=?` рядом со стампом эффорта ORCH-087; пустой резолв → `NULL`; never-raise) → модель видна не-`null` при любом исходе прогона, включая timeout-kill (`exit_code=-9`), и in-flight в `GET /metrics`/`GET /queue` (`get_running_agents` уже отдаёт `model`); постфактум `record_usage` (`model=COALESCE(?, model)`) остаётся **обогащением**, не единственным источником истины. (2) **Per-role wall-clock бюджеты** через выделенные ключи `agent_timeout_developer_s=3600`/`agent_timeout_reviewer_s=3000` (лестница `_resolve_timeout`: `agent_timeout_overrides_json` → выделенный ключ роли → `agent_timeout_seconds=1800`; прочие роли — байт-в-байт; малформный/вне-диапазонный конфиг → дефолт + WARNING). Инвариант reaper ORCH-065 сохранён синхронным поднятием `reaper_max_running_s` 3600→**5400** (`5400 > max(timeout)3600 + grace20`). FR-5 анти-salvage — структурно: продвижение гейтится `if exit_code==0`, timeout-kill → `_finalize_job` (retry/fail), не advance. `STAGE_TRANSITIONS`/`QG_CHECKS`/схема БД не тронуты. - **Staging-runner** (`src/staging_runner.py`, ORCH-115 — [adr-0048](adr/adr-0048-deterministic-staging-runner.md)) — чистый **never-raise** leaf (паттерн `self_deploy`/`proc_group`/`staging_verdict`), заменяющий **LLM-агента `deployer` на стадии `deploy-staging`** детерминированным кодом (первый реализованный срез determinization-roadmap, A6/`replace-deterministic-now`). Перехват в `launch_job` **до `_spawn`** (рядом с D1/D2 `deploy-finalizer`/`post-deploy-monitor`): дискриминатор — **стадия задачи** `deploy-staging` **И** `applies(repo)` (kill-switch `staging_runner_enabled` + скоуп `staging_runner_repos`, пусто → self-hosting only), `should_intercept` never-raise → `False` → штатный `_spawn` (fail-safe к LLM). Раннер (зеркало `run_deploy_finalizer`) исполняет ту же staging-сюиту (`docker exec orchestrator-staging … staging_check.py`) через `proc_group` (tree-kill, таймаут `staging_runner_timeout_s=600`), маппит exit-код единым контрактом `self_deploy.map_exit_code_to_status` (`0→SUCCESS`/иначе→`FAILED`; ORCH-061 infra-tolerance остаётся внутри `staging_check.py`), пишет `15-staging-log.md` (тот же machine-key `staging_status:`, `author_agent: staging-runner`/`model_used: n/a`) + best-effort push в фичеветку, и вызывает **существующий** `advance_stage(current_stage="deploy-staging", finished_agent="deployer")` — без новых рёбер/исходов; transition-lease ORCH-114 берётся внутри `advance_stage` (раннер не трогает). **Двухуровневый исход (анти-ORCH-110):** сюита исполнилась → verdict→advance (FAILED → тот же откат `deploy-staging → development` + developer-retry, что у LLM); tool-error/таймаут → bounded defer (`staging_runner_infra_max_retries`) → fail-closed `FAILED` + alert на исчерпании (инфра ≠ код-фейл, никогда тихий advance/ложный green). `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_staging_status`/`_parse_staging_status`/machine-verdict/схема БД — **байт-в-байт не тронуты** (замена *продюсера*, не гейта). Наблюдаемость — in-process счётчики + блок `staging_runner` в `GET /queue`. Откат — `ORCH_STAGING_RUNNER_ENABLED=false` (прежний LLM-deployer-путь байт-в-байт). Детали — `docs/work-items/ORCH-115/06-adr/ADR-001-deterministic-staging-runner.md`. **ORCH-123 (фикс стратегии исполнения — [adr-0049](adr/adr-0049-host-side-docker-execution-boundary.md)):** раннер ORCH-115 вызывал `docker exec` **изнутри** прод-контейнера, где **нет docker CLI** (образ несёт только `openssh-client git curl`, `Dockerfile:11`) → `FileNotFoundError` → постоянный environment-дефект ложно откатывался как код-фейл `deploy-staging → development` (инцидент ORCH-116). Фикс: `build_staging_command` теперь исполняет ту же `docker exec … staging_check.py … --mode stub` **host-side** через доверенный ssh-канал `ssh ''` (зеркало `self_deploy`/`image_freshness`, флаг `ORCH_STAGING_RUNNER_EXEC_HOST_SIDE=true`, дефолт; меняется **инициатор/канал**, не сама сюита — она по-прежнему бежит внутри `orchestrator-staging` 8501). Двухуровневый исход ORCH-115 заменён **трёхсторонней классификацией** (`classify_staging_outcome`): `suite-ran` (распознанный exit-код без env-маркера в stderr → доверяем коду: `0→SUCCESS`/`≠0→FAILED`+прежний откат, анти-over-tolerance), `permanent-env` (spawn-error/нет ssh-target/126-127/env-маркер `No such container`/`Cannot connect to the Docker daemon` → **немедленный infra-HOLD**: без отката, без developer-retry, DEFER пропускается), `transient-infra` (timeout/ssh 255 → bounded DEFER, на исчерпании → infra-HOLD, **не** прежний fail-closed FAILED+откат). Корневой инвариант: «сюита **не** исполнилась» (environment ИЛИ инфра) **никогда** не оканчивается код-фейл-откатом — закрывает RCA-класс ORCH-110 на staging-ребре. Plus prod-like preflight host-side канала в `main.lifespan` (best-effort, never-blocks). `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_staging_status`/machine-verdict/схема БД — байт-в-байт не тронуты. Детали — `docs/work-items/ORCH-123/06-adr/ADR-001-host-side-staging-execution-and-env-classification.md`. -- **Test-runner** (`src/test_runner.py`, ORCH-116 — [adr-0049](adr/adr-0049-deterministic-test-runner.md)) — чистый **never-raise** leaf (зеркало `staging_runner`), заменяющий **LLM-агента `tester` на стадии `testing`** детерминированным кодом (**второй** реализованный срез determinization-roadmap, A5/`needs-hybrid-fallback`). Перехват в `launch_job` **до `_spawn`** (рядом с D1/D2/ORCH-115): дискриминатор — роль `tester` **И** стадия задачи `testing` (defense-in-depth: `tester` — единственный агент входа в `testing`) **И** `applies(repo)` (kill-switch `test_runner_enabled` + скоуп `test_runner_repos`, пусто → self-hosting only, **И** резолв тест-контракта `_has_test_contract` — репо без контракта → LLM-tester, BR-9). `should_intercept` never-raise → `False` → штатный `_spawn` (fail-safe к LLM). Раннер (зеркало `run_staging_gate`) исполняет регресс `python -m pytest ` **в worktree ветки** (анти checkout-гонка) через `proc_group` (tree-kill, таймаут `test_runner_timeout_s=900`) + опц. **read-only smoke** (`/health`/`/status`/`/queue` + блок `serial_gate`, `test_runner_smoke_enabled`; транзиентная недостижимость — ограниченный ретрай, не-200/нет блока — немедленный FAIL), маппит exit-код единым контрактом `self_deploy.map_exit_code_to_status` в токенах `result:` (`0→PASS`/иначе→`FAIL`; smoke-провал AND-ится в `FAIL`), пишет `13-test-report.md` (тот же machine-key `result:`, `author_agent: test-runner`/`model_used: n/a`; **52c-`status:` ВСЕГДА выровнен по вердикту** `success`/`failed` — иначе негативный токен в `status:` при `result: PASS` дал бы ложный FAIL через `_parse_tests_verdict`, D6.1) + best-effort push в фичеветку, и вызывает **существующий** `advance_stage(current_stage="testing", finished_agent="tester")` — без новых рёбер/исходов; transition-lease ORCH-114 берётся внутри `advance_stage` (раннер не трогает). **Двухуровневый исход (анти-ORCH-110):** сюита исполнилась → verdict→advance (FAIL → тот же откат `testing → development` + developer-retry, что у LLM); tool-error/таймаут (сюита НЕ исполнилась) → bounded defer (re-queue **`tester`**-джоба, `test_runner_infra_max_retries`) → fail-closed `FAIL` + INFRA-alert на исчерпании (инфра ≠ код-фейл, никогда тихий advance/ложный green, не жжёт developer-retry на транзиентной инфре). **Гибрид (BR-8/NFR-7):** LLM строго off-control-path — детерминированный раннер единственный продюсер `result:`; будущий off-control-path триаж падений не выносит/не переопределяет вердикт и не добавляет ребро в `STAGE_TRANSITIONS` (в Phase 1 не реализован). `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_tests_passed`/`_parse_tests_verdict`/machine-verdict/схема БД — **байт-в-байт не тронуты** (замена *продюсера*, не гейта). Наблюдаемость — in-process счётчики + блок `test_runner` в `GET /queue`. Откат — `ORCH_TEST_RUNNER_ENABLED=false` (прежний LLM-tester-путь байт-в-байт). Детали — `docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md`. +- **Test-runner** (`src/test_runner.py`, ORCH-116 — [adr-0050](adr/adr-0050-deterministic-test-runner.md)) — чистый **never-raise** leaf (зеркало `staging_runner`), заменяющий **LLM-агента `tester` на стадии `testing`** детерминированным кодом (**второй** реализованный срез determinization-roadmap, A5/`needs-hybrid-fallback`). Перехват в `launch_job` **до `_spawn`** (рядом с D1/D2/ORCH-115): дискриминатор — роль `tester` **И** стадия задачи `testing` (defense-in-depth: `tester` — единственный агент входа в `testing`) **И** `applies(repo)` (kill-switch `test_runner_enabled` + скоуп `test_runner_repos`, пусто → self-hosting only, **И** резолв тест-контракта `_has_test_contract` — репо без контракта → LLM-tester, BR-9). `should_intercept` never-raise → `False` → штатный `_spawn` (fail-safe к LLM). Раннер (зеркало `run_staging_gate`) исполняет регресс `python -m pytest ` **в worktree ветки** (анти checkout-гонка) через `proc_group` (tree-kill, таймаут `test_runner_timeout_s=900`) + опц. **read-only smoke** (`/health`/`/status`/`/queue` + блок `serial_gate`, `test_runner_smoke_enabled`; транзиентная недостижимость — ограниченный ретрай, не-200/нет блока — немедленный FAIL), маппит exit-код единым контрактом `self_deploy.map_exit_code_to_status` в токенах `result:` (`0→PASS`/иначе→`FAIL`; smoke-провал AND-ится в `FAIL`), пишет `13-test-report.md` (тот же machine-key `result:`, `author_agent: test-runner`/`model_used: n/a`; **52c-`status:` ВСЕГДА выровнен по вердикту** `success`/`failed` — иначе негативный токен в `status:` при `result: PASS` дал бы ложный FAIL через `_parse_tests_verdict`, D6.1) + best-effort push в фичеветку, и вызывает **существующий** `advance_stage(current_stage="testing", finished_agent="tester")` — без новых рёбер/исходов; transition-lease ORCH-114 берётся внутри `advance_stage` (раннер не трогает). **Двухуровневый исход (анти-ORCH-110):** сюита исполнилась → verdict→advance (FAIL → тот же откат `testing → development` + developer-retry, что у LLM); tool-error/таймаут (сюита НЕ исполнилась) → bounded defer (re-queue **`tester`**-джоба, `test_runner_infra_max_retries`) → fail-closed `FAIL` + INFRA-alert на исчерпании (инфра ≠ код-фейл, никогда тихий advance/ложный green, не жжёт developer-retry на транзиентной инфре). **Гибрид (BR-8/NFR-7):** LLM строго off-control-path — детерминированный раннер единственный продюсер `result:`; будущий off-control-path триаж падений не выносит/не переопределяет вердикт и не добавляет ребро в `STAGE_TRANSITIONS` (в Phase 1 не реализован). `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_tests_passed`/`_parse_tests_verdict`/machine-verdict/схема БД — **байт-в-байт не тронуты** (замена *продюсера*, не гейта). Наблюдаемость — in-process счётчики + блок `test_runner` в `GET /queue`. Откат — `ORCH_TEST_RUNNER_ENABLED=false` (прежний LLM-tester-путь байт-в-байт). Детали — `docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md`. - **Queue** (`src/queue_worker.py`, ORCH-1) — персистентная очередь задач (SQLite `jobs`), atomic claim, max_concurrency, ретраи, restart-safe. **ORCH-026:** `claim_next_job` гейтит задачи с незавершёнными зависимостями (`job_deps`, `NOT EXISTS`) без занятия слота; декларации/циклы — leaf `src/task_deps.py`. - **Job-reaper** (`src/job_reaper.py`, ORCH-065 — [adr-0011](adr/adr-0011-job-reaper-lease-reclaim.md)) — фоновый daemon-поток (каркас `reconciler`), стартует/останавливается в `main.lifespan` (после `reconciler.start()` / перед `worker.stop()`). Детектирует «мёртвый» `running`-job **без рестарта** процесса (Tier-1 мёртвый `jobs.pid` после `reaper_dead_ticks` тиков; Tier-2 `agent_runs.exit_code` записан, а job ещё `running`; Tier-3 backstop `reaper_max_running_s`) и приводит строку к корректному статусу через те же контракты (`_try_advance_stage`/`_finalize_job`, gate-driven; exit≠0/неизвестно → `attempts`. `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_*`/machine-verdict/схемы существующих таблиц — байт-в-байт. Подробнее ниже (§ «Единое владение side-effectful переходами»). Детали — `docs/work-items/ORCH-114/06-adr/ADR-001-transition-ownership-lease-and-stage-cas.md`. @@ -449,7 +449,7 @@ ORCH-079 синхронизирует витрину с кодом и закры `llm-call-sites.md` (A6), `llm-determinization-roadmap.md` (rank 1, инвариант «ровно один `first_slice`») и анти-дрейф-тесты обновляются **атомарно с кодом** в development (норматив сопровождения NFR-6). -- **Второй срез реализован (ORCH-116 — [adr-0049](adr/adr-0049-deterministic-test-runner.md)):** +- **Второй срез реализован (ORCH-116 — [adr-0050](adr/adr-0050-deterministic-test-runner.md)):** rank-2 кандидат **tester (`result:`)** заменён детерминированным `src/test_runner.py` (тем же перехватом до `_spawn`) — A5 переходит из «план» в «реализовано». `needs-hybrid-fallback`-природа сохранена: детерминированное ядро (exit-код `pytest` + smoke) вынесено в раннер, LLM-ветвь жива как diff --git a/docs/architecture/adr/adr-0049-deterministic-test-runner.md b/docs/architecture/adr/adr-0050-deterministic-test-runner.md similarity index 99% rename from docs/architecture/adr/adr-0049-deterministic-test-runner.md rename to docs/architecture/adr/adr-0050-deterministic-test-runner.md index c1c878a..5f20742 100644 --- a/docs/architecture/adr/adr-0049-deterministic-test-runner.md +++ b/docs/architecture/adr/adr-0050-deterministic-test-runner.md @@ -7,7 +7,7 @@ created_at: 2026-06-16 model_used: claude-opus-4-8 --- -# adr-0049: Детерминированный test-раннер — второй реализованный срез determinization-roadmap (tester-гибрид) +# adr-0050: Детерминированный test-раннер — второй реализованный срез determinization-roadmap (tester-гибрид) > **Сквозной (cross-cutting) ADR.** Агрегирует решение ORCH-116, влияющее на **весь** > оркестратор: вводит новый компонент-leaf `src/test_runner.py`, снимает вторую avoidable diff --git a/docs/architecture/internals.md b/docs/architecture/internals.md index 43f905b..0328e77 100644 --- a/docs/architecture/internals.md +++ b/docs/architecture/internals.md @@ -109,7 +109,7 @@ LLM). Leaf `src/staging_runner.py` (зеркало `run_deploy_finalizer`) ис `self_deploy.map_exit_code_to_status`, пишет `15-staging-log.md` (тот же machine-key `staging_status:`) и вызывает существующий `advance_stage(finished_agent="deployer")` (см. §5). Так LLM-агент `deployer` на `deploy-staging` исчезает из happy-path; `STAGE_TRANSITIONS`/`QG_CHECKS`/схема БД не тронуты. -**ORCH-116 ([adr-0049](adr/adr-0049-deterministic-test-runner.md)):** тем же паттерном (рядом с +**ORCH-116 ([adr-0050](adr/adr-0050-deterministic-test-runner.md)):** тем же паттерном (рядом с ORCH-115) перехватывается джоб `tester` на стадии `testing` для in-scope репо с тест-контрактом (дискриминатор — роль `tester` **И** `tasks.stage == "testing"` **И** `test_runner.applies(repo)` под kill-switch `test_runner_enabled`, скоуп `test_runner_repos`, резолв `_has_test_contract`; пусто → diff --git a/docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md b/docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md index 2f682fd..9702a92 100644 --- a/docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md +++ b/docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md @@ -13,7 +13,7 @@ Work Item: **ORCH-116** — заменить LLM-агента `tester` на ст (self-hosting `orchestrator`) детерминированным test-раннером (второй срез determinization-roadmap, **rank 2 / tester-гибрид**). Стадия: **architecture** -Сквозная регистрация: **`docs/architecture/adr/adr-0049-deterministic-test-runner.md`** +Сквозная регистрация: **`docs/architecture/adr/adr-0050-deterministic-test-runner.md`** (решение кросс-каттинговое — вводит новый компонент-leaf `src/test_runner.py` и реализует второй срез determinization-roadmap; влияет на карту LLM-консультаций всего оркестратора). @@ -459,7 +459,7 @@ LLM-консультации; политика соблюдена. - Тест-план: `docs/work-items/ORCH-116/04-test-plan.yaml` - Инфра: `docs/work-items/ORCH-116/07-infra-requirements.md`; Данные: `08-data-requirements.md`; Риски: `10-tech-risks.md` -- Сквозной ADR: `docs/architecture/adr/adr-0049-deterministic-test-runner.md` +- Сквозной ADR: `docs/architecture/adr/adr-0050-deterministic-test-runner.md` - Эталон реализации: `src/staging_runner.py` (ORCH-115), `docs/work-items/ORCH-115/06-adr/ADR-001-deterministic-staging-runner.md` - Сверено по коду: `src/agents/launcher.py:397/404/438`, `src/stages.py:17-18`, diff --git a/docs/work-items/ORCH-116/12-review.md b/docs/work-items/ORCH-116/12-review.md index edd1868..c9a8af1 100644 --- a/docs/work-items/ORCH-116/12-review.md +++ b/docs/work-items/ORCH-116/12-review.md @@ -23,7 +23,7 @@ leaf `src/test_runner.py`, перехватываемым в `launch_job` **до байт-в-байт: `src/stages.py`, `src/qg/checks.py`, `src/staging_runner.py`, `src/transition_lease.py`, `src/proc_group.py` — **не тронуты** (подтверждено `git diff --stat`); в `src/` изменены только `test_runner.py` (новый), `launcher.py`/`config.py`/`main.py` (аддитивно). Документация = golden -source обновлена в том же PR (8 doc-файлов + CHANGELOG + ADR-001/adr-0049). Полный регресс +source обновлена в том же PR (8 doc-файлов + CHANGELOG + ADR-001/adr-0050). Полный регресс **проверен лично**: `pytest tests/ -q` → **2137 passed**; ORCH-116 + LLM-анти-дрейф + system-docs → **74 passed**. **P0/P1/P2 findings отсутствуют → `APPROVED`.** @@ -68,7 +68,7 @@ source обновлена в том же PR (8 doc-файлов + CHANGELOG + AD ### 2. Соответствие ADR — PASS -Реализация дословно следует ADR-001 (D1–D12) и сквозному adr-0049. Сверено критическое: +Реализация дословно следует ADR-001 (D1–D12) и сквозному adr-0050. Сверено критическое: - **D6.1 (анти-коллизия 52c-`status:` ↔ `_parse_tests_verdict`)** — самая тонкая мина задачи. Сверено по **неизменённому** парсеру (`src/qg/checks.py:226-282`): он читает вердикт из ТРЁХ равноранговых полей `verdict:`/`status:`/`result:` c negative-token-priority. `build_test_report` @@ -124,7 +124,7 @@ source обновлена в том же PR (8 doc-файлов + CHANGELOG + AD fallback под выключенным флагом / для репо без контракта»; канон 52d (5 секций, ключ `result:`) цел. - **`CHANGELOG.md`** — развёрнутая запись `[Unreleased]`. - **ADR** заведён (`06-adr/ADR-001-deterministic-test-runner.md` + сквозной - `adr/adr-0049-deterministic-test-runner.md`). + `adr/adr-0050-deterministic-test-runner.md`). Обзорные доки / README «Известные ограничения» (ORCH-079): раннер — **новая способность**, не закрытие документированного ограничения → дополнительных правок README не требуется. @@ -163,7 +163,7 @@ source обновлена в том же PR (8 doc-файлов + CHANGELOG + AD Обновлена в полном объёме в том же PR (см. ось 4): `CLAUDE.md`, `docs/architecture/README.md`, `internals.md`, `llm-call-sites.md`, `llm-determinization-roadmap.md`, `llm-usage-policy.md`, `docs/overview/{tech-pipeline,tech-agents,tech-quality-security}.md`, `.openclaw/agents/tester.md`, -`CHANGELOG.md`, ADR-001 + сквозной adr-0049. Анти-дрейф-тесты документации +`CHANGELOG.md`, ADR-001 + сквозной adr-0050. Анти-дрейф-тесты документации (`test_llm_call_site_inventory.py`, `test_llm_determinization_docs.py`, `test_system_docs.py`) — зелёные (лично прогнаны). Невыполненных требований к обновлению документации **нет**. diff --git a/src/config.py b/src/config.py index b754f5b..d379ce1 100644 --- a/src/config.py +++ b/src/config.py @@ -489,7 +489,7 @@ class Settings(BaseSettings): # STAGE_TRANSITIONS and the DB schema are byte-for-byte UNCHANGED — this only # replaces the *producer* of the artifact. Pattern = staging_runner_* / coverage_gate_*. # See docs/work-items/ORCH-116/06-adr/ADR-001-deterministic-test-runner.md and - # docs/architecture/adr/adr-0049-deterministic-test-runner.md. + # docs/architecture/adr/adr-0050-deterministic-test-runner.md. # test_runner_enabled -> SINGLE kill-switch (env ORCH_TEST_RUNNER_ENABLED). # False -> the intercept never fires -> the prior # LLM tester runs on testing via _spawn byte-for-byte From c470576202fc3a238c6697210e0c8086383ec909 Mon Sep 17 00:00:00 2001 From: claude-bot Date: Tue, 16 Jun 2026 09:59:29 +0300 Subject: [PATCH 12/16] developer(ET): auto-commit from developer run_id=756 --- .../work-items/ORCH-116/17-security-report.md | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 docs/work-items/ORCH-116/17-security-report.md diff --git a/docs/work-items/ORCH-116/17-security-report.md b/docs/work-items/ORCH-116/17-security-report.md new file mode 100644 index 0000000..015f79c --- /dev/null +++ b/docs/work-items/ORCH-116/17-security-report.md @@ -0,0 +1,29 @@ +--- +security_status: PASS +secrets_found: 0 +deps_blocking: 0 +deps_warning: 8 +deps_audit_degraded: false +--- +# Security Report — ORCH-116 + +Детерминированный security-гейт (ORCH-022): secret-scanning (gitleaks, offline) + dependency audit (pip-audit). Машинный вердикт читается ТОЛЬКО из frontmatter выше. + +## Verdict +clean: 0 secrets, 0 blocking CVE(s) + +## Secrets +- None + +## Dependencies (blocking) +- None + +## Dependencies (warning) +- `pytest==8.3.3` — GHSA-6w46-j5rx-g56g severity=UNKNOWN fix=9.0.3 +- `starlette==0.38.6` — PYSEC-2026-161 severity=UNKNOWN fix=1.0.1 +- `starlette==0.38.6` — GHSA-f96h-pmfr-66vw severity=UNKNOWN fix=0.40.0 +- `starlette==0.38.6` — GHSA-2c2j-9gv5-cj73 severity=UNKNOWN fix=0.47.2 +- `starlette==0.38.6` — GHSA-wqp7-x3pw-xc5r severity=UNKNOWN fix=1.1.0 +- `starlette==0.38.6` — GHSA-x746-7m8f-x49c severity=UNKNOWN fix=1.1.0 +- `starlette==0.38.6` — GHSA-82w8-qh3p-5jfq severity=UNKNOWN fix=1.3.1 +- `starlette==0.38.6` — GHSA-jp82-jpqv-5vv3 severity=UNKNOWN fix=1.3.0 From e12b03b2358b6ed8be12c23a305b5035f343fe30 Mon Sep 17 00:00:00 2001 From: claude-bot Date: Tue, 16 Jun 2026 10:11:33 +0300 Subject: [PATCH 13/16] reviewer(ET): auto-commit from reviewer run_id=757 --- docs/work-items/ORCH-116/12-review.md | 236 +++++++++++--------------- 1 file changed, 101 insertions(+), 135 deletions(-) diff --git a/docs/work-items/ORCH-116/12-review.md b/docs/work-items/ORCH-116/12-review.md index c9a8af1..246f3a1 100644 --- a/docs/work-items/ORCH-116/12-review.md +++ b/docs/work-items/ORCH-116/12-review.md @@ -8,166 +8,132 @@ created_at: 2026-06-16 model_used: claude-opus-4-8 type: review work_item_id: ORCH-116 -version: 3 +version: 4 --- # Review ORCH-116 — детерминированный test-раннер вместо LLM-тестера +> Машинный вердикт читается ТОЛЬКО из `verdict:` во frontmatter. + ## Summary -PR заменяет LLM-агента `tester` на стадии `testing` (self-hosting `orchestrator`) детерминированным -leaf `src/test_runner.py`, перехватываемым в `launch_job` **до `_spawn`** — точное зеркало уже -работающего в проде ORCH-115/`staging_runner`. Ревью выполнено **независимо** по всем четырём осям -(ТЗ/AC · ADR · качество кода · документация) с личным прогоном тестов и сверкой сигнатур -зависимостей. Критический инвариант **NFR-1** («замена *продюсера* артефакта, не гейта») соблюдён -байт-в-байт: `src/stages.py`, `src/qg/checks.py`, `src/staging_runner.py`, `src/transition_lease.py`, -`src/proc_group.py` — **не тронуты** (подтверждено `git diff --stat`); в `src/` изменены только -`test_runner.py` (новый), `launcher.py`/`config.py`/`main.py` (аддитивно). Документация = golden -source обновлена в том же PR (8 doc-файлов + CHANGELOG + ADR-001/adr-0050). Полный регресс -**проверен лично**: `pytest tests/ -q` → **2137 passed**; ORCH-116 + LLM-анти-дрейф + system-docs → -**74 passed**. **P0/P1/P2 findings отсутствуют → `APPROVED`.** +Реализация **полностью соответствует ТЗ (02-trz.md), критериям приёмки (03-acceptance-criteria.md) +и ADR-001 / adr-0050**. ORCH-116 заменяет LLM-агента `tester` на стадии `testing` детерминированным +leaf `src/test_runner.py`, перехватываемым в `launch_job` до `_spawn` — точное зеркало эталона +`src/staging_runner.py` (ORCH-115). Критический инвариант NFR-1 соблюдён байт-в-байт: гейт +`check_tests_passed` / `_parse_tests_verdict`, `STAGE_TRANSITIONS`, `QG_CHECKS`, machine-key `result:` +и схема БД **не тронуты** (это замена *продюсера* артефакта, не гейта). Тонкая мина D6.1 (52c-`status:` +↔ парсер с negative-token-priority) обработана корректно и прибита тестом через неизменённый парсер. +Документация обновлена в полном объёме (CLAUDE.md / CHANGELOG / README / internals / витрина +`docs/overview/` / LLM-карта/roadmap/policy / tester.md / .env.example). Все 4 оси — зелёные. Findings +уровня P0/P1, относящихся к ORCH-116, нет. ## Оси проверки -### 1. Соответствие ТЗ / Acceptance Criteria — PASS +### 1. Соответствие ТЗ / AC — PASS +- **FR-1 / AC-1** перехват до `_spawn`: `launcher.launch_job` врезка `if job.get("agent")=="tester" + and test_runner.should_intercept(job): return self._run_test_runner_job(job)` рядом с + D1/D2/ORCH-115; `_run_test_runner_job` — зеркало `_run_staging_runner_job`, ведёт `jobs` через + `mark_job`, возвращает `None` (нет `agent_runs`). ✔ (TC-05). +- **FR-2/3 / AC-3/AC-11** pytest в worktree через `proc_group` (tree-kill, `_resolve_timeout` + fail-safe), маппинг `map_exit_code_to_result` поверх единого `self_deploy.map_exit_code_to_status` + (без второго маппинга). ✔ (TC-02, TC-12). +- **FR-4 / AC-2** `write_test_report` — `result:` UPPERCASE + 52c-схема, `author_agent: test-runner` / + `model_used: n/a`, push только в фичеветку (без merge в `main`). ✔ (TC-03, TC-04). +- **FR-5 / AC-4** `_advance` вызывает `advance_stage(current_stage="testing", finished_agent="tester")` + — FAIL-ветвь `stage_engine.py:849` матчит по `agent=="tester"`. ✔ (TC-07). +- **FR-6 / AC-5** two-level outcome: `suite_ran=(returncode is not None) and (not timed_out)`; + tool-error → bounded DEFER (re-queue именно **`tester`**-джоба + restart-safe маркер), на исчерпании + → fail-closed `FAIL` + advance + INFRA-alert. ✔ (TC-10). +- **FR-7 / AC-7/AC-8** `applies()` = kill-switch + скоуп + `_has_test_contract` (репо без контракта → + LLM-tester даже при ручном добавлении в CSV). ✔ (TC-01, TC-08). +- **FR-8 / AC-13** блок `test_runner` в `GET /queue` + счётчики + структурный лог, различающий + code-fail / tool-error. ✔ (TC-14). +- **FR-9 / AC-12** гибрид: LLM вне control-path вердикта. ✔. -Верифицировано по коду + тестам + личному прогону каждое AC: -- **AC-1** (перехват до `_spawn`) — `launcher.launch_job`: `if job.get("agent")=="tester":` → - `if test_runner.should_intercept(job): return self._run_test_runner_job(job)` вставлено **перед** - `return self._spawn(...)`; `_run_test_runner_job` ведёт `jobs` через `mark_job(done|failed)`, - возвращает `None` (нет `agent_runs`). TC-05 воспроизводит без живого CLI (`spawn.assert_not_called`). -- **AC-2** (контракт `13-test-report.md`) — `build_test_report` эмитит `result: PASS|FAIL` UPPERCASE - + полную 52c-схему; читается **неизменённым** `_parse_tests_verdict` (TC-04, лично подтверждено - прогоном через реальный парсер). -- **AC-3** (exit→verdict) — `map_exit_code_to_result` — тонкий транслятор над единым - `self_deploy.map_exit_code_to_status` (`0→PASS`, иначе/None/нечисло→`FAIL`, fail-closed); второй - маппинг не введён (TC-02 сверяет с базовым контрактом). -- **AC-4** (эквивалентность маршрутизации) — `_advance(current_stage="testing", - finished_agent="tester")`, без новых рёбер; PASS→advance, FAIL→существующий откат - `testing→development` (TC-07 параметризован [PASS/FAIL]). -- **AC-5** (two-level outcome, анти-ORCH-110) — `suite_ran = (returncode is not None) and (not - timed_out)`; tool-error → bounded DEFER re-queue **`tester`**-джоба (TC-10 проверяет `agent == - "tester"`), не код-фейл-откат, не жжёт developer-retry; исчерпание бюджета → fail-closed FAIL + - alert. -- **AC-6** (анти-дрейф) — `git diff` по `src/` затрагивает только - `launcher.py`/`config.py`/`main.py`/`test_runner.py`; `src/stages.py`, `src/qg/checks.py` - **байт-в-байт не тронуты** (проверено `git diff --stat` лично); новых таблиц нет (TC-09). -- **AC-7/AC-8** (kill-switch / backward-compat) — `applies()` гасит при `enabled=False`, скоупит CSV; - `_has_test_contract` → `False` для не-self репо даже при ручном добавлении в CSV (TC-01/TC-08). -- **AC-9** (never-raise) — все публичные функции в `try/except`; `run_test_gate` имеет внешний - guard; `_run_test_runner_job` дополнительно оборачивает (TC-11: воркер не падает / не клинит). -- **AC-10** (self-hosting safety) — `build_test_command` без литералов - рестарта/compose/build/force-push/`.env`; smoke строго read-only GET; лог пушится только в - фичеветку, никакой прямой работы с `main` (TC-13). -- **AC-11** (proc_group/worktree/timeout) — pytest в `get_worktree_path(repo, branch)` через - `run_in_process_group` (tree-kill), `_resolve_timeout` дефолтит на малформе + WARNING; без правки - `reaper_max_running_s` (TC-12). -- **AC-12/AC-13/AC-14/AC-15** — гибрид off-control-path, блок `test_runner` в `/queue`, обновление - LLM-карты/политики/roadmap/витрины, полный регресс — все зелёные (AC-15: 2137 passed, проверено - лично). - -### 2. Соответствие ADR — PASS - -Реализация дословно следует ADR-001 (D1–D12) и сквозному adr-0050. Сверено критическое: -- **D6.1 (анти-коллизия 52c-`status:` ↔ `_parse_tests_verdict`)** — самая тонкая мина задачи. - Сверено по **неизменённому** парсеру (`src/qg/checks.py:226-282`): он читает вердикт из ТРЁХ - равноранговых полей `verdict:`/`status:`/`result:` c negative-token-priority. `build_test_report` - жёстко выравнивает `sub_status = "success" if result=="PASS" else "failed"`: для PASS конкатенация - `"SUCCESS PASS"` не содержит ни одного из `_TESTS_NEGATIVE_TOKENS` - (`BLOCKED/FAILED/FAIL/REQUEST_CHANGES/REJECT/RED`), позитив `PASS` из `result:` → `True`; для FAIL - `"FAILED FAIL"` → негативный токен → `False`. Прибито TC-04 - (`test_tc04_status_field_never_false_negatives_a_pass`) через реальный парсер. Мина снята верно. -- **D5 DEFER** — зеркало `staging_runner._handle_tool_error`, но re-queue **`tester`**-джоба (не - `deployer`!), счётчик restart-safe по маркеру `test-runner infra-retry` в `task_content` (без - правки схемы БД). Проверено TC-10. -- **D4 единый маппинг** — переиспользован `self_deploy.map_exit_code_to_status` (BR-4), второй - несогласованный маппинг не введён. -- **Трассировка маркеров (TRACEABILITY):** правки рядом с ORCH-115 (`launcher` врезка), ORCH-114 - (transition-lease берётся **внутри** `advance_stage` — раннер не трогает, граница O1), ORCH-110 - (`proc_group` переиспользуется как есть) — ни один зафиксированный инвариант не сломан. -- **Глобальные ADR** (INV-4 «мерж только через PR», запрет рестарта прод-контейнера) — соблюдены: - лог пушится только в фичеветку (`git push origin `, не force, не `main`); смоук read-only. +### 2. Соответствие ADR / инварианты — PASS +- NFR-1 / AC-6: `git diff origin/main...HEAD` НЕ затрагивает `src/stages.py`, `src/qg/`, + `src/stage_engine.py`, `src/staging_runner.py`, `src/proc_group.py`, `src/transition_lease.py`, + `src/git_worktree.py` — проверено явно (пустой diff). ✔. +- **D6.1 (ключевая мина)**: `_parse_tests_verdict` (`src/qg/checks.py:263-277`) читает вердикт из трёх + полей с приоритетом негативного токена. Раннер выравнивает `status:` по вердикту (`PASS→success` + «SUCCESS» — не позитивный и не негативный токен → `True` берётся из `result: PASS`; `FAIL→failed` + «FAILED» — негативный → `False`). Проверено вручную по логике парсера и тестом TC-04 + (`test_tc04_status_field_never_false_negatives_a_pass`) через **неизменённый** парсер. ✔. +- Граница O1: `staging_runner` (ORCH-115), `transition_lease` (ORCH-114), `checkout_hygiene` + (ORCH-112) не модифицированы — соответствует требованию. ✔. +- Трассировка: новые врезки корректно ссылаются на прецеденты D1/D2/ORCH-115; зафиксированные + инварианты конвейера не сломаны. ✔. ### 3. Качество кода — PASS - -- **Docstrings** на всех публичных функциях; контракт **never-raise** выдержан сквозно (каждый - внешний вызов обёрнут; счётчики через `_bump` не ломают решение). -- **Сигнатуры зависимостей сверены лично** (риск latent false-FAIL устранён): - `db.enqueue_job(agent, repo, task_content, task_id=, available_at_delay_s=)`, `db.mark_job`, - `self_deploy.map_exit_code_to_status`, `git_worktree.get_worktree_path(repo, branch)`, - `qg.checks.is_self_hosting_repo`, `config.post_deploy_base_url` (дефолт `http://localhost:8500`), - `notifications.send_telegram`/`link_for`, `proc_group.run_in_process_group`/`ProcResult` — все - существуют ровно как используются. -- **Тесты содержательные** (TC-01…TC-15, ~32 тест-функции, не тривиальные): kill-switch/scope/contract, - маппинг по классам входа, рендер+неизменённый парсер, перехват до `_spawn`, two-level outcome, - never-raise, timeout-resolve, smoke read-only (включая транзиент-ретрай и missing-`serial_gate`), - анти-дрейф конвейера, наблюдаемость, структурный лог. -- **Security:** smoke — только `urllib` GET к локальному оркестратору; мутирующих запросов нет. -- **Багфикс-трек неприменим:** это **не** `Bug`-задача (full-cycle, стадия `architecture` отработана, - есть ADR) → требование регресс-фиксатора ORCH-019/BR-4 не применяется; покрытие тем не менее - исчерпывающее. +- never-raise соблюдён во всех публичных функциях (`applies`/`should_intercept`/`run_test_gate`/ + `snapshot`/`write_test_report`/`run_smoke` — guarded; TC-01/TC-06/TC-11/TC-14 покрывают). +- Лениво импортируются тяжёлые модули — leaf-чистота сохранена (импорт на уровне модуля только + `config`/`logging`/`proc_group`). +- Тесты содержательные (14 TC + анти-дрейф TC-15), без живого Claude CLI/сети; покрывают happy/FAIL/ + tool-error/never-raise/kill-switch/scope/smoke/observability. +- Это feature-трек (не `Bug`), регресс-тест-фиксатор (ORCH-019 BR-4) не требуется; покрытие тем не + менее исчерпывающее. ### 4. Документация — PASS (обязательная проверка) +`src/` изменён → документация обновлена в том же PR, проверено пофайлово: +- `CLAUDE.md` — новый раздел «Детерминированный test-раннер (ORCH-116)». ✔ +- `CHANGELOG.md` — детальная запись `[Unreleased]`. ✔ +- `docs/architecture/README.md` — компонент **Test-runner** + блок roadmap «второй срез реализован». ✔ +- `docs/architecture/internals.md` — примечание о перехвате на `testing`. ✔ +- `docs/architecture/llm-call-sites.md` (A5), `llm-determinization-roadmap.md` (rank 2), + `llm-usage-policy.md` (§5) — обновлены; **инвариант «ровно один `first_slice=yes`» сохранён** + (deployer=yes, tester=no), анти-дрейф `tests/test_llm_call_site_inventory.py` / + `test_llm_determinization_docs.py` — зелёные. ✔ +- Витрина `docs/overview/` (ORCH-011): `tech-pipeline.md` / `tech-agents.md` / + `tech-quality-security.md` обновлены; `tests/test_system_docs.py` зелёный. ✔ +- `.openclaw/agents/tester.md` — LLM-ветвь помечена fallback'ом (канон 52d цел). ✔ +- `.env.example` — все 7 ключей `ORCH_TEST_RUNNER_*`. ✔ +- ADR + сквозной `adr-0050` присутствуют. ✔ -`src/` изменён → документация обновлена **в том же PR**, проверено явно по `git diff` (наличие -правок подтверждено по каждому файлу): -- **Паспорт** `CLAUDE.md` — новый раздел «Детерминированный test-раннер вместо LLM-тестера (ORCH-116)». -- **Компонент-карта** `docs/architecture/README.md` (3 hits) + **внутренности** `internals.md` - (5 hits) — перехват на `testing` рядом с ORCH-115. -- **LLM-карта/политика/roadmap** — `llm-call-sites.md` (A5), `llm-determinization-roadmap.md` - (rank 2 ✅ реализован; инвариант «ровно один `first_slice=yes`» цел — `yes` у rank 1 deployer, - `no`/`hybrid_needed=yes` у rank 2 tester), `llm-usage-policy.md` (§5); анти-дрейф-тесты - `test_llm_call_site_inventory.py`/`test_llm_determinization_docs.py` — **зелёные (лично прогнаны)**. -- **Витрина системы `docs/overview/` (ORCH-011)** — обновлены `tech-pipeline.md`, `tech-agents.md`, - `tech-quality-security.md`; `tests/test_system_docs.py` — **зелёный (лично прогнан)**. -- **Промпт** `.openclaw/agents/tester.md` — врезка «детерминированный раннер ведёт стадию; LLM — - fallback под выключенным флагом / для репо без контракта»; канон 52d (5 секций, ключ `result:`) цел. -- **`CHANGELOG.md`** — развёрнутая запись `[Unreleased]`. -- **ADR** заведён (`06-adr/ADR-001-deterministic-test-runner.md` + сквозной - `adr/adr-0050-deterministic-test-runner.md`). - -Обзорные доки / README «Известные ограничения» (ORCH-079): раннер — **новая способность**, не -закрытие документированного ограничения → дополнительных правок README не требуется. +## Тесты (AC-15) +- `tests/test_orch116_test_runner.py` + LLM анти-дрейф — **45 passed**. +- Полный регресс `pytest tests/ -q` — **2162 passed, 1 failed** (84s). Единственный фейл — + `tests/test_orch123_staging_runner_exec.py::test_r2_held_deploy_staging_not_rolled_back` (см. P2). ## Findings ### P0 — Blocker -- Нет. +- (нет) ### P1 — Must fix -- Нет. +- (нет) ### P2 — Should fix -- Нет. +- **[Вне ORCH-116, для отдельного follow-up] Pre-existing test-isolation flake в ORCH-123.** + В полном прогоне падает `tests/test_orch123_staging_runner_exec.py::test_r2_held_deploy_staging_ + not_rolled_back`. Доказано, что это **не** дефект ORCH-116: (1) тест зелёный в изоляции и в своём + файле; (2) фейл воспроизводится при прогоне полного сьюта **без** `tests/test_orch116_test_runner.py` + (`--ignore`) → 1 failed; (3) ORCH-116 не трогает `src/staging_runner.py` (граница O1, корректно). + Это загрязнение глобального состояния от соседнего теста в ORCH-123-коде (недавно влит в `main`). + AC-15 в части «ORCH-116 не краснит ранее зелёные тесты» удовлетворён. Рекомендация: завести + отдельный bug на изоляцию теста ORCH-123 — он вне области ORCH-116 и не должен блокировать этот PR. -### P3 — Nice-to-have (не блокирует) -- [ ] `_http_get` читает первые 8192 байта тела; smoke ищет `serial_gate` в ответе `/queue`. **Лично - измерено:** `serial_gate` на смещении **1471 байт** при полном ответе ~3.6 КБ → запас огромный, - **сейчас корректно**. Латентная хрупкость лишь при экстремальном разрастании ранних блоков; можно - опционально поднять лимит чтения для `/queue` или искать ключ потоково. -- [ ] `build_test_command` добавляет `-q`, отсутствующий в литеральной команде ADR/CHANGELOG (`python - -m pytest `). Безвредно (exit-код, а не парс вывода, формирует вердикт; согласовано с прежним - промптом `pytest tests/ -q`); фиксирую лишь как расхождение текст↔код. -- [ ] Tracked-scratch `.task-dev.md` перезаписан с ORCH-115 на ORCH-116 (нормальная churn dev-раннера, - предсуществующий паттерн, не введён этим PR; вне осей ревью). - -### Контекст (не finding) -- В истории ветки присутствует `15-staging-log.md` со `staging_status: FAILED` (`exit_code: None` — - staging-сюита **не исполнилась**, tool-error/инфра, бюджет инфра-ретраев исчерпан → fail-closed). - Это исход стадии **deploy-staging** (downstream от review), относится к staging-раннеру ORCH-115 и - является **инфра-сбоем, а не дефектом кода ORCH-116** — вне осей код-ревью. Поведение гейта - корректно (fail-closed на исчерпании инфра-бюджета); правок в коде задачи не требует. Отмечено как - контекст для последующих стадий. +### P3 — Nice to have +- `run_smoke` (`src/test_runner.py:291`) дублирует литерал `"http://localhost:8500"`, который уже + является дефолтом `settings.post_deploy_base_url`. Это безвредный defensive double-default + (`localhost`/`8500` НЕ в FORBIDDEN-списке `test_no_host_hardcodes` — нарушения нет); можно опереться + только на дефолт config. Косметика. +- Smoke-провал из-за транзиентного блипа прод-8500 после bounded-ретраев даёт `FAIL` → откат + + расход developer-retry (формально инфра, трактуемая как код-фейл — родственно классу ORCH-110). + Архитектор **осознанно** взвесил это в ADR (D3 + Consequences «−»): bounded smoke-ретрай + + config-gate `test_runner_smoke_enabled` + developer-retry-cap; поведение эквивалентно прежнему + LLM-tester (`curl /health`). Принято как задокументированный компромисс; не блокирует. ## Документация -Обновлена в полном объёме в том же PR (см. ось 4): `CLAUDE.md`, `docs/architecture/README.md`, -`internals.md`, `llm-call-sites.md`, `llm-determinization-roadmap.md`, `llm-usage-policy.md`, -`docs/overview/{tech-pipeline,tech-agents,tech-quality-security}.md`, `.openclaw/agents/tester.md`, -`CHANGELOG.md`, ADR-001 + сквозной adr-0050. Анти-дрейф-тесты документации -(`test_llm_call_site_inventory.py`, `test_llm_determinization_docs.py`, `test_system_docs.py`) — -зелёные (лично прогнаны). Невыполненных требований к обновлению документации **нет**. +Обновлена в полном объёме в том же PR (см. ось 4). Изменение `src/` сопровождено обновлением +паспорта, чейнджлога, архитектурной карты, internals, витрины `docs/overview/`, LLM-карты/roadmap/ +политики, промпта `tester.md`, `.env.example` и ADR (локальный + сквозной). Машинно-проверяемые факты +витрины и LLM-карты держатся зелёными анти-дрейф-тестами. Требование «документация = golden source» +выполнено → блокирующих документационных findings нет. ## Вердикт -Нет P0/P1/P2 findings; критический инвариант NFR-1 соблюдён байт-в-байт (`stages.py`/`qg/checks.py` -не тронуты — проверено лично); документация = golden source обновлена синхронно с кодом; полный -регресс зелёный лично проверен (2137 passed). **`verdict: APPROVED`.** +Нет P0/P1, относящихся к ORCH-116. Все четыре оси (ТЗ, ADR/инварианты, качество кода, документация) +пройдены; критические инварианты сохранены байт-в-байт; покрытие исчерпывающее. **APPROVED.** +Единственный красный тест полного сьюта — pre-existing flake ORCH-123 (P2), доказанно независимый от +ORCH-116 и вне его области правки. From 3270647d86f8d0255b4623d00477830ca8191e0f Mon Sep 17 00:00:00 2001 From: claude-bot Date: Tue, 16 Jun 2026 10:19:58 +0300 Subject: [PATCH 14/16] tester(ET): auto-commit from tester run_id=758 --- docs/work-items/ORCH-116/13-test-report.md | 163 +++++++++++++++------ 1 file changed, 121 insertions(+), 42 deletions(-) diff --git a/docs/work-items/ORCH-116/13-test-report.md b/docs/work-items/ORCH-116/13-test-report.md index c5b6eb4..df71b8b 100644 --- a/docs/work-items/ORCH-116/13-test-report.md +++ b/docs/work-items/ORCH-116/13-test-report.md @@ -1,5 +1,5 @@ --- -result: PASS +result: PASS # PASS | FAIL — машинный вердикт, UPPERCASE work_item: ORCH-116 stage: testing author_agent: tester @@ -10,63 +10,142 @@ type: test-report work_item_id: ORCH-116 --- -# Test Report — ORCH-116 +# Test Report — ORCH-116 — детерминированный test-раннер вместо LLM-тестера -Детерминированный test-раннер вместо LLM-тестера (стадия `testing`). +> Машинный вердикт читается ТОЛЬКО из frontmatter (`result:`; равнорангово `verdict:`/`status:`, +> ORCH-047). Любой негативный токен авторитетен. ## Окружение - Python: 3.12.13 -- pytest: 8.3.3 (plugins: cov-5.0.0, anyio-4.14.0, asyncio-0.23.8) -- Worktree: `/repos/_wt/orchestrator/feature_ORCH-116-orch-replace-llm-tester-with-d` -- Ветка: `feature/ORCH-116-orch-replace-llm-tester-with-d` +- pytest: 8.3.3 - Дата: 2026-06-16 +- Worktree: `/repos/_wt/orchestrator/feature_ORCH-116-orch-replace-llm-tester-with-d` + (ветка `feature/ORCH-116-orch-replace-llm-tester-with-d`) — регресс прогнан в worktree ветки + задачи, НЕ в общем `/repos/orchestrator` (анти checkout-гонка). +- Прод-контейнер 8500 не трогался; smoke — строго read-only GET. +- Review-гейт: `12-review.md` → `verdict: APPROVED` ✔ (предусловие стадии выполнено). ## Smoke API (read-only) -- `GET /health` → `{"status":"ok","service":"orchestrator"}` — **OK** -- `GET /status` → активные задачи отданы (ORCH-116 на `testing`) — **OK** -- `GET /queue` → отдан; блок `serial_gate` присутствует (ORCH-088), блок `auto_labels` присутствует, - блок `test_runner` присутствует (ORCH-116 наблюдаемость) — **OK** -## Результаты по тест-плану (04-test-plan.yaml) +| Эндпоинт | Результат | +|----------|-----------| +| `GET /health` | `{"status":"ok","service":"orchestrator"}` — **OK** | +| `GET /status` | 200, активные задачи отдаются (вкл. ORCH-116, stage=testing) — **OK** | +| `GET /queue` | 200; блок `serial_gate` присутствует ✔ (ORCH-088); блок `auto_labels` присутствует ✔ — **OK** | -| TC ID | Описание | Тест(ы) | Результат | -|-------|----------|---------|-----------| -| TC-01 | `applies(repo)`: kill-switch/скоуп/тест-контракт (BR-9), never-raise | `test_tc01_applies_killswitch_scope_and_contract`, `test_tc01_applies_never_raises` | PASS | -| TC-02 | Маппинг exit-кода 0→PASS / иначе/None→FAIL (fail-closed, единый контракт) | `test_tc02_map_exit_code` | PASS | -| TC-03 | Рендер `13-test-report.md`: `result:` UPPERCASE + 52c-схема + хвост stdout/smoke | `test_tc03_report_render_schema_and_status_alignment` | PASS | -| TC-04 | Артефакт читается неизменённым `_parse_tests_verdict` для PASS/FAIL | `test_tc04_gate_parser_unchanged`, `test_tc04_status_field_never_false_negatives_a_pass` | PASS | -| TC-05 | `launch_job` перехватывает tester-джоб до `_spawn`; `agent_runs` не создаётся, None | `test_tc05_launch_job_intercepts_before_spawn` | PASS | -| TC-06 | Дискриминатор: не-`testing`/не-tester/не-self не перехватываются; never-raise→False | `test_tc06_*` (4 теста) | PASS | -| TC-07 | PASS→advance(`tester`)→`deploy-staging`; FAIL→откат `testing→development` + retry | `test_tc07_advance_initiated_like_llm[0-PASS]`, `[1-FAIL]` | PASS | -| TC-08 | Kill-switch `test_runner_enabled=False` → `_spawn` (LLM-путь байт-в-байт) | `test_tc08_killswitch_falls_back_to_spawn` | PASS | -| TC-09 | Анти-дрейф NFR-1: `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_tests_passed`/токены/схема БД целы | `test_tc09_pipeline_contract_unchanged` | PASS | -| TC-10 | Two-level (анти-ORCH-110): tool-error→bounded DEFER; исчерпание→fail-closed FAIL+alert | `test_tc10_nonzero_exit_is_fail_and_advances`, `test_tc10_timeout_defers_without_advance`, `test_tc10_tool_error_budget_exhausted_fails_closed` | PASS | -| TC-11 | never-raise/fail-safe: pytest-бросок/таймаут/worktree-ошибка → FAIL/DEFER, не клинит | `test_tc11_run_gate_never_raises`, `test_tc11_launcher_contains_runner_fault` | PASS | -| TC-12 | Изоляция/таймаут: proc_group tree-kill в worktree; малформ→дефолт 900+WARNING | `test_tc12_resolve_timeout_default_on_bad_value`, `test_tc12_pytest_runs_in_worktree_via_proc_group` | PASS | -| TC-13 | Self-hosting safety: нет опасных литералов; smoke строго read-only GET; push в фичеветку | `test_tc13_*` (5 тестов) | PASS | -| TC-14 | Наблюдаемость+гибрид: блок `test_runner` в `/queue`; структурный лог; LLM вне control-path | `test_tc14_*` (4 теста) | PASS | -| TC-15 | Анти-дрейф LLM-карты: `llm-call-sites`/roadmap/policy зелёные после правок | `test_tc15_llm_map_anti_drift_green`, `test_llm_call_site_inventory.py`, `test_llm_determinization_docs.py` | PASS | +Примечание: блок `test_runner` (ORCH-116) в `/queue` прод-инстанса отсутствует — ожидаемо, т.к. +прод исполняет до-ORCH-116 код (эта ветка ещё не задеплоена). Это не регресс смока: контрактные +блоки `serial_gate`/`auto_labels` на месте. -Каждый TC из `04-test-plan.yaml` выполнен и сопоставлен с критериями `03-acceptance-criteria.md`. +## Результаты -## Вывод pytest +### Полный регресс (`pytest tests/ -v --tb=short`, worktree ветки) +- **2162 passed, 1 failed** (105.31s). +- Профильная сюита `tests/test_orch116_test_runner.py` — **32 passed** (в изоляции, 2.64s). +- Анти-дрейф LLM-карты `tests/test_llm_call_site_inventory.py` + `test_llm_determinization_docs.py` + — зелёные (в составе полного регресса). + +### Единственный красный — pre-existing flake ORCH-123, НЕ дефект ORCH-116 + +`tests/test_orch123_staging_runner_exec.py::test_r2_held_deploy_staging_not_rolled_back`. + +Доказано независимым воспроизведением, что фейл **полностью независим** от ORCH-116 и пред-существует +в `main` (анти-ложная-маршрутизация инфра/чужого фейла как код-фейла — класс ORCH-110): + +1. **Изоляция:** `pytest …::test_r2_held_deploy_staging_not_rolled_back` отдельно → **1 passed**. +2. **Профильный файл ORCH-116:** `tests/test_orch116_test_runner.py` → **32 passed** (зелёный). +3. **Полный регресс БЕЗ файла ORCH-116** (`--ignore=tests/test_orch116_test_runner.py`) → всё равно + **1 failed, 2130 passed** — тот же тест красный без участия нового кода тестов ORCH-116. +4. **Чистый `origin/main` (`9c88fdd`), полный регресс** во временном worktree → **1 failed, 2130 + passed**, падает РОВНО тот же тест. → флейк пред-существует в `main`, идентичный счётчик фейлов. +5. **Граница правки:** `git diff origin/main...HEAD` НЕ затрагивает `src/staging_runner.py`, + `src/stages.py`, `src/qg/`, `src/stage_engine.py`. ORCH-116 физически не может влиять на этот тест. + +Итог сопоставления: ветка ORCH-116 = `2162 passed / 1 failed`; `main` = `2130 passed / 1 failed`. +ORCH-116 добавляет **32 зелёных** теста и **не делает красным ни один ранее зелёный** — это +кросс-тестовое загрязнение глобального состояния в коде ORCH-123 (недавно влит в `main`). +**AC-15 FAIL-условие** («любой ранее зелёный тест становится красным / новые тесты падают») — +**не наступило**; AC-15-интент NFR-1/NFR-5 («существующий конвейер не сломан») — выполнен. +Рекомендация: завести отдельный bug на изоляцию `test_orch123_staging_runner_exec.py` (вне области +ORCH-116, не должен блокировать этот PR). Согласуется с вердиктом reviewer (P2, APPROVED). + +### Сопоставление с тест-планом (`04-test-plan.yaml`) + +| TC ID | Тип | Описание (кратко) | Тест-функция / проверка | Результат | +|-------|-----|-------------------|--------------------------|-----------| +| TC-01 | unit | `applies(repo)`: kill-switch/CSV/контракт (BR-9)/never-raise | `test_tc01_*` | PASS | +| TC-02 | unit | Маппинг exit→verdict (0→PASS, иначе/None→FAIL, единый контракт) | `test_tc02_map_exit_code` | PASS | +| TC-03 | unit | Рендер `13-test-report.md`: `result:` UPPERCASE + 52c-схема | `test_tc03_report_render_schema_and_status_alignment` | PASS | +| TC-04 | integration | Артефакт читается **неизменённым** `_parse_tests_verdict` | `test_tc04_gate_parser_unchanged`, `test_tc04_status_field_never_false_negatives_a_pass` | PASS | +| TC-05 | integration | Перехват tester на `testing` до `_spawn`, нет `agent_runs`, `None` | `test_tc05_launch_job_intercepts_before_spawn` | PASS | +| TC-06 | integration | Дискриминатор: не-`testing`/не-`tester` не перехват; never-raise→`False` | `test_tc06_*` | PASS | +| TC-07 | integration | PASS→`advance_stage(finished_agent='tester')`; FAIL→откат+retry | `test_tc07_advance_initiated_like_llm[0-PASS]`, `[1-FAIL]` | PASS | +| TC-08 | integration | Kill-switch off → `_spawn` (LLM-путь байт-в-байт) | `test_tc08_killswitch_falls_back_to_spawn` | PASS | +| TC-09 | unit | Анти-дрейф NFR-1: STAGE_TRANSITIONS/QG_CHECKS/парсер/токены/схема БД целы | `test_tc09_pipeline_contract_unchanged` | PASS | +| TC-10 | integration | Two-level outcome: tool-error→bounded DEFER→fail-closed FAIL+alert | `test_tc10_*` | PASS | +| TC-11 | unit | never-raise/fail-safe: pytest бросает/таймаут→FAIL/DEFER, не клинит | `test_tc11_run_gate_never_raises`, `test_tc11_launcher_contains_runner_fault` | PASS | +| TC-12 | unit | Изоляция/таймаут: proc_group tree-kill в worktree; малформ→дефолт 900+WARN | `test_tc12_*` | PASS | +| TC-13 | unit | Self-hosting safety: нет запрещённых литералов; smoke read-only GET | `test_tc13_*` | PASS | +| TC-14 | integration | Наблюдаемость: блок `test_runner` в `/queue`, структурный лог, гибрид | `test_tc14_*` | PASS | +| TC-15 | integration | Анти-дрейф LLM-карты (A5/rank 2, «ровно один first_slice=yes») | `test_llm_call_site_inventory.py` / `test_llm_determinization_docs.py` | PASS | + +**Все 15 TC выполнены и сопоставлены; все PASS.** + +### Сопоставление с критериями приёмки (`03-acceptance-criteria.md`) + +| AC | Покрыт | Результат | +|----|--------|-----------| +| AC-1 Перехват на `testing` без `_spawn`/LLM | TC-05 | PASS | +| AC-2 Контракт `13-test-report.md` неизменен | TC-03, TC-04 | PASS | +| AC-3 exit-code→verdict маппинг (fail-closed) | TC-02 | PASS | +| AC-4 Эквивалентность маршрутизации PASS/FAIL | TC-07 | PASS | +| AC-5 Two-level outcome (tool-error ≠ code-fail) | TC-10 | PASS | +| AC-6 Скоуп: гейты/стадии/схема БД не тронуты | TC-09 + `git diff` | PASS | +| AC-7 Kill-switch и скоуп (обратимость) | TC-01, TC-08 | PASS | +| AC-8 Backward-compat для репо без контракта | TC-01 | PASS | +| AC-9 never-raise / fail-safe | TC-11 | PASS | +| AC-10 Self-hosting safety | TC-13 | PASS | +| AC-11 Изоляция процесса/таймаут (proc_group) | TC-12 | PASS | +| AC-12 Гибрид: LLM не в control-path вердикта | TC-14 | PASS | +| AC-13 Наблюдаемость | TC-14 | PASS | +| AC-14 Норматив LLM-карты/политики/витрины | TC-15 + ревью оси 4 | PASS | +| AC-15 Полный регресс зелёный | полный регресс | PASS* | + +\* AC-15: новые тесты зелёные, ни один ранее зелёный тест не покраснел из-за ORCH-116. Единственный +красный — pre-existing flake ORCH-123 (идентичен на чистом `main`), вне области ORCH-116. + +## Вывод pytest (хвост полного регресса) -### Полный регресс ``` -$ python -m pytest tests/ -q --tb=short -........................................................................ [ 97%] -................................................. [100%] -2137 passed, 1 warning in 84.57s (0:01:24) +=================================== FAILURES =================================== +_________________ test_r2_held_deploy_staging_not_rolled_back __________________ +tests/test_orch123_staging_runner_exec.py:462: in test_r2_held_deploy_staging_not_rolled_back + assert result is None # red gate -> stay, no advance call +E AssertionError: assert is None +=========================== short test summary info ============================ +FAILED tests/test_orch123_staging_runner_exec.py::test_r2_held_deploy_staging_not_rolled_back +============ 1 failed, 2162 passed, 1 warning in 105.31s (0:01:45) ============= ``` -(единственный warning — несвязанный Pydantic V2 deprecation в `src/config.py:8`) -### Тесты ORCH-116 (verbose) +Контрольные прогоны (доказательство независимости от ORCH-116): ``` -$ python -m pytest tests/test_orch116_test_runner.py tests/test_llm_call_site_inventory.py tests/test_llm_determinization_docs.py -v -45 passed, 1 warning in 2.20s +# тест в изоляции +1 passed +# профильный файл ORCH-116 +32 passed +# полный регресс БЕЗ файла ORCH-116 (--ignore) +1 failed, 2130 passed (тот же тест красный) +# чистый origin/main (9c88fdd), полный регресс +1 failed, 2130 passed (тот же тест красный) ``` ## Итог -PASS — полный регресс зелёный (2137 passed), smoke read-only OK (`/health`/`/status`/`/queue`, -блок `serial_gate` присутствует), все 15 TC выполнены и сопоставлены с критериями приёмки. -Задача переходит на `deploy-staging`. + +**PASS.** Smoke OK (read-only `/health`/`/status`/`/queue`; `serial_gate` + `auto_labels` на месте). +Профильная сюита (32) и анти-дрейф LLM-карты зелёные. Все 15 TC и 15 AC сопоставлены и пройдены. +Единственный красный тест полного регресса — **pre-existing flake ORCH-123** +(`test_r2_held_deploy_staging_not_rolled_back`), доказанно идентичный на чистом `origin/main` +(`2130 passed / 1 failed`) и полностью независимый от ORCH-116 (граница правки не затрагивает +`src/staging_runner.py`); ORCH-116 не делает красным ни один ранее зелёный тест и добавляет 32 +зелёных. AC-15-интент «существующий конвейер не сломан» выполнен. Рекомендован отдельный bug на +изоляцию теста ORCH-123 (вне области этой задачи). Задача переходит на `deploy-staging`. From b212afbbd04d3659b261813f03e64bf2756e43f0 Mon Sep 17 00:00:00 2001 From: staging-runner Date: Tue, 16 Jun 2026 10:21:36 +0300 Subject: [PATCH 15/16] staging(ORCH-115): staging gate SUCCESS for ORCH-116 --- docs/work-items/ORCH-116/15-staging-log.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/work-items/ORCH-116/15-staging-log.md b/docs/work-items/ORCH-116/15-staging-log.md index a8e1f27..3782f98 100644 --- a/docs/work-items/ORCH-116/15-staging-log.md +++ b/docs/work-items/ORCH-116/15-staging-log.md @@ -31,8 +31,8 @@ Staging suite stdout (tail): [CLEANUP] · CLEANUP: no branch to delete - ✓ PASS CLEANUP: deleted Plane issue 90c81fdc-d61f-47f3-8e2e-1fec3860513d (HTTP 204) - · CLEANUP DB: no task row found for plane_id=90c81fdc-d61f-47f3-8e2e-1fec3860513d + ✓ PASS CLEANUP: deleted Plane issue d88719d1-378b-49d4-b4be-3cc30e9dca4f (HTTP 204) + · CLEANUP DB: no task row found for plane_id=d88719d1-378b-49d4-b4be-3cc30e9dca4f · CLEANUP DB dedup: no such table: events_dedup ============================================================ From 274fbd77fc811b3e95cc0182433eeb4403cc6c42 Mon Sep 17 00:00:00 2001 From: deploy-finalizer Date: Tue, 16 Jun 2026 10:27:22 +0300 Subject: [PATCH 16/16] deploy(ORCH-036): finalize SUCCESS for ORCH-116 --- docs/work-items/ORCH-116/14-deploy-log.md | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 docs/work-items/ORCH-116/14-deploy-log.md diff --git a/docs/work-items/ORCH-116/14-deploy-log.md b/docs/work-items/ORCH-116/14-deploy-log.md new file mode 100644 index 0000000..a98a775 --- /dev/null +++ b/docs/work-items/ORCH-116/14-deploy-log.md @@ -0,0 +1,12 @@ +--- +deploy_status: SUCCESS +work_item: ORCH-116 +hook_exit_code: 0 +deployed_by: deploy-finalizer +--- + +# Deploy log — ORCH-036 executable self-deploy + +Прод-деплой завершён хост-хуком с exit-code `0` -> `deploy_status: SUCCESS`. + +Вердикт зафиксирован детерминированным finalizer'ом (Фаза C), не LLM.