@7n/rules 1.49.15 → 1.49.17

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.49.17] - 2026-07-27
+
+### Fixed
+
+- Keep git-reconcile progress live and PR readiness fail-closed
+
+## [1.49.16] - 2026-07-27
+
+### Fixed
+
+- Обмежено npm-module репозиторіями з npm publisher topology
+
 ## [1.49.15] - 2026-07-27
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/rules",
-  "version": "1.49.15",
+  "version": "1.49.17",
   "description": "CLI еталонних правил і skills (префікс n-): синк у репозиторій, дельта-lint, конформність",
   "keywords": [
     "cli",

package/scripts/lib/lint-surface/docs/run-detectors.md

@@ -3,7 +3,7 @@ type: JS Module
 title: run-detectors.mjs
 resource: npm/scripts/lib/lint-surface/run-detectors.mjs
 docgen:
-  crc: e9224e37
+  crc: 9f044303
   model: openai-codex/gpt-5.4-mini
   tier: cloud-min
   score: 100
@@ -19,7 +19,7 @@ docgen:
 
 DEFAULT_RULES_DIR задає базовий корінь правил, від якого стартує discovery, коли споживач не передав власні каталоги.
 
-buildDetectPlan спочатку визначає набір rules-каталогів, потім відбирає лише доступні concern-и з урахуванням capability, далі будує план виконання за режимом прогону: scoped, delta, full або repo-wide. Сам план фіксує, які concern-и запускаються whole-repo, а які лише по перетину з файлами, щоб detect і fix-pipeline працювали з однаковою картиною.
+buildDetectPlan спочатку визначає набір rules-каталогів, відбирає concern-и за capability і застосовує опційний rule-level `applies` gate. Лише після цього він будує план виконання за режимом прогону: scoped, delta, full або repo-wide. Сам план фіксує, які concern-и запускаються whole-repo, а які лише по перетину з файлами, щоб detect і fix-pipeline працювали з однаковою картиною.
 
 loadEnabledLintRules використовує той самий discovery-ланцюжок, але повертає не план, а повну мапу concern-и за rule-id разом із множиною активних правил. Це потрібно зовнішнім споживачам, які мають знати, що реально доступно для прогону, не запускаючи сам detector-цикл.
 
@@ -42,6 +42,8 @@ concern тригериться на цих файлах (та сама табл
 full-scope перевірки — справа `--repo-wide`).
 - detectAll — Запускає detect-only прохід. Повертає всі violations і похідний exitCode.
 
+Rule-level `applies` у `<rule>/applies/main.mjs` може повернути `false`, щоб виключити всі concern-и правила з плану для поточного репозиторію.
+
 ## Гарантії поведінки
 
 - Власних операцій запису (ФС/БД) у файлі немає; виклики імпортованих модулів можуть писати.

package/scripts/lib/lint-surface/run-detectors.mjs

@@ -9,9 +9,10 @@
  * @typedef {import('../concern-meta.mjs').ConcernMeta} ConcernMeta
  * @typedef {{ ruleId: string, concern: ConcernMeta }} LintEntry
  */
+import { existsSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { env } from 'node:process'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 
 import picomatch from 'picomatch'
 
@@ -126,6 +127,46 @@ async function filterByCapabilities(byRule, opts) {
   return out
 }
 
+/**
+ * Застосовує опційний rule-level gate з `<rule>/applies/main.mjs` до всіх
+ * concern-ів правила. Це потрібно для доменних правил, чий канон має сенс
+ * лише за наявності конкретної topology в репозиторії: один gate не дає
+ * policy- й JS-concern-ам розійтися у власних евристиках застосовності.
+ *
+ * @param {Record<string, ConcernMeta[]>} byRule concerns за rule-id.
+ * @param {string} cwd корінь репозиторію, який лінтиться.
+ * @returns {Promise<Record<string, ConcernMeta[]>>} лише застосовні правила.
+ */
+async function filterByRuleApplies(byRule, cwd) {
+  /** @type {Record<string, ConcernMeta[]>} */
+  const out = {}
+  for (const [ruleId, concerns] of Object.entries(byRule)) {
+    const firstConcern = concerns[0]
+    if (!firstConcern) continue
+    const appliesPath = join(dirname(firstConcern.dir), 'applies', 'main.mjs')
+    if (!existsSync(appliesPath)) {
+      out[ruleId] = concerns
+      continue
+    }
+    let applies
+    try {
+      const mod = await import(pathToFileURL(appliesPath).href)
+      applies = mod.applies
+    } catch (error) {
+      throw new Error(`rule ${ruleId}: не вдалося завантажити applies gate: ${error.message}`)
+    }
+    if (applies === undefined) {
+      out[ruleId] = concerns
+      continue
+    }
+    if (typeof applies !== 'function') {
+      throw new Error(`rule ${ruleId}: applies/main.mjs має експортувати applies(cwd)`)
+    }
+    if (await applies(cwd)) out[ruleId] = concerns
+  }
+  return out
+}
+
 /**
  * Мердж concerns кількох rules-каталогів: правила зливаються за id, концерни — за іменем
  * (перший власник виграє: ядро → плагіни у порядку списку). Плагін може ДОДАВАТИ концерни
@@ -267,7 +308,8 @@ export async function buildDetectPlan(opts) {
  */
 export async function loadEnabledLintRules(opts) {
   const rulesDirs = await effectiveRulesDirs(opts)
-  const byRule = await filterByCapabilities(await readLintConcernsByRuleMulti(rulesDirs), opts)
+  const capable = await filterByCapabilities(await readLintConcernsByRuleMulti(rulesDirs), opts)
+  const byRule = await filterByRuleApplies(capable, opts.cwd)
   const enabledSet = new Set(await enabledRuleIds(byRule, opts.cwd, rulesDirs))
   return { byRule, enabledSet }
 }
@@ -618,7 +660,8 @@ export async function detectAll(opts) {
   const baseLog = opts.log ?? (s => process.stdout.write(s))
 
   const rulesDirs = await effectiveRulesDirs(opts)
-  const byRule = await filterByCapabilities(await readLintConcernsByRuleMulti(rulesDirs), opts)
+  const capable = await filterByCapabilities(await readLintConcernsByRuleMulti(rulesDirs), opts)
+  const byRule = await filterByRuleApplies(capable, cwd)
   const plan = await buildPlan({
     byRule,
     full,

package/skills/git-reconcile/SKILL.md

@@ -44,7 +44,8 @@ time без вигаданого total, а `triage`, `PR` і `cleanup` — ок
 append-only bar snapshots за вже відомими batches/groups/sources. Поточний
 LLM-етап показує tier `min` або `max`; довгі етапи кожні 30 секунд отримують
 heartbeat з elapsed time. Формат однаковий у TTY/CI, тому captured output не
-містить cursor-control spam.
+містить cursor-control spam. Install, tests, lint і очікування PR checks
+виконуються через non-blocking child processes, тому heartbeat не завмирає.
 
 Незалежні PR-групи виконуються з bounded concurrency `3`; override
 `N_GIT_RECONCILE_CONCURRENCY=1..4`. Порядок фінального звіту лишається
@@ -90,8 +91,14 @@ transport. Після провалу `max` джерело fail-closed лишає
 - Перед push обов'язково проходять фінальний tree-diff guard, domain lint для
   non-code paths, changelog і `git diff --check`; code changes додатково
   проходять scoped docs/lint та tests.
+- Canonical fixers охоплюють code і non-code directories; після механічного
+  виправлення фінальні gates обов'язково запускаються повторно без fix.
 - Behavioral LLM не викликається для змін без code paths; test baseline
   актуальної policy base branch кешується між PR-групами.
+- Після `gh pr create` JS чекає terminal CI state і порівнює failed checks із
+  base commit. Лише `ready` PR дозволяє cleanup; regression, baseline-red,
+  timeout, pending або unreadable checks зберігають branch, URL і worktree та
+  завершують команду non-zero.
 - Cleanup виконує лише JS і тільки після inventory/PR-фази: видаляє точні refs,
   уже merged/patch-equivalent, явно класифіковані як `drop` або повністю
   перенесені в успішний PR.
@@ -104,6 +111,8 @@ transport. Після провалу `max` джерело fail-closed лишає
 
 Оркестратор повертає для кожного джерела один verdict: `merged`,
 `patch-equivalent`, `open-pr`, `protected`, `pr-created`, `kept`,
-`drop-recommended` або `failed`. Для `pr-created` додає URL, перенесені коміти,
-конфлікти та виконані перевірки. Для cleanup ref звіт також містить точний OID
-і видалені aliases, а для failure — branch та збережений worktree.
+`drop-recommended`, `pr-checks-regressed`, `pr-checks-baseline-red`,
+`pr-checks-unverified` або `failed`. `pr-created` означає, що checks завершились
+успішно; для непідтвердженого PR звіт зберігає URL, branch, worktree і точну
+причину. Summary містить точний count кожного outcome. Для cleanup ref звіт
+також містить точний OID і видалені aliases.

package/skills/git-reconcile/js/docs/orchestrate.md

@@ -3,70 +3,46 @@ type: JS Module
 title: orchestrate.mjs
 resource: npm/skills/git-reconcile/js/orchestrate.mjs
 docgen:
-  crc: 6e9cb156
-  model: openai-codex/gpt-5.5
-  tier: cloud-avg
+  crc: e28dcd28
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
 ---
 
 ## Огляд
 
-Файл координує Git reconcile-орchestrator: інвентаризує repository refs і worktrees, прибирає дублікати refs, визначає conflict files, формує triage prompt, перевіряє decision envelope та застосовує рішення через runner. Він існує, щоб переносити cleanup у перевірюваний процес із behavior baseline, cached baseline у межах прогону, validation gates, контрольованим concurrency і детермінованим Markdown-звітом.
+Модуль координує Git reconcile: інвентаризує branches, worktrees і stash, передає LLM лише semantic triage та conflict/behavioral рішення, а механічне перенесення, перевірки, PR readiness і cleanup виконує детерміновано. Довгі install/test/lint/checks-команди працюють асинхронно, щоб progress heartbeat не блокувався.
 
 ## Поведінка
 
-`runGitReconcileOrchestrator` керує всім потоком: збирає Git-стан через `inventoryRepository`, веде фазовий progress через `createPhaseProgress`, запускає bounded triage, матеріалізує рішення у PR-пайплайн, виконує cleanup і повертає звіт через `formatReport`. Паралельність PR-фази обмежується `normalizePrConcurrency`, а незалежні задачі виконуються через `runWithConcurrency` зі стабільним порядком результатів.
+`runGitReconcileOrchestrator` виконує чотири однозначно підписані фази: inventory, triage, PR і cleanup. `createPhaseProgress` формує append-only snapshots та heartbeat, `runWithConcurrency` обмежує паралельність PR-груп, а `formatOutcomeCounts` і `formatReport` повертають точні counts та деталі кожного outcome.
 
-`inventoryRepository` отримує факти з локального checkout і remote refs, оновлює remote refs через fetch --prune, але не змінює робочі файли. `parseWorktrees` і `dedupeRefs` зводять worktree-захист, branch refs, aliases і commit identity в один детермінований inventory, щоб protected або відкриті джерела не потрапили в небезпечний cleanup. `conflictFiles` додає до inventory ранню оцінку потенційних merge-conflicts.
+`inventoryRepository`, `parseWorktrees` і `dedupeRefs` зводять Git refs, commit identity, open PR та фактичні worktree paths в один inventory. Protected або вже відкриті джерела не матеріалізуються й не потрапляють у небезпечний cleanup. `buildTriagePrompt`, `parseDecisionEnvelope` і `validateTriageOutcome` обмежують LLM повним JSON-рішенням над уже зібраними фактами; `callWithValidatedFallback` приймає `min` після validation або викликає `max` лише для residual cognitive failure.
 
-Для review-кандидатів `buildTriagePrompt` формує обмежене завдання для LLM: модель отримує вже пораховані Git-факти й має повернути лише JSON-рішення. `callRunner` викликає обраний runner, `parseDecisionEnvelope` дістає структуровану відповідь, а `validateTriageOutcome` приймає тільки повний і узгоджений набір рішень для поточного batch. `callWithValidatedFallback` спершу пробує дешевший рівень, а дорожчий використовує лише після конкретного validation failure.
+Для корисної групи JS створює ізольований worktree від policy base, застосовує commits або stash і відсікає порожній tree diff. `captureCachedBehaviorBaseline` кешує Promise baseline за base OID, щоб concurrent PR-групи не дублювали test run. `validateBehaviorState` перевіряє Git state, scoped docs/lint, tests відносно baseline і changelog. `remediateBehaviorState` запускає canonical fixers для code та non-code directories; після remediation final gates повторюються у read-only режимі.
 
-Під час матеріалізації рішення source переноситься у керований worktree. `branchSlug` забезпечує передбачувані rescue-гілки без крайового дефіса після скорочення, а `ensureLocalWorktreeExclude` не дає службовим worktree забруднювати root `git status`. Після `@7n/mt` actual checkout визначається через `git worktree list --porcelain`, тому collision sanitized-каталогу не веде до реконструйованого cwd. Setup failure повертається як `failed` лише для цієї PR-групи з branch, фактичним worktree та `spawnSync`-діагностикою; source і forensic checkout не очищуються. Якщо cherry-pick стає порожнім, `skipEmptyCherryPick` дозволяє skip лише для доведеного semantic no-op, а `finishCherryPick` завершує активний перенос без прийняття неперевіреного Git-стану. `hasChangesFromBase` відсікає PR без реального tree diff.
+`runAsync` запускає install, tests, lint і PR checks без блокування event loop. Після push та `gh pr create` функція `verifyPullRequestReadiness` очікує terminal checks і передає набори PR/base checks у `classifyPullRequestChecks`. Успішний outcome `pr-created` повертається лише для `ready`; regression, baseline-red, pending, timeout або unreadable checks зберігають branch, URL і worktree та блокують cleanup.
 
-Behavior-gates будуються навколо baseline: `captureBehaviorBaseline` фіксує стан чистої `origin/<baseBranch>` із repository Git policy, а `captureCachedBehaviorBaseline` перевикористовує цей результат у межах одного прогону для однакової бази. `validateBehaviorState` перевіряє Git-консистентність, scoped lint/docs і test outcome; правила запуску тестів і скриптів беруться з `package.json`. `testFailureSignatures` нормалізує failures, а `acceptsTestOutcome` дозволяє red baseline тільки без нових failures. Якщо валідація падає через типовий formatting, CSpell, docs або changelog-дефект, `remediateBehaviorState` запускає canonical fixers перед ескалацією LLM.
-
-Для scoped gates `sourceDirectories` звужує code-зміни до мінімальних директорій, а `changedNonCodeDirectories` окремо готує non-code області для фінальної перевірки. `validateFinalProjectGates` добирає domain lint для workflows, dependency manifests, rules та інших non-code змін після того, як code-директорії вже пройшли свої перевірки.
-
-Після успішного перенесення або доведеної неактуальності `cleanupSource` видаляє тільки точний source, який не є protected і не має відкритого PR. Усі accepted, kept, dropped, failed і cleaned результати зводяться в детермінований Markdown через `formatReport`, щоб наступний крок бачив і створені PR, і причини fail-closed рішень.
+`cleanupSource` видаляє лише точний доказово безпечний branch/stash. Cleanup review-source дозволений після `drop` або коли всі його групи завершились `pr-created` чи `patch-equivalent`; `failed` і всі `pr-checks-*` outcomes лишають source та forensic worktree.
 
 ## Публічний API
 
-- createPhaseProgress — Створює ANSI-free snapshot progress для однієї фази.
-- parseWorktrees — Парсить `git worktree list --porcelain` у branch→path.
-- dedupeRefs — Дедуплікує local/remote refs одного commit.
-- conflictFiles — Витягає конфліктні файли з `git merge-tree`.
-- inventoryRepository — Збирає детермінований Git inventory.
-- buildTriagePrompt — Формує bounded semantic-triage prompt.
-- parseDecisionEnvelope — Витягає JSON object із чистої або fenced відповіді.
-- callRunner — Викликає вибраний LLM runner для одного bounded-завдання.
-- callWithValidatedFallback — Виконує min, валідує результат і викликає max лише після validation failure.
-- validateTriageOutcome — Структурно перевіряє triage-рішення.
-- branchSlug — Перетворює title/ref на валідний короткий branch slug.
-- ensureLocalWorktreeExclude — Додає `.worktrees/` до локального Git exclude без tracked-змін.
-- skipEmptyCherryPick — Пропускає лише підтверджений empty cherry-pick.
-- finishCherryPick — Завершує активний cherry-pick.
-- hasChangesFromBase — Перевіряє реальний tree diff, а не commits ahead.
-- testFailureSignatures — Витягає стабільні Vitest failure identifiers.
-- acceptsTestOutcome — Дозволяє red baseline лише без нових failures.
-- sourceDirectories — Зводить code paths до найвужчих директорій для scoped gates.
-- changedNonCodeDirectories — Повертає директорії non-code змін для domain lint.
-- remediateBehaviorState — Запускає canonical fixers перед behavioral max fallback.
-- captureBehaviorBaseline — Фіксує test baseline на чистій policy base branch.
-- captureCachedBehaviorBaseline — Кешує test baseline між PR-групами.
-- validateBehaviorState — Додає Git-state validation, tests і changelog gate.
-- validateFinalProjectGates — Перевіряє фінальні non-code domain gates.
-- cleanupSource — Видаляє тільки доказово безпечний точний source.
-- formatReport — Формує deterministic report.
-- runWithConcurrency — Виконує async jobs із bounded concurrency та стабільним output.
-- normalizePrConcurrency — Нормалізує bounded concurrency PR-фази.
-- runGitReconcileOrchestrator — Координує inventory, triage, PR і cleanup.
+- `runAsync` — виконує довгу команду без блокування progress heartbeat.
+- `createPhaseProgress` — формує ANSI-free progress snapshots і heartbeat.
+- `parseWorktrees`, `dedupeRefs`, `conflictFiles`, `inventoryRepository` — збирають і нормалізують Git inventory.
+- `buildTriagePrompt`, `parseDecisionEnvelope`, `validateTriageOutcome` — задають і перевіряють bounded triage contract.
+- `callRunner`, `callWithValidatedFallback` — викликають runner за схемою `min → validation → max`.
+- `captureBehaviorBaseline`, `captureCachedBehaviorBaseline` — фіксують і кешують test baseline.
+- `validateBehaviorState`, `validateFinalProjectGates`, `remediateBehaviorState` — виконують behavioral та canonical gates.
+- `classifyPullRequestChecks`, `verifyPullRequestReadiness` — класифікують CI відносно base commit.
+- `formatOutcomeCounts`, `formatReport` — формують точний deterministic summary.
+- `cleanupSource`, `runGitReconcileOrchestrator` — виконують безпечний cleanup і координують повний flow.
 
 ## Гарантії поведінки
 
-- Progress є append-only та не містить ANSI cursor-control sequences.
-- Не більше чотирьох PR-груп виконуються одночасно; типовий ліміт — три.
-- Canonical fixers мають пріоритет перед behavioral `max` fallback.
-- Cleanup починається лише після завершення всіх PR jobs і не видаляє protected/open-PR/failed sources.
-- `spawnSync.error`, зокрема `ENOENT`, не губиться в command diagnostics.
-- Setup failure зберігає forensic worktree і не зупиняє незалежні PR-групи.
-- Test baseline кешується за OID policy base branch у межах одного прогону.
+- Довгі child processes не блокують event loop і progress heartbeat.
+- Baseline test Promise дедуплікується між concurrent PR-групами одного base OID.
+- Canonical fixers охоплюють code/non-code scope, після чого gates повторюються без fix.
+- PR вважається створеним успішно лише після terminal green checks.
+- CI regression, baseline-red або непідтверджений стан завершують orchestration non-zero і зберігають forensic refs/worktree.
+- Cleanup не видаляє protected, open-PR, kept, failed або `pr-checks-*` sources.
+- `spawnSync.error`, зокрема `ENOENT`, зберігається в command diagnostics.

package/skills/git-reconcile/js/orchestrate.mjs

@@ -1,5 +1,6 @@
 /** @see ./docs/orchestrate.md */
-import { spawnSync } from 'node:child_process'
+import { spawn, spawnSync } from 'node:child_process'
+import { once } from 'node:events'
 import { appendFileSync, existsSync, readFileSync } from 'node:fs'
 import { dirname, isAbsolute, join } from 'node:path'
 import { performance } from 'node:perf_hooks'
@@ -12,6 +13,7 @@ const LLM_TIERS = ['min', 'max']
 const REVIEW_BATCH_SIZE = 10
 const PROMPT_TEXT_LIMIT = 12_000
 const PROGRESS_HEARTBEAT_MS = 30_000
+const PR_CHECK_TIMEOUT_MS = 15 * 60_000
 const DEFAULT_PR_CONCURRENCY = 3
 const MAX_PR_CONCURRENCY = 4
 const SOURCE_BRANCH_PREFIX = 'branch:'
@@ -28,11 +30,24 @@ const REF_INVENTORY_FORMAT = ['%(refname)', '%00', '%(object', 'name)', '%00', '
   ''
 )
 
+/** @typedef {(command:string,args:string[],options:object)=>object|Promise<object>} CommandRunner */
+
 /** Порожній callback для опційного progress log. */
 function noop() {
   // Навмисно порожньо: caller не запросив progress output.
 }
 
+/**
+ * Форматує spawn error без вкладених template literals.
+ * @param {object|undefined|null} error process error
+ * @returns {string} діагностика
+ */
+function formatProcessError(error) {
+  if (!error) return ''
+  const code = error.code ? ` ${error.code}` : ''
+  return `${error.name ?? 'Error'}${code}: ${error.message}`
+}
+
 /**
  * @param {string} cwd корінь репозиторію
  * @returns {string} remote ref базової гілки
@@ -154,7 +169,7 @@ function run(command, args, cwd, spawnFn, options = {}) {
     status: result.status ?? 1,
     stdout: result.stdout ?? '',
     stderr: result.stderr ?? '',
-    error: result.error ? `${result.error.name ?? 'Error'}${result.error.code ? ` ${result.error.code}` : ''}: ${result.error.message}` : ''
+    error: formatProcessError(result.error)
   }
   if (!options.allowFailure && normalized.status !== 0) {
     throw new Error(
@@ -164,6 +179,100 @@ function run(command, args, cwd, spawnFn, options = {}) {
   return normalized
 }
 
+/**
+ * Виконує довгу команду без блокування event loop, щоб progress heartbeat
+ * продовжував працювати під час install/test/lint/PR checks. Інжектований
+ * sync runner у unit tests також підтримується.
+ * @param {string} command виконуваний файл
+ * @param {string[]} args аргументи
+ * @param {string} cwd робочий каталог
+ * @param {CommandRunner} spawnFn async або sync runner
+ * @param {{ allowFailure?: boolean, input?: string, timeoutMs?: number }} [options] режим
+ * @returns {Promise<{status:number,stdout:string,stderr:string,error:string}>} результат
+ */
+export async function runAsync(command, args, cwd, spawnFn, options = {}) {
+  const childEnv = { ...env, GIT_EDITOR: 'true' }
+  if (command === 'npx') delete childEnv.npm_config_package
+  const spawned = spawnFn(command, args, {
+    cwd,
+    env: childEnv,
+    stdio: ['pipe', 'pipe', 'pipe']
+  })
+  if (!spawned || typeof spawned.on !== 'function') {
+    const result = await spawned
+    const normalized = {
+      status: result?.status ?? 1,
+      stdout: result?.stdout ?? '',
+      stderr: result?.stderr ?? '',
+      error: formatProcessError(result?.error)
+    }
+    if (!options.allowFailure && normalized.status !== 0) {
+      throw new Error(
+        `${command} ${args.join(' ')} → exit ${normalized.status}: ${normalized.stderr || normalized.stdout || normalized.error}`
+      )
+    }
+    return normalized
+  }
+
+  const stdout = []
+  const stderr = []
+  let processError = ''
+  let timedOut = false
+  spawned.stdout?.setEncoding?.('utf8')
+  spawned.stderr?.setEncoding?.('utf8')
+  spawned.stdout?.on('data', chunk => {
+    stdout.push(chunk)
+  })
+  spawned.stderr?.on('data', chunk => {
+    stderr.push(chunk)
+  })
+  spawned.on('error', error => {
+    processError = formatProcessError(error)
+  })
+  if (options.input === undefined) spawned.stdin?.end()
+  else spawned.stdin?.end(options.input)
+
+  const timer =
+    options.timeoutMs > 0
+      ? setTimeout(() => {
+          timedOut = true
+          spawned.kill('SIGTERM')
+        }, options.timeoutMs)
+      : null
+  timer?.unref?.()
+  let status
+  try {
+    const [exitCode] = await once(spawned, 'close')
+    status = exitCode ?? 1
+  } catch {
+    status = 1
+  }
+  if (timer) clearTimeout(timer)
+  const normalized = {
+    status,
+    stdout: stdout.join(''),
+    stderr: stderr.join(''),
+    error: timedOut ? `Timeout after ${options.timeoutMs}ms` : processError
+  }
+  if (!options.allowFailure && normalized.status !== 0) {
+    throw new Error(
+      `${command} ${args.join(' ')} → exit ${normalized.status}: ${normalized.stderr || normalized.stdout || normalized.error}`
+    )
+  }
+  return normalized
+}
+
+/**
+ * Production використовує non-blocking spawn, а існуючі sync test doubles
+ * лишаються єдиним джерелом детермінованих результатів.
+ * @param {CommandRunner} spawnFn sync runner
+ * @param {CommandRunner|null|undefined} asyncSpawnFn явний async runner
+ * @returns {CommandRunner} runner довгих команд
+ */
+function resolveAsyncSpawn(spawnFn, asyncSpawnFn) {
+  return asyncSpawnFn ?? (spawnFn === spawnSync ? spawn : spawnFn)
+}
+
 /**
  * Запускає git у конкретному checkout.
  * @param {string[]} args аргументи git
@@ -946,12 +1055,14 @@ export function changedNonCodeDirectories(cwd, spawnFn = spawnSync) {
  * @param {string} cwd worktree
  * @param {typeof spawnSync} spawnFn інжект
  * @param {(stage:string)=>void} [onProgress] stage callback
- * @returns {{ok:boolean,error?:string}} gate
+ * @param {CommandRunner|null} [asyncSpawnFn] async runner
+ * @returns {Promise<{ok:boolean,error?:string}>} gate
  */
-function validateScopedProjectGates(cwd, spawnFn, onProgress = noop) {
+async function validateScopedProjectGates(cwd, spawnFn, onProgress = noop, asyncSpawnFn = null) {
+  const longRunner = resolveAsyncSpawn(spawnFn, asyncSpawnFn)
   for (const path of changedSourceDirectories(cwd, spawnFn)) {
     onProgress(`doc-files (${path})`)
-    const docs = run('npx', ['@7n/rules', 'lint', 'doc-files', '--path', path], cwd, spawnFn, {
+    const docs = await runAsync('npx', ['@7n/rules', 'lint', 'doc-files', '--path', path], cwd, longRunner, {
       allowFailure: true
     })
     if (docs.status !== 0) {
@@ -962,7 +1073,7 @@ function validateScopedProjectGates(cwd, spawnFn, onProgress = noop) {
       }
     }
     onProgress(`scoped lint (${path})`)
-    const lint = run('npx', ['@7n/rules', 'lint', '--path', path, '--no-fix'], cwd, spawnFn, {
+    const lint = await runAsync('npx', ['@7n/rules', 'lint', '--path', path, '--no-fix'], cwd, longRunner, {
       allowFailure: true
     })
     if (lint.status !== 0) {
@@ -983,14 +1094,24 @@ function validateScopedProjectGates(cwd, spawnFn, onProgress = noop) {
  * @param {typeof spawnSync} spawnFn інжект
  * @param {{remediation?:string}} validation провалена validation
  * @param {(stage:string)=>void} [onProgress] stage callback
- * @returns {{attempted:boolean,ok:boolean,error?:string}} результат
+ * @param {CommandRunner|null} [asyncSpawnFn] async runner
+ * @returns {Promise<{attempted:boolean,ok:boolean,error?:string}>} результат
  */
-export function remediateBehaviorState(cwd, spawnFn = spawnSync, validation = {}, onProgress = noop) {
+export async function remediateBehaviorState(
+  cwd,
+  spawnFn = spawnSync,
+  validation = {},
+  onProgress = noop,
+  asyncSpawnFn = null
+) {
   if (validation.remediation !== 'canonical-fixers') return { attempted: false, ok: false }
 
-  for (const path of changedSourceDirectories(cwd, spawnFn)) {
+  const longRunner = resolveAsyncSpawn(spawnFn, asyncSpawnFn)
+  const changedDirectories = [...new Set([...changedSourceDirectories(cwd, spawnFn), ...changedNonCodeDirectories(cwd, spawnFn)])]
+    .toSorted()
+  for (const path of changedDirectories) {
     onProgress(`deterministic fix (${path})`)
-    const fixed = run('npx', ['@7n/rules', 'lint', '--path', path], cwd, spawnFn, {
+    const fixed = await runAsync('npx', ['@7n/rules', 'lint', '--path', path], cwd, longRunner, {
       allowFailure: true
     })
     if (fixed.status !== 0) {
@@ -1003,7 +1124,7 @@ export function remediateBehaviorState(cwd, spawnFn = spawnSync, validation = {}
   }
 
   onProgress('deterministic changelog fix')
-  const changelog = run('npx', ['@7n/rules', 'lint', 'changelog'], cwd, spawnFn, {
+  const changelog = await runAsync('npx', ['@7n/rules', 'lint', 'changelog'], cwd, longRunner, {
     allowFailure: true
   })
   if (changelog.status !== 0) {
@@ -1020,25 +1141,30 @@ export function remediateBehaviorState(cwd, spawnFn = spawnSync, validation = {}
  * Встановлює frozen Bun dependencies, якщо новий worktree їх ще не має.
  * @param {string} cwd worktree
  * @param {typeof spawnSync} spawnFn інжект
+ * @param {CommandRunner|undefined} asyncSpawnFn async runner
+ * @returns {Promise<void>} завершення install
  */
-function ensureWorktreeDependencies(cwd, spawnFn) {
+async function ensureWorktreeDependencies(cwd, spawnFn, asyncSpawnFn) {
   if (!existsSync(join(cwd, 'package.json')) || !existsSync(join(cwd, 'bun.lock'))) return
   if (existsSync(join(cwd, 'node_modules'))) return
-  run('bun', ['install', '--frozen-lockfile'], cwd, spawnFn)
+  await runAsync('bun', ['install', '--frozen-lockfile'], cwd, resolveAsyncSpawn(spawnFn, asyncSpawnFn))
 }
 
 /**
  * Фіксує test baseline на чистій policy base гілці до перенесення source.
  * @param {string} cwd worktree
  * @param {typeof spawnSync} spawnFn інжект
- * @returns {{tests:{status:number,stdout:string,stderr:string}|null}} baseline
+ * @param {CommandRunner|null} [asyncSpawnFn] async runner
+ * @returns {Promise<{tests:{status:number,stdout:string,stderr:string}|null}>} baseline
  */
-export function captureBehaviorBaseline(cwd, spawnFn = spawnSync) {
-  ensureWorktreeDependencies(cwd, spawnFn)
+export async function captureBehaviorBaseline(cwd, spawnFn = spawnSync, asyncSpawnFn = null) {
+  await ensureWorktreeDependencies(cwd, spawnFn, asyncSpawnFn)
   const packageJsonPath = join(cwd, 'package.json')
   if (!existsSync(packageJsonPath)) return { tests: null }
   const packageJson = parseJson(readFileSync(packageJsonPath, 'utf8'), {})
-  const tests = packageJson?.scripts?.test ? run('bun', ['run', 'test'], cwd, spawnFn, { allowFailure: true }) : null
+  const tests = packageJson?.scripts?.test
+    ? await runAsync('bun', ['run', 'test'], cwd, resolveAsyncSpawn(spawnFn, asyncSpawnFn), { allowFailure: true })
+    : null
   return { tests }
 }
 
@@ -1048,15 +1174,23 @@ export function captureBehaviorBaseline(cwd, spawnFn = spawnSync) {
  * @param {string} cwd worktree
  * @param {Map<string,object>} cache кеш за OID бази
  * @param {typeof spawnSync} spawnFn інжект
- * @returns {{baseline:object,cached:boolean}} baseline і ознака cache hit
+ * @param {CommandRunner|null} [asyncSpawnFn] async runner
+ * @returns {Promise<{baseline:object,cached:boolean}>} baseline і ознака cache hit
  */
-export function captureCachedBehaviorBaseline(cwd, cache, spawnFn = spawnSync) {
-  ensureWorktreeDependencies(cwd, spawnFn)
+export async function captureCachedBehaviorBaseline(cwd, cache, spawnFn = spawnSync, asyncSpawnFn = null) {
+  await ensureWorktreeDependencies(cwd, spawnFn, asyncSpawnFn)
   const baseOid = git(['rev-parse', policyBaseRef(cwd)], cwd, spawnFn).stdout.trim()
-  if (cache.has(baseOid)) return { baseline: cache.get(baseOid), cached: true }
-  const baseline = captureBehaviorBaseline(cwd, spawnFn)
-  cache.set(baseOid, baseline)
-  return { baseline, cached: false }
+  if (cache.has(baseOid)) return { baseline: await cache.get(baseOid), cached: true }
+  const pending = captureBehaviorBaseline(cwd, spawnFn, asyncSpawnFn)
+  cache.set(baseOid, pending)
+  try {
+    const baseline = await pending
+    cache.set(baseOid, baseline)
+    return { baseline, cached: false }
+  } catch (error) {
+    cache.delete(baseOid)
+    throw error
+  }
 }
 
 /**
@@ -1066,12 +1200,19 @@ export function captureCachedBehaviorBaseline(cwd, cache, spawnFn = spawnSync) {
  * @param {typeof spawnSync} spawnFn інжект
  * @param {{tests:{status:number,stdout:string,stderr:string}|null}|null} [baseline] стан policy base гілки
  * @param {(stage:string)=>void} [onProgress] stage callback
- * @returns {{ok:boolean,error?:string}} validation
+ * @param {CommandRunner|null} [asyncSpawnFn] async runner
+ * @returns {Promise<{ok:boolean,error?:string}>} validation
  */
-export function validateBehaviorState(cwd, spawnFn = spawnSync, baseline = null, onProgress = noop) {
+export async function validateBehaviorState(
+  cwd,
+  spawnFn = spawnSync,
+  baseline = null,
+  onProgress = noop,
+  asyncSpawnFn = null
+) {
   const gitState = validateGitState(cwd, spawnFn)
   if (!gitState.ok) return gitState
-  const projectGates = validateScopedProjectGates(cwd, spawnFn, onProgress)
+  const projectGates = await validateScopedProjectGates(cwd, spawnFn, onProgress, asyncSpawnFn)
   if (!projectGates.ok) return projectGates
   const postGateGitState = validateGitState(cwd, spawnFn)
   if (!postGateGitState.ok) return postGateGitState
@@ -1081,7 +1222,9 @@ export function validateBehaviorState(cwd, spawnFn = spawnSync, baseline = null,
     const packageJson = parseJson(readFileSync(packageJsonPath, 'utf8'), {})
     if (packageJson?.scripts?.test) {
       onProgress('project tests')
-      const tests = run('bun', ['run', 'test'], cwd, spawnFn, { allowFailure: true })
+      const tests = await runAsync('bun', ['run', 'test'], cwd, resolveAsyncSpawn(spawnFn, asyncSpawnFn), {
+        allowFailure: true
+      })
       if (!acceptsTestOutcome(baseline?.tests ?? null, tests)) {
         return { ok: false, error: `bun run test: ${tests.stderr || tests.stdout}` }
       }
@@ -1089,7 +1232,13 @@ export function validateBehaviorState(cwd, spawnFn = spawnSync, baseline = null,
   }
 
   onProgress('changelog')
-  const changelog = run('npx', ['@7n/rules', 'lint', 'changelog', '--no-fix'], cwd, spawnFn, { allowFailure: true })
+  const changelog = await runAsync(
+    'npx',
+    ['@7n/rules', 'lint', 'changelog', '--no-fix'],
+    cwd,
+    resolveAsyncSpawn(spawnFn, asyncSpawnFn),
+    { allowFailure: true }
+  )
   if (changelog.status !== 0) {
     return {
       ok: false,
@@ -1105,19 +1254,33 @@ export function validateBehaviorState(cwd, spawnFn = spawnSync, baseline = null,
  * manifests і правила. Code directories уже пройшли scoped lint і tests.
  * @param {string} cwd worktree
  * @param {typeof spawnSync} spawnFn інжект
- * @returns {{ok:boolean,error?:string}} gate
+ * @param {CommandRunner|null} [asyncSpawnFn] async runner
+ * @returns {Promise<{ok:boolean,error?:string}>} gate
  */
-export function validateFinalProjectGates(cwd, spawnFn = spawnSync) {
+export async function validateFinalProjectGates(cwd, spawnFn = spawnSync, asyncSpawnFn = null) {
+  const longRunner = resolveAsyncSpawn(spawnFn, asyncSpawnFn)
   for (const path of changedNonCodeDirectories(cwd, spawnFn)) {
-    const lint = run('npx', ['@7n/rules', 'lint', '--path', path, '--no-fix'], cwd, spawnFn, {
+    const lint = await runAsync('npx', ['@7n/rules', 'lint', '--path', path, '--no-fix'], cwd, longRunner, {
       allowFailure: true
     })
-    if (lint.status !== 0) return { ok: false, error: `domain lint (${path}): ${lint.stderr || lint.stdout}` }
+    if (lint.status !== 0) {
+      return {
+        ok: false,
+        error: `domain lint (${path}): ${lint.stderr || lint.stdout}`,
+        remediation: 'canonical-fixers'
+      }
+    }
   }
-  const changelog = run('npx', ['@7n/rules', 'lint', 'changelog', '--no-fix'], cwd, spawnFn, {
+  const changelog = await runAsync('npx', ['@7n/rules', 'lint', 'changelog', '--no-fix'], cwd, longRunner, {
     allowFailure: true
   })
-  if (changelog.status !== 0) return { ok: false, error: `changelog gate: ${changelog.stderr || changelog.stdout}` }
+  if (changelog.status !== 0) {
+    return {
+      ok: false,
+      error: `changelog gate: ${changelog.stderr || changelog.stdout}`,
+      remediation: 'canonical-fixers'
+    }
+  }
   return { ok: true }
 }
 
@@ -1212,17 +1375,160 @@ async function finalizeBehavior(args) {
     label: `behavior ${source}`,
     onAttempt: ({ tier }) => onProgress('behavior validation', tier),
     validate: () =>
-      validateBehaviorState(worktreeCwd, spawnFn, baseline, step => onProgress(`behavior validation: ${step}`)),
+      validateBehaviorState(
+        worktreeCwd,
+        spawnFn,
+        baseline,
+        step => onProgress(`behavior validation: ${step}`),
+        deps.asyncSpawnFn
+      ),
     remediate: validation =>
-      remediateBehaviorState(worktreeCwd, spawnFn, validation, step => onProgress(`behavior validation: ${step}`))
+      remediateBehaviorState(
+        worktreeCwd,
+        spawnFn,
+        validation,
+        step => onProgress(`behavior validation: ${step}`),
+        deps.asyncSpawnFn
+      )
   })
   if (!outcome.ok) throw new Error(`LLM behavioral verification: ${outcome.error}`)
   return outcome.text.slice(0, PROMPT_TEXT_LIMIT)
 }
 
+/**
+ * Нормалізує GitHub check/status до стабільного імені та стану.
+ * @param {object} check statusCheckRollup або check-run
+ * @returns {{name:string,state:'success'|'failure'|'pending'}} нормалізований check
+ */
+function normalizeGitHubCheck(check) {
+  const name = check.name ?? check.context ?? check.workflowName ?? 'unnamed-check'
+  const rawState = String(check.conclusion ?? check.state ?? check.status ?? '').toUpperCase()
+  const successful = ['SUCCESS', 'NEUTRAL', 'SKIPPED'].includes(rawState)
+  const pending = ['', 'EXPECTED', 'PENDING', 'QUEUED', 'IN_PROGRESS', 'REQUESTED', 'WAITING'].includes(rawState)
+  let state = 'failure'
+  if (successful) state = 'success'
+  else if (pending) state = 'pending'
+  return { name, state }
+}
+
+/**
+ * Класифікує PR checks відносно checks base commit. Будь-який pending/unknown
+ * стан fail-closed зберігає worktree; baseline-red дозволений лише коли кожен
+ * failed check уже падає на base.
+ * @param {object[]} prChecks PR statusCheckRollup
+ * @param {object[]} baseChecks check-runs base commit
+ * @returns {{status:'ready'|'pr-checks-regressed'|'pr-checks-baseline-red'|'pr-checks-unverified',error?:string}} класифікація
+ */
+export function classifyPullRequestChecks(prChecks, baseChecks) {
+  const normalizedPr = prChecks.map(check => normalizeGitHubCheck(check))
+  const pending = normalizedPr.filter(check => check.state === 'pending')
+  if (pending.length > 0) {
+    return {
+      status: 'pr-checks-unverified',
+      error: `Незавершені PR checks: ${pending.map(check => check.name).join(', ')}`
+    }
+  }
+  const failed = normalizedPr.filter(check => check.state === 'failure')
+  if (failed.length === 0) return { status: 'ready' }
+
+  const failedOnBase = new Set(
+    baseChecks
+      .map(check => normalizeGitHubCheck(check))
+      .filter(check => check.state === 'failure')
+      .map(check => check.name)
+  )
+  const regressions = failed.filter(check => !failedOnBase.has(check.name))
+  if (regressions.length > 0) {
+    return {
+      status: 'pr-checks-regressed',
+      error: `Нові failed PR checks: ${regressions.map(check => check.name).join(', ')}`
+    }
+  }
+  return {
+    status: 'pr-checks-baseline-red',
+    error: `PR checks повторюють failed base checks: ${failed.map(check => check.name).join(', ')}`
+  }
+}
+
+/**
+ * Чекає terminal CI state й порівнює failed checks з base commit.
+ * @param {object} args PR context
+ * @returns {Promise<{status:string,error?:string}>} readiness
+ */
+export async function verifyPullRequestReadiness(args) {
+  const { url, cwd, spawnFn = spawnSync, asyncSpawnFn } = args
+  const longRunner = resolveAsyncSpawn(spawnFn, asyncSpawnFn)
+  await runAsync('gh', ['pr', 'checks', url, '--watch', '--interval', '10'], cwd, longRunner, {
+    allowFailure: true,
+    timeoutMs: PR_CHECK_TIMEOUT_MS
+  })
+  const view = await runAsync(
+    'gh',
+    ['pr', 'view', url, '--json', 'statusCheckRollup,baseRefOid'],
+    cwd,
+    longRunner,
+    { allowFailure: true }
+  )
+  if (view.status !== 0) {
+    return { status: 'pr-checks-unverified', error: `Не вдалося прочитати PR checks: ${view.stderr || view.error}` }
+  }
+  const pr = parseJson(view.stdout, null)
+  if (!pr || !Array.isArray(pr.statusCheckRollup) || !pr.baseRefOid) {
+    return { status: 'pr-checks-unverified', error: 'GitHub повернув неповний PR check rollup' }
+  }
+  const repository = await runAsync(
+    'gh',
+    ['repo', 'view', '--json', 'nameWithOwner', '--jq', '.nameWithOwner'],
+    cwd,
+    longRunner,
+    { allowFailure: true }
+  )
+  if (repository.status !== 0 || !repository.stdout.trim()) {
+    return { status: 'pr-checks-unverified', error: `Не вдалося визначити GitHub repository: ${repository.stderr}` }
+  }
+  const base = await runAsync(
+    'gh',
+    ['api', `repos/${repository.stdout.trim()}/commits/${pr.baseRefOid}/check-runs?per_page=100`],
+    cwd,
+    longRunner,
+    { allowFailure: true }
+  )
+  if (base.status !== 0) {
+    return { status: 'pr-checks-unverified', error: `Не вдалося прочитати base checks: ${base.stderr || base.error}` }
+  }
+  const basePayload = parseJson(base.stdout, null)
+  if (!basePayload || !Array.isArray(basePayload.check_runs)) {
+    return { status: 'pr-checks-unverified', error: 'GitHub повернув неповний base check rollup' }
+  }
+  return classifyPullRequestChecks(pr.statusCheckRollup, basePayload.check_runs)
+}
+
+/**
+ * Запускає final gates і один canonical remediation pass.
+ * @param {object} args gate context
+ * @returns {Promise<{ok:boolean,error?:string}>} фінальний стан
+ */
+async function passFinalProjectGates(args) {
+  const { cwd, spawnFn, asyncSpawnFn, onProgress } = args
+  let finalGates = await validateFinalProjectGates(cwd, spawnFn, asyncSpawnFn)
+  if (finalGates.ok || finalGates.remediation !== 'canonical-fixers') return finalGates
+
+  onProgress('canonical final remediation')
+  const remediation = await remediateBehaviorState(
+    cwd,
+    spawnFn,
+    finalGates,
+    step => onProgress(`canonical final remediation: ${step}`),
+    asyncSpawnFn
+  )
+  if (!remediation.ok) return { ok: false, error: remediation.error ?? finalGates.error }
+  finalGates = await validateFinalProjectGates(cwd, spawnFn, asyncSpawnFn)
+  return finalGates
+}
+
 /**
  * Створює один готовий PR. При будь-якому провалі worktree лишається для
- * ручного відновлення; прибирається тільки після успішного gh pr create.
+ * ручного відновлення; прибирається тільки після успішних CI checks.
  * @param {object} args параметри
  * @returns {Promise<{status:string,url?:string,branch?:string,error?:string,worktree?:string}>} результат
  */
@@ -1247,7 +1553,7 @@ async function createPullRequest(args) {
     let baseline = null
     if (sourceMayChangeCode) {
       onProgress('baseline tests')
-      const captured = captureCachedBehaviorBaseline(worktree.cwd, baselineCache, spawnFn)
+      const captured = await captureCachedBehaviorBaseline(worktree.cwd, baselineCache, spawnFn, deps.asyncSpawnFn)
       baseline = captured.baseline
       if (captured.cached) onProgress('baseline tests (cached)')
     }
@@ -1292,15 +1598,22 @@ async function createPullRequest(args) {
       git(['diff', '--cached', '--quiet'], worktree.cwd, spawnFn, {
         allowFailure: true
       }).status !== 0
-    if (staged) git(['commit', '-m', group.title], worktree.cwd, spawnFn)
+    if (!staged) throw new Error('Після Git validation немає staged змін')
     if (!hasChangesFromBase(worktree.cwd, spawnFn)) {
       onProgress('remove no-op worktree')
       removeReconcileWorktree(worktree, rootCwd, spawnFn)
       return { status: 'patch-equivalent', branch: worktree.branch }
     }
     onProgress('delta lint')
-    const finalGates = validateFinalProjectGates(worktree.cwd, spawnFn)
+    const finalGates = await passFinalProjectGates({
+      cwd: worktree.cwd,
+      spawnFn,
+      asyncSpawnFn: deps.asyncSpawnFn,
+      onProgress
+    })
     if (!finalGates.ok) throw new Error(finalGates.error)
+    git(['add', '-A'], worktree.cwd, spawnFn)
+    git(['commit', '-m', group.title], worktree.cwd, spawnFn)
     const baseRef = policyBaseRef(worktree.cwd)
     const baseBranch = readGitPolicy(worktree.cwd).baseBranch
     git(['diff', '--check', `${baseRef}...HEAD`], worktree.cwd, spawnFn)
@@ -1327,6 +1640,23 @@ async function createPullRequest(args) {
       worktree.cwd,
       spawnFn
     ).stdout.trim()
+    onProgress('PR checks')
+    const readinessVerifier = deps.verifyPullRequestReadiness ?? verifyPullRequestReadiness
+    const readiness = await readinessVerifier({
+      url: createdPr,
+      cwd: worktree.cwd,
+      spawnFn,
+      asyncSpawnFn: deps.asyncSpawnFn
+    })
+    if (readiness.status !== 'ready') {
+      return {
+        status: readiness.status,
+        error: readiness.error,
+        url: createdPr,
+        branch: worktree.branch,
+        worktree: worktree.cwd
+      }
+    }
     onProgress('remove worktree')
     removeReconcileWorktree(worktree, rootCwd, spawnFn)
     return { status: 'pr-created', url: createdPr, branch: worktree.branch }
@@ -1392,13 +1722,29 @@ function formatRemovedRefs(cleanup) {
   return `; refs=${refs}`
 }
 
+/**
+ * Рахує точні outcomes без змішування створеного PR з CI-ready PR.
+ * @param {Array<{status:string}>} results результати materialization
+ * @returns {string} стабільний summary
+ */
+export function formatOutcomeCounts(results) {
+  const counts = new Map()
+  for (const result of results) counts.set(result.status, (counts.get(result.status) ?? 0) + 1)
+  return counts
+    .keys()
+    .toArray()
+    .toSorted((left, right) => left.localeCompare(right))
+    .map(status => `${status}=${counts.get(status)}`)
+    .join(', ')
+}
+
 /**
  * Формує deterministic report.
  * @param {{inventory:object,results:Array<object>}} args дані
  * @returns {string} markdown
  */
 export function formatReport({ inventory, results }) {
-  const lines = ['## git-reconcile: підсумок']
+  const lines = ['## git-reconcile: підсумок', `- Outcomes: ${formatOutcomeCounts(results) || 'none'}`]
   for (const branch of inventory.branches) {
     if (branch.state === 'review') continue
     let suffix = ''
@@ -1697,7 +2043,7 @@ export async function runGitReconcileOrchestrator(options = {}) {
   const baselineCache = new Map()
 
   const inventoryStartedAt = now()
-  log('⏳ 1/4 inventory')
+  log('⏳ етап 1/4: inventory')
   const inventory = inventoryFn(rootCwd, { spawnFn })
   if (deps.ensureLocalWorktreeExclude !== false) {
     const ensureExclude = deps.ensureLocalWorktreeExclude ?? ensureLocalWorktreeExclude
@@ -1705,14 +2051,14 @@ export async function runGitReconcileOrchestrator(options = {}) {
   }
   const candidates = [...inventory.branches, ...inventory.stashes].filter(item => item.state === 'review')
   log(
-    `✅ 1/4 inventory · ${elapsedLabel(inventoryStartedAt, now)} · ${inventory.branches.length} branches · ${inventory.stashes.length} stash`
+    `✅ етап 1/4: inventory · ${elapsedLabel(inventoryStartedAt, now)} · ${inventory.branches.length} branches · ${inventory.stashes.length} stash`
   )
 
   const triageTotal = Math.ceil(candidates.length / REVIEW_BATCH_SIZE)
   const triageProgress = createPhaseProgress({
     total: triageTotal,
     unitLabel: 'triage-пакетів',
-    phase: '2/4 triage',
+    phase: 'етап 2/4: triage',
     log,
     now,
     heartbeatMs,
@@ -1734,7 +2080,7 @@ export async function runGitReconcileOrchestrator(options = {}) {
   } finally {
     triageProgress.stop()
   }
-  log(`✅ 2/4 triage · ${elapsedLabel(triageStartedAt, now)} · ${triageTotal} batches`)
+  log(`✅ етап 2/4: triage · ${elapsedLabel(triageStartedAt, now)} · ${triageTotal} batches`)
 
   const prTotal = decisions.reduce((total, decision) => {
     return total + (decision.action === 'pr' && Array.isArray(decision.groups) ? decision.groups.length : 0)
@@ -1742,7 +2088,7 @@ export async function runGitReconcileOrchestrator(options = {}) {
   const prProgress = createPhaseProgress({
     total: prTotal,
     unitLabel: 'PR-груп',
-    phase: '3/4 PR',
+    phase: 'етап 3/4: PR',
     log,
     now,
     heartbeatMs,
@@ -1769,14 +2115,16 @@ export async function runGitReconcileOrchestrator(options = {}) {
   } finally {
     prProgress.stop()
   }
-  log(`✅ 3/4 PR · ${elapsedLabel(prStartedAt, now)} · ${prTotal} groups`)
+  log(
+    `✅ етап 3/4: PR · ${elapsedLabel(prStartedAt, now)} · ${prTotal} groups · ${formatOutcomeCounts(materialized.results) || 'none'}`
+  )
 
   const { bySource, results } = materialized
   const cleanupCount = countCleanupSources(inventory, bySource, results)
   const cleanupProgress = createPhaseProgress({
     total: cleanupCount,
     unitLabel: 'джерел',
-    phase: '4/4 cleanup',
+    phase: 'етап 4/4: cleanup',
     log,
     now,
     heartbeatMs,
@@ -1806,10 +2154,16 @@ export async function runGitReconcileOrchestrator(options = {}) {
   } finally {
     cleanupProgress.stop()
   }
-  log(`✅ 4/4 cleanup · ${elapsedLabel(cleanupStartedAt, now)} · ${cleanupCount} sources`)
+  log(`✅ етап 4/4: cleanup · ${elapsedLabel(cleanupStartedAt, now)} · ${cleanupCount} sources`)
 
   const report = formatReport({ inventory, results })
   log(report)
-  const ok = results.every(result => result.status !== 'failed' && result.incomplete !== true)
+  const blockingStatuses = new Set([
+    'failed',
+    'pr-checks-regressed',
+    'pr-checks-baseline-red',
+    'pr-checks-unverified'
+  ])
+  const ok = results.every(result => !blockingStatuses.has(result.status) && result.incomplete !== true)
   return { ok, report, inventory, results }
 }