deploy-staging(ORCH-114): staging gate SUCCESS (8/10 PASS, C9a/C9b infra-waived)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.env.example

@@ -164,11 +164,32 @@ ORCH_TRACKER_LIVE_STATUS_TIMEOUT_S=3
 #   DEFER_MAX_ATTEMPTS -> defer retries before escalation (avoids livelock).
 ORCH_MERGE_GATE_ENABLED=true
 ORCH_MERGE_GATE_REPOS=
-ORCH_MERGE_RETEST_TIMEOUT_S=600
+# ORCH-110 (D5): re-test budget raised 600 -> 900 (74% headroom over the observed
+# 516.7s suite). Cross-invariant (ORCH-065/109): keep ORCH_REAPER_MAX_RUNNING_S
+# (5400) > Σ(deploy-staging gate-work) + grace if you raise this — see
+# docs/work-items/ORCH-110/07-infra-requirements.md.
+ORCH_MERGE_RETEST_TIMEOUT_S=900
 ORCH_MERGE_RETEST_TARGET=tests/
 ORCH_MERGE_LOCK_TIMEOUT_S=300
 ORCH_MERGE_DEFER_DELAY_S=60
 ORCH_MERGE_DEFER_MAX_ATTEMPTS=5
+# ORCH-110: merge-gate re-test infra-timeout tolerance + tree-kill of the
+# orchestrator-spawned pytest subprocess (re-test + coverage). Each default = the
+# desired prod behaviour; each flag is an independent kill-switch (off ->
+# byte-for-byte pre-ORCH-110). The tree-kill grace reuses ORCH_AGENT_KILL_GRACE_SECONDS.
+#   SUBPROCESS_TREE_KILL_ENABLED          -> D1: spawn re-test/coverage pytest in its
+#       own process group; tree-kill the WHOLE group on timeout (no orphan grandchildren).
+#   MERGE_RETEST_INFRA_TOLERANCE_ENABLED  -> D3: a re-test TIMEOUT is a transient
+#       (bounded infra-retry, NOT a code-fault rollback to development).
+#   MERGE_RETEST_INFRA_MAX_RETRIES        -> D3: infra-retry budget before an infra-alert.
+#   MERGE_RETEST_INFRA_RETRY_DELAY_S      -> D3: delay before the staging-deployer re-run.
+#   MERGE_RETEST_SKIP_WHEN_CURRENT_ENABLED-> D4: skip the local re-test when the
+#       pre-merge rebase was a proven no-op (HEAD already CI/tester/staging-validated).
+ORCH_SUBPROCESS_TREE_KILL_ENABLED=true
+ORCH_MERGE_RETEST_INFRA_TOLERANCE_ENABLED=true
+ORCH_MERGE_RETEST_INFRA_MAX_RETRIES=2
+ORCH_MERGE_RETEST_INFRA_RETRY_DELAY_S=120
+ORCH_MERGE_RETEST_SKIP_WHEN_CURRENT_ENABLED=true
 # ORCH-026 Level A: unconditional pre-merge rebase. With the flag ON (default),
 # check_branch_mergeable ALWAYS rebases the branch onto origin/main under the held
 # merge-lease (not only when behind) — a deterministic structural anti-phantom on
@@ -319,6 +340,15 @@ ORCH_DEPLOY_PROD_TARGET_IMAGE=orchestrator-orchestrator
 ORCH_DEPLOY_PROD_COMPOSE_PROFILE=
 ORCH_DEPLOY_PROD_PREV_IMAGE_FILE=.deploy-prev-image-prod
 
+# ORCH-112: deploy-base checkout-hygiene (resilient-pull). The self-deploy hook
+# converges a DIRTY shared deploy-base to a clean, current origin/main BEFORE the
+# `git pull` (git fetch + reset --hard + a SCOPED `git clean -fd`, NEVER `-x`), so
+# manual/abandoned WIP left by a failed/cancelled task never blocks the deploy
+# (incident ORCH-111). False -> bare `git pull origin main` 1:1 as before ORCH-112.
+# Empty REPOS -> only the self-hosting repo (orchestrator).
+ORCH_CHECKOUT_HYGIENE_ENABLED=true
+ORCH_CHECKOUT_HYGIENE_REPOS=
+
 # ORCH-058: staging-image provenance before the BUILD-ONCE prod retag (INV-FRESH).
 # Guarantees the staging image promoted to prod is the EXACT artefact rebuilt from the
 # validated commit — two layers, self-hosting only:

.task-dev.md

@@ -1,4 +1,4 @@
-Work item: ORCH-111
+Work item: ORCH-112
 Repo: orchestrator
-Branch: feature/ORCH-111-bug-watchdog-must-alert-on-lon
+Branch: feature/ORCH-112-bug-failed-cancelled-task-arti
 Stage: development

CHANGELOG.md

@@ -3,6 +3,23 @@
 Формат: [Keep a Changelog](https://keepachangelog.com/). Записи — на смысловой PR/задачу.
 
 ## [Unreleased]
+- **Гигиена shared deploy-базы: устойчивый self-deploy `git pull` к грязному дереву** (ORCH-112, `fix`, bug→escalate full-cycle): устранён инцидент ORCH-111 — self-deploy падал на шаге `git pull origin main` хост-хука с `error: Your local changes to the following files would be overwritten by merge: src/config.py` (грязь от неуспешной/отменённой/брошенной задачи ORCH-104 в общем main checkout) → деплой вставал → ручное вмешательство (на self-hosting — групповой риск). Решение — **resilient-pull, встроенный в прод-deploy-хук** (`--deploy`): перед `git pull` хук при обнаружении грязи приводит deploy-базу к чистому актуальному `origin/main` (`git fetch` + `git reset --hard origin/main` + **скоупленный** `git clean -fd`). Аддитивно, под kill-switch, never-raise, скоуп self-hosting; `STAGE_TRANSITIONS` / реестр `QG_CHECKS` / семантика и имена `check_*` / machine-verdict-ключи / схема БД / exit-code-контракт хука (0/1/2, ORCH-036) — **байт-в-байт не тронуты** (это устойчивость deploy-пути, **не** Quality Gate и **не** стадия). ADR: `docs/work-items/ORCH-112/06-adr/ADR-001-deploy-base-checkout-hygiene.md`, сквозной `docs/architecture/adr/adr-0044-deploy-base-checkout-hygiene.md`.
+  - **Leaf `src/checkout_hygiene.py` (новый, чистый never-raise):** по образцу `serial_gate`/`cancel`/`self_deploy` (импортирует только `config`, лениво `self_deploy`/`qg.checks`/`notifications`) — `applies(repo)` (kill-switch `checkout_hygiene_enabled` + скоуп `checkout_hygiene_repos`, пусто → self-hosting only, локально и ПЕРВЫМ), `hook_env(repo, work_item_id)` (env-префикс `CHECKOUT_HYGIENE=1 HYGIENE_REPORT=<host-path>`, инжектится в detached-команду хука только при `applies==True`, иначе `""` → голый pull 1:1), `read_report`/`alert_dirty` (наблюдаемость), `snapshot()` (read-only блок `GET /queue`).
+  - **Хук-блок «2a. Resilient pull» (`scripts/orchestrator-deploy-hook.sh`):** между шагом «1. Capture PREV_IMG» и «2. Pull», под `if [[ "${CHECKOUT_HYGIENE:-0}" == "1" ]]`. **Сохранность (NFR-2, жёсткий контракт):** `git clean` — **только `-fd`, НИКОГДА `-x`** (иначе удалил бы gitignored `.env`/прод-секреты, `data/*.db`/БД, `build/`); явные `-e '.deploy-prev-image-*'` и `-e 'deploy-hook.log'` (untracked-но-НЕ-ignored — иначе сломался бы rollback `do_rollback`); sibling `<repos_dir>/.deploy-state-*`/`.merge-lease-*.json` (под родителем `$REPO`) и `.git/worktrees/*` (внутри `.git/`) — вне области `git clean` в `$REPO`. Каждый git-шаг — `|| log "...continuing"` (never-break): сбой гигиены не ухудшает исход относительно текущего голого pull; на чистой базе блок — no-op (happy-path и exit-коды байт-в-байт). `--build-staging` (build из worktree, без pull) не затронут.
+  - **Сходимость после failed/cancelled (FR-2)** — этим же deploy-time self-heal (база сходится на следующем же self-deploy); `cancel_task` (ORCH-090) **не расширяется**, фоновый janitor **не вводится**. **Наблюдаемость (FR-4)** — хук пишет sentinel `hygiene` в deploy-state каталог; Phase-C finalizer (`stage_engine.run_deploy_finalizer`) читает (`read_report`) и шлёт Telegram-алерт (`alert_dirty`, кликабельный номер, best-effort, never-raise — сбой алерта не валит деплой).
+  - **Флаги** (`config.py`, дефолт = боевое): `checkout_hygiene_enabled` (env `ORCH_CHECKOUT_HYGIENE_ENABLED`), `checkout_hygiene_repos` (env `ORCH_CHECKOUT_HYGIENE_REPOS`). Откат = `ORCH_CHECKOUT_HYGIENE_ENABLED=false` → деплой байт-в-байт до ORCH-112. Покрытие — `tests/test_deploy_checkout_hygiene.py` (TC-01…TC-10: шелл-симуляция реального хука во временном git-репо без сети/прода/ssh + unit; TC-01 — обязательный регресс ORCH-111: КРАСНЫЙ до фикса, ЗЕЛЁНЫЙ после).
+- **Job-reaper не реапит живой долго финализирующий монитор `deploy-staging`** (ORCH-113, `fix`, bug→escalate full-cycle): устранено расхождение состояния из инцидента ORCH-111 (deployer job 1914 / run_id 683). На ребре `deploy-staging → deploy` живой монитор (`launcher._monitor_agent`) штампит `agent_runs.finished_at`/`exit_code` **первым**, затем синхронно в своём потоке прогоняет тяжёлые edge-под-гейты (`security → merge-gate re-test → coverage → image-freshness`) — **минуты** — и лишь потом `_finalize_job`. Reaper Tier-2 меряет `finished_age_s` от `finished_at` (= начала финализации), поэтому по истечении `reaper_finalize_grace_s=300` трактовал живого долго финализирующего монитора как мёртвого и **независимо** повторял тот же тяжёлый advance: повторный re-test стал красным → ложный откат `deploy-staging → development` (+ ложный developer-retry) **параллельно** с тем, что исходный finalizer довёл deploy до SUCCESS и смержил PR — состояние раздвоилось. Аддитивно, под глобальным kill-switch, never-raise; `STAGE_TRANSITIONS`/`QG_CHECKS`/каждый `check_*`/machine-verdict ключи/схема БД — **байт-в-байт не тронуты**; `reaper_finalize_grace_s`/`reaper_max_running_s` и сквозной бюджет ORCH-065/109/110 (`5400 > Σ(gate-work)+grace`) сохранены; фикс не рестартит прод и не пушит `main`. ADR: `docs/work-items/ORCH-113/06-adr/ADR-001-reaper-finalizer-liveness-ownership.md`, сквозной `docs/architecture/adr/adr-0043-reaper-finalizer-liveness-ownership.md`.
+  - **Leaf `src/finalizer_liveness.py` (новый, процесс-локальный реестр владения):** чистый never-raise модуль (паттерн `serial_gate`/`coverage_gate`, без сети/БД) — `mark(job_id, run_id, stage)` / `clear(job_id)` / `is_active(job_id)` / `snapshot()`; состояние `{job_id: {...}}` под `threading.Lock`. Авторитетно in-memory, т.к. монитор и reaper — daemon-**потоки одного** uvicorn-процесса (CMD без `--workers`) с общей SQLite-БД. Собственного TTL нет — ограничение по времени даёт Tier-3 backstop. `is_active` при ошибке → `False` (консервативно: не блокировать добивание).
+  - **Эмиссия владения (`launcher._monitor_agent`):** `mark()` вызывается **сразу после** штампа `exit_code` (самый ранний момент Tier-2), хвост финализации вынесен в `_run_monitor_finalization` и обёрнут в `try/finally` с `clear()` в `finally` → исключение в потоке монитора гарантированно снимает владение, и реально мёртвый finalizer добивается. Маркер пишется **безусловно** (kill-switch гейтит только консультацию reaper, поэтому выключенный путь — байт-в-байт прежний). Хвост перенесён **дословно** (проверяется `git diff -w`: +49/−0, нулевое изменение логики).
+  - **Консультация reaper (`job_reaper._reap_job` Tier-2):** при `reaper_finalizer_liveness_enabled` **И** стадии задачи `== "deploy-staging"` **И** активном владении → **defer** (счётчик + лог, не повторять advance), провал к Tier-3. **Tier-3 (`age >= reaper_max_running_s`) маркер игнорирует** — застрявший/мёртвый finalizer добивается в ограниченное время. Скоуп — только глобальный kill-switch `reaper_finalizer_liveness_enabled` (env `ORCH_REAPER_FINALIZER_LIVENESS_ENABLED`, дефолт `True`; `False` → reaper байт-в-байт прежний), **без** per-repo разреза (баг общий для всех репо со стадией `deploy-staging`).
+  - **Наблюдаемость:** аддитивные ключи `finalizer_liveness_enabled`/`finalizer_defers_total`/`finalizer_owned` в блоке `reaper` ответа `GET /queue` (существующие ключи не тронуты). Покрытие — `tests/test_orch113_reaper_finalizer_liveness.py` (TC-01…TC-08, включая обязательный регресс ORCH-111: КРАСНЫЙ до фикса, ЗЕЛЁНЫЙ после).
+- **Merge-gate re-test: толерантность к инфра-таймауту + tree-kill спавненных pytest + контракт необходимости re-test** (ORCH-110, `fix`, bug→escalate full-cycle): устранён ложный откат `deploy-staging → development`, возникавший когда локальный re-test merge-gate падал по **таймауту** (инфра/ресурс) при зелёных CI + tester + staging (инцидент ORCH-109/PR #129: сюит 516.7s упёрся в бюджет 600s под CPU-голоданием от осиротевших pytest-процессов → `(False, "re-test timeout after 600s")` → `_handle_merge_gate_rollback` → каждый из 3 developer-retry падал так же → «Merge-gate still failing after 3 developer retries» → ручное вмешательство). Аддитивно, под 5 независимыми kill-switch, never-raise, скоуп self-hosting; `STAGE_TRANSITIONS`/реестр `QG_CHECKS`/семантика `check_*`/machine-verdict-ключи/схема БД — **байт-в-байт не тронуты**; INV-4 (никогда push/force-push `main`) и запрет рестарта прод-контейнера — соблюдены. ADR: `docs/work-items/ORCH-110/06-adr/ADR-001-merge-gate-retest-infra-tolerance-and-tree-kill.md`, сквозной `docs/architecture/adr/adr-0042-merge-gate-retest-infra-tolerance-and-tree-kill.md`.
+  - **D1 — process-group tree-kill (`src/proc_group.py`, новый stdlib-only leaf):** `merge_gate.retest_branch` и `coverage_gate.measure_coverage` теперь спавнят pytest в **отдельной группе процессов** (`start_new_session`) и при таймауте убивают **всё дерево** (`os.killpg`, каскад SIGTERM→grace→SIGKILL по образцу `launcher.stop_process`), а не только прямого потомка — осиротевшие внуки-pytest больше не переживают бюджет и не грузят CPU. Контракты возврата сохранены (меняется лишь побочный эффект — нет утечки). Грейс реюзит `agent_kill_grace_seconds`. Fallback never-break: `subprocess_tree_kill_enabled=False` или не-POSIX → прежний `subprocess.run(timeout=)`.
+  - **D2/D3 — классификация + маршрутизация инфра-таймаута:** чистый предикат `merge_gate.classify_retest_failure(reason)` различает `timeout`/`red`/`lock-busy`/`other` (scope-guard: `auto_rebase_onto_main`'s «rebase timeout» — НЕ инфра-таймаут re-test, остаётся на rollback-пути). Инфра-таймаут → новый `_handle_merge_gate_infra_retry` (ограниченный повтор по образцу `_handle_merge_gate_defer`: задача **остаётся на deploy-staging**, staging-deployer перезапускается с задержкой, **БЕЗ** отката на `development` и **БЕЗ** расхода developer-retry). Анти-над-толерантность (BR-6): детерминированно **красный** re-test / конфликт по-прежнему → `_handle_merge_gate_rollback`. Anti-loop: исчерпание бюджета → один **инфра-alert** (явно инфраструктурная формулировка «НЕ дефект кода» с кликабельным номером), задача НЕ уходит в `development`.
+  - **D4 — контракт необходимости re-test:** при `premerge_rebase_always=True` re-test теперь **пропускается**, когда rebase оказался доказанным no-op (HEAD не сдвинулся = ветка уже содержит свежий `origin/main`, тот же коммит уже подтвердили CI + tester + staging) — distribute той же оптимизации, что путь `premerge_rebase_always=False` уже имеет для не-behind ветки. Fail-safe: при любой неопределённости (`head_sha` пуст / git-ошибка) re-test **выполняется** (BR-6/AC-3 не ослаблен).
+  - **D5 — бюджет:** `merge_retest_timeout_s` 600 → **900** (запас 74% над 516.7s) + валидация `_resolve_retest_timeout` (малформ/непозитив → дефолт 900 + WARNING). Сквозной инвариант ORCH-065/109 `reaper_max_running_s (5400) > Σ(deploy-staging gate-work)+grace (≈4460)` соблюдён **без** правки `reaper_max_running_s`.
+  - **D6 — наблюдаемость:** in-process счётчики (`retest_timeout_total`/`retest_infra_retry_total`/`retest_infra_exhausted_total`/`retest_skipped_current_total`/`last_infra_timeout_wi`) + read-only блок `merge_gate` в `GET /queue` (отличим от код-фейл-отката); координация с ORCH-111 (`proc_blocking`) без дубля (ORCH-110 предотвращает/толерирует, ORCH-111 наблюдает). Append-only regression-guard: добавлен `("ORCH-110", "classify_retest_failure", "src/merge_gate.py")` в `MAIN_REGRESSION_MARKERS`.
+  - **Конфиг (5 новых ключей, дефолт = боевое):** `ORCH_SUBPROCESS_TREE_KILL_ENABLED`/`ORCH_MERGE_RETEST_INFRA_TOLERANCE_ENABLED`/`ORCH_MERGE_RETEST_INFRA_MAX_RETRIES=2`/`ORCH_MERGE_RETEST_INFRA_RETRY_DELAY_S=120`/`ORCH_MERGE_RETEST_SKIP_WHEN_CURRENT_ENABLED` + бамп `ORCH_MERGE_RETEST_TIMEOUT_S=900`. Покрытие — `tests/test_orch110_*.py` (TC-01…TC-12, включая регресс инцидента red-before/green-after).
 - **Watchdog-сигнал `proc_blocking`: алерт на долго живущий осиротевший тест-процесс** (ORCH-111, `feat`): закрыта слепая зона наблюдаемости между `agent_hung` (видит только треканые джобы по `jobs.pid`) и осиротевшими субпроцессами `pytest`, которые орк запускает сам (`merge_gate.retest_branch`/`coverage_gate.measure_coverage`) и которые при timeout-kill агента (`-9`, ORCH-109) репарентируются на tini и живут сутками, грузя CPU и валя merge-gate re-test (инцидент: процессы `test_install_lite_script.py` жили >2 суток без единого алерта). Изменения **строго внутри наблюдателя** (`watchdog/**` + сервис watchdog в compose); `src/**`/`/metrics`/`schema_version`/`STAGE_TRANSITIONS`/`QG_CHECKS`/`check_*`/machine-verdict/схема БД — **байт-в-байт не тронуты**; выкат пересобирает **только** `orchestrator-watchdog`, прод `orchestrator` не рестартится (NFR-3). ADR: `docs/work-items/ORCH-111/06-adr/ADR-001-watchdog-orphan-test-process-alert.md`, сквозной `docs/architecture/adr/adr-0041-watchdog-orphan-test-process-alert.md`.
   - **Коллектор `watchdog/collectors/proc.py` (D3):** новый stdlib-only `/proc`-скан (под `pid: host` контейнерный `/proc` отражает хост-namespace) — читает `/proc/stat` (`btime`) + `os.sysconf("SC_CLK_TCK")`, итерирует числовые `/proc/<pid>`, матчит `/proc/<pid>/cmdline` по паттерну тест-класса, парсит `/proc/<pid>/stat` (поле 22 `starttime` → `age_s`, поля 14+15 `utime+stime` → `cpu_s` информационно). Строго **read-only** (никаких `os.kill`/сигналов/`subprocess`; **никогда** не читает `/proc/<pid>/environ` — секреты); **never-raise** (per-pid гонка «процесс умер между listdir и read» пропускается, top-level → `[]`); чистый разбор отделён от I/O (тестируется на фейковом `/proc`-дереве).
   - **Чистый builder `proc_signals` + синтез RECOVERY (D4):** per-entity `Signal("proc_blocking", pid)` active ⇔ `age_s > cfg.proc_age_s` (cmdline уже отфильтрована коллектором); действенный RU-`detail` (PID + возраст + усечённый фрагмент cmdline + CPU-время). Исчезновение процесса не оставляет «висящего» алерта: в `core.tick()` для каждого alerting-ключа без свежего сигнала **синтезируется** `Signal(active=False)` → существующая `decision.decide()`/`AlertState` даёт **однократный** RECOVERY и чистит состояние (никакой новой анти-спам-логики — FR-5).

CLAUDE.md

@@ -235,6 +235,94 @@ kill-switch, never-raise, fail-safe → полный цикл.
   `docs/work-items/ORCH-027/06-adr/ADR-001-coverage-gate.md`,
   `docs/architecture/adr/adr-0029-coverage-gate.md`.
 
+## Merge-gate re-test: инфра-толерантность + tree-kill + контракт re-test (ORCH-110)
+Багфикс инцидента **ORCH-109/PR #129** (bug → escalate full-cycle): локальный re-test merge-gate
+(`check_branch_mergeable`, ребро `deploy-staging → deploy`) падал по **таймауту** (516.7s-сюит упёрся
+в бюджет 600s под CPU-голоданием от **осиротевших** pytest-процессов) при зелёных CI+tester+staging →
+маршрутизировался как **код-фейл** в `_handle_merge_gate_rollback` (откат на `development` + расход
+developer-retry) → каждый retry падал так же → «Merge-gate still failing after 3 developer retries» →
+ручное вмешательство. Аддитивно, под **5 независимыми kill-switch**, never-raise, скоуп self-hosting;
+`STAGE_TRANSITIONS`/реестр `QG_CHECKS`/семантика/имя `check_branch_mergeable`/machine-verdict-ключи/
+схема БД — **байт-в-байт не тронуты** (merge-gate остаётся под-гейтом-врезкой, не новой стадией/QG);
+INV-4 (никогда push/force-push `main`) и запрет рестарта прод-контейнера — соблюдены.
+- **D1 (tree-kill, корень утечки):** новый stdlib-only leaf `src/proc_group.py`
+  (`run_in_process_group`, паттерн чистоты `serial_gate`) спавнит спавненный pytest в **отдельной
+  группе процессов** (`start_new_session`) и при таймауте убивает **всё дерево** (`os.killpg`, каскад
+  SIGTERM→grace→SIGKILL, зеркало `launcher.stop_process`, грейс = `agent_kill_grace_seconds`).
+  Используют его `merge_gate.retest_branch` И `coverage_gate.measure_coverage` (сиблинг-источник
+  утечки). Контракты возврата сохранены — меняется лишь отсутствие сирот. Fallback never-break:
+  `subprocess_tree_kill_enabled=False`/не-POSIX → прежний `subprocess.run`.
+- **D2/D3 (классификация + маршрутизация):** чистый предикат `merge_gate.classify_retest_failure`
+  различает `timeout`/`red`/`lock-busy`/`other` (scope-guard: «rebase timeout» git'а — НЕ инфра-таймаут
+  re-test). Инфра-таймаут → `_handle_merge_gate_infra_retry` (зеркало `_handle_merge_gate_defer`:
+  задача **остаётся на `deploy-staging`**, staging-deployer перезапускается с задержкой, **БЕЗ** отката
+  на `development` и **БЕЗ** developer-retry; restart-safe счётчик `_merge_infra_retry_count` по маркеру
+  `merge-gate infra-timeout retry` в `task_content`). Анти-над-толерантность (BR-6): детерминированно
+  **красный** re-test / конфликт → прежний `_handle_merge_gate_rollback`. Anti-loop: исчерпание
+  `merge_retest_infra_max_retries` (дефолт 2) → один **инфра-alert** (явно «НЕ дефект кода»,
+  кликабельный номер), задача НЕ уходит в `development`. Kill-switch `merge_retest_infra_tolerance_enabled`
+  off → таймаут = прежний rollback (байт-в-байт).
+- **D4 (контракт необходимости re-test):** при `premerge_rebase_always=True` re-test **пропускается**,
+  когда rebase — доказанный no-op (`merge_gate.head_sha` до==после, обе непусты = ветка уже содержит
+  свежий `origin/main`, тот же коммит уже прошёл CI+tester+staging) → лиз HELD, без re-test. Распространяет
+  на путь `=True` ту же оптимизацию, что путь `=False` уже имеет для не-behind ветки. Fail-safe: любая
+  неопределённость (`head_sha` пуст / git-ошибка) → re-test **выполняется** (BR-6/AC-3 не ослаблен).
+  Kill-switch `merge_retest_skip_when_current_enabled`.
+- **D5 (бюджет):** `merge_retest_timeout_s` 600 → **900** (запас 74% над 516.7s) + валидация
+  `_resolve_retest_timeout` (малформ/непозитив → дефолт 900 + WARNING). Сквозной инвариант ORCH-065/109
+  `reaper_max_running_s (5400) > Σ(deploy-staging gate-work)+grace (≈4460)` соблюдён **без** правки
+  `reaper_max_running_s`.
+- **D6 (наблюдаемость):** in-process счётчики (`_MERGE_GATE_COUNTERS`) + read-only блок `merge_gate` в
+  `GET /queue` (отличим от код-фейл-отката); координация с ORCH-111 (`proc_blocking`) без дубля (ORCH-110
+  предотвращает/толерирует у источника, ORCH-111 наблюдает). Append-only regression-guard:
+  `("ORCH-110", "classify_retest_failure", "src/merge_gate.py")` в `MAIN_REGRESSION_MARKERS`.
+- **Флаги** (`config.py`, дефолт = боевое): `subprocess_tree_kill_enabled`/
+  `merge_retest_infra_tolerance_enabled`/`merge_retest_infra_max_retries`/`merge_retest_infra_retry_delay_s`/
+  `merge_retest_skip_when_current_enabled` (env `ORCH_*`). Откат = выставить 4 kill-switch в `False` +
+  `ORCH_MERGE_RETEST_TIMEOUT_S=600` → байт-в-байт до-ORCH-110. Детали —
+  `docs/work-items/ORCH-110/06-adr/ADR-001-merge-gate-retest-infra-tolerance-and-tree-kill.md`, сквозной
+  `docs/architecture/adr/adr-0042-merge-gate-retest-infra-tolerance-and-tree-kill.md`.
+
+## Гигиена shared deploy-базы: устойчивый self-deploy `git pull` (ORCH-112)
+Багфикс инцидента **ORCH-111** (bug → escalate full-cycle): прод-self-deploy падал на шаге
+`git pull origin main` хост-хука (`scripts/orchestrator-deploy-hook.sh`) с `error: Your local changes
+to the following files would be overwritten by merge: src/config.py` — грязь, оставленная
+неуспешной/отменённой/брошенной задачей ORCH-104 в **общем** main checkout (`settings.deploy_host_repo_path`).
+Деплой вставал → ручное вмешательство; на self-hosting (один прод-инстанс на все проекты) — групповой
+риск. **Инвариант (нормативно):** shared main checkout `<host_repos_dir>/<repo>` — **deploy/worktree-management
+база, НЕ редактируемый workspace** (агенты — worktree `git_worktree`, build — worktree-контекст, fallback'и
+гейтов — read-only `git show origin/main`); локальных правок там быть не должно. Решение — **resilient-pull,
+встроенный в хук** (`--deploy`): перед `git pull` хук при грязи приводит базу к чистому актуальному
+`origin/main` (`git fetch` + `git reset --hard origin/main` + **скоупленный** `git clean -fd`). Аддитивно,
+под kill-switch, never-raise, скоуп self-hosting; `STAGE_TRANSITIONS` / реестр `QG_CHECKS` / семантика и
+имена `check_*` / machine-verdict-ключи / схема БД / exit-code-контракт хука (0/1/2, ORCH-036) — **байт-в-байт
+не тронуты** (это устойчивость deploy-пути, **не** Quality Gate и **не** стадия).
+- **Leaf `src/checkout_hygiene.py` (чистый never-raise):** по образцу `serial_gate`/`cancel`/`self_deploy`
+  (импортирует только `config`, лениво `self_deploy`/`qg.checks`/`notifications`) — `applies(repo)`
+  (kill-switch `checkout_hygiene_enabled` + скоуп `checkout_hygiene_repos`, **пусто → self-hosting only**,
+  локально и ПЕРВЫМ), `hook_env(repo, work_item_id)` (env-префикс `CHECKOUT_HYGIENE=1 HYGIENE_REPORT=<host-path>`,
+  инжектится в detached-команду `self_deploy.build_deploy_command` только при `applies==True`, иначе `""` →
+  хук видит `CHECKOUT_HYGIENE` неустановленным → голый `git pull` 1:1 до ORCH-112), `read_report`/`alert_dirty`
+  (наблюдаемость), `snapshot()` (read-only блок `GET /queue`).
+- **Хук-блок «2a. Resilient pull»:** между шагом «1. Capture PREV_IMG» и «2. Pull», под
+  `if [[ "${CHECKOUT_HYGIENE:-0}" == "1" ]]`. **Сохранность (NFR-2, жёсткий контракт):** `git clean` —
+  **только `-fd`, НИКОГДА `-x`** (иначе удалил бы gitignored `.env`/прод-секреты, `data/*.db`/БД, `build/`);
+  явные `-e '.deploy-prev-image-*'` и `-e 'deploy-hook.log'` (untracked-но-НЕ-ignored — иначе сломался бы
+  rollback `do_rollback`); sibling `<repos_dir>/.deploy-state-*`/`.merge-lease-*.json` и `.git/worktrees/*` —
+  вне области `git clean` в `$REPO`. Каждый git-шаг — `|| log "...continuing"` (never-break): сбой гигиены не
+  ухудшает исход относительно голого pull; чистая база → no-op (happy-path/exit-коды байт-в-байт);
+  `--build-staging` (build из worktree, без pull) не затронут.
+- **Сходимость после failed/cancelled (FR-2)** — этим же deploy-time self-heal (база сходится на следующем же
+  self-deploy); `cancel_task` (ORCH-090) **не расширяется**, фоновый janitor **не вводится**.
+  **Наблюдаемость (FR-4)** — хук пишет sentinel `hygiene`; Phase-C finalizer (`stage_engine.run_deploy_finalizer`)
+  читает (`read_report`) и шлёт Telegram-алерт (`alert_dirty`, кликабельный номер, best-effort, never-raise).
+- **Флаги** (`config.py`, дефолт = боевое): `checkout_hygiene_enabled` (env `ORCH_CHECKOUT_HYGIENE_ENABLED`),
+  `checkout_hygiene_repos` (env `ORCH_CHECKOUT_HYGIENE_REPOS`). Откат = `ORCH_CHECKOUT_HYGIENE_ENABLED=false` →
+  деплой байт-в-байт до ORCH-112. Покрытие — `tests/test_deploy_checkout_hygiene.py` (шелл-симуляция реального
+  хука во временном git-репо без сети/прода/ssh + unit; TC-01 — обязательный регресс ORCH-111: красный до
+  фикса, зелёный после). Детали — `docs/work-items/ORCH-112/06-adr/ADR-001-deploy-base-checkout-hygiene.md`,
+  сквозной `docs/architecture/adr/adr-0044-deploy-base-checkout-hygiene.md`.
+
 ## Машинный журнал уроков (ORCH-098)
 Шаг 1 («Фундамент», F2) эпика саморазвития: формализует свободнотекстовые «уроки» из `memory/` в
 **машинную структурированную таблицу отклонений конвейера** `lessons`, фундамент для будущих

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`/схема БД не тронуты.
 - **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<max`→`queued`, иначе `failed`+Telegram). Атомарный reap-claim (guard `status='running'`) совместим со стартовым `requeue_running_jobs`. Тот же поток периодически делает проактивный реклейм stale/dead merge-lease (см. ниже). never-raise; kill-switch `ORCH_REAPER_ENABLED`; снимок в `GET /queue` (блок `reaper`).
+- **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<max`→`queued`, иначе `failed`+Telegram). Атомарный reap-claim (guard `status='running'`) совместим со стартовым `requeue_running_jobs`. Тот же поток периодически делает проактивный реклейм stale/dead merge-lease (см. ниже). never-raise; kill-switch `ORCH_REAPER_ENABLED`; снимок в `GET /queue` (блок `reaper`). **ORCH-113 ([adr-0043](adr/adr-0043-reaper-finalizer-liveness-ownership.md)):** на ребре `deploy-staging → deploy` тяжёлые edge-под-гейты (security/merge-gate re-test/coverage/image-freshness) исполняются в потоке монитора **после** штампа `finished_at` и **до** `_finalize_job` — минуты, а Tier-2 `finished_age_s` меряется от `finished_at`, поэтому живой долго финализирующий монитор ошибочно реапился (инцидент ORCH-111: повторный re-test → ложный откат `deploy-staging → development` параллельно успешному deploy). Фикс — процесс-локальный реестр владения финализацией (leaf `src/finalizer_liveness.py`, never-raise): монитор `mark()`/`clear()` (try/finally), reaper в Tier-2 при `stage=="deploy-staging"` И активном владении делает **defer** (не повторяет advance); Tier-3 backstop маркер игнорирует (мёртвый/застрявший finalizer добивается в ограниченное время). In-memory restart-safe через `requeue_running_jobs` (вызов до старта reaper); схема БД, `reaper_finalize_grace_s`/`reaper_max_running_s` и сквозной бюджет не тронуты. Kill-switch `ORCH_REAPER_FINALIZER_LIVENESS_ENABLED`.
 - **Reconciler** (`src/reconciler.py`, ORCH-053 — реализовано, [adr-0007](adr/adr-0007-reconciler.md)) — фоновый daemon-поток (паттерн `queue_worker`), стартует/останавливается в `main.lifespan` (после `worker.start()` / перед `worker.stop()`). Реконсилирует рассинхрон «источник истины ≠ стадия задачи» при потерянном webhook. F-1 gate-side (продвигает застрявшую стадию по локальной БД через штатный `advance_stage(..., finished_agent=None)`), F-2 plane-side (опрос Plane API → `handle_*` из `plane.py`), F-3 (БД-fallback `sha→branch` в `handle_ci_status`). Источник истины — гейт/Plane, не событие; идемпотентность (active-job guard + atomic-claim + grace); kill-switch `ORCH_RECONCILE_ENABLED`. `analysis` F-1 не трогает (человеческий гейт). F-1 также пропускает escalated (retry≥лимита) и Blocked/Needs-Input задачи (ORCH-060). Наблюдаемость — блок `reconcile` в `GET /queue`.
 - **Disk-watchdog** (`src/disk_watchdog.py`, ORCH-063 — [adr-0024](adr/adr-0024-disk-watchdog.md)) — фоновый daemon-поток (каркас `reconciler`/`job_reaper`), стартует/останавливается в `main.lifespan` (старт последним — после `reaper.start()`; стоп первым в reverse-порядке; гард `disk_monitor_enabled`). Каждые `disk_monitor_interval_s` (дефолт 300с) меряет заполнение **хост-ФС** по смонтированным bind-путям (`/repos`, `/app/data`) через stdlib `shutil.disk_usage` (не overlay `/` контейнера, не субпроцесс `df`; дедуп путей по `st_dev`). Решение об алерте — pure-функция `decide_action(used_pct, threshold, prev_state, now, realert_s)`: алерт на пересечении порога (дефолт **85%**), cooldown-повтор `disk_monitor_realert_s` (анти-спам, не на каждом тике), однократный recovery при возврате ниже порога. Алерт — `send_telegram` (notifying, best-effort). Состояние анти-спама — in-memory (без миграции БД). never-raise (per-path/per-tick/per-send); только читает и уведомляет — не трогает диск/контейнер, не рестартит прод (self-hosting безопасность). Kill-switch `ORCH_DISK_MONITOR_ENABLED`; снимок — блок `disk_monitor` в `GET /queue` (`enabled`/`threshold_pct`/`interval_s`/`realert_s`/`paths`[`used_pct`/`free_gb`/`alerting`/`last_alert_at`]). `STAGE_TRANSITIONS`/`QG_CHECKS`/схема БД — не тронуты. Детали — `docs/work-items/ORCH-063/06-adr/ADR-001-disk-watchdog.md`.
 - **Build-cache-pruner** (`src/build_cache_pruner.py`, ORCH-062 — [adr-0025](adr/adr-0025-build-cache-pruner.md)) — фоновый daemon-поток (каркас `disk_watchdog`), стартует/останавливается в `main.lifespan` (старт последним — после `disk_watchdog.start()`; стоп первым в reverse; гард `build_cache_prune_enabled`). «Вторая половина» disk-watchdog: **watchdog сигналит — pruner убирает**. Каждые `build_cache_prune_interval_s` (дефолт 21600с = 6ч) выполняет **строго `docker builder prune -f --filter until=<until>`** (BuildKit GC; дефолт `until=24h` — удаляет build cache старше суток, тёплый кэш сохраняет; `-a` опционально, только в паре с фильтром). Затрагивает **только** build cache — НЕ образы/контейнеры; рестарт docker daemon/прода не выполняется (self-hosting безопасность). В контейнере нет `docker` CLI (`Dockerfile:11`), поэтому уборка идёт **на хосте через ssh** каналом `deploy_ssh_user@deploy_ssh_host` (как `image_freshness`/`self_deploy`); пустой `deploy_ssh_host` → тик no-op (скоуп на self-host). never-raise (per-команда/per-tick); учёт результата in-memory (без миграции БД). Kill-switch `ORCH_BUILD_CACHE_PRUNE_ENABLED`; снимок — блок `build_cache_prune` в `GET /queue` (`enabled`/`interval_s`/`until`/`last_run_ts`/`last_reclaimed`/`last_error`). `STAGE_TRANSITIONS`/`QG_CHECKS`/схема БД — не тронуты. Детали — `docs/work-items/ORCH-062/06-adr/ADR-001-build-cache-pruner.md`.
@@ -447,13 +447,50 @@ Self-hosting зацикливался на `deploy-staging`: `scripts/staging_ch
 Назначение: ветка валидируется относительно того `main`, из которого создана; параллельная задача могла уйти вперёд → семантический конфликт слияния (зелёная ветка ломает обновлённый `main`). Merge-gate гарантирует проверку против **актуального** `origin/main` перед слиянием:
 - **Догон:** ветка отстаёт (⇔ `origin/main` не предок HEAD) → `rebase origin/main` в worktree + `push --force-with-lease` (ТОЛЬКО ветка задачи; `main` — никогда). Текстовый конфликт → `rebase --abort` → откат на `development`.
 - **Безусловный pre-merge rebase (ORCH-026, A-2):** при `premerge_rebase_always` (дефолт `True`, скоуп `merge_gate_repos`) short-circuit `branch_is_behind_main` пропускается — `auto_rebase_onto_main` вызывается **всегда** под лизом. На актуальной ветке это no-op (`rebase` не меняет HEAD, `push --force-with-lease` → «Everything up-to-date», CI не триггерится); на отстающей — реальный догон. Детерминированный структурный анти-фантом на уровне планировщика (дополняет рубежи ORCH-073, не заменяет). Kill-switch `premerge_rebase_always=False` → прежнее поведение (ребейз только при behind).
-- **Re-test:** `python -m pytest` (`merge_retest_target`, дефолт `tests/`) в worktree догнанной ветки, тайм-аут `merge_retest_timeout_s`. Красный/тайм-аут → откат на `development`.
+- **Re-test:** `python -m pytest` (`merge_retest_target`, дефолт `tests/`) в worktree догнанной ветки, тайм-аут `merge_retest_timeout_s` (ORCH-110 D5: 600 → **900**, валидация `_resolve_retest_timeout` — малформ/непозитив → дефолт 900 + WARNING). **Красный** (детерминированный сбой теста) → откат на `development` + developer-retry (без изменений). **ORCH-110 (реализовано, [adr-0042](adr/adr-0042-merge-gate-retest-infra-tolerance-and-tree-kill.md)):**
+  - **(D4) Контракт необходимости re-test:** локальный re-test исполняется лишь когда rebase реально сдвинул HEAD (`main` уехал). Доказанный **no-op** rebase (`head_sha` до==после, обе непусты — ветка уже содержит свежий `origin/main`, HEAD уже прошёл CI+tester+staging) **пропускает** re-test (`(True, "branch up-to-date (re-test skipped: rebase no-op, HEAD CI-validated)")`, лиз HELD) — распространяет на путь `premerge_rebase_always=True` ту же оптимизацию, что путь `=False` уже имеет для не-behind ветки. Fail-safe: любая неопределённость (`head_sha` пуст / git-ошибка) → re-test **выполняется**. Kill-switch `merge_retest_skip_when_current_enabled`.
+  - **(D2/D3) Толерантность к инфра-таймауту:** предикат `classify_retest_failure(reason)` различает `timeout`/`red`/`lock-busy`/`other`. **Таймаут** re-test = инфра-транзиент → `_handle_merge_gate_infra_retry` (ограниченный повтор по образцу defer: задача **остаётся на `deploy-staging`**, staging-deployer перезапускается с задержкой `merge_retest_infra_retry_delay_s`, **БЕЗ** отката на `development` и **БЕЗ** расхода developer-retry), а НЕ прежний rollback. Исчерпание `merge_retest_infra_max_retries` → один **инфра-alert** (явно «НЕ дефект кода», кликабельный номер), задача НЕ уходит в `development`. Анти-над-толерантность (BR-6): **красный** re-test / конфликт по-прежнему откатывают. Scope-guard: «rebase timeout» (git завис) — НЕ инфра-таймаут re-test, остаётся на rollback-пути. Kill-switch `merge_retest_infra_tolerance_enabled` (off → таймаут=прежний rollback).
+  - **(D1) Tree-kill спавненных pytest:** re-test (и coverage `measure_coverage`) бегут через `proc_group.run_in_process_group` в **отдельной группе процессов** (`start_new_session`); при таймауте убивается **всё дерево** (`os.killpg`, каскад SIGTERM→grace→SIGKILL, грейс = `agent_kill_grace_seconds`) — осиротевшие внуки-pytest не переживают бюджет (корень CPU-голодания инцидента ORCH-109). Контракты возврата сохранены. Fallback never-break: `subprocess_tree_kill_enabled=False`/не-POSIX → прежний `subprocess.run`. Наблюдаемость — блок `merge_gate` в `GET /queue`; координация с ORCH-111 (`proc_blocking`) без дубля.
 - **Сериализация (merge-lock):** файловый **merge-lease** на репо (`<repos_dir>/.merge-lease-<repo>.json`), живёт от гейта до фактического merge. Acquire **неблокирующий** (anti-deadlock при `max_concurrency=1`): busy → **defer** (повторная постановка deployer'а на `deploy-staging` с задержкой через `available_at`), а не откат. Release — на PR-merged вебхуке / `deploy→done` / откате / по возрасту (crash-реклейм). Restart-safe; без изменения схемы БД. **ORCH-026 (A-1):** это окно = «merge → main-updated» (для self `done` ⇔ SHA-in-main, ORCH-073) — пока A не в `main`, B того же репо получает `merge-lock busy` → defer. Окно сериализации per-repo НЕ переписывается; кросс-репо параллелизм сохранён (лиз — per-repo файл).
 - **Условность (как ORCH-35):** реален для `orchestrator`; прочие репо — no-op. Флаги `merge_gate_enabled` / `merge_gate_repos` — поэтапный раскат. Контракт **never-raise**.
 
 Подробнее: [adr-0006](adr/adr-0006-merge-gate.md), детально — `docs/work-items/ORCH-043/06-adr/ADR-001-merge-gate.md`.
 Безусловный pre-merge rebase + связь с зависимостями задач — [adr-0015](adr/adr-0015-task-deps-and-merge-serialization.md) (ORCH-026).
 
+#### Merge-gate re-test: толерантность к инфра-таймауту + tree-kill + контракт re-test (ORCH-110 — design)
+Инцидент ORCH-109/PR#129: при зелёном tester `PASS` (1899 passed / 516.7s), зелёном CI и актуальной
+ветке локальный re-test merge-gate упал по **таймауту** (600s) из-за CPU-голодания от **осиротевших**
+pytest-процессов (жили > 2 суток). Таймаут классифицировался как код-фейл → ложный откат
+`deploy-staging → development` + 3 сожжённых developer-retry → manual-gate. ORCH-110 бьёт по двум
+корням, одному контракту и бюджету — **аддитивно, под kill-switch, never-raise, скоуп self-hosting**;
+исходная защита merge-gate от семантического конфликта сохранена (красный re-test по-прежнему
+откатывает). `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_*`/machine-verdict/схема БД — **не тронуты**.
+- **Tree-kill (root, D1):** новый leaf `src/proc_group.py::run_in_process_group` спавнит
+  оркестратор-порождённые pytest-прогоны (`merge_gate.retest_branch` + `coverage_gate.measure_coverage`)
+  в отдельной группе процессов (`start_new_session`) и при таймауте/прерывании убивает **всё дерево**
+  (`os.killpg`, каскад SIGTERM→grace→SIGKILL, зеркало `launcher.stop_process`). Контракты возврата 1:1
+  (меняется лишь побочный эффект — нет сирот); fallback на прежний `subprocess.run` при kill-switch off
+  / не-POSIX. Kill-switch `subprocess_tree_kill_enabled`.
+- **Классификация + маршрутизация (D2/D3):** чистый `merge_gate.classify_retest_failure(reason) →
+  timeout|red|lock-busy|other`; инфра-таймаут → `_handle_merge_gate_infra_retry` (ограниченный
+  повтор/defer по образцу `_handle_merge_gate_defer`, **без** отката на `development`, **без** расхода
+  developer-retry; исчерпание → отдельный **инфра-alert**, не «developer must fix»); красный re-test →
+  прежний `_handle_merge_gate_rollback`. Kill-switch `merge_retest_infra_tolerance_enabled`, бюджеты
+  `merge_retest_infra_max_retries` (2) / `merge_retest_infra_retry_delay_s` (120s).
+- **Контракт re-test (D4):** локальный re-test исполняется ⇔ rebase реально сдвинул HEAD; доказанный
+  no-op rebase пропускает re-test (как уже делает путь `premerge_rebase_always=False` для не-behind
+  ветки), offline, без сетевого CI-запроса; fail-safe — на неопределённости re-test бежит. Kill-switch
+  `merge_retest_skip_when_current_enabled`.
+- **Бюджет (D5):** `merge_retest_timeout_s` 600 → 900 (запас 74% над 516.7s) + валидация (непозитив →
+  дефолт + WARNING); сквозной инвариант `reaper_max_running_s (5400) > Σ(deploy-staging gate-work
+  ≈4460)+grace` проверен — `reaper_max_running_s` **не меняется**.
+- **Наблюдаемость (D6):** счётчики + блок `merge_gate` в `GET /queue`; координация с ORCH-111
+  (`proc_blocking`, adr-0041) без дубля: ORCH-110 предотвращает/толерирует у источника, ORCH-111
+  наблюдает.
+
+Подробнее: [adr-0042](adr/adr-0042-merge-gate-retest-infra-tolerance-and-tree-kill.md), детально —
+`docs/work-items/ORCH-110/06-adr/ADR-001-merge-gate-retest-infra-tolerance-and-tree-kill.md`.
+
 ### Coverage-гейт: защита от деградации покрытия тестами (ORCH-027 — design)
 Существующие тестовые гейты (`check_ci_green`, `check_tests_passed`, merge-gate re-test) судят
 только по факту прохождения тестов, не по **полноте** — фича «300 строк, 0 тестов» проходит
@@ -705,6 +742,40 @@ sentinel-файлы (`<repos_dir>/.deploy-state-<repo>/<wi>/`), без мигр
 Подробнее: [adr-0007](adr/adr-0007-executable-self-deploy.md), детально —
 `docs/work-items/ORCH-036/06-adr/ADR-001-executable-self-deploy.md`.
 
+#### Гигиена shared deploy-базы: устойчивый self-deploy `git pull` (ORCH-112 — design)
+**Инвариант (нормативно):** shared main checkout `<host_repos_dir>/<repo>`
+(= `settings.deploy_host_repo_path` = `/home/slin/repos/orchestrator`) — это
+**deploy/worktree-management база, НЕ редактируемый workspace.** Рабочие изменения туда
+**не пишутся** конвейером/агентами: агенты работают в worktree'ах `/repos/_wt/<repo>/<branch>`
+(`git_worktree.ensure_worktree`), `docker build` берёт контекст worktree
+(`image_freshness._host_worktree_path`), fallback'и гейтов на main clone — только чтение
+(`git show origin/main:...`). Локальные правки в deploy-базе по определению существовать не должны.
+
+**Проблема (инцидент ORCH-111 от грязи ORCH-104):** хук `scripts/orchestrator-deploy-hook.sh`
+делал **голый** `git pull origin main` в `$REPO` без гигиены рабочего дерева → любая локальная правка
+tracked-файла (`src/config.py`) блокировала merge → деплой падал → ручное вмешательство (групповой риск
+self-hosting). **Решение** — **resilient-pull, встроенный в хук** (`--deploy`): перед `git pull` хук
+при обнаружении грязи приводит базу к чистому актуальному `origin/main`
+(`git fetch` + `git reset --hard origin/main` + **скоупленный** `git clean -fd`). Гейт — env
+`CHECKOUT_HYGIENE`, инжектится `self_deploy.build_deploy_command` когда новый чистый never-raise leaf
+`src/checkout_hygiene.py`-`applies(repo)` истинен (kill-switch `checkout_hygiene_enabled` + скоуп
+`checkout_hygiene_repos`, пусто → self-hosting only).
+- **Сохранность (NFR-2, жёсткий контракт):** `git clean` — **только `-fd`, НИКОГДА `-x`** (иначе
+  удалит gitignored `.env`/прод-секреты, `data/*.db`/БД, `build/`); явные `-e '.deploy-prev-image-*'`
+  и `-e 'deploy-hook.log'` (untracked-но-НЕ-ignored — иначе сломается rollback `do_rollback`).
+  Sibling `<repos_dir>/.deploy-state-*` / `.merge-lease-*.json` (под родителем `$REPO`) и
+  `.git/worktrees/*` (внутри `.git/`) — вне области `git clean` в `$REPO`.
+- **Сходимость после failed/cancelled** — этим же deploy-time self-heal (база сходится на следующем
+  деплое); `cancel_task` (ORCH-090) **не расширяется**, фоновый janitor **не вводится**.
+- **Наблюдаемость** — хук пишет sentinel `hygiene` в deploy-state каталог; Phase-C finalizer читает и
+  шлёт Telegram-алерт (кликабельный номер, best-effort, never-raise).
+- **Чистая база / kill-switch off** — голый fast-forward `git pull` байт-в-байт (happy-path без
+  регресса); `--build-staging` (build из worktree, без pull) не затронут. `STAGE_TRANSITIONS` / реестр
+  `QG_CHECKS` / `check_*` / machine-verdict / схема БД / exit-code-контракт хука (0/1/2) — не тронуты.
+
+Детально — `docs/work-items/ORCH-112/06-adr/ADR-001-deploy-base-checkout-hygiene.md`, сквозной
+[adr-0044](adr/adr-0044-deploy-base-checkout-hygiene.md).
+
 #### Выделенный статус-триггер прод-деплоя «Confirm Deploy» (ORCH-059 — реализовано)
 Перегрузка: один Plane-статус `Approved` служил И человеческим гейтом BRD на
 `analysis` (`check_analysis_approved`), И триггером Фазы B прод-деплоя на `deploy`
@@ -1134,7 +1205,15 @@ ORCH-065 вводит фоновый watchdog, чтобы смерть проц
   затем git push/PR/Plane-комментарии), поэтому Tier-2 реапит только после
   finalization-grace `reaper_finalize_grace_s` (живой финализирующий monitor НЕ
   реапится); Tier-3 backstop по потолку `reaper_max_running_s` (> max
-  agent_timeout+grace). Действие переиспользует контракты по принципу
+  agent_timeout+grace). **ORCH-113 (adr-0043):** на ребре `deploy-staging → deploy`
+  финализация в потоке монитора длится **минуты** (тяжёлые edge-под-гейты
+  security/merge-gate re-test/coverage/image-freshness идут после штампа
+  `finished_at` и до `_finalize_job`), а grace=300 это не покрывал → живой долгий
+  finalizer ошибочно реапился и независимо повторял advance (ложный откат,
+  инцидент ORCH-111). Tier-2 теперь консультирует процесс-локальный реестр владения
+  (`src/finalizer_liveness.py`): при `stage=="deploy-staging"` И активном владении —
+  **defer** (не повторяет advance), Tier-3 backstop маркер игнорирует. In-memory,
+  restart-safe через `requeue_running_jobs`; grace/потолок и бюджет не меняются. Действие переиспользует контракты по принципу
   **claim-before-act**: для exit0 канонический QG оценивается read-only ПЕРЕД
   атомарным claim, затем claim `done` ПЕРВЫМ и только победитель claim делает
   `_try_advance_stage` (advance+enqueue) — проигравший claim (поздний monitor /
@@ -1166,11 +1245,15 @@ ORCH-065 вводит фоновый watchdog, чтобы смерть проц
   `logger.warning`; reap→`failed` и lease-reclaim → Telegram.
 - **Kill-switch'и:** `ORCH_REAPER_ENABLED`, `ORCH_REAPER_INTERVAL_S`,
   `ORCH_REAPER_DEAD_TICKS`, `ORCH_REAPER_MAX_RUNNING_S`,
-  `ORCH_REAPER_FINALIZE_GRACE_S`, `ORCH_LEASE_RECLAIM_ENABLED`; `false` → строго
-  прежнее поведение.
+  `ORCH_REAPER_FINALIZE_GRACE_S`, `ORCH_LEASE_RECLAIM_ENABLED`,
+  `ORCH_REAPER_FINALIZER_LIVENESS_ENABLED` (ORCH-113); `false` → строго прежнее
+  поведение.
 
-Подробнее: [adr-0011](adr/adr-0011-job-reaper-lease-reclaim.md), детально —
-`docs/work-items/ORCH-065/06-adr/ADR-001-job-reaper-and-lease-reclaim.md`.
+Подробнее: [adr-0011](adr/adr-0011-job-reaper-lease-reclaim.md) +
+[adr-0043](adr/adr-0043-reaper-finalizer-liveness-ownership.md) (ORCH-113,
+finalizer-liveness ownership); детально —
+`docs/work-items/ORCH-065/06-adr/ADR-001-job-reaper-and-lease-reclaim.md`,
+`docs/work-items/ORCH-113/06-adr/ADR-001-reaper-finalizer-liveness-ownership.md`.
 
 ### Осмысленная статусная модель Plane (ORCH-066 — реализовано)
 Plane-доска была семантически перегружена: `In Progress` означал «человек запускает

docs/architecture/adr/adr-0042-merge-gate-retest-infra-tolerance-and-tree-kill.md

@@ -0,0 +1,84 @@
+---
+work_item: ORCH-110
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# adr-0042: Merge-gate re-test — толерантность к инфра-таймауту + tree-kill спавненных процессов + контракт re-test
+
+- **Статус:** proposed
+- **Дата:** 2026-06-15
+- **Задача:** ORCH-110 (bug → escalate full-cycle)
+- **Детальный ADR:** `docs/work-items/ORCH-110/06-adr/ADR-001-merge-gate-retest-infra-tolerance-and-tree-kill.md`
+- **Парные/смежные ADR:** `adr-0006` (merge-gate ORCH-043), `adr-0040` (timeout-бюджеты ORCH-109),
+  `adr-0029` (coverage-gate ORCH-027), `adr-0011` (reaper/lease ORCH-065),
+  `adr-0041` (ORCH-111 `proc_blocking` — комплементарный наблюдатель)
+
+## Контекст
+
+Merge-gate (ORCH-043) на ребре `deploy-staging → deploy` локально пере-прогоняет тест-сюит
+(`retest_branch`) для защиты от семантического конфликта слияния. Инцидент ORCH-109/PR#129: при
+зелёном tester `PASS` (1899 passed / 516.7s), зелёном CI и актуальной ветке re-test упал по
+**таймауту** (600s) из-за CPU-голодания от **осиротевших** pytest-процессов, переживших > 2 суток.
+Таймаут классифицировался как код-фейл → откат `deploy-staging → development` + 3 сожжённых
+developer-retry → manual-gate. Корни: (1) `subprocess.run(timeout=)` убивает только прямого потомка —
+внуки pytest репарентируются на PID 1 и живут (в `merge_gate.retest_branch` и
+`coverage_gate.measure_coverage`); (2) нет толерантности к инфра-таймауту; (3) тонкий бюджет (≈16%);
+(4) избыточный re-test на уже актуальной ветке (`premerge_rebase_always=True` форсит rebase+retest
+даже на no-op rebase).
+
+Решение кросс-каттинговое: затрагивает merge-gate, coverage-gate и сквозной инвариант времени
+reaper/lease — поэтому регистрируется глобально.
+
+## Решение (сводка)
+
+Аддитивно, под kill-switch, never-raise, скоуп self-hosting; исходная защита merge-gate от
+семантического конфликта сохранена (красный re-test по-прежнему откатывает).
+
+- **D1 — tree-kill.** Новый leaf `src/proc_group.py::run_in_process_group` спавнит
+  оркестратор-порождённые pytest-прогоны в отдельной группе процессов (`start_new_session`) и при
+  таймауте убивает **всё дерево** (`os.killpg`, каскад SIGTERM→grace→SIGKILL, зеркало
+  `launcher.stop_process`). Используют `retest_branch` и `measure_coverage`; контракты возврата 1:1,
+  меняется лишь побочный эффект (нет сирот). Fallback на прежний `subprocess.run` при kill-switch off
+  / не-POSIX. Kill-switch `subprocess_tree_kill_enabled`.
+- **D2 — классификация.** Чистый `merge_gate.classify_retest_failure(reason) → timeout|red|lock-busy|
+  other`; `check_branch_mergeable` не меняет имя/семантику/PASS-FAIL (реестр `QG_CHECKS` цел).
+- **D3 — маршрутизация.** Инфра-таймаут → `_handle_merge_gate_infra_retry` (ограниченный повтор/defer
+  по образцу `_handle_merge_gate_defer`, **без** отката на `development`, **без** расхода
+  developer-retry); исчерпание → отдельный **инфра-alert** (не «developer must fix»). Красный re-test
+  → прежний `_handle_merge_gate_rollback`. Kill-switch `merge_retest_infra_tolerance_enabled`,
+  бюджеты `merge_retest_infra_max_retries`/`merge_retest_infra_retry_delay_s`.
+- **D4 — контракт re-test.** Локальный re-test исполняется ⇔ rebase реально сдвинул HEAD (`main`
+  уехал); доказанный no-op rebase пропускает re-test (как уже делает путь
+  `premerge_rebase_always=False` для не-behind ветки), offline, без сетевого CI-запроса. Fail-safe: на
+  любой неопределённости re-test бежит. Kill-switch `merge_retest_skip_when_current_enabled`.
+- **D5 — бюджет.** `merge_retest_timeout_s` 600 → 900 (запас 74%) + валидация (непозитив → дефолт +
+  WARNING). Сквозной инвариант `reaper_max_running_s (5400) > Σ(deploy-staging gate-work ≈4460)+grace`
+  проверен — `reaper_max_running_s` **не меняется**.
+- **D6 — наблюдаемость.** Счётчики `merge_gate` + блок `merge_gate` в `GET /queue`; координация с
+  ORCH-111 без дубля (ORCH-110 предотвращает/толерирует у источника, ORCH-111 наблюдает).
+
+## Инварианты (неприкосновенны)
+
+- `STAGE_TRANSITIONS` / реестр `QG_CHECKS` / семантика `check_*` / machine-verdict ключи / схема БД —
+  **байт-в-байт** (под-гейт — врезка в `advance_stage`, не новая стадия/QG; новых таблиц/колонок нет).
+- INV-4: никогда push/force-push `main`, merge только через Gitea PR API; прод-контейнер не
+  рестартится; detached-деплой не трогается.
+- never-raise во всех новых функциях/врезках; исключение не уходит в `advance_stage`/монитор.
+- Kill-switch + нулевая регрессия: каждый флаг off → байт-в-байт до-ORCH-110; enduro (non-self) — no-op.
+
+## Последствия
+
+- **+** Устранён ложный откат/manual-gate при инфра-таймауте; устранена утечка CPU от сирот;
+  re-test не избыточен на актуальной ветке.
+- **−** До ~34 мин на инфра-ретраи перед alert (вместо мгновенного ложного отката); +5 конфиг-ключей.
+- **Откат:** вернуть 4 kill-switch и `merge_retest_timeout_s=600`.
+
+## Ссылки
+- Детально: `docs/work-items/ORCH-110/06-adr/ADR-001-merge-gate-retest-infra-tolerance-and-tree-kill.md`
+- Код: `src/merge_gate.py`, `src/coverage_gate.py`, `src/qg/checks.py`, `src/stage_engine.py`,
+  `src/config.py`, `src/agents/launcher.py`, `src/job_reaper.py`, новый `src/proc_group.py`
+</content>

docs/architecture/adr/adr-0043-reaper-finalizer-liveness-ownership.md

@@ -0,0 +1,95 @@
+---
+work_item: ORCH-113
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# adr-0043: Reaper Tier-2 — in-memory ownership-маркер финализации `deploy-staging` (живой finalizer не реапится)
+
+- **Статус:** proposed
+- **Дата:** 2026-06-15
+- **Задача:** ORCH-113 (bug → escalate full-cycle; кластер инцидента ORCH-111)
+- **Детальный ADR:** `docs/work-items/ORCH-113/06-adr/ADR-001-reaper-finalizer-liveness-ownership.md`
+- **Уточняет:** `adr-0011` (job-reaper/lease-reclaim ORCH-065), `adr-0040` (timeout-бюджеты ORCH-109),
+  `adr-0042` (merge-gate re-test infra-tolerance + tree-kill ORCH-110), `adr-0041`
+  (ORCH-111 `proc_blocking` — комплементарный наблюдатель того же инцидента)
+
+## Контекст
+
+На ребре `deploy-staging → deploy` живой монитор (`launcher._monitor_agent`) штампит
+`agent_runs.finished_at`/`exit_code` **первым**, затем синхронно, в своём потоке, прогоняет тяжёлый
+набор edge-под-гейтов через `_try_advance_stage → advance_stage` (`stage_engine.py:327–368`):
+`security` → `merge-gate` (полный локальный re-test, `merge_retest_timeout_s=900`) → `coverage`
+(`pytest --cov`) → `image-freshness` (docker-rebuild + пересоздание staging) — **минуты**, — и лишь
+потом `_finalize_job`. Reaper Tier-2 (`job_reaper.py:197–209`) меряет `finished_age_s` от
+`finished_at` = **начала** финализации и по `reaper_finalize_grace_s=300` считает живого, долго
+финализирующего монитора мёртвым → независимо повторяет тот же тяжёлый advance. Атомарный
+claim-before-act защищает лишь **флип строки** job, но не **side-effectful исполнение edge-гейтов**
+(монитор не claim'ит строку перед `advance_stage`) → две `advance_stage` параллельно.
+
+Инцидент ORCH-111 (job 1914): повторный re-test красный, ложный откат `deploy-staging → development`
+(+ ложный developer-retry), **параллельно** исходный finalizer довёл deploy до SUCCESS и смержил
+PR #130 — состояние раздвоилось. Реального сигнала «жив ли finalizer» нет (pid агента в Tier-2 мёртв в
+обоих случаях). Per-stage grace, покрывающая Σ финализации (≈4160с), невозможна без нарушения сквозного
+бюджета ORCH-065/109/110 `reaper_max_running_s (5400) > Σ(deploy-staging gate-work) + grace (≈4460)`.
+
+**Решающий факт (проверен):** монитор и reaper — daemon-**потоки одного** uvicorn-процесса (CMD без
+`--workers`), общая SQLite-БД → живость finalizer'а определяется **in-memory**. Рестарт покрыт
+существующим `requeue_running_jobs()` (running→queued), вызываемым в `main.lifespan` **до** старта reaper.
+
+## Решение
+
+1. **Leaf `src/finalizer_liveness.py`** — чистый процесс-локальный реестр владения финализацией
+   (паттерн `serial_gate`/`coverage_gate`: never-raise, без сети/БД): `mark(job_id, run_id, stage)` /
+   `clear(job_id)` / `is_active(job_id) -> bool` / `snapshot()`; `{job_id: {...}}` + `threading.Lock`;
+   собственного TTL нет (ограничение по времени даёт Tier-3).
+2. **Эмиссия владения** — `launcher._monitor_agent`: `mark(...)` сразу после штампа `exit_code`
+   (самый ранний момент Tier-2), `clear(...)` в `try/finally` вокруг хвоста финализации → исключение
+   в потоке монитора гарантированно снимает владение (reaper добивает). Гибель процесса → рестарт →
+   `requeue_running_jobs` → реестр пуст (restart-safe без durable-хранения).
+3. **Консультация reaper** — `_reap_job` Tier-2 (`exit_code` записан, `finished_age >= grace`): если
+   `reaper_finalizer_liveness_enabled` **И** стадия `== "deploy-staging"` **И** `is_active(job_id)` →
+   **defer** (лог + счётчик), не реапить через Tier-2, провалиться к Tier-3. Иначе — прежний путь.
+   **Tier-3 (`age >= reaper_max_running_s`) маркер игнорирует** — добивает всегда в ограниченное время.
+4. **Скоуп/флаг** — только глобальный kill-switch `reaper_finalizer_liveness_enabled`
+   (env `ORCH_REAPER_FINALIZER_LIVENESS_ENABLED`, дефолт `True`); **без** per-repo разреза (баг общий
+   для всех репо со стадией `deploy-staging`; per-repo оставил бы баг активным для части репо).
+   `False` → reaper байт-в-байт прежний; стадии `!= deploy-staging` не консультируются.
+5. **Наблюдаемость** — счётчик `finalizer_defers_total` + размер `snapshot()` в блоке `reaper`
+   `GET /queue`; существующие ключи ответа не меняются; новых эндпоинтов нет.
+
+**Инварианты:** `STAGE_TRANSITIONS` / `QG_CHECKS` / каждый `check_*` / machine-verdict ключи / схема
+существующих таблиц — **байт-в-байт**; **нулевое** изменение схемы БД; reaper остаётся never-raise
+наблюдателем; `reaper_finalize_grace_s` и `reaper_max_running_s` **не меняются** (сквозной бюджет цел);
+фикс не рестартит прод и не пушит `main`.
+
+## Альтернативы
+- Per-stage grace, покрывающая Σ — отвергнуто (нарушает бюджет `5400 > Σ+grace`; таймер = источник бага).
+- Durable-колонка (heartbeat/owner-токен) — отвергнуто (один процесс → in-memory авторитетно; рестарт
+  покрыт requeue; блокирующий re-test не может бить heartbeat).
+- Sub-state `finalizing` в `jobs.status` — отвергнуто (меняет семантику статуса для
+  claim/requeue/reconciler/reaper — нарушение NFR-2).
+- Lease-файл на `(job, stage)` — отвергнуто (тяжелее, дублирует merge-lease, TTL = таймер-проблема).
+- Флип job из `running` до тяжёлых гейтов — отвергнуто (ломает `get_running_jobs`/метрики и
+  restart-requeue).
+
+## Последствия
+- (+) Устранены повторный прогон edge-гейтов, ложный откат и расхождение состояния при живом долгом
+  finalizer'е `deploy-staging`; идемпотентность исполнения edge-гейтов через владение.
+- (+) Реально мёртвый/застрявший finalizer добивается (finally-clear → Tier-2; иначе Tier-3); функция
+  reaper ORCH-065 сохранена.
+- (+) Нулевое изменение схемы и контрактов; сквозной бюджет ORCH-065/109/110 не тронут; откат — один
+  env-флаг.
+- (−) Гарантия владения валидна при **одном процессе/одной БД** (проверено: один uvicorn-воркер); ввод
+  `--workers>1` потребует durable-сигнала (риск в work-item 10-tech-risks).
+- (−) Окно «штамп `finished_at` → `mark()`» (git push) маркером не покрыто — закрыто прежним grace=300.
+
+## Связи
+- Базируется/уточняет: `adr-0011`, `adr-0040`, `adr-0042`, `adr-0041`.
+- Союзные задачи кластера инцидента ORCH-111: `ORCH-110` (инфра-толерантность merge-gate — отдельный
+  объём, не дублировать), `ORCH-109` (бюджеты).
+- Детально: `docs/work-items/ORCH-113/06-adr/ADR-001-reaper-finalizer-liveness-ownership.md`.
+</content>

docs/architecture/adr/adr-0044-deploy-base-checkout-hygiene.md

@@ -0,0 +1,66 @@
+---
+work_item: ORCH-112
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# adr-0044: Гигиена shared deploy-базы — устойчивый self-deploy `git pull`
+
+Сквозное (cross-cutting) решение. Детальный per-work-item ADR —
+`docs/work-items/ORCH-112/06-adr/ADR-001-deploy-base-checkout-hygiene.md`.
+
+## Статус
+Proposed (ORCH-112)
+
+## Контекст (сквозной)
+
+Глобальный путь прод-деплоя self-hosting (`deploy`-стадия, ORCH-036) исполняет хост-хук
+`scripts/orchestrator-deploy-hook.sh`, чей шаг «2. Pull latest code» — **голый** `git pull origin main`
+в shared main clone (`settings.deploy_host_repo_path`). Любая грязь рабочего дерева (модифицированный
+tracked-файл и/или untracked-остатки failed/cancelled/брошенной задачи) **блокирует** merge → деплой
+встаёт → ручное вмешательство. На self-hosting (один прод-инстанс на все проекты с общей БД/очередью)
+это **групповой риск**: залипший self-deploy орка останавливает обслуживание всех проектов
+(инцидент ORCH-111, грязь от ORCH-104).
+
+## Решение (сквозное)
+
+Вводится **resilient-pull, встроенный в прод-deploy-хук** (`--deploy`), + новый чистый never-raise
+leaf-компонент `src/checkout_hygiene.py`:
+
+- **Хук** перед `git pull origin main` приводит грязную deploy-базу к чистому актуальному `origin/main`
+  (`git fetch` + `git reset --hard origin/main` + **скоупленный** `git clean -fd`), **строго сохраняя**
+  rollback/лог-артефакты. Гейт — env `CHECKOUT_HYGIENE`, инжектится `self_deploy.build_deploy_command`.
+- **Leaf** `checkout_hygiene` решает условность (`applies(repo)`: kill-switch `checkout_hygiene_enabled`
+  + скоуп `checkout_hygiene_repos`, пусто → self-hosting only), строит env-префикс, читает sentinel
+  отчёта, шлёт Telegram-алерт. Образец `serial_gate`/`cancel`/`self_deploy`.
+- **Сходимость** базы после failed/cancelled (FR-2) — этим же deploy-time self-heal; `cancel_task`
+  (ORCH-090) **не расширяется**, фоновый janitor **не вводится**.
+- **Наблюдаемость** — хук пишет sentinel `hygiene`, Phase-C finalizer читает и шлёт Telegram-алерт
+  (best-effort, never-raise).
+- **Инвариант** «main checkout — deploy/worktree-management база, НЕ workspace» документируется
+  (INFRA.md + architecture/README.md); de-facto энфорс — сам resilient-pull.
+
+## Кросс-каттинг-инварианты (обязательны к соблюдению будущими задачами)
+
+- **INV-HYGIENE-1 (никогда `-x`):** hygiene-`git clean` — только `git clean -fd`. `-x` удалил бы
+  gitignored `.env` (прод-секреты) / `data/*.db` (БД прода) / `build/`. Анти-регресс — статический тест.
+- **INV-HYGIENE-2 (явные excludes):** `.deploy-prev-image-*` (rollback, `deploy_prod_prev_image_file`)
+  и `deploy-hook.log` — untracked-но-НЕ-ignored → обязательны `-e`-исключения; их удаление сломало бы
+  rollback.
+- **INV-HYGIENE-3 (скоуп = `$REPO`):** гигиена оперирует только рабочим деревом deploy-базы;
+  sibling `<repos_dir>/.deploy-state-*` / `.merge-lease-*.json` и `.git/worktrees/*` — вне области.
+- **Self-hosting safety (NFR-1):** никогда не трогать `main` на remote, не force-push, не рестартить
+  прод вне штатного гейта, не сносить worktree/ветки других активных задач.
+- **Нулевая регрессия (NFR-5):** `STAGE_TRANSITIONS` / реестр `QG_CHECKS` / семантика и имена `check_*` /
+  machine-verdict ключи / схема БД / exit-code-контракт хука (0/1/2, ORCH-036) — байт-в-байт. Это
+  устойчивость deploy-пути, **не** Quality Gate и **не** стадия.
+
+## Связи
+- Дополняет: adr-0007 (executable self-deploy, ORCH-036), adr-0008 (image-freshness, ORCH-058).
+- Не нарушает: adr-0026 (STOP/cancel, ORCH-090) — каскад cancel не трогается.
+
+## Откат
+`ORCH_CHECKOUT_HYGIENE_ENABLED=false` → прод-деплой байт-в-байт до ORCH-112 (голый `git pull origin main`).

docs/architecture/internals.md

@@ -385,7 +385,16 @@ daemon-поток `src/job_reaper.py` (каркас `reconciler`) периоди
   git push/PR/Plane-комментарии (секунды-десятки секунд) и лишь потом
   `_finalize_job`; pid агента к этому моменту мёртв в обоих случаях. Поэтому
   Tier-2 реапит только после finalization-grace `reaper_finalize_grace_s`
-  (`finished_age_s >= grace`) — живой финализирующий monitor НЕ реапится;
+  (`finished_age_s >= grace`) — живой финализирующий monitor НЕ реапится.
+  **ORCH-113 (adr-0043):** на ребре `deploy-staging → deploy` финализация длится
+  **минуты** (тяжёлые edge-под-гейты после штампа `finished_at`, до `_finalize_job`),
+  grace=300 это не покрывал → живой долгий finalizer ошибочно реапился и повторял
+  advance (ложный откат, инцидент ORCH-111). Tier-2 консультирует процесс-локальный
+  реестр владения `src/finalizer_liveness.py` (`mark`/`clear` в потоке монитора через
+  try/finally): при `stage=="deploy-staging"` И активном владении → **defer**;
+  Tier-3 backstop маркер игнорирует (мёртвый/застрявший finalizer добивается).
+  Kill-switch `ORCH_REAPER_FINALIZER_LIVENESS_ENABLED`; in-memory, restart-safe через
+  `requeue_running_jobs` (до старта reaper); схема БД и сквозной бюджет не тронуты;
 - **Tier-3** — backstop: job висит `running` дольше `reaper_max_running_s`.
 
 Реап атомарен (`UPDATE jobs SET ... WHERE id=? AND status='running'` + `rowcount`,

docs/operations/INFRA.md

@@ -21,6 +21,14 @@
    /repos/<project>  ← общий каталог репозиториев (host: /home/slin/repos)
 ```
 
+> **Инвариант deploy-базы (ORCH-112, нормативно).** Shared main checkout
+> `<host_repos_dir>/<repo>` (= `/home/slin/repos/orchestrator` == `/repos/orchestrator` в контейнере
+> через bind-mount == `settings.deploy_host_repo_path`) — это **deploy/worktree-management база, НЕ
+> редактируемый workspace.** Рабочие изменения туда **не пишутся** конвейером/агентами: агенты —
+> worktree `/repos/_wt/<repo>/<branch>` (`git_worktree`), `docker build` — worktree-контекст,
+> fallback'и гейтов — read-only `git show origin/main`. Self-deploy `git pull` устойчив к грязной
+> базе (resilient-pull, см. self-hosting-страховки ниже).
+
 ## Контейнеры
 
 | Контейнер | Роль | Порт | env_file | БД (хост) | Старт |
@@ -220,6 +228,7 @@ watchdog'а: **watchdog сигналит, pruner убирает**.
 **Страховки:**
 - Стадия `deploy-staging` (порт 8501) — обязательный гейт перед прод-деплоем орка. Прод-деплой недостижим, пока staging-гейт не зелёный (см. `STAGING.md`, ORCH-35). Гейт условный: реален только для self-hosting (repo=orchestrator), для остальных проектов — no-op.
 - **Свежесть staging-образа (ORCH-058):** на ребре `deploy-staging → deploy` (ПОСЛЕ merge-gate, ДО Phase A) QG-под-чек `check_staging_image_fresh` пересобирает staging-образ из валидированного коммита и пересоздаёт 8501 (Strategy A), а хук перед build-once retag fail-closed сверяет OCI-лейбл `revision` с `EXPECTED_REVISION` (Strategy B). Гарантирует: в прод промоутится РОВНО провалидированный артефакт (инцидент LESSONS_ORCH-036 п.4 — тихий промоут устаревшего образа). Сборки/recreate — ТОЛЬКО staging (8501); FAIL → откат на `development`. Условный: реален только для self-hosting.
+- **Гигиена shared deploy-базы (ORCH-112):** self-deploy `git pull origin main` устойчив к грязному рабочему дереву deploy-базы (модифицированные tracked + untracked-остатки failed/cancelled/брошенных задач). Хук `--deploy` перед pull приводит базу к чистому `origin/main` (resilient-pull: `git fetch` + `git reset --hard origin/main` + `git clean -fd`), **строго сохраняя** rollback-снимки `.deploy-prev-image-*`, `deploy-hook.log`, gitignored `.env`/`data/`/`*.db` (НИКОГДА `-x`!), sibling `.deploy-state-*`/`.merge-lease-*.json`, `.git/worktrees/*`. Гейт — kill-switch `ORCH_CHECKOUT_HYGIENE_ENABLED` (дефолт `True`; off → голый pull 1:1); скоуп `ORCH_CHECKOUT_HYGIENE_REPOS` (пусто → self-hosting only). Грязь базы детектируется → лог + Telegram-алерт (Phase-C finalizer). Решает инцидент ORCH-111 (грязь ORCH-104 заблокировала `git pull`). Детально — `docs/work-items/ORCH-112/06-adr/ADR-001`, сквозной adr-0044.
 
 **Правила для агентов при задачах ORCH:**
 1. НЕ перезапускать / не ронять прод-контейнер `orchestrator` в рамках задачи.

docs/overview/tech-pipeline.md

@@ -46,7 +46,10 @@ created → analysis → architecture → development → review → testing →
 4. `check_staging_image_fresh` — staging-образ собран из актуального кода.
 
 Это **врезки в переход, а не стадии**: они не появляются в карте `STAGE_TRANSITIONS`, а
-исполняются stage engine'ом внутри ребра. Провал любого из них — откат на доработку. На ребре
+исполняются stage engine'ом внутри ребра. Провал любого из них — откат на доработку. Исключение
+(ORCH-110): **инфра-таймаут** локального re-test merge-gate (а не детерминированный красный тест) —
+это транзиент, а не дефект кода → ограниченный повтор + отдельный инфра-alert, без отката на
+доработку и без расхода developer-retry (красный re-test/конфликт по-прежнему откатывают). На ребре
 `deploy → done` аналогичная врезка merge-verify подтверждает, что код задачи реально слит в
 `main` (слияние — только через PR-API Gitea, см. [интеграции](tech-integrations.md)).
 

docs/work-items/ORCH-110/00-business-request.md

@@ -0,0 +1,7 @@
+# Business Request: BUG: merge-gate local re-test timeout causes false rollback after green CI
+
+Work Item ID: ORCH-110
+
+## Description
+
+TBD

docs/work-items/ORCH-110/01-brd.md

@@ -0,0 +1,178 @@
+---
+work_item: ORCH-110
+stage: analysis
+author_agent: analyst
+status: ready-for-review
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+escalate: full-cycle
+---
+
+# 01 — BRD (бизнес-требования): ORCH-110 — BUG: merge-gate local re-test timeout causes false rollback after green CI
+
+Work Item: **ORCH-110** · Repo: **orchestrator** · Стадия: analysis
+
+> **Багфикс-трек → эскалация в полный цикл (`escalate: full-cycle`).** Задача помечена `Bug`, но
+> сама баг-карточка требует «отдельный анализ вариантов и контрактов merge-gate» (см. «Ограничение»
+> ниже) — это решение с несколькими проектными альтернативами и нетривиальными инвариантами
+> self-hosting, которому нужен ADR. По правилу ORCH-019 (ADR-001 D5) выпускается **полный**
+> analysis-пакет, а трек эскалируется (`POST /bug-fast-track/escalate?work_item=ORCH-110`) → задача
+> проходит стадию `architecture`. Прецедент — родственная задача ORCH-111 («bug → escalate
+> full-cycle»).
+
+---
+
+## 1. Бизнес-контекст и проблема
+
+Оркестратор — self-hosting инструмент: его прод-контейнер обслуживает конвейер всех проектов и
+дорабатывает сам себя. На ребре `deploy-staging → deploy` исполняется детерминированный под-гейт
+**merge-gate** (`check_branch_mergeable`, ORCH-043): он догоняет ветку до текущего `origin/main`
+(`auto_rebase_onto_main`) и затем **локально пере-прогоняет весь тест-сюит** (`retest_branch` →
+`python -m pytest tests/ -q`) в worktree, чтобы поймать **семантический** конфликт слияния (ветка
+зелёная по своей базе, но ломает уехавший `main`).
+
+**Установленные факты инцидента (ORCH-109, PR #129):**
+- tester завершился `result: PASS`; полный регресс — **`1899 passed` за `516.70s`**;
+- CI Gitea по HEAD — зелёный (push + pull_request success); PR после rebase — open, `mergeable=true`;
+- merge-gate локальный re-test упал по **таймауту**: `re-test timeout after 600s`
+  (`merge_retest_timeout_s = 600`);
+- на хосте обнаружены **старые зависшие pytest-процессы** `tests/test_install_lite_script.py`,
+  жившие **> 2 суток** и грузившие CPU; прибиты вручную 2026-06-14.
+
+**Цепочка отказа.** Зависшие осиротевшие pytest-процессы (CPU-голодание) → тот же сюит, что у tester
+шёл 516.70s (запас до 600s ≈ 16%), под нагрузкой превысил 600s → `check_branch_mergeable` вернул
+`(False, "re-test timeout after 600s")` → `_handle_merge_gate_rollback`: откат `deploy-staging →
+development` + developer-retry. Каждый из 3 retry повторно падал по тому же CPU-голоданию → финальный
+alert **«Merge-gate still failing after 3 developer retries (re-test timeout after 600s)»** → задача
+застряла, потребовалось ручное вмешательство.
+
+**Корень (подтверждён по коду):**
+1. **Утечка осиротевших процессов.** `merge_gate.retest_branch` и `coverage_gate.measure_coverage`
+   запускают `subprocess.run([... pytest ...], timeout=...)` **без изоляции группы процессов**
+   (`start_new_session`/`preexec_fn`). При `TimeoutExpired` Python убивает только **прямого
+   потомка**; внуки pytest репарентируются на PID 1 (tini жнёт зомби, но не убивает живых сирот) и
+   живут сутками, грузя CPU. Это источник CPU-голодания (ровно симптом из фактов).
+2. **Нет толерантности к инфра-таймауту.** Re-test **таймаут** (ресурсная/инфра-причина)
+   классифицируется идентично **красному** re-test (реальный дефект кода): оба → откат на
+   `development` + расход developer-retry. Разработчик не может «починить» CPU-голодание → retry
+   сгорают вхолостую и упираются в alert «Manual intervention needed».
+3. **Тонкий бюджет.** Бюджет re-test `600s` практически равен фактическому времени сюита
+   (`516.70s`); запас не растёт вместе с сюитом (ср. ORCH-109, где по той же причине были подняты
+   бюджеты агентов developer/reviewer).
+4. **Контракт необходимости re-test.** На ветке, уже актуальной к `origin/main` (rebase — no-op), и
+   с зелёным CI по этому же HEAD локальный полный re-test пере-проверяет ровно тот коммит, что CI
+   уже подтвердил, — становясь избыточной единственной точкой ложного отказа.
+
+## 2. Объём (scope)
+
+### В объёме
+- Поведение merge-gate при **таймауте** локального re-test: классификация и путь восстановления
+  (толерантность к инфра-таймауту вместо ложного отката на `development`).
+- **Жизненный цикл подпроцессов**, которые оркестратор запускает САМ для проверок: re-test merge-gate
+  (`merge_gate.retest_branch`) и coverage-run (`coverage_gate.measure_coverage`) — гарантия отсутствия
+  осиротевших процессов после таймаута/kill.
+- **Согласованность бюджета** re-test с фактическим временем полного сюита (адекватный запас) с учётом
+  сквозных инвариантов reaper/lease.
+- **Контракт необходимости** локального re-test merge-gate (когда он реально нужен относительно
+  зелёного CI и состояния `branch vs origin/main`) — анализ вариантов под решение архитектора.
+- Наблюдаемость инфра-таймаута (отличить «инфра-таймаут, повтор/defer» от «дефект кода → developer»).
+
+### Вне объёма
+- **Алерт sidecar-watchdog на осиротевший тест-процесс** — это **ORCH-111** (`proc_blocking`,
+  наблюдатель только сигналит, никогда не убивает, C-1). ORCH-110 — комплементарная сторона
+  (предотвращение утечки + толерантность), дубля детекции не вводит.
+- Ручное умерщвление уже зависших хост-процессов — операционная мера (выполнена 2026-06-14), не код.
+- Любые правки `STAGE_TRANSITIONS` / реестра `QG_CHECKS` / `check_*`-семантики / machine-verdict
+  ключей / схемы БД (инвариант NFR-1).
+- Изменение конкретного теста `tests/test_install_lite_script.py` (его поведение — отдельный предмет;
+  здесь важен класс «оркестратор-спавненный pytest не должен переживать свой бюджет»).
+- Поведение не-self-hosting репозиториев (enduro-trails) — нулевая регрессия.
+- Изменение хука прод-деплоя/рестарт прод-контейнера (self-hosting безопасность).
+
+## 3. Заинтересованные стороны
+- **Owner / оператор self-hosting** — страдает от ручного разбора застрявших задач и зависших
+  процессов; заказчик исправления.
+- **Конвейер всех проектов** — общий прод-контейнер: утечка CPU деградирует обслуживание enduro.
+- **Пакетный автономный режим (эпик ORCH-088)** — ложные откаты и manual-gate'ы ломают цель
+  «10–20 задач за ночь без вмешательства».
+- **Принимает результат:** reviewer → tester → deployer штатного конвейера.
+
+## 4. Бизнес-требования (BR)
+
+- **BR-1 — Зелёный путь без ручного вмешательства.** При зелёном tester `PASS` и зелёном CI задача
+  **не должна** требовать ручного вмешательства из-за инфраструктурного/локального re-test таймаута
+  (прямое «Ожидаемое поведение» баг-карточки).
+- **BR-2 — Инфра-таймаут ≠ дефект кода.** Таймаут локального re-test merge-gate (ресурсная/инфра
+  причина) **не должен** трактоваться как код-фейл: путь восстановления **не** должен сжигать
+  developer-retry и приводить к «Manual intervention after N developer retries», если CI и tester
+  были зелёными. Реакция на таймаут — ограниченный повтор/defer и/или отдельный инфра-сигнал, не
+  безусловный откат на `development`.
+- **BR-3 — Нет осиротевших процессов.** Подпроцессы pytest, запущенные самим оркестратором для
+  re-test и coverage-run, **должны** полностью завершаться (всё дерево, включая внуков) при
+  таймауте/kill. Ни один оркестратор-спавненный pytest не должен переживать свой бюджет и продолжать
+  грузить CPU.
+- **BR-4 — Адекватный бюджет re-test.** Бюджет времени re-test **должен** иметь достаточный запас над
+  фактическим временем полного сюита, чтобы здоровый сюит при штатной нагрузке не падал по таймауту;
+  бюджет конфигурируем и со-эволюционирует с ростом сюита.
+- **BR-5 — Контракт необходимости re-test.** Merge-gate **должен** различать «ветка реально отстала
+  от уехавшего `origin/main` и была ребейзнута» (риск семантического конфликта → re-test оправдан) и
+  «ветка уже актуальна / rebase — no-op, CI по этому HEAD зелёный» (re-test избыточен). Локальный
+  re-test не должен быть избыточной единственной точкой ложного отказа на коммите, уже подтверждённом
+  CI. Конкретный контракт (skip/scope/trust-CI-SHA) выбирает архитектор и фиксирует в ADR.
+- **BR-6 — Сохранение защиты от семантического конфликта.** Толерантность к таймауту **не должна**
+  ослаблять исходную цель merge-gate (ORCH-043): **детерминированно красный** re-test (реальный сбой
+  теста, а не таймаут) по-прежнему обязан откатывать на `development`. Послабление применяется ТОЛЬКО
+  к таймауту/инфра, никогда к красному результату.
+- **BR-7 — Наблюдаемость.** Состояние «инфра-таймаут» должно быть видимым (лог + Telegram с
+  кликабельным номером + read-only в `GET /queue`) и отличимым от код-фейл-отката; согласовано с
+  сигналом ORCH-111 (без дубля).
+
+## 5. Нефункциональные требования (NFR)
+
+- **NFR-1 — Инварианты конвейера неприкосновенны.** `STAGE_TRANSITIONS` / реестр `QG_CHECKS` /
+  семантика `check_*` / machine-verdict ключи (`verdict:`/`result:`/`deploy_status:`/
+  `staging_status:`/`security_status:`/`coverage_status:`) / схема БД — **байт-в-байт** прежние.
+  Исправление — аддитивное (врезка/leaf-логика), не новая стадия и не новый зарегистрированный QG.
+- **NFR-2 — Kill-switch + нулевая регрессия.** Новое поведение под флагом; при выключенном флаге —
+  поведение **байт-в-байт** как до ORCH-110 (таймаут → прежний откат). Скоуп — self-hosting
+  (`orchestrator`); enduro не затронут.
+- **NFR-3 — Self-hosting безопасность.** Исправление **никогда** не пушит/force-push в `main` (INV-4;
+  merge только через Gitea PR-merge API), не рестартит прод-контейнер, не трогает detached-деплой.
+- **NFR-4 — never-raise.** Любая ошибка в новом пути → безопасный дефолт + WARNING; исключение
+  никогда не уходит в `advance_stage`/monitor-поток (контракт merge-gate сохранён).
+- **NFR-5 — Ограниченность (anti-loop).** Любой повтор/defer таймаута строго ограничен по числу
+  попыток и суммарному времени; исчерпание → **чёткий инфра-alert**, отличный от «developer must
+  fix», а не бесконечный bounce и не молчаливое зависание.
+- **NFR-6 — Сквозные инварианты времени.** Любое изменение бюджета re-test должно уважать
+  существующие соотношения: `merge_lock_timeout_s` (TTL merge-lease), `reaper_max_running_s`
+  (Tier-3 backstop reaper, ORCH-065/109), `coverage_run_timeout_s` — без рассинхрона.
+
+## 6. Допущения и ограничения
+- **Ограничение из баг-карточки (дословно):** «Решение намеренно не описано в этой баге; нужен
+  отдельный анализ вариантов и контрактов merge-gate». → Аналитик фиксирует требования и
+  тест-план; **варианты и контракт merge-gate** прорабатывает архитектор (06-adr) — основание
+  эскалации в полный цикл.
+- Допущение: tini (PID 1) жнёт зомби, но не убивает живых осиротевших процессов (подтверждено
+  поведением инцидента) — отсюда требование tree-kill (BR-3).
+- Допущение: таймаут merge-gate re-test в зелёном инциденте вызван внешним CPU-голоданием, а не
+  реальным зависанием теста ветки; но решение обязано остаться **fail-safe** к случаю реального
+  зависшего теста (см. Риск R-2 / BR-6).
+- Среда верификации — staging-контур (8501), обязательная страховка перед прод-деплоем self.
+
+## 7. Критерии успеха
+Резюме: зелёный tester `PASS` + зелёный CI + актуальная ветка → задача доходит до `deploy` без
+ложного отката на `development` и без manual-gate из-за инфра-таймаута; оркестратор-спавненные
+pytest-процессы не переживают свой бюджет; реальный красный re-test по-прежнему откатывает на
+`development`; инварианты конвейера и self-hosting не тронуты. Детальные PASS/FAIL —
+`03-acceptance-criteria.md`.
+
+## 8. Риски
+- **R-1** — Над-толерантность маскирует реальный зависший тест (бесконечный/долгий) как «инфра» →
+  смягчение: строгая ограниченность (NFR-5) + отдельный инфра-alert + сохранение красно-откат-пути
+  (BR-6).
+- **R-2** — Поднятие бюджета без правки tree-kill лишь отодвигает отказ (сюит растёт) → исправление
+  должно бить корень (BR-3), бюджет (BR-4) — вторично.
+- **R-3** — Рассинхрон сквозных таймаутов (reaper/lease) при изменении бюджета (NFR-6).
+- **R-4** — Дубль/конфликт с сигналом ORCH-111 (`proc_blocking`) → координация: ORCH-110
+  предотвращает/толерирует, ORCH-111 наблюдает; разные слои.
+- Детальная оценка и митигации — `10-tech-risks.md` (заполняет архитектор).

docs/work-items/ORCH-110/02-trz.md

@@ -0,0 +1,129 @@
+---
+work_item: ORCH-110
+stage: analysis
+author_agent: analyst
+status: ready-for-review
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+escalate: full-cycle
+---
+
+# 02 — ТЗ (TRZ): ORCH-110 — merge-gate local re-test timeout: устранение ложного отката + утечки процессов
+
+Work Item: **ORCH-110** · Repo: **orchestrator** · Стадия: analysis
+
+> ТЗ описывает **конкретные требования к реализации**, выведенные из BRD и фактического кода.
+> Архитектурное обоснование, выбор вариантов и **контракт merge-gate** — задача архитектора (06-adr,
+> основание `escalate: full-cycle`). Здесь — поведение/контракты/инварианты и привязка к модулям,
+> НЕ выбор механизма.
+
+## 1. Сводка изменения
+Устранить ложный откат `deploy-staging → development`, возникающий когда локальный re-test merge-gate
+падает по **таймауту** (инфра/ресурс), при зелёном tester `PASS` и зелёном CI. Изменение бьёт по двум
+корням и одному контракту: (1) **утечка осиротевших pytest-процессов** из оркестратор-спавненных
+прогонов re-test/coverage (источник CPU-голодания) → гарантировать tree-kill дерева подпроцесса при
+таймауте/kill; (2) **классификация инфра-таймаута** как транзиента (повтор/defer/инфра-alert), а не
+код-фейла (откат + расход developer-retry); (3) **контракт необходимости** локального re-test
+относительно зелёного CI и состояния `branch vs origin/main`. Сопутствующе — согласование **бюджета**
+re-test с реальным временем сюита. Всё — аддитивно, под kill-switch, never-raise, скоуп self-hosting,
+с сохранением исходной защиты merge-gate от семантического конфликта (красный re-test по-прежнему
+откатывает).
+
+## 2. Задействованные модули / пути
+| Путь | Действие |
+|------|----------|
+| `src/merge_gate.py` | изменить — `retest_branch`: жизненный цикл подпроцесса (tree-kill при таймауте/kill); классификация исхода «timeout» как транзиента (контракт возврата) |
+| `src/coverage_gate.py` | изменить — `measure_coverage`: тот же tree-kill при таймауте (сиблинг-источник утечки, BR-3) |
+| `src/qg/checks.py` | изменить — `check_branch_mergeable`: различать «timeout/infra» от «red re-test» в возвращаемом контракте (без смены имени/семантики зарегистрированного `check_*`) |
+| `src/stage_engine.py` | изменить — `_handle_merge_gate` / маршрутизация исхода: инфра-таймаут → defer/повтор/инфра-alert (по образцу `_handle_merge_gate_defer`), НЕ `_handle_merge_gate_rollback`; красный re-test → прежний rollback |
+| `src/config.py` | изменить — флаг(и) толерантности к инфра-таймауту + (опц.) согласование `merge_retest_timeout_s`; уважить сквозные инварианты `merge_lock_timeout_s` / `reaper_max_running_s` / `coverage_run_timeout_s` |
+| `docs/architecture/README.md`, `CLAUDE.md`, `CHANGELOG.md` | обновить — описание поведения merge-gate re-test (golden source наравне с кодом) |
+| `tests/test_*` | создать — покрытие по `04-test-plan.yaml` |
+
+> Точный набор новых символов/флагов и механизм tree-kill (process-group `start_new_session`+killpg,
+> либо иной) — решение архитектора. ТЗ фиксирует **что** должно выполняться, не **как**.
+
+## 3. Функциональные требования
+
+### FR-1 — Толерантность к инфра-таймауту re-test (нет ложного отката) [BR-1, BR-2]
+Когда merge-gate локальный re-test завершается специфически по **таймауту** (а не детерминированно
+красным результатом), исход ДОЛЖЕН классифицироваться как транзиент/инфра, не код-фейл. Путь
+восстановления НЕ ДОЛЖЕН быть тем же `_handle_merge_gate_rollback` (откат на `development` + инкремент
+developer-retry), который при зелёных CI/tester ведёт к «Manual intervention needed». Допустимая
+реакция (выбор — архитектор): ограниченный повтор re-test и/или defer (по образцу существующего
+`_handle_merge_gate_defer` для `merge-lock busy`) и/или отдельный инфра-alert. Прецеденты толерантности
+к инфра: ORCH-061 (staging infra tolerance), ORCH-093 (transient vs terminal классификация merge-POST).
+
+### FR-2 — Tree-kill оркестратор-спавненных тест-процессов [BR-3]
+`merge_gate.retest_branch` и `coverage_gate.measure_coverage` ДОЛЖНЫ гарантировать, что при таймауте
+(а также при любом kill/прерывании прогона) завершается **всё дерево** подпроцесса pytest, включая
+внуков, а не только прямой потомок. После таймаута ни один оркестратор-спавненный pytest-процесс не
+должен оставаться живым и грузить CPU. Контракт возврата `retest_branch`
+(`(False, "re-test timeout after <T>s")`) сохраняется; меняется лишь побочный эффект — отсутствие
+утечки. Существующий каскад launcher `SIGTERM→grace→SIGKILL` (`stop_process`) — образец на уровне
+агентов; для этих subprocess-прогонов требуется эквивалентная гарантия на уровне группы процессов.
+
+### FR-3 — Согласованность бюджета re-test [BR-4, NFR-6]
+Бюджет `merge_retest_timeout_s` ДОЛЖЕН иметь достаточный запас над фактическим временем полного сюита
+(наблюдаемо: 600s бюджет vs 516.70s факт ≈ 16%). Бюджет остаётся конфигурируемым; при его изменении
+ДОЛЖНЫ соблюдаться сквозные инварианты: `reaper_max_running_s > max(agent_timeout, бюджеты) + grace`
+(ORCH-065/109) и согласование с `merge_lock_timeout_s` (TTL merge-lease держится на время re-test).
+Малформный/непозитивный конфиг → безопасный дефолт + WARNING (never-break).
+
+### FR-4 — Контракт необходимости локального re-test [BR-5, BR-6]
+Merge-gate ДОЛЖЕН различать риск-кейсы и применять re-валидацию пропорционально реальному риску
+слияния:
+- ветка **реально отстала** от уехавшего `origin/main` и ребейзнута → семантический риск → re-test
+  оправдан (текущая цель ORCH-043 сохраняется);
+- ветка **уже актуальна** / rebase — no-op, и CI по этому самому HEAD зелёный → локальный полный
+  re-test пере-проверяет ровно подтверждённый CI коммит и не должен быть единственной точкой ложного
+  отказа.
+Конкретный контракт (например: пропуск re-test при «не-behind + зелёный CI по HEAD», сокращённый
+scope, доверие SHA, подтверждённому CI, и т. п.) — **выбор архитектора в ADR** (ядро запрошенного
+баг-карточкой «анализа контрактов merge-gate»). Инвариант **BR-6**: детерминированно **красный**
+re-test (реальный сбой теста) обязан и далее откатывать на `development` — послабление применяется
+ТОЛЬКО к таймауту/инфра.
+
+### FR-5 — Сохранение инвариантов и kill-switch [NFR-1, NFR-2, NFR-3, NFR-4]
+Изменение аддитивно: `STAGE_TRANSITIONS` / реестр `QG_CHECKS` / семантика `check_*` / machine-verdict
+ключи / схема БД — без изменений; merge-gate остаётся под-гейтом-врезкой, не новой стадией/QG. Под
+kill-switch: выключенный флаг → байт-в-байт прежнее поведение (таймаут → откат). Скоуп self-hosting
+(`orchestrator`); enduro — no-op. never-raise; INV-4 (никогда push/force-push `main`; merge только
+через Gitea PR API) и запрет рестарта прод-контейнера — соблюдены.
+
+### FR-6 — Наблюдаемость и ограниченность [BR-7, NFR-5]
+Состояние «инфра-таймаут» ДОЛЖНО логироваться, уведомляться в Telegram (кликабельный номер задачи) и
+быть видимым read-only (например, расширение блока `merge`/`merge_verify` в `GET /queue`), отличимо от
+код-фейл-отката. Любой повтор/defer строго ограничен (число попыток + суммарное время); исчерпание →
+**инфра-alert** (не «developer must fix»). Координация с ORCH-111 (`proc_blocking`) — без дубля:
+ORCH-110 предотвращает/толерирует, ORCH-111 наблюдает.
+
+## 4. Изменения API
+Новых обязательных эндпоинтов **не требуется**. Допустимо (when-applicable, на усмотрение
+архитектора) **read-only** расширение существующего снимка `GET /queue` (блок merge-gate) полями
+наблюдаемости инфра-таймаута/повторов. Никаких новых управляющих эндпоинтов.
+
+## 5. Изменения схемы БД
+**Нет.** Счётчики повторов/defer — по образцу существующих (`_merge_defer_count` /
+`_developer_retry_count` поверх `jobs`/`agent_runs`) либо in-memory/sentinel; новые таблицы/колонки не
+вводятся (NFR-1).
+
+## 6. Требования к новым/изменённым QG checks
+**Нет нового зарегистрированного QG.** `check_branch_mergeable` остаётся в реестре `QG_CHECKS` с тем же
+именем и семантикой PASS/FAIL; меняется лишь **различение причины FAIL** (timeout/infra vs red) в
+возвращаемом reason и **маршрутизация исхода** во врезке `_handle_merge_gate` (`advance_stage`).
+`STAGE_TRANSITIONS` и состав `QG_CHECKS` — байт-в-байт.
+
+## 7. Совместимость / регресс
+- **Обратная совместимость:** kill-switch off → поведение байт-в-байт как до ORCH-110 (таймаут →
+  rollback на `development`), включая текст alert'ов.
+- **Область раската:** self-hosting `orchestrator` (как ORCH-035/043/058/071); прочие репо — no-op,
+  путь LLM-`deployer`/прежний merge не затронут.
+- **Обратимость:** чисто аддитивная логика под флагом; откат = выключить флаг.
+- **Self-hosting:** без рестарта прод-контейнера; merge только через Gitea PR API; никаких операций с
+  `main` (INV-4).
+- **Анти-регресс целей merge-gate:** красный re-test → прежний rollback (BR-6); защита от
+  семантического конфликта/фантомного merge (ORCH-043/071/073) — не ослаблена.
+- **Трассировка маркеров (ORCH-078):** правки в `merge_gate.py`/`coverage_gate.py`/`qg/checks.py`
+  затрагивают блоки с маркерами ORCH-043/071/073/093/027/065/109 — перед изменением сверить их
+  `06-adr` и не сломать зафиксированные инварианты (lease, never-raise, fail-open/closed, бюджеты).

docs/work-items/ORCH-110/03-acceptance-criteria.md

@@ -0,0 +1,123 @@
+---
+work_item: ORCH-110
+stage: analysis
+author_agent: analyst
+status: ready-for-review
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+escalate: full-cycle
+---
+
+# 03 — Критерии приёмки (Acceptance Criteria): ORCH-110 — merge-gate re-test timeout
+
+Work Item: **ORCH-110** · Repo: **orchestrator** · Стадия: analysis
+
+Формат: каждый критерий имеет **PASS** (что должно быть истинно для приёмки) и **FAIL** (что считается
+провалом). Reviewer/тестировщик проверяет их буквально по файлам/тестам репозитория.
+
+---
+
+## AC-1 — Зелёный путь не требует ручного вмешательства из-за инфра-таймаута
+**Условие:** tester `PASS` + зелёный CI + ветка актуальна к `origin/main`, но локальный re-test
+merge-gate упирается в таймаут (смоделированное CPU-голодание/медленный прогон).
+- **PASS:** задача НЕ откатывается ложно как код-фейл и НЕ доходит до alert «Merge-gate still failing
+  after N developer retries»; она доходит до `deploy` (возможно после ограниченного defer/повтора)
+  или поднимает **отдельный инфра-alert**, отличимый от «developer must fix».
+- **FAIL:** таймаут → `_handle_merge_gate_rollback` на `development` с расходом developer-retry →
+  manual-gate (текущее ошибочное поведение).
+
+---
+
+## AC-2 — Инфра-таймаут классифицируется отдельно от красного re-test
+**Условие:** `check_branch_mergeable` вернул FAIL по причине таймаута vs по причине красного теста.
+- **PASS:** таймаут маршрутизируется в транзиент-путь (defer/повтор/инфра-alert), красный re-test —
+  в прежний rollback на `development`; пути различимы в коде и в логах/наблюдаемости.
+- **FAIL:** оба исхода идут одним путём отката на `development`.
+
+---
+
+## AC-3 — Реальный красный re-test по-прежнему откатывает (анти-над-толерантность)
+**Условие:** локальный re-test даёт детерминированно красный результат (реальный сбой теста, не
+таймаут).
+- **PASS:** задача откатывается на `development` + developer-retry (цель ORCH-043 сохранена), lease
+  освобождается.
+- **FAIL:** красный re-test «толерируется» и задача продвигается/деплоится со сломанным кодом.
+
+---
+
+## AC-4 — Нет осиротевших тест-процессов после таймаута
+**Условие:** `merge_gate.retest_branch` (и `coverage_gate.measure_coverage`) запущены против прогона,
+порождающего дочерние/внучатые процессы, и прогон превышает бюджет (таймаут).
+- **PASS:** по таймауту завершается всё дерево подпроцесса (включая внуков); живых
+  оркестратор-спавненных pytest-процессов не остаётся; контракт возврата
+  `(False, "re-test timeout after <T>s")` сохранён.
+- **FAIL:** прямой потомок убит, но внуки репарентируются и продолжают жить/грузить CPU.
+
+---
+
+## AC-5 — Бюджет re-test согласован и уважает сквозные инварианты
+**Условие:** конфигурация бюджета re-test и связанных таймаутов.
+- **PASS:** `merge_retest_timeout_s` имеет адекватный запас над фактическим временем сюита;
+  соблюдено `reaper_max_running_s > max(agent_timeout, бюджеты) + grace` и согласование с
+  `merge_lock_timeout_s`/`coverage_run_timeout_s`; малформный конфиг → дефолт + WARNING.
+- **FAIL:** бюджет оставлен впритык к времени сюита без обоснования, либо изменение бюджета ломает
+  инвариант reaper/lease.
+
+---
+
+## AC-6 — Контракт необходимости re-test зафиксирован и реализован
+**Условие:** ветка не-behind (rebase no-op) + зелёный CI по этому HEAD.
+- **PASS:** поведение локального re-test соответствует контракту, выбранному архитектором в ADR
+  (skip/scope/trust-CI-SHA и т. п.); re-test не является избыточной единственной точкой ложного
+  отказа на коммите, уже подтверждённом CI; решение и его обоснование задокументированы в `06-adr/`.
+- **FAIL:** контракт не определён/не реализован; полный re-test безусловно гоняется и при не-behind +
+  зелёном CI.
+
+---
+
+## AC-7 — Kill-switch и нулевая регрессия
+**Условие:** флаг толерантности выключен; и/или не-self-hosting репозиторий (enduro).
+- **PASS:** поведение байт-в-байт как до ORCH-110 (таймаут → прежний rollback; те же тексты
+  alert'ов); enduro-путь не затронут.
+- **FAIL:** при выключенном флаге/для enduro поведение изменилось.
+
+---
+
+## AC-8 — Инварианты конвейера и self-hosting не тронуты
+**Условие:** статический и поведенческий анализ изменений.
+- **PASS:** `STAGE_TRANSITIONS` / реестр `QG_CHECKS` / семантика `check_*` / machine-verdict ключи /
+  схема БД — без изменений; никаких push/force-push в `main` (INV-4), merge только через Gitea PR API,
+  прод-контейнер не рестартится; все публичные функции merge-gate/coverage остаются never-raise.
+- **FAIL:** изменён любой из перечисленных инвариантов, или исключение уходит в `advance_stage`.
+
+---
+
+## AC-9 — Ограниченность транзиент-пути (anti-loop) + наблюдаемость
+**Условие:** инфра-таймаут повторяется.
+- **PASS:** число повторов/defer ограничено и по попыткам, и по суммарному времени; исчерпание →
+  один чёткий инфра-alert; событие видно в логах/`GET /queue` и отличимо от код-фейла.
+- **FAIL:** бесконечный bounce/повтор, либо молчаливое зависание без терминального сигнала.
+
+---
+
+## AC-10 — Регресс-тест (красный до фикса, зелёный после)
+**Условие:** наличие автоматического теста, воспроизводящего инцидент.
+- **PASS:** в `tests/` есть тест, который на текущем коде **падал бы** (инфра-таймаут re-test →
+  ложный rollback / выживший процесс), а после фикса **зелёный**; включён в полный регресс `pytest`.
+- **FAIL:** регресс-теста нет, либо он не воспроизводит инцидент.
+
+---
+
+## Сводная матрица AC ↔ FR/BR
+| AC | Покрывает |
+|----|-----------|
+| AC-1 | BR-1 / FR-1 |
+| AC-2 | BR-2 / FR-1 |
+| AC-3 | BR-6 / FR-4 |
+| AC-4 | BR-3 / FR-2 |
+| AC-5 | BR-4 / FR-3 / NFR-6 |
+| AC-6 | BR-5 / FR-4 |
+| AC-7 | NFR-2 / FR-5 |
+| AC-8 | NFR-1 / NFR-3 / NFR-4 / FR-5 |
+| AC-9 | NFR-5 / BR-7 / FR-6 |
+| AC-10 | BR-1…BR-3 (регресс инцидента) |

docs/work-items/ORCH-110/04-test-plan.yaml

@@ -0,0 +1,94 @@
+work_item: ORCH-110
+stage: analysis
+author_agent: analyst
+status: ready-for-review
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+escalate: full-cycle
+title: "merge-gate re-test timeout: tolerance + no orphan-process leak + re-test contract"
+framework: pytest
+scope: >
+  Покрывает: классификацию инфра-таймаута re-test merge-gate как транзиента (без ложного отката),
+  tree-kill оркестратор-спавненных pytest-прогонов (re-test + coverage), сохранение красно-откат-пути,
+  согласование бюджета re-test со сквозными инвариантами, контракт необходимости re-test, kill-switch
+  и наблюдаемость. Вне покрытия: алерт sidecar-watchdog (ORCH-111), правка конкретного
+  test_install_lite_script.py, поведение enduro (только проверяется no-op).
+notes: >
+  TC-10 — ОБЯЗАТЕЛЬНЫЙ регресс-тест инцидента ORCH-109/PR#129: красный на текущем коде (инфра-таймаут
+  re-test → ложный rollback / выживший процесс), зелёный после фикса. Подпроцессы в тестах мокаются
+  (управляемый "медленный/спавнящий детей pytest"), без обращения к сети/Plane/Gitea. Полный регресс
+  tests/ должен оставаться зелёным. Точные имена символов/флагов уточняет архитектор (06-adr);
+  модули-плейсхолдеры ниже выровнены под манифест PIPELINE_DOCS.
+
+tests:
+  - id: TC-01
+    type: unit
+    description: "retest_branch: таймаут возвращает (False, 're-test timeout after <T>s') И завершает всё дерево подпроцесса (внуки не переживают таймаут)."
+    module: tests/test_orch110_retest_lifecycle.py
+    expected: PASS
+
+  - id: TC-02
+    type: unit
+    description: "coverage_gate.measure_coverage: таймаут завершает всё дерево подпроцесса (сиблинг-источник утечки, BR-3); возврат None сохранён."
+    module: tests/test_orch110_retest_lifecycle.py
+    expected: PASS
+
+  - id: TC-03
+    type: unit
+    description: "check_branch_mergeable: исход 'timeout' различим от 'red re-test' в reason/классификации (без смены имени/семантики зарегистрированного check_*)."
+    module: tests/test_orch110_merge_gate_classify.py
+    expected: PASS
+
+  - id: TC-04
+    type: unit
+    description: "Маршрутизация исхода: инфра-таймаут → defer/повтор/инфра-alert путь (НЕ _handle_merge_gate_rollback на development, без инкремента developer-retry)."
+    module: tests/test_orch110_merge_gate_routing.py
+    expected: PASS
+
+  - id: TC-05
+    type: unit
+    description: "Анти-над-толерантность: детерминированно КРАСНЫЙ re-test по-прежнему → откат на development + developer-retry + release lease (BR-6 сохранён)."
+    module: tests/test_orch110_merge_gate_routing.py
+    expected: PASS
+
+  - id: TC-06
+    type: unit
+    description: "Ограниченность (anti-loop): повторы/defer инфра-таймаута лимитированы по попыткам и суммарному времени; исчерпание → один инфра-alert, не бесконечный bounce."
+    module: tests/test_orch110_merge_gate_routing.py
+    expected: PASS
+
+  - id: TC-07
+    type: unit
+    description: "Kill-switch off → байт-в-байт прежнее поведение (таймаут → rollback на development, прежний текст alert); not-self repo (enduro) → no-op."
+    module: tests/test_orch110_killswitch.py
+    expected: PASS
+
+  - id: TC-08
+    type: unit
+    description: "Бюджет/инварианты: malformed/непозитивный merge_retest_timeout_s → дефолт + WARNING; соблюдён reaper_max_running_s > max(agent_timeout, бюджеты)+grace и согласование с merge_lock_timeout_s."
+    module: tests/test_orch110_budget_invariants.py
+    expected: PASS
+
+  - id: TC-09
+    type: unit
+    description: "never-raise: любая ошибка в новом транзиент-пути → безопасный дефолт + WARNING; исключение не уходит в advance_stage."
+    module: tests/test_orch110_merge_gate_routing.py
+    expected: PASS
+
+  - id: TC-10
+    type: integration
+    description: "РЕГРЕСС инцидента: tester PASS + зелёный CI + ветка не-behind, но re-test таймаут — задача НЕ откатывается ложно и НЕ упирается в 'Merge-gate still failing after N developer retries'; доходит до deploy или поднимает инфра-alert. Красный до фикса, зелёный после."
+    module: tests/test_orch110_false_rollback_regression.py
+    expected: PASS
+
+  - id: TC-11
+    type: integration
+    description: "Контракт необходимости re-test (FR-4/AC-6): при не-behind + зелёном CI по HEAD локальный re-test ведёт себя по выбранному в ADR контракту (skip/scope/trust-CI) и не является избыточной единственной точкой ложного отказа. Финальная форма — после решения архитектора."
+    module: tests/test_orch110_retest_contract.py
+    expected: PASS
+
+  - id: TC-12
+    type: integration
+    description: "Наблюдаемость: инфра-таймаут отражён в логах/GET /queue (read-only) и Telegram-уведомлении с кликабельным номером; отличим от код-фейл-отката; без дубля с ORCH-111."
+    module: tests/test_orch110_observability.py
+    expected: PASS

docs/work-items/ORCH-110/06-adr/ADR-001-merge-gate-retest-infra-tolerance-and-tree-kill.md

@@ -0,0 +1,352 @@
+---
+work_item: ORCH-110
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# ADR-001: Merge-gate re-test — толерантность к инфра-таймауту, tree-kill спавненных процессов и контракт необходимости re-test
+
+Work Item: **ORCH-110** — BUG: merge-gate local re-test timeout causes false rollback after green CI
+Стадия: **architecture**
+Сквозная регистрация: **`docs/architecture/adr/adr-0042-merge-gate-retest-infra-tolerance-and-tree-kill.md`**
+(решение кросс-каттинговое: затрагивает merge-gate ORCH-043, coverage-gate ORCH-027 и
+сквозной инвариант времени reaper ORCH-065/109).
+
+## Статус
+Proposed
+
+## Контекст
+
+На ребре `deploy-staging → deploy` детерминированный под-гейт **merge-gate** (`check_branch_mergeable`,
+ORCH-043) догоняет ветку до текущего `origin/main` (`auto_rebase_onto_main`) и **локально
+пере-прогоняет весь тест-сюит** (`retest_branch` → `python -m pytest tests/ -q`, бюджет
+`merge_retest_timeout_s=600`), чтобы поймать семантический конфликт слияния (зелёная по своей базе
+ветка ломает уехавший `main`).
+
+**Инцидент (ORCH-109 / PR #129, факты сверены по коду):** tester `PASS` (полный регресс
+`1899 passed` за `516.70s`), CI Gitea зелёный, PR `mergeable=true`, ветка не-behind — но merge-gate
+re-test **упал по таймауту** (`re-test timeout after 600s`). На хосте — осиротевшие pytest-процессы
+(`tests/test_install_lite_script.py`), жившие > 2 суток и грузившие CPU. Цепочка отказа: осиротевшие
+процессы → CPU-голодание → сюит (516.7s, запас до 600s ≈ 16%) превысил бюджет →
+`check_branch_mergeable` вернул `(False, "re-test timeout after 600s")` → `_handle_merge_gate`
+маршрутизировал в `_handle_merge_gate_rollback` (откат `deploy-staging → development` +
+developer-retry) → каждый из 3 retry падал по тому же CPU-голоданию → alert «Merge-gate still failing
+after 3 developer retries» → задача застряла, потребовалось ручное вмешательство.
+
+**Корни (подтверждены по коду):**
+1. **Утечка осиротевших процессов.** `merge_gate.retest_branch` (`src/merge_gate.py:202`) и
+   `coverage_gate.measure_coverage` (`src/coverage_gate.py:156`) запускают
+   `subprocess.run([... pytest ...], timeout=...)` **без изоляции группы процессов**. При
+   `TimeoutExpired` Python убивает только **прямого потомка** (`proc.kill()`); внуки pytest
+   репарентируются на PID 1 (tini жнёт зомби, но не убивает живых сирот) и живут сутками. Это
+   источник CPU-голодания.
+2. **Нет толерантности к инфра-таймауту.** `_handle_merge_gate` (`src/stage_engine.py:967`)
+   различает лишь `"merge-lock busy"` (→ defer) от всего остального (→ rollback). Re-test **таймаут**
+   (инфра/ресурс) классифицируется идентично **красному** re-test (дефект кода) → откат на
+   `development` + расход developer-retry, который разработчик не может «починить».
+3. **Тонкий бюджет.** `merge_retest_timeout_s=600` практически равен фактическому времени сюита
+   (516.7s); запас не растёт с сюитом.
+4. **Контракт необходимости re-test.** При `premerge_rebase_always=True` (дефолт, ORCH-026 A-2)
+   `check_branch_mergeable` (`src/qg/checks.py:705`) **всегда** ребейзит и пере-тестирует — даже на
+   ветке, уже актуальной к `origin/main` (rebase — no-op). На таком HEAD локальный re-test
+   пере-проверяет ровно тот коммит, что CI + tester + staging уже подтвердили, становясь избыточной
+   единственной точкой ложного отказа. (Заметим: на пути `premerge_rebase_always=False` не-behind
+   ветка re-test **уже пропускает** — `src/qg/checks.py:707-709`.)
+
+Баг-карточка явно отложила выбор механизма архитектору: «Решение намеренно не описано; нужен
+отдельный анализ вариантов и контрактов merge-gate» — основание эскалации `escalate: full-cycle`.
+
+## Решение
+
+### Сводка
+
+Бьём по двум корням, одному контракту и одному бюджету — **аддитивно, под kill-switch, never-raise,
+скоуп self-hosting**, сохраняя исходную защиту merge-gate от семантического конфликта:
+
+- **D1 (root)** — единый leaf `src/proc_group.py` спавнит оркестратор-порождённые pytest-прогоны в
+  **отдельной группе процессов** (`start_new_session`) и при таймауте/прерывании убивает **всё
+  дерево** (`os.killpg`, каскад SIGTERM→grace→SIGKILL). Используют его `retest_branch` и
+  `measure_coverage`. Контракты возврата сохранены — меняется лишь побочный эффект (нет сирот).
+- **D2 (классификация)** — чистый предикат `merge_gate.classify_retest_failure(reason)` различает
+  `timeout`/`red`/`lock-busy`/`other` без смены имени/семантики `check_branch_mergeable`.
+- **D3 (маршрутизация)** — инфра-таймаут → новый `_handle_merge_gate_infra_retry` (ограниченный
+  повтор/defer по образцу `_handle_merge_gate_defer`, **без** отката на `development` и **без**
+  расхода developer-retry); красный re-test → прежний `_handle_merge_gate_rollback`.
+- **D4 (контракт re-test)** — re-test исполняется **тогда и только тогда**, когда rebase реально
+  сдвинул HEAD (`main` уехал); no-op rebase (ветка уже актуальна) **пропускает** локальный re-test,
+  ровно как уже делает путь `premerge_rebase_always=False` для не-behind ветки.
+- **D5 (бюджет)** — `merge_retest_timeout_s` 600 → **900** (запас 74% над 516.7s) с валидацией и
+  проверкой сквозного инварианта reaper/lease — **без** изменения `reaper_max_running_s`.
+- **D6 (наблюдаемость)** — счётчики в `merge_gate`, блок `merge_gate` в `GET /queue`, отдельный
+  инфра-alert, отличимый от код-фейла; координация с ORCH-111 без дубля.
+
+### D1 — Process-group изоляция + tree-kill спавненных pytest [FR-2 / BR-3 / AC-4]
+
+Новый **leaf-модуль** `src/proc_group.py` (stdlib-only, never-raise, импортирует только `os`/`signal`/
+`subprocess`/`time`/`logging` — НЕ другие `src/*`, по образцу чистоты `serial_gate`/`staging_verdict`):
+
+```python
+def run_in_process_group(
+    cmd: list[str], *, cwd: str, timeout: float, env: dict | None = None,
+    grace_s: float = 5.0, tree_kill: bool = True,
+) -> ProcResult:   # ProcResult(returncode:int|None, stdout:str, stderr:str, timed_out:bool)
+```
+
+Механика (POSIX):
+1. `proc = subprocess.Popen(cmd, cwd=cwd, env=env, stdout=PIPE, stderr=PIPE, text=True,
+   start_new_session=True)` — `start_new_session=True` делает потомка лидером новой сессии/группы
+   (`setsid`), поэтому все его потомки (xdist-воркеры, подпроцессы тестов) разделяют один `pgid ==
+   proc.pid`.
+2. `proc.communicate(timeout=timeout)` — ждём в бюджете.
+3. На `subprocess.TimeoutExpired` — **tree-kill группы** каскадом, зеркало `launcher.stop_process`,
+   но по **группе**: `os.killpg(os.getpgid(pid), SIGTERM)` → poll `grace_s` → если жива
+   `os.killpg(..., SIGKILL)`; затем обязательный `proc.communicate()`/`proc.wait()` (reap), чтобы не
+   оставить зомби. `ProcessLookupError` толерируется на каждом шаге.
+4. Возвращает `timed_out=True` при таймауте; иначе `returncode`/stdout/stderr.
+
+**Fallback (never-break):** при `tree_kill=False` ИЛИ платформе без `os.killpg`/`start_new_session`
+(`not hasattr(os, "killpg")`) — деградирует на прежний `subprocess.run(cmd, ..., timeout=timeout)`
+(байт-в-байт прежнее поведение, прод-Linux на это не попадает).
+
+**Интеграция:**
+- `retest_branch` зовёт `run_in_process_group([... pytest target -q], cwd=wt, timeout=<resolved>,
+  tree_kill=settings.subprocess_tree_kill_enabled, grace_s=settings.agent_kill_grace_seconds)`;
+  маппинг исхода 1:1 прежнему: `timed_out → (False, "re-test timeout after <T>s")`,
+  `returncode==0 → (True, "re-test green")`, иначе `(False, "re-test failed: ...<tail>")`. **Контракт
+  возврата сохранён** (FR-2) — меняется лишь отсутствие утечки.
+- `measure_coverage` зовёт тот же helper для `pytest --cov`; исход маппится как сейчас (таймаут/ошибка
+  → `None`, иначе чтение `--cov-report=json`). Грантия tree-kill — сиблинг-источник утечки закрыт
+  (BR-3).
+
+Грейс берётся из существующего `agent_kill_grace_seconds` (новый ключ не вводим — минимизация
+конфига); для subprocess-pytest грейс короткий и без необходимости «флашить артефакты».
+
+Kill-switch `subprocess_tree_kill_enabled` (дефолт `True`). Это **глобальная** гигиена процессов (не
+гейт-решение), поэтому без `*_repos`-скоупа; на практике оба call-site исполняются лишь для
+merge_gate/coverage-репо (self-hosting).
+
+### D2 — Классификация исхода re-test [FR-1 / AC-2 / TC-03]
+
+Чистый предикат в `src/merge_gate.py` (never-raise), единая точка «магической строки» вместо россыпи
+`"timeout" in reason`:
+
+```python
+def classify_retest_failure(reason: str) -> str:
+    # "timeout"  — re-test упёрся в бюджет (инфра/ресурс)
+    # "red"      — детерминированно красный re-test (дефект кода)
+    # "lock-busy"— merge-lock busy (контеншн леза)
+    # "other"    — rebase conflict / setup error / прочее
+```
+
+`check_branch_mergeable` **не меняет** имя/семантику/PASS-FAIL контракт (NFR-1): он уже возвращает
+различимый reason (`"re-test timeout after <T>s"` vs `"re-test failed after rebase: ..."` vs
+`"merge-lock busy"` vs `"rebase conflict: ..."`). Меняется только **различение причины FAIL** на
+слое маршрутизации.
+
+**Скоуп классификации — строго re-test таймаут.** `auto_rebase_onto_main` имеет собственный
+`"rebase timeout"` (git завис) — это **другой** инфра-таймаут, но без успешного rebase ветку нельзя
+догнать до `main` → merge невозможен по существу. Он остаётся на прежнем rollback-пути (вне объёма
+ORCH-110; консервативно). Документируем границу явно.
+
+### D3 — Маршрутизация инфра-таймаута: ограниченный повтор + инфра-alert [FR-1 / FR-6 / NFR-5 / AC-1 / AC-9]
+
+В `_handle_merge_gate` (`src/stage_engine.py`) после ветки `reason == "merge-lock busy"`:
+
+```python
+if (settings.merge_retest_infra_tolerance_enabled
+        and merge_gate.classify_retest_failure(reason) == "timeout"):
+    _handle_merge_gate_infra_retry(task_id, current_stage, repo, work_item_id, branch, reason, result)
+    return True
+_handle_merge_gate_rollback(...)   # red re-test / conflict — БЕЗ изменений (BR-6/AC-3)
+```
+
+Новый `_handle_merge_gate_infra_retry` — зеркало `_handle_merge_gate_defer` (НЕ rollback):
+- Перекладывает staging-deployer обратно в очередь с задержкой `merge_retest_infra_retry_delay_s`
+  (`enqueue_job("deployer", ..., available_at_delay_s=...)`); задача **остаётся на `deploy-staging`**.
+  **Нет** `update_task_stage("development")`, **нет** инкремента developer-retry, **нет**
+  `notify_qg_failure`-код-фейл-семантики.
+- Счётчик повторов — restart-safe, по маркеру в `task_content` (`_merge_infra_retry_count`, зеркало
+  `_merge_defer_count`: `... LIKE '%merge-gate infra-timeout retry%'`). Бюджет
+  `merge_retest_infra_max_retries` (дефолт 2).
+- **Лиз уже освобождён** `check_branch_mergeable` при таймауте (`src/qg/checks.py:721`) — на повторе
+  гейт переacquire'ит штатно (как defer-путь). Согласовано с инвариантом леза.
+- **Исчерпание (anti-loop, NFR-5):** `set_issue_blocked` + **отдельный инфра-alert** (Telegram с
+  кликабельным `link_for` + Plane-коммент), формулировка **явно инфраструктурная**, отличная от
+  «developer must fix»: *«Merge-gate re-test infra-timeout сохраняется после N повторов — ресурсная
+  проблема (CPU/осиротевшие процессы), НЕ дефект кода. Нужно ручное вмешательство /
+  проверьте хост.»* Задача **не** уходит в `development`.
+
+**Ограниченность по времени (NFR-5/AC-9).** Каждый повтор — **отдельный** staging-deployer job со
+своим agent-timeout и reaper-backstop; ни один прогон не превышает `reaper_max_running_s` сам по себе.
+Суммарная стоимость худшего случая: `N × (delay + re-test ≤ timeout)` =
+`2 × (120 + 900) ≈ 34 мин` до инфра-alert — конечно и наблюдаемо. После первого таймаута D1 уже убил
+сирот, поэтому следующий re-test, как правило, проходит — повтор есть механизм восстановления, а не
+маскировки.
+
+**Скоуп.** Отдельный `*_repos` не нужен: путь достижим только когда merge-gate **реален**
+(`_merge_gate_applies` → self-hosting/`merge_gate_repos`); для прочих репо гейт N/A → PASS → ветка
+недостижима. Kill-switch off → таймаут идёт прежним rollback-путём (NFR-2, байт-в-байт).
+
+### D4 — Контракт необходимости локального re-test [FR-4 / BR-5 / BR-6 / AC-6]
+
+**Выбранный вариант — пропуск re-test при no-op rebase** (ветка уже содержит свежий `origin/main`).
+ORCH-043 защищает от семантического конфликта, который возникает **только** когда `main` уехал и
+ветка была реально ребейзнута на новые коммиты. Если rebase HEAD **не сдвинул** (ветка уже актуальна),
+«уехавшего main» нет → re-test не даёт сигнала сверх уже пройденных `check_ci_green` + tester
+`check_tests_passed` + staging на **этом же** HEAD → он избыточен.
+
+Реализация в `check_branch_mergeable` (детерминированно, **offline**, без сетевого CI-запроса):
+1. `pre = _head_sha(repo, branch)` (rev-parse HEAD в worktree, never-raise → `""`).
+2. `auto_rebase_onto_main(...)` (как сейчас; конфликт → release lease → FAIL без изменений).
+3. `post = _head_sha(repo, branch)`.
+4. Если `merge_retest_skip_when_current_enabled` И `pre` и `post` непусты И `pre == post` (rebase —
+   доказанный no-op) → **пропустить re-test**, вернуть
+   `(True, "branch up-to-date (re-test skipped: rebase no-op, HEAD CI-validated)")`; лиз HELD.
+5. Иначе (HEAD сдвинут / SHA не определить / флаг off) → `retest_branch` как сейчас.
+
+**Почему без отдельного сетевого CI-запроса (отличие от варианта C).** HEAD на момент merge-gate при
+no-op rebase — тот же коммит, что уже прошёл `check_ci_green` (ребро development→review), tester и
+staging в этом же конвейере. «CI green for this HEAD» гарантирован **транзитивно** пройденным
+конвейером; повторный сетевой запрос статуса — лишняя зависимость и хрупкость.
+
+**Fail-safe к контракту (BR-6/AC-3):** при невозможности доказать no-op (любой `pre`/`post` пуст,
+git-ошибка) — re-test **выполняется** (не пропускается на неопределённости). Когда re-test
+**исполняется** и красный → прежний rollback. Послабление применяется ТОЛЬКО к доказанному no-op, и
+только к *пропуску*, не к красному вердикту. Это симметрично уже существующему пропуску re-test на
+не-behind ветке при `premerge_rebase_always=False` — D4 лишь распространяет ту же оптимизацию на
+no-op-rebase случай `premerge_rebase_always=True`, приводя оба режима к согласованному правилу:
+«локальный re-test гоняется лишь когда ветка реально догоняла уехавший `main`».
+
+Kill-switch `merge_retest_skip_when_current_enabled` (дефолт `True`); off → re-test после rebase
+всегда (прежнее `premerge_rebase_always` поведение).
+
+### D5 — Согласование бюджета re-test [FR-3 / BR-4 / AC-5 / NFR-6]
+
+`merge_retest_timeout_s`: **600 → 900** (запас 74% над наблюдаемыми 516.7s; против прежних ≈16%).
+Бюджет — теперь **третья** линия защиты (D1 убирает корень CPU-голодания, D3 толерирует редкий
+остаточный таймаут, D4 резко сокращает частоту re-test), поэтому большой бамп не нужен; умеренные 900
+дают runway под рост сюита, оставаясь в сквозном инварианте reaper **без** правки
+`reaper_max_running_s`.
+
+**Валидация (never-break):** `retest_branch` резолвит бюджет через новый
+`_resolve_retest_timeout()` — `int(settings.merge_retest_timeout_s)` если `> 0`, иначе дефолт **900**
++ WARNING (зеркало `launcher._resolve_timeout`). Малформ/непозитив больше не уходит в `subprocess`.
+
+**Проверка сквозного инварианта (NFR-6, AC-5).** Re-test/coverage исполняются в монитор-потоке
+**staging-deployer**-джоба (агент deployer уже завершён; `advance_stage` post-agent), поэтому суммарная
+работа джоба считается против `reaper_max_running_s`. Worst-case для deploy-staging-джоба:
+
+| Слагаемое | Бюджет, s |
+|-----------|-----------|
+| deployer-агент (deploy-staging, `agent_timeout_seconds`) | 1800 |
+| security-scan (gitleaks+pip-audit) | ~120 |
+| rebase (`_REBASE_TIMEOUT`) | 120 |
+| **re-test (`merge_retest_timeout_s`, новый)** | **900** |
+| coverage (`coverage_run_timeout_s`) | 900 |
+| image-freshness rebuild | ~600 |
+| grace | 20 |
+| **Σ** | **≈ 4460** |
+
+`reaper_max_running_s = 5400 > 4460` ✓ (запас ~940s). Инвариант ORCH-065/109
+`reaper_max_running_s > max(agent_timeout)+grace` (5400 > 3600+20 для developer-джоба) сохранён.
+`merge_lock_timeout_s = 300` (TTL леза) **меньше** держания леза на время re-test+coverage — но это
+**существующее** свойство (ORCH-043: лиз держится от гейта до merge, дольше TTL; реклейм безопасен
+holder-aware и pid-aware, ORCH-065) и **не** ухудшается ORCH-110 (re-test 900 vs прежние 600 — +300s
+держания, всё ещё покрыто pid-liveness реклеймом, который не трогает живого держателя). Поэтому
+`reaper_max_running_s` **не меняем**; D5 — только бамп `merge_retest_timeout_s` + валидация.
+
+> Если оператор поднимет `merge_retest_timeout_s` env'ом выше — обязан соблюсти
+> `reaper_max_running_s > Σ(deploy-staging gate-work) + grace` (таблица выше); зафиксировано в
+> `07-infra-requirements.md`.
+
+### D6 — Наблюдаемость и координация с ORCH-111 [FR-6 / BR-7 / AC-9 / R-4]
+
+- **Счётчики** in-process в `merge_gate.py` (`_MERGE_GATE_COUNTERS`, образец `_MERGE_VERIFY_COUNTERS`):
+  `retest_timeout_total`, `retest_infra_retry_total`, `retest_infra_exhausted_total`,
+  `retest_skipped_current_total`, `last_infra_timeout_wi`. Снимок `merge_gate_status()` → read-only
+  блок `merge_gate` в `GET /queue` (флаги/счётчики). Только информация, никогда не источник решения.
+- **Логи** — раздельные строки для infra-retry vs code-fail rollback; INFO на пропуск re-test (D4).
+- **Telegram/Plane** — инфра-alert на исчерпании (D3), формулировка инфраструктурная (не «developer
+  must fix») с кликабельным номером.
+- **Координация с ORCH-111 (`proc_blocking`, adr-0041) — без дубля (R-4):** ORCH-110
+  **предотвращает/толерирует** (tree-kill у источника + транзиент-маршрут), ORCH-111 **наблюдает**
+  (sidecar алертит на пережившие осиротевшие тест-процессы). ORCH-110 не вводит детектор процессов;
+  он убирает сирот у источника. Разные слои — нулевое пересечение.
+
+### Затронутые маркеры / трассировка (ORCH-078)
+
+Правки касаются блоков с маркерами ORCH-043 (`retest_branch`, `check_branch_mergeable`, lease),
+ORCH-026 (`premerge_rebase_always`), ORCH-027 (`measure_coverage`), ORCH-065/109 (инвариант
+reaper/timeout). 3+ маркера в `merge_gate.py` → опираемся на **сводный сквозной**
+`adr-0042` (этот пакет) + `adr-0006`/`adr-0040`. Инварианты ORCH-043/071/073/093 (лиз holder-aware,
+INV-4 «никогда push/force-push main», never-raise, fail-open/closed классификации) **не нарушаются**:
+ORCH-110 не трогает merge-актор/верификатор пути `deploy → done`.
+
+**Директива developer'у (append-only regression-guard, ORCH-073):** дописать в
+`merge_gate.MAIN_REGRESSION_MARKERS` строку `("ORCH-110", "classify_retest_failure",
+"src/merge_gate.py")`, чтобы новый инвариант был защищён от фантомного отката.
+
+## Альтернативы
+
+- **Только поднять бюджет (без D1).** Отвергнуто (R-2): не бьёт корень — растущий сюит снова упрётся;
+  сироты продолжат грузить CPU. Бюджет — вторичная мера.
+- **Tree-kill через `subprocess.run` + ручной `Popen` в каждом модуле (без общего leaf).** Отвергнуто:
+  дублирование хрупкой `killpg`-логики в двух местах → дрейф. Один тестируемый leaf
+  (`proc_group.py`) — single source of truth.
+- **Вариант C: trust-CI-SHA (сетевой запрос статуса CI HEAD → skip re-test).** Отвергнуто как контракт
+  по умолчанию: вводит сетевую зависимость в детерминированный offline-гейт и ослабляет
+  семантик-конфликт-гард (CI бежал на базе ветки, не на результате слияния). D4 (no-op-rebase skip)
+  даёт ту же выгоду детерминированно и offline.
+- **Толерировать ЛЮБОЙ FAIL merge-gate (включая красный) как транзиент.** Отвергнуто (BR-6/AC-3,
+  R-1): сломает цель ORCH-043 — красный re-test обязан откатывать. Послабление строго к таймауту.
+- **Новый зарегистрированный QG / новая стадия для инфра-ретрая.** Отвергнуто (NFR-1): под-гейт —
+  врезка в `advance_stage`; `STAGE_TRANSITIONS`/`QG_CHECKS` неприкосновенны.
+- **Init-process / убийца сирот на хосте.** Отвергнуто: реинтродукция привилегий/хост-доступа;
+  предотвращение у источника (D1) проще и self-hosting-безопасно; наблюдение оставлено ORCH-111.
+
+## Последствия
+
+- **+** Зелёный путь (tester PASS + CI green + актуальная ветка) больше не ловит ложный откат/manual-gate
+  из-за инфра-таймаута (BR-1/AC-1). Сироты не переживают бюджет (BR-3/AC-4). Re-test не гоняется
+  избыточно на актуальной ветке (BR-5/AC-6), что само снижает шанс таймаута.
+- **+** Красный re-test по-прежнему откатывает (BR-6/AC-3); инварианты конвейера/леза/INV-4
+  неприкосновенны (NFR-1/NFR-3/AC-8).
+- **−** Инфра-таймаут добавляет до `N×(delay+timeout)` (~34 мин) к худшему случаю перед инфра-alert
+  (вместо мгновенного, но ложного, отката). Митигейшн: D1 устраняет первопричину → повтор обычно
+  проходит первым; бюджет повторов мал (2).
+- **−** +5 конфиг-ключей + бамп бюджета. Митигейшн: дефолты = желаемое прод-поведение (ORCH-101
+  канон), каждый под kill-switch.
+- **−** D4 пропускает re-test на no-op rebase: теоретический пропуск семантик-конфликта, не
+  поймать который CI/tester/staging уже не смогли бы. Митигейшн: пропуск **только** при доказанном
+  no-op (нет «уехавшего main» → нет нового класса конфликта); на любой неопределённости — re-test
+  бежит (fail-safe).
+- **Откат:** `subprocess_tree_kill_enabled=False` (→ прежний `subprocess.run`),
+  `merge_retest_infra_tolerance_enabled=False` (→ таймаут=rollback),
+  `merge_retest_skip_when_current_enabled=False` (→ всегда re-test после rebase),
+  `merge_retest_timeout_s=600` (→ прежний бюджет). Каждый флаг независим; полный откат = вернуть 4
+  значения → байт-в-байт до-ORCH-110.
+
+## Ссылки
+- BRD: `docs/work-items/ORCH-110/01-brd.md`
+- TRZ: `docs/work-items/ORCH-110/02-trz.md`
+- Acceptance: `docs/work-items/ORCH-110/03-acceptance-criteria.md`
+- Test-plan: `docs/work-items/ORCH-110/04-test-plan.yaml`
+- Инфра: `docs/work-items/ORCH-110/07-infra-requirements.md`
+- Риски: `docs/work-items/ORCH-110/10-tech-risks.md`
+- Сквозной ADR: `docs/architecture/adr/adr-0042-merge-gate-retest-infra-tolerance-and-tree-kill.md`
+- Сверено по коду: `src/merge_gate.py` (`retest_branch`, `auto_rebase_onto_main`,
+  `MAIN_REGRESSION_MARKERS`), `src/coverage_gate.py` (`measure_coverage`),
+  `src/qg/checks.py` (`check_branch_mergeable`, `_merge_gate_applies`),
+  `src/stage_engine.py` (`_handle_merge_gate`, `_handle_merge_gate_defer`,
+  `_handle_merge_gate_rollback`, `_merge_defer_count`),
+  `src/config.py` (`merge_retest_timeout_s`, `reaper_max_running_s`, `agent_kill_grace_seconds`),
+  `src/agents/launcher.py` (`stop_process` — образец каскада),
+  `src/job_reaper.py` (`reaper_max_running_s` backstop)
+- Смежные: `adr-0006` (merge-gate ORCH-043), `adr-0040` (timeout-бюджеты ORCH-109),
+  `adr-0029` (coverage-gate ORCH-027), `adr-0011` (reaper/lease ORCH-065),
+  `adr-0041` (ORCH-111 `proc_blocking` — комплементарный наблюдатель)
+</content>
+</invoke>

docs/work-items/ORCH-110/07-infra-requirements.md

@@ -0,0 +1,68 @@
+---
+work_item: ORCH-110
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# 07 — Инфра-требования: ORCH-110 — merge-gate re-test infra-tolerance + tree-kill
+
+Work Item: **ORCH-110** · Repo: **orchestrator** · Стадия: architecture
+
+> When-applicable. Топология/контейнеры/порты/CI **не меняются**; файл фиксирует новые env-ключи,
+> сквозной инвариант времени и аудит self-hosting безопасности.
+
+## I-1. Топология / окружения
+**N/A.** Новых контейнеров/портов/томов/сетей нет. Изменения — только в коде приложения
+(`src/proc_group.py` новый leaf; правки `merge_gate`/`coverage_gate`/`qg.checks`/`stage_engine`/
+`config`) и в значениях конфигурации. Прод `orchestrator` (8500) / staging (8501) — без изменений
+топологии.
+
+**Требование среды:** оркестратор должен исполняться под POSIX (Linux-контейнер, как сейчас) — D1
+использует `os.setsid`/`os.killpg`/`os.getpgid`. На не-POSIX helper деградирует на прежний
+`subprocess.run` (never-break), но боевая среда — Linux.
+
+## I-2. Переменные окружения / секреты
+Секретов нет. Новые ключи (`src/config.py` + `.env.example`); **дефолт каждого = желаемому
+прод-поведению** (ORCH-101 канон: пустой `.env` воспроизводит целевое поведение):
+
+| Ключ (config) | Env | Дефолт | Назначение |
+|---------------|-----|--------|------------|
+| `subprocess_tree_kill_enabled` | `ORCH_SUBPROCESS_TREE_KILL_ENABLED` | `True` | D1 kill-switch; off → прежний `subprocess.run(timeout=)` |
+| `merge_retest_infra_tolerance_enabled` | `ORCH_MERGE_RETEST_INFRA_TOLERANCE_ENABLED` | `True` | D3 kill-switch; off → таймаут = прежний rollback |
+| `merge_retest_infra_max_retries` | `ORCH_MERGE_RETEST_INFRA_MAX_RETRIES` | `2` | D3 бюджет повторов инфра-таймаута |
+| `merge_retest_infra_retry_delay_s` | `ORCH_MERGE_RETEST_INFRA_RETRY_DELAY_S` | `120` | D3 задержка перед повтором staging-deployer |
+| `merge_retest_skip_when_current_enabled` | `ORCH_MERGE_RETEST_SKIP_WHEN_CURRENT_ENABLED` | `True` | D4 kill-switch; off → re-test после rebase всегда |
+| `merge_retest_timeout_s` (изменение значения) | `ORCH_MERGE_RETEST_TIMEOUT_S` | `600 → 900` | D5 бюджет re-test (запас 74% над 516.7s) |
+
+Реюз существующего `agent_kill_grace_seconds` (грейс tree-kill каскада) — новый ключ не вводится.
+
+## I-3. Деплой / рестарт
+- **Self-hosting инвариант соблюдён:** изменение НЕ рестартит прод-контейнер, НЕ пушит/force-push
+  `main` (INV-4), НЕ трогает detached-деплой. Выкат — штатным конвейером через **обязательный
+  staging-гейт (8501)**.
+- Дефолты вступают в силу при следующей сборке образа; ручных env-шагов на хосте не требуется
+  (дефолты = целевое поведение). Откат — выставить 4 kill-switch в `False` и
+  `ORCH_MERGE_RETEST_TIMEOUT_S=600`.
+
+## I-4. CI/CD
+**Без изменений** `.gitea/workflows/`. Новые pytest-тесты (`tests/test_orch110_*.py` по
+`04-test-plan.yaml`) исполняются существующим шагом `pytest tests/ -q`. Новых зависимостей нет
+(`proc_group` — stdlib-only; `pytest-cov` уже в образе по ORCH-027).
+
+## I-5. Сквозной инвариант времени (NFR-6 — операционно критично)
+Re-test/coverage исполняются в монитор-потоке staging-deployer-джоба, поэтому их суммарная работа
+считается против `reaper_max_running_s`. Проверенный worst-case deploy-staging-джоба:
+
+```
+deployer-агент 1800 + security ~120 + rebase 120 + re-test 900 + coverage 900 + image ~600 + grace 20
+≈ 4460 s  <  reaper_max_running_s = 5400   (запас ~940 s)  ✓
+```
+
+`reaper_max_running_s` **не меняется** (D5). При ручном повышении `ORCH_MERGE_RETEST_TIMEOUT_S` env'ом
+оператор ОБЯЗАН сохранить неравенство `reaper_max_running_s > Σ(gate-work) + grace`, иначе reaper
+(ORCH-065) может реапнуть легитимный мид-гейт джоб; при необходимости поднять
+`ORCH_REAPER_MAX_RUNNING_S` в локстеп (паттерн ORCH-109).
+</content>

docs/work-items/ORCH-110/10-tech-risks.md

@@ -0,0 +1,40 @@
+---
+work_item: ORCH-110
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# 10 — Технические риски: ORCH-110 — merge-gate re-test infra-tolerance + tree-kill
+
+Work Item: **ORCH-110** · Repo: **orchestrator** · Стадия: architecture
+
+> Информационный (гейтом не парсится). Риски реализации и их митигейшн.
+
+## Реестр рисков
+
+| ID | Риск | Вер. | Влия. | Митигейшн |
+|----|------|------|-------|-----------|
+| TR-1 | **Над-толерантность маскирует реально зависший тест ветки** как «инфра» (R-1 BRD): бесконечный/долгий тест ветки → таймаут → толерируется → задача не падает на дефекте | Низ. | Выс. | Строгая ограниченность D3 (`merge_retest_infra_max_retries=2`, суммарное время ≤ ~34 мин) → исчерпание = **инфра-alert** (не молчание); красно-откат-путь сохранён (BR-6); D4 не пропускает re-test когда HEAD реально сдвинут. Остаточно: «зависший тест ветки» эскалируется как инфра, а не код — приемлемо (оператор увидит alert и разберёт; тест-зависание чинит developer вручную) |
+| TR-2 | **`os.killpg`/`start_new_session` платформенная зависимость** (не-POSIX / урезанный контейнер) | Низ. | Сред. | Гард `hasattr(os, "killpg")` + kill-switch `subprocess_tree_kill_enabled` → fallback на прежний `subprocess.run` (never-break); бой — Linux |
+| TR-3 | **Tree-kill убьёт не те процессы** (неверный pgid → SIGKILL чужой группе) | Низ. | Выс. | `pgid == proc.pid` гарантирован `start_new_session` для **нашего** потомка; killpg только по `os.getpgid(proc.pid)` нашего Popen; `ProcessLookupError` толерируется; никогда не киляем pgid 0/own |
+| TR-4 | **Рассинхрон сквозных таймаутов** при бампе бюджета (R-3 BRD): re-test 900 + coverage 900 + агент → > reaper_max_running_s | Низ. | Сред. | Проверенная таблица worst-case (≈4460 < 5400, 07-infra I-5); `reaper_max_running_s` не меняется; валидация непозитивного бюджета → дефолт+WARNING; операторская заметка про ручной бамп |
+| TR-5 | **Магическая строка классификации** (`"timeout" in reason`) хрупка к смене текста reason | Низ. | Сред. | Единый предикат `classify_retest_failure` (одна тестируемая точка, TC-03) вместо россыпи; reason — стабильный контракт ORCH-043 (как `"merge-lock busy"`) |
+| TR-6 | **D4 пропустит re-test и пропустит семантический конфликт** | Оч.низ. | Сред. | Пропуск ТОЛЬКО при доказанном no-op rebase (нет «уехавшего main» → нет нового класса конфликта); на неопределённости (`pre`/`post` пуст / git-ошибка) re-test бежит (fail-safe); HEAD уже прошёл CI+tester+staging транзитивно |
+| TR-7 | **Дубль/конфликт с ORCH-111** (`proc_blocking`) | Оч.низ. | Низ. | Чёткое разделение слоёв (D6): ORCH-110 предотвращает/толерирует у источника, ORCH-111 наблюдает; ORCH-110 не вводит детектор процессов |
+| TR-8 | **Регресс при выключенном флаге** (нарушен байт-в-байт fallback) | Низ. | Выс. | TC-07 проверяет kill-switch off = прежнее поведение и enduro no-op; каждый из 4 флагов независим и off → старый путь |
+| TR-9 | **Гонка leдза на инфра-ретрае** (повторный acquire, держание дольше TTL) | Низ. | Сред. | Существующее свойство ORCH-043 (лиз держится дольше TTL; реклейм holder-aware + pid-aware, ORCH-065 не трогает живого держателя); таймаут уже освободил лиз перед ретраем — переacquire штатный |
+
+## Сводный вывод
+Доминирующий класс — **над-толерантность vs анти-регресс защиты merge-gate** (TR-1/TR-6): закрыт
+строгой ограниченностью + сохранением красно-откат-пути + пропуском re-test только на доказанном
+no-op. Остальные риски — стандартного класса (платформенная зависимость, сквозные таймауты,
+kill-switch регресс), митигированы существующими паттернами кодовой базы (never-raise, fail-safe,
+дефолт=бой, валидация). Изменение **аддитивно** и **полностью обратимо** флагами; новой стадии/QG/
+схемы БД нет. **Эскалация `arch:major-change` не требуется**; возврат в анализ не требуется. Остаточный
+риск для прод-конвейера (self-hosting) — **низкий**: critical-path не трогает `main`/прод-рестарт/
+detached-деплой, а наихудший новый сценарий (инфра-alert после ретраев) строго лучше текущего (ложный
+manual-gate).
+</content>

docs/work-items/ORCH-110/12-review.md

@@ -0,0 +1,112 @@
+---
+verdict: APPROVED        # APPROVED | REQUEST_CHANGES — строго одно из двух, UPPERCASE
+work_item: ORCH-110
+stage: review
+author_agent: reviewer
+status: approved
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+type: review
+work_item_id: ORCH-110
+version: 1
+---
+
+# Review ORCH-110
+
+> Машинный вердикт читается ТОЛЬКО из `verdict:` во frontmatter. `APPROVED` → дальше по конвейеру.
+
+## Summary
+Багфикс инцидента ORCH-109/PR#129 (bug → escalate full-cycle): локальный re-test merge-gate падал по
+**таймауту** при зелёных CI+tester+staging → ложно маршрутизировался как код-фейл (откат
+`deploy-staging → development` + расход developer-retry) → manual-gate. Реализация **полностью
+соответствует ТЗ (FR-1…FR-6, AC-1…AC-10) и ADR-001 (D1…D6)**, аддитивна, под 5 независимыми
+kill-switch, never-raise, скоуп self-hosting. Инварианты конвейера и self-hosting — байт-в-байт целы;
+документация (golden source) обновлена в том же PR; багфикс несёт регресс-тест-фиксатор (ORCH-019 BR-4 /
+AC-10). **Вердикт: APPROVED** — P0/P1/P2 findings нет.
+
+> Замечание по ревью-процессу (не finding): локальный ref `main` в worktree устарел (6a04d0a);
+> истинная цель мержа — `origin/main` (b6c9d27, уже содержит ORCH-111). Диф против `origin/main`
+> добавляет ровно 4 ORCH-110-коммита (fix + analysis + architect + business-request); посторонних
+> изменений нет. Ревью проведено против `origin/main`.
+
+## Оси проверки
+
+### 1. Соответствие ТЗ (02-trz / 03-acceptance-criteria) — PASS
+- **FR-1/AC-1/AC-2** (толерантность к инфра-таймауту, отдельная классификация): `merge_gate.classify_retest_failure`
+  (`timeout`/`red`/`lock-busy`/`other`) + `stage_engine._handle_merge_gate_infra_retry` (зеркало
+  `_handle_merge_gate_defer`: задача остаётся на `deploy-staging`, БЕЗ отката/developer-retry). ✓
+- **FR-2/AC-4** (tree-kill): новый stdlib-only leaf `src/proc_group.py::run_in_process_group`
+  (`start_new_session` → `os.killpg` SIGTERM→grace→SIGKILL), интегрирован в `retest_branch` и
+  `measure_coverage`; реальный grandchild-тест TC-01 доказывает «сирота не переживает таймаут». ✓
+- **FR-3/AC-5** (бюджет): `merge_retest_timeout_s` 600→900 + `_resolve_retest_timeout` (малформ/непозитив
+  → дефолт 900 + WARNING); сквозной инвариант `reaper_max_running_s (5400) > Σ≈4460 + grace` проверен
+  тестом TC-08 **без** правки `reaper_max_running_s`. ✓
+- **FR-4/AC-6/AC-3 (BR-6)** (контракт необходимости re-test): пропуск re-test при доказанном no-op rebase
+  (`head_sha` до==после, обе непусты) в `check_branch_mergeable`; fail-safe — на любой неопределённости
+  re-test выполняется; красный re-test/конфликт по-прежнему откатывают (тест
+  `test_tc10_real_catchup_red_retest_still_rolls_back`). ✓
+- **FR-5/AC-7/AC-8** (kill-switch + нулевая регрессия + инварианты): 5 независимых флагов (дефолт = боевое);
+  `STAGE_TRANSITIONS`/реестр `QG_CHECKS`/семантика и имя `check_branch_mergeable`/machine-verdict/схема БД —
+  статически подтверждено «не тронуты»; INV-4 (никогда push/force-push `main`) соблюдён. ✓
+- **FR-6/AC-9** (наблюдаемость + anti-loop): счётчики `_MERGE_GATE_COUNTERS` + read-only блок `merge_gate`
+  в `GET /queue`; ограниченность по попыткам (`merge_retest_infra_max_retries=2`, restart-safe счётчик по
+  маркеру в `task_content`) и времени; исчерпание → один инфра-alert (явно «НЕ дефект кода»). ✓
+- **AC-10** (регресс red-before/green-after): `tests/test_orch110_false_rollback_regression.py` гоняет
+  РЕАЛЬНЫЙ `check_branch_mergeable` через `advance_stage`; на до-ORCH-110-коде оба сценария упали бы
+  (Scenario A гоняла бы обречённый re-test, Scenario B откатилась бы на `development`). ✓
+
+### 2. Соответствие ADR + трассировка маркеров (ORCH-078) — PASS
+- D1…D6 реализованы как зафиксировано в `06-adr/ADR-001` + сквозном `adr-0042`. ✓
+- Директива developer'у выполнена: `("ORCH-110", "classify_retest_failure", "src/merge_gate.py")`
+  дописан в `MAIN_REGRESSION_MARKERS` (append-only, существующие маркеры целы). ✓
+- Затронутые маркеры ORCH-043/071/073/093/027/065/109 сверены, зафиксированные инварианты **не сломаны**:
+  лиз held-on-success / released-on-failure (контракт `check_branch_mergeable` сохранён, skip-путь
+  возвращает `(True, …)` с HELD lease), anti-phantom pre-merge rebase не тронут, coverage fail-open `None`
+  сохранён, reaper-инвариант проверен численно.
+
+### 3. Качество кода — PASS
+- never-raise по всему пути (leaf `proc_group`, классификатор, врезка `_handle_merge_gate_infra_retry`
+  обёрнута в `_handle_merge_gate_infra_retry`/`_merge_gate_infra_retry_impl` с проглатыванием исключения).
+- Docstrings на всех публичных функциях; чёткое разделение чистого предиката и I/O.
+- Тесты содержательные (реальный kill дерева процессов, реальная маршрутизация через `advance_stage`,
+  валидация бюджета, kill-switch-параметризация, наблюдаемость). Прогон зелёный:
+  141 (ORCH-110 + изменённые merge/coverage/config) + 575 (широкая зона stage_engine/qg/merge/deploy/reaper)
+  + 37 (docs-инварианты, ORCH-011 + host-hardcodes) — все PASS.
+- **Багфикс-трек (ORCH-019 BR-4):** исправление несёт тест-фиксатор дефекта (AC-10) — требование выполнено.
+
+### 4. Документация — PASS (приоритетная проверка)
+`src/` изменён → документация обновлена в **том же PR**:
+- `CLAUDE.md` — добавлена секция ORCH-110 (паспорт). ✓
+- `CHANGELOG.md` — запись `[Unreleased]` с разбивкой D1…D6 + 5 ключей. ✓
+- `.env.example` — 5 новых ключей + бамп `ORCH_MERGE_RETEST_TIMEOUT_S=900` с врезкой про сквозной
+  инвариант. ✓
+- `docs/architecture/README.md` — поведение merge-gate re-test (D1…D6) + ссылки на ADR. ✓
+- `docs/overview/tech-pipeline.md` — **витрина системы (ORCH-011)** обновлена: исключение «инфра-таймаут =
+  транзиент, не откат»; `tests/test_system_docs.py` зелёный. ✓
+- Глобальный сквозной ADR `docs/architecture/adr/adr-0042-…md` + work-item `06-adr/ADR-001-…md` заведены. ✓
+
+## Findings
+
+### P0 — Blocker
+- (нет)
+
+### P1 — Must fix
+- (нет)
+
+### P2 — Should fix
+- (нет)
+
+### P3 — Nice-to-have (не блокирует)
+- В `check_branch_mergeable` (`src/qg/checks.py:750`) причина FAIL раскладывается локальной подстрокой
+  `"timeout" in t_reason`, тогда как введён точный предикат `merge_gate.classify_retest_failure`. Поведение
+  безопасно (авторитетная маршрутизация в `stage_engine._handle_merge_gate` использует классификатор; редкий
+  `"re-test error: …"` со словом «timeout» в детали безопасно уйдёт в `other`→rollback), но единая точка
+  классификации читалась бы чище. Косметика, на усмотрение.
+
+## Документация
+**Обновлена полностью в том же PR** (golden source наравне с кодом): `CLAUDE.md`, `CHANGELOG.md`,
+`.env.example`, `docs/architecture/README.md`, витрина `docs/overview/tech-pipeline.md` (ORCH-011),
+глобальный ADR `adr-0042`, work-item ADR `06-adr/ADR-001`. Машинно-проверяемые факты витрины и
+запрет хост-хардкодов — зелёные (`tests/test_system_docs.py`, `tests/test_no_host_hardcodes.py`).
+Пунктов `README.md` «Известные ограничения», требующих снятия этим PR, не затронуто. Расхождений
+документации с кодом не выявлено.

docs/work-items/ORCH-110/13-test-report.md

@@ -0,0 +1,91 @@
+---
+result: PASS   # PASS | FAIL — машинный вердикт, UPPERCASE
+work_item: ORCH-110
+stage: testing
+author_agent: tester
+status: pass
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+type: test-report
+work_item_id: ORCH-110
+---
+
+# Test Report — ORCH-110
+
+Багфикс инцидента ORCH-109/PR#129: локальный re-test merge-gate падал по **таймауту** (инфра/CPU-
+голодание от осиротевших pytest-процессов) при зелёных CI+tester+staging → ложно маршрутизировался
+как код-фейл (откат `deploy-staging → development` + расход developer-retry) → manual-gate. Прогон
+регресса подтверждает: инфра-таймаут толерируется (D1…D6), tree-kill устраняет утечку, красный re-test
+по-прежнему откатывает.
+
+## Окружение
+- Python: 3.12.13
+- pytest: 8.3.3 (plugins: cov-5.0.0, anyio-4.13.0, asyncio-0.23.8)
+- Worktree: `/repos/_wt/orchestrator/feature_ORCH-110-bug-merge-gate-local-re-test-t`
+- Branch: `feature/ORCH-110-bug-merge-gate-local-re-test-t` (HEAD `5391c8b`; fix-коммит `b80edf3`)
+- Дата: 2026-06-15
+
+## Smoke API (read-only)
+| Эндпоинт | Результат |
+|----------|-----------|
+| `GET /health` | `{"status":"ok","service":"orchestrator"}` — OK |
+| `GET /status` | OK; задача ORCH-110 (id=100) на стадии `testing`, `agent_running=null` |
+| `GET /queue` | OK; блок `serial_gate` присутствует ✓ (наряду с `auto_labels` ✓); полезная нагрузка не деградировала |
+
+> Прим.: блок `merge_gate` (новая наблюдаемость ORCH-110, FR-6) в проде (8500) ещё отсутствует — это
+> ожидаемо, фича не задеплоена (задача на стадии `testing`). В коде ветки блок присутствует и покрыт
+> тестом TC-12 (`test_tc12_queue_endpoint_includes_merge_gate_block`). Регресса смока нет.
+
+## Результаты (покрытие ТЗ: каждый TC из 04-test-plan.yaml ↔ 03-acceptance-criteria.md)
+
+| TC ID | Описание | AC | Модуль | Результат |
+|-------|----------|----|--------|-----------|
+| TC-01 | `retest_branch`: таймаут → `(False, 're-test timeout after <T>s')` + tree-kill всего дерева (внуки не переживают) | AC-4 (BR-3) | test_orch110_retest_lifecycle.py | PASS |
+| TC-02 | `coverage_gate.measure_coverage`: таймаут → tree-kill дерева; возврат `None` сохранён | AC-4 (BR-3) | test_orch110_retest_lifecycle.py | PASS |
+| TC-03 | `classify_retest_failure`: `timeout` различим от `red`/`lock-busy`/`other` (имя/семантика `check_*` целы) | AC-2 | test_orch110_merge_gate_classify.py | PASS |
+| TC-04 | Маршрутизация: инфра-таймаут → defer/повтор/инфра-alert (НЕ `_handle_merge_gate_rollback`, без developer-retry) | AC-1 | test_orch110_merge_gate_routing.py | PASS |
+| TC-05 | Анти-над-толерантность: красный/конфликт re-test → откат на `development` + developer-retry + release lease (BR-6) | AC-3 | test_orch110_merge_gate_routing.py | PASS |
+| TC-06 | Anti-loop: повторы лимитированы по попыткам/времени; исчерпание → один инфра-alert | AC-9 | test_orch110_merge_gate_routing.py | PASS |
+| TC-07 | Kill-switch off → байт-в-байт прежнее (таймаут → rollback); not-self repo (enduro) → no-op | AC-7 | test_orch110_killswitch.py | PASS |
+| TC-08 | Бюджет: malformed/непозитив → дефолт 900 + WARNING; `reaper_max_running_s (5400) > Σ+grace`; `reaper_max_running_s` не тронут | AC-5 | test_orch110_budget_invariants.py | PASS |
+| TC-09 | never-raise: ошибка транзиент-пути → безопасный дефолт + WARNING; исключение не уходит в `advance_stage` | AC-8 | test_orch110_merge_gate_routing.py | PASS |
+| TC-10 | РЕГРЕСС инцидента: no-op rebase → skip+advance; catch-up timeout → infra-retry (НЕ rollback); красный → rollback (red-before/green-after) | AC-10 | test_orch110_false_rollback_regression.py | PASS |
+| TC-11 | Контракт необходимости re-test: no-op rebase → skip (lease HELD); HEAD сдвинулся / неопределённость SHA → re-test (fail-safe) | AC-6 | test_orch110_retest_contract.py | PASS |
+| TC-12 | Наблюдаемость: счётчики + блок `merge_gate` в `GET /queue`; инфра-alert кликабелен и отличим от код-фейла; без дубля ORCH-111 | AC-9 (FR-6) | test_orch110_observability.py | PASS |
+
+Все 12 TC выполнены и сопоставлены с критериями приёмки AC-1…AC-10. FAIL/непокрытых TC нет.
+
+## Вывод pytest
+
+### ORCH-110-специфичные модули (verbose)
+```
+collected 55 items
+tests/test_orch110_retest_lifecycle.py ........  (TC-01, TC-02)
+tests/test_orch110_merge_gate_classify.py ........  (TC-03)
+tests/test_orch110_merge_gate_routing.py ........  (TC-04, TC-05, TC-06, TC-09)
+tests/test_orch110_killswitch.py ....  (TC-07)
+tests/test_orch110_budget_invariants.py .........  (TC-08)
+tests/test_orch110_false_rollback_regression.py ...  (TC-10)
+tests/test_orch110_retest_contract.py ......  (TC-11)
+tests/test_orch110_observability.py .....  (TC-12)
+======================== 55 passed, 1 warning in 15.17s ========================
+```
+
+### Полный регресс
+```
+$ cd /repos/_wt/orchestrator/feature_ORCH-110-bug-merge-gate-local-re-test-t && python3 -m pytest tests/ -q --tb=short
+........................................................................ [100%]
+1988 passed, 1 warning in 346.71s (0:05:46)
+```
+(Единственное warning — `PydanticDeprecatedSince20` в `src/config.py:8`, предсуществующее, не связано
+с ORCH-110.)
+
+## Итог
+PASS
+
+- Полный регресс `pytest tests/` — **1988 passed** (0 failed).
+- Все 12 TC из `04-test-plan.yaml` выполнены, сопоставлены с `03-acceptance-criteria.md` (AC-1…AC-10) — **PASS**.
+- Smoke API read-only (`/health`, `/status`, `/queue`) — OK; блоки `serial_gate` и `auto_labels` присутствуют.
+- Review-вердикт — `APPROVED`.
+
+**Вердикт: `result: PASS`** → задача переходит на `deploy-staging`.

docs/work-items/ORCH-110/14-deploy-log.md

@@ -0,0 +1,12 @@
+---
+deploy_status: SUCCESS
+work_item: ORCH-110
+hook_exit_code: 0
+deployed_by: deploy-finalizer
+---
+
+# Deploy log — ORCH-036 executable self-deploy
+
+Прод-деплой завершён хост-хуком с exit-code `0` -> `deploy_status: SUCCESS`.
+
+Вердикт зафиксирован детерминированным finalizer'ом (Фаза C), не LLM.

docs/work-items/ORCH-110/15-staging-log.md

@@ -0,0 +1,32 @@
+---
+staging_status: SUCCESS
+work_item: ORCH-110
+stage: deploy-staging
+author_agent: deployer
+status: success
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+timestamp: 2026-06-15T07:40:28Z
+base_url: http://localhost:8501
+---
+
+# Staging Gate Log
+
+Staging test suite completed against the live staging environment (port 8501).
+
+**Execution:** canonical run INSIDE `orchestrator-staging` via the Docker Engine API
+exec endpoint (ORCH-048/ADR-001):
+`python3 /repos/orchestrator/scripts/staging_check.py --base-url http://localhost:8501 --mode stub`.
+
+**Result:** 8/10 checks PASS, exit code **0** → advance.
+
+- REAL checks (A1–A3 SMOKE, B4–B6 ACCESS, C7–C8 E2E): all green.
+  - B6 registry-isolation: `sandbox=YES, prod-ET=NO, prod-ORCH=NO` (instance built registry
+    from its own `.env.staging` process-env — correct canonical-run behaviour).
+- SANDBOX_INFRA checks (C9a/C9b): FAIL, **waived** under ORCH-061 infra-tolerance
+  (known sandbox-infra; depend on SANDBOX bot accounts being project members, not on the
+  pipeline). All REAL checks green → exit 0.
+
+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) — infra-waived: ['C9a Branch appears in orchestrator-sandbox', 'C9b Analyst job enqueued in staging queue'] are known sandbox-infra checks; all real checks green.

docs/work-items/ORCH-112/00-business-request.md

@@ -0,0 +1,7 @@
+# Business Request: BUG: failed/cancelled task artifacts must be cleaned from shared checkout
+
+Work Item ID: ORCH-112
+
+## Description
+
+TBD

docs/work-items/ORCH-112/01-brd.md

@@ -0,0 +1,169 @@
+---
+work_item: ORCH-112
+stage: analysis
+author_agent: analyst
+status: ready-for-review
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+escalate: full-cycle
+---
+
+# 01 — BRD / Bug-report: ORCH-112 — failed/cancelled task artifacts must be cleaned from shared checkout
+
+Work Item: **ORCH-112** · Repo: **orchestrator** · Стадия: analysis · Трек: **Bug → эскалация в full-cycle**
+
+> ⚠️ **`escalate: full-cycle` (ADR-001 D5 ORCH-019).** Баг помечен `Bug`, но по сути это
+> **архитектурный + safety-critical (self-hosting)** дефект: правка лежит в самом опасном пути
+> прод-деплоя (хост-хук, прямо перед рестартом прод-контейнера) и требует **решения о политике
+> жизненного цикла** shared checkout (ADR). Поэтому выпускается **полный** analysis-пакет, а не
+> облегчённый bug-пакет. Оператор снимает багфикс-трек: `POST /bug-fast-track/escalate?work_item=ORCH-112`
+> → задача пойдёт через стадию `architecture` (architect выпустит ADR для политики cleanup/изоляции).
+
+---
+
+## 1. Бизнес-контекст и проблема
+
+### Симптом (наблюдаемое)
+Self-deploy задачи **ORCH-111** упал на шаге `git pull origin main` хост-хука деплоя с ошибкой:
+```
+error: Your local changes to the following files would be overwritten by merge:
+        src/config.py
+Please commit your changes or stash them before you merge.
+```
+Деплой прерван, конвейер потребовал **ручного вмешательства оператора** (на self-hosting это
+групповой риск — встаёт деплой и всех других проектов).
+
+### Причина симптома (установленный факт)
+В **общем (shared) checkout** `/home/slin/repos/orchestrator` оставались грязные файлы от
+ранее **неуспешной/отменённой/перезапущенной задачи ORCH-104** (тема Lite installer):
+- модифицированный tracked-файл: `src/config.py`;
+- модифицированный/untracked: `docs/deployment/LITE_SETUP.md`;
+- untracked: `scripts/install_lite.py`, `tests/test_install_lite.py`,
+  `docs/deployment/lite-install.example.yaml`.
+
+Через несколько дней эти остатки **заблокировали** `git pull` другой задачи (ORCH-111).
+
+### Локализация (анализ — куда смотреть архитектору/разработчику)
+
+**Установленный факт о топологии (CLAUDE.md / `docs/architecture/README.md`):**
+`/home/slin/repos/orchestrator` (хост) == `/repos/orchestrator` (контейнер, bind-mount) ==
+**main clone** (`settings.repos_dir/<repo>` = `settings.deploy_host_repo_path`). Это **deploy-база
+и база управления worktree'ами**, а НЕ рабочая копия агента.
+
+1. **Первичный дефект — нерезистентный `git pull`.**
+   `scripts/orchestrator-deploy-hook.sh:224-226` делает `cd "$REPO"` (= deploy-база) и
+   **голый** `git pull origin main` **без гигиены рабочего дерева**. Любая локальная правка
+   tracked-файла блокирует merge → деплой падает. Проверено: во всём `src/`+`scripts/` **нет ни
+   одного** `git reset --hard` / `git clean` / `git stash` для приведения базы к чистому состоянию.
+   Shared checkout трактуется как «всегда чистый», что не гарантировано.
+
+2. **Невыполненный/неэнфорснутый инвариант + отсутствие «дворника».**
+   Нормальный конвейер **не пишет** в рабочее дерево main clone: агенты работают в изолированных
+   worktree'ах `/repos/_wt/<repo>/<branch>` (`git_worktree.ensure_worktree`); `docker build`
+   использует контекст **worktree** (`image_freshness._host_worktree_path`), не main clone;
+   fallback'и гейтов на main clone — **только чтение** (`git show origin/main:...`,
+   `qg/checks.py:451`, `coverage_gate.py:297`, `stage_engine.py:145`). Поэтому грязь ORCH-104
+   почти наверняка — **ручной/брошенный WIP** в shared checkout во время инцидента ORCH-104
+   (косвенное подтверждение: файлы `install_lite.py`/`test_install_lite.py`/`lite-install.example.yaml`
+   **никогда не существовали в git-истории** — закоммиченный артефакт ORCH-104 это
+   `scripts/setup_lite.py`, commit `e2cf883`). Вне зависимости от источника: **нет механизма**,
+   который детектирует/чистит грязную базу и **нет задокументированного/энфорснутого инварианта**
+   «main checkout — неизменяемая deploy-база, не workspace».
+
+3. **`cancel_task` чистит worktree + remote-ветку, но НЕ shared checkout.**
+   `stage_engine.cancel_task` (шаг 3d, строки ~2330-2343): `remove_worktree(repo, branch)` +
+   `gitea.delete_remote_branch(repo, branch)`. Это корректно (конвейер в main clone не пишет), но
+   означает **нулевое покрытие** случая «грязная deploy-база» в каскадах failed/cancelled.
+
+**Вывод:** даже если первопричина грязи — ручное действие, устойчивость должна быть на стороне
+системы: deploy-база обязана **самовосстанавливаться** в чистый `origin/main` перед pull, а
+политика жизненного цикла — гарантировать, что остатки failed/cancelled задач не клинят будущие
+операции.
+
+## 2. Объём (scope)
+
+### В объёме
+- Сделать self-deploy `git pull origin main` (shared deploy-база) **устойчивым к грязному рабочему
+  дереву** — приведение базы к чистому `origin/main` **автономно**, без ручного вмешательства.
+- Гарантировать, что после **failed / cancelled / брошенной** задачи в shared checkout не остаётся
+  рабочих остатков, способных заблокировать будущий деплой/операцию (сходимость базы к чистому
+  `origin/main`).
+- Задокументировать (и где осуществимо — мягко энфорснуть/гардить) инвариант
+  «shared main checkout — deploy/worktree-management база, НЕ редактируемый workspace».
+- Наблюдаемость: лог + Telegram-алерт, когда deploy-база найдена грязной и автоочищена (или отказ).
+
+### Вне объёма
+- ❌ Запрет/контроль ручных операций оператора в shared checkout (вне технической власти системы;
+  закрываем устойчивостью, а не запретом).
+- ❌ Изменение модели worktree per-task (`git_worktree`, ORCH-2) — она корректна и не трогается.
+- ❌ Любое изменение `STAGE_TRANSITIONS` / `QG_CHECKS` / `check_*` / machine-verdict ключей / схемы БД.
+- ❌ Изменение поведения деплоя на чистой базе (happy-path должен остаться байт-в-байт).
+- ❌ Выбор конкретного механизма (reset --hard vs janitor vs guard) — это **зона архитектора** (ADR).
+
+## 3. Заинтересованные стороны
+- **Заказчик/оператор (Слава)** — страдает от ручного разруливания залипших деплоев; принимает результат.
+- **Self-hosting конвейер orchestrator** — прямой потребитель (надёжность прод-деплоя).
+- **Все проекты на общем инстансе (enduro-trails)** — косвенно: залипший self-deploy орка
+  останавливает обслуживание их задач.
+
+## 4. Бизнес-требования (BR)
+- **BR-1** — Грязное рабочее дерево shared deploy-базы (модифицированные tracked-файлы и/или
+  untracked-файлы) **НЕ должно блокировать** self-deploy `git pull origin main`: деплой обязан
+  привести базу к чистому, актуальному `origin/main` **без ручного вмешательства**.
+- **BR-2** — После failed / cancelled / брошенной задачи в shared checkout **не должно оставаться**
+  рабочих остатков этой задачи, способных заблокировать будущий деплой/git-операцию; база
+  **сходится** к чистому `origin/main`.
+- **BR-3** — Инвариант «shared main checkout (`<host_repos_dir>/<repo>`) — deploy/worktree-management
+  база, НЕ workspace» должен быть **задокументирован** (`docs/operations/INFRA.md` +
+  `docs/architecture/README.md`) и, где осуществимо, **энфорснут/гардирован**; конвейер/агенты
+  **никогда** не пишут рабочие изменения в main clone (верифицировать, что это так).
+- **BR-4** — **Наблюдаемость:** обнаружение грязной базы и факт автоочистки (или отказ) должны
+  логироваться и алертиться (Telegram, кликабельный номер) — оператор видит, что гигиена сработала.
+- **BR-5** — На **чистой** базе поведение деплоя — **байт-в-байт прежнее** (обычный fast-forward
+  `git pull`); никакого регресса happy-path.
+
+## 5. Нефункциональные требования (NFR)
+- **NFR-1 (self-hosting safety)** — гигиена **никогда** не трогает ветку `main` на remote, не делает
+  force-push, не рестартит прод-контейнер вне штатного гейта, не удаляет worktree/ветки **других
+  активных** задач. Оперирует **только** настроенным путём deploy-базы.
+- **NFR-2 (сохранность deploy-состояния)** — автоочистка **не должна** удалять артефакты, легитимно
+  живущие под `$REPO`/рядом: rollback-снимки `$REPO/.deploy-prev-image-*`
+  (`deploy_prod_prev_image_file`), `deploy-hook.log`, sibling-состояния
+  `<repos_dir>/.deploy-state-*` / `.merge-lease-*.json`, и админ-записи worktree в `.git/worktrees`.
+  (Наивный `git clean -xfd` в `$REPO` уничтожил бы `.deploy-prev-image-*` и сломал rollback — это
+  **жёсткое ограничение** для архитектора/разработчика.)
+- **NFR-3 (обратимость / kill-switch)** — новое поведение под флагом; выключенный флаг → деплой
+  байт-в-байт как до ORCH-112 (голый `git pull origin main`).
+- **NFR-4 (надёжность)** — never-raise / fail-safe (по образцу leaf'ов `serial_gate`/`cancel`);
+  идемпотентность; restart-safe; сбой гигиены не должен маскировать или ухудшать исход деплоя сверх
+  текущего.
+- **NFR-5 (нулевая регрессия конвейера)** — `STAGE_TRANSITIONS` / `QG_CHECKS` / `check_*` /
+  machine-verdict ключи / схема БД / exit-code-контракт хука (0/1/2, ORCH-036) — **байт-в-байт**.
+- **NFR-6 (область)** — изменение скоупится на self-hosting (`orchestrator`); поведение для прочих
+  репо/синхронного деплоя агентом — не ухудшается.
+
+## 6. Допущения и ограничения
+- Shared checkout и хост-хук физически разделяют один путь с контейнером через bind-mount
+  (`repos_dir`↔`host_repos_dir`); хук исполняется на **хосте** по ssh (ORCH-036, detached).
+- Build-once путь (`SOURCE_IMAGE` retag) **не** зависит от содержимого рабочего дерева main clone —
+  прод получает ровно staging-валидированный образ; значит дискард рабочего дерева base перед pull
+  **безопасен для деплоимого артефакта**. (`--build-staging` собирается из **worktree**, не из main —
+  отдельный контур.)
+- Источник истины кода — `origin/main`; локальные правки в deploy-базе **по определению** не должны
+  существовать (это deploy-база, а не место работы).
+- Конкретный механизм (resilient pull через reset+clean со скоуп-исключениями / активный janitor /
+  guard инварианта / комбинация) — **открытый вопрос для архитектуры**, решается в `06-adr/`.
+
+## 7. Критерии успеха
+Self-deploy успешно выполняет `git pull` на ранее грязной shared-базе **без ручного вмешательства**;
+deploy-база сходится к чистому `origin/main`; rollback-состояние и sibling-артефакты сохранены;
+happy-path и весь конвейер — без регресса; обязательный регресс-тест **красный до фикса, зелёный
+после**. Детальные PASS/FAIL — `03-acceptance-criteria.md`.
+
+## 8. Риски
+- Деструктивная гигиена (`reset --hard`/`clean`) в **прод-deploy-базе** рядом с рестартом прода —
+  ошибка скоупа может удалить rollback-state/логи (см. NFR-2) → ADR обязателен.
+- Маскировка реальной первопричины: если в будущем какой-то код **начнёт** писать в main clone,
+  «тихая автоочистка» это скроет → нужна наблюдаемость (BR-4).
+- Кросс-каттинг с ORCH-036 (self-deploy), ORCH-058 (image-freshness/provenance), ORCH-090 (cancel),
+  ORCH-2 (worktree-модель). Детали/митигации — `10-tech-risks.md` (заполняет архитектор).

docs/work-items/ORCH-112/02-trz.md

@@ -0,0 +1,110 @@
+---
+work_item: ORCH-112
+stage: analysis
+author_agent: analyst
+status: ready-for-review
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# 02 — ТЗ (TRZ): ORCH-112 — failed/cancelled task artifacts must be cleaned from shared checkout
+
+Work Item: **ORCH-112** · Repo: **orchestrator** · Стадия: analysis
+
+> ТЗ описывает **требования и ограничения к реализации**, выведенные из BRD и фактического кода.
+> Архитектурное **решение** (какой механизм гигиены/изоляции выбрать) — задача архитектора (`06-adr/`),
+> т.к. задача эскалирована в full-cycle (`01-brd.md` → `escalate: full-cycle`).
+
+## 1. Сводка изменения
+Сделать self-deploy устойчивым к **грязной shared deploy-базе** и гарантировать сходимость базы к
+чистому `origin/main` после failed/cancelled/брошенных задач. Корень симптома — голый
+`git pull origin main` в `scripts/orchestrator-deploy-hook.sh` (строка 226), исполняемый в
+`$REPO` (= `settings.deploy_host_repo_path` = main clone), который падает при любой локальной правке
+tracked-файла. Требуется: (а) приведение deploy-базы к чистому `origin/main` перед/в момент pull
+**без ручного вмешательства**, со строгим сохранением deploy-rollback-состояния; (б) документирование
++ (по возможности) энфорс инварианта «main checkout — deploy-база, не workspace»; (в) наблюдаемость.
+
+## 2. Задействованные модули / пути
+| Путь | Действие | Примечание |
+|------|----------|-----------|
+| `scripts/orchestrator-deploy-hook.sh` | изменить | строки 224-226: голый `git pull origin main` в `$REPO` — точка отказа (FR-1) |
+| `src/self_deploy.py` | возможно изменить | `build_deploy_command` / `initiate_deploy` / `rebuild_staging_image` строят инвокацию хука — возможная точка передачи гигиены/флага (решает архитектор) |
+| `src/stage_engine.py` | возможно изменить | `cancel_task` (шаг 3d, ~2330-2343) — каскад cancel; расширение гигиены на shared-базу (FR-2, если выбран этот путь) |
+| `src/git_worktree.py` | возможно изменить | модель main clone ↔ worktree; возможный helper приведения базы к чистоте / верификация инварианта (BR-3) |
+| `src/config.py` | изменить | новый kill-switch + флаги области (FR-5) |
+| `src/<new_leaf>.py` (напр. `checkout_hygiene.py`) | возможно создать | чистый never-raise leaf политики гигиены (по образцу `serial_gate`/`cancel`) — **создавать ли** решает архитектор |
+| `docs/operations/INFRA.md` | изменить | инвариант «shared checkout — deploy-база, не workspace» (BR-3) |
+| `docs/architecture/README.md` | изменить | описать политику гигиены/жизненного цикла deploy-базы |
+| `CHANGELOG.md`, `CLAUDE.md` | изменить | правило «docs = golden source» (CLAUDE.md §2) |
+| `tests/test_<...>.py` | создать | регресс + покрытие (см. `04-test-plan.yaml`) |
+
+## 3. Функциональные требования
+
+### FR-1 — Устойчивый self-deploy `git pull` (BR-1, BR-5)
+- На пути self-deploy (`scripts/orchestrator-deploy-hook.sh`, шаг «2. Pull latest code»)
+  `git pull origin main` **не должен падать** из-за грязного рабочего дерева `$REPO`.
+- Перед обновлением база приводится к чистому, актуальному `origin/main` (приведение tracked- и
+  untracked-изменений к состоянию `origin/main`), **с сохранением** артефактов из NFR-2.
+- На **уже чистой** базе результат — обычный fast-forward; наблюдаемое поведение и exit-коды
+  (0/1/2, ORCH-036) — **байт-в-байт прежние** (BR-5).
+- Контракт: never-break — сбой шага гигиены не должен ухудшать исход относительно текущего голого
+  pull (fail-safe).
+
+### FR-2 — Сходимость shared-базы после failed/cancelled/брошенной задачи (BR-2)
+- После терминации задачи (`failed` job-исход / `cancelled` через STOP / брошенный WIP) в shared
+  checkout **не остаётся** рабочих остатков, способных заблокировать будущий деплой/git-операцию.
+- Допустимая трактовка «сходимости» (на выбор архитектора, **не** прескриптивно здесь): автоочистка
+  непосредственно в self-deploy перед pull (FR-1) **и/или** активный «дворник», приводящий
+  `<host_repos_dir>/<repo>` к чистому `origin/main`.
+- Каскад `cancel_task` (ORCH-090) уже чистит **worktree + remote-ветку**; расширение на shared-базу
+  (если выбрано) делается тем же never-raise best-effort способом.
+
+### FR-3 — Инвариант deploy-базы (BR-3)
+- Задокументировать: `<host_repos_dir>/<repo>` — deploy/worktree-management база; рабочие изменения
+  туда **не пишутся** конвейером/агентами (агенты — worktree `git_worktree`; build — worktree-контекст;
+  fallback'и гейтов — read-only `git show origin/main`).
+- Верифицировать, что текущий код этот инвариант соблюдает (анализ ORCH-112: соблюдает; единственные
+  обращения к main clone — read-only/fetch/worktree-управление). Где осуществимо — добавить
+  лёгкий guard/проверку (решает архитектор), **без** изменения горячих путей.
+
+### FR-4 — Наблюдаемость (BR-4)
+- Обнаружение грязной deploy-базы и факт автоочистки (число/имена сброшенных путей) или **отказ**
+  гигиены — лог (структурная запись) + Telegram-алерт (`send_telegram`, кликабельный номер задачи,
+  best-effort, never-raise). Опционально — read-only снапшот в `GET /queue` (решает архитектор).
+
+### FR-5 — Условность / kill-switch (BR-5, NFR-3, NFR-6)
+- Новое поведение под **kill-switch** (env `ORCH_*`, по образцу `serial_gate_enabled`/`stop_status_enabled`);
+  выключенный флаг → деплой байт-в-байт прежний (голый `git pull origin main`).
+- Область — self-hosting (`orchestrator`); прочие репо/синхронный деплой агентом — не ухудшаются.
+- `applies(repo)` (локальный, без сети) проверяется первым.
+
+## 4. Изменения API
+**Нет** обязательных. Опционально (на усмотрение архитектора) — read-only блок (напр. `checkout_hygiene`)
+в существующем `GET /queue` для наблюдаемости. Новых управляющих эндпоинтов не требуется.
+
+## 5. Изменения схемы БД
+**Нет.** Состояние гигиены, если нужно, — in-memory / sentinel-файлы (паттерн `self_deploy`/`merge_gate`),
+без миграции БД. Аддитивная таблица не требуется.
+
+## 6. Требования к новым/изменённым QG checks
+**Нет.** Это **не** Quality Gate и не стадия — это устойчивость deploy-пути и политика гигиены.
+`STAGE_TRANSITIONS` / реестр `QG_CHECKS` / семантика и имена `check_*` / machine-verdict ключи
+(`deploy_status:`/`staging_status:`/…) — **байт-в-байт не тронуты** (NFR-5).
+
+## 7. Совместимость / регресс
+- **Обратная совместимость:** kill-switch off → голый `git pull origin main` (1:1 до ORCH-112);
+  чистая база → fast-forward без изменений (BR-5).
+- **Область раската:** self-hosting `orchestrator`; enduro/прочие — нулевая регрессия.
+- **Обратимость:** выключение флага мгновенно возвращает прежнее поведение.
+- **Сохранность (жёсткое ограничение, NFR-2):** гигиена **не удаляет** `$REPO/.deploy-prev-image-*`
+  (rollback), `deploy-hook.log`, sibling `<repos_dir>/.deploy-state-*` / `.merge-lease-*.json`,
+  админ-записи `.git/worktrees`. Любой `clean`-скоуп обязан их исключать.
+- **Self-hosting инварианты (NFR-1):** никогда не трогать `main` на remote, не force-push, не
+  рестартить прод вне гейта, не сносить worktree/ветки других активных задач, оперировать только
+  настроенным путём deploy-базы. Exit-code-контракт хука (0/1/2) сохранён.
+- **Артефакты pipeline:** создаются/обновляются обычные docs work item (`01..04` этой задачи,
+  `06-adr/` на стадии architecture после эскалации, `14-deploy-log.md` при деплое). Новых
+  pipeline-артефактов задача не вводит.
+- **Трассировка (CLAUDE.md §9 / ORCH-078):** правки маркированных блоков (ORCH-036 self-deploy,
+  ORCH-058 image-freshness, ORCH-090 cancel) — сверять с их `06-adr/` перед изменением, инварианты
+  не ломать.

docs/work-items/ORCH-112/03-acceptance-criteria.md

@@ -0,0 +1,128 @@
+---
+work_item: ORCH-112
+stage: analysis
+author_agent: analyst
+status: ready-for-review
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# 03 — Критерии приёмки (Acceptance Criteria): ORCH-112 — failed/cancelled task artifacts must be cleaned from shared checkout
+
+Work Item: **ORCH-112** · Repo: **orchestrator** · Стадия: analysis
+
+Формат: каждый критерий имеет **PASS** (что должно быть истинно для приёмки) и **FAIL**
+(что считается провалом). Reviewer/CI проверяют их буквально по файлам репозитория и тестам.
+
+---
+
+## AC-1 — Грязная tracked-правка не блокирует self-deploy pull (регресс ORCH-104/ORCH-111)
+
+**Условие:** shared deploy-база имеет локальную модификацию tracked-файла (напр. `src/config.py`),
+self-deploy выполняет шаг pull.
+- **PASS:** база приводится к чистому актуальному `origin/main` без ручного вмешательства; шаг pull
+  не возвращает «local changes would be overwritten by merge»; деплой продолжается; есть тест,
+  воспроизводящий точный сценарий ORCH-111 (**красный до фикса, зелёный после**).
+- **FAIL:** pull/деплой падает на грязной tracked-правке; или сценарий не покрыт тестом.
+
+---
+
+## AC-2 — Untracked WIP-файлы не блокируют и не «протекают» в деплой
+
+**Условие:** в shared-базе лежат untracked-файлы failed/брошенной задачи (напр.
+`scripts/install_lite.py`, `tests/test_install_lite.py`, `docs/deployment/lite-install.example.yaml`).
+- **PASS:** база сходится к чистому `origin/main`; untracked-остатки не блокируют операцию и не
+  попадают в деплоимый/собираемый артефакт.
+- **FAIL:** untracked-остатки блокируют операцию либо остаются и клинят будущий деплой.
+
+---
+
+## AC-3 — Сохранность deploy-rollback-состояния и sibling-артефактов (жёсткое ограничение)
+
+**Условие:** в `$REPO`/рядом присутствуют `.deploy-prev-image-*` (rollback), `deploy-hook.log`,
+`<repos_dir>/.deploy-state-*`, `.merge-lease-*.json`, `.git/worktrees/*`.
+- **PASS:** после гигиены **все** перечисленные артефакты на месте; rollback по
+  `.deploy-prev-image-*` остаётся работоспособным; есть тест, доказывающий их неудаление.
+- **FAIL:** гигиена удаляет хотя бы один из этих артефактов (особенно `.deploy-prev-image-*`).
+
+---
+
+## AC-4 — Happy-path без регресса (чистая база)
+
+**Условие:** shared-база чистая, self-deploy выполняет pull.
+- **PASS:** поведение и exit-коды (0/1/2, ORCH-036) — байт-в-байт прежние (обычный fast-forward);
+  полный `pytest tests/ -q` зелёный.
+- **FAIL:** изменилось наблюдаемое поведение/exit-код на чистой базе, либо красный регресс.
+
+---
+
+## AC-5 — Self-hosting safety
+
+**Условие:** исполнение пути гигиены/деплоя.
+- **PASS:** нет операций над веткой `main` на remote, нет force-push, нет рестарта прод-контейнера
+  вне штатного гейта, нет удаления worktree/веток других активных задач; операции строго в пределах
+  настроенного пути deploy-базы; тест/анализ это подтверждает.
+- **FAIL:** любое из перечисленных нарушений присутствует или возможно.
+
+---
+
+## AC-6 — Kill-switch и обратимость
+
+**Условие:** новый флаг выключен.
+- **PASS:** деплой ведёт себя байт-в-байт как до ORCH-112 (голый `git pull origin main`); включение
+  флага активирует устойчивое поведение; область скоупится на self-hosting (прочие репо не затронуты).
+- **FAIL:** выключенный флаг меняет поведение, либо нет kill-switch, либо затронуты прочие репо.
+
+---
+
+## AC-7 — Сходимость после cancel/failed
+
+**Условие:** задача отменена (STOP/ORCH-090) или job завершился `failed`, оставив остатки в
+рабочем дереве deploy-базы.
+- **PASS:** shared-база сходится к чистому `origin/main` (через автоочистку в деплое и/или дворник),
+  и последующий self-deploy проходит без ручного вмешательства; покрыто интеграционным тестом.
+- **FAIL:** остатки сохраняются и блокируют последующий деплой/git-операцию.
+
+---
+
+## AC-8 — Наблюдаемость
+
+**Условие:** обнаружена грязная deploy-база.
+- **PASS:** факт обнаружения и автоочистки (или отказ) — в логах (структурно) и в Telegram-алерте
+  (кликабельный номер); алерт best-effort, never-raise (его сбой не валит деплой).
+- **FAIL:** тихая очистка без следа в логах/уведомлениях, либо сбой алерта роняет деплой.
+
+---
+
+## AC-9 — Инвариант конвейера и БД не тронуты
+
+**Условие:** диф задачи.
+- **PASS:** `STAGE_TRANSITIONS` / реестр `QG_CHECKS` / семантика и имена `check_*` / machine-verdict
+  ключи / схема БД / exit-code-контракт хука — байт-в-байт; структурные тесты конвейера зелёные.
+- **FAIL:** любой из перечисленных контрактов изменён.
+
+---
+
+## AC-10 — Документация (golden source)
+
+**Условие:** изменён функционал deploy-базы/гигиены.
+- **PASS:** обновлены `docs/operations/INFRA.md` (инвариант deploy-база ≠ workspace) и
+  `docs/architecture/README.md`; `CHANGELOG.md`/`CLAUDE.md` отражают изменение; ADR заведён на
+  стадии `architecture` (после эскалации `escalate: full-cycle`).
+- **FAIL:** функционал изменён, доки/ADR не обновлены (reviewer → finding ≥P1, CLAUDE.md §6).
+
+---
+
+## Сводная матрица AC ↔ FR/BR
+| AC | Покрывает |
+|----|-----------|
+| AC-1 | BR-1 / FR-1 |
+| AC-2 | BR-1, BR-2 / FR-1, FR-2 |
+| AC-3 | NFR-2 / FR-1 (ограничение) |
+| AC-4 | BR-5 / FR-1 |
+| AC-5 | NFR-1 / FR-1, FR-2 |
+| AC-6 | NFR-3, NFR-6 / FR-5 |
+| AC-7 | BR-2 / FR-2 |
+| AC-8 | BR-4 / FR-4 |
+| AC-9 | NFR-5 / FR-1…FR-5 |
+| AC-10 | BR-3 / FR-3 |

docs/work-items/ORCH-112/04-test-plan.yaml

@@ -0,0 +1,83 @@
+work_item: ORCH-112
+stage: analysis
+author_agent: analyst
+status: ready-for-review
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+title: "Гигиена shared deploy-базы: устойчивость self-deploy git pull к грязному дереву"
+framework: pytest
+scope: >
+  Покрывается: устойчивость self-deploy `git pull origin main` к грязной shared deploy-базе
+  (модифицированные tracked + untracked файлы), сходимость базы к чистому origin/main после
+  failed/cancelled задач, сохранность deploy-rollback-состояния, kill-switch/область, наблюдаемость,
+  self-hosting safety. Вне покрытия: модель worktree per-task (ORCH-2, не трогается), запрет ручных
+  операций оператора, изменения STAGE_TRANSITIONS/QG_CHECKS/схемы БД (их нет).
+notes: >
+  TC-01 — ОБЯЗАТЕЛЬНЫЙ регресс-тест воспроизведения инцидента ORCH-111: КРАСНЫЙ до фикса, ЗЕЛЁНЫЙ
+  после. Шелл-симуляции хука моделировать по образцу tests/test_deploy_hook_rollback_sim.py
+  (временный git-репо во временной директории, без сети/прода/ssh). Полный регресс `pytest tests/ -q`
+  обязан оставаться зелёным (NFR-5). Точные имена тест-модулей/функций уточнит разработчик; тип
+  гигиены (resilient-pull / janitor / guard) выберет архитектор — тесты сформулированы так, чтобы
+  проверять ТРЕБУЕМЫЙ ИНВАРИАНТ (база сходится к чистому origin/main, артефакты сохранены), а не
+  конкретный механизм.
+
+tests:
+  - id: TC-01
+    type: integration
+    description: "РЕГРЕСС (обязательный, red→green): shared deploy-база с локальной модификацией tracked-файла src/config.py + untracked файлами — симуляция шага git pull хука приводит базу к чистому origin/main и НЕ падает с 'local changes would be overwritten by merge' (воспроизводит ORCH-111; красный до фикса)."
+    module: tests/test_deploy_checkout_hygiene.py
+    expected: PASS
+
+  - id: TC-02
+    type: integration
+    description: "Untracked WIP-файлы (install_lite.py / test_install_lite.py / lite-install.example.yaml) в shared-базе не блокируют операцию и база сходится к чистому origin/main."
+    module: tests/test_deploy_checkout_hygiene.py
+    expected: PASS
+
+  - id: TC-03
+    type: integration
+    description: "Сохранность (NFR-2): после гигиены файлы $REPO/.deploy-prev-image-* , deploy-hook.log, sibling .deploy-state-* / .merge-lease-*.json и .git/worktrees/* НЕ удалены; rollback по .deploy-prev-image-* остаётся работоспособным."
+    module: tests/test_deploy_checkout_hygiene.py
+    expected: PASS
+
+  - id: TC-04
+    type: integration
+    description: "Happy-path без регресса: на ЧИСТОЙ shared-базе шаг pull — обычный fast-forward; наблюдаемое поведение и exit-коды (0/1/2, ORCH-036) байт-в-байт прежние."
+    module: tests/test_deploy_checkout_hygiene.py
+    expected: PASS
+
+  - id: TC-05
+    type: unit
+    description: "Self-hosting safety: путь гигиены никогда не оперирует веткой main на remote, не делает force-push, не рестартит прод и не сносит worktree/ветки других задач; операции ограничены настроенным путём deploy-базы (статический/поведенческий ассерт)."
+    module: tests/test_deploy_checkout_hygiene.py
+    expected: PASS
+
+  - id: TC-06
+    type: unit
+    description: "Kill-switch off → деплой/pull байт-в-байт прежний (голый git pull origin main); on → активна устойчивая гигиена. Область applies(repo): self-hosting orchestrator real, прочие репо — no-op."
+    module: tests/test_deploy_checkout_hygiene.py
+    expected: PASS
+
+  - id: TC-07
+    type: integration
+    description: "Сходимость после cancel/failed: cancel_task (ORCH-090) / failed-исход не оставляет рабочих остатков в shared-базе, блокирующих будущий деплой; последующий self-deploy проходит без ручного вмешательства."
+    module: tests/test_deploy_checkout_hygiene.py
+    expected: PASS
+
+  - id: TC-08
+    type: unit
+    description: "Наблюдаемость: обнаружение грязной базы и факт автоочистки (или отказ) попадают в лог; Telegram-алерт best-effort/never-raise (его сбой не валит деплой), номер задачи кликабельный."
+    module: tests/test_deploy_checkout_hygiene.py
+    expected: PASS
+
+  - id: TC-09
+    type: unit
+    description: "Инвариант конвейера: STAGE_TRANSITIONS / реестр QG_CHECKS / имена и семантика check_* / machine-verdict ключи / exit-code-контракт хука — не изменены (структурный анти-регресс)."
+    module: tests/test_deploy_checkout_hygiene.py
+    expected: PASS
+
+  - id: TC-10
+    type: unit
+    description: "Документация-инвариант: docs/operations/INFRA.md и docs/architecture/README.md содержат правило «shared main checkout — deploy/worktree-management база, не workspace» (структурная сверка)."
+    module: tests/test_deploy_checkout_hygiene.py
+    expected: PASS

docs/work-items/ORCH-112/06-adr/ADR-001-deploy-base-checkout-hygiene.md

@@ -0,0 +1,244 @@
+---
+work_item: ORCH-112
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# ADR-001: Гигиена shared deploy-базы — устойчивый self-deploy `git pull` через resilient-pull в хуке
+
+Work Item: **ORCH-112** — failed/cancelled task artifacts must be cleaned from shared checkout
+Стадия: **architecture**
+Сквозная регистрация: **`docs/architecture/adr/adr-0044-deploy-base-checkout-hygiene.md`** (решение
+кросс-каттинговое: новый leaf-компонент на глобальном пути прод-деплоя + изменение прод-deploy-хука).
+
+## Статус
+Proposed
+
+## Контекст
+
+Self-deploy задачи **ORCH-111** упал на шаге `git pull origin main` хост-хука с
+`error: Your local changes to the following files would be overwritten by merge: src/config.py`.
+Деплой прерван → потребовал ручного вмешательства (на self-hosting это групповой риск — встаёт
+деплой всех проектов). Грязь оставлена ранее **неуспешной/отменённой/перезапущенной** задачей
+ORCH-104 в общем (shared) checkout.
+
+Факты, сверенные с кодом:
+
+1. **Точка отказа — голый pull.** `scripts/orchestrator-deploy-hook.sh:223-226` делает `cd "$REPO"`
+   (= `settings.deploy_host_repo_path` = main clone, строка 73) и **голый** `git pull origin main`
+   **без гигиены рабочего дерева**. Любая локальная правка tracked-файла блокирует merge. Во всём
+   `src/`+`scripts/` нет ни одного `git reset --hard` / `git clean` / `git stash` для приведения базы
+   к чистому состоянию.
+
+2. **Инвариант «main clone ≠ workspace» соблюдён, но не задокументирован и не энфорснут.** Агенты
+   работают в worktree'ах `/repos/_wt/<repo>/<branch>` (`git_worktree.ensure_worktree`); `docker build`
+   берёт контекст **worktree** (`image_freshness._host_worktree_path`); fallback'и гейтов на main clone —
+   **только чтение** (`git show origin/main:...`). Значит грязь — почти наверняка ручной/брошенный WIP.
+   Но **нет механизма**, детектирующего/чистящего грязную базу, и **нет задокументированного
+   инварианта**.
+
+3. **`cancel_task` чистит worktree + remote-ветку, но не shared checkout.** `stage_engine.cancel_task`
+   (строки 2333-2342): `remove_worktree(repo, branch)` + `gitea.delete_remote_branch(repo, branch)` —
+   нулевое покрытие случая «грязная deploy-база».
+
+4. **NFR-2 (сохранность) — жёсткое ограничение.** Сверено `.gitignore` + `src/config.py`:
+   - `.env`, `data/`, `*.db`, `.venv/`, `__pycache__/`, `build/`, `.env.staging`, `.env.watchdog`,
+     `deploy/bundled/repos/` — **gitignored** → переживают `git clean -fd` (без `-x`) автоматически.
+     **Прод-секреты `.env` и БД `data/*.db` пропадут только при ошибочном `-x`.**
+   - `.deploy-prev-image-prod` (`deploy_prod_prev_image_file`) / `.deploy-prev-image-staging`,
+     а также `deploy-hook.log` (fallback-локация лога, хук строки 60-65) — **untracked, НЕ gitignored**
+     → голый `git clean -fd` их **удалит** → сломает rollback (`do_rollback`, хук строки 107-139).
+   - Sibling-состояния `<repos_dir>/.deploy-state-<repo>/...` (`self_deploy._state_dir`) и
+     `<repos_dir>/.merge-lease-<repo>.json` (`merge_gate`, строка 315) лежат под **родителем** `$REPO`
+     (`settings.repos_dir`, не `$REPO`) → `git clean` в `$REPO` их физически не достаёт.
+   - `.git/worktrees/*` (админ-записи worktree) — внутри `.git/`, `git clean` его **никогда** не трогает.
+
+«Как есть» не годится: deploy-база трактуется как «всегда чистая», что не гарантировано; устойчивость
+должна быть на стороне системы — база обязана **самовосстанавливаться** в чистый `origin/main` перед pull.
+
+## Решение
+
+### Сводка
+
+Сделать self-deploy `git pull` **устойчивым к грязной shared deploy-базе** через **resilient-pull,
+встроенный в хук** (`--deploy`): перед `git pull origin main` добавляется детерминированный
+hygiene-блок, который при обнаружении грязного дерева приводит базу к чистому актуальному `origin/main`
+(`git fetch` + `git reset --hard origin/main` + **скоупленный** `git clean -fd`), **строго сохраняя**
+rollback/лог-артефакты (NFR-2). Блок гейтится env-переменной `CHECKOUT_HYGIENE`, которую инжектит
+`self_deploy.build_deploy_command` **только** когда новый leaf `src/checkout_hygiene.py`-`applies(repo)`
+истинен (kill-switch + self-hosting-скоуп). Сходимость базы после failed/cancelled (FR-2) достигается
+этим же deploy-time self-heal — **без** расширения `cancel_task` и **без** фонового «дворника».
+Наблюдаемость — sentinel-файл от хука, который читает Phase-C finalizer и шлёт Telegram-алерт.
+
+**Инвариант (NFR-5):** `STAGE_TRANSITIONS` / реестр `QG_CHECKS` / семантика и имена `check_*` /
+machine-verdict ключи (`deploy_status:`/`staging_status:`/`security_status:`) / схема БД /
+exit-code-контракт хука (0/1/2, ORCH-036) — **байт-в-байт не тронуты**. Это устойчивость deploy-пути
+и политика гигиены, **не** Quality Gate и **не** стадия.
+
+### D1 — Механизм: resilient-pull в хуке (а не janitor / не container-side clean) — FR-1, AC-1/AC-2
+
+Падающий `git pull` исполняется **на хосте** внутри detached-хука (`self_deploy.build_deploy_command`
+→ ssh + setsid). Поэтому гигиена обязана выполняться **в самом хуке, на хосте, непосредственно перед
+pull** — это исключает TOCTOU-гонку, которая возникла бы при чистке shared-mount из контейнера
+параллельно бегущему detached-хуку.
+
+Новый блок «2a. Resilient pull» в `scripts/orchestrator-deploy-hook.sh` **между** шагом «1. Capture
+PREV_IMG» и шагом «2. Pull latest code», под `if [[ "${CHECKOUT_HYGIENE:-0}" == "1" ]]`:
+
+```bash
+# 2a. ORCH-112: resilient pull — converge the shared deploy-base to a clean
+#     origin/main BEFORE the pull, so a dirty working tree (manual/abandoned WIP)
+#     never blocks the deploy. Gated by CHECKOUT_HYGIENE (Python kill-switch +
+#     self-hosting scope). NEVER `-x` (would delete .env/data/*.db); EXCLUDES the
+#     rollback/log artefacts (NFR-2). Best-effort: any failure is logged and the
+#     bare `git pull` below still runs (never-break).
+if [[ "${CHECKOUT_HYGIENE:-0}" == "1" ]]; then
+    dirty="$(git status --porcelain 2>/dev/null || true)"
+    if [[ -n "$dirty" ]]; then
+        log "HYGIENE: dirty deploy-base detected, converging to origin/main:"
+        log "$dirty"
+        git fetch origin main           >> "$LOG" 2>&1 || log "HYGIENE: fetch failed (continuing)"
+        git reset --hard origin/main    >> "$LOG" 2>&1 || log "HYGIENE: reset failed (continuing)"
+        git clean -fd \
+            -e '.deploy-prev-image-*' \
+            -e 'deploy-hook.log' \
+            >> "$LOG" 2>&1 || log "HYGIENE: clean failed (continuing)"
+        if [[ -n "${HYGIENE_REPORT:-}" ]]; then
+            { printf 'dirty=1\n'; printf '%s\n' "$dirty"; } > "$HYGIENE_REPORT" 2>/dev/null || true
+        fi
+    else
+        log "HYGIENE: deploy-base already clean (no-op)"
+    fi
+fi
+```
+
+- `git status --porcelain` детектирует грязь; **чистая база → блок no-op** (порожний вывод) → дальше
+  обычный `git pull` (AC-4, happy-path байт-в-байт).
+- `git fetch origin main` обновляет `origin/main`-ref, чтобы `reset --hard origin/main` сходился к
+  **актуальному** источнику истины; tracked-правки (`src/config.py`) дискардятся (AC-1).
+- `git clean -fd` снимает untracked-остатки (AC-2). **`-x` запрещён** (см. D2). Последующий
+  `git pull origin main` (строка 226, **не изменяется**) становится no-op fast-forward.
+- Шаг 1 хука пишет `.deploy-prev-image-prod` **до** hygiene → exclude `-e '.deploy-prev-image-*'`
+  сохраняет rollback-снимок **этого** деплоя (AC-3).
+
+### D2 — Сохранность deploy-состояния: NFR-2 как жёсткий контракт — AC-3
+
+**INV-HYGIENE-1 (никогда `-x`).** Hygiene-`git clean` исполняется **только** как `git clean -fd`
+(без `-x`). `-x` удалил бы gitignored `.env` (прод-секреты), `data/*.db` (БД прода), `build/` — что
+катастрофично. Анти-регресс: статический тест ассертит, что hygiene-блок хука **не содержит** токена
+`-x` (TC-05/TC-09).
+
+**INV-HYGIENE-2 (явные excludes).** `.deploy-prev-image-*` и `deploy-hook.log` untracked-но-НЕ-ignored
+→ обязательны `-e '.deploy-prev-image-*'` и `-e 'deploy-hook.log'`. TC-03 доказывает их неудаление и
+работоспособность rollback после гигиены.
+
+**INV-HYGIENE-3 (скоуп = `$REPO`).** Hygiene оперирует **только** рабочим деревом `$REPO`. Sibling
+`.deploy-state-*` / `.merge-lease-*.json` (под `<repos_dir>`, родитель `$REPO`) и `.git/worktrees/*`
+(внутри `.git/`) **вне** области `git clean` в `$REPO` — подтверждено топологией; гигиена их не достаёт.
+
+### D3 — Гейтинг: leaf `src/checkout_hygiene.py` + инжекция env в `build_deploy_command` — FR-5, AC-6
+
+Новый чистый never-raise leaf `src/checkout_hygiene.py` (по образцу `serial_gate`/`cancel`/`self_deploy`;
+импортирует только `config`, лениво — `qg.checks.is_self_hosting_repo`):
+
+- `applies(repo) -> bool` — `checkout_hygiene_enabled=False` → `False` (kill-switch, голый pull 1:1 до
+  ORCH-112); `checkout_hygiene_repos` (CSV) непуст → только перечисленные репо; **пусто →
+  self-hosting only** (`is_self_hosting_repo`, как `self_deploy_repos`). Локальный, без сети, **первым**.
+- `hook_env(repo, work_item_id) -> str` — возвращает префикс `CHECKOUT_HYGIENE=1 HYGIENE_REPORT=<path>`
+  (через `shlex.quote`) **только** при `applies==True`; иначе `""`. `HYGIENE_REPORT` =
+  `os.path.join(self_deploy.host_state_dir(repo, work_item_id), "hygiene")` — в том же deploy-state
+  каталоге, что и `result` (shared mount, читается контейнером).
+- `read_report(repo, work_item_id) -> dict | None` — читает sentinel `hygiene` через
+  `self_deploy.container_state_dir`; never-raise.
+- `alert_dirty(...)` — best-effort `send_telegram` (кликабельный номер), never-raise (D5).
+- `snapshot() -> dict` — read-only блок для `GET /queue` (флаг/скоуп; опционально).
+
+`self_deploy.build_deploy_command` (строки 253-261) добавляет `checkout_hygiene.hook_env(repo, wi)` в
+`env_assignments` (одна строка-присваивание в префиксе detached-команды; точно как ORCH-058
+`EXPECTED_REVISION`). Когда `applies==False` → префикс пуст → хук видит `CHECKOUT_HYGIENE` неустановленным
+→ блок 2a — no-op → **голый `git pull` (1:1 до ORCH-112)**.
+
+Флаги в `src/config.py` (дефолт = боевое):
+- `checkout_hygiene_enabled: bool = True` (env `ORCH_CHECKOUT_HYGIENE_ENABLED`);
+- `checkout_hygiene_repos: str = ""` (env `ORCH_CHECKOUT_HYGIENE_REPOS`; пусто → self-hosting only).
+
+### D4 — Сходимость после failed/cancelled: deploy-time self-heal достаточен; `cancel_task` НЕ расширяется — FR-2, AC-7
+
+Нормальный конвейер **не пишет** в main clone (факт 2 контекста) → грязь — ручной/брошенный WIP.
+Resilient-pull (D1) приводит базу к чистому `origin/main` **на следующем же self-deploy** → база
+**сходится** независимо от источника остатков → FR-2/AC-7 удовлетворены deploy-time self-heal.
+
+`stage_engine.cancel_task` (ORCH-090) **намеренно не расширяется** на shared-базу:
+- избегаем касания критично-оконного каскада ORCH-090 (`cancel.in_critical_window`, adr-0026);
+- избегаем container-side мутации deploy-базы (гонка с возможным параллельным деплоем);
+- расширение было бы избыточным — self-heal в D1 уже гарантирует сходимость.
+
+**Отвергнут активный «дворник» (janitor)** (фоновый актор, приводящий базу к чистоте по таймеру/событию):
+новый background-поток + дополнительная гонка с detached-деплоем и держателем merge-lease, без выигрыша
+сверх deploy-time self-heal.
+
+### D5 — Наблюдаемость: sentinel хука → Telegram-алерт finalizer'а — FR-4, AC-8
+
+Detached-хук (bash) не шлёт Telegram сам. Он пишет sentinel `hygiene` (`HYGIENE_REPORT`) в deploy-state
+каталог. Phase-C finalizer (`stage_engine`, уже читает `result` через `self_deploy.read_result`) после
+маппинга exit-code вызывает `checkout_hygiene.read_report` + `alert_dirty` (best-effort):
+структурный лог + Telegram (`send_telegram`, кликабельный `ORCH-112` через `plane_issue_link`,
+`disable_web_page_preview`). Сбой алерта **не валит** деплой (never-raise, AC-8). Опционально — блок
+`checkout_hygiene` в `GET /queue`.
+
+### D6 — Инвариант deploy-базы: документирование + de-facto энфорс — FR-3, AC-10
+
+Инвариант «`<host_repos_dir>/<repo>` (main checkout) — deploy/worktree-management база, **НЕ**
+редактируемый workspace; рабочие изменения туда не пишутся конвейером/агентами» документируется в
+`docs/operations/INFRA.md` (топология + self-hosting) и `docs/architecture/README.md` (раздел ORCH-36).
+**De-facto энфорс** — сам resilient-pull (D1): любая локальная правка дискардится при следующем деплое.
+**Отвергнут** тяжёлый рантайм-guard на горячих путях (FR-3 «где осуществимо, без изменения горячих
+путей») — он не нужен: self-heal уже обеспечивает сходимость, а guard добавил бы риск/латентность.
+
+### D7 — Скоуп пути: только `--deploy` pull, не `--build-staging`
+
+Hygiene врезается **только** в режим `--deploy` (где есть падающий `git pull`). Режим `--build-staging`
+(хук строки 166-204) собирает образ из `BUILD_CONTEXT` = **worktree** и **не делает** `git pull` →
+hygiene там не нужна и не добавляется.
+
+## Альтернативы
+
+- **`git stash` вместо `reset --hard`** — отвергнуто: накапливает stash-записи в deploy-базе, не
+  «сходится к чистому origin/main», прячет источник грязи; сложнее и менее детерминирован.
+- **Container-side Python clean перед ssh-dispatch** — отвергнуто (D1): TOCTOU-гонка с detached-хуком,
+  дублирование пути deploy-базы.
+- **Активный фоновый janitor** — отвергнуто (D4): новый актор + гонки, нулевой выигрыш над self-heal.
+- **Расширить `cancel_task` на shared-базу** — отвергнуто (D4): касание критично-оконного каскада
+  ORCH-090 + container-side мутация; избыточно.
+- **Тяжёлый рантайм-guard инварианта** — отвергнуто (D6): не нужен при self-heal, риск на горячем пути.
+- **`git clean -xfd`** — **категорически** отвергнуто (D2/INV-HYGIENE-1): удалит `.env`/`data/*.db`.
+
+## Последствия
+
+- **+** Self-deploy `git pull` устойчив к грязной shared-базе → нет ручного разруливания (BR-1, AC-1/2).
+- **+** База **сходится** к чистому `origin/main` после failed/cancelled/брошенных задач (BR-2, AC-7).
+- **+** Happy-path и kill-switch-off — байт-в-байт (BR-5, AC-4/AC-6); конвейер/БД/exit-коды не тронуты.
+- **+** Наблюдаемость: оператор видит факт автоочистки (BR-4, AC-8); инвариант задокументирован (AC-10).
+- **−** `reset --hard` **дискардит** локальные правки deploy-базы безвозвратно. Митигейшн: это **ровно**
+  инвариант (база = `origin/main`, источник истины — remote; deploy лишь fast-forward'ит); скоуп —
+  self-hosting; наблюдаемость показывает, что именно сброшено.
+- **−** Новый leaf + хук-блок + флаги = площадь сопровождения. Митигейшн: leaf минимальный, образец
+  существующих leaf'ов; never-raise; полный набор анти-регресс-тестов (`04-test-plan.yaml`).
+- **Откат:** `ORCH_CHECKOUT_HYGIENE_ENABLED=false` → деплой байт-в-байт до ORCH-112 (голый
+  `git pull origin main`); полный откат — revert leaf + хук-блок + флагов.
+
+## Ссылки
+- BRD: `docs/work-items/ORCH-112/01-brd.md`
+- TRZ: `docs/work-items/ORCH-112/02-trz.md`
+- Acceptance: `docs/work-items/ORCH-112/03-acceptance-criteria.md`
+- Test-plan: `docs/work-items/ORCH-112/04-test-plan.yaml`
+- Infra-requirements: `docs/work-items/ORCH-112/07-infra-requirements.md`
+- Tech-risks: `docs/work-items/ORCH-112/10-tech-risks.md`
+- Сквозной ADR: `docs/architecture/adr/adr-0044-deploy-base-checkout-hygiene.md`
+- Сверено по коду: `scripts/orchestrator-deploy-hook.sh:73,107-139,223-226`, `src/self_deploy.py:119-135,
+  220-278`, `src/merge_gate.py:315`, `src/config.py:285-291`, `.gitignore`, `src/stage_engine.py:2333-2342`
+- Трассировка (CLAUDE.md §9 / ORCH-078): ORCH-036 (self-deploy, adr-0007), ORCH-058 (image-freshness,
+  adr-0008), ORCH-090 (cancel, adr-0026) — инварианты не нарушаются.

docs/work-items/ORCH-112/07-infra-requirements.md

@@ -0,0 +1,59 @@
+---
+work_item: ORCH-112
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# 07 — Инфра-требования: ORCH-112 — гигиена shared deploy-базы
+
+Work Item: **ORCH-112** · Repo: **orchestrator** · Стадия: architecture
+
+> When-applicable. Затрагивается **жизненный цикл shared deploy-базы** (`<host_repos_dir>/<repo>`),
+> а не топология контейнеров/портов/томов. Контейнеры/сеть/тома — `N/A`.
+
+## I-1. Топология / окружения
+**Без изменений в составе.** Контейнеры (`orchestrator` 8500 / `orchestrator-staging` 8501), сеть
+(`network_mode: host`), порты, тома — прежние.
+
+Затрагивается **deploy-база** `<host_repos_dir>/<repo>` (= `/home/slin/repos/orchestrator` ==
+`/repos/orchestrator` в контейнере через bind-mount == `settings.deploy_host_repo_path`). **Нормативно
+закрепляется инвариант:** deploy-база — **deploy/worktree-management база, НЕ редактируемый workspace**.
+Рабочие изменения туда не пишутся конвейером/агентами (агенты — worktree `/repos/_wt/<repo>/<branch>`,
+build — worktree-контекст, fallback'и гейтов — read-only `git show origin/main`). Документируется в
+`docs/operations/INFRA.md` (топология + self-hosting) и `docs/architecture/README.md` (раздел ORCH-36).
+
+**Контракт сохранности рабочего дерева deploy-базы (NFR-2, жёсткий):** автоочистка hygiene
+(`git clean -fd`, **без** `-x`) **обязана сохранять**:
+| Артефакт | Расположение | Почему сохраняется |
+|----------|--------------|--------------------|
+| `.deploy-prev-image-prod` / `.deploy-prev-image-staging` | `$REPO/` (untracked, НЕ ignored) | rollback-снимок → `-e '.deploy-prev-image-*'` |
+| `deploy-hook.log` | `$REPO/` (fallback-лог) | аудит → `-e 'deploy-hook.log'` |
+| `.env`, `data/`, `*.db`, `build/` | `$REPO/` (gitignored) | прод-секреты/БД → переживают `git clean` **без** `-x` |
+| `.deploy-state-<repo>/*`, `.merge-lease-<repo>.json` | `<repos_dir>/` (sibling, родитель `$REPO`) | вне области `git clean` в `$REPO` |
+| `.git/worktrees/*` | `$REPO/.git/` | `git clean` никогда не трогает `.git/` |
+
+## I-2. Переменные окружения / секреты
+Две новые env-переменные (`src/config.py`, дефолт = боевое; **обновить `.env.example`**):
+| Ключ | Env | Дефолт | Назначение |
+|------|-----|--------|-----------|
+| `checkout_hygiene_enabled` | `ORCH_CHECKOUT_HYGIENE_ENABLED` | `True` | kill-switch resilient-pull; `False` → голый `git pull` (1:1 до ORCH-112) |
+| `checkout_hygiene_repos` | `ORCH_CHECKOUT_HYGIENE_REPOS` | `""` | CSV-скоуп; пусто → self-hosting only (`orchestrator`) |
+
+Внутренние env, инжектируемые в detached-хук `self_deploy.build_deploy_command` (не операторские):
+`CHECKOUT_HYGIENE=1`, `HYGIENE_REPORT=<host_state_dir>/hygiene`. Новых секретов нет.
+
+## I-3. Деплой / рестарт
+**Рестарт прод-контейнера задачей ORCH-112 — НЕ требуется и ЗАПРЕЩЁН** (self-hosting инвариант,
+CLAUDE.md). Изменение активируется штатно: новый промпт/хук/код `cat`-ается/деплоится в обычном
+self-deploy-цикле через **staging-гейт (8501)** сначала, затем `Confirm Deploy` (ORCH-059). Хук-блок
+hygiene исполняется **только** в `--deploy` режиме (где есть `git pull`); `--build-staging` собирает из
+worktree и не пуллит → не затронут. Exit-code-контракт хука (0/1/2, ORCH-036) — байт-в-байт.
+
+## I-4. CI/CD
+**Без изменений** `.gitea/workflows/`. Новый тест-модуль `tests/test_deploy_checkout_hygiene.py`
+(шелл-симуляция хука во временном git-репо, без сети/прода/ssh — образец
+`tests/test_deploy_hook_rollback_sim.py`) исполняется обычным `pytest tests/ -q`. Полный регресс обязан
+оставаться зелёным (NFR-5).

docs/work-items/ORCH-112/10-tech-risks.md

@@ -0,0 +1,42 @@
+---
+work_item: ORCH-112
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# 10 — Технические риски: ORCH-112 — гигиена shared deploy-базы
+
+Work Item: **ORCH-112** · Repo: **orchestrator** · Стадия: architecture
+
+> Информационный (гейтом не парсится). Риски реализации resilient-pull и их митигейшн.
+
+## Реестр рисков
+
+| ID | Риск | Вер. | Влия. | Митигейшн |
+|----|------|------|-------|-----------|
+| TR-1 | **`git clean -x`** ошибочно добавлен → удалит gitignored `.env` (прод-секреты) / `data/*.db` (БД прода) / `build/` — катастрофа на прод-deploy-базе | Низ. | **Выс.** | INV-HYGIENE-1 (ADR D2): только `git clean -fd`, **никогда** `-x`. Статический анти-регресс-тест ассертит отсутствие `-x` в hygiene-блоке хука (TC-05/TC-09); явная рамка в ADR + INFRA |
+| TR-2 | Неверный/отсутствующий `-e` exclude → `git clean -fd` удалит `.deploy-prev-image-*` → сломан rollback (`do_rollback`) | Сред. | **Выс.** | INV-HYGIENE-2: обязательные `-e '.deploy-prev-image-*'` + `-e 'deploy-hook.log'`; TC-03 доказывает неудаление и работоспособность rollback; шаг 1 хука пишет prev-image **до** hygiene |
+| TR-3 | Сбой шага hygiene (fetch/reset/clean) маскирует/ухудшает исход деплоя | Низ. | Сред. | never-break (ADR D1): каждая git-операция `\|\| log "...continuing"`; деплой продолжается к голому `git pull`; sentinel-отчёт фиксирует факт; fail-safe, исход не хуже текущего |
+| TR-4 | `reset --hard origin/main` безвозвратно дискардит локальные правки deploy-базы, которые кто-то «нужными» считал | Низ. | Сред. | Это **ровно** инвариант: deploy-база = `origin/main` (источник истины — remote); deploy лишь fast-forward'ит. Наблюдаемость (D5) показывает сброшенное; скоуп — self-hosting; документировано (INFRA/README) |
+| TR-5 | Гонка: hygiene на хосте чистит mount, пока контейнер читает deploy-базу | Низ. | Низ. | Деплой сериализован (serial-gate ORCH-088, один деплой за раз); hygiene в detached-хуке непосредственно перед pull; нормальный конвейер deploy-базу не читает в этот момент (worktree-изоляция). TOCTOU между `status` и `reset` пренебрежимо (один процесс) |
+| TR-6 | Скоуп-leak: hygiene затронет прочие репо / синхронный деплой агентом | Низ. | Сред. | `applies(repo)` (локально, первым): пусто → self-hosting only; инжекция env только на self-deploy-пути (сам self-hosting-скоупленный, `self_deploy_applies`); TC-06 |
+| TR-7 | Стейл `origin/main` (fetch не выполнился) → `reset --hard` сходится к устаревшему коммиту | Низ. | Низ. | `git fetch origin main` перед reset; при сбое fetch — `\|\| log` + продолжение; последующий `git pull origin main` (строка 226, не тронута) до-тянет недостающее; deploy промоутит build-once `SOURCE_IMAGE` (артефакт не зависит от дерева main clone) |
+| TR-8 | Расширение объёма (касание `cancel_task`/`STAGE_TRANSITIONS`/QG) при реализации | Низ. | Сред. | ADR D4 явно запрещает расширение `cancel_task`; NFR-5 байт-в-байт; TC-09 структурно ассертит неизменность контрактов; трассировка ORCH-036/058/090 |
+
+## Сводный вывод
+
+Доминирующий класс — **деструктивная гигиена рядом с прод-rollback-состоянием** (TR-1/TR-2): низкая
+вероятность, высокое влияние, **полностью** снимается контрактом сохранности (INV-HYGIENE-1/2) + явными
+тестами (TC-03/TC-05/TC-09). Изменение аддитивно, под kill-switch (`checkout_hygiene_enabled`, дефолт
+`True`; off → байт-в-байт до ORCH-112), never-raise, self-hosting-скоупленное, **не трогает**
+`STAGE_TRANSITIONS`/`QG_CHECKS`/`check_*`/machine-verdict/схему БД/exit-code-контракт хука.
+
+**Эскалация:** вводится новый leaf-компонент (`src/checkout_hygiene.py`) на глобальном пути прод-деплоя
++ правка прод-deploy-хука + сквозной ADR adr-0044 → рекомендуется лейбл **`arch:major-change`** для
+reviewer-внимания (изменение safety-critical, в прод-deploy-пути). Возврат в анализ **не** требуется:
+ТЗ удовлетворяется без нарушения принципов архитектуры (всё в Docker на одном сервере, без новых
+зависимостей/очередей/k8s, без рестарта прода вне staging-гейта). Остаточный риск для прод-конвейера —
+**низкий** при соблюдении INV-HYGIENE-1/2/3.

docs/work-items/ORCH-112/12-review.md

@@ -0,0 +1,123 @@
+---
+verdict: APPROVED        # APPROVED | REQUEST_CHANGES — строго одно из двух, UPPERCASE
+work_item: ORCH-112
+stage: review
+author_agent: reviewer
+status: approved
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+type: review
+work_item_id: ORCH-112
+version: 1
+---
+
+# Review ORCH-112 — deploy-base checkout-hygiene (resilient-pull)
+
+## Summary
+
+Багфикс инцидента **ORCH-111** (bug → escalate full-cycle): прод-self-deploy падал на голом
+`git pull origin main` хост-хука из-за грязного shared main checkout (остатки ORCH-104 от ORCH-104).
+Реализован **resilient-pull в хуке** (`--deploy`): перед pull при обнаружении грязи база сводится к
+чистому `origin/main` (`git fetch` + `git reset --hard origin/main` + скоупленный `git clean -fd`),
+под kill-switch, never-raise, скоуп self-hosting.
+
+Проверены все 4 оси. Реализация **точно соответствует** ADR-001 (D1–D7) и сквозному adr-0044, все
+10 критериев приёмки (AC-1…AC-10) покрыты содержательными тестами, документация (golden source)
+обновлена в том же PR, инварианты конвейера/БД/exit-code-контракт хука — байт-в-байт не тронуты.
+
+**Вердикт: APPROVED.** P0/P1/P2 findings отсутствуют.
+
+### Что сверено (доказательная база)
+
+**Ось 1 — соответствие ТЗ (02-trz) / критериям (03-acceptance-criteria):**
+- FR-1 (устойчивый pull) / AC-1 — ✅ хук-блок «2a. Resilient pull» + регресс **TC-01** (зелёный после
+  фикса) и **TC-01b** (тот же грязный base без гигиены → `would be overwritten by merge`, репро инцидента).
+- FR-1 / AC-2 (untracked WIP) — ✅ **TC-02** (остатки сняты, не протекают в деплой).
+- NFR-2 / AC-3 (сохранность) — ✅ **TC-03** (`.deploy-prev-image-*`, `deploy-hook.log`, gitignored
+  `.env`/`data/*.db`, sibling `.deploy-state-*`/`.merge-lease-*.json`, `.git/worktrees/*` — на месте) +
+  **TC-05** статический контракт (`git clean -fd`, **никогда `-x`**, явные excludes).
+- BR-5 / AC-4 (happy-path) — ✅ **TC-04** (чистая база → no-op + fast-forward, exit-коды байт-в-байт).
+- NFR-1 / AC-5 (self-hosting safety) — ✅ скоуп `$REPO`, `reset --hard origin/main` (не локальная
+  догадка), нет push/force-push (TC-05 ассерт).
+- FR-5 / AC-6 (kill-switch + обратимость) — ✅ **TC-06** (off → инертно; пустой CSV → self-hosting only;
+  enduro не затронут).
+- FR-2 / AC-7 (сходимость после cancel/failed) — ✅ **TC-07** (deploy-time self-heal; `cancel_task`
+  корректно НЕ расширён — D4).
+- FR-4 / AC-8 (наблюдаемость) — ✅ **TC-08** (`read_report`/`alert_dirty` never-raise) + врезка в
+  `run_deploy_finalizer` (sentinel → Telegram, best-effort).
+- NFR-5 / AC-9 (инвариант конвейера/БД) — ✅ **TC-09** + проверка дифа: `STAGE_TRANSITIONS`/`QG_CHECKS`/
+  `check_*`/machine-verdict/схема БД/exit-code-контракт хука (0/1/2) не тронуты.
+- BR-3 / AC-10 (документация) — ✅ см. ось 4.
+
+**Ось 2 — соответствие ADR:**
+- ADR-001 D1–D7 реализованы дословно: resilient-pull в хуке (не janitor/не container-side, D1),
+  NEVER `-x` + excludes (D2), leaf `checkout_hygiene.py` + инжекция env в `build_deploy_command` (D3),
+  `cancel_task` не расширяется / janitor не вводится (D4), sentinel → finalizer-alert (D5), docs (D6),
+  только `--deploy` не `--build-staging` (D7, подтверждено размещением блока между шагами 1 и 2 пути
+  `--deploy`).
+- Трассировка (ORCH-078): правка `build_deploy_command` (маркеры ORCH-101/ORCH-058) — чисто аддитивна
+  (одно env-присваивание после `EXPECTED_REVISION`), инвариант image-freshness не сломан; ORCH-036
+  exit-code-контракт и ORCH-090 cancel-каскад не нарушены; INV-4 (никогда push/force-push `main`)
+  соблюдён.
+
+**Ось 3 — качество кода:**
+- Leaf чистый, never-raise, ленивые импорты (`self_deploy`/`qg.checks`/`notifications`) — leaf-инвариант
+  доказан **TC-05** (`leaf_is_a_pure_leaf`). Docstrings на всех публичных функциях. `shlex.quote` на
+  инжектируемом пути. Env-проводка консистентна с существующим паттерном `result`-sentinel
+  (`initiate_deploy` пред-создаёт `container_state_dir` → запись `hygiene` гарантированно проходит).
+- **Багфикс-трек регресс-тест (ORCH-019 / BR-4):** присутствует — **TC-01** (фиксатор дефекта,
+  зелёный после фикса) в паре с **TC-01b** (репродукция инцидента: голый pull аборт без гигиены).
+- Все ссылки на API существуют (`notifications.link_for`/`send_telegram`, `self_deploy.host_state_dir`/
+  `container_state_dir`, `qg.checks.is_self_hosting_repo`). `repo`/`work_item_id`/`task_id` в скоупе
+  финализатора.
+- Тесты содержательные: 17 TC (шелл-симуляция реального хука в герметичном git-репо без сети/прода/ssh
+  + unit). Прогон: **17/17 зелёные**; смежные deploy/config/stage_engine/frontmatter — **200/200 зелёные**;
+  docs/hardcode/canon — **101/101 зелёные**.
+
+**Ось 4 — документация (golden source):**
+- `src/` изменён → документация обновлена **в том же PR**: `docs/operations/INFRA.md` (инвариант
+  deploy-база ≠ workspace), `docs/architecture/README.md` (раздел ORCH-112 design), `CHANGELOG.md`,
+  `CLAUDE.md` (паспортный блок), `.env.example` (новые ключи), ADR-001 + сквозной
+  `docs/architecture/adr/adr-0044`. Консистентны между собой и с кодом.
+- Обзорные доки (ORCH-079): открытые пункты `README.md` «Известные ограничения» (Telegram 48h /
+  intra-repo deps / batch-автоном) этим PR **не закрываются** → обновление не требуется. ✅
+- Витрина системы (ORCH-011): фикс — внутренняя устойчивость deploy-пути, **не** новая
+  стадия/гейт/агент/интеграция/способность → витрина `docs/overview/` не затронута;
+  `tests/test_system_docs.py` зелёный. ✅
+
+## Findings
+
+### P0 — Blocker
+- Нет.
+
+### P1 — Must fix
+- Нет.
+
+### P2 — Should fix
+- Нет.
+
+### P3 — Nice-to-have (не блокирует, на усмотрение)
+- `tests/test_deploy_checkout_hygiene.py::test_tc05_hook_clean_is_never_destructive` ассертит
+  `assert "-x" not in code` по **всем** исполняемым строкам хука. Текущий хук токена `-x` не содержит
+  (тест зелёный), но будущая легитимная конструкция (`set -x`, `[ -x file ]`, `chmod +x`) ложно уронит
+  ассерт. Можно сузить проверку до строки(ок) `git clean` — но это страховка критичного инварианта
+  INV-HYGIENE-1, поэтому строгость намеренна и допустима. Не блокирует.
+
+## Документация
+
+**Статус: обновлена полностью, в том же PR (golden source соблюдён).**
+
+| Документ | Статус |
+|----------|--------|
+| `docs/work-items/ORCH-112/06-adr/ADR-001-deploy-base-checkout-hygiene.md` | ✅ заведён (architecture, после escalate full-cycle) |
+| `docs/architecture/adr/adr-0044-deploy-base-checkout-hygiene.md` | ✅ сквозной ADR заведён |
+| `docs/operations/INFRA.md` | ✅ инвариант deploy-база ≠ workspace + страховка resilient-pull |
+| `docs/architecture/README.md` | ✅ раздел ORCH-112 (design) |
+| `CHANGELOG.md` | ✅ запись [Unreleased] |
+| `CLAUDE.md` | ✅ паспортный блок |
+| `.env.example` | ✅ `ORCH_CHECKOUT_HYGIENE_ENABLED` / `_REPOS` |
+| `docs/overview/` (витрина, ORCH-011) | ➖ не требуется (внутренний deploy-fix, не новая способность) |
+| `README.md` «Известные ограничения» (ORCH-079) | ➖ не требуется (открытые пункты не закрываются) |
+
+Необновлённой документации при изменённом `src/` **нет** → ось 4 пройдена, P0 по документации
+отсутствует.

docs/work-items/ORCH-112/13-test-report.md

@@ -0,0 +1,71 @@
+---
+result: PASS   # PASS | FAIL — машинный вердикт, UPPERCASE
+work_item: ORCH-112
+stage: testing
+author_agent: tester
+status: pass
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+type: test-report
+work_item_id: ORCH-112
+---
+
+# Test Report — ORCH-112
+
+Гигиена shared deploy-базы: устойчивость self-deploy `git pull` к грязному дереву
+(багфикс инцидента ORCH-111). Review-вердикт: **APPROVED** (`12-review.md`).
+
+## Окружение
+- Python: 3.12.13
+- pytest: 8.3.3 (plugins: cov-5.0.0, anyio-4.13.0, asyncio-0.23.8)
+- Worktree: `/repos/_wt/orchestrator/feature_ORCH-112-bug-failed-cancelled-task-arti/`
+- Ветка: `feature/ORCH-112-bug-failed-cancelled-task-arti`
+- Дата: 2026-06-15
+
+## Smoke API (read-only)
+| Endpoint | Результат |
+|----------|-----------|
+| `GET /health` | PASS — `{"status":"ok","service":"orchestrator"}` |
+| `GET /status` | PASS — задача 102 ORCH-112 на стадии `testing`, ветка совпадает |
+| `GET /queue` | PASS — блок `serial_gate` присутствует (ORCH-088); `auto_labels` присутствует |
+
+Блок `checkout_hygiene`/`serial_gate`/`auto_labels` — все на месте в полезной нагрузке `/queue`,
+регресса смока нет.
+
+## Покрытие ТЗ (TC из 04-test-plan.yaml ↔ 03-acceptance-criteria)
+
+| TC ID | Описание | AC | Тест | Результат |
+|-------|----------|----|------|-----------|
+| TC-01 | Регресс ORCH-111: грязный tracked `src/config.py` + untracked → база сходится к чистому `origin/main`, pull не падает (red→green) | AC-1 | `test_tc01_dirty_tracked_edit_converges_and_deploys` (+ `test_tc01b_bare_pull_aborts_without_hygiene_documents_incident`) | PASS |
+| TC-02 | Untracked WIP-файлы не блокируют и не протекают в деплой | AC-2 | `test_tc02_untracked_wip_does_not_block` | PASS |
+| TC-03 | Сохранность `.deploy-prev-image-*`/`deploy-hook.log`/sibling `.deploy-state-*`/`.merge-lease-*.json`/`.git/worktrees/*` (NFR-2) | AC-3 | `test_tc03_preserves_rollback_and_sibling_artifacts` | PASS |
+| TC-04 | Happy-path: чистая база → fast-forward, exit-коды байт-в-байт | AC-4 | `test_tc04_clean_base_fast_forwards_no_op_hygiene` | PASS |
+| TC-05 | Self-hosting safety: нет операций над `main`/force-push/рестарта прода; `git clean -fd` (никогда `-x`); leaf чист | AC-5 | `test_tc05_hook_clean_is_never_destructive`, `test_tc05_leaf_is_a_pure_leaf` | PASS |
+| TC-06 | Kill-switch off → инертно; пустой CSV → self-hosting only; скоуп репо | AC-6 | `test_tc06_kill_switch_off_is_inert`, `test_tc06_empty_csv_is_self_hosting_only`, `test_tc06_csv_scope_limits_repos` | PASS |
+| TC-07 | Сходимость после cancel/failed → следующий self-deploy чист | AC-7 | `test_tc07_convergence_then_next_deploy_is_clean` | PASS |
+| TC-08 | Наблюдаемость: `read_report`/`alert_dirty`, Telegram best-effort/never-raise | AC-8 | `test_tc08_read_report_none_when_absent`, `test_tc08_read_report_parses_dirty_sentinel`, `test_tc08_alert_dirty_never_raises_on_send_failure` | PASS |
+| TC-09 | Инвариант конвейера: `STAGE_TRANSITIONS`/`QG_CHECKS`/`check_*`/machine-verdict/exit-code-контракт хука не тронуты | AC-9 | `test_tc09_pipeline_contracts_untouched`, `test_tc09_hook_exit_code_contract_intact` | PASS |
+| TC-10 | Документация-инвариант: INFRA.md и architecture/README.md содержат правило «main checkout — deploy-база, не workspace» | AC-10 | `test_tc10_docs_state_deploy_base_invariant` | PASS |
+
+Каждый TC из `04-test-plan.yaml` выполнен и сопоставлен с критерием приёмки `03-acceptance-criteria.md`.
+TC-01 (обязательный red→green регресс инцидента ORCH-111) — зелёный; парный TC-01b документирует
+аборт голого pull без гигиены.
+
+## Вывод pytest
+
+### Целевой модуль `tests/test_deploy_checkout_hygiene.py`
+```
+collected 17 items
+... 17 passed, 1 warning in 7.51s
+```
+
+### Полный регресс `pytest tests/ -q`
+```
+2018 passed, 1 warning in 342.01s (0:05:42)
+```
+(единственный warning — Pydantic V2 deprecation в `src/config.py:8`, существующий, не связан с задачей)
+
+## Итог
+PASS — все 10 TC (17 тест-функций) зелёные, полный регресс 2018/2018 зелёный, smoke API OK
+(`/health`, `/status`, `/queue` с блоками `serial_gate` и `auto_labels`). Задача готова к переходу
+на `deploy-staging`.

docs/work-items/ORCH-112/14-deploy-log.md

@@ -0,0 +1,12 @@
+---
+deploy_status: SUCCESS
+work_item: ORCH-112
+hook_exit_code: 0
+deployed_by: deploy-finalizer
+---
+
+# Deploy log — ORCH-036 executable self-deploy
+
+Прод-деплой завершён хост-хуком с exit-code `0` -> `deploy_status: SUCCESS`.
+
+Вердикт зафиксирован детерминированным finalizer'ом (Фаза C), не LLM.

docs/work-items/ORCH-112/15-staging-log.md

@@ -0,0 +1,38 @@
+---
+staging_status: SUCCESS
+work_item: ORCH-112
+stage: deploy-staging
+author_agent: deployer
+status: success
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+timestamp: 2026-06-15T12:11:26Z
+base_url: http://localhost:8501
+---
+
+# Staging Gate Log
+
+Staging test suite completed against the live staging environment (`orchestrator-staging`,
+port 8501), executed inside the container via the canonical path
+`/repos/orchestrator/scripts/staging_check.py --base-url http://localhost:8501 --mode stub`
+(ORCH-048: B6 registry-isolation reads `.env.staging` from the running instance's own process-env).
+
+**Result: 8/10 checks PASS — exit code 0 → SUCCESS.**
+
+- REAL failed: none
+- SANDBOX_INFRA failed (waived, ORCH-061): C9a, C9b
+
+The two failing checks (C9a "Branch appears in orchestrator-sandbox", C9b "Analyst job enqueued in
+staging queue") are the known sandbox-infra checks that depend on SANDBOX bot accounts being project
+members — not on the pipeline. With every REAL check green, the suite waives them and exits 0.
+
+```
+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
+```
+
+Block A (SMOKE): A1 /health 200, A2 /queue 200, A3 ORCH_STAGING=true — all PASS.
+Block B (ACCESS): B4 Plane sandbox, B5 Gitea push, B6 registry isolation — all PASS.
+Block C (E2E, stub): C7 create issue PASS, C8 trigger pipeline PASS, C9a/C9b waived sandbox-infra.
+
+Staging gate passed. Task may advance to the `deploy` stage.

docs/work-items/ORCH-113/00-business-request.md

@@ -0,0 +1,7 @@
+# Business Request: BUG: job-reaper must not re-run deploy-staging finalization while original finalizer is alive
+
+Work Item ID: ORCH-113
+
+## Description
+
+TBD

docs/work-items/ORCH-113/01-brd.md

@@ -0,0 +1,167 @@
+---
+work_item: ORCH-113
+stage: analysis
+author_agent: analyst
+status: ready-for-review
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+escalate: full-cycle
+---
+
+# 01 — BRD (бизнес-требования): ORCH-113 — BUG: job-reaper не должен повторно запускать финализацию `deploy-staging`, пока жив исходный finalizer
+
+Work Item: **ORCH-113** · Repo: **orchestrator** · Стадия: analysis
+
+> **Багфикс-трек → эскалация в полный цикл (`escalate: full-cycle`).** Задача помечена `Bug`, но
+> сама баг-карточка явно требует «анализ контракта reaper, статуса `running/finalizing`, длительности
+> grace и идемпотентности edge-гейтов» (см. «Ограничение» в бизнес-запросе) — это решение с
+> несколькими проектными альтернативами (liveness-heartbeat finalizer'а / явный sub-state
+> `finalizing` / per-stage grace / ownership-lease на edge-гейты) и нетривиальными инвариантами
+> self-hosting, затрагивающее **задокументированный сквозной инвариант ORCH-065** (контракт
+> живости reaper, `adr-0011`). По правилу ORCH-019 (ADR-001 D5) выпускается **полный** analysis-пакет,
+> а трек эскалируется (`POST /bug-fast-track/escalate?work_item=ORCH-113`) → задача проходит стадию
+> `architecture`. Прецедент — родственные задачи того же инцидент-кластера: ORCH-110 / ORCH-111
+> («bug → escalate full-cycle»).
+
+---
+
+## 1. Бизнес-контекст и проблема
+
+Оркестратор — self-hosting инструмент: его прод-контейнер обслуживает конвейер **всех** проектов из
+одного инстанса с общей БД и общей очередью и дорабатывает сам себя. Фоновый демон **job-reaper**
+(`src/job_reaper.py`, ORCH-065) — страховочный слой: он добивает «зомби»-job'ы, чей монитор умер,
+не записав терминальный статус. Его Tier-2-ветка (процесс агента завершился — `agent_runs.exit_code`
+записан, — но job всё ещё `running`) **неоднозначна**: это одновременно «монитор умер посреди
+финализации» И «живой монитор ещё финализирует». Reaper разрешает неоднозначность таймером —
+**finalization grace** `reaper_finalize_grace_s = 300` (db.py:1345-1348, job_reaper.py:36-44): если
+`exit_code` записан дольше grace — трактует ситуацию как **мёртвый монитор** и сам до-водит стадию.
+
+**Корневая ошибка контракта:** grace=300с построен на задокументированном допущении, что после записи
+`finished_at` монитор делает лишь «git commit/push (+PR), БАГ-8-проверку и сетевые Plane-комментарии —
+**секунды…десятки секунд**, и ТОЛЬКО ПОТОМ `_try_advance_stage`». Для ребра `deploy-staging → deploy`
+это **неверно**: `_try_advance_stage` (`launcher._monitor_agent`, строка 998) синхронно, в потоке
+монитора, прогоняет **весь набор тяжёлых детерминированных edge-под-гейтов** —
+`security` → `merge-gate` (полный локальный re-test, бюджет `merge_retest_timeout_s = 900`) →
+`coverage` (ещё один полный `pytest --cov`) → `image-freshness` (docker-rebuild + пересоздание
+staging). Это **минуты**, и весь этот объём идёт **ПОСЛЕ** штампа `finished_at` (launcher:861) и
+**ДО** `_finalize_job` (launcher:1003). `finished_age_s` reaper меряет именно от `finished_at`
+(db.py:1360) — то есть от **начала** финализации. Итог: пока живой монитор ещё внутри edge-гейтов,
+reaper по истечении 300с считает его мёртвым и **независимо запускает тот же тяжёлый набор edge-гейтов
+повторно**.
+
+**Установленные факты инцидента (ORCH-111, deployer job `1914`, run_id `683`):**
+- deployer завершился `exit_code=0` и записал `15-staging-log.md` со `staging_status: SUCCESS`;
+- после выхода агента job `1914` оставалась `running`, т.к. монитор ещё финализировал стадию;
+- финализация `deploy-staging` заняла **дольше 300с** (полный локальный re-test + coverage);
+- reaper после `reaper_finalize_grace_s=300` трактовал это как умерший monitor и повторно вызвал
+  gate-driven advance (`_reap_exit0` → `_gate_driven_advance` → `_try_advance_stage` → `advance_stage`);
+- edge-гейты `deploy-staging` исполнились **повторно**: `security-gate`, `merge-gate`, rebase, полный
+  локальный re-test;
+- один из повторных re-test стал **красным**: `3 failed, 1916 passed, 1 warning, 14 errors in 444.79s`;
+- задача была откатана `deploy-staging → development` (+ ложный developer-retry), хотя **параллельно**
+  исходный prod-deploy/finalizer дошёл до `deploy_status: SUCCESS`, **PR #130 был смержен**, задача
+  перешла `deploy → done`.
+
+**Симптом:** две ветки системы расходятся по состоянию **одной** задачи — одна повторно откатывает
+`deploy-staging`, другая успешно завершает deploy. Гонка + ложный rollback + ложный developer-retry +
+шумные алерты + несогласованное состояние Plane/БД.
+
+**Почему существующие гарды reaper не спасли:** атомарный claim-before-act
+(`reap_running_job(... WHERE status='running')`, job_reaper.py:280) защищает **строку job** от
+двойного терминального флипа, но **не защищает побочное исполнение edge-гейтов**: reaper вызывает
+`_gate_driven_advance → advance_stage`, который и прогоняет тяжёлые под-гейты, **до/независимо** от
+монитора. Гонка — в **side-effectful исполнении edge-гейтов**, а не в флипе строки. Дешёвая
+read-only пред-проверка `_gate_is_green('deploy-staging')` читает лишь `check_staging_status`
+(frontmatter `15-staging-log.md` = `SUCCESS`, зелёный) → reaper уверенно идёт в тяжёлый advance.
+Tier-3 backstop (`reaper_max_running_s = 5400`) при этом не срабатывает — баг чисто в Tier-2 grace.
+
+## 2. Объём (scope)
+
+### В объёме
+- Reaper **не должен** повторно исполнять тяжёлую финализацию `deploy-staging`/merge-gate (security /
+  merge-gate / локальный re-test / coverage / image-freshness), пока исходный monitor/finalizer ещё
+  **жив** или пока edge-гейты для этого job/stage **уже исполняются**.
+- Повторная обработка завершившегося-но-ещё-`running` job на `deploy-staging` должна быть
+  **идемпотентной**: без второго локального re-test/merge-gate для того же job/stage без **строгого
+  владения состоянием**.
+- Согласование Tier-2 grace (`reaper_finalize_grace_s`) с **фактической** wall-clock-длительностью
+  финализации `deploy-staging` ИЛИ замена таймерного критерия живости на сигнал, переживающий
+  «долгую, но живую» финализацию.
+- Сохранение основной функции reaper (ORCH-065): реально **мёртвый** finalizer на `deploy-staging`
+  по-прежнему добивается за ограниченное время.
+
+### Вне объёма
+- Изменение `STAGE_TRANSITIONS` / `QG_CHECKS` / семантики любого `check_*` / machine-verdict ключей /
+  схемы существующих таблиц (правки — только аддитивные).
+- Инфра-толерантность merge-gate к таймауту re-test и tree-kill осиротевших pytest-процессов — это
+  **ORCH-110** (союзная задача того же инцидента; не дублировать).
+- Починка конкретных «мигающих» тестов, давших `3 failed … 14 errors`.
+- Полный редизайн reaper или модели финализации монитора.
+- **Выбор механизма** решения (heartbeat / sub-state `finalizing` / per-stage grace / ownership-lease)
+  — это **архитектурное решение** (06-adr), не зона аналитика.
+
+## 3. Заинтересованные стороны
+- **Owner / Слава** — заказчик исправления, держатель инвариантов self-hosting.
+- **Конвейер всех проектов** (orchestrator self-hosting + enduro-trails) — общий инстанс/БД/очередь:
+  ложный rollback и гонка состояния касаются стабильности платформы в целом.
+- **Операторы** — получатели алертов; именно их будят ложные «merge-gate FAILED / rolled back».
+- **Архитектор** — принимает решение по механизму владения/живости (06-adr) после эскалации.
+
+## 4. Бизнес-требования (BR)
+- **BR-1** — Reaper **не должен** запускать второй прогон edge-гейтов ребра `deploy-staging → deploy`
+  (security / merge-gate / re-test / coverage / image-freshness) для job, чей исходный
+  monitor/finalizer **ещё жив**.
+- **BR-2** — Повторная обработка завершившегося-но-`running` job на `deploy-staging` **идемпотентна**:
+  не более **одного** локального re-test/merge-gate на пару (job, stage) без строгого владения
+  состоянием; второй актор, не владеющий состоянием, **не исполняет** побочных шагов.
+- **BR-3** — Критерий живости Tier-2 должен учитывать **реальную** wall-clock-длительность
+  финализации `deploy-staging` (включающую полный набор edge-гейтов), ИЛИ живость должна определяться
+  сигналом, который **переживает** долгую-но-живую финализацию (не одним `finished_age_s`).
+- **BR-4** — Реально **мёртвый** монитор (краш посреди финализации `deploy-staging`) по-прежнему
+  должен добиваться reaper'ом за ограниченное время — основная функция ORCH-065 **сохраняется**;
+  фикс не превращает reaper в no-op для `deploy-staging`.
+- **BR-5** — После согласования у задачи — **единственное** консистентное состояние: **никакого**
+  ложного отката `deploy-staging → development` и **никакого** ложного developer-retry после
+  фактически успешного deploy; ветки системы сходятся, не расходятся.
+
+## 5. Нефункциональные требования (NFR)
+- **NFR-1** — Контракт reaper сохранён: **never-raise** на единицу работы, **kill-switch**,
+  fail-safe; reaper остаётся наблюдателем-страховкой, не Quality Gate'ом.
+- **NFR-2** — `STAGE_TRANSITIONS` / `QG_CHECKS` / каждый `check_*` / machine-verdict ключи / схема
+  существующих таблиц — **байт-в-байт**; любые БД-правки — только **аддитивные** (`_ensure_column` /
+  `CREATE TABLE IF NOT EXISTS`).
+- **NFR-3** — Self-hosting-безопасно: фикс **никогда** не рестартит/не роняет прод-контейнер и
+  **никогда** не пушит/force-push'ит `main`.
+- **NFR-4** — Обратная совместимость и обратимость: поведение reaper для **не-`deploy-staging`** стадий
+  и путь добивания **мёртвого** монитора сохранены; выключенный kill-switch → строго прежнее
+  поведение; раскат обратим.
+- **NFR-5** — Restart-safe: in-memory состояние reaper сбрасывается при рестарте (это покрыто
+  стартовым `requeue_running_jobs`); любой **новый** маркер владения/живости должен быть либо durable,
+  либо безопасно восстановимым после рестарта.
+- **NFR-6** — Сквозной инвариант ORCH-065/109/110 сохранён: `reaper_max_running_s (5400) >
+  Σ(deploy-staging gate-work) + grace` (Tier-3 backstop). Любая правка grace/таймаутов не должна его
+  нарушить.
+
+## 6. Допущения и ограничения
+- Задача помечена `Bug`; ввиду архитектурной природы — **эскалация в полный цикл** (нужен ADR +
+  анализ тех-рисков архитектором: 06-adr / 07 / 08 / 10).
+- Инстанс общий для всех проектов (общая БД/очередь) — фикс не должен вносить регрессию для
+  enduro-trails и не-self репо.
+- Выбор конкретного механизма владения/живости — за архитектором; настоящий BRD фиксирует **требования
+  и инварианты**, а не реализацию.
+- Источник истины о «жив ли finalizer» сегодня отсутствует: pid агента в Tier-2 **уже мёртв** в обоих
+  случаях (`proc.wait()` вернулся), а живости **потока-монитора/финализатора** система не наблюдает —
+  это и есть пробел, который закрывает фикс.
+
+## 7. Критерии успеха
+Reaper при живом finalizer'е `deploy-staging` не запускает второй прогон edge-гейтов и не откатывает
+задачу; повторная обработка идемпотентна; мёртвый finalizer по-прежнему добивается; после фикса нет
+ложного rollback/developer-retry и расхождения состояния; инварианты ORCH-065/NFR-2 целы; полный
+регресс `tests/` зелёный. Детальные PASS/FAIL — `03-acceptance-criteria.md`.
+
+## 8. Риски
+- **Гонка/расхождение состояния** (наблюдалось): повторный откат после успешного deploy. **Высокий.**
+- **Над-толерантность**: слишком «доверять живости» → реально мёртвый finalizer не добивается (регресс
+  ORCH-065). Сдерживается BR-4 + Tier-3 backstop.
+- **Нарушение сквозного бюджета** при правке grace/таймаутов (NFR-6).
+Детальная проработка и контрмеры — `10-tech-risks.md` (заполняет архитектор).

docs/work-items/ORCH-113/02-trz.md

@@ -0,0 +1,106 @@
+---
+work_item: ORCH-113
+stage: analysis
+author_agent: analyst
+status: ready-for-review
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+escalate: full-cycle
+---
+
+# 02 — ТЗ (TRZ): ORCH-113 — BUG: job-reaper не должен повторно запускать финализацию `deploy-staging`, пока жив исходный finalizer
+
+Work Item: **ORCH-113** · Repo: **orchestrator** · Стадия: analysis
+
+> ТЗ описывает **требования к изменению**, выведенные из BRD и фактического кода. Конкретный
+> механизм (heartbeat живости / sub-state `finalizing` / per-stage grace / ownership-lease на
+> edge-гейты), точные имена символов/колонок/флагов и порядок врезок — **архитектурное решение**
+> (06-adr), не зона аналитика. Модули-плейсхолдеры ниже выровнены под манифест `PIPELINE_DOCS.md`.
+
+## 1. Сводка изменения
+
+Сделать повторную обработку reaper'ом завершившегося-но-ещё-`running` job на стадии `deploy-staging`
+**идемпотентной и владеющей состоянием**: пока исходный monitor/finalizer **жив** (или edge-гейты для
+пары `(job, stage)` уже исполняются), reaper **не должен** независимо запускать второй прогон edge-
+под-гейтов ребра `deploy-staging → deploy` (security / merge-gate / локальный re-test / coverage /
+image-freshness) и **не должен** на этом основании откатывать задачу. Корень — ошибочное допущение
+Tier-2 finalization-grace (`reaper_finalize_grace_s=300`), что финализация после штампа `finished_at`
+длится «секунды…десятки секунд»; для `deploy-staging` она длится **минуты** (полный re-test + coverage
++ rebuild), потому что `_try_advance_stage` (тяжёлые edge-гейты) выполняется **после** штампа
+`finished_at` и **до** `_finalize_job`. Фикс должен дать reaper'у способ отличить «живой, долго
+финализирующий монитор» от «мёртвого монитора» и обеспечить строгое владение исполнением edge-гейтов.
+
+## 2. Задействованные модули / пути
+| Путь | Действие |
+|------|----------|
+| `src/job_reaper.py` | изменить — Tier-2-ветка `_reap_job` (строки ~197-209), `_reap_known_outcome` / `_reap_exit0` / `_gate_driven_advance`: ввести проверку живости/владения перед side-effectful re-drive `advance_stage` для `deploy-staging`; при живом finalizer'е — **defer**, не reap |
+| `src/agents/launcher.py` | изменить (вероятно) — `_monitor_agent`: место/порядок штампа `finished_at` (строка ~861) относительно `_try_advance_stage` (строка ~998) и/или эмиссия durable-сигнала «finalizer жив/финализирует» перед запуском тяжёлых edge-гейтов |
+| `src/db.py` | изменить (вероятно) — `get_running_jobs` (строки ~1337-1367, источник `finished_age_s`) и/или аддитивная колонка владения/живости (`_ensure_column`, паттерн `tasks.cancelled_at`); `reap_running_job` — без изменения контракта атомарного флипа |
+| `src/config.py` | изменить (вероятно) — kill-switch фикса и/или per-stage/finalize-aware grace; сохранить сквозной инвариант `reaper_max_running_s > Σ gate-work + grace` (NFR-6) |
+| `src/stage_engine.py` | **только чтение/ссылка** — `advance_stage` ребро `deploy-staging` (строки ~321-383): эталон того, какие edge-гейты дублируются. Изменение нежелательно; идемпотентность предпочтительно решать на стороне reaper/launcher |
+
+> Точный набор затронутых модулей и распределение логики (reaper-only vs launcher-сигнал vs db-колонка)
+> архитектор фиксирует в 06-adr. Аналитик фиксирует, что центр тяжести правки — `src/job_reaper.py`.
+
+## 3. Функциональные требования
+
+### FR-1 — Распознавание живости финализирующего монитора (BR-1, BR-3)
+Reaper в Tier-2 для стадии `deploy-staging` должен распознавать ситуацию «процесс агента завершён,
+но monitor/finalizer ещё **жив** и исполняет edge-гейты» и **не** трактовать её как мёртвый монитор по
+одному лишь `finished_age_s >= reaper_finalize_grace_s`. Сигнал живости должен переживать долгую
+(минуты) финализацию `deploy-staging`. **Инвариант:** живой finalizer **никогда** не reap'ается.
+
+### FR-2 — Идемпотентность и строгое владение edge-гейтами (BR-2)
+Для пары `(job, stage)` на `deploy-staging` тяжёлый прогон edge-гейтов (security / merge-gate /
+локальный re-test / coverage / image-freshness) исполняется **не более одного раза одновременно**:
+актор, не владеющий состоянием, **не** запускает второй `advance_stage`/re-test/merge-gate. Текущий
+атомарный claim-before-act (`reap_running_job ... WHERE status='running'`) защищает только флип строки
+job — требование расширяет защиту на **side-effectful исполнение edge-гейтов**.
+
+### FR-3 — Согласование grace/бюджета (BR-3, NFR-6)
+Длительность finalization-grace (или заменяющий её сигнал живости) должна покрывать фактический
+wall-clock финализации `deploy-staging` = Σ(security + merge re-test `merge_retest_timeout_s=900` +
+coverage + image rebuild). Любая правка grace/таймаутов сохраняет сквозной инвариант ORCH-065/109/110:
+`reaper_max_running_s (5400) > Σ(deploy-staging gate-work) + grace`.
+
+### FR-4 — Сохранение добивания мёртвого finalizer'а (BR-4)
+Реально **мёртвый** monitor/finalizer на `deploy-staging` (краш посреди финализации, сигнал живости
+отсутствует/протух) по-прежнему добивается reaper'ом за ограниченное время по существующему контракту
+(retry в пределах бюджета, иначе `failed` + Telegram; Tier-3 backstop как крайний предохранитель).
+Reaper не становится no-op для `deploy-staging`.
+
+### FR-5 — Отсутствие расхождения состояния (BR-5)
+Исключить одновременный ложный откат `deploy-staging → development` и успешное завершение
+`deploy → done` для одной задачи. После согласования у задачи — единственное консистентное
+терминальное/стадийное состояние; ложный developer-retry не инкрементируется. Под-гейт merge-verify
+(`deploy → done`, ORCH-071) остаётся единственным choke-point'ом в `done` — он **не** ослабляется.
+
+## 4. Изменения API
+Новых публичных эндпоинтов **не требуется**. Допустима **аддитивная read-only** наблюдаемость в
+`GET /queue` (например, отметка «deploy-staging finalize in-progress / deferred-by-liveness» в блоке
+`reaper`) — без изменения существующих ключей ответа.
+
+## 5. Изменения схемы БД
+Возможна **аддитивная** колонка владения/живости finalizer'а (например, durable-таймштамп
+«finalizing heartbeat» или owner-токен на job/agent_run), вводимая идемпотентно через `_ensure_column`
+(паттерн `tasks.cancelled_at` / `tasks.track`). Существующие таблицы/колонки/индексы и их семантика —
+**без изменений**. Точная необходимость и форма — за архитектором (06-adr / 08-data-requirements).
+
+## 6. Требования к новым/изменённым QG checks
+**Нет.** `QG_CHECKS` и любой `check_*` (включая `check_staging_status`, `check_branch_mergeable`,
+`check_coverage_gate`, `check_security_gate`, `check_staging_image_fresh`, `check_deploy_status`) — не
+трогаются ни по составу, ни по семантике, ни по machine-verdict ключам. Багфикс — свойство страховочного
+демона/финализатора, **не** Quality Gate.
+
+## 7. Совместимость / регресс
+- **Kill-switch:** фикс под выделенным флагом; `False` → строго прежнее поведение reaper (нулевая
+  регрессия).
+- **Область:** поведение для **не-`deploy-staging`** стадий и путь добивания мёртвого монитора —
+  сохранены; self-hosting-only/скоуп репо согласовать с существующими leaf-паттернами (если вводится
+  per-repo разрез).
+- **Обратимость:** раскат обратим выключением флага (+ откатом значений grace/таймаутов к дефолтам).
+- **Never-raise / restart-safe / self-hosting (NFR-1/3/5):** любой сбой нового пути живости/владения
+  деградирует безопасно (reaper-тик продолжается); новый durable-маркер восстановим после рестарта;
+  фикс не рестартит прод и не пушит `main`.
+- **Сквозной инвариант (NFR-6):** `reaper_max_running_s > Σ gate-work + grace` сохранён.
+- **Анти-регресс:** структурный тест-гард (см. `04-test-plan.yaml`), полный `tests/` остаётся зелёным.

docs/work-items/ORCH-113/03-acceptance-criteria.md

@@ -0,0 +1,98 @@
+---
+work_item: ORCH-113
+stage: analysis
+author_agent: analyst
+status: ready-for-review
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+escalate: full-cycle
+---
+
+# 03 — Критерии приёмки (Acceptance Criteria): ORCH-113 — BUG: job-reaper не должен повторно запускать финализацию `deploy-staging`, пока жив исходный finalizer
+
+Work Item: **ORCH-113** · Repo: **orchestrator** · Стадия: analysis
+
+Формат: каждый критерий имеет **PASS** (что должно быть истинно для приёмки) и **FAIL** (что считается
+провалом). Любой машинный/ручной reviewer проверяет их буквально по файлам репозитория и тестам.
+
+---
+
+## AC-1 — Нет второго прогона edge-гейтов при живом finalizer'е
+
+**Условие:** job на `deploy-staging` с `exit_code=0`, `finished_age_s >= reaper_finalize_grace_s`, но
+исходный monitor/finalizer ещё **жив** (сигнал живости присутствует).
+- **PASS:** reaper **не** вызывает `_gate_driven_advance`/`advance_stage` для этого job; второй прогон
+  security / merge-gate / локального re-test / coverage / image-freshness **не** запускается; reaper
+  логирует defer.
+- **FAIL:** reaper запускает повторный `advance_stage` / любой edge-под-гейт, пока finalizer жив.
+
+---
+
+## AC-2 — Идемпотентность и строгое владение состоянием
+
+**Условие:** монитор финализирует `deploy-staging` и параллельно срабатывает reaper-тик для того же
+job/stage.
+- **PASS:** тяжёлый прогон edge-гейтов (merge-gate / локальный re-test) исполняется **ровно один раз**
+  для пары `(job, stage)`; актор без владения состоянием не выполняет побочных шагов (мерж/re-test/
+  rollback).
+- **FAIL:** второй локальный re-test/merge-gate запускается для того же job/stage без владения
+  состоянием (двойное исполнение edge-гейтов).
+
+---
+
+## AC-3 — Мёртвый finalizer по-прежнему добивается
+
+**Условие:** monitor/finalizer на `deploy-staging` реально **умер** посреди финализации (сигнал
+живости отсутствует/протух), job завис в `running`.
+- **PASS:** reaper за ограниченное время добивает job по существующему контракту (retry в пределах
+  бюджета, иначе `failed` + Telegram; Tier-3 backstop как предохранитель); reaper для `deploy-staging`
+  **не** превращён в no-op.
+- **FAIL:** мёртвый finalizer на `deploy-staging` не добивается reaper'ом (зомби-job блокирует очередь).
+
+---
+
+## AC-4 — Нет ложного отката и расхождения состояния после успешного deploy
+
+**Условие:** сценарий инцидента ORCH-111 — долгая (> grace) финализация `deploy-staging` при зелёном
+`staging_status: SUCCESS`, deploy/finalizer параллельно доходит до `deploy_status: SUCCESS` / merge PR.
+- **PASS:** задача **не** откатывается `deploy-staging → development` параллельной reaper-веткой;
+  developer-retry **не** инкрементируется ложно; у задачи единственное консистентное
+  терминальное/стадийное состояние (сходимость, не расхождение).
+- **FAIL:** задача откатана `deploy-staging → development` и/или начислен ложный developer-retry, в то
+  время как deploy фактически успешен; ветки состояния расходятся.
+
+---
+
+## AC-5 — Инварианты и контракт reaper сохранены
+
+**Условие:** аудит диффа и поведения при выключенном kill-switch.
+- **PASS:** `STAGE_TRANSITIONS` / `QG_CHECKS` / каждый `check_*` / machine-verdict ключи / схема
+  существующих таблиц — **байт-в-байт**; БД-правки только аддитивные (`_ensure_column` /
+  `CREATE TABLE IF NOT EXISTS`); reaper остаётся never-raise per unit; выключенный флаг → прежнее
+  поведение; правки не рестартят прод и не пушат `main`; сквозной инвариант
+  `reaper_max_running_s > Σ gate-work + grace` (ORCH-065/109/110) сохранён.
+- **FAIL:** изменены `STAGE_TRANSITIONS`/`QG_CHECKS`/семантика `check_*`/machine-verdict ключи или
+  схема существующих таблиц; reaper может бросить исключение из тика; флаг `False` меняет поведение;
+  нарушен сквозной бюджетный инвариант.
+
+---
+
+## AC-6 — Обязательный регресс-тест и зелёный полный прогон
+
+**Условие:** запуск тест-сюита репозитория.
+- **PASS:** добавлен регресс-тест инцидента ORCH-111 (TC-05 в `04-test-plan.yaml`), **красный** на
+  коде до фикса и **зелёный** после; полный `pytest tests/ -q` зелёный.
+- **FAIL:** регресс-теста нет, либо он зелёный и до фикса (не воспроизводит баг), либо полный регресс
+  `tests/` красный.
+
+---
+
+## Сводная матрица AC ↔ FR/BR
+| AC | Покрывает |
+|----|-----------|
+| AC-1 | BR-1 / BR-3 / FR-1 |
+| AC-2 | BR-2 / FR-2 |
+| AC-3 | BR-4 / FR-4 |
+| AC-4 | BR-5 / FR-5 |
+| AC-5 | NFR-1 / NFR-2 / NFR-3 / NFR-6 / FR-3 |
+| AC-6 | BR-1…BR-5 (регресс-доказательство) |

docs/work-items/ORCH-113/04-test-plan.yaml

@@ -0,0 +1,76 @@
+work_item: ORCH-113
+stage: analysis
+author_agent: analyst
+status: ready-for-review
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+escalate: full-cycle
+title: "job-reaper не повторяет финализацию deploy-staging при живом finalizer'е: живость + идемпотентность + строгое владение"
+framework: pytest
+scope: >
+  Покрывает: распознавание живого финализирующего монитора в Tier-2 reaper на стадии deploy-staging
+  (не reap по одному finished_age_s); идемпотентность и строгое владение исполнением edge-гейтов
+  (не более одного локального re-test/merge-gate на (job, stage)); сохранение добивания РЕАЛЬНО
+  мёртвого finalizer'а; отсутствие ложного отката deploy-staging -> development и расхождения состояния
+  после успешного deploy; сохранение инвариантов (STAGE_TRANSITIONS/QG_CHECKS/check_*/machine-verdict/
+  схема существующих таблиц байт-в-байт; never-raise; kill-switch; сквозной бюджет ORCH-065/109/110).
+  Вне покрытия: инфра-толерантность merge-gate к таймауту re-test и tree-kill осиротевших процессов
+  (ORCH-110); починка конкретных мигающих тестов; поведение enduro/не-self репо (только проверяется
+  отсутствие регрессии / no-op).
+notes: >
+  TC-05 — ОБЯЗАТЕЛЬНЫЙ регресс-тест инцидента ORCH-111 (deployer job 1914 / run_id 683): КРАСНЫЙ на
+  коде до фикса (reaper при живом долгом finalizer'е deploy-staging независимо запускает второй прогон
+  edge-гейтов и откатывает задачу), ЗЕЛЁНЫЙ после фикса. Подпроцессы (pytest re-test / coverage /
+  docker), сеть, Plane и Gitea — мокаются; «живой/мёртвый finalizer» и «долгая финализация > grace»
+  моделируются управляемо, без обращения наружу. Полный регресс tests/ должен оставаться зелёным.
+  Точные имена символов/колонок/флагов уточняет архитектор (06-adr); модули-плейсхолдеры выровнены под
+  манифест PIPELINE_DOCS.
+
+tests:
+  - id: TC-01
+    type: unit
+    description: "Tier-2 reaper на deploy-staging: exit_code=0 и finished_age_s >= grace, но finalizer ЖИВ (сигнал живости присутствует) -> reaper НЕ вызывает _gate_driven_advance/advance_stage; второй прогон edge-гейтов не запускается; логируется defer (AC-1/FR-1)."
+    module: tests/test_orch113_reaper_finalizer_liveness.py
+    expected: PASS
+
+  - id: TC-02
+    type: unit
+    description: "Строгое владение: при попытке повторной обработки того же (job, stage) актор без владения состоянием НЕ исполняет merge-gate/локальный re-test/advance (claim/ownership проигран -> ноль побочных эффектов), AC-2/FR-2."
+    module: tests/test_orch113_reaper_finalizer_liveness.py
+    expected: PASS
+
+  - id: TC-03
+    type: unit
+    description: "Мёртвый finalizer на deploy-staging (сигнал живости отсутствует/протух) -> reaper по-прежнему добивает job за ограниченное время по существующему контракту (retry в пределах бюджета, иначе failed+Telegram; Tier-3 backstop срабатывает) — reaper не no-op для deploy-staging (AC-3/FR-4)."
+    module: tests/test_orch113_reaper_finalizer_liveness.py
+    expected: PASS
+
+  - id: TC-04
+    type: integration
+    description: "Идемпотентность под гонкой: монитор финализирует deploy-staging и параллельно срабатывает reaper-тик -> тяжёлый прогон edge-гейтов (merge-gate/re-test) исполняется РОВНО ОДИН раз для (job, stage); нет второго re-test и нет ложного rollback (AC-2/AC-4/FR-2/FR-5)."
+    module: tests/test_orch113_reaper_finalizer_liveness.py
+    expected: PASS
+
+  - id: TC-05
+    type: integration
+    description: "ОБЯЗАТЕЛЬНЫЙ регресс ORCH-111: долгая (> grace) финализация deploy-staging при staging_status=SUCCESS, deploy/finalizer параллельно доходит до успеха/merge PR -> reaper НЕ откатывает deploy-staging -> development и НЕ инкрементирует developer-retry; у задачи единственное консистентное состояние. КРАСНЫЙ до фикса, ЗЕЛЁНЫЙ после (AC-4/FR-5)."
+    module: tests/test_orch113_reaper_finalizer_liveness.py
+    expected: PASS
+
+  - id: TC-06
+    type: unit
+    description: "Регресс-гард совместимости: kill-switch выключен ИЛИ стадия не deploy-staging -> поведение reaper байт-в-байт прежнее (Tier-2 grace, claim-before-act, dead-pid/Tier-3 пути неизменны), NFR-4/AC-5."
+    module: tests/test_orch113_reaper_finalizer_liveness.py
+    expected: PASS
+
+  - id: TC-07
+    type: unit
+    description: "Сквозной инвариант бюджета (ORCH-065/109/110): при дефолтном конфиге reaper_max_running_s (5400) > Σ(deploy-staging gate-work) + grace; любая правка grace/таймаутов фикса инвариант не нарушает (NFR-6/AC-5)."
+    module: tests/test_orch113_reaper_finalizer_liveness.py
+    expected: PASS
+
+  - id: TC-08
+    type: unit
+    description: "never-raise: сбой/исключение в новом пути распознавания живости/владения деградирует безопасно — reaper-тик не падает, прочие job обрабатываются, прод не трогается, main не пушится (NFR-1/NFR-3/AC-5)."
+    module: tests/test_orch113_reaper_finalizer_liveness.py
+    expected: PASS

docs/work-items/ORCH-113/06-adr/ADR-001-reaper-finalizer-liveness-ownership.md

@@ -0,0 +1,158 @@
+---
+work_item: ORCH-113
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# ADR-001: Reaper Tier-2 — in-memory ownership-маркер финализации `deploy-staging` (живой finalizer не реапится)
+
+Work Item: **ORCH-113** — BUG: job-reaper повторно запускает финализацию `deploy-staging`, пока жив исходный finalizer
+Стадия: **architecture**
+Сквозная регистрация: **`docs/architecture/adr/adr-0043-reaper-finalizer-liveness-ownership.md`** (решение кросс-каттинговое — уточняет контракт reaper ORCH-065/adr-0011).
+
+## Статус
+Proposed
+
+## Контекст
+
+Оркестратор self-hosting: один инстанс, общая БД/очередь, `max_concurrency=1`. Финальный статус job
+(`done`/`queued`/`failed`/`cancelled`) пишется **только** в живом процессе
+(`launcher._monitor_agent → _finalize_job`). Сверено по коду:
+
+- `_monitor_agent` штампит `agent_runs.finished_at`/`exit_code` **ПЕРВЫМ** (`launcher.py:861`), затем
+  делает git commit/push (+PR), usage-комментарии Plane (секунды…десятки секунд), затем
+  `_try_advance_stage` (`launcher.py:998`) и лишь потом `_finalize_job` (`launcher.py:1003`).
+- На ребре `deploy-staging → deploy` `_try_advance_stage → advance_stage` синхронно, **в потоке
+  монитора**, прогоняет тяжёлый набор edge-под-гейтов (`stage_engine.py:327–368`):
+  `security` → `merge-gate` (полный локальный re-test, бюджет `merge_retest_timeout_s=900`) →
+  `coverage` (`pytest --cov`) → `image-freshness` (docker-rebuild + пересоздание staging) — это
+  **минуты**, и весь объём идёт **после** штампа `finished_at` и **до** `_finalize_job`.
+- Reaper Tier-2 (`job_reaper._reap_job`, `job_reaper.py:197–209`) меряет `finished_age_s` от
+  `agent_runs.finished_at` (`db.get_running_jobs`, `db.py:1360`) = **от начала** финализации. По
+  истечении `reaper_finalize_grace_s=300` он трактует живого, долго финализирующего монитора как
+  мёртвого и независимо запускает тот же тяжёлый advance (`_reap_exit0 → _gate_driven_advance →
+  _try_advance_stage → advance_stage`).
+
+Дешёвая read-only пред-проверка `_gate_is_green('deploy-staging')` читает лишь `check_staging_status`
+(frontmatter `15-staging-log.md` = `SUCCESS`) → reaper уверенно идёт в тяжёлый advance. Атомарный
+claim-before-act (`reap_running_job ... WHERE status='running'`) защищает **флип строки** job, но **не
+side-effectful исполнение edge-гейтов**: монитор не claim'ит строку перед `advance_stage`, поэтому
+монитор и reaper выполняют `advance_stage` **параллельно**.
+
+**Инцидент ORCH-111 (deployer job 1914, run_id 683):** финализация `deploy-staging` заняла >300с;
+reaper повторил edge-гейты; один повторный re-test стал красным (`3 failed … 14 errors in 444.79s`);
+задача ложно откатана `deploy-staging → development` (+ ложный developer-retry), **параллельно**
+исходный finalizer довёл deploy до `SUCCESS` и смержил PR #130 (`deploy → done`). Состояние раздвоилось.
+
+Источника истины «жив ли finalizer» сегодня нет: pid агента в Tier-2 уже мёртв в **обоих** случаях
+(`proc.wait()` вернулся), а живость **потока-монитора** система не наблюдает. Per-stage grace,
+покрывающая Σ финализации (`Σ ≈ 4160с`), невозможна без нарушения сквозного бюджета ORCH-065/109/110
+`reaper_max_running_s (5400) > Σ(deploy-staging gate-work) + grace (≈4460)`.
+
+**Решающий факт (проверен):** монитор и reaper — daemon-**потоки одного** uvicorn-процесса (CMD без
+`--workers`; `_monitor_agent` стартует `threading.Thread`, `launcher.py:661`; reaper — daemon-поток,
+`main.py:144`), разделяющие одну SQLite-БД. Значит, живость finalizer'а можно определить **in-memory**.
+Рестарт покрыт существующим `requeue_running_jobs()` (`running → queued`), который в `main.lifespan`
+вызывается (`main.py:59`) **до** старта reaper (`main.py:144`).
+
+## Решение
+
+### Сводка
+Ввести **процесс-локальный реестр владения финализацией**: живой монитор регистрирует «я финализирую
+job X», а reaper в Tier-2 на стадии `deploy-staging` **не реапит** job, чьё владение активно, и
+переходит к Tier-3 backstop. Реестр in-memory — авторитетен в рамках одного процесса/БД; рестарт
+покрыт `requeue_running_jobs`. Grace и `reaper_max_running_s` не меняются → сквозной бюджет цел. Под
+глобальным kill-switch; **нулевое** изменение схемы БД и контрактов.
+
+### D1 — Leaf `src/finalizer_liveness.py` (владение, FR-2)
+Новый чистый процесс-локальный модуль (паттерн `serial_gate`/`coverage_gate`: never-raise, без сети/БД):
+- `mark(job_id, run_id, stage)` — зарегистрировать активную финализацию;
+- `clear(job_id)` — снять;
+- `is_active(job_id) -> bool` — есть ли живое владение;
+- `snapshot() -> dict` — read-only для наблюдаемости.
+
+Состояние — `{job_id: {"run_id", "stage", "started_ts"}}` + `threading.Lock`. Собственного TTL нет —
+ограничение по времени даёт Tier-3 (см. D3). Все функции изолированы `try/except` → дефолт
+(`is_active` при ошибке → `False`, консервативно: не блокировать добивание).
+
+### D2 — Эмиссия владения в `launcher._monitor_agent` (FR-1)
+`mark(job_id, run_id, stage)` вызывается **сразу после** штампа `exit_code` (`launcher.py:864`, самый
+ранний момент, когда reaper переходит в Tier-2; до этого pid агента жив → Tier-1 защищает). Хвост
+финализации (git push … `_try_advance_stage` … `_finalize_job`) оборачивается в `try/finally`, в
+`finally` — `clear(job_id)`. Так исключение **в потоке монитора** гарантированно снимает владение →
+reaper добивает (FR-4). Только при `job_id is not None` (legacy `launch()` с `job_id=None` не в
+`get_running_jobs`). Гибель **всего процесса** → рестарт → `requeue_running_jobs` → реестр пуст
+(restart-safe без durable, NFR-5).
+
+### D3 — Консультация reaper, scoped + Tier-3 backstop (FR-3, FR-4)
+В `job_reaper._reap_job`, Tier-2-ветка (`exit_code` записан, `finished_age >= grace`): **перед**
+`_reap_known_outcome` — если `settings.reaper_finalizer_liveness_enabled` **И** стадия задачи
+(`_task_meta`) `== "deploy-staging"` **И** `finalizer_liveness.is_active(job_id)` → **defer** (лог +
+счётчик), **не** реапить через Tier-2, провалиться к Tier-3. Иначе — прежний путь
+(`_reap_known_outcome; return`), байт-в-байт. **Tier-3** (`age >= reaper_max_running_s`) маркер
+**игнорирует** — добивает всегда (ограниченное время; бюджет `5400 > Σ+grace ≈ 4460` гарантирует, что
+легитимная финализация завершится до 5400 → ложного Tier-3-реапа живого finalizer'а нет).
+
+### D4 — Скоуп и kill-switch (NFR-4)
+Только глобальный `reaper_finalizer_liveness_enabled` (`config.py`, env
+`ORCH_REAPER_FINALIZER_LIVENESS_ENABLED`, дефолт `True`). **Без** per-repo разреза: баг общий для
+любого репо со стадией `deploy-staging` (enduro тоже); per-repo оставил бы баг активным для части
+репо. Это сознательный отход от leaf-паттерна `*_repos` (он для **гейтов, действующих на репо**; здесь
+— наблюдатель-безопасность глобального демона). `False` → reaper никогда не консультирует маркер →
+поведение байт-в-байт прежнее; стадии `!= deploy-staging` не консультируются → не тронуты.
+
+### D5 — Наблюдаемость (TZ §4)
+Счётчик `finalizer_defers_total` + размер `finalizer_liveness.snapshot()` в блоке `reaper`
+`GET /queue`. Существующие ключи ответа не меняются; новых эндпоинтов нет.
+
+### Инварианты
+`STAGE_TRANSITIONS` / `QG_CHECKS` / каждый `check_*` / machine-verdict ключи / схема существующих
+таблиц — **байт-в-байт**; **нулевое** изменение схемы БД; reaper остаётся never-raise per-unit;
+`reaper_finalize_grace_s` и `reaper_max_running_s` **не меняются** (NFR-6 цел); фикс не рестартит прод
+и не пушит `main` (NFR-3). Merge-verify (`deploy → done`, ORCH-071) — единственный choke-point в
+`done`, не ослабляется (FR-5).
+
+## Альтернативы
+- **Per-stage grace, покрывающая Σ** — отвергнуто: нарушает бюджет `5400 > Σ+grace` (Σ≈4160 ⇒ grace
+  пришлось бы <1240, не покрывает Σ); таймер — это и есть источник бага.
+- **Durable-колонка (finalizing-heartbeat / owner-токен)** — отвергнуто: один процесс/одна БД →
+  in-memory авторитетно; рестарт покрыт requeue; блокирующий re-test (900с) не может бить периодический
+  heartbeat из того же потока; durable добавляет миграцию и запись ради нулевой выгоды.
+- **Sub-state `finalizing` в `jobs.status`** — отвергнуто: меняет семантику статуса, который читают
+  `claim_next_job`/`requeue_running_jobs`/`reconciler`/`reaper` (`WHERE status='running'`) — нарушение
+  NFR-2 и высокий радиус поражения.
+- **Lease-файл на `(job, stage)` (как merge-lease)** — отвергнуто: тяжелее (файловый I/O, TTL,
+  reclaim), дублирует merge-lease; in-memory достаточно при одном процессе; TTL возвращает таймер-проблему.
+- **Флип job из `running` до тяжёлых гейтов** — отвергнуто: ломает `get_running_jobs`/метрики и
+  restart-requeue (краш мид-гейт оставит job non-running и нереквью'имым).
+
+## Последствия
+- **+** Устранены повторный прогон edge-гейтов, ложный откат `deploy-staging → development` и
+  расхождение состояния при живом долгом finalizer'е; идемпотентность edge-гейтов через владение
+  (AC-1/AC-2/AC-4).
+- **+** Реально мёртвый/застрявший finalizer добивается (finally-clear → Tier-2; иначе Tier-3);
+  основная функция reaper ORCH-065 сохранена (AC-3).
+- **+** Нулевое изменение схемы и контрактов; сквозной бюджет ORCH-065/109/110 не тронут (AC-5).
+- **−** Гарантия владения валидна при **одном процессе/одной БД** (проверено: один uvicorn-воркер);
+  ввод `--workers>1` потребует durable-сигнала — зафиксировано в `10-tech-risks.md` (TR-3).
+- **−** Окно «штамп `finished_at` → `mark()`» (git push) маркером не покрыто — закрыто прежним
+  grace=300 (окно ≪ grace), TR-2.
+- **Откат:** `ORCH_REAPER_FINALIZER_LIVENESS_ENABLED=false` → reaper байт-в-байт прежний (маркер
+  по-прежнему пишется монитором, но не консультируется — инертен). Полный откат — удаление leaf +
+  двух врезок.
+
+## Ссылки
+- BRD: `docs/work-items/ORCH-113/01-brd.md`
+- TRZ: `docs/work-items/ORCH-113/02-trz.md`
+- Acceptance: `docs/work-items/ORCH-113/03-acceptance-criteria.md`
+- Test-plan: `docs/work-items/ORCH-113/04-test-plan.yaml`
+- Сквозной ADR: `docs/architecture/adr/adr-0043-reaper-finalizer-liveness-ownership.md`
+- Базовые ADR: `adr-0011` (reaper/lease ORCH-065), `adr-0040` (timeout-бюджеты ORCH-109),
+  `adr-0042` (merge-gate re-test ORCH-110)
+- Сверено по коду: `src/job_reaper.py`, `src/agents/launcher.py` (`_monitor_agent`/`_try_advance_stage`),
+  `src/db.py` (`get_running_jobs`/`requeue_running_jobs`), `src/stage_engine.py` (`advance_stage` ребро
+  `deploy-staging`), `src/config.py` (`reaper_*`), `src/main.py` (`lifespan`)
+</content>

docs/work-items/ORCH-113/07-infra-requirements.md

@@ -0,0 +1,40 @@
+---
+work_item: ORCH-113
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# 07 — Инфра-требования: ORCH-113 — reaper finalizer-liveness ownership
+
+Work Item: **ORCH-113** · Repo: **orchestrator** · Стадия: architecture
+
+> When-applicable / информационный. Топология **не меняется**; ниже — только конфиг и операционные
+> инварианты, которые сопровождающий обязан удержать.
+
+## Изменения топологии
+**N/A.** Ни новых сервисов/контейнеров, ни портов, ни томов, ни сетевых правил. Решение целиком внутри
+процесса `orchestrator` (новый leaf + две врезки в существующие потоки monitor/reaper).
+
+## Новый конфиг (env)
+| Ключ | Дефолт | Назначение |
+|------|--------|-----------|
+| `ORCH_REAPER_FINALIZER_LIVENESS_ENABLED` | `true` | Kill-switch. `false` → reaper байт-в-байт прежний (маркер пишется, но не консультируется). Откат фикса = установить `false`. |
+
+Существующие `reaper_finalize_grace_s` (300) и `reaper_max_running_s` (5400) — **не меняются**.
+`.env.example` пополнить новым ключом (дефолт = боевое значение, паттерн ORCH-101: пустой `.env` ⇒
+прежнее поведение).
+
+## Операционные инварианты (сопровождение)
+- **Одно-процессная модель — несущий инвариант.** Авторитетность in-memory реестра владения держится
+  на том, что монитор и reaper — потоки **одного** uvicorn-процесса. CMD/команда compose **не должны**
+  получать `uvicorn --workers>1` без перевода сигнала в durable (см. `10-tech-risks.md` TR-3, ADR-001).
+  Сверено: `Dockerfile:65`, `docker-compose.yml:36` (prod), `docker-compose.yml:123` (staging) — без
+  `--workers`.
+- **Сквозной бюджет ORCH-065/109/110** `reaper_max_running_s (5400) > Σ(deploy-staging gate-work)+grace
+  (≈4460)` остаётся в силе и фиксом не затрагивается (TR-4).
+- **Self-hosting-страховка:** обкатка — на staging (8501, изолированная БД) до прод-деплоя; деплой
+  орка — только через статус «Confirm Deploy». Фикс не рестартит прод и не пушит `main`.
+</content>

docs/work-items/ORCH-113/08-data-requirements.md

@@ -0,0 +1,43 @@
+---
+work_item: ORCH-113
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# 08 — Требования к данным: ORCH-113 — reaper finalizer-liveness ownership
+
+Work Item: **ORCH-113** · Repo: **orchestrator** · Стадия: architecture
+
+> When-applicable / информационный (гейтом не парсится).
+
+## Изменения схемы БД
+
+**N/A — нулевое изменение схемы.** Сознательное архитектурное решение (ADR-001 / adr-0043): сигнал
+владения финализацией — **in-memory** (leaf `src/finalizer_liveness.py`), а не durable-колонка. Ни
+новых таблиц, ни новых колонок, ни индексов; `init_db()` / `_ensure_column` не трогаются. Схема
+существующих таблиц (`jobs`, `agent_runs`, `tasks`, …) и их семантика — **байт-в-байт** (NFR-2/AC-5).
+
+## Новые/изменённые сущности
+
+**Процесс-локальный реестр владения** (не БД): `finalizer_liveness` хранит
+`{job_id: {"run_id", "stage", "started_ts"}}` под `threading.Lock`. Запись/снятие — живой
+монитор-поток (`launcher._monitor_agent`); чтение — reaper-поток (`job_reaper`). Ключ — `jobs.id`
+(существующая сущность). Никаких новых персистентных данных.
+
+## Совместимость данных / миграции
+
+- **Миграций нет** — нечего мигрировать (нет схемных изменений); общая прод-БД (self-hosting +
+  enduro-trails) не затрагивается.
+- **Restart-safe без durable (NFR-5):** in-memory реестр сбрасывается при рестарте процесса, что
+  **безопасно** по существующему контракту: `main.lifespan` вызывает `requeue_running_jobs()`
+  (`running → queued`, `main.py:59`) **до** старта reaper (`main.py:144`). После рестарта нет ни одного
+  `running`-job, ссылающегося на потерянный маркер → отсутствие маркера корректно (нет живых
+  finalizer'ов). Гибель **потока** монитора (не процесса) покрыта `try/finally`-снятием маркера; гибель
+  **процесса** → рестарт → requeue.
+- **Авторитетность in-memory** опирается на одно-процессную модель (один uvicorn-воркер, общая
+  SQLite-БД; проверено: CMD без `--workers`). Условие задокументировано как инвариант сопровождения —
+  при вводе `--workers>1` сигнал должен стать durable (см. `10-tech-risks.md` TR-3).
+</content>

docs/work-items/ORCH-113/10-tech-risks.md

@@ -0,0 +1,37 @@
+---
+work_item: ORCH-113
+stage: architecture
+author_agent: architect
+status: proposed
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+---
+
+# 10 — Технические риски: ORCH-113 — reaper finalizer-liveness ownership
+
+Work Item: **ORCH-113** · Repo: **orchestrator** · Стадия: architecture
+
+> Информационный (гейтом не парсится). Риски реализации и их митигейшн.
+
+## Реестр рисков
+
+| ID | Риск | Вер. | Влия. | Митигейшн |
+|----|------|------|-------|-----------|
+| TR-1 | **Над-толерантность:** маркер «жив» застрял (не снят) → реально мёртвый finalizer не добивается, зомби клинит очередь (регресс ORCH-065). | Низ. | Выс. | `try/finally`-снятие в `_monitor_agent` (исключение потока снимает владение); гибель процесса → рестарт → `requeue_running_jobs`. **Tier-3 backstop игнорирует маркер** и добивает при `age >= reaper_max_running_s=5400` → ограниченное время гарантировано (FR-4/AC-3). Покрытие — TC-03. |
+| TR-2 | **Окно без владения** между штампом `finished_at` (launcher:861) и `mark()` (после exit_code, launcher:864): reaper мог бы реапнуть в этом окне. | Низ. | Сред. | Окно = git push/PR/Plane-комментарии (секунды…десятки секунд) ≪ `reaper_finalize_grace_s=300` → прежний grace покрывает его; маркер ставится самым ранним возможным моментом Tier-2 (до этого pid агента жив → Tier-1 защищает). |
+| TR-3 | **Многопроцессность:** при `uvicorn --workers>1` монитор и reaper окажутся в разных процессах → in-memory реестр не разделяется → возможна двойная финализация. | Низ. | Выс. | Сейчас CMD без `--workers` (проверено: `Dockerfile:65`, `docker-compose.yml:36`). Инвариант сопровождения зафиксирован в ADR-001/adr-0043 и 08-data-requirements: ввод `--workers>1` ⇒ перевести сигнал в durable (heartbeat-колонка) — отдельная задача. Анти-дрейф можно усилить структурным тестом (нет `--workers` в CMD). |
+| TR-4 | **Нарушение сквозного бюджета** ORCH-065/109/110 при правке grace/таймаутов. | Оч. низ. | Выс. | Решение **не меняет** `reaper_finalize_grace_s` (300) и `reaper_max_running_s` (5400) — инвариант `5400 > Σ(deploy-staging gate-work)+grace ≈ 4460` тривиально цел; покрытие — TC-07/AC-5. |
+| TR-5 | **Гонка чтения/записи** реестра (монитор пишет, reaper читает). | Низ. | Сред. | `threading.Lock` вокруг операций реестра; `is_active`/`snapshot` атомарны под локом; never-raise → ошибка чтения = `False` (консервативно, не блокирует добивание). Покрытие — TC-02/TC-04/TC-08. |
+| TR-6 | **Регресс не-deploy-staging / выключенного флага** (NFR-4): фикс случайно меняет прежние пути reaper. | Низ. | Сред. | Консультация маркера gated `enabled AND stage=="deploy-staging"`; Tier-1/Tier-3/exit≠0/claim-before-act не трогаются; `False` → reaper байт-в-байт прежний. Покрытие — TC-06. |
+| TR-7 | **Ложный regression-тест** TC-05: зелёный и до фикса (не воспроизводит баг). | Сред. | Сред. | TC-05 моделирует «живой долгий finalizer > grace» управляемо (моки подпроцессов/сети); обязан быть **красным до** фикса и **зелёным после** (AC-6). Reviewer/tester проверяют красноту на базе. |
+
+## Сводный вывод
+
+Доминирующий класс — **над-толерантность** (TR-1) и **многопроцессная авторитетность** (TR-3); оба
+имеют низкую вероятность и закрыты соответственно Tier-3 backstop'ом (без правки бюджета) и
+зафиксированным инвариантом одно-процессной модели. Решение аддитивно, под kill-switch, без изменения
+схемы/контрактов и без правки сквозного бюджета. Эскалация `arch:major-change` **не требуется**
+(нет новой стадии/QG, нет изменения схемы БД, центр тяжести — один leaf + две точечные врезки).
+Остаточный риск для прод-конвейера (self-hosting) — **низкий**; полностью обратим выключением
+`ORCH_REAPER_FINALIZER_LIVENESS_ENABLED`.
+</content>

docs/work-items/ORCH-113/12-review.md

@@ -0,0 +1,86 @@
+---
+verdict: APPROVED
+work_item: ORCH-113
+stage: review
+author_agent: reviewer
+status: approved
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+type: review
+work_item_id: ORCH-113
+version: 1
+---
+
+# Review ORCH-113 — BUG: job-reaper не должен повторно запускать финализацию `deploy-staging`, пока жив исходный finalizer
+
+## Summary
+
+Фикс инцидента ORCH-111 реализован чисто и полно. Введён процесс-локальный реестр владения
+финализацией (`src/finalizer_liveness.py`, never-raise leaf по паттерну `serial_gate`/`coverage_gate`):
+монитор `mark()`-ит владение сразу после штампа `exit_code` и `clear()`-ит его в `finally` хвоста
+финализации; reaper в Tier-2 при `stage=="deploy-staging"` И активном владении делает **defer** вместо
+повторного `advance_stage`, проваливаясь к Tier-3 backstop (который маркер игнорирует → застрявший
+finalizer всё равно добивается).
+
+Проверено по всем 4 осям; блокирующих findings нет.
+
+- **ТЗ:** FR-1…FR-5 реализованы; AC-1…AC-6 покрыты тестами `tests/test_orch113_reaper_finalizer_liveness.py`
+  (TC-01…TC-08). Схема БД — **нулевое** изменение (выбран in-memory реестр), что строже допущенной ТЗ §5
+  «аддитивная колонка». API §4 (read-only ключи в `GET /queue`) и QG §6 (не трогать) — соблюдены.
+- **ADR:** реализация байт-в-байт соответствует ADR-001 / сквозному adr-0043 (D1–D5). Трассировка
+  сохранена: авторитет Tier-3 (adr-0011/ORCH-065) и сквозной бюджет `reaper_max_running_s (5400) >
+  Σ(gate-work)+grace` (ORCH-109/110) не нарушены — зафиксировано регресс-тестом TC-07. Ни один
+  маркированный инвариант не сломан.
+- **Качество кода:** хвост `_monitor_agent` вынесен в `_run_monitor_finalization` **дословно** —
+  подтверждено `git diff -w` (+49/−0, нулевое изменение логики); все переменные, на которые ссылается
+  извлечённое тело, — параметры/локальные/модульные (нет риска `NameError`, проверено вручную).
+  never-raise во всех публичных функциях и врезках. Обязательный регресс-тест багфикс-трека (ORCH-019
+  BR-4 / coverage ORCH-027) присутствует: TC-05 по построению КРАСНЫЙ до фикса (assert `calls == []`,
+  который pre-fix reaper нарушил бы вызовом `_try_advance_stage`) и ЗЕЛЁНЫЙ после.
+- **Документация:** обновлены в том же PR — `docs/architecture/README.md` (описание Job-reaper +
+  раздел Tier-2 + список kill-switch + ссылки на ADR), `docs/architecture/internals.md` (детализация
+  Tier-2), `CHANGELOG.md`, ADR-001 (work-item) и сквозной adr-0043; все номерные доки задачи (00–04,
+  06-adr, 07, 08, 10) на месте.
+
+**Проверка прогона:** `pytest tests/ -q` → **2001 passed**, 0 failures (AC-6); целевой файл — 13 passed.
+
+## Findings
+
+### P0 — Blocker
+- _нет_
+
+### P1 — Must fix
+- _нет_
+
+### P2 — Should fix
+- _нет_
+
+### P3 — Nice-to-have (не блокирует приёмку)
+- [ ] Frontmatter обоих ADR (`ADR-001` и `adr-0043`) держит `status: proposed`. По мере мержа фикса
+  статус естественно становится принятым решением — стоит при следующем касании обновить на `accepted`
+  (косметика трассировки, не влияет на гейт).
+- [ ] В врезке `mark()` (`launcher._monitor_agent`, стр. ~884) делается отдельный
+  `get_task_by_repo_branch(repo, branch)` ради `stage`-контекста, хотя тот же lookup повторяется ниже в
+  хвосте финализации (стр. ~984). Дублирование на пути, и так делающем БД-работу, обёрнуто never-raise;
+  `stage` здесь — best-effort контекст для `snapshot()` (reaper резолвит стадию независимо через
+  `_task_meta`), так что корректность не зависит от него. Можно при желании переиспользовать один lookup.
+
+## Документация
+
+**Статус: полностью обновлена в том же PR (golden source соблюдён).**
+
+| Артефакт | Изменение | Оценка |
+|----------|-----------|--------|
+| `docs/architecture/README.md` | Job-reaper компонент + раздел Tier-2 + список kill-switch (`ORCH_REAPER_FINALIZER_LIVENESS_ENABLED`) + ссылки на adr-0043 | ✅ |
+| `docs/architecture/internals.md` | Детализация Tier-2 deploy-staging defer | ✅ |
+| `CHANGELOG.md` | Развёрнутая запись `[Unreleased]` с подпунктами (leaf / эмиссия / консультация / наблюдаемость) | ✅ |
+| `docs/work-items/ORCH-113/06-adr/ADR-001-…` | Детальный ADR (D1–D5, альтернативы, последствия) | ✅ |
+| `docs/architecture/adr/adr-0043-…` | Сквозной ADR (уточняет adr-0011/0040/0042/0041) | ✅ |
+| `docs/work-items/ORCH-113/{00..04,07,08,10}` | Полный пакет номерных доков | ✅ |
+
+**Обзорные доки / витрина:** правка внутренняя для job-reaper; высокоуровневые описания в
+`docs/overview/tech-architecture.md` («job-reaper возвращает в очередь job'ы, чей исполнитель умер») и
+`README.md` остаются корректными — обновления не требуют (ORCH-079/ORCH-011 не задеты). Раздел README
+«Известные ограничения» не содержит пункта, закрываемого этим PR (баг был инцидентом, не значился
+ограничением) — обновление не требуется. Известное ограничение `--workers>1` (TR-3) — системное
+пред-допущение, документировано в `10-tech-risks.md` и обоих ADR; вынос в README не обязателен.

docs/work-items/ORCH-113/13-test-report.md

@@ -0,0 +1,66 @@
+---
+result: PASS   # PASS | FAIL — машинный вердикт, UPPERCASE
+work_item: ORCH-113
+stage: testing
+author_agent: tester
+status: pass
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+type: test-report
+work_item_id: ORCH-113
+---
+
+# Test Report — ORCH-113
+
+BUG: job-reaper не должен повторно запускать финализацию `deploy-staging`, пока жив исходный finalizer.
+
+## Окружение
+- Worktree: `/repos/_wt/orchestrator/feature_ORCH-113-bug-job-reaper-must-not-re-run` (ветка `feature/ORCH-113-bug-job-reaper-must-not-re-run`)
+- Python: 3.12.13
+- pytest: 8.3.3 (plugins: cov-5.0.0, anyio-4.13.0, asyncio-0.23.8)
+- Дата: 2026-06-15
+- Review verdict (12-review.md): `APPROVED`
+
+## Smoke API (read-only)
+| Endpoint | Результат |
+|----------|-----------|
+| `GET /health` | `{"status":"ok","service":"orchestrator"}` — PASS |
+| `GET /status` | Отвечает; ORCH-113 (task 101) виден на стадии `testing` — PASS |
+| `GET /queue` | Блоки `serial_gate` (ORCH-088) **и** `auto_labels` (ORCH-089) присутствуют — PASS |
+
+## Результаты — покрытие тест-плана (04-test-plan.yaml)
+
+Все TC реализованы в `tests/test_orch113_reaper_finalizer_liveness.py` (13 тест-функций на 8 TC).
+
+| TC ID | Описание | AC / FR | Тест-функция | Результат |
+|-------|----------|---------|--------------|-----------|
+| TC-01 | Живой finalizer на `deploy-staging` (exit=0, age≥grace) → reaper НЕ вызывает `_gate_driven_advance`/`advance_stage`, логирует defer | AC-1/FR-1 | `test_tc01_live_finalizer_deploy_staging_not_reaped` | PASS |
+| TC-02 | Строгое владение: актор без владения НЕ исполняет merge-gate/re-test/advance (ноль побочных эффектов) | AC-2/FR-2 | `test_tc02_non_owner_runs_no_edge_gates` | PASS |
+| TC-03 | Мёртвый finalizer → reaper по-прежнему добивает job (Tier-2 retry + Tier-3 backstop игнорирует маркер); reaper не no-op | AC-3/FR-4 | `test_tc03_dead_finalizer_still_reaped_tier2`, `test_tc03_tier3_backstop_ignores_marker` | PASS |
+| TC-04 | Идемпотентность под гонкой: тяжёлый прогон edge-гейтов исполняется ровно один раз для `(job, stage)`, нет второго re-test/ложного rollback | AC-2/AC-4/FR-2/FR-5 | `test_tc04_idempotent_no_second_advance_under_race` | PASS |
+| TC-05 | **ОБЯЗАТЕЛЬНЫЙ регресс ORCH-111:** долгая (>grace) финализация при `staging_status=SUCCESS` → нет отката `deploy-staging → development`, нет ложного developer-retry; единственное консистентное состояние (красный до фикса, зелёный после) | AC-4/FR-5 | `test_tc05_orch111_no_false_rollback_no_retry_increment` | PASS |
+| TC-06 | Регресс-гард совместимости: kill-switch off ИЛИ не-`deploy-staging` → поведение reaper байт-в-байт прежнее | NFR-4/AC-5 | `test_tc06_killswitch_off_byte_for_byte_prior`, `test_tc06_non_deploy_staging_stage_not_consulted`, `test_tc06_within_grace_unchanged` | PASS |
+| TC-07 | Сквозной инвариант бюджета: `reaper_max_running_s (5400) > Σ(deploy-staging gate-work) + grace` (ORCH-065/109/110) | NFR-6/AC-5 | `test_tc07_budget_invariant_preserved` | PASS |
+| TC-08 | never-raise: сбой пути живости/владения деградирует безопасно — reaper-тик не падает, прочие job обрабатываются | NFR-1/NFR-3/AC-5 | `test_tc08_liveness_error_never_breaks_tick`, `test_tc08_reap_once_isolates_and_never_raises`, `test_tc08_finalizer_liveness_leaf_never_raises` | PASS |
+
+**Сопоставление с 03-acceptance-criteria.md:** AC-1…AC-6 покрыты (AC-1→TC-01, AC-2→TC-02/TC-04, AC-3→TC-03, AC-4→TC-04/TC-05, AC-5→TC-06/TC-07/TC-08, AC-6→полный зелёный прогон + TC-05 как регресс-доказательство). Каждый TC из тест-плана выполнен и сопоставлен.
+
+## Вывод pytest
+
+Целевой файл:
+```
+tests/test_orch113_reaper_finalizer_liveness.py ... 13 passed, 1 warning in 3.60s
+```
+
+Полный регресс:
+```
+$ python -m pytest tests/ -q
+........................................................................ [ 39%]
+... (snip) ...
+.........................................................                [100%]
+2001 passed, 1 warning in 316.72s (0:05:16)
+```
+(единственный warning — `PydanticDeprecatedSince20` в `src/config.py:8`, не относится к задаче, присутствует исторически)
+
+## Итог
+**PASS** — целевой файл 13/13 PASS, полный регресс `tests/` 2001 passed / 0 failed, smoke API (`/health`, `/status`, `/queue` с блоками `serial_gate` + `auto_labels`) зелёный, каждый TC тест-плана выполнен и сопоставлен с критериями приёмки. Задача переходит на `deploy-staging`.

docs/work-items/ORCH-113/14-deploy-log.md

@@ -0,0 +1,12 @@
+---
+deploy_status: SUCCESS
+work_item: ORCH-113
+hook_exit_code: 0
+deployed_by: deploy-finalizer
+---
+
+# Deploy log — ORCH-036 executable self-deploy
+
+Прод-деплой завершён хост-хуком с exit-code `0` -> `deploy_status: SUCCESS`.
+
+Вердикт зафиксирован детерминированным finalizer'ом (Фаза C), не LLM.

docs/work-items/ORCH-113/15-staging-log.md

@@ -0,0 +1,42 @@
+---
+staging_status: SUCCESS
+work_item: ORCH-113
+stage: deploy-staging
+author_agent: deployer
+status: success
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+timestamp: 2026-06-15T10:04:59Z
+base_url: http://localhost:8501
+---
+
+# Staging Gate Log
+
+Staging test suite completed against the live staging environment
+(`orchestrator-staging`, port 8501, mode=stub), run inside the container via the
+Docker Exec API (canonical `docker exec` path — host `docker` CLI unavailable;
+ADR-001/ORCH-048 invariant preserved: B6 registry-isolation reads the running
+instance's own `.env.staging` process-env).
+
+## Result
+
+```
+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
+
+## Verdict mapping (ORCH-061)
+
+- Suite exit code: **0** → `staging_status: SUCCESS`.
+- All REAL checks green (Blocks A/B SMOKE+ACCESS, C7/C8 E2E).
+- C9a/C9b are the two tolerated sandbox-infra checks (depend on SANDBOX bot
+  accounts being project members — not on the pipeline). They were waived per
+  ORCH-061; the script printed the `INFRA-WAIVED:`/`VERDICT:` lines and exited 0.
+  Exit code is trusted; waived checks are not re-judged.
+
+Staging gate passed → advance to `deploy`.

docs/work-items/ORCH-113/17-security-report.md

@@ -0,0 +1,25 @@
+---
+security_status: PASS
+secrets_found: 0
+deps_blocking: 0
+deps_warning: 4
+deps_audit_degraded: false
+---
+# Security Report — ORCH-113
+
+Детерминированный 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

docs/work-items/ORCH-113/18-coverage-report.md

@@ -0,0 +1,22 @@
+---
+coverage_status: PASS
+work_item: ORCH-113
+measured_coverage: 80.02
+baseline: 79.95
+floor: 0.00
+policy: both
+epsilon: 0.50
+delta: 0.07
+---
+# Coverage Report — ORCH-113
+
+Детерминированный гейт покрытия (ORCH-027) — под-гейт ребра `deploy-staging→deploy` (ПОСЛЕ merge-gate, ДО image-freshness). Машинный вердикт читается ТОЛЬКО из `coverage_status:` frontmatter выше.
+
+## Verdict
+measured=80.02% policy=both eps=0.50: absolute 80.02% >= floor 0.00%-eps0.50 -> PASS; baseline 80.02% >= base 79.95%-eps0.50 -> PASS
+
+## Measurement
+pytest --cov=src: line coverage src/ = 80.02%
+
+## Policy
+policy=both, floor=0.0%, baseline=79.95%, epsilon=0.5%

docs/work-items/ORCH-114/15-staging-log.md

@@ -0,0 +1,33 @@
+---
+staging_status: SUCCESS
+work_item: ORCH-114
+stage: deploy-staging
+author_agent: deployer
+status: success
+created_at: 2026-06-15
+model_used: claude-opus-4-8
+timestamp: 2026-06-15T16:25:50Z
+base_url: http://localhost:8501
+---
+
+# Staging Gate Log
+
+Staging test suite completed against the live `orchestrator-staging` instance (port 8501),
+run canonically inside the container (`docker exec orchestrator-staging python3
+/repos/orchestrator/scripts/staging_check.py --base-url http://localhost:8501 --mode stub`,
+ORCH-048/ADR-001). Exit code **0** → advance.
+
+All REAL pipeline checks passed. The only two failures are the known sandbox-infra checks
+C9a/C9b, which are waived per ORCH-061 (they depend on SANDBOX bot accounts being project
+members, not on the pipeline). The script printed the waiver and still exited 0.
+
+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
+
+## Results
+- **Block A (SMOKE)**: PASS — A1 `/health` 200 ok, A2 `/queue` 200 with counts/max_concurrency/resilience, A3 `ORCH_STAGING=true`.
+- **Block B (ACCESS)**: PASS — B4 Plane sandbox accessible (sandbox=YES), B5 Gitea orchestrator-sandbox accessible push=true, B6 registry isolation (sandbox present, prod ET/ORCH absent).
+- **Block C (E2E, mode=stub)**: C7 create Plane issue PASS, C8 trigger `/webhook/plane` PASS; C9a/C9b FAIL → **INFRA-WAIVED** (sandbox-infra). Cleanup: Plane issue deleted (HTTP 204).
+
+RESULT: 8/10 checks PASS. REAL failed: none. SANDBOX_INFRA failed (waived): C9a, C9b.
+Tolerance: `staging_infra_tolerance_enabled=True`.

scripts/orchestrator-deploy-hook.sh

@@ -220,6 +220,35 @@ else
     log "No previous image captured (first deploy or service not running?)"
 fi
 
+# 2a. ORCH-112: resilient pull — converge the shared deploy-base to a clean, current
+#     origin/main BEFORE the pull, so a dirty working tree (manual/abandoned WIP left
+#     by a failed/cancelled task) never blocks the deploy (incident ORCH-111, dirt from
+#     ORCH-104). Gated by CHECKOUT_HYGIENE (Python kill-switch + self-hosting scope,
+#     injected by self_deploy.build_deploy_command). NEVER `-x` (would delete gitignored
+#     .env / data/*.db / build/); EXCLUDES the untracked-but-not-ignored rollback/log
+#     artefacts .deploy-prev-image-* and deploy-hook.log (NFR-2). Best-effort: every git
+#     step is `|| log "...continuing"` and the bare `git pull` below still runs
+#     (never-break). On a CLEAN base the whole block is a no-op -> the happy-path
+#     behaviour and exit-codes (0/1/2, ORCH-036) are byte-for-byte unchanged.
+if [[ "${CHECKOUT_HYGIENE:-0}" == "1" ]]; then
+    dirty="$(git status --porcelain 2>/dev/null || true)"
+    if [[ -n "$dirty" ]]; then
+        log "HYGIENE: dirty deploy-base detected, converging to origin/main:"
+        log "$dirty"
+        git fetch origin main        >> "$LOG" 2>&1 || log "HYGIENE: fetch failed (continuing)"
+        git reset --hard origin/main >> "$LOG" 2>&1 || log "HYGIENE: reset failed (continuing)"
+        git clean -fd \
+            -e '.deploy-prev-image-*' \
+            -e 'deploy-hook.log' \
+            >> "$LOG" 2>&1 || log "HYGIENE: clean failed (continuing)"
+        if [[ -n "${HYGIENE_REPORT:-}" ]]; then
+            { printf 'dirty=1\n'; printf '%s\n' "$dirty"; } > "$HYGIENE_REPORT" 2>/dev/null || true
+        fi
+    else
+        log "HYGIENE: deploy-base already clean (no-op)"
+    fi
+fi
+
 # 2. Pull latest code (keeps the host working tree current for future builds;
 #    the DEPLOYED artefact is the retagged SOURCE_IMAGE below when build-once).
 log "git pull origin main"

src/agents/launcher.py

@@ -868,6 +868,55 @@ class AgentLauncher:
         _task_id = _row[0] if _row else None
         conn.close()
 
+        # ORCH-113 (adr-0043 / D2): register finalizer ownership at the EARLIEST
+        # moment the reaper can enter Tier-2 — exit_code is now stamped, so the agent
+        # pid is dead and Tier-1 no longer protects this row. On the
+        # deploy-staging -> deploy edge the rest of the finalization (git push, the
+        # heavy edge sub-gates via _try_advance_stage, _finalize_job) runs IN THIS
+        # THREAD for MINUTES; without ownership the reaper would treat the live
+        # finalizer as dead and re-run the advance (false rollback, incident
+        # ORCH-111). The marker is written unconditionally (kill-switch only gates the
+        # reaper's CONSULTATION, so the disabled path is byte-for-byte prior). Only
+        # queue-launched jobs (job_id is not None) are in get_running_jobs / reapable.
+        if job_id is not None:
+            try:
+                from .. import finalizer_liveness
+                _t_mark = get_task_by_repo_branch(repo, branch)
+                finalizer_liveness.mark(
+                    job_id, run_id, _t_mark["stage"] if _t_mark else None
+                )
+            except Exception:  # noqa: BLE001 - never-raise: marker is best-effort
+                pass
+
+        # The finalization tail runs under try/finally so ownership is ALWAYS
+        # released — including on ANY exception in this thread, which lets the reaper
+        # finish a genuinely dead finalizer (FR-4).
+        try:
+            self._run_monitor_finalization(
+                run_id, agent, repo, branch, exit_code, output_path,
+                job_id, _task_id, _duration_s,
+            )
+        finally:
+            if job_id is not None:
+                try:
+                    from .. import finalizer_liveness
+                    finalizer_liveness.clear(job_id)
+                except Exception:  # noqa: BLE001 - never-raise
+                    pass
+
+    def _run_monitor_finalization(
+        self, run_id, agent, repo, branch, exit_code, output_path,
+        job_id, _task_id, _duration_s,
+    ):
+        """ORCH-113 (adr-0043): finalization tail of ``_monitor_agent``.
+
+        Extracted VERBATIM from ``_monitor_agent`` (no logic change — verify with
+        ``git diff -w``) so the caller can wrap it in a single ``try/finally`` that
+        releases the finalizer-ownership marker (``finalizer_liveness.clear``) on any
+        outcome. Runs in the monitor thread: notify, usage accounting, git
+        commit/push (+PR), failure handling, usage comments, the gate-driven
+        ``_try_advance_stage`` and finally ``_finalize_job`` for queue-launched jobs.
+        """
         notify_agent_finished(run_id, agent, exit_code, task_id=_task_id, duration_s=_duration_s)
 
         # Feature 4: parse token usage / cost from the (json) run log and record

src/checkout_hygiene.py

@@ -0,0 +1,214 @@
+"""ORCH-112 (ADR-001 / adr-0044): deploy-base checkout-hygiene leaf — pure policy.
+
+Leaf module mirroring ``src/serial_gate.py`` / ``src/cancel.py`` / ``src/self_deploy.py``:
+pure, unit-testable, never-raise functions over ``config`` + the deploy-state sentinels.
+Module-level imports are limited to ``config`` (and stdlib); ``self_deploy``,
+``qg.checks.is_self_hosting_repo`` and ``notifications`` are imported LAZILY so this
+stays a leaf and an import cycle can never form.
+
+What it answers / does (the MECHANISM — git fetch/reset/clean — lives in the host
+deploy hook ``scripts/orchestrator-deploy-hook.sh`` block "2a. Resilient pull"; this
+leaf only decides conditionality, builds the env gate, reads the report and alerts):
+
+  * ``applies(repo)``                          — is resilient-pull hygiene REAL here?
+  * ``hook_env(repo, work_item_id)``           — the ``CHECKOUT_HYGIENE=1 HYGIENE_REPORT=…``
+                                                 env prefix injected into the detached
+                                                 deploy-hook command ("" when not applies).
+  * ``read_report(repo, work_item_id)``        — read the ``hygiene`` sentinel the hook wrote.
+  * ``alert_dirty(repo, work_item_id, report)``— best-effort Telegram + structured log.
+  * ``snapshot()``                             — read-only block for ``GET /queue``.
+
+never-raise contract (self-hosting safety): every public function degrades
+conservatively. ``applies`` -> False on error (hygiene inert == kill-switch off, the
+safe default that keeps the bare ``git pull`` 1:1 as before ORCH-112). ``hook_env`` ->
+"" on error (no env -> the hook's ``${CHECKOUT_HYGIENE:-0}`` guard stays 0). The report
+reader / alert swallow every error so a deploy is NEVER crashed by an observability
+hiccup (D5 / AC-8).
+"""
+from __future__ import annotations
+
+import logging
+import os
+import re
+import shlex
+
+from .config import settings
+
+logger = logging.getLogger("orchestrator.checkout_hygiene")
+
+# Sentinel filename the hook writes (HYGIENE_REPORT points at it) and read_report
+# reads back. Lives in the SAME deploy-state dir as self_deploy's ``result`` (shared
+# mount visible to both host and container).
+REPORT_NAME = "hygiene"
+
+# Repo tokens in the CSV scope must match this (mirrors serial_gate._REPO_TOKEN). The
+# CSV is operator config, not user input, but the guard is mandatory; an invalid token
+# is dropped.
+_REPO_TOKEN = re.compile(r"^[A-Za-z0-9._-]+$")
+
+
+# ---------------------------------------------------------------------------
+# Conditionality (mirrors self_deploy_applies / serial_gate_applies)
+# ---------------------------------------------------------------------------
+def _scope_repos() -> set[str]:
+    """Sanitised set of in-scope repo tokens from ``checkout_hygiene_repos`` (CSV).
+
+    Empty/blank CSV -> empty set, meaning "self-hosting only" (resolved in ``applies``).
+    Invalid tokens (regex miss) are dropped. Never raises.
+    """
+    try:
+        raw = (settings.checkout_hygiene_repos or "").strip()
+    except Exception:  # noqa: BLE001
+        return set()
+    if not raw:
+        return set()
+    out: set[str] = set()
+    for tok in raw.split(","):
+        t = tok.strip()
+        if t and _REPO_TOKEN.match(t):
+            out.add(t)
+        elif t:
+            logger.warning("checkout_hygiene: dropping invalid repo token %r from CSV", t)
+    return out
+
+
+def applies(repo: str) -> bool:
+    """Whether resilient-pull hygiene is REAL for this repo (D3 / AC-6).
+
+      * ``checkout_hygiene_enabled=False`` -> always False (kill-switch; the hook sees
+        no CHECKOUT_HYGIENE env -> bare ``git pull origin main`` 1:1 as before ORCH-112).
+      * ``checkout_hygiene_repos`` (CSV) non-empty -> real only for listed repos.
+      * empty CSV -> real ONLY for the self-hosting repo (``orchestrator``), mirroring
+        ``self_deploy_repos`` — this is a self-hosting prod-deploy-path feature, so it
+        must NOT touch enduro / other repos' synchronous deploy.
+    Local-only (no network), meant to be checked FIRST. Never raises -> False on error.
+    """
+    try:
+        if not getattr(settings, "checkout_hygiene_enabled", False):
+            return False
+        scope = _scope_repos()
+        if scope:
+            return (repo or "").strip() in scope
+        # Lazy import keeps this module a leaf (no qg import at module load).
+        from .qg.checks import is_self_hosting_repo
+        return is_self_hosting_repo(repo)
+    except Exception as e:  # noqa: BLE001 - never-raise
+        logger.warning("checkout_hygiene.applies error for %s: %s", repo, e)
+        return False
+
+
+# ---------------------------------------------------------------------------
+# Env gate injected into the detached deploy-hook command (Phase B wiring)
+# ---------------------------------------------------------------------------
+def report_path_host(repo: str, work_item_id: str | None) -> str:
+    """HOST view of the ``hygiene`` sentinel path (the wrapper writes it there)."""
+    from . import self_deploy
+    return os.path.join(self_deploy.host_state_dir(repo, work_item_id), REPORT_NAME)
+
+
+def hook_env(repo: str, work_item_id: str | None) -> str:
+    """Build the env-assignment prefix injected into the detached deploy-hook command.
+
+    Returns ``CHECKOUT_HYGIENE=1 HYGIENE_REPORT=<host-path>`` (shlex-quoted) ONLY when
+    ``applies(repo)`` is True; otherwise ``""`` so the hook's ``${CHECKOUT_HYGIENE:-0}``
+    guard stays 0 and the bare ``git pull`` runs (1:1 before ORCH-112). The
+    ``HYGIENE_REPORT`` path is the HOST view of the deploy-state dir (the host wrapper
+    writes the sentinel there; the container reads it back via ``read_report``). Never
+    raises -> "" (no hygiene env, the safe default).
+    """
+    try:
+        if not applies(repo):
+            return ""
+        report = report_path_host(repo, work_item_id)
+        return f"CHECKOUT_HYGIENE=1 HYGIENE_REPORT={shlex.quote(report)}"
+    except Exception as e:  # noqa: BLE001 - never-raise -> no hygiene env
+        logger.warning("checkout_hygiene.hook_env error for %s/%s: %s", repo, work_item_id, e)
+        return ""
+
+
+# ---------------------------------------------------------------------------
+# Report sentinel reader (Phase C observability)
+# ---------------------------------------------------------------------------
+def read_report(repo: str, work_item_id: str | None) -> dict | None:
+    """Read the ``hygiene`` sentinel the hook wrote (container view of deploy-state).
+
+    The hook writes the sentinel ONLY when it detected a dirty base, body::
+
+        dirty=1
+        <git status --porcelain lines...>
+
+    Returns ``{"dirty": True, "paths": [...]}`` when the sentinel exists and reports a
+    dirty base; ``None`` when there is no sentinel (clean base / hygiene disabled / not
+    written yet). Never raises -> None on error.
+    """
+    try:
+        from . import self_deploy
+        p = os.path.join(self_deploy.container_state_dir(repo, work_item_id), REPORT_NAME)
+        with open(p, "r", encoding="utf-8") as f:
+            raw = f.read()
+    except FileNotFoundError:
+        return None
+    except Exception as e:  # noqa: BLE001 - never-raise
+        logger.warning("checkout_hygiene.read_report error for %s/%s: %s", repo, work_item_id, e)
+        return None
+    lines = raw.splitlines()
+    if not any(ln.strip() == "dirty=1" for ln in lines):
+        return None
+    paths = [
+        ln.strip() for ln in lines
+        if ln.strip() and not ln.strip().startswith("dirty=")
+    ]
+    return {"dirty": True, "paths": paths}
+
+
+# ---------------------------------------------------------------------------
+# Best-effort Telegram alert (Phase C observability) — D5 / AC-8
+# ---------------------------------------------------------------------------
+def alert_dirty(repo: str, work_item_id: str | None, report: dict | None) -> bool:
+    """Structured log + best-effort Telegram that the deploy-base was dirty and was
+    converged to ``origin/main`` before the pull (D5 / AC-8). Returns True iff an alert
+    was sent. Its failure NEVER crashes the finalizer (never-raise) — observability is
+    best-effort and must not block the conveyor (AC-8 FAIL is "alert crashes deploy").
+    """
+    try:
+        if not report or not report.get("dirty"):
+            return False
+        paths = report.get("paths") or []
+        n = len(paths)
+        logger.warning(
+            "checkout_hygiene: dirty deploy-base converged to origin/main for %s/%s "
+            "(%d path(s)): %s", repo, work_item_id, n, paths[:20],
+        )
+        from .notifications import link_for, send_telegram
+        send_telegram(
+            f"\U0001f9f9 {link_for(work_item_id)}: грязная deploy-база сведена к "
+            f"origin/main перед прод-деплоем ({n} путь(ей) сброшено)."
+        )
+        return True
+    except Exception as e:  # noqa: BLE001 - never-raise: alert is best-effort
+        logger.warning("checkout_hygiene.alert_dirty error for %s/%s: %s", repo, work_item_id, e)
+        return False
+
+
+# ---------------------------------------------------------------------------
+# Observability snapshot for GET /queue (D3, optional)
+# ---------------------------------------------------------------------------
+def snapshot() -> dict:
+    """Read-only checkout-hygiene summary for GET /queue.
+
+    Additive block; existing /queue keys are untouched. never-raise -> a minimal dict
+    with the flags on error.
+    """
+    try:
+        enabled = bool(getattr(settings, "checkout_hygiene_enabled", False))
+    except Exception:  # noqa: BLE001
+        enabled = False
+    try:
+        repos_cfg = getattr(settings, "checkout_hygiene_repos", "") or ""
+    except Exception:  # noqa: BLE001
+        repos_cfg = ""
+    return {
+        "enabled": enabled,
+        "repos": repos_cfg,
+        "scope": "csv" if (repos_cfg or "").strip() else "self-hosting-only",
+    }

src/config.py

@@ -202,18 +202,50 @@ class Settings(BaseSettings):
     #                             only the self-hosting repo (orchestrator). Other
     #                             repos -> conditional no-op (mirrors ORCH-35 staging).
     #   merge_retest_timeout_s -> wall-clock budget for the post-rebase re-test.
+    #       ORCH-110 (D5): raised 600 -> 900 (74% headroom over the observed 516.7s
+    #       suite vs the prior ~16%). Cross-invariant (ORCH-065/109): keep
+    #       reaper_max_running_s (5400) > Σ(deploy-staging gate-work) + grace — see
+    #       docs/work-items/ORCH-110/07-infra-requirements.md.
     #   merge_retest_target    -> pytest target for the re-test (portability across repos).
     #   merge_lock_timeout_s   -> max lease age; an older lease is reclaimed (crash backstop).
     #   merge_defer_delay_s    -> delay before re-running the gate when the lock is busy.
     #   merge_defer_max_attempts -> defer retries before escalation (avoids livelock).
     merge_gate_enabled: bool = True
     merge_gate_repos: str = ""
-    merge_retest_timeout_s: int = 600
+    merge_retest_timeout_s: int = 900
     merge_retest_target: str = "tests/"
     merge_lock_timeout_s: int = 300
     merge_defer_delay_s: int = 60
     merge_defer_max_attempts: int = 5
 
+    # ORCH-110: merge-gate re-test infra-timeout tolerance + tree-kill of the
+    # orchestrator-spawned pytest subprocess (re-test + coverage). Each default =
+    # the desired prod behaviour (ORCH-101 canon); each flag is an INDEPENDENT
+    # kill-switch (off -> byte-for-byte pre-ORCH-110). Detailed ADR:
+    # docs/work-items/ORCH-110/06-adr/ADR-001-merge-gate-retest-infra-tolerance-and-tree-kill.md.
+    #   subprocess_tree_kill_enabled           -> D1: spawn the re-test / coverage
+    #       pytest in its own process group and tree-kill the WHOLE group on timeout
+    #       (no orphan grandchildren grinding the host CPU). off -> the prior
+    #       subprocess.run(timeout=) (ORCH_SUBPROCESS_TREE_KILL_ENABLED).
+    #   merge_retest_infra_tolerance_enabled   -> D3: a re-test TIMEOUT is a transient
+    #       (bounded infra-retry, NOT a code-fault rollback to development burning a
+    #       developer retry). off -> timeout = the prior rollback
+    #       (ORCH_MERGE_RETEST_INFRA_TOLERANCE_ENABLED).
+    #   merge_retest_infra_max_retries         -> D3: infra-retry budget before an
+    #       infra-alert (anti-loop). (ORCH_MERGE_RETEST_INFRA_MAX_RETRIES)
+    #   merge_retest_infra_retry_delay_s       -> D3: delay before the staging-deployer
+    #       re-run. (ORCH_MERGE_RETEST_INFRA_RETRY_DELAY_S)
+    #   merge_retest_skip_when_current_enabled -> D4: skip the local re-test when the
+    #       pre-merge rebase was a PROVEN no-op (branch already at origin/main; HEAD is
+    #       exactly the CI/tester/staging-validated commit). off -> always re-test
+    #       after rebase (ORCH_MERGE_RETEST_SKIP_WHEN_CURRENT_ENABLED).
+    # The tree-kill grace reuses the existing agent_kill_grace_seconds (no new key).
+    subprocess_tree_kill_enabled: bool = True
+    merge_retest_infra_tolerance_enabled: bool = True
+    merge_retest_infra_max_retries: int = 2
+    merge_retest_infra_retry_delay_s: int = 120
+    merge_retest_skip_when_current_enabled: bool = True
+
     # ORCH-036: executable self-deploy (deploy stage drives the host hook).
     # The `deploy` stage for the self-hosting repo is turned into a REAL prod
     # restart via a detached host process, gated by a manual approve. Three-phase
@@ -258,6 +290,25 @@ class Settings(BaseSettings):
     deploy_prod_compose_profile: str = ""
     deploy_prod_prev_image_file: str = ".deploy-prev-image-prod"
 
+    # ORCH-112: deploy-base checkout-hygiene (resilient-pull). The self-deploy hook's
+    # bare `git pull origin main` in the shared main clone blocked on a dirty working
+    # tree (manual/abandoned WIP left by a failed/cancelled task — incident ORCH-111
+    # from ORCH-104). The fix converges the deploy-base to a clean, current origin/main
+    # (git fetch + reset --hard + a SCOPED `git clean -fd`, NEVER `-x`) BEFORE the pull,
+    # gated by the CHECKOUT_HYGIENE env injected by self_deploy.build_deploy_command.
+    # Pure leaf: src/checkout_hygiene.py (never-raise). Not a Quality Gate / not a stage
+    # — STAGE_TRANSITIONS / QG_CHECKS / check_* / machine-verdict / DB schema / the
+    # hook's exit-code contract (0/1/2, ORCH-036) are byte-for-byte untouched.
+    #
+    #   checkout_hygiene_enabled -> kill-switch (env ORCH_CHECKOUT_HYGIENE_ENABLED).
+    #                               False -> the hook gets no CHECKOUT_HYGIENE env ->
+    #                               bare `git pull origin main` 1:1 as before ORCH-112.
+    #   checkout_hygiene_repos   -> CSV scope (env ORCH_CHECKOUT_HYGIENE_REPOS). Empty
+    #                               -> only the self-hosting repo (orchestrator). Mirrors
+    #                               self_deploy_repos (a self-hosting prod-deploy feature).
+    checkout_hygiene_enabled: bool = True
+    checkout_hygiene_repos: str = ""
+
     # ORCH-058: staging-image provenance before the BUILD-ONCE retag to prod.
     # Closes the INV-FRESH gap (ADR-001): the BUILD-ONCE retag (ORCH-36) promotes
     # the staging image to prod WITHOUT a rebuild, assuming the staging image is
@@ -512,12 +563,32 @@ class Settings(BaseSettings):
     #   lease_reclaim_enabled -> kill-switch for the proactive stale/dead lease reclaim
     #                           (false -> only the legacy lazy TTL reclaim in acquire).
     # (reuse) merge_lock_timeout_s -> lease TTL; merge_gate_repos -> reclaim scope.
+    #   reaper_finalizer_liveness_enabled -> ORCH-113 (adr-0043): consult the
+    #                           process-local finalizer-ownership registry
+    #                           (src/finalizer_liveness.py) in the Tier-2 branch. On the
+    #                           deploy-staging -> deploy edge the monitor runs the heavy
+    #                           edge sub-gates (security/merge-gate re-test/coverage/
+    #                           image-freshness) in-thread AFTER the finished_at stamp and
+    #                           BEFORE _finalize_job — MINUTES — which finished_age_s grace
+    #                           does NOT cover, so a live long finalizer was wrongly reaped
+    #                           and re-ran the advance (false rollback, incident ORCH-111).
+    #                           When true AND the task stage == 'deploy-staging' AND a live
+    #                           monitor owns the finalization, the reaper DEFERS (no second
+    #                           advance) and falls through to the Tier-3 backstop (which
+    #                           ignores the marker -> a stuck/dead finalizer is still reaped
+    #                           in bounded time). false -> reaper byte-for-byte as before
+    #                           (the marker is still written by the monitor but never
+    #                           consulted -> inert). Global only, NO per-repo split (the bug
+    #                           is common to every repo with a deploy-staging stage). Does
+    #                           NOT touch grace/ceiling -> the cross-cutting budget
+    #                           reaper_max_running_s > Σ(gate-work) + grace stays intact.
     reaper_enabled: bool = True
     reaper_interval_s: int = 60
     reaper_dead_ticks: int = 2
     reaper_max_running_s: int = 5400
     reaper_finalize_grace_s: int = 300
     lease_reclaim_enabled: bool = True
+    reaper_finalizer_liveness_enabled: bool = True
 
     # ORCH-063: disk-watchdog — background heartbeat that measures host-FS fill via
     # the mounted bind-paths and Telegram-alerts the operator at >= threshold. On

src/coverage_gate.py

@@ -44,7 +44,8 @@ Invariants (ADR-001 §7, never broken):
     artefact / decides. It never calls the deploy hook, never restarts the prod
     container, never pushes / force-pushes ``main``.
 
-This module is a **leaf**: it imports only ``config`` / ``git_worktree`` and lazily
+This module is a **leaf**: it imports only ``config`` / ``git_worktree`` /
+``proc_group`` (the ORCH-110 stdlib-only process-group runner) and lazily
 ``qg.checks.is_self_hosting_repo`` / ``db`` / ``notifications``; it never imports
 ``stage_engine``.
 """
@@ -52,11 +53,11 @@ This module is a **leaf**: it imports only ``config`` / ``git_worktree`` and laz
 import json
 import logging
 import os
-import subprocess
 import sys
 
 from .config import settings
 from .git_worktree import ensure_worktree, get_worktree_path
+from .proc_group import run_in_process_group  # ORCH-110 D1: tree-kill on timeout
 
 logger = logging.getLogger("orchestrator.coverage_gate")
 
@@ -152,22 +153,25 @@ def measure_coverage(repo: str, branch: str) -> float | None:
         "-q",
     ]
     timeout = settings.coverage_run_timeout_s
-    try:
-        subprocess.run(cmd, cwd=wt, capture_output=True, text=True, timeout=timeout)
-    except subprocess.TimeoutExpired:
+    # ORCH-110 (D1 / FR-2 / BR-3): run the coverage suite in its OWN process group so
+    # a timeout tree-kills the WHOLE subtree (the sibling orphan-leak source of the
+    # ORCH-109 incident), not just the direct child. The metric is read from the JSON
+    # file regardless of the exit code, so a non-timeout spawn/OS error (returncode
+    # None) just falls through to "no coverage json produced" -> None, byte-for-byte
+    # the prior fail-open contract.
+    res = run_in_process_group(
+        cmd,
+        cwd=wt,
+        timeout=timeout,
+        tree_kill=bool(getattr(settings, "subprocess_tree_kill_enabled", True)),
+        grace_s=settings.agent_kill_grace_seconds,
+    )
+    if res.timed_out:
         logger.warning(
             "measure_coverage: pytest --cov timed out after %ss for %s/%s",
             timeout, repo, branch,
         )
         return None
-    except FileNotFoundError:
-        logger.warning(
-            "measure_coverage: pytest / pytest-cov not available for %s/%s", repo, branch
-        )
-        return None
-    except (subprocess.SubprocessError, OSError) as e:
-        logger.warning("measure_coverage: pytest --cov error for %s/%s: %s", repo, branch, e)
-        return None
 
     data = None
     try:

src/finalizer_liveness.py

@@ -0,0 +1,120 @@
+"""ORCH-113 (adr-0043): process-local finalizer-ownership registry.
+
+Leaf module — pure, process-local, never-raise (pattern of ``serial_gate`` /
+``coverage_gate``: imports nothing from ``stage_engine`` / ``launcher`` / the DB,
+talks to no network). It records "a LIVE monitor thread is currently finalizing
+job X" so the job-reaper can tell a long-running-but-alive finalizer apart from a
+genuinely dead one.
+
+Why in-memory is authoritative (ADR-001 / adr-0043): the monitor
+(``launcher._monitor_agent``) and the reaper (``job_reaper``) are daemon THREADS
+of the SAME single uvicorn process (CMD has no ``--workers``), sharing one SQLite
+DB. So liveness of the finalizing thread can be observed in-process. A whole-process
+death is covered by the startup ``requeue_running_jobs()`` (``running -> queued``),
+which ``main.lifespan`` runs BEFORE the reaper starts — so a restart leaves this
+registry empty and the requeued jobs are re-driven cleanly (restart-safe, no durable
+state needed).
+
+The bug this closes (incident ORCH-111, deployer job 1914): on the
+``deploy-staging -> deploy`` edge the monitor stamps ``agent_runs.finished_at``
+FIRST, then runs the heavy edge sub-gates (security -> merge-gate re-test ->
+coverage -> image-freshness) synchronously in its own thread — MINUTES — and only
+THEN ``_finalize_job``. Reaper Tier-2 measures ``finished_age_s`` from
+``finished_at`` (= the START of finalization), so once it exceeds
+``reaper_finalize_grace_s`` (300s) it treated the live, long-finalizing monitor as
+dead and independently re-ran the same heavy advance -> a second re-test went red ->
+false rollback ``deploy-staging -> development`` while the original finalizer
+concurrently merged the PR. State diverged.
+
+No own TTL: time-bounding is the reaper's Tier-3 backstop (``reaper_max_running_s``),
+which deliberately IGNORES this marker so a truly stuck finalizer is still reaped in
+bounded time. Every public function is isolated (``try/except`` -> safe default);
+``is_active`` defaults to ``False`` on error (conservative: never block the reaping
+of a possibly-dead finalizer).
+
+See docs/work-items/ORCH-113/06-adr/ADR-001-reaper-finalizer-liveness-ownership.md
+and the cross-cutting docs/architecture/adr/adr-0043-reaper-finalizer-liveness-ownership.md.
+"""
+from __future__ import annotations
+
+import logging
+import threading
+import time
+
+logger = logging.getLogger("orchestrator.finalizer_liveness")
+
+# Process-local ownership registry: {job_id: {"run_id", "stage", "started_ts"}}.
+# Guarded by a Lock because the monitor thread writes (mark/clear) while the reaper
+# thread reads (is_active/snapshot). All state resets on process restart, which is
+# safe (the startup requeue_running_jobs covers the restart path).
+_LOCK = threading.Lock()
+_OWNED: dict[int, dict] = {}
+
+
+def mark(job_id: int | None, run_id: int | None, stage: str | None) -> None:
+    """Register that a live monitor thread is finalizing ``job_id``.
+
+    Called by ``launcher._monitor_agent`` right after the ``exit_code`` stamp (the
+    earliest moment the reaper can enter Tier-2). ``stage`` is best-effort context
+    for the snapshot only — the reaper decides the actual stage from ``tasks`` via
+    its own ``_task_meta`` lookup. No-op when ``job_id is None`` (legacy direct
+    ``launch()`` jobs are not in ``get_running_jobs`` and are unreapable). Never
+    raises.
+    """
+    if job_id is None:
+        return
+    try:
+        with _LOCK:
+            _OWNED[job_id] = {
+                "run_id": run_id,
+                "stage": stage,
+                "started_ts": time.time(),
+            }
+    except Exception as e:  # noqa: BLE001 - never-raise contract
+        logger.warning("finalizer_liveness.mark failed for job %s: %s", job_id, e)
+
+
+def clear(job_id: int | None) -> None:
+    """Release ownership of ``job_id`` (idempotent).
+
+    Called from the ``finally`` of the monitor's finalization tail, so ANY exception
+    in the monitor thread still releases ownership -> a genuinely dead finalizer is
+    reaped (FR-4). Never raises.
+    """
+    if job_id is None:
+        return
+    try:
+        with _LOCK:
+            _OWNED.pop(job_id, None)
+    except Exception as e:  # noqa: BLE001 - never-raise contract
+        logger.warning("finalizer_liveness.clear failed for job %s: %s", job_id, e)
+
+
+def is_active(job_id: int | None) -> bool:
+    """True iff a live monitor currently owns the finalization of ``job_id``.
+
+    Consulted by the reaper Tier-2 branch. Defaults to ``False`` on any error or
+    when ``job_id is None`` (conservative: never block the reaping of a possibly
+    dead finalizer). Never raises.
+    """
+    if job_id is None:
+        return False
+    try:
+        with _LOCK:
+            return job_id in _OWNED
+    except Exception as e:  # noqa: BLE001 - never-raise contract
+        logger.warning("finalizer_liveness.is_active failed for job %s: %s", job_id, e)
+        return False
+
+
+def snapshot() -> dict:
+    """Read-only view of current ownership for ``GET /queue`` observability.
+
+    Returns ``{"active": <count>, "jobs": [job_id, ...]}``. Never raises.
+    """
+    try:
+        with _LOCK:
+            return {"active": len(_OWNED), "jobs": sorted(_OWNED.keys())}
+    except Exception as e:  # noqa: BLE001 - never-raise contract
+        logger.warning("finalizer_liveness.snapshot failed: %s", e)
+        return {"active": 0, "jobs": []}

src/job_reaper.py

@@ -38,7 +38,15 @@ Liveness (defense in depth, ADR-001 Р-1):
     reaper therefore treats it as a dead monitor (KNOWN outcome) only after a
     finalization grace: ``exit_code`` recorded for >= ``reaper_finalize_grace_s``
     (a live finalizing monitor is NEVER reaped, FR-1.3/AC-3). Within the grace the
-    row is left untouched.
+    row is left untouched. **ORCH-113 (adr-0043):** on the ``deploy-staging ->
+    deploy`` edge the in-thread finalization runs the heavy edge sub-gates
+    (security/merge-gate re-test/coverage/image-freshness) for MINUTES AFTER the
+    ``finished_at`` stamp, so even past the grace the monitor may be alive. Tier-2
+    now consults a process-local ownership marker (``finalizer_liveness``): a job
+    on ``deploy-staging`` still owned by a live finalizer is DEFERRED (not reaped via
+    Tier-2 — re-running the advance caused the false rollback in incident ORCH-111)
+    and falls through to the Tier-3 backstop, which IGNORES the marker. Kill-switch
+    ``reaper_finalizer_liveness_enabled``.
   * **Tier-3 (backstop): age ceiling.** A job ``running`` longer than
     ``reaper_max_running_s`` (deliberately > max ``agent_timeout`` + grace) is
     reaped even when liveness cannot be determined (pid reused / unknown).
@@ -142,6 +150,10 @@ class JobReaper:
         self.reaped_total: int = 0
         self.last_reaped: dict | None = None
         self.lease_reclaimed_total: int = 0
+        # ORCH-113 (adr-0043 / D5): count of Tier-2 reaps deferred because a live
+        # monitor still owns a deploy-staging finalization. Reset on restart (safe:
+        # startup requeue_running_jobs covers the restart path).
+        self.finalizer_defers_total: int = 0
 
     # -- A: zombie-job reaping --------------------------------------------
     def reap_once(self) -> None:
@@ -199,13 +211,34 @@ class JobReaper:
             finished_age = job.get("finished_age_s")
             grace = int(settings.reaper_finalize_grace_s)
             if finished_age is not None and int(finished_age) >= grace:
-                self._reap_known_outcome(job, int(exit_code))
-                return
-            logger.info(
-                "reaper: job %s exit_code=%s recorded %ss ago (< grace %ss) — "
-                "deferring (monitor may still be finalizing)",
-                job_id, exit_code, finished_age, grace,
-            )
+                # ORCH-113 (adr-0043 / D3): even past the grace, a LIVE monitor may
+                # still be running the minutes-long deploy-staging edge sub-gates
+                # in-thread — finished_age is measured from the START of finalization
+                # (the finished_at stamp), and on deploy-staging the heavy advance
+                # (security/merge-gate re-test/coverage/image-freshness) runs AFTER
+                # that stamp and BEFORE _finalize_job. If a live finalizer still owns
+                # this job, DEFER the Tier-2 reap (re-running the advance caused the
+                # false rollback in incident ORCH-111) and fall through to the Tier-3
+                # backstop, which IGNORES the marker so a stuck/dead finalizer is
+                # still reaped in bounded time.
+                if self._finalizer_owns(job):
+                    self.finalizer_defers_total += 1
+                    logger.info(
+                        "reaper: job %s (deploy-staging) still owned by a live "
+                        "finalizer %ss past grace — deferring Tier-2 (Tier-3 backstop "
+                        "at %ss still applies)",
+                        job_id, finished_age, settings.reaper_max_running_s,
+                    )
+                    # fall through to the Tier-3 backstop guard below.
+                else:
+                    self._reap_known_outcome(job, int(exit_code))
+                    return
+            else:
+                logger.info(
+                    "reaper: job %s exit_code=%s recorded %ss ago (< grace %ss) — "
+                    "deferring (monitor may still be finalizing)",
+                    job_id, exit_code, finished_age, grace,
+                )
             # fall through to the Tier-3 backstop guard below.
         else:
             # Tier-1: dead pid, only after `reaper_dead_ticks` consecutive dead ticks.
@@ -400,6 +433,33 @@ class JobReaper:
                            job.get("id"), e)
             return None, None, None
 
+    def _finalizer_owns(self, job: dict) -> bool:
+        """ORCH-113 (adr-0043 / D3): True iff a LIVE monitor still owns this job's
+        ``deploy-staging`` finalization, so the Tier-2 reap must be deferred.
+
+        Order matters for the zero-regression contract: the kill-switch is checked
+        FIRST (disabled -> ``False`` with no DB lookup, so the path is byte-for-byte
+        prior); then the stage is scoped to ``deploy-staging`` only (the sole edge
+        whose in-thread finalization runs for minutes — every other stage is left
+        untouched); only then is the process-local ownership marker consulted. Never
+        raises -> ``False`` on any error (conservative: never block reaping when
+        ownership is unknowable, so the Tier-3 backstop is never neutered).
+        """
+        try:
+            if not settings.reaper_finalizer_liveness_enabled:
+                return False
+            _branch, stage, _wid = self._task_meta(job)
+            if stage != "deploy-staging":
+                return False
+            from . import finalizer_liveness
+            return finalizer_liveness.is_active(job.get("id"))
+        except Exception as e:  # noqa: BLE001 - never break the reap tick
+            logger.warning(
+                "reaper: finalizer-liveness check failed for job %s: %s",
+                job.get("id"), e,
+            )
+            return False
+
     def _notify_failed(self, job: dict, reason: str) -> None:
         try:
             from .notifications import send_telegram
@@ -463,6 +523,14 @@ class JobReaper:
 
     def status(self) -> dict:
         """Reaper snapshot for /queue observability (Р-6)."""
+        # ORCH-113 (adr-0043 / D5): expose the defer counter + the current finalizer
+        # ownership set (read-only, never-raise). Additive keys only — existing keys
+        # are unchanged.
+        try:
+            from . import finalizer_liveness
+            _owned = finalizer_liveness.snapshot()
+        except Exception:  # noqa: BLE001 - observability must never break /queue
+            _owned = {"active": 0, "jobs": []}
         return {
             "enabled": settings.reaper_enabled,
             "interval": self.interval_s,
@@ -470,6 +538,9 @@ class JobReaper:
             "reaped_total": self.reaped_total,
             "last_reaped": self.last_reaped,
             "lease_reclaimed_total": self.lease_reclaimed_total,
+            "finalizer_liveness_enabled": settings.reaper_finalizer_liveness_enabled,
+            "finalizer_defers_total": self.finalizer_defers_total,
+            "finalizer_owned": _owned,
         }
 
 

src/main.py

@@ -214,6 +214,7 @@ async def queue():
     from . import cancel
     from . import bug_fast_track
     from . import lessons
+    from . import checkout_hygiene
     from .disk_watchdog import disk_watchdog
     from .build_cache_pruner import build_cache_pruner
     return {
@@ -225,6 +226,11 @@ async def queue():
         "reaper": reaper.status(),
         "post_deploy": post_deploy.status(),
         "merge_verify": merge_gate.merge_verify_status(),
+        # ORCH-110 (D6): merge-gate re-test infra-timeout observability (read-only) —
+        # tolerance/skip/tree-kill flags + timeout/infra-retry/skip counters, so an
+        # infra-timeout is distinguishable from a code-fault rollback. Additive block;
+        # never-raise.
+        "merge_gate": merge_gate.merge_gate_status(),
         # ORCH-026 (G-2): declarative task-dependency observability (read-only,
         # NOT a source of truth) — declared edges, blocked tasks, detected cycle.
         "task_deps": task_deps.snapshot(),
@@ -249,6 +255,9 @@ async def queue():
         # kill-switch, label, scope, bug-task counts + the structural savings metric
         # (architecture stages skipped). Additive block; never-raise.
         "bug_fast_track": bug_fast_track.snapshot(),
+        # ORCH-112 (D3): deploy-base checkout-hygiene observability (read-only) —
+        # kill-switch + scope. Additive block; never-raise.
+        "checkout_hygiene": checkout_hygiene.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).

src/merge_gate.py

@@ -36,6 +36,7 @@ import time
 
 from .config import settings
 from .git_worktree import ensure_worktree, get_worktree_path
+from .proc_group import run_in_process_group  # ORCH-110 D1: tree-kill on timeout
 
 logger = logging.getLogger("orchestrator.merge_gate")
 
@@ -175,17 +176,103 @@ def auto_rebase_onto_main(repo: str, branch: str) -> tuple[bool, str]:
 # ---------------------------------------------------------------------------
 # re-test in the caught-up worktree
 # ---------------------------------------------------------------------------
+def _resolve_retest_timeout() -> int:
+    """Resolve the re-test wall-clock budget (ORCH-110 D5), never-break.
+
+    ``int(settings.merge_retest_timeout_s)`` when it is a positive int; otherwise
+    the safe default (900) + WARNING (mirrors ``launcher._resolve_timeout``). A
+    malformed / non-positive config never reaches ``subprocess`` (FR-3 / AC-5).
+    """
+    default = 900
+    try:
+        v = int(settings.merge_retest_timeout_s)
+        if v > 0:
+            return v
+        logger.warning(
+            "Non-positive merge_retest_timeout_s=%r; using default %ss",
+            settings.merge_retest_timeout_s, default,
+        )
+    except (TypeError, ValueError):
+        logger.warning(
+            "Invalid merge_retest_timeout_s=%r; using default %ss",
+            settings.merge_retest_timeout_s, default,
+        )
+    return default
+
+
+def head_sha(repo: str, branch: str) -> str:
+    """Return ``git rev-parse HEAD`` of the branch worktree, or ``""`` (ORCH-110 D4).
+
+    Used by ``check_branch_mergeable`` to detect a no-op rebase (HEAD unchanged ->
+    branch already contained the latest origin/main). Reads ONLY the existing
+    per-branch worktree (``get_worktree_path``; the worktree exists by the
+    deploy-staging->deploy edge) — it never CREATES one, so on an absent worktree it
+    safely returns ``""`` (the no-op-skip then never triggers; re-test runs —
+    fail-safe). Never-raise: any git/OS error -> ``""``.
+    """
+    try:
+        wt = get_worktree_path(repo, branch)
+        if not os.path.isdir(wt):
+            return ""
+        r = subprocess.run(
+            ["git", "-C", wt, "rev-parse", "HEAD"],
+            capture_output=True, text=True, timeout=_SHORT_TIMEOUT,
+        )
+        if r.returncode != 0:
+            return ""
+        return (r.stdout or "").strip()
+    except (subprocess.SubprocessError, OSError) as e:
+        logger.warning("head_sha error for %s/%s: %s", repo, branch, e)
+        return ""
+
+
+def classify_retest_failure(reason: str) -> str:
+    """Classify a merge-gate FAIL ``reason`` (ORCH-110 D2). Pure, never-raise.
+
+    The single point for the 'magic string' of the re-test outcome so the routing
+    in ``stage_engine._handle_merge_gate`` can distinguish an INFRA timeout from a
+    real RED re-test without scattering ``"timeout" in reason`` checks:
+
+      * ``"timeout"``   — the re-test hit its wall-clock budget (infra/resource);
+                          ``check_branch_mergeable`` returns ``"re-test timeout after <T>s"``.
+      * ``"red"``       — a deterministically red re-test (a real code defect):
+                          ``"re-test failed after rebase: ..."``.
+      * ``"lock-busy"`` — merge-lock contention (``"merge-lock busy"``).
+      * ``"other"``     — rebase conflict / setup error / anything else.
+
+    SCOPE (ADR D2): ONLY the re-test timeout is an infra-tolerated transient.
+    ``auto_rebase_onto_main``'s own ``"rebase timeout"`` is a DIFFERENT timeout (git
+    hung) and stays on the rollback path — without a successful rebase the branch
+    cannot be caught up to ``main``, so a merge is impossible by construction.
+    """
+    try:
+        r = (reason or "").strip().lower()
+        if r == "merge-lock busy":
+            return "lock-busy"
+        if "re-test timeout" in r:
+            return "timeout"
+        if r.startswith("re-test failed"):
+            return "red"
+        return "other"
+    except Exception:  # noqa: BLE001 - never-raise; unknown -> other (safe: rollback)
+        return "other"
+
+
 def retest_branch(repo: str, branch: str) -> tuple[bool, str]:
     """Run the project test-suite in the (already caught-up) branch worktree.
 
     Command: ``python -m pytest <merge_retest_target>`` (default ``tests/``),
-    matching the orchestrator CI / check_tests_local pattern. Bounded by
-    ``settings.merge_retest_timeout_s``.
+    matching the orchestrator CI / check_tests_local pattern. Bounded by the
+    validated ``_resolve_retest_timeout()`` budget (ORCH-110 D5).
 
-    Returns:
+    ORCH-110 (D1 / FR-2): the suite is spawned in its OWN process group via
+    ``run_in_process_group`` so a timeout tree-kills the WHOLE subtree (no orphan
+    grandchildren grinding the host CPU). The RETURN contract is byte-for-byte the
+    prior one — only the side effect (no leak) changes:
       * ``(True,  "re-test green")``                 — pytest rc == 0
-      * ``(False, "re-test timeout after <T>s")``    — exceeded the timeout (AC-6)
+      * ``(False, "re-test timeout after <T>s")``    — exceeded the timeout (AC-4/AC-6)
       * ``(False, "re-test failed: ...<tail>")``     — non-zero rc, with output tail
+      * ``(False, "re-test error: ...")``            — spawn / OS error (not a timeout)
     Never-raise (AC-9): any setup/OS error -> ``(False, "<reason>")``.
     """
     wt = get_worktree_path(repo, branch)
@@ -197,21 +284,25 @@ def retest_branch(repo: str, branch: str) -> tuple[bool, str]:
             return False, f"re-test setup error: {e}"
 
     target = settings.merge_retest_target or "tests/"
-    timeout = settings.merge_retest_timeout_s
-    try:
-        r = subprocess.run(
-            ["python", "-m", "pytest", target, "-q"],
-            cwd=wt, capture_output=True, text=True, timeout=timeout,
-        )
-    except subprocess.TimeoutExpired:
+    timeout = _resolve_retest_timeout()
+    res = run_in_process_group(
+        ["python", "-m", "pytest", target, "-q"],
+        cwd=wt,
+        timeout=timeout,
+        tree_kill=bool(getattr(settings, "subprocess_tree_kill_enabled", True)),
+        grace_s=settings.agent_kill_grace_seconds,
+    )
+    if res.timed_out:
         logger.warning("retest_branch: timeout (%ss) on %s/%s", timeout, repo, branch)
         return False, f"re-test timeout after {timeout}s"
-    except (subprocess.SubprocessError, OSError) as e:
-        return False, f"re-test error: {e}"
-
-    if r.returncode == 0:
+    if res.returncode is None:
+        # Spawn / OS error that was NOT a timeout -> preserve the prior error reason.
+        detail = (res.stderr or "").strip()[:200]
+        logger.warning("retest_branch: spawn error on %s/%s: %s", repo, branch, detail)
+        return False, f"re-test error: {detail}"
+    if res.returncode == 0:
         return True, "re-test green"
-    tail = ((r.stdout or "") + (r.stderr or ""))[-500:]
+    tail = ((res.stdout or "") + (res.stderr or ""))[-500:]
     logger.warning("retest_branch: red on %s/%s", repo, branch)
     return False, f"re-test failed: ...{tail}"
 
@@ -576,6 +667,82 @@ def merge_verify_status() -> dict:
         return {"enabled": False}
 
 
+# ---------------------------------------------------------------------------
+# ORCH-110 (D6): re-test infra-timeout observability counters (read-only).
+#
+# In-process counters (mirror _MERGE_VERIFY_COUNTERS): reset only on process start,
+# surfaced read-only via merge_gate_status() in GET /queue. NEVER the source of any
+# decision — purely informational, so an infra timeout is distinguishable from a
+# code-fault rollback in the snapshot. never-raise.
+# ---------------------------------------------------------------------------
+_MERGE_GATE_COUNTERS: dict = {
+    "retest_timeout_total": 0,          # re-test hit its wall-clock budget
+    "retest_infra_retry_total": 0,      # infra-timeout -> bounded re-queue (D3)
+    "retest_infra_exhausted_total": 0,  # infra-retry budget exhausted -> infra-alert
+    "retest_skipped_current_total": 0,  # re-test skipped on a no-op rebase (D4)
+    "last_infra_timeout_wi": None,
+}
+
+
+def note_retest_timeout(work_item_id: str | None = None) -> None:
+    """Bump the 're-test timeout' counter (observability only). Never raises."""
+    try:
+        _MERGE_GATE_COUNTERS["retest_timeout_total"] += 1
+        _MERGE_GATE_COUNTERS["last_infra_timeout_wi"] = work_item_id
+    except Exception:  # noqa: BLE001 - observability must never break a decision
+        pass
+
+
+def note_retest_infra_retry() -> None:
+    """Bump the 'infra-timeout re-queue' counter (observability only). Never raises."""
+    try:
+        _MERGE_GATE_COUNTERS["retest_infra_retry_total"] += 1
+    except Exception:  # noqa: BLE001 - observability must never break a decision
+        pass
+
+
+def note_retest_infra_exhausted() -> None:
+    """Bump the 'infra-retry exhausted' counter (observability only). Never raises."""
+    try:
+        _MERGE_GATE_COUNTERS["retest_infra_exhausted_total"] += 1
+    except Exception:  # noqa: BLE001 - observability must never break a decision
+        pass
+
+
+def note_retest_skipped_current() -> None:
+    """Bump the 're-test skipped (no-op rebase)' counter (D4). Never raises."""
+    try:
+        _MERGE_GATE_COUNTERS["retest_skipped_current_total"] += 1
+    except Exception:  # noqa: BLE001 - observability must never break a decision
+        pass
+
+
+def merge_gate_status() -> dict:
+    """Read-only snapshot of the ORCH-110 merge-gate re-test path for GET /queue.
+
+    Additive block; existing /queue keys are untouched. Surfaces the flags +
+    counters so an infra-timeout (retry/exhaustion) is distinguishable from a
+    code-fault rollback. Never the source of any decision. never-raise.
+    """
+    try:
+        return {
+            "infra_tolerance_enabled": bool(settings.merge_retest_infra_tolerance_enabled),
+            "infra_max_retries": settings.merge_retest_infra_max_retries,
+            "infra_retry_delay_s": settings.merge_retest_infra_retry_delay_s,
+            "skip_when_current_enabled": bool(settings.merge_retest_skip_when_current_enabled),
+            "tree_kill_enabled": bool(settings.subprocess_tree_kill_enabled),
+            "retest_timeout_s": settings.merge_retest_timeout_s,
+            "retest_timeout_total": _MERGE_GATE_COUNTERS["retest_timeout_total"],
+            "retest_infra_retry_total": _MERGE_GATE_COUNTERS["retest_infra_retry_total"],
+            "retest_infra_exhausted_total": _MERGE_GATE_COUNTERS["retest_infra_exhausted_total"],
+            "retest_skipped_current_total": _MERGE_GATE_COUNTERS["retest_skipped_current_total"],
+            "last_infra_timeout_wi": _MERGE_GATE_COUNTERS["last_infra_timeout_wi"],
+        }
+    except Exception as e:  # noqa: BLE001 - never-raise contract
+        logger.warning("merge_gate_status error: %s", e)
+        return {"infra_tolerance_enabled": False}
+
+
 def merge_verify_applies(repo: str) -> bool:
     """Whether the ORCH-071 merge-verify under-gate is REAL for this repo.
 
@@ -1037,6 +1204,7 @@ MAIN_REGRESSION_MARKERS: list[tuple[str, str, str]] = [
     ("ORCH-073", "check_main_regression", "src/merge_gate.py"),
     ("ORCH-082", "ensure_open_pr", "src/merge_gate.py"),
     ("ORCH-093", "_classify_merge_response", "src/merge_gate.py"),
+    ("ORCH-110", "classify_retest_failure", "src/merge_gate.py"),
 ]
 
 

src/proc_group.py

@@ -0,0 +1,179 @@
+"""Process-group runner with tree-kill on timeout (ORCH-110 D1).
+
+Background
+----------
+The orchestrator spawns its OWN pytest subprocesses OUTSIDE the LLM-agent path:
+``merge_gate.retest_branch`` (the merge-gate re-test) and
+``coverage_gate.measure_coverage`` (the coverage measurement). Both used a plain
+``subprocess.run(..., timeout=...)``. On ``TimeoutExpired`` CPython kills only the
+DIRECT child (``proc.kill()``); any grandchildren (pytest-xdist workers, tests that
+spawn their own processes) are re-parented to PID 1 and keep running — for days,
+starving the host CPU. That orphan leak is a ROOT cause of the ORCH-109 / PR #129
+incident (a 516s suite blew its 600s budget under CPU starvation -> a false
+merge-gate rollback after a green CI).
+
+This leaf gives those orchestrator-spawned runs the SAME SIGTERM->grace->SIGKILL
+cascade the LLM agents already get from ``launcher.stop_process`` — but at the
+process-GROUP level so the WHOLE subtree dies on a timeout:
+
+  * the child becomes the leader of a NEW session / process group
+    (``start_new_session=True`` -> ``setsid``), so every descendant shares
+    ``pgid == child.pid``;
+  * on timeout the whole group is killed with ``os.killpg`` (SIGTERM, grace poll,
+    then SIGKILL), then reaped (no zombies).
+
+Invariants:
+  * **stdlib-only leaf** — imports only ``os`` / ``signal`` / ``subprocess`` /
+    ``time`` / ``logging`` / ``dataclasses``; NEVER another ``src/*`` module
+    (mirrors the purity of ``serial_gate`` / ``staging_verdict``).
+  * **never-raise** — any OS error degrades to a safe ``ProcResult`` (the caller maps
+    it to its existing contract); an exception never escapes.
+  * **never-break fallback** — with ``tree_kill=False`` OR on a platform without
+    ``os.killpg`` / ``os.setsid`` (non-POSIX) it degrades to the prior
+    ``subprocess.run(cmd, ..., timeout=timeout)`` (byte-for-byte the old behaviour;
+    prod is Linux and never hits the fallback).
+"""
+
+import logging
+import os
+import signal
+import subprocess
+import time
+from dataclasses import dataclass
+
+logger = logging.getLogger("orchestrator.proc_group")
+
+
+@dataclass
+class ProcResult:
+    """Outcome of a process-group run (ORCH-110 D1).
+
+    ``returncode`` is the child's exit code, or ``None`` when the process could not
+    be reaped with a real code (timeout-kill / spawn error). ``timed_out`` is True
+    iff the command exceeded its wall-clock budget (and the whole group was killed).
+    """
+
+    returncode: int | None
+    stdout: str
+    stderr: str
+    timed_out: bool
+
+
+def _tree_kill_supported() -> bool:
+    """POSIX process-group ops available? (non-POSIX -> fall back to subprocess.run)."""
+    return hasattr(os, "killpg") and hasattr(os, "getpgid") and hasattr(os, "setsid")
+
+
+def _kill_group(pid: int, grace_s: float) -> None:
+    """SIGTERM -> grace -> SIGKILL the whole process GROUP led by ``pid``.
+
+    Mirrors ``launcher.stop_process`` but targets the process GROUP (``os.killpg``)
+    so grandchildren die too. ``ProcessLookupError`` is tolerated at every step (the
+    group may already be gone). Never raises.
+    """
+    try:
+        pgid = os.getpgid(pid)
+    except (ProcessLookupError, OSError):
+        return
+
+    # Phase 1: SIGTERM the whole group (graceful).
+    try:
+        os.killpg(pgid, signal.SIGTERM)
+    except ProcessLookupError:
+        return
+    except OSError as e:  # noqa: BLE001 - never-raise
+        logger.warning("proc_group: SIGTERM killpg(%s) error: %s", pgid, e)
+
+    # Phase 2: poll for graceful group exit within the grace window.
+    poll = 0.2
+    waited = 0.0
+    while waited < max(0.0, grace_s):
+        time.sleep(poll)
+        waited += poll
+        try:
+            os.killpg(pgid, 0)  # signal 0 = liveness probe of the group
+        except ProcessLookupError:
+            return  # whole group gone
+        except OSError:
+            break
+
+    # Phase 3: still alive -> hard SIGKILL the group.
+    try:
+        os.killpg(pgid, signal.SIGKILL)
+    except ProcessLookupError:
+        return
+    except OSError as e:  # noqa: BLE001 - never-raise
+        logger.warning("proc_group: SIGKILL killpg(%s) error: %s", pgid, e)
+
+
+def _run_plain(cmd, *, cwd, timeout, env=None) -> ProcResult:
+    """Fallback path: prior ``subprocess.run`` semantics (never-break)."""
+    try:
+        r = subprocess.run(
+            cmd, cwd=cwd, env=env, capture_output=True, text=True, timeout=timeout
+        )
+        return ProcResult(
+            returncode=r.returncode, stdout=r.stdout or "", stderr=r.stderr or "",
+            timed_out=False,
+        )
+    except subprocess.TimeoutExpired:
+        return ProcResult(returncode=None, stdout="", stderr="", timed_out=True)
+    except (subprocess.SubprocessError, OSError) as e:
+        logger.warning("proc_group(_run_plain): error for %s: %s", cmd, e)
+        return ProcResult(returncode=None, stdout="", stderr=str(e), timed_out=False)
+
+
+def run_in_process_group(
+    cmd, *, cwd, timeout, env=None, grace_s: float = 5.0, tree_kill: bool = True
+) -> ProcResult:
+    """Run ``cmd`` in its own process group; tree-kill the whole group on timeout.
+
+    See the module docstring. Returns a ``ProcResult``; ``timed_out=True`` iff the
+    command exceeded ``timeout`` (and the whole group was killed). Never raises.
+
+    Fallback (never-break): ``tree_kill=False`` or a non-POSIX platform -> a plain
+    ``subprocess.run(cmd, ..., timeout=timeout)`` (the prior behaviour).
+    """
+    if not tree_kill or not _tree_kill_supported():
+        return _run_plain(cmd, cwd=cwd, timeout=timeout, env=env)
+
+    try:
+        proc = subprocess.Popen(  # noqa: S603 - cmd is an internal, fixed argv
+            cmd,
+            cwd=cwd,
+            env=env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            start_new_session=True,  # setsid -> child leads a new process group
+        )
+    except (OSError, ValueError) as e:
+        logger.warning("proc_group: spawn error for %s: %s", cmd, e)
+        return ProcResult(returncode=None, stdout="", stderr=str(e), timed_out=False)
+
+    try:
+        out, err = proc.communicate(timeout=timeout)
+        return ProcResult(
+            returncode=proc.returncode, stdout=out or "", stderr=err or "",
+            timed_out=False,
+        )
+    except subprocess.TimeoutExpired:
+        # Tree-kill the WHOLE group (children + grandchildren), then reap to avoid
+        # leaving a zombie behind.
+        _kill_group(proc.pid, grace_s)
+        out, err = "", ""
+        try:
+            out, err = proc.communicate(timeout=grace_s + 5.0)
+        except (subprocess.TimeoutExpired, OSError, ValueError):
+            try:
+                proc.wait(timeout=grace_s + 5.0)
+            except (subprocess.TimeoutExpired, OSError, ValueError):
+                pass
+        return ProcResult(
+            returncode=proc.returncode, stdout=out or "", stderr=err or "",
+            timed_out=True,
+        )
+    except (OSError, ValueError) as e:  # noqa: BLE001 - never-raise
+        logger.warning("proc_group: communicate error for %s: %s", cmd, e)
+        _kill_group(proc.pid, grace_s)
+        return ProcResult(returncode=proc.returncode, stdout="", stderr=str(e), timed_out=False)

src/qg/checks.py

@@ -708,10 +708,38 @@ def check_branch_mergeable(repo: str, work_item_id: str, branch: str) -> tuple[b
                 logger.info("check_branch_mergeable: %s up-to-date with main", branch)
                 return True, "branch up-to-date with main"
 
+            # ORCH-110 (D4): capture HEAD before/after the rebase to detect a no-op
+            # rebase (branch already contained the latest origin/main).
+            pre_sha = merge_gate.head_sha(repo, branch)
             ok, rb_reason = merge_gate.auto_rebase_onto_main(repo, branch)
             if not ok:
                 merge_gate.release_merge_lease(repo, branch)
                 return False, rb_reason  # "rebase conflict: ..."
+            post_sha = merge_gate.head_sha(repo, branch)
+
+            # ORCH-110 (D4 / FR-4 / AC-6): re-test contract. ORCH-043 catches a
+            # SEMANTIC merge conflict that can only arise when ``main`` actually moved
+            # and the branch was really rebased onto new commits. When the rebase was
+            # a PROVEN no-op (HEAD unchanged), there is no "moved main" -> the local
+            # re-test re-checks exactly the commit CI + tester + staging already
+            # validated on THIS HEAD -> it is a redundant single point of false
+            # failure (the ORCH-109 timeout incident). Skip it ONLY on a proven no-op
+            # (both SHAs non-empty AND equal); on ANY uncertainty (empty SHA / flag
+            # off) the re-test runs (fail-safe to BR-6/AC-3). This extends to the
+            # premerge_rebase_always=True path the same optimisation the
+            # premerge_rebase_always=False not-behind short-circuit already has.
+            if (
+                bool(getattr(settings, "merge_retest_skip_when_current_enabled", False))
+                and pre_sha and post_sha and pre_sha == post_sha
+            ):
+                logger.info(
+                    "check_branch_mergeable: %s rebase no-op (HEAD %s unchanged) -> "
+                    "re-test skipped (HEAD CI-validated)", branch, pre_sha[:8],
+                )
+                merge_gate.note_retest_skipped_current()
+                return True, (
+                    "branch up-to-date (re-test skipped: rebase no-op, HEAD CI-validated)"
+                )
 
             ok_t, t_reason = merge_gate.retest_branch(repo, branch)
             if ok_t:

src/self_deploy.py

@@ -239,7 +239,7 @@ def build_deploy_command(repo: str, work_item_id: str | None, branch: str) -> li
     ``expected_revision`` returns ``""`` and the env is omitted, keeping the hook's
     backward-compatible "no provenance check" behaviour (AC-5 / AC-7).
     """
-    from . import image_freshness
+    from . import checkout_hygiene, image_freshness
 
     host_dir = host_state_dir(repo, work_item_id)
     result_sentinel = os.path.join(host_dir, RESULT)
@@ -262,6 +262,12 @@ def build_deploy_command(repo: str, work_item_id: str | None, branch: str) -> li
     expected_rev = image_freshness.expected_revision(repo, branch)
     if expected_rev:
         env_assignments += f" EXPECTED_REVISION={shlex.quote(expected_rev)}"
+    # ORCH-112: inject CHECKOUT_HYGIENE=1 HYGIENE_REPORT=<path> only when the leaf says
+    # hygiene applies (kill-switch + self-hosting scope). Empty -> the hook's
+    # ${CHECKOUT_HYGIENE:-0} guard stays 0 -> bare `git pull` 1:1 as before ORCH-112.
+    hygiene_env = checkout_hygiene.hook_env(repo, work_item_id)
+    if hygiene_env:
+        env_assignments += f" {hygiene_env}"
     inner = (
         f"cd {shlex.quote(settings.deploy_host_repo_path)} && "
         f"{env_assignments} "

src/stage_engine.py

@@ -995,6 +995,22 @@ def _handle_merge_gate(
         )
         return True
 
+    # ORCH-110 (D2/D3): classify the FAIL cause. An INFRA re-test TIMEOUT (the
+    # ORCH-109 incident: green CI + green tester, but the local re-test blew its
+    # wall-clock budget under CPU starvation) is a TRANSIENT, NOT a code fault — it
+    # must NOT take the _handle_merge_gate_rollback path (rollback to development +
+    # burn a developer retry that nobody can fix). Route it to a bounded infra-retry
+    # instead. A deterministically RED re-test / conflict still rolls back (BR-6 /
+    # AC-3). Kill-switch off -> byte-for-byte the prior behaviour (timeout ->
+    # rollback), NFR-2.
+    if merge_gate.classify_retest_failure(reason) == "timeout":
+        merge_gate.note_retest_timeout(work_item_id)
+        if settings.merge_retest_infra_tolerance_enabled:
+            _handle_merge_gate_infra_retry(
+                task_id, current_stage, repo, work_item_id, branch, reason, result
+            )
+            return True
+
     _handle_merge_gate_rollback(
         task_id, current_stage, repo, work_item_id, branch, reason, result
     )
@@ -1044,6 +1060,110 @@ def _handle_merge_gate_defer(
         )
 
 
+def _merge_infra_retry_count(task_id: int) -> int:
+    """How many times this task was re-queued by the merge-gate infra-timeout path.
+
+    Restart-safe (mirror of ``_merge_defer_count``): counted from the persisted jobs
+    queue by the infra-retry marker in task_content, so a service restart never
+    resets the infra-retry budget (ORCH-110 D3 / AC-9).
+    """
+    conn = get_db()
+    n = conn.execute(
+        "SELECT COUNT(*) FROM jobs WHERE task_id=? AND "
+        "task_content LIKE '%merge-gate infra-timeout retry%'",
+        (task_id,),
+    ).fetchone()[0]
+    conn.close()
+    return n
+
+
+def _handle_merge_gate_infra_retry(
+    task_id, current_stage, repo, work_item_id, branch, reason, result: AdvanceResult
+):
+    """ORCH-110 (D3): merge-gate re-test INFRA timeout -> bounded infra-retry.
+
+    Mirror of ``_handle_merge_gate_defer`` (NOT ``_handle_merge_gate_rollback``): the
+    task STAYS on deploy-staging, the staging-deployer is re-queued after a delay, and
+    there is NO ``update_task_stage("development")``, NO developer-retry increment and
+    NO code-fault QG-failure semantics — so a green-CI + green-tester task is never
+    falsely sent back to development for an infra hiccup (BR-1 / AC-1). The merge lease
+    was already released by ``check_branch_mergeable`` on the timeout, so the re-run
+    re-acquires it normally (defer-path parity).
+
+    Bounded (anti-loop, NFR-5 / AC-9): after ``merge_retest_infra_max_retries``
+    re-tries the task is blocked with an INFRA-specific alert (a resource problem,
+    explicitly NOT "developer must fix"), so it never bounces forever. The first
+    timeout already tree-killed the orphan processes (D1), so the next re-test usually
+    passes — the retry is recovery, not masking. The task does NOT move to development.
+
+    never-raise (TC-09): any unexpected error in this transient path is logged with a
+    WARNING and swallowed (the task simply stays on deploy-staging for the reconciler /
+    reaper to re-drive) so an exception never escapes into ``advance_stage``.
+    """
+    try:
+        _merge_gate_infra_retry_impl(
+            task_id, current_stage, repo, work_item_id, branch, reason, result
+        )
+    except Exception as e:  # noqa: BLE001 - never-raise; do not crash advance_stage
+        logger.warning(
+            f"Task {task_id}: merge-gate infra-retry path error: {e} "
+            f"(swallowed; task stays on deploy-staging)"
+        )
+        result.note = "merge-gate-infra-retry-error"
+
+
+def _merge_gate_infra_retry_impl(
+    task_id, current_stage, repo, work_item_id, branch, reason, result: AdvanceResult
+):
+    """Body of the merge-gate infra-retry (ORCH-110 D3); wrapped by the never-raise
+    ``_handle_merge_gate_infra_retry``."""
+    retries = _merge_infra_retry_count(task_id)
+    if retries < settings.merge_retest_infra_max_retries:
+        task_desc = (
+            f"Work item: {work_item_id}\nRepo: {repo}\nBranch: {branch}\n"
+            f"Stage: deploy-staging\nNote: merge-gate infra-timeout retry "
+            f"(attempt {retries + 1}/{settings.merge_retest_infra_max_retries}) — "
+            f"re-test hit the wall-clock budget (infra/resource, NOT a code defect); "
+            f"retrying after {settings.merge_retest_infra_retry_delay_s}s. Reason: {reason}."
+        )
+        new_job = enqueue_job(
+            "deployer", repo, task_desc, task_id=task_id,
+            available_at_delay_s=settings.merge_retest_infra_retry_delay_s,
+        )
+        merge_gate.note_retest_infra_retry()
+        result.enqueued_agent = "deployer"
+        result.enqueued_job_id = new_job
+        result.note = "merge-gate-infra-retry"
+        logger.warning(
+            f"Task {task_id}: merge-gate re-test infra-timeout, re-queued deployer "
+            f"(job_id={new_job}, attempt {retries + 1}/"
+            f"{settings.merge_retest_infra_max_retries}); NOT a code fault ({reason})"
+        )
+    else:
+        merge_gate.note_retest_infra_exhausted()
+        set_issue_blocked(work_item_id)
+        send_telegram(
+            f"⏳ {link_for(work_item_id)}: merge-gate re-test infra-timeout "
+            f"сохраняется после {settings.merge_retest_infra_max_retries} повторов — "
+            f"ресурсная проблема (CPU / осиротевшие процессы), НЕ дефект кода. "
+            f"Проверьте хост / нужно ручное вмешательство."
+        )
+        plane_add_comment(
+            work_item_id,
+            f"⏳ Merge-gate re-test infra-timeout сохраняется после "
+            f"{settings.merge_retest_infra_max_retries} повторов — инфраструктурная "
+            f"проблема (ресурсы / осиротевшие процессы), НЕ дефект кода. Задача "
+            f"остаётся на deploy-staging; нужно ручное вмешательство (НЕ доработка кода).",
+            author="deployer",
+        )
+        result.alerted = True
+        result.note = "merge-gate-infra-retry-exhausted"
+        logger.error(
+            f"Task {task_id}: merge-gate re-test infra-timeout exhausted "
+            f"({settings.merge_retest_infra_max_retries} retries) ({reason})"
+        )
+
+
 def _handle_merge_gate_rollback(
     task_id, current_stage, repo, work_item_id, branch, reason, result: AdvanceResult
 ):
@@ -1837,6 +1957,17 @@ def run_deploy_finalizer(job: dict):
     logger.info(
         f"Task {task_id}: deploy finalized, hook exit={code} -> deploy_status={status}"
     )
+
+    # ORCH-112 (D5 / AC-8): if the host hook converged a DIRTY deploy-base to
+    # origin/main before the pull, surface it (structured log + best-effort Telegram).
+    # never-raise — observability must never crash the finalizer.
+    try:
+        from . import checkout_hygiene
+        report = checkout_hygiene.read_report(repo, work_item_id)
+        if report:
+            checkout_hygiene.alert_dirty(repo, work_item_id, report)
+    except Exception as e:  # noqa: BLE001 - never break the finalizer
+        logger.warning("Task %s: checkout-hygiene report read failed: %s", task_id, e)
     if status == "SUCCESS" and work_item_id:
         plane_add_comment(
             work_item_id,

tests/test_config.py

@@ -56,7 +56,7 @@ def test_merge_gate_settings_defaults(monkeypatch):
     s = Settings()
     assert s.merge_gate_enabled is True
     assert s.merge_gate_repos == ""
-    assert s.merge_retest_timeout_s == 600
+    assert s.merge_retest_timeout_s == 900  # ORCH-110 D5: raised 600 -> 900
     assert s.merge_retest_target == "tests/"
     assert s.merge_lock_timeout_s == 300
     assert s.merge_defer_delay_s == 60

tests/test_coverage_gate.py

@@ -425,12 +425,14 @@ def test_tc14_real_measurement(tmp_path, monkeypatch):
 
 
 def test_tc14_measure_timeout_returns_none(monkeypatch):
-    import subprocess
+    # ORCH-110: measure_coverage now runs via proc_group.run_in_process_group
+    # (tree-kill on timeout). A timed_out ProcResult -> None (prior contract).
+    from src.proc_group import ProcResult
     monkeypatch.setattr(cg, "ensure_worktree", lambda r, b: "/tmp")
-
-    def _timeout(*a, **k):
-        raise subprocess.TimeoutExpired(cmd="pytest", timeout=1)
-    monkeypatch.setattr(cg.subprocess, "run", _timeout)
+    monkeypatch.setattr(
+        cg, "run_in_process_group",
+        lambda *a, **k: ProcResult(returncode=None, stdout="", stderr="", timed_out=True),
+    )
     assert cg.measure_coverage(_REPO, _BRANCH) is None
 
 

tests/test_deploy_checkout_hygiene.py

@@ -0,0 +1,485 @@
+"""ORCH-112: deploy-base checkout-hygiene (resilient-pull) — TC-01…TC-10.
+
+Two test layers:
+
+  * SHELL simulation (TC-01..TC-04, TC-07) — drives the REAL
+    ``scripts/orchestrator-deploy-hook.sh`` in a hermetic sandbox. ``git`` is REAL
+    (against a LOCAL bare "origin" — no network), while ``docker`` / ``curl`` /
+    ``sleep`` are PATH-shimmed stubs so no real infra is touched and prod is never
+    restarted (INFRA safety). Models tests/test_deploy_hook_rollback_sim.py.
+
+  * UNIT (TC-05, TC-06, TC-08, TC-09, TC-10) — the ``checkout_hygiene`` leaf, the
+    static safety contract of the hook (never ``-x`` / explicit excludes), the
+    pipeline-invariant guard and the documentation invariant.
+
+TC-01 is the MANDATORY incident-reproduction regression (ORCH-111): a dirty tracked
+edit to ``src/config.py`` over an advanced ``origin/main`` makes the bare ``git pull``
+abort with "local changes would be overwritten by merge" (RED before the fix); the
+resilient-pull hygiene converges the base and the deploy proceeds (GREEN after).
+"""
+
+import os
+import shutil
+import stat
+import subprocess
+
+import pytest
+
+from src import checkout_hygiene
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+HOOK = os.path.join(ROOT, "scripts", "orchestrator-deploy-hook.sh")
+
+pytestmark = pytest.mark.skipif(
+    shutil.which("bash") is None or shutil.which("git") is None,
+    reason="bash + git required for the deploy-hook hygiene simulation",
+)
+
+# Distinctive file bodies so assertions prove WHICH version won.
+_V1 = "ORIGIN-V1\n"
+_V2 = "ORIGIN-V2-ADVANCED\n"
+_DIRTY = "DIRTY-LOCAL-WIP\n"
+
+# Isolate git from any host/global config (hermetic).
+_GIT_ENV = {
+    "GIT_AUTHOR_NAME": "t",
+    "GIT_AUTHOR_EMAIL": "t@example.com",
+    "GIT_COMMITTER_NAME": "t",
+    "GIT_COMMITTER_EMAIL": "t@example.com",
+    "GIT_CONFIG_GLOBAL": os.devnull,
+    "GIT_CONFIG_SYSTEM": os.devnull,
+}
+
+
+def _git(cwd, *args):
+    r = subprocess.run(
+        ["git", "-C", str(cwd), *args],
+        capture_output=True, text=True, env={**os.environ, **_GIT_ENV},
+    )
+    assert r.returncode == 0, f"git {args} failed: {r.stdout}\n{r.stderr}"
+    return r
+
+
+def _write(path, content):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(content)
+
+
+def _write_exec(path, content):
+    _write(path, content)
+    os.chmod(path, os.stat(path).st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+
+
+def _make_stubs(binx, prev_running=True):
+    """Healthy docker/curl/sleep stubs (no real infra; deploy always succeeds).
+
+    ``prev_running`` controls whether ``docker compose ps -q`` returns a container id:
+    True -> step 1 captures a previous image and writes PREV_IMAGE_FILE (the normal
+    case); False -> no previous image is recorded (first-deploy / service-down), so the
+    deploy-base stays genuinely clean at the hygiene step (exercises the no-op branch).
+    """
+    ps_id = "fakecid" if prev_running else ""
+    _write_exec(str(binx / "docker"), f"""#!/bin/bash
+case "$1" in
+  compose)
+    for a in "$@"; do [ "$a" = "ps" ] && {{ echo "{ps_id}"; exit 0; }}; done
+    exit 0;;
+  inspect) echo "sha256:previmage"; exit 0;;
+  image) exit 0;;
+  tag) exit 0;;
+  *) exit 0;;
+esac
+""")
+    # curl: ALWAYS healthy -> deploy health-check passes immediately -> exit 0.
+    _write_exec(str(binx / "curl"), """#!/bin/bash
+iscode=""
+for a in "$@"; do [ "$a" = "-w" ] && iscode=1; done
+[ -n "$iscode" ] && echo "200" || echo '{"status":"ok"}'
+exit 0
+""")
+    _write_exec(str(binx / "sleep"), "#!/bin/bash\nexit 0\n")
+
+
+def _seed_origin_and_clone(tmp_path):
+    """Build a local bare origin (at V2) + a deploy-base clone (at V1).
+
+    Returns ``repo`` (the deploy-base path). The clone is one commit BEHIND origin so
+    that, with a conflicting dirty edit to src/config.py, a bare ``git pull`` would
+    abort (the exact ORCH-111 incident), while hygiene's reset --hard converges it.
+    """
+    work = tmp_path / "work"
+    work.mkdir()
+    _write(str(work / "src" / "config.py"), _V1)
+    _write(str(work / ".gitignore"), ".env\ndata/\n*.db\nbuild/\n")
+    _git(work, "init", "-q")
+    _git(work, "add", "-A")
+    _git(work, "commit", "-q", "-m", "v1")
+    _git(work, "branch", "-M", "main")
+
+    origin = tmp_path / "origin.git"
+    _git(tmp_path, "init", "-q", "--bare", str(origin))
+    _git(work, "remote", "add", "origin", str(origin))
+    _git(work, "push", "-q", "-u", "origin", "main")
+
+    repo = tmp_path / "repo"
+    _git(tmp_path, "clone", "-q", str(origin), str(repo))
+
+    # Advance origin/main to V2 (touches the SAME file we will dirty locally).
+    _write(str(work / "src" / "config.py"), _V2)
+    _git(work, "commit", "-q", "-am", "v2")
+    _git(work, "push", "-q", "origin", "main")
+    # Make repo's remote-tracking ref aware of V2's existence is the hook's job
+    # (it runs `git fetch`); leave repo at V1 deliberately.
+    return repo
+
+
+def _run_hook(repo, tmp_path, hygiene="1", extra_env=None, prev_running=True):
+    """Run the real hook in --deploy mode against ``repo`` with stubbed infra."""
+    binx = tmp_path / "bin"
+    if not binx.exists():
+        binx.mkdir()
+        _make_stubs(binx, prev_running=prev_running)
+    state = tmp_path / "state"
+    state.mkdir(exist_ok=True)
+    env = {
+        **os.environ,
+        **_GIT_ENV,
+        "PATH": f"{binx}:{os.environ['PATH']}",
+        "REPO": str(repo),
+        "LOG": str(state / "hook.log"),
+        "PREV_IMAGE_FILE": str(repo / ".deploy-prev-image-prod"),
+        "COMPOSE_PROFILE": "",
+        "TARGET_SERVICE": "orchestrator",
+        "TARGET_PORT": "8500",
+    }
+    if hygiene is not None:
+        env["CHECKOUT_HYGIENE"] = hygiene
+        env["HYGIENE_REPORT"] = str(state / "hygiene")
+    if extra_env:
+        env.update(extra_env)
+    return subprocess.run(
+        ["bash", HOOK, "--deploy"], env=env, capture_output=True, text=True, timeout=60,
+    )
+
+
+def _porcelain(repo):
+    r = subprocess.run(
+        ["git", "-C", str(repo), "status", "--porcelain"],
+        capture_output=True, text=True, env={**os.environ, **_GIT_ENV},
+    )
+    return r.stdout.strip()
+
+
+def _wip_dirt(repo):
+    """Porcelain output MINUS the intentionally-preserved deploy artefacts.
+
+    After hygiene, the deploy-base is converged to origin/main but the rollback/log
+    artefacts (.deploy-prev-image-* / deploy-hook.log) are legitimately untracked-and-
+    preserved (NFR-2). This returns ONLY the *real* residual dirt (a non-empty result
+    means a tracked edit survived or WIP was not cleaned)."""
+    lines = []
+    for ln in _porcelain(repo).splitlines():
+        name = ln[3:] if len(ln) > 3 else ""
+        if name.startswith(".deploy-prev-image-") or name == "deploy-hook.log":
+            continue
+        lines.append(ln)
+    return "\n".join(lines).strip()
+
+
+def _head_config(repo):
+    with open(repo / "src" / "config.py", encoding="utf-8") as f:
+        return f.read()
+
+
+# ===========================================================================
+# TC-01 — MANDATORY regression (red->green): dirty tracked edit + advanced origin
+# ===========================================================================
+def test_tc01_dirty_tracked_edit_converges_and_deploys(tmp_path):
+    repo = _seed_origin_and_clone(tmp_path)
+    # Dirty the SAME tracked file origin advanced -> a bare `git pull` would abort.
+    _write(str(repo / "src" / "config.py"), _DIRTY)
+    # Untracked WIP left behind too (failed/cancelled task residue).
+    _write(str(repo / "scripts" / "install_lite.py"), "# wip\n")
+
+    proc = _run_hook(repo, tmp_path, hygiene="1")
+
+    assert proc.returncode == 0, (
+        "resilient-pull must converge a dirty base and let the deploy proceed "
+        f"(stdout={proc.stdout}\nstderr={proc.stderr})"
+    )
+    # Base converged to the ADVANCED origin/main (dirty local edit discarded).
+    assert _head_config(repo) == _V2
+    # No real WIP remains (tracked edit reset, untracked WIP cleaned); the rollback
+    # snapshot .deploy-prev-image-prod is legitimately preserved (NFR-2), so we check
+    # the residual dirt MINUS the preserved artefacts.
+    assert _wip_dirt(repo) == ""
+    assert not (repo / "scripts" / "install_lite.py").exists()
+    out = proc.stdout + proc.stderr
+    assert "HYGIENE" in out
+
+
+def test_tc01b_bare_pull_aborts_without_hygiene_documents_incident(tmp_path):
+    """ORCH-111 reproduction: WITHOUT hygiene the same dirty base aborts the pull."""
+    repo = _seed_origin_and_clone(tmp_path)
+    _write(str(repo / "src" / "config.py"), _DIRTY)
+
+    proc = _run_hook(repo, tmp_path, hygiene=None)  # CHECKOUT_HYGIENE unset
+
+    assert proc.returncode != 0, "bare `git pull` must abort on the conflicting dirty edit"
+    log = (tmp_path / "state" / "hook.log").read_text(encoding="utf-8")
+    assert "would be overwritten by merge" in (log + proc.stdout + proc.stderr)
+
+
+# ===========================================================================
+# TC-02 — untracked WIP files do not block and do not leak into the deploy
+# ===========================================================================
+def test_tc02_untracked_wip_does_not_block(tmp_path):
+    repo = _seed_origin_and_clone(tmp_path)
+    for rel in (
+        "scripts/install_lite.py",
+        "tests/test_install_lite.py",
+        "docs/deployment/lite-install.example.yaml",
+    ):
+        _write(str(repo / rel), "# abandoned WIP\n")
+
+    proc = _run_hook(repo, tmp_path, hygiene="1")
+
+    assert proc.returncode == 0, f"{proc.stdout}\n{proc.stderr}"
+    assert _wip_dirt(repo) == ""
+    for rel in (
+        "scripts/install_lite.py",
+        "tests/test_install_lite.py",
+        "docs/deployment/lite-install.example.yaml",
+    ):
+        assert not (repo / rel).exists(), f"{rel} must be cleaned, not leaked into deploy"
+
+
+# ===========================================================================
+# TC-03 — preservation of rollback/log/gitignored/sibling artefacts (NFR-2)
+# ===========================================================================
+def test_tc03_preserves_rollback_and_sibling_artifacts(tmp_path):
+    repo = _seed_origin_and_clone(tmp_path)
+    _write(str(repo / "src" / "config.py"), _DIRTY)  # force the hygiene path
+
+    # In-$REPO artefacts that MUST survive (untracked, NOT gitignored).
+    _write(str(repo / ".deploy-prev-image-staging"), "sha256:stagingprev\n")
+    _write(str(repo / "deploy-hook.log"), "audit line\n")
+    # gitignored prod secrets / DB — must survive `git clean -fd` (NO -x).
+    _write(str(repo / ".env"), "ORCH_SECRET=keepme\n")
+    _write(str(repo / "data" / "orchestrator.db"), "sqlite-bytes\n")
+    # .git internal worktree admin record — git clean never touches .git/.
+    _write(str(repo / ".git" / "worktrees" / "wt1" / "HEAD"), "ref: refs/heads/x\n")
+    # Sibling state under the PARENT of $REPO — outside the clean scope.
+    _write(str(tmp_path / ".deploy-state-orchestrator" / "ORCH-112" / "result"), "0\n")
+    _write(str(tmp_path / ".merge-lease-orchestrator.json"), '{"branch":"x"}\n')
+
+    proc = _run_hook(repo, tmp_path, hygiene="1")
+    assert proc.returncode == 0, f"{proc.stdout}\n{proc.stderr}"
+
+    # Rollback snapshot freshly written by step 1 (PREV_IMAGE_FILE) survived hygiene.
+    assert (repo / ".deploy-prev-image-prod").is_file()
+    assert (repo / ".deploy-prev-image-prod").read_text().strip() != ""
+    # Wildcard-excluded sibling prev-image + log survived.
+    assert (repo / ".deploy-prev-image-staging").read_text() == "sha256:stagingprev\n"
+    assert (repo / "deploy-hook.log").read_text() == "audit line\n"
+    # gitignored secrets/DB survived (proves NO -x at runtime).
+    assert (repo / ".env").read_text() == "ORCH_SECRET=keepme\n"
+    assert (repo / "data" / "orchestrator.db").read_text() == "sqlite-bytes\n"
+    # .git internal + sibling state untouched.
+    assert (repo / ".git" / "worktrees" / "wt1" / "HEAD").is_file()
+    assert (tmp_path / ".deploy-state-orchestrator" / "ORCH-112" / "result").is_file()
+    assert (tmp_path / ".merge-lease-orchestrator.json").is_file()
+
+
+# ===========================================================================
+# TC-04 — happy-path: genuinely clean base -> hygiene no-op + plain fast-forward.
+# Uses prev_running=False so step 1 records NO prev-image, leaving the base clean at
+# the hygiene step (no untracked artefact) — the no-op `else` branch is exercised and
+# the deploy reduces to the plain `git pull` fast-forward (exit-codes byte-for-byte).
+# ===========================================================================
+def test_tc04_clean_base_fast_forwards_no_op_hygiene(tmp_path):
+    repo = _seed_origin_and_clone(tmp_path)  # repo is CLEAN, just behind origin
+
+    proc = _run_hook(repo, tmp_path, hygiene="1", prev_running=False)
+
+    assert proc.returncode == 0, f"{proc.stdout}\n{proc.stderr}"
+    log = (tmp_path / "state" / "hook.log").read_text(encoding="utf-8")
+    assert "deploy-base already clean (no-op)" in log
+    assert "dirty deploy-base detected" not in log
+    # Plain fast-forward brought origin/main's V2.
+    assert _head_config(repo) == _V2
+
+
+# ===========================================================================
+# TC-07 — convergence after cancel/failed: leftovers cleared, next deploy clean
+# ===========================================================================
+def test_tc07_convergence_then_next_deploy_is_clean(tmp_path):
+    repo = _seed_origin_and_clone(tmp_path)
+    # Leftovers from a failed/cancelled task: dirty tracked + untracked WIP.
+    _write(str(repo / "src" / "config.py"), _DIRTY)
+    _write(str(repo / "tests" / "test_install_lite.py"), "# wip\n")
+
+    first = _run_hook(repo, tmp_path, hygiene="1")
+    assert first.returncode == 0, f"{first.stdout}\n{first.stderr}"
+    assert _wip_dirt(repo) == ""  # base converged, no WIP residue
+    assert _head_config(repo) == _V2
+
+    # A subsequent self-deploy proceeds without manual intervention (no WIP to block it).
+    second = _run_hook(repo, tmp_path, hygiene="1")
+    assert second.returncode == 0, f"{second.stdout}\n{second.stderr}"
+    assert _wip_dirt(repo) == ""
+
+
+# ===========================================================================
+# TC-05 — self-hosting safety + static hook safety contract (never -x / excludes)
+# ===========================================================================
+def _hook_code_lines():
+    """Non-comment, non-blank lines of the hook (so a comment mentioning `-x` or
+    `exit` for documentation does not trip the static safety asserts)."""
+    out = []
+    for ln in open(HOOK, encoding="utf-8").read().splitlines():
+        s = ln.strip()
+        if not s or s.startswith("#"):
+            continue
+        out.append(ln)
+    return out
+
+
+def test_tc05_hook_clean_is_never_destructive():
+    text = open(HOOK, encoding="utf-8").read()
+    code = "\n".join(_hook_code_lines())
+    assert "CHECKOUT_HYGIENE" in text, "hygiene block must exist in the hook"
+    # INV-HYGIENE-1: the hook's only `git clean` is `-fd`, NEVER `-x` (which would
+    # delete gitignored .env / data/*.db / build/). Checked against CODE only.
+    assert "git clean -fd" in code
+    assert "-x" not in code  # no -x / -xfd / -fdx in any executable line
+    # INV-HYGIENE-2: explicit excludes for the untracked-but-not-ignored artefacts.
+    assert "-e '.deploy-prev-image-*'" in code
+    assert "-e 'deploy-hook.log'" in code
+    # Converge to the authoritative remote, never a local guess.
+    assert "git reset --hard origin/main" in code
+    # Self-hosting safety: the hygiene path never pushes/force-pushes the remote.
+    assert "push --force" not in code and "push -f " not in code
+
+
+def test_tc05_leaf_is_a_pure_leaf():
+    """checkout_hygiene must not import stage_engine / launcher at module load."""
+    src = open(os.path.join(ROOT, "src", "checkout_hygiene.py"), encoding="utf-8").read()
+    import_lines = [
+        ln for ln in src.splitlines()
+        if ln.startswith("import ") or ln.startswith("from ")
+    ]
+    joined = "\n".join(import_lines)
+    assert "stage_engine" not in joined
+    assert "launcher" not in joined
+
+
+# ===========================================================================
+# TC-06 — kill-switch + repo scope (applies / hook_env)
+# ===========================================================================
+def test_tc06_kill_switch_off_is_inert(monkeypatch):
+    from src.config import settings
+    monkeypatch.setattr(settings, "checkout_hygiene_enabled", False)
+    assert checkout_hygiene.applies("orchestrator") is False
+    assert checkout_hygiene.hook_env("orchestrator", "ORCH-112") == ""
+
+
+def test_tc06_empty_csv_is_self_hosting_only(monkeypatch):
+    from src.config import settings
+    monkeypatch.setattr(settings, "checkout_hygiene_enabled", True)
+    monkeypatch.setattr(settings, "checkout_hygiene_repos", "")
+    assert checkout_hygiene.applies("orchestrator") is True
+    assert checkout_hygiene.applies("enduro-trails") is False
+    env = checkout_hygiene.hook_env("orchestrator", "ORCH-112")
+    assert env.startswith("CHECKOUT_HYGIENE=1 ")
+    assert "HYGIENE_REPORT=" in env
+    # A non-self repo gets no hygiene env (other repos unaffected).
+    assert checkout_hygiene.hook_env("enduro-trails", "ET-1") == ""
+
+
+def test_tc06_csv_scope_limits_repos(monkeypatch):
+    from src.config import settings
+    monkeypatch.setattr(settings, "checkout_hygiene_enabled", True)
+    monkeypatch.setattr(settings, "checkout_hygiene_repos", "alpha, beta")
+    assert checkout_hygiene.applies("alpha") is True
+    assert checkout_hygiene.applies("beta") is True
+    assert checkout_hygiene.applies("orchestrator") is False
+
+
+# ===========================================================================
+# TC-08 — observability: read_report / alert_dirty never-raise
+# ===========================================================================
+def test_tc08_read_report_none_when_absent(monkeypatch, tmp_path):
+    from src.config import settings
+    monkeypatch.setattr(settings, "repos_dir", str(tmp_path))
+    assert checkout_hygiene.read_report("orchestrator", "ORCH-112") is None
+
+
+def test_tc08_read_report_parses_dirty_sentinel(monkeypatch, tmp_path):
+    from src import self_deploy
+    from src.config import settings
+    monkeypatch.setattr(settings, "repos_dir", str(tmp_path))
+    d = self_deploy.container_state_dir("orchestrator", "ORCH-112")
+    os.makedirs(d, exist_ok=True)
+    _write(os.path.join(d, "hygiene"), "dirty=1\n M src/config.py\n?? scripts/x.py\n")
+    rep = checkout_hygiene.read_report("orchestrator", "ORCH-112")
+    assert rep == {"dirty": True, "paths": ["M src/config.py", "?? scripts/x.py"]}
+
+
+def test_tc08_alert_dirty_never_raises_on_send_failure(monkeypatch):
+    import src.notifications as notifications
+
+    def boom(*a, **k):
+        raise RuntimeError("telegram down")
+
+    monkeypatch.setattr(notifications, "send_telegram", boom)
+    # Must swallow the error (best-effort) and NOT crash the finalizer.
+    assert checkout_hygiene.alert_dirty(
+        "orchestrator", "ORCH-112", {"dirty": True, "paths": ["x"]}
+    ) is False
+    # No report / not dirty -> no alert, no raise.
+    assert checkout_hygiene.alert_dirty("orchestrator", "ORCH-112", None) is False
+
+
+# ===========================================================================
+# TC-09 — pipeline invariant: STAGE_TRANSITIONS / QG_CHECKS / exit-codes untouched
+# ===========================================================================
+def test_tc09_pipeline_contracts_untouched():
+    from src import stages
+    from src.qg import checks
+    # The hygiene feature is NOT a stage and NOT a QG check.
+    assert "checkout_hygiene" not in {
+        k for tr in stages.STAGE_TRANSITIONS.values() for k in (tr if isinstance(tr, dict) else {})
+    }
+    assert not any("hygiene" in name for name in checks.QG_CHECKS)
+
+
+def test_tc09_hook_exit_code_contract_intact():
+    text = open(HOOK, encoding="utf-8").read()
+    # The hook still maps to the 0/1/2 contract (ORCH-036).
+    assert "exit 0" in text and "exit 1" in text and "exit 2" in text
+    # The hygiene block itself never emits an `exit` statement (best-effort,
+    # never-break). Inspect only the CODE lines of the 2a block (a comment that
+    # mentions "exit-codes" must not trip this).
+    block = text.split("# 2a.", 1)[1].split("# 2.", 1)[0]
+    code_lines = [
+        ln for ln in block.splitlines()
+        if ln.strip() and not ln.strip().startswith("#")
+    ]
+    for ln in code_lines:
+        assert not ln.strip().startswith("exit"), (
+            f"hygiene block must never change the hook exit-code: {ln!r}"
+        )
+
+
+# ===========================================================================
+# TC-10 — documentation invariant (golden source)
+# ===========================================================================
+def test_tc10_docs_state_deploy_base_invariant():
+    infra = open(os.path.join(ROOT, "docs", "operations", "INFRA.md"), encoding="utf-8").read()
+    readme = open(os.path.join(ROOT, "docs", "architecture", "README.md"), encoding="utf-8").read()
+    for doc in (infra, readme):
+        assert "ORCH-112" in doc
+        assert "deploy/worktree-management база" in doc
+        assert "workspace" in doc

tests/test_merge_gate.py

@@ -203,10 +203,16 @@ def fake_worktree(tmp_path, monkeypatch):
     return str(wt)
 
 
+# ORCH-110: retest_branch now runs the suite via proc_group.run_in_process_group
+# (tree-kill on timeout). The seam is mocked with a ProcResult; the RETURN contract
+# is byte-for-byte the prior one.
+from src.proc_group import ProcResult  # noqa: E402
+
+
 def test_tc07_retest_green(fake_worktree, monkeypatch):
     monkeypatch.setattr(
-        merge_gate.subprocess, "run",
-        lambda *a, **k: subprocess.CompletedProcess(a, 0, "1 passed", ""),
+        merge_gate, "run_in_process_group",
+        lambda *a, **k: ProcResult(returncode=0, stdout="1 passed", stderr="", timed_out=False),
     )
     ok, reason = merge_gate.retest_branch("orchestrator", "feature/x")
     assert ok is True
@@ -215,9 +221,11 @@ def test_tc07_retest_green(fake_worktree, monkeypatch):
 
 def test_tc08_retest_red_with_tail(fake_worktree, monkeypatch):
     monkeypatch.setattr(
-        merge_gate.subprocess, "run",
-        lambda *a, **k: subprocess.CompletedProcess(
-            a, 1, "FAILED tests/test_x.py::t - AssertionError\n1 failed", ""
+        merge_gate, "run_in_process_group",
+        lambda *a, **k: ProcResult(
+            returncode=1,
+            stdout="FAILED tests/test_x.py::t - AssertionError\n1 failed",
+            stderr="", timed_out=False,
         ),
     )
     ok, reason = merge_gate.retest_branch("orchestrator", "feature/x")
@@ -227,11 +235,11 @@ def test_tc08_retest_red_with_tail(fake_worktree, monkeypatch):
 
 
 def test_tc09_retest_timeout(fake_worktree, monkeypatch):
-    def _boom(*a, **k):
-        raise subprocess.TimeoutExpired(cmd="pytest", timeout=1)
-
     monkeypatch.setattr(merge_gate.settings, "merge_retest_timeout_s", 1)
-    monkeypatch.setattr(merge_gate.subprocess, "run", _boom)
+    monkeypatch.setattr(
+        merge_gate, "run_in_process_group",
+        lambda *a, **k: ProcResult(returncode=None, stdout="", stderr="", timed_out=True),
+    )
     ok, reason = merge_gate.retest_branch("orchestrator", "feature/x")
     assert ok is False
     assert "re-test timeout" in reason

tests/test_orch110_budget_invariants.py

@@ -0,0 +1,82 @@
+"""ORCH-110 TC-08: re-test budget validation + cross-invariants (D5).
+
+Covers FR-3 / AC-5 / NFR-6:
+  * ``_resolve_retest_timeout`` validates the config (malformed / non-positive ->
+    safe default 900 + WARNING; never reaches subprocess);
+  * the budget was bumped 600 -> 900;
+  * the cross-invariant ``reaper_max_running_s > Σ(deploy-staging gate-work) + grace``
+    (ORCH-065/109) still holds with the new 900s re-test budget — WITHOUT raising
+    ``reaper_max_running_s``.
+"""
+import os
+import tempfile
+
+os.environ.setdefault("ORCH_DB_PATH", os.path.join(tempfile.gettempdir(), "test_orch110_budget.db"))
+os.environ.setdefault("ORCH_GITEA_TOKEN", "test-token")
+os.environ.setdefault("ORCH_PLANE_API_TOKEN", "test-token")
+
+import pytest  # noqa: E402
+
+from src import merge_gate  # noqa: E402
+from src.config import Settings, settings  # noqa: E402
+
+
+# ---------------------------------------------------------------------------
+# _resolve_retest_timeout — validation (never-break).
+# ---------------------------------------------------------------------------
+def test_tc08_resolve_uses_positive_config(monkeypatch):
+    monkeypatch.setattr(merge_gate.settings, "merge_retest_timeout_s", 1234, raising=False)
+    assert merge_gate._resolve_retest_timeout() == 1234
+
+
+@pytest.mark.parametrize("bad", [0, -5, "abc", None, 3.0])
+def test_tc08_resolve_bad_config_falls_back_to_default(monkeypatch, bad):
+    monkeypatch.setattr(merge_gate.settings, "merge_retest_timeout_s", bad, raising=False)
+    # 3.0 is a valid positive int(3) -> stays 3; everything else -> 900 default.
+    out = merge_gate._resolve_retest_timeout()
+    if bad == 3.0:
+        assert out == 3
+    else:
+        assert out == 900
+
+
+def test_tc08_default_budget_bumped_to_900():
+    """D5: the shipped default budget is 900 (raised from 600)."""
+    assert Settings().merge_retest_timeout_s == 900
+
+
+# ---------------------------------------------------------------------------
+# Cross-invariant: reaper backstop covers the worst-case deploy-staging gate-work.
+# ---------------------------------------------------------------------------
+def test_tc08_reaper_covers_deploy_staging_worstcase():
+    """ORCH-065/109 invariant with the new 900s re-test budget (ADR D5 table)."""
+    s = Settings()
+    # Worst-case sum of work charged to a deploy-staging-deployer job (ADR D5).
+    security = 120
+    rebase = 120
+    image = 600
+    worst = (
+        s.agent_timeout_seconds          # deployer agent (1800)
+        + security
+        + rebase
+        + s.merge_retest_timeout_s       # re-test (900, new)
+        + s.coverage_run_timeout_s       # coverage (900)
+        + image
+        + s.agent_kill_grace_seconds     # grace (20)
+    )
+    assert worst <= 4460  # matches the ADR D5 table
+    assert s.reaper_max_running_s > worst, (
+        f"reaper_max_running_s={s.reaper_max_running_s} must exceed "
+        f"deploy-staging worst-case {worst}"
+    )
+
+
+def test_tc08_reaper_still_covers_max_agent_timeout():
+    """ORCH-065/109: reaper_max_running_s > max(agent timeout) + grace (unchanged)."""
+    s = Settings()
+    assert s.reaper_max_running_s > s.agent_timeout_developer_s + s.agent_kill_grace_seconds
+
+
+def test_tc08_reaper_max_running_s_unchanged():
+    """D5 must NOT change reaper_max_running_s (stays 5400 from ORCH-109)."""
+    assert settings.reaper_max_running_s == 5400

tests/test_orch110_false_rollback_regression.py

@@ -0,0 +1,213 @@
+"""ORCH-110 TC-10: regression of the ORCH-109 / PR #129 incident.
+
+Incident: tester PASS + green CI + the branch not-behind, but the merge-gate local
+re-test blew its wall-clock budget under CPU starvation -> ``check_branch_mergeable``
+returned ``(False, "re-test timeout ...")`` -> the engine routed it to
+``_handle_merge_gate_rollback`` (rollback deploy-staging -> development + a developer
+retry) -> every retry timed out the same way -> "Merge-gate still failing after 3
+developer retries" -> a stuck task needing manual intervention.
+
+This drives the REAL ``check_branch_mergeable`` through ``advance_stage`` (only the
+git/test primitives are mocked) and asserts the incident can no longer happen:
+
+  * Scenario A (D4) — a not-behind branch (no-op rebase) on a green-CI HEAD: the
+    local re-test is SKIPPED entirely -> the gate passes -> advance to deploy.
+  * Scenario B (D3) — a real catch-up whose re-test times out: a bounded infra-retry
+    (task stays on deploy-staging), NEVER a rollback to development and NEVER the
+    "Merge-gate still failing after N developer retries" alert.
+
+RED-before / GREEN-after: on pre-ORCH-110 code both scenarios would roll the task
+back to development (Scenario A would even run the doomed re-test), so the
+``rolled_back_to is None`` / ``stage == deploy-staging`` assertions below would FAIL.
+"""
+import os
+import tempfile
+
+import pytest
+
+_test_db = os.path.join(tempfile.gettempdir(), "test_orch110_regression.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  # noqa: E402
+from src import stage_engine  # noqa: E402
+from src import merge_gate  # noqa: E402
+from src.qg import checks as qg  # noqa: E402
+from src.stage_engine import advance_stage  # noqa: E402
+
+_REPO = "orchestrator"
+_WI = "ORCH-110"
+_BRANCH = "feature/ORCH-110-x"
+
+
+@pytest.fixture(autouse=True)
+def fresh_db(monkeypatch):
+    monkeypatch.setattr(_db.settings, "db_path", _test_db)
+    if os.path.exists(_test_db):
+        os.unlink(_test_db)
+    init_db()
+    yield
+
+
+@pytest.fixture(autouse=True)
+def silence(monkeypatch):
+    for name in (
+        "notify_stage_change", "notify_qg_failure", "send_telegram",
+        "plane_notify_stage", "plane_notify_qg", "plane_add_comment",
+        "set_issue_in_progress", "set_issue_blocked", "notify_approve_requested",
+        "set_issue_in_review", "set_issue_needs_input",
+    ):
+        monkeypatch.setattr(stage_engine, name, MagicMock())
+    # Keep the merge-gate the only intervening sub-gate on the edge; no Phase A.
+    monkeypatch.setattr(stage_engine.settings, "deploy_require_manual_approve", False)
+    # Real gate scope: orchestrator self-hosting.
+    monkeypatch.setattr(qg.settings, "merge_gate_enabled", True, raising=False)
+    monkeypatch.setattr(qg.settings, "merge_gate_repos", "", raising=False)
+    monkeypatch.setattr(qg.settings, "premerge_rebase_always", True, raising=False)
+    monkeypatch.setattr(qg.settings, "merge_retest_skip_when_current_enabled", True, raising=False)
+    monkeypatch.setattr(stage_engine.settings, "merge_retest_infra_tolerance_enabled", True)
+    monkeypatch.setattr(stage_engine.settings, "merge_retest_infra_max_retries", 2)
+    monkeypatch.setattr(stage_engine.settings, "merge_retest_infra_retry_delay_s", 120)
+
+
+def _pass(*a, **k):
+    return (True, "ok")
+
+
+def _patch_edge_gates_except_merge(monkeypatch):
+    """All edge gates pass EXCEPT check_branch_mergeable, which stays the REAL one."""
+    patched = {**stage_engine.QG_CHECKS}
+    patched["check_staging_status"] = _pass
+    patched["check_security_gate"] = _pass
+    patched["check_coverage_gate"] = _pass
+    patched["check_staging_image_fresh"] = _pass
+    monkeypatch.setattr(stage_engine, "QG_CHECKS", patched)
+
+
+def _mock_merge_primitives(monkeypatch, *, head_shas, retest_result, retest_calls):
+    """Mock the git/test primitives the real check_branch_mergeable composes."""
+    monkeypatch.setattr(merge_gate, "acquire_merge_lease", lambda *a, **k: (True, "lease acquired"))
+    monkeypatch.setattr(merge_gate, "release_merge_lease", lambda *a, **k: None)
+    monkeypatch.setattr(merge_gate, "branch_is_behind_main", lambda r, b: True)
+    monkeypatch.setattr(merge_gate, "auto_rebase_onto_main", lambda r, b: (True, "rebased onto origin/main"))
+
+    shas = list(head_shas)
+
+    def _head_sha(r, b):
+        return shas.pop(0) if shas else ""
+
+    monkeypatch.setattr(merge_gate, "head_sha", _head_sha)
+
+    def _retest(r, b):
+        retest_calls.append((r, b))
+        return retest_result
+
+    monkeypatch.setattr(merge_gate, "retest_branch", _retest)
+
+
+def _make_task():
+    conn = get_db()
+    cur = conn.execute(
+        "INSERT INTO tasks (plane_id, work_item_id, repo, branch, stage) VALUES (?,?,?,?,?)",
+        (f"plane-{_WI}", _WI, _REPO, _BRANCH, "deploy-staging"),
+    )
+    tid = cur.lastrowid
+    conn.commit()
+    conn.close()
+    return tid
+
+
+def _stage(task_id):
+    conn = get_db()
+    row = conn.execute("SELECT stage FROM tasks WHERE id=?", (task_id,)).fetchone()
+    conn.close()
+    return row[0]
+
+
+def _agents():
+    conn = get_db()
+    rows = conn.execute("SELECT agent FROM jobs ORDER BY id").fetchall()
+    conn.close()
+    return [r[0] for r in rows]
+
+
+def _advance(task_id):
+    return advance_stage(task_id, "deploy-staging", _REPO, _WI, _BRANCH, finished_agent="deployer")
+
+
+# ---------------------------------------------------------------------------
+# Scenario A (D4): the literal incident — not-behind branch, green CI HEAD.
+# The re-test is SKIPPED, so the timeout can never happen; advance to deploy.
+# ---------------------------------------------------------------------------
+def test_tc10_incident_noop_rebase_skips_retest_and_advances(monkeypatch):
+    _patch_edge_gates_except_merge(monkeypatch)
+    retest_calls = []
+    # Same SHA before/after rebase -> proven no-op. retest is rigged to TIME OUT if
+    # it were (wrongly) called — proving the skip is what avoids the false rollback.
+    _mock_merge_primitives(
+        monkeypatch,
+        head_shas=["abc123", "abc123"],
+        retest_result=(False, "re-test timeout after 900s"),
+        retest_calls=retest_calls,
+    )
+    task_id = _make_task()
+    res = _advance(task_id)
+
+    assert retest_calls == [], "re-test must be SKIPPED on a no-op rebase (D4)"
+    assert res.rolled_back_to is None              # the incident's false rollback is gone
+    assert res.advanced is True
+    assert res.to_stage == "deploy"
+    assert _stage(task_id) == "deploy"
+    assert "developer" not in _agents()           # no developer-retry burned
+    assert stage_engine.set_issue_blocked.called is False
+
+
+# ---------------------------------------------------------------------------
+# Scenario B (D3): a real catch-up whose re-test times out -> infra-retry, not
+# rollback, and never the "still failing after N retries" manual gate.
+# ---------------------------------------------------------------------------
+def test_tc10_real_catchup_retest_timeout_infra_retries_not_rollback(monkeypatch):
+    _patch_edge_gates_except_merge(monkeypatch)
+    retest_calls = []
+    # HEAD moved (real catch-up) -> re-test runs -> times out.
+    _mock_merge_primitives(
+        monkeypatch,
+        head_shas=["old111", "new222"],
+        retest_result=(False, "re-test timeout after 900s"),
+        retest_calls=retest_calls,
+    )
+    task_id = _make_task()
+    res = _advance(task_id)
+
+    assert retest_calls, "re-test SHOULD run on a real (HEAD-moving) catch-up"
+    assert res.rolled_back_to is None              # NOT the code-fault rollback
+    assert res.note == "merge-gate-infra-retry"
+    assert _stage(task_id) == "deploy-staging"     # stays put for a bounded retry
+    assert _agents() == ["deployer"]               # staging-deployer re-queued, NOT developer
+    assert stage_engine.set_issue_blocked.called is False
+    # The "Merge-gate still failing after N developer retries" manual gate never fires.
+    for call in stage_engine.send_telegram.call_args_list:
+        assert "developer retries" not in call[0][0]
+
+
+def test_tc10_real_catchup_red_retest_still_rolls_back(monkeypatch):
+    """Anti-over-tolerance guard inside the incident scenario: a genuinely RED
+    re-test on a real catch-up STILL rolls back (BR-6 / AC-3)."""
+    _patch_edge_gates_except_merge(monkeypatch)
+    retest_calls = []
+    _mock_merge_primitives(
+        monkeypatch,
+        head_shas=["old111", "new222"],
+        retest_result=(False, "re-test failed: ...1 failed"),
+        retest_calls=retest_calls,
+    )
+    task_id = _make_task()
+    res = _advance(task_id)
+    assert res.rolled_back_to == "development"
+    assert _stage(task_id) == "development"
+    assert _agents() == ["developer"]

tests/test_orch110_killswitch.py

@@ -0,0 +1,103 @@
+"""ORCH-110 TC-07: kill-switches + non-self repo => byte-for-byte pre-ORCH-110.
+
+Covers NFR-2 / FR-5 / AC-7. Each ORCH-110 behaviour is an INDEPENDENT kill-switch;
+with a flag off the affected path reverts to the prior behaviour. A non-self-hosting
+repo (enduro-trails) never reaches the infra-retry / tree-kill paths at all (the
+merge-gate is N/A for it).
+"""
+import os
+import tempfile
+
+os.environ.setdefault("ORCH_DB_PATH", os.path.join(tempfile.gettempdir(), "test_orch110_killswitch.db"))
+os.environ.setdefault("ORCH_REPOS_DIR", tempfile.gettempdir())
+os.environ.setdefault("ORCH_GITEA_TOKEN", "test-token")
+os.environ.setdefault("ORCH_PLANE_API_TOKEN", "test-token")
+
+import pytest  # noqa: E402
+
+from src import merge_gate  # noqa: E402
+from src.qg import checks as qg  # noqa: E402
+from src.proc_group import ProcResult  # noqa: E402
+
+_REPO = "orchestrator"
+_BRANCH = "feature/ORCH-110-x"
+_WI = "ORCH-110"
+
+
+# ---------------------------------------------------------------------------
+# D1 kill-switch: subprocess_tree_kill_enabled=False -> the fallback path.
+# ---------------------------------------------------------------------------
+def test_tc07_tree_kill_off_passes_tree_kill_false(tmp_path, monkeypatch):
+    wt = tmp_path / "wt"
+    wt.mkdir()
+    monkeypatch.setattr(merge_gate, "get_worktree_path", lambda r, b: str(wt))
+    monkeypatch.setattr(merge_gate.settings, "subprocess_tree_kill_enabled", False, raising=False)
+    captured = {}
+
+    def _fake(cmd, *, cwd, timeout, env=None, grace_s=5.0, tree_kill=True):
+        captured["tree_kill"] = tree_kill
+        return ProcResult(returncode=0, stdout="1 passed", stderr="", timed_out=False)
+
+    monkeypatch.setattr(merge_gate, "run_in_process_group", _fake)
+    ok, reason = merge_gate.retest_branch(_REPO, _BRANCH)
+    assert ok is True and reason == "re-test green"
+    assert captured["tree_kill"] is False  # -> run_in_process_group degrades to subprocess.run
+
+
+# ---------------------------------------------------------------------------
+# D4 kill-switch: merge_retest_skip_when_current_enabled=False -> always re-test
+# after a rebase (even a proven no-op).
+# ---------------------------------------------------------------------------
+@pytest.fixture
+def gate_primitives(monkeypatch):
+    calls = {"retest": 0}
+    monkeypatch.setattr(qg.settings, "merge_gate_enabled", True, raising=False)
+    monkeypatch.setattr(qg.settings, "merge_gate_repos", "", raising=False)
+    monkeypatch.setattr(qg.settings, "premerge_rebase_always", True, raising=False)
+    monkeypatch.setattr(merge_gate, "acquire_merge_lease", lambda *a, **k: (True, "lease acquired"), raising=False)
+    monkeypatch.setattr(merge_gate, "branch_is_behind_main", lambda r, b: True, raising=False)
+    monkeypatch.setattr(merge_gate, "auto_rebase_onto_main", lambda r, b: (True, "rebased"), raising=False)
+    monkeypatch.setattr(merge_gate, "release_merge_lease", lambda *a, **k: None, raising=False)
+    # A PROVEN no-op rebase: HEAD is identical before/after.
+    monkeypatch.setattr(merge_gate, "head_sha", lambda r, b: "deadbeefcafe", raising=False)
+
+    def _retest(r, b):
+        calls["retest"] += 1
+        return True, "re-test green"
+
+    monkeypatch.setattr(merge_gate, "retest_branch", _retest, raising=False)
+    return calls
+
+
+def test_tc07_skip_when_current_off_always_retests(gate_primitives, monkeypatch):
+    monkeypatch.setattr(qg.settings, "merge_retest_skip_when_current_enabled", False, raising=False)
+    ok, reason = qg.check_branch_mergeable(_REPO, _WI, _BRANCH)
+    assert ok is True
+    assert reason == "rebased onto main, re-test green"
+    assert gate_primitives["retest"] == 1  # re-test STILL runs (D4 off)
+
+
+def test_tc07_skip_when_current_on_skips_noop_retest(gate_primitives, monkeypatch):
+    """Mirror sanity: with the flag ON, the proven no-op rebase skips the re-test."""
+    monkeypatch.setattr(qg.settings, "merge_retest_skip_when_current_enabled", True, raising=False)
+    ok, reason = qg.check_branch_mergeable(_REPO, _WI, _BRANCH)
+    assert ok is True
+    assert "re-test skipped" in reason
+    assert gate_primitives["retest"] == 0  # re-test NOT run on the no-op
+
+
+# ---------------------------------------------------------------------------
+# Non-self repo (enduro-trails): the merge-gate is N/A -> never the new paths.
+# ---------------------------------------------------------------------------
+def test_tc07_non_self_repo_is_noop(monkeypatch):
+    monkeypatch.setattr(qg.settings, "merge_gate_enabled", True, raising=False)
+    monkeypatch.setattr(qg.settings, "merge_gate_repos", "", raising=False)
+    # Guard: if the gate wrongly engaged it would touch the lease -> fail loudly.
+    monkeypatch.setattr(
+        merge_gate, "acquire_merge_lease",
+        lambda *a, **k: pytest.fail("merge-gate must be N/A for enduro-trails"),
+        raising=False,
+    )
+    ok, reason = qg.check_branch_mergeable("enduro-trails", "ET-1", "feature/ET-1-x")
+    assert ok is True
+    assert "N/A" in reason

tests/test_orch110_merge_gate_classify.py

@@ -0,0 +1,64 @@
+"""ORCH-110 TC-03: classify_retest_failure distinguishes infra-timeout from red.
+
+Covers D2 (FR-1 / AC-2): the pure predicate that lets the engine route an INFRA
+re-test timeout differently from a deterministically RED re-test, WITHOUT changing
+the name / PASS-FAIL semantics of the registered ``check_branch_mergeable``.
+
+The critical scope guard: an ``auto_rebase_onto_main`` "rebase timeout" is a
+DIFFERENT timeout (git hung) and must NOT be classified as the infra-tolerated
+re-test timeout (it stays on the rollback path).
+"""
+import os
+import tempfile
+
+os.environ.setdefault("ORCH_DB_PATH", os.path.join(tempfile.gettempdir(), "test_orch110_classify.db"))
+os.environ.setdefault("ORCH_GITEA_TOKEN", "test-token")
+os.environ.setdefault("ORCH_PLANE_API_TOKEN", "test-token")
+
+import pytest  # noqa: E402
+
+from src import merge_gate  # noqa: E402
+
+classify = merge_gate.classify_retest_failure
+
+
+@pytest.mark.parametrize(
+    "reason,expected",
+    [
+        ("re-test timeout after 900s", "timeout"),
+        ("re-test timeout after 600s", "timeout"),
+        ("re-test failed after rebase: 1 failed, 5 passed", "red"),
+        ("re-test failed: ...AssertionError\n1 failed", "red"),
+        ("merge-lock busy", "lock-busy"),
+        ("rebase conflict: src/db.py", "other"),
+        # SCOPE GUARD: a git "rebase timeout" is NOT the infra-tolerated re-test
+        # timeout — it must stay on the rollback path (ADR D2).
+        ("rebase timeout", "other"),
+        ("push --force-with-lease failed: ...", "other"),
+        ("", "other"),
+    ],
+)
+def test_tc03_classify_reasons(reason, expected):
+    assert classify(reason) == expected
+
+
+def test_tc03_classify_never_raises_on_bad_input():
+    # None / non-str must degrade to the safe "other" (-> rollback), never raise.
+    assert classify(None) == "other"
+    assert classify(12345) == "other"
+
+
+def test_tc03_case_insensitive():
+    assert classify("RE-TEST TIMEOUT AFTER 900S") == "timeout"
+    assert classify("Merge-Lock Busy") == "lock-busy"
+
+
+def test_tc03_distinct_from_lock_busy_and_conflict():
+    """timeout is a distinct class from the existing defer (lock-busy) and rollback
+    (conflict) reasons — the three must never collide."""
+    classes = {
+        classify("re-test timeout after 900s"),
+        classify("merge-lock busy"),
+        classify("rebase conflict: x"),
+    }
+    assert classes == {"timeout", "lock-busy", "other"}

tests/test_orch110_merge_gate_routing.py

@@ -0,0 +1,261 @@
+"""ORCH-110 TC-04 / TC-05 / TC-06 / TC-09: merge-gate infra-timeout routing.
+
+Drives the engine (``stage_engine.advance_stage``) on the deploy-staging -> deploy
+edge with ``check_branch_mergeable`` monkeypatched, exactly like the existing
+``test_stage_engine.TestMergeGate`` suite, and asserts the NEW routing (D3):
+
+  * TC-04 — an INFRA re-test timeout -> bounded infra-retry (re-queue the
+    staging-deployer with a delay, task STAYS on deploy-staging) — NOT a rollback to
+    development and NOT a developer-retry.
+  * TC-05 — a deterministically RED re-test STILL rolls back to development +
+    developer retry (BR-6 / AC-3 anti-over-tolerance).
+  * TC-06 — the infra-retry is bounded (anti-loop): after the budget it blocks with
+    ONE infra-alert, no infinite bounce, no new job, task NOT in development.
+  * TC-09 — never-raise: an error in the transient path is swallowed (a WARNING) and
+    never escapes into advance_stage.
+
+Offline: isolated sqlite DB; Plane/Telegram/notifications mocked at stage_engine.
+"""
+import os
+import tempfile
+
+import pytest
+
+_test_db = os.path.join(tempfile.gettempdir(), "test_orch110_routing.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  # noqa: E402
+from src import stage_engine  # noqa: E402
+from src.stage_engine import advance_stage  # noqa: E402
+
+_REPO = "orchestrator"
+_WI = "ORCH-110"
+_BRANCH = "feature/ORCH-110-x"
+_TIMEOUT_REASON = "re-test timeout after 900s"
+
+
+@pytest.fixture(autouse=True)
+def fresh_db(monkeypatch):
+    monkeypatch.setattr(_db.settings, "db_path", _test_db)
+    if os.path.exists(_test_db):
+        os.unlink(_test_db)
+    init_db()
+    yield
+
+
+@pytest.fixture(autouse=True)
+def silence_side_effects(monkeypatch):
+    for name in (
+        "notify_stage_change", "notify_qg_failure", "send_telegram",
+        "plane_notify_stage", "plane_notify_qg", "plane_add_comment",
+        "set_issue_in_progress", "set_issue_blocked",
+    ):
+        monkeypatch.setattr(stage_engine, name, MagicMock())
+    # The merge-gate sub-gate runs only AFTER the stage QG + security + coverage pass;
+    # the self-deploy Phase A interception is irrelevant (merge-gate intervenes first).
+    monkeypatch.setattr(stage_engine.settings, "deploy_require_manual_approve", False)
+
+
+@pytest.fixture(autouse=True)
+def tolerance_on(monkeypatch):
+    monkeypatch.setattr(stage_engine.settings, "merge_retest_infra_tolerance_enabled", True)
+    monkeypatch.setattr(stage_engine.settings, "merge_retest_infra_max_retries", 2)
+    monkeypatch.setattr(stage_engine.settings, "merge_retest_infra_retry_delay_s", 120)
+
+
+def _pass(*a, **k):
+    return (True, "ok")
+
+
+def _fail(reason):
+    def _f(*a, **k):
+        return (False, reason)
+    return _f
+
+
+def _patch_gates(monkeypatch, merge_reason):
+    monkeypatch.setattr(
+        stage_engine, "QG_CHECKS",
+        {**stage_engine.QG_CHECKS,
+         "check_staging_status": _pass,
+         "check_security_gate": _pass,
+         "check_coverage_gate": _pass,
+         "check_branch_mergeable": _fail(merge_reason),
+         "check_staging_image_fresh": _pass},
+    )
+
+
+def _make_task(stage="deploy-staging"):
+    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 _stage(task_id):
+    conn = get_db()
+    row = conn.execute("SELECT stage FROM tasks WHERE id=?", (task_id,)).fetchone()
+    conn.close()
+    return row[0]
+
+
+def _jobs():
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT agent, task_content, available_at FROM jobs ORDER BY id"
+    ).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def _seed_infra_retry_jobs(task_id, n):
+    conn = get_db()
+    for _ in range(n):
+        conn.execute(
+            "INSERT INTO jobs (agent, repo, task_id, task_content) "
+            "VALUES ('deployer','orchestrator',?, 'Note: merge-gate infra-timeout retry')",
+            (task_id,),
+        )
+    conn.commit()
+    conn.close()
+
+
+def _advance(task_id):
+    return advance_stage(
+        task_id, "deploy-staging", _REPO, _WI, _BRANCH, finished_agent="deployer"
+    )
+
+
+# ---------------------------------------------------------------------------
+# TC-04 — infra-timeout -> bounded infra-retry, NOT a rollback to development.
+# ---------------------------------------------------------------------------
+def test_tc04_infra_timeout_reschedules_not_rollback(monkeypatch):
+    _patch_gates(monkeypatch, _TIMEOUT_REASON)
+    task_id = _make_task()
+    res = _advance(task_id)
+
+    assert res.advanced is False
+    assert res.rolled_back_to is None             # NOT a code-fault rollback
+    assert res.note == "merge-gate-infra-retry"
+    assert _stage(task_id) == "deploy-staging"    # stays put
+    jobs = _jobs()
+    assert len(jobs) == 1
+    assert jobs[0]["agent"] == "deployer"          # re-queued staging-deployer, NOT developer
+    assert "merge-gate infra-timeout retry" in jobs[0]["task_content"]
+    assert jobs[0]["available_at"] is not None     # delayed re-pickup
+    assert stage_engine.set_issue_blocked.called is False
+    # No developer-retry semantics: the rollback comment / in-progress is never set.
+    assert stage_engine.set_issue_in_progress.called is False
+
+
+def test_tc04_killswitch_within_routing_is_observed(monkeypatch):
+    """The infra-timeout always bumps the timeout counter (observability), even when
+    routed to the retry path."""
+    _patch_gates(monkeypatch, _TIMEOUT_REASON)
+    before = stage_engine.merge_gate.merge_gate_status()["retest_timeout_total"]
+    task_id = _make_task()
+    _advance(task_id)
+    after = stage_engine.merge_gate.merge_gate_status()["retest_timeout_total"]
+    assert after == before + 1
+
+
+# ---------------------------------------------------------------------------
+# TC-05 — a deterministically RED re-test STILL rolls back (BR-6 / AC-3).
+# ---------------------------------------------------------------------------
+def test_tc05_red_retest_still_rolls_back(monkeypatch):
+    _patch_gates(monkeypatch, "re-test failed after rebase: 1 failed, 5 passed")
+    task_id = _make_task()
+    res = _advance(task_id)
+
+    assert res.advanced is False
+    assert res.rolled_back_to == "development"
+    assert _stage(task_id) == "development"
+    jobs = _jobs()
+    assert len(jobs) == 1
+    assert jobs[0]["agent"] == "developer"        # developer re-queued (retry)
+
+
+def test_tc05_conflict_still_rolls_back(monkeypatch):
+    _patch_gates(monkeypatch, "rebase conflict: src/db.py")
+    task_id = _make_task()
+    res = _advance(task_id)
+    assert res.rolled_back_to == "development"
+    assert _stage(task_id) == "development"
+    assert _jobs()[0]["agent"] == "developer"
+
+
+# ---------------------------------------------------------------------------
+# TC-06 — anti-loop: infra-retry is bounded; exhaustion -> ONE infra-alert.
+# ---------------------------------------------------------------------------
+def test_tc06_infra_retry_bounded_then_infra_alert(monkeypatch):
+    monkeypatch.setattr(stage_engine.settings, "merge_retest_infra_max_retries", 2)
+    _patch_gates(monkeypatch, _TIMEOUT_REASON)
+    task_id = _make_task()
+    _seed_infra_retry_jobs(task_id, 2)  # budget already spent
+
+    res = _advance(task_id)
+    assert res.advanced is False
+    assert res.rolled_back_to is None                  # NOT a rollback even at exhaustion
+    assert res.note == "merge-gate-infra-retry-exhausted"
+    assert res.alerted is True
+    assert _stage(task_id) == "deploy-staging"         # NOT moved to development
+    assert stage_engine.set_issue_blocked.called
+    assert stage_engine.send_telegram.called
+    # No NEW retry job past the cap (still only the 2 we seeded).
+    assert len(_jobs()) == 2
+    # The alert is INFRA-specific, not "developer must fix".
+    msg = stage_engine.send_telegram.call_args[0][0]
+    assert "infra" in msg.lower() or "ресурс" in msg.lower()
+    assert "НЕ дефект кода" in msg
+
+
+def test_tc06_below_budget_keeps_retrying(monkeypatch):
+    monkeypatch.setattr(stage_engine.settings, "merge_retest_infra_max_retries", 3)
+    _patch_gates(monkeypatch, _TIMEOUT_REASON)
+    task_id = _make_task()
+    _seed_infra_retry_jobs(task_id, 1)  # one retry already done, budget 3
+
+    res = _advance(task_id)
+    assert res.note == "merge-gate-infra-retry"
+    assert res.alerted is not True
+    # The seeded job + the new retry job.
+    assert len(_jobs()) == 2
+
+
+# ---------------------------------------------------------------------------
+# TC-09 — never-raise: an error in the transient path is swallowed.
+# ---------------------------------------------------------------------------
+def test_tc09_infra_retry_never_raises(monkeypatch):
+    _patch_gates(monkeypatch, _TIMEOUT_REASON)
+
+    def _boom(*a, **k):
+        raise RuntimeError("enqueue exploded")
+
+    monkeypatch.setattr(stage_engine, "enqueue_job", _boom)
+    task_id = _make_task()
+    # Must NOT raise into advance_stage.
+    res = _advance(task_id)
+    assert res.note == "merge-gate-infra-retry-error"
+    assert _stage(task_id) == "deploy-staging"  # left for the reconciler/reaper
+
+
+def test_tc09_killswitch_off_falls_back_to_rollback(monkeypatch):
+    """tolerance off -> a timeout takes the prior rollback path byte-for-byte (NFR-2)."""
+    monkeypatch.setattr(stage_engine.settings, "merge_retest_infra_tolerance_enabled", False)
+    _patch_gates(monkeypatch, _TIMEOUT_REASON)
+    task_id = _make_task()
+    res = _advance(task_id)
+    assert res.rolled_back_to == "development"
+    assert _stage(task_id) == "development"
+    assert _jobs()[0]["agent"] == "developer"

tests/test_orch110_observability.py

@@ -0,0 +1,135 @@
+"""ORCH-110 TC-12: observability of the infra-timeout path (D6 / FR-6 / AC-9).
+
+The infra-timeout state must be (a) reflected in read-only counters, (b) surfaced in
+the additive ``merge_gate`` block of ``GET /queue``, and (c) distinguishable from a
+code-fault rollback — with the exhaustion alert carrying the CLICKABLE issue number
+and an explicitly infrastructural (NOT "developer must fix") wording. No dedup/overlap
+with ORCH-111 (which only OBSERVES surviving processes; ORCH-110 prevents/tolerates).
+"""
+import asyncio
+import os
+import tempfile
+
+_test_db = os.path.join(tempfile.gettempdir(), "test_orch110_observability.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 pytest  # noqa: E402
+
+import src.db as _db  # noqa: E402
+from src.db import init_db, get_db  # noqa: E402
+from src import merge_gate  # noqa: E402
+from src import stage_engine  # noqa: E402
+from src.stage_engine import AdvanceResult  # noqa: E402
+
+
+@pytest.fixture(autouse=True)
+def fresh_db(monkeypatch):
+    monkeypatch.setattr(_db.settings, "db_path", _test_db)
+    if os.path.exists(_test_db):
+        os.unlink(_test_db)
+    init_db()
+    # Reset the in-process counters so each test starts from a known baseline.
+    merge_gate._MERGE_GATE_COUNTERS.update(
+        retest_timeout_total=0, retest_infra_retry_total=0,
+        retest_infra_exhausted_total=0, retest_skipped_current_total=0,
+        last_infra_timeout_wi=None,
+    )
+    yield
+
+
+# ---------------------------------------------------------------------------
+# merge_gate_status() snapshot + counter increments.
+# ---------------------------------------------------------------------------
+def test_tc12_status_exposes_flags_and_counters():
+    snap = merge_gate.merge_gate_status()
+    for key in (
+        "infra_tolerance_enabled", "infra_max_retries", "infra_retry_delay_s",
+        "skip_when_current_enabled", "tree_kill_enabled", "retest_timeout_s",
+        "retest_timeout_total", "retest_infra_retry_total",
+        "retest_infra_exhausted_total", "retest_skipped_current_total",
+        "last_infra_timeout_wi",
+    ):
+        assert key in snap, f"missing /queue merge_gate key: {key}"
+
+
+def test_tc12_counters_track_infra_timeout_distinctly():
+    merge_gate.note_retest_timeout("ORCH-110")
+    merge_gate.note_retest_infra_retry()
+    merge_gate.note_retest_infra_exhausted()
+    merge_gate.note_retest_skipped_current()
+    snap = merge_gate.merge_gate_status()
+    assert snap["retest_timeout_total"] == 1
+    assert snap["retest_infra_retry_total"] == 1
+    assert snap["retest_infra_exhausted_total"] == 1
+    assert snap["retest_skipped_current_total"] == 1
+    # Distinguishable from a code-fault: the last infra-timeout WI is tracked here,
+    # NOT in the merge-verify (code/merge) counters.
+    assert snap["last_infra_timeout_wi"] == "ORCH-110"
+
+
+def test_tc12_status_never_raises(monkeypatch):
+    # A broken settings attribute -> the snapshot degrades, never raises.
+    monkeypatch.delattr(merge_gate.settings, "merge_retest_infra_tolerance_enabled", raising=False)
+    snap = merge_gate.merge_gate_status()
+    assert isinstance(snap, dict)
+
+
+# ---------------------------------------------------------------------------
+# GET /queue carries the additive merge_gate block (and the legacy keys stay).
+# ---------------------------------------------------------------------------
+def test_tc12_queue_endpoint_includes_merge_gate_block():
+    from src.main import queue
+    out = asyncio.run(queue())
+    assert "merge_gate" in out
+    assert "infra_tolerance_enabled" in out["merge_gate"]
+    # The pre-existing observability keys are untouched (additive only).
+    assert "merge_verify" in out and "coverage" in out
+
+
+# ---------------------------------------------------------------------------
+# The exhaustion alert is INFRA-specific + carries the clickable issue number,
+# distinct from the code-fault "Merge-gate still failing after N developer retries".
+# ---------------------------------------------------------------------------
+def test_tc12_exhaustion_alert_is_infra_specific_and_clickable(monkeypatch):
+    sent = {}
+
+    def _tg(msg):
+        sent["msg"] = msg
+
+    monkeypatch.setattr(stage_engine, "send_telegram", _tg)
+    monkeypatch.setattr(stage_engine, "set_issue_blocked", MagicMock())
+    monkeypatch.setattr(stage_engine, "plane_add_comment", MagicMock())
+    # link_for builds the clickable number; use a recognisable sentinel.
+    monkeypatch.setattr(stage_engine, "link_for", lambda wi, **k: f"<a href='x'>{wi}</a>")
+    monkeypatch.setattr(stage_engine.settings, "merge_retest_infra_max_retries", 2)
+
+    # Seed an exhausted budget for the task.
+    conn = get_db()
+    cur = conn.execute(
+        "INSERT INTO tasks (plane_id, work_item_id, repo, branch, stage) VALUES (?,?,?,?,?)",
+        ("plane-ORCH-110", "ORCH-110", "orchestrator", "feature/ORCH-110-x", "deploy-staging"),
+    )
+    task_id = cur.lastrowid
+    for _ in range(2):
+        conn.execute(
+            "INSERT INTO jobs (agent, repo, task_id, task_content) "
+            "VALUES ('deployer','orchestrator',?, 'Note: merge-gate infra-timeout retry')",
+            (task_id,),
+        )
+    conn.commit()
+    conn.close()
+
+    res = AdvanceResult()
+    stage_engine._handle_merge_gate_infra_retry(
+        task_id, "deploy-staging", "orchestrator", "ORCH-110",
+        "feature/ORCH-110-x", "re-test timeout after 900s", res,
+    )
+    assert res.note == "merge-gate-infra-retry-exhausted"
+    assert "ORCH-110" in sent["msg"]                  # clickable issue number present
+    assert "developer retries" not in sent["msg"]     # NOT the code-fault wording
+    assert "НЕ дефект кода" in sent["msg"]             # explicitly infrastructural

tests/test_orch110_retest_contract.py

@@ -0,0 +1,95 @@
+"""ORCH-110 TC-11: the local re-test necessity contract (D4 / FR-4 / AC-6).
+
+The chosen contract: run the local re-test IFF the pre-merge rebase actually moved
+HEAD (``main`` had moved -> a real semantic-conflict risk). When the rebase is a
+PROVEN no-op (HEAD unchanged -> branch already at origin/main, the CI/tester/staging-
+validated commit) the re-test is SKIPPED — it would be a redundant single point of
+false failure. On ANY uncertainty (an empty SHA) the re-test runs (fail-safe -> the
+red-rollback contract BR-6/AC-3 is never weakened).
+"""
+import os
+import tempfile
+
+os.environ.setdefault("ORCH_DB_PATH", os.path.join(tempfile.gettempdir(), "test_orch110_contract.db"))
+os.environ.setdefault("ORCH_REPOS_DIR", tempfile.gettempdir())
+os.environ.setdefault("ORCH_GITEA_TOKEN", "test-token")
+os.environ.setdefault("ORCH_PLANE_API_TOKEN", "test-token")
+
+import pytest  # noqa: E402
+
+from src import merge_gate  # noqa: E402
+from src.qg import checks as qg  # noqa: E402
+
+_REPO = "orchestrator"
+_BRANCH = "feature/ORCH-110-x"
+_WI = "ORCH-110"
+
+
+@pytest.fixture
+def gate(monkeypatch):
+    """Real check_branch_mergeable, mocked primitives; record control flow."""
+    state = {"retest": 0, "released": 0, "rebased": 0}
+    monkeypatch.setattr(qg.settings, "merge_gate_enabled", True, raising=False)
+    monkeypatch.setattr(qg.settings, "merge_gate_repos", "", raising=False)
+    monkeypatch.setattr(qg.settings, "premerge_rebase_always", True, raising=False)
+    monkeypatch.setattr(qg.settings, "merge_retest_skip_when_current_enabled", True, raising=False)
+    monkeypatch.setattr(merge_gate, "acquire_merge_lease", lambda *a, **k: (True, "lease acquired"))
+    monkeypatch.setattr(merge_gate, "branch_is_behind_main", lambda r, b: True)
+
+    def _rebase(r, b):
+        state["rebased"] += 1
+        return True, "rebased onto origin/main"
+
+    def _release(r, b=None):
+        state["released"] += 1
+
+    def _retest(r, b):
+        state["retest"] += 1
+        return True, "re-test green"
+
+    monkeypatch.setattr(merge_gate, "auto_rebase_onto_main", _rebase)
+    monkeypatch.setattr(merge_gate, "release_merge_lease", _release)
+    monkeypatch.setattr(merge_gate, "retest_branch", _retest)
+    return state
+
+
+def _set_head_shas(monkeypatch, shas):
+    seq = list(shas)
+    monkeypatch.setattr(merge_gate, "head_sha", lambda r, b: seq.pop(0) if seq else "")
+
+
+def test_tc11_noop_rebase_skips_retest_lease_held(gate, monkeypatch):
+    """Proven no-op rebase (HEAD unchanged) -> skip re-test, PASS, lease HELD."""
+    _set_head_shas(monkeypatch, ["sha_same", "sha_same"])
+    ok, reason = qg.check_branch_mergeable(_REPO, _WI, _BRANCH)
+    assert ok is True
+    assert "re-test skipped" in reason
+    assert gate["retest"] == 0          # re-test NOT run
+    assert gate["released"] == 0        # lease HELD until the merge
+
+
+def test_tc11_head_moved_runs_retest(gate, monkeypatch):
+    """A real catch-up (HEAD moved) -> re-test RUNS (the ORCH-043 risk is real)."""
+    _set_head_shas(monkeypatch, ["sha_old", "sha_new"])
+    ok, reason = qg.check_branch_mergeable(_REPO, _WI, _BRANCH)
+    assert ok is True
+    assert reason == "rebased onto main, re-test green"
+    assert gate["retest"] == 1
+
+
+@pytest.mark.parametrize("shas", [["", "sha_new"], ["sha_old", ""], ["", ""]])
+def test_tc11_uncertain_sha_runs_retest_failsafe(gate, monkeypatch, shas):
+    """Cannot prove a no-op (empty SHA) -> re-test RUNS (fail-safe, never skips on
+    uncertainty)."""
+    _set_head_shas(monkeypatch, shas)
+    ok, reason = qg.check_branch_mergeable(_REPO, _WI, _BRANCH)
+    assert ok is True
+    assert gate["retest"] == 1          # re-test still runs on uncertainty
+
+
+def test_tc11_skip_bumps_observability_counter(gate, monkeypatch):
+    """The skip increments the read-only observability counter (D6)."""
+    merge_gate._MERGE_GATE_COUNTERS["retest_skipped_current_total"] = 0
+    _set_head_shas(monkeypatch, ["sha_same", "sha_same"])
+    qg.check_branch_mergeable(_REPO, _WI, _BRANCH)
+    assert merge_gate._MERGE_GATE_COUNTERS["retest_skipped_current_total"] == 1

tests/test_orch110_retest_lifecycle.py

@@ -0,0 +1,185 @@
+"""ORCH-110 TC-01 / TC-02: process-group tree-kill of orchestrator-spawned pytest.
+
+Covers D1 (FR-2 / BR-3 / AC-4): a timeout in ``merge_gate.retest_branch`` /
+``coverage_gate.measure_coverage`` must tree-kill the WHOLE subprocess subtree
+(children + grandchildren) — the orphan-leak root cause of the ORCH-109 incident —
+not just the direct child.
+
+Fully deterministic and offline:
+  * TC-01 runs a REAL throwaway process that spawns a long-sleeping grandchild via
+    ``sys.executable`` (always present), then asserts the grandchild is dead after a
+    ``run_in_process_group`` timeout — the concrete "no orphan survives" proof.
+  * TC-01b / TC-02 assert the two call sites delegate to ``run_in_process_group``
+    with the right tree-kill kwargs and map a timed-out ProcResult to their existing
+    contract (``(False, "re-test timeout after <T>s")`` / ``None``).
+No network, no Plane/Gitea, no Claude CLI.
+"""
+import os
+import tempfile
+import time
+
+os.environ.setdefault("ORCH_DB_PATH", os.path.join(tempfile.gettempdir(), "test_orch110_lifecycle.db"))
+os.environ.setdefault("ORCH_REPOS_DIR", tempfile.gettempdir())
+os.environ.setdefault("ORCH_GITEA_TOKEN", "test-token")
+os.environ.setdefault("ORCH_PLANE_API_TOKEN", "test-token")
+
+import sys  # noqa: E402
+
+import pytest  # noqa: E402
+
+from src import coverage_gate as cg  # noqa: E402
+from src import merge_gate  # noqa: E402
+from src import proc_group  # noqa: E402
+from src.proc_group import ProcResult, run_in_process_group  # noqa: E402
+
+_POSIX = hasattr(os, "killpg") and hasattr(os, "setsid")
+
+
+def _alive(pid: int) -> bool:
+    """True iff ``pid`` is a live (non-reaped) process."""
+    try:
+        os.kill(pid, 0)
+        return True
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+
+
+# ---------------------------------------------------------------------------
+# TC-01: real grandchild is tree-killed on timeout (the FR-2 / AC-4 proof).
+# ---------------------------------------------------------------------------
+@pytest.mark.skipif(not _POSIX, reason="process-group tree-kill is POSIX-only")
+def test_tc01_grandchild_orphan_is_tree_killed_on_timeout(tmp_path):
+    pidfile = tmp_path / "grandchild.pid"
+    script = tmp_path / "spawner.py"
+    # The leader spawns a long-sleeping grandchild, records its pid, then sleeps far
+    # past the timeout. A naive subprocess.run(timeout=) would kill ONLY the leader
+    # and leak the grandchild (the ORCH-109 bug). The process-group tree-kill must
+    # reap the grandchild too.
+    script.write_text(
+        "import subprocess, sys, time\n"
+        "gc = subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(120)'])\n"
+        "open(sys.argv[1], 'w').write(str(gc.pid))\n"
+        "time.sleep(120)\n",
+        encoding="utf-8",
+    )
+
+    res = run_in_process_group(
+        [sys.executable, str(script), str(pidfile)],
+        cwd=str(tmp_path), timeout=2, grace_s=1, tree_kill=True,
+    )
+    assert res.timed_out is True
+
+    # Wait for the leader to actually have written the grandchild pid.
+    deadline = time.time() + 5
+    while time.time() < deadline and not pidfile.exists():
+        time.sleep(0.05)
+    assert pidfile.exists(), "spawner never recorded the grandchild pid"
+    gc_pid = int(pidfile.read_text().strip())
+
+    # The grandchild must die (be reaped) within a short window after the tree-kill.
+    deadline = time.time() + 8
+    while time.time() < deadline and _alive(gc_pid):
+        time.sleep(0.1)
+    assert not _alive(gc_pid), "grandchild orphan survived the timeout tree-kill (FR-2/AC-4)"
+
+
+@pytest.mark.skipif(not _POSIX, reason="process-group runner is POSIX-only")
+def test_tc01_green_and_red_returncodes_passthrough(tmp_path):
+    """The runner returns the real exit code on a normal (non-timeout) completion."""
+    ok = run_in_process_group(
+        [sys.executable, "-c", "import sys; sys.exit(0)"],
+        cwd=str(tmp_path), timeout=30, tree_kill=True,
+    )
+    assert ok.timed_out is False and ok.returncode == 0
+    red = run_in_process_group(
+        [sys.executable, "-c", "import sys; sys.exit(3)"],
+        cwd=str(tmp_path), timeout=30, tree_kill=True,
+    )
+    assert red.timed_out is False and red.returncode == 3
+
+
+def test_tc01_fallback_when_tree_kill_disabled(tmp_path, monkeypatch):
+    """tree_kill=False -> degrades to subprocess.run (never-break); still times out."""
+    res = run_in_process_group(
+        [sys.executable, "-c", "import time; time.sleep(30)"],
+        cwd=str(tmp_path), timeout=1, tree_kill=False,
+    )
+    assert res.timed_out is True
+
+
+def test_tc01_fallback_on_non_posix(tmp_path, monkeypatch):
+    """No os.killpg/setsid (non-POSIX) -> the plain subprocess.run fallback runs."""
+    monkeypatch.setattr(proc_group, "_tree_kill_supported", lambda: False)
+    res = run_in_process_group(
+        [sys.executable, "-c", "import sys; sys.exit(0)"],
+        cwd=str(tmp_path), timeout=30,
+    )
+    assert res.timed_out is False and res.returncode == 0
+
+
+# ---------------------------------------------------------------------------
+# TC-01b: retest_branch delegates to the process-group runner with the right
+# kwargs and maps a timeout to its existing contract.
+# ---------------------------------------------------------------------------
+def test_tc01b_retest_branch_uses_process_group_and_maps_timeout(tmp_path, monkeypatch):
+    wt = tmp_path / "wt"
+    wt.mkdir()
+    monkeypatch.setattr(merge_gate, "get_worktree_path", lambda repo, branch: str(wt))
+    monkeypatch.setattr(merge_gate.settings, "merge_retest_timeout_s", 900, raising=False)
+    monkeypatch.setattr(merge_gate.settings, "subprocess_tree_kill_enabled", True, raising=False)
+    monkeypatch.setattr(merge_gate.settings, "agent_kill_grace_seconds", 7, raising=False)
+
+    captured = {}
+
+    def _fake(cmd, *, cwd, timeout, env=None, grace_s=5.0, tree_kill=True):
+        captured.update(cmd=cmd, cwd=cwd, timeout=timeout, grace_s=grace_s, tree_kill=tree_kill)
+        return ProcResult(returncode=None, stdout="", stderr="", timed_out=True)
+
+    monkeypatch.setattr(merge_gate, "run_in_process_group", _fake)
+    ok, reason = merge_gate.retest_branch("orchestrator", "feature/x")
+    assert ok is False
+    assert reason == "re-test timeout after 900s"
+    # FR-2: spawned via the process-group runner with tree-kill + the agent grace.
+    assert captured["tree_kill"] is True
+    assert captured["grace_s"] == 7
+    assert captured["cmd"][:3] == ["python", "-m", "pytest"]
+
+
+# ---------------------------------------------------------------------------
+# TC-02: coverage_gate.measure_coverage — sibling orphan source (BR-3). Timeout
+# tree-kills + returns None; uses the same runner with tree-kill from settings.
+# ---------------------------------------------------------------------------
+def test_tc02_measure_coverage_timeout_tree_kill_returns_none(tmp_path, monkeypatch):
+    monkeypatch.setattr(cg, "ensure_worktree", lambda r, b: str(tmp_path))
+    monkeypatch.setattr(cg.settings, "subprocess_tree_kill_enabled", True, raising=False)
+    monkeypatch.setattr(cg.settings, "agent_kill_grace_seconds", 5, raising=False)
+    monkeypatch.setattr(cg.settings, "coverage_run_timeout_s", 900, raising=False)
+
+    captured = {}
+
+    def _fake(cmd, *, cwd, timeout, env=None, grace_s=5.0, tree_kill=True):
+        captured.update(tree_kill=tree_kill, grace_s=grace_s, timeout=timeout)
+        return ProcResult(returncode=None, stdout="", stderr="", timed_out=True)
+
+    monkeypatch.setattr(cg, "run_in_process_group", _fake)
+    assert cg.measure_coverage("orchestrator", "feature/x") is None
+    assert captured["tree_kill"] is True
+    assert captured["grace_s"] == 5
+    assert captured["timeout"] == 900
+
+
+def test_tc02_measure_coverage_respects_tree_kill_killswitch(tmp_path, monkeypatch):
+    """With the tree-kill kill-switch off, the runner is asked for the fallback path."""
+    monkeypatch.setattr(cg, "ensure_worktree", lambda r, b: str(tmp_path))
+    monkeypatch.setattr(cg.settings, "subprocess_tree_kill_enabled", False, raising=False)
+    captured = {}
+
+    def _fake(cmd, *, cwd, timeout, env=None, grace_s=5.0, tree_kill=True):
+        captured.update(tree_kill=tree_kill)
+        return ProcResult(returncode=None, stdout="", stderr="", timed_out=True)
+
+    monkeypatch.setattr(cg, "run_in_process_group", _fake)
+    assert cg.measure_coverage("orchestrator", "feature/x") is None
+    assert captured["tree_kill"] is False

tests/test_orch113_reaper_finalizer_liveness.py

@@ -0,0 +1,386 @@
+"""ORCH-113 (adr-0043): reaper must not re-run deploy-staging finalization while
+the original finalizer is alive — finalizer-liveness ownership tests (TC-01..TC-08).
+
+Covers the bug from incident ORCH-111 (deployer job 1914): on the
+``deploy-staging -> deploy`` edge the live monitor runs the heavy edge sub-gates
+(security/merge-gate re-test/coverage/image-freshness) in-thread for MINUTES AFTER
+stamping ``agent_runs.finished_at`` and BEFORE ``_finalize_job``. Reaper Tier-2
+measures ``finished_age_s`` from ``finished_at``, so past ``reaper_finalize_grace_s``
+it treated the live, long-finalizing monitor as dead and independently re-ran the
+advance -> a second re-test went red -> false rollback ``deploy-staging ->
+development`` while the original finalizer concurrently merged the PR. State diverged.
+
+The reaper never spawns claude / pytest / docker; we drive the DB directly (a
+'running' jobs row + a linked agent_runs exit_code) and the process-local
+``finalizer_liveness`` marker, then assert the reaper's terminal flip / deferral.
+No network, no subprocess — every external is mocked.
+"""
+import os
+import tempfile
+
+import pytest
+
+# Override env before importing app modules (same convention as test_job_reaper.py).
+os.environ["ORCH_DB_PATH"] = os.path.join(
+    tempfile.gettempdir(), "test_orch113_reaper.db"
+)
+os.environ["ORCH_REPOS_DIR"] = tempfile.gettempdir()
+os.environ["ORCH_GITEA_TOKEN"] = "test-token"
+os.environ["ORCH_PLANE_API_TOKEN"] = "test-token"
+
+import src.db as db
+from src.db import init_db, get_db, get_job
+import src.finalizer_liveness as fl
+import src.job_reaper as jr
+from src.job_reaper import JobReaper
+
+
+@pytest.fixture(autouse=True)
+def fresh_db(tmp_path, monkeypatch):
+    dbfile = tmp_path / "reaper113.db"
+    monkeypatch.setattr(db.settings, "db_path", str(dbfile))
+    init_db()
+    # Each test starts with a clean ownership registry (process-local module state).
+    with fl._LOCK:
+        fl._OWNED.clear()
+    # Default: kill-switch ON (the fix is active) unless a test flips it.
+    monkeypatch.setattr(db.settings, "reaper_finalizer_liveness_enabled", True)
+    yield
+    with fl._LOCK:
+        fl._OWNED.clear()
+
+
+# --- helpers ----------------------------------------------------------------
+def _make_task(repo="orchestrator", branch="feature/orch113",
+               stage="deploy-staging", work_item_id="ORCH-113"):
+    conn = get_db()
+    cur = conn.execute(
+        "INSERT INTO tasks (plane_id, work_item_id, repo, branch, stage) "
+        "VALUES (?, ?, ?, ?, ?)",
+        (work_item_id, work_item_id, repo, branch, stage),
+    )
+    tid = cur.lastrowid
+    conn.commit()
+    conn.close()
+    return tid
+
+
+def _make_running_job(agent="deployer", repo="orchestrator", task_id=None,
+                      pid=None, age_s=0, attempts=0, max_attempts=2,
+                      run_id=None, exit_code=0, finished_age_s=600):
+    """Insert a job already in 'running' with a linked agent_runs row.
+
+    ``finished_at`` is back-dated by ``finished_age_s`` so the Tier-2 grace
+    (default 300) is satisfied by default; pass a small value to stay within grace.
+    """
+    conn = get_db()
+    if run_id is None and exit_code is not None:
+        cur = conn.execute(
+            "INSERT INTO agent_runs (task_id, agent, finished_at, exit_code) "
+            "VALUES (?, ?, datetime('now', ?), ?)",
+            (task_id, agent, f"-{int(finished_age_s)} seconds", exit_code),
+        )
+        run_id = cur.lastrowid
+    cur = conn.execute(
+        "INSERT INTO jobs (agent, repo, task_id, status, attempts, max_attempts, "
+        "run_id, pid, started_at) "
+        "VALUES (?, ?, ?, 'running', ?, ?, ?, ?, datetime('now', ?))",
+        (agent, repo, task_id, attempts, max_attempts, run_id, pid,
+         f"-{int(age_s)} seconds"),
+    )
+    job_id = cur.lastrowid
+    conn.commit()
+    conn.close()
+    return job_id
+
+
+def _spy_advance(monkeypatch, side_effect=None):
+    """Patch launcher._try_advance_stage with a call recorder.
+
+    Returns a mutable ``calls`` list. ``side_effect(run_id, agent, repo, branch)``
+    runs on each call (e.g. to simulate the false rollback to development).
+    """
+    import src.agents.launcher as L
+    calls: list = []
+
+    def _fake(run_id, agent, repo, branch):
+        calls.append((run_id, agent, repo, branch))
+        if side_effect is not None:
+            side_effect(run_id, agent, repo, branch)
+
+    monkeypatch.setattr(L.launcher, "_try_advance_stage", _fake)
+    return calls
+
+
+def _green_gate(monkeypatch):
+    """Force the read-only canonical-QG pre-eval green (staging SUCCESS)."""
+    monkeypatch.setattr(JobReaper, "_gate_is_green",
+                        lambda self, stage, job, branch, wid: True)
+
+
+# --- TC-01: live finalizer on deploy-staging is NOT reaped (AC-1/FR-1) ------
+def test_tc01_live_finalizer_deploy_staging_not_reaped(monkeypatch):
+    """exit_code=0 and finished_age_s >= grace, but the finalizer is ALIVE (marked)
+    -> reaper does NOT call _try_advance_stage; the row stays running; defer logged."""
+    _green_gate(monkeypatch)
+    calls = _spy_advance(monkeypatch)
+    tid = _make_task(stage="deploy-staging")
+    jid = _make_running_job(task_id=tid, exit_code=0, finished_age_s=600)
+    # A live monitor owns this finalization.
+    fl.mark(jid, run_id=1, stage="deploy-staging")
+
+    r = JobReaper()
+    r.reap_once()
+
+    assert get_job(jid)["status"] == "running"   # not reaped
+    assert calls == []                            # no second advance
+    assert r.finalizer_defers_total == 1
+    assert r.reaped_total == 0
+
+
+# --- TC-02: strict ownership — non-owner runs zero side effects (AC-2/FR-2) --
+def test_tc02_non_owner_runs_no_edge_gates(monkeypatch):
+    """While a live finalizer owns the (job, stage), a racing reaper tick performs
+    NO side-effectful advance/merge-gate/re-test (zero side effects)."""
+    _green_gate(monkeypatch)
+    calls = _spy_advance(monkeypatch)
+    tid = _make_task(stage="deploy-staging")
+    jid = _make_running_job(task_id=tid, exit_code=0, finished_age_s=900)
+    fl.mark(jid, run_id=7, stage="deploy-staging")
+
+    r = JobReaper()
+    # Several ticks while ownership is held — still zero advances, still running.
+    for _ in range(3):
+        r.reap_once()
+
+    assert calls == []
+    assert get_job(jid)["status"] == "running"
+    assert r.finalizer_defers_total == 3
+
+
+# --- TC-03: a genuinely dead finalizer is still reaped (AC-3/FR-4) ----------
+def test_tc03_dead_finalizer_still_reaped_tier2(monkeypatch):
+    """No ownership marker (finalizer dead) -> reaper reaps via Tier-2 as before."""
+    _green_gate(monkeypatch)
+    calls = _spy_advance(monkeypatch)
+    tid = _make_task(stage="deploy-staging")
+    jid = _make_running_job(task_id=tid, exit_code=0, finished_age_s=600)
+    # No fl.mark() -> ownership absent (finalizer dead).
+
+    r = JobReaper()
+    r.reap_once()
+
+    assert get_job(jid)["status"] == "done"   # reaped to done (gate green)
+    assert len(calls) == 1                     # advance driven exactly once
+    assert r.finalizer_defers_total == 0
+
+
+def test_tc03_tier3_backstop_ignores_marker(monkeypatch):
+    """Even with an active ownership marker, a job past reaper_max_running_s is
+    reaped by the Tier-3 backstop (a stuck finalizer is never immortal)."""
+    monkeypatch.setattr(db.settings, "reaper_max_running_s", 1000)
+    tid = _make_task(stage="deploy-staging")
+    # age beyond the backstop ceiling; exit_code=0 within grace so Tier-2 defers,
+    # but Tier-3 must still fire.
+    jid = _make_running_job(task_id=tid, exit_code=0, finished_age_s=10,
+                            age_s=2000, attempts=0, max_attempts=2)
+    fl.mark(jid, run_id=3, stage="deploy-staging")
+
+    r = JobReaper()
+    r.reap_once()
+
+    # Backstop reaps to a retry (attempts<max) -> queued, regardless of the marker.
+    assert get_job(jid)["status"] == "queued"
+    assert r.reaped_total == 1
+
+
+# --- TC-04: idempotency under race — exactly-once advance (AC-2/AC-4/FR-2) ---
+def test_tc04_idempotent_no_second_advance_under_race(monkeypatch):
+    """Monitor finalizing (owns the job) + concurrent reaper ticks -> the heavy
+    edge-gate advance is NEVER duplicated by the reaper; no false rollback."""
+    rolled_back = {"hit": False}
+
+    def _rollback(run_id, agent, repo, branch):
+        # Simulate the incident: a second advance rolls back to development.
+        conn = get_db()
+        conn.execute("UPDATE tasks SET stage='development' WHERE branch=?", (branch,))
+        conn.commit()
+        conn.close()
+        rolled_back["hit"] = True
+
+    _green_gate(monkeypatch)
+    calls = _spy_advance(monkeypatch, side_effect=_rollback)
+    tid = _make_task(stage="deploy-staging")
+    jid = _make_running_job(task_id=tid, exit_code=0, finished_age_s=1200)
+    fl.mark(jid, run_id=9, stage="deploy-staging")
+
+    r = JobReaper()
+    for _ in range(5):
+        r.reap_once()
+
+    assert calls == []                # reaper never re-ran the advance
+    assert rolled_back["hit"] is False
+    # The task is NOT rolled back; the live finalizer remains the sole driver.
+    conn = get_db()
+    stage = conn.execute("SELECT stage FROM tasks WHERE id=?", (tid,)).fetchone()[0]
+    conn.close()
+    assert stage == "deploy-staging"
+
+
+# --- TC-05: MANDATORY regression for incident ORCH-111 (AC-4/FR-5) ----------
+def test_tc05_orch111_no_false_rollback_no_retry_increment(monkeypatch):
+    """Long (> grace) deploy-staging finalization at staging_status=SUCCESS while
+    the deploy finalizer concurrently reaches success/merge -> reaper does NOT roll
+    back deploy-staging -> development and does NOT increment developer-retry; the
+    task keeps a single consistent state. RED before the fix, GREEN after."""
+    def _rollback(run_id, agent, repo, branch):
+        # Simulate the incident: a second advance rolls the task back to development
+        # and spawns a fresh developer run (the developer-retry count is derived from
+        # agent_runs — stage_engine.developer_retry_count).
+        conn = get_db()
+        conn.execute("UPDATE tasks SET stage='development' WHERE branch=?", (branch,))
+        _t = conn.execute("SELECT id FROM tasks WHERE branch=?", (branch,)).fetchone()
+        conn.execute(
+            "INSERT INTO agent_runs (task_id, agent) VALUES (?, 'developer')",
+            (_t[0],),
+        )
+        conn.commit()
+        conn.close()
+
+    from src.stage_engine import developer_retry_count
+    _green_gate(monkeypatch)                       # staging_status SUCCESS
+    calls = _spy_advance(monkeypatch, side_effect=_rollback)
+    tid = _make_task(stage="deploy-staging")
+    jid = _make_running_job(task_id=tid, exit_code=0, finished_age_s=1500)
+    # The original finalizer is still alive (running the heavy edge sub-gates).
+    fl.mark(jid, run_id=11, stage="deploy-staging")
+
+    r = JobReaper()
+    r.reap_once()
+
+    # No second advance => no false rollback, no developer-retry increment.
+    assert calls == []
+    conn = get_db()
+    stage = conn.execute("SELECT stage FROM tasks WHERE id=?", (tid,)).fetchone()[0]
+    conn.close()
+    assert stage == "deploy-staging"            # NOT rolled back to development
+    assert developer_retry_count(tid) == 0       # developer-retry NOT incremented
+    assert get_job(jid)["status"] == "running"
+    assert r.finalizer_defers_total == 1
+
+
+# --- TC-06: compatibility guard — kill-switch / non-deploy-staging (AC-5) ----
+def test_tc06_killswitch_off_byte_for_byte_prior(monkeypatch):
+    """Kill-switch OFF -> the marker is ignored; a deploy-staging exit0/past-grace
+    job is reaped exactly as before the fix (advance driven once)."""
+    monkeypatch.setattr(db.settings, "reaper_finalizer_liveness_enabled", False)
+    _green_gate(monkeypatch)
+    calls = _spy_advance(monkeypatch)
+    tid = _make_task(stage="deploy-staging")
+    jid = _make_running_job(task_id=tid, exit_code=0, finished_age_s=600)
+    fl.mark(jid, run_id=5, stage="deploy-staging")   # marked, but ignored
+
+    r = JobReaper()
+    r.reap_once()
+
+    assert get_job(jid)["status"] == "done"
+    assert len(calls) == 1
+    assert r.finalizer_defers_total == 0
+
+
+def test_tc06_non_deploy_staging_stage_not_consulted(monkeypatch):
+    """A non-deploy-staging stage is never consulted -> reaped as before even when
+    an (irrelevant) marker happens to be present."""
+    _green_gate(monkeypatch)
+    calls = _spy_advance(monkeypatch)
+    tid = _make_task(stage="testing")     # deployer also owns 'testing'
+    jid = _make_running_job(task_id=tid, agent="deployer", exit_code=0,
+                            finished_age_s=600)
+    fl.mark(jid, run_id=6, stage="testing")
+
+    r = JobReaper()
+    r.reap_once()
+
+    assert get_job(jid)["status"] == "done"
+    assert len(calls) == 1
+    assert r.finalizer_defers_total == 0
+
+
+def test_tc06_within_grace_unchanged(monkeypatch):
+    """Within the finalization grace the Tier-2 path is unchanged (deferred, not
+    reaped) regardless of the marker — the fix only acts PAST the grace."""
+    monkeypatch.setattr(db.settings, "reaper_finalize_grace_s", 300)
+    _green_gate(monkeypatch)
+    calls = _spy_advance(monkeypatch)
+    tid = _make_task(stage="deploy-staging")
+    jid = _make_running_job(task_id=tid, exit_code=0, finished_age_s=5)  # < grace
+
+    r = JobReaper()
+    r.reap_once()
+
+    assert get_job(jid)["status"] == "running"
+    assert calls == []
+    # Within-grace deferral is the legacy path, not a finalizer-liveness defer.
+    assert r.finalizer_defers_total == 0
+
+
+# --- TC-07: cross-cutting budget invariant (NFR-6/AC-5) ---------------------
+def test_tc07_budget_invariant_preserved():
+    """reaper_max_running_s (5400) > Σ(deploy-staging gate-work) + grace; the fix
+    changed neither the grace nor the ceiling (ORCH-065/109/110 invariant)."""
+    s = jr.settings
+    # The fix did not touch these (zero schema/budget change).
+    assert s.reaper_finalize_grace_s == 300
+    assert s.reaper_max_running_s == 5400
+    # Conservative Σ of the heavy deploy-staging gate-work + grace must fit.
+    sigma = s.merge_retest_timeout_s + s.coverage_run_timeout_s
+    assert s.reaper_max_running_s > sigma + s.reaper_finalize_grace_s
+
+
+# --- TC-08: never-raise — a fault in the liveness path degrades safely -------
+def test_tc08_liveness_error_never_breaks_tick(monkeypatch):
+    """An exception inside the ownership consultation must not crash the tick; the
+    job is still processed (conservatively reaped, never blocked)."""
+    def _boom(job_id):
+        raise RuntimeError("registry exploded")
+
+    monkeypatch.setattr(fl, "is_active", _boom)
+    _green_gate(monkeypatch)
+    calls = _spy_advance(monkeypatch)
+    tid = _make_task(stage="deploy-staging")
+    jid = _make_running_job(task_id=tid, exit_code=0, finished_age_s=600)
+    fl.mark(jid, run_id=2, stage="deploy-staging")
+
+    r = JobReaper()
+    r.reap_once()  # must not raise
+
+    # is_active raised -> _finalizer_owns conservatively returns False -> reaped.
+    assert get_job(jid)["status"] == "done"
+    assert len(calls) == 1
+
+
+def test_tc08_reap_once_isolates_and_never_raises(monkeypatch):
+    """A fault while resolving one job's metadata is isolated; reap_once never
+    raises and other jobs are still processed."""
+    def _boom(self, job):
+        raise RuntimeError("meta exploded")
+
+    monkeypatch.setattr(JobReaper, "_task_meta", _boom)
+    tid = _make_task(stage="deploy-staging")
+    _make_running_job(task_id=tid, exit_code=0, finished_age_s=600)
+
+    r = JobReaper()
+    r.reap_once()  # outer + per-job never-raise -> no exception propagates
+
+
+def test_tc08_finalizer_liveness_leaf_never_raises():
+    """The leaf degrades safely on bad input / None job_id."""
+    fl.mark(None, None, None)          # no-op, no raise
+    fl.clear(None)                     # no-op, no raise
+    assert fl.is_active(None) is False
+    fl.mark(1234, 1, "deploy-staging")
+    assert fl.is_active(1234) is True
+    snap = fl.snapshot()
+    assert snap["active"] >= 1 and 1234 in snap["jobs"]
+    fl.clear(1234)
+    assert fl.is_active(1234) is False