@7n/rules 1.49.11 → 1.49.13

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.49.13] - 2026-07-26
+
+### Fixed
+
+- pass coverage mutation verdict feedback to the next ladder rung
+
+## [1.49.12] - 2026-07-26
+
+### Fixed
+
+- Git-reconcile отримав ANSI-free progress, heartbeat, canonical fixer pass і bounded parallel PR jobs.
+
 ## [1.49.11] - 2026-07-26
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/rules",
-  "version": "1.49.11",
+  "version": "1.49.13",
   "description": "CLI еталонних правил і skills (префікс n-): синк у репозиторій, дельта-lint, конформність",
   "keywords": [
     "cli",
@@ -65,7 +65,7 @@
     "rename-yaml-extensions": "bun ./bin/n-rules.js rename-yaml-extensions"
   },
   "dependencies": {
-    "@7n/llm-lib": "2.9.6",
+    "@7n/llm-lib": "2.9.7",
     "@7n/mt": "^0.5.1",
     "@zed-industries/agent-client-protocol": "^0.4.5",
     "ajv": "^8.20.0",

package/rules/changelog/consistency/docs/main.md

@@ -3,7 +3,7 @@ type: JS Module
 title: main.mjs
 resource: npm/rules/changelog/consistency/main.mjs
 docgen:
-  crc: 40857795
+  crc: 3d8d2a45
   model: openai-codex/gpt-5.4-mini
   tier: cloud-min
   score: 95
@@ -22,7 +22,7 @@ docgen:
 3. Для кожного workspace оцінює, чи є релевантні зміни відносно цієї бази, і відсікає шум від ігнорованих changelog-шляхів та ignore-правил. Це потрібно, щоб перевірка реагувала лише на зміни, які справді потребують bump або change-файлу.
 4. Для published workspace перевіряє, що changelog присутній і має базовий формат, а також що опублікована версія не відстає від локальної. Якщо версія в дереві випереджає опубліковану — це вважається ручним bump поза CI, а не штатним станом.
 5. Якщо published workspace має релевантні Git-зміни без change-файлу, або фіксує це як помилку, або в autofix-режимі створює change-файл із автоматичним описом і ставить його в індекс, щоб коміт не падав. Для published-пакетів додатково вимагається, щоб `files` у маніфесті містив `CHANGELOG.md`, бо релізний changelog має публікуватися разом із пакетом.
-6. Для workspace, які змінюються лише локально, звіряє версію з базою порівняння, перевіряє наявність незрелізних change-файлів і, якщо треба, також пропонує або створює change-файл. Повідомлення формуються в стилі, сумісному з правилами ``.
+6. Для workspace, які змінюються лише локально, звіряє версію з базою порівняння, перевіряє наявність невипущених change-файлів і, якщо треба, також пропонує або створює change-файл. Повідомлення формуються в стилі, сумісному з правилами ``.
 7. Резолвить опубліковану версію залежно від типу пакета: для Python орієнтується на PyPI, для інших — на npm. Пошук публікації йде через `https://pypi.org/pypi/`, а також через конфігурацію `res.json`, якщо вона визначає очікувану поведінку workspace.
 8. Працює fail-safe: мережеві чи git-помилки не пробиваються назовні як винятки, а перетворюються на м’який результат або перевірочний фейл, щоб один збій не ламав увесь lint-прогін.
 

package/rules/changelog/consistency/main.mjs

@@ -602,7 +602,10 @@ async function checkPublishedWorkspacePendingGitChanges(manifest, _Vcurrent, sub
     return
   }
 
-  if (policy.releaseBranches.includes(branch ?? '') && (await workspaceHasRelevantChangesAgainstBase('HEAD', manifest.ws, subWorkspaces, cwd))) {
+  if (
+    policy.releaseBranches.includes(branch ?? '') &&
+    (await workspaceHasRelevantChangesAgainstBase('HEAD', manifest.ws, subWorkspaces, cwd))
+  ) {
     await fixOrFailPublishedWorkspace(manifest, label, mf, autofix, pass, fail, cwd)
   }
 }

package/rules/test/coverage/fix-worker.mjs

@@ -90,6 +90,7 @@ export async function fixWorker(violations, ctx, deps = {}) {
   const touchedFiles = []
   /** @type {Array<{provider: string, hook: string, files: string[], error: string}>} */
   const failed = []
+  let feedback = null
   const deferred = []
   /**
    * Викликає опційний fix-hook провайдера, збирає touchedFiles; виняток хука не
@@ -104,6 +105,7 @@ export async function fixWorker(violations, ctx, deps = {}) {
     try {
       const res = await provider[hook]({ ...args, cwd: ctx.cwd, ctx: hookCtx(ctx, deadlineAt) })
       touchedFiles.push(...(res?.touchedFiles ?? []))
+      if (res?.feedback?.previousError) feedback = res.feedback
       deferred.push(...(res?.deferred ?? []))
       for (const failure of res?.failed ?? []) {
         const error = failure?.error ?? 'невідома причина'
@@ -135,5 +137,5 @@ export async function fixWorker(violations, ctx, deps = {}) {
     }
   }
 
-  return { touchedFiles, failed, deferred }
+  return { touchedFiles, failed, deferred, feedback }
 }

package/scripts/lib/changed-files.mjs

@@ -67,7 +67,10 @@ export function resolveChangedBase(cwd = process.cwd(), baseRef = null) {
   }
   if (baseRef) return mergeBaseWith(baseRef) || null
   const { integrationBranches } = readGitPolicy(cwd)
-  const bases = integrationBranches.flatMap(name => [`origin/${name}`, name]).map(mergeBaseWith).filter(Boolean)
+  const bases = integrationBranches
+    .flatMap(name => [`origin/${name}`, name])
+    .map(ref => mergeBaseWith(ref))
+    .filter(Boolean)
   if (bases.length === 0) return null
   let newest = bases[0]
   for (const candidate of bases.slice(1)) {

package/scripts/lib/docs/changed-files.md

@@ -3,7 +3,7 @@ type: JS Module
 title: changed-files.mjs
 resource: npm/scripts/lib/changed-files.mjs
 docgen:
-  crc: 0482c036
+  crc: 2bf61f5b
   model: openai-codex/gpt-5.5
   tier: cloud-avg
   score: 100
@@ -25,7 +25,7 @@ docgen:
 
 `collectChangedFilesSince` споживає базу з `resolveChangedBase` або її відсутність. За наявної бази вона збирає всі файли, змінені від цієї бази до поточного робочого дерева, включно із закоміченими після бази, staged і незакоміченими змінами, та додає untracked файли. За відсутньої бази делегує збір до `collectChangedFiles`.
 
-Усі результати є списками унікальних шляхів для наступних lint-етапів. Для обох режимів діє спільне правило: видалені файли не потрапляють у scope, а файли всередині службових worktree-чекаутів відкидаються, щоб сесійні копії репозиторію не лінтилися як робочий код. Поза git-репозиторієм або при помилці git звичайний quick-збір повертає порожній список, але scoped-збір із недосяжною базою завершується явною помилкою, щоб перевірка не пройшла з порожнім scope помилково.
+Усі результати є списками унікальних шляхів для наступних lint-етапів. Для обох режимів діє спільне правило: видалені файли не потрапляють у scope, а файли всередині службових worktree-чекаутів відкидаються, щоб сесійні копії репозиторію не перевірялися як робочий код. Поза git-репозиторієм або при помилці git звичайний quick-збір повертає порожній список, але scoped-збір із недосяжною базою завершується явною помилкою, щоб перевірка не пройшла з порожнім scope помилково.
 
 ## Публічний API
 

package/scripts/lib/docs/git-policy.md

@@ -3,7 +3,7 @@ type: JS Module
 title: git-policy.mjs
 resource: npm/scripts/lib/git-policy.mjs
 docgen:
-  crc: 5809ac19
+  crc: 057bf20c
   model: openai-codex/gpt-5.5
   tier: cloud-avg
   score: 100

package/scripts/lib/git-policy.mjs

@@ -22,7 +22,7 @@ function branchName(value) {
  * Повертає effective policy. `releaseBranches` одночасно є integration-кандидатами
  * delta та захищеними довгоживучими гілками; `baseBranch` додається до обох наборів.
  * @param {string} [cwd] корінь репозиторію
- * @returns {{baseBranch:string,releaseBranches:string[],integrationBranches:string[],protectedBranches:string[]}}
+ * @returns {{baseBranch:string,releaseBranches:string[],integrationBranches:string[],protectedBranches:string[]}} effective Git policy
  */
 export function readGitPolicy(cwd = process.cwd()) {
   let raw = null
@@ -38,7 +38,9 @@ export function readGitPolicy(cwd = process.cwd()) {
   }
   const git = raw && typeof raw.git === 'object' && !Array.isArray(raw.git) ? raw.git : {}
   const baseBranch = branchName(git.baseBranch) ?? DEFAULT_BASE_BRANCH
-  const configuredRelease = Array.isArray(git.releaseBranches) ? git.releaseBranches.map(branchName).filter(Boolean) : []
+  const configuredRelease = Array.isArray(git.releaseBranches)
+    ? git.releaseBranches.map(value => branchName(value)).filter(Boolean)
+    : []
   const releaseBranches = configuredRelease.length > 0 ? [...new Set(configuredRelease)] : [DEFAULT_BASE_BRANCH]
   const integrationBranches = [...new Set([baseBranch, ...releaseBranches])]
   return { baseBranch, releaseBranches, integrationBranches, protectedBranches: integrationBranches }

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

@@ -454,6 +454,10 @@ async function runRung(rung, worker, violations, feedback, rungDeps) {
 
   const vetoed = after.length === 0 && !error && (collateralAll.length > 0 || brokenTest !== null)
   const touchedFiles = workerResult?.touchedFiles ?? []
+  // Provider може повернути quality-verdict без worker exception (наприклад,
+  // generated coverage test зелений у Vitest, але не вбив target mutant). Це
+  // не змінює retry policy; лише дає наступному ladder rung-у конкретний feedback.
+  const workerFeedback = workerResult?.feedback?.previousError ?? null
 
   if (after.length === 0 && !error && !vetoed) {
     log(`  ✅ ${rung.tier} (${rung.model}): ${ruleId}/${concernName}\n`)
@@ -501,7 +505,7 @@ async function runRung(rung, worker, violations, feedback, rungDeps) {
     outcome: {
       action: decideAfterFailure(rung, error),
       violations: after.length > 0 ? after : violations,
-      feedback: { previousModel: rung.model, previousError: error ?? silentFailureNote }
+      feedback: { previousModel: rung.model, previousError: error ?? workerFeedback ?? silentFailureNote }
     }
   }
 }

package/skills/git-reconcile/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: n-git-reconcile
 description: >-
-  JS-оркестрований аналіз git-гілок, worktree та stash відносно актуального
-  origin/main: детерміновано відсіює merged і patch-equivalent refs, передає
+  JS-оркестрований аналіз git-гілок, worktree та stash відносно актуальної
+  policy base branch: детерміновано відсіює merged і patch-equivalent refs, передає
   LLM лише semantic triage та conflict resolution, а корисні зміни переносить
   у перевірені PR. Використовуй, коли просять розібрати, консолідувати,
   підготувати PR або безпечно почистити старі Git refs і stash.
@@ -22,7 +22,7 @@ npx @7n/rules skill pi git-reconcile
 ## Розподіл відповідальності
 
 JS виконує `fetch`, inventory, patch-equivalence, дедуплікацію refs, збір
-worktree/PR/stash, підготовку worktree від `origin/main`, cherry-pick або
+worktree/PR/stash, підготовку worktree від `origin/<baseBranch>`, cherry-pick або
 застосування stash, gates, commit, push, PR і фінальний звіт. Semantic no-op
 після conflict resolution детерміновано пропускає через `cherry-pick --skip`;
 порожній tree diff не push-иться і не створює PR.
@@ -39,30 +39,38 @@ doc generation, lint і changelog gates запускає JS після cognitive
 Doc-files і unified lint отримують лише унікальні директорії зміненого коду,
 щоб repository-wide baseline та stale docs поза scope не забруднювали PR.
 
-Оркестратор показує чесний фазовий progress: inventory має elapsed time без
-вигаданого total, а `triage`, `PR` і `cleanup` — окремі точні bars за вже
-відомими batches/groups/sources. Поточний LLM-етап показує tier `min` або
-`max`. У non-TTY/CI замість перемальовування виводяться append-only рядки.
+Оркестратор показує чесний ANSI-free фазовий progress: inventory має elapsed
+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.
+
+Незалежні PR-групи виконуються з bounded concurrency `3`; override
+`N_GIT_RECONCILE_CONCURRENCY=1..4`. Порядок фінального звіту лишається
+детермінованим, а cleanup починається лише після завершення всіх PR jobs.
 
 Кожен LLM-крок починається на tier `min`. JS детерміновано перевіряє:
 
 - triage — повноту verdicts, schema, groups і commit OID;
 - worktree — відсутність conflict markers та `git diff --check`;
-- поведінку — repository test script відносно test baseline чистого
-  `origin/main` і changelog gate. Red baseline приймається лише для
+- поведінку — repository test script відносно test baseline чистої
+  `origin/<baseBranch>` і changelog gate. Red baseline приймається лише для
   розпізнаних Vitest failures, якщо після перенесення не додалось нових.
 - змінений код — scoped `doc-files` у fix-режимі та unified lint у
   `--no-fix`, окремо для кожної code directory.
 
-Лише валідна відповідь runner, яка провалила validation, запускає повтор того
-самого bounded-завдання на `max` із точною причиною провалу. Infrastructure
+Після min validation failure JS спершу запускає canonical scoped/changelog
+fixers. Якщо вони детерміновано усунули format, CSpell, docs або changeset
+дефект, min приймається без `max`. Лише residual behavioral failure запускає
+повтор того самого bounded-завдання на `max` із точною причиною. Infrastructure
 failure runner завершує крок одразу: повтор іншою моделлю не маскує проблему
 transport. Після провалу `max` джерело fail-closed лишається `kept` або
 `failed`, не потрапляє в cleanup, а неповний triage завершує команду non-zero.
 
 ## Інваріанти
 
-- База — тільки свіжий `origin/main`.
+- База — тільки свіжий `origin/<baseBranch>` із repository Git policy.
 - Живі worktree, включно з detached HEAD за commit OID, та гілки відкритих
   PR — protected.
 - Стара дата або великий divergence не означають, що зміна непотрібна.
@@ -72,13 +80,18 @@ transport. Після провалу `max` джерело fail-closed лишає
   відсутніх conflicts і порожнього staged diff.
 - Вкладені `npx` не успадковують package selector зовнішнього
   `npm exec --package`.
+- Перед створенням worktree JS додає `.worktrees/` до локального
+  `.git/info/exclude`, не змінюючи tracked `.gitignore` consumer-а.
+- ACP semantic idle watchdog не подовжується від `usage`, thought,
+  config або повторних tool-update events; його скидають лише новий tool-call
+  чи agent output.
 - За невизначеності джерело лишається `kept`; misleading ready PR не
   створюється.
 - Перед push обов'язково проходять фінальний tree-diff guard, domain lint для
   non-code paths, changelog і `git diff --check`; code changes додатково
   проходять scoped docs/lint та tests.
 - Behavioral LLM не викликається для змін без code paths; test baseline
-  актуального `origin/main` кешується між PR-групами.
+  актуальної policy base branch кешується між PR-групами.
 - Cleanup виконує лише JS і тільки після inventory/PR-фази: видаляє точні refs,
   уже merged/patch-equivalent, явно класифіковані як `drop` або повністю
   перенесені в успішний PR.

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

@@ -3,64 +3,86 @@ type: JS Module
 title: orchestrate.mjs
 resource: npm/skills/git-reconcile/js/orchestrate.mjs
 docgen:
-  crc: f0c9ea76
-  model: omlx/gemma-4-e4b-it-OptiQ-4bit
-  score: 70
+  crc: c3233b69
+  model: openai-codex/gpt-5.5
+  tier: cloud-avg
+  score: 100
 ---
 
 ## Огляд
 
-Модуль узгоджує Git branches, worktree і stash зі свіжим `origin/main`.
-JS виконує inventory, validation, materialization, gates, PR і cleanup, а LLM
-отримує лише bounded semantic triage, conflict resolution та behavioral edits.
+Файл координує Git reconcile-орchestrator: інвентаризує repository refs і worktrees, прибирає дублікати refs, визначає conflict files, формує triage prompt, перевіряє decision envelope та застосовує рішення через runner. Він існує, щоб переносити cleanup у перевірюваний процес із behavior baseline, cached baseline у межах прогону, validation gates, контрольованим concurrency і детермінованим Markdown-звітом.
 
 ## Поведінка
 
-- Збирає refs, aliases, worktree, open PR, patch-equivalent commits і stash.
-  Detached worktree захищає за checkout HEAD OID.
-- Ізолює вкладені `npx` від `npm_config_package` зовнішнього `npm exec`.
-- Приглушує дубльовані ACP events, якщо користувач не ввімкнув explicit verbose.
-- Показує inventory elapsed time та окремі progress bars для triage, PR і
-  cleanup; довгі deterministic gates отримують окремі stage labels.
-- Перевіряє повноту triage, groups та commit OID. `max` запускається лише після
-  конкретного провалу validation.
-- Створює worktree від `origin/main`; baseline tests кешує за OID бази між
-  PR-групами. Для змін без code paths behavioral LLM не викликається.
-- Red baseline допускається лише для розпізнаних Vitest failures без нових
-  failures після перенесення.
-- Для code paths запускає scoped `doc-files`, lint і tests. Перед push запускає
-  domain lint для non-code paths, changelog та `git diff --check`.
-- Після conflict resolution порожній cherry-pick пропускається лише за
-  активного `CHERRY_PICK_HEAD`, відсутніх conflicts і порожнього staged diff.
-- Tree-diff guard двічі відсікає semantic no-op. Порожня група отримує
-  `patch-equivalent`, worktree прибирається, push і PR не виконуються.
-- Cleanup видаляє всі точні local/remote aliases і звітує їх. Failed source
-  зберігає branch, worktree і, якщо PR уже створено, його URL.
+`runGitReconcileOrchestrator` керує всім потоком: збирає Git-стан через `inventoryRepository`, веде фазовий progress через `createPhaseProgress`, запускає bounded triage, матеріалізує рішення у PR-пайплайн, виконує cleanup і повертає звіт через `formatReport`. Паралельність PR-фази обмежується `normalizePrConcurrency`, а незалежні задачі виконуються через `runWithConcurrency` зі стабільним порядком результатів.
+
+`inventoryRepository` отримує факти з локального checkout і remote refs, оновлює remote refs через fetch --prune, але не змінює робочі файли. `parseWorktrees` і `dedupeRefs` зводять worktree-захист, branch refs, aliases і commit identity в один детермінований inventory, щоб protected або відкриті джерела не потрапили в небезпечний cleanup. `conflictFiles` додає до inventory ранню оцінку потенційних merge-conflicts.
+
+Для review-кандидатів `buildTriagePrompt` формує обмежене завдання для LLM: модель отримує вже пораховані Git-факти й має повернути лише JSON-рішення. `callRunner` викликає обраний runner, `parseDecisionEnvelope` дістає структуровану відповідь, а `validateTriageOutcome` приймає тільки повний і узгоджений набір рішень для поточного batch. `callWithValidatedFallback` спершу пробує дешевший рівень, а дорожчий використовує лише після конкретного validation failure.
+
+Під час матеріалізації рішення source переноситься у керований worktree. `branchSlug` забезпечує передбачувані rescue-гілки, а `ensureLocalWorktreeExclude` не дає службовим worktree забруднювати root `git status`. Якщо cherry-pick стає порожнім, `skipEmptyCherryPick` дозволяє skip лише для доведеного semantic no-op, а `finishCherryPick` завершує активний перенос без прийняття неперевіреного Git-стану. `hasChangesFromBase` відсікає PR без реального tree diff.
+
+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 рішень.
 
 ## Публічний API
 
-- `parseWorktrees` — парсить `git worktree list --porcelain`.
-- `dedupeRefs` — зводить local/remote refs одного commit зі збереженням aliases.
-- `inventoryRepository` — збирає детермінований Git inventory.
-- `callWithValidatedFallback` — виконує min → validation → max fallback.
-- `finishCherryPick` — пропускає semantic no-op або продовжує непорожній pick.
-- `hasChangesFromBase` — перевіряє реальний tree diff, а не commits ahead.
-- `captureCachedBehaviorBaseline` — кешує test baseline за OID `origin/main`.
-- `changedNonCodeDirectories` — групує non-code paths у domain directories.
-- `validateBehaviorState` — перевіряє scoped code gates і test regression.
-- `validateFinalProjectGates` — перевіряє non-code domains та changelog.
-- `cleanupSource` — видаляє тільки доказово безпечні точні refs або stash.
-- `formatReport` — формує deterministic звіт із cleanup та failure details.
-- `runGitReconcileOrchestrator` — координує inventory, triage, PR і cleanup.
+- createPhaseProgress — Створює ANSI-free snapshot progress для однієї фази. Однаковий append-only
+формат у TTY/CI не засмічує captured output cursor-control кодами, а
+heartbeat показує elapsed time довгих LLM-етапів.
+- parseWorktrees — Парсить `git worktree list --porcelain` у branch→path.
+- dedupeRefs — Дедуплікує local/remote refs одного commit: remote має пріоритет, але
+worktree-protection локального ref переноситься у запис.
+- conflictFiles — Витягає конфліктні файли з `git merge-tree`.
+- inventoryRepository — Збирає детермінований Git inventory. Нічого не видаляє і не змінює у
+checkout, крім оновлення remote refs через fetch --prune.
+- buildTriagePrompt — Формує bounded semantic-triage prompt. Git-факти вже пораховані JS; модель
+не виконує shell-команди й повертає лише JSON-рішення.
+- parseDecisionEnvelope — Витягає JSON object із чистої або fenced відповіді.
+- callRunner — Викликає вибраний LLM runner для одного bounded-завдання.
+- callWithValidatedFallback — Виконує bounded LLM-крок через min, валідовує результат JS-функцією і
+викликає max лише після конкретного провалу.
+- validateTriageOutcome — Структурно перевіряє triage-рішення: рівно один verdict на candidate,
+валідні actions/groups і лише відомі commit OID.
+- branchSlug — Перетворює довільний title/ref на branch slug.
+- ensureLocalWorktreeExclude — Додає `.worktrees/` до локального Git exclude без tracked-змін у consumer.
+Це не замінює repository Vitest excludes, але не лишає root checkout dirty
+через керовані або forensic worktree.
+- skipEmptyCherryPick — Пропускає лише підтверджений empty cherry-pick: sequencer активний,
+конфліктів немає, staged diff порожній.
+- finishCherryPick — Завершує активний cherry-pick: semantic no-op пропускає, непорожній
+продовжує. Відсутній sequencer не потребує дії.
+- hasChangesFromBase — Перевіряє реальний tree diff, а не лише кількість commits ahead.
+- testFailureSignatures — Витягає стабільні Vitest failure identifiers без summary/timing.
+- acceptsTestOutcome — Дозволяє red baseline лише якщо після перенесення не з'явилось нових
+Vitest failures. Нерозпізнаний red output завжди fail-closed.
+- sourceDirectories — Зводить змінені code paths до найвужчих директорій для scoped gates.
+- changedNonCodeDirectories — Повертає директорії non-code змін для фінального domain lint.
+- remediateBehaviorState — Запускає canonical fixers у worktree до ескалації min→max. Це прибирає
+formatting/CSpell/doc/changelog дефекти без повторного behavioral LLM.
+- captureBehaviorBaseline — Фіксує test baseline на чистій policy base branch до перенесення source.
+- captureCachedBehaviorBaseline — Повторно використовує test baseline однієї policy base branch між PR-групами.
+Залежності все одно встановлюються в кожному окремому worktree.
+- validateBehaviorState — Додає до Git-state validation test script із репозиторію і changelog gate.
+Саме ці докази вирішують, чи приймати min-результат або ескалювати на max.
+- validateFinalProjectGates — Фінальний domain gate охоплює non-code зміни, зокрема workflows, dependency
+manifests і правила. Code directories уже пройшли scoped lint і tests.
+- cleanupSource — Видаляє точний source після Git-доказу неактуальності або успішного
+перенесення. Protected/open-PR refs не потрапляють у цей крок.
+- formatReport — Формує deterministic report.
+- runWithConcurrency — Виконує async jobs із bounded concurrency та стабільним порядком output.
+- normalizePrConcurrency — Нормалізує bounded concurrency PR-фази.
+- runGitReconcileOrchestrator — JS-оркестратор: inventory → bounded LLM triage → deterministic PR pipeline.
 
 ## Гарантії поведінки
 
-- Shell interpolation не використовується: executable та arguments
-  передаються окремо.
-- Live worktree, open PR, `kept`, incomplete triage та failed source не
-  видаляються.
-- Stash видаляється точково за стабільним commit ID; `git stash clear` не
-  використовується.
-- Worktree із проваленим перенесенням зберігається для діагностики.
-- Порожній tree diff не може створити remote branch або PR.
-- Progress не змішує фази з різною вартістю в удаваний global percentage.
+- Progress є append-only та не містить ANSI cursor-control sequences.
+- Не більше чотирьох PR-груп виконуються одночасно; типовий ліміт — три.
+- Canonical fixers мають пріоритет перед behavioral `max` fallback.
+- Cleanup починається лише після завершення всіх PR jobs і не видаляє
+  protected/open-PR/failed sources.
+- Test baseline кешується за OID policy base branch у межах одного прогону.

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

@@ -1,16 +1,19 @@
 /** @see ./docs/orchestrate.md */
 import { spawnSync } from 'node:child_process'
-import { existsSync, readFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
+import { appendFileSync, existsSync, readFileSync } from 'node:fs'
+import { dirname, isAbsolute, join } from 'node:path'
 import { performance } from 'node:perf_hooks'
 import { env } from 'node:process'
 
-import { createProgressReporter } from '../../../scripts/lib/lint-surface/progress.mjs'
+import { renderProgressLine } from '../../../scripts/lib/lint-surface/progress.mjs'
 import { readGitPolicy } from '../../../scripts/lib/git-policy.mjs'
 
 const LLM_TIERS = ['min', 'max']
 const REVIEW_BATCH_SIZE = 10
 const PROMPT_TEXT_LIMIT = 12_000
+const PROGRESS_HEARTBEAT_MS = 30_000
+const DEFAULT_PR_CONCURRENCY = 3
+const MAX_PR_CONCURRENCY = 4
 const SOURCE_BRANCH_PREFIX = 'branch:'
 const SOURCE_STASH_PREFIX = 'stash:'
 const CONTENT_CONFLICT_RE = /^CONFLICT \(.+?\): Merge conflict in (.+)$/
@@ -30,7 +33,10 @@ function noop() {
   // Навмисно порожньо: caller не запросив progress output.
 }
 
-/** @param {string} cwd корінь репозиторію @returns {string} remote ref базової гілки */
+/**
+ * @param {string} cwd корінь репозиторію
+ * @returns {string} remote ref базової гілки
+ */
 function policyBaseRef(cwd) {
   return `origin/${readGitPolicy(cwd).baseBranch}`
 }
@@ -47,37 +53,81 @@ function elapsedLabel(startedAt, now) {
 }
 
 /**
- * Створює точний progress reporter для однієї фази. У TTY тримає живий bar,
- * у non-TTY додає незмінювані рядки початку етапів і завершених одиниць.
+ * Створює ANSI-free snapshot progress для однієї фази. Однаковий append-only
+ * формат у TTY/CI не засмічує captured output cursor-control кодами, а
+ * heartbeat показує elapsed time довгих LLM-етапів.
  * @param {object} args параметри фази
  * @returns {{step:(key:string,detail:string,tier?:string)=>void,done:(key:string)=>void,stop:()=>void}} reporter
  */
-function createPhaseProgress(args) {
-  const { total, unitLabel, phase, log, isTTY, reporterFactory } = args
-  if (total === 0) return { step: noop, done: noop, stop: noop }
-
-  const baseLog = text => log(text.endsWith('\n') ? text.slice(0, -1) : text)
-  const reporter = reporterFactory({
+export function createPhaseProgress(args) {
+  const {
     total,
-    log: baseLog,
-    isTTY,
     unitLabel,
-    withFixed: false
-  })
-  let lastNonTtyLabel = ''
+    phase,
+    log,
+    now = () => performance.now(),
+    heartbeatMs = PROGRESS_HEARTBEAT_MS,
+    setIntervalFn = setInterval,
+    clearIntervalFn = clearInterval
+  } = args
+  if (total === 0) return { step: noop, done: noop, stop: noop }
+
+  const active = new Map()
+  const completed = new Set()
+
+  /**
+   * Рендерить один append-only snapshot без керувальних ANSI-послідовностей.
+   * @param {string} prefix статус
+   * @param {string} current поточний етап
+   * @param {number|null} startedAt початок активної одиниці
+   */
+  function render(prefix, current, startedAt = null) {
+    const elapsed = startedAt === null ? '' : ` · elapsed ${elapsedLabel(startedAt, now)}`
+    log(
+      `${prefix} ${renderProgressLine({
+        done: completed.size,
+        total,
+        found: 0,
+        fixed: 0,
+        current,
+        unitLabel,
+        withFixed: false
+      })}${elapsed}`
+    )
+  }
+
+  const heartbeat = setIntervalFn(() => {
+    if (active.size === 0) return
+    const labels = active
+      .values()
+      .map(item => item.label)
+      .toArray()
+      .join(' | ')
+    const oldest = Math.min(...active.values().map(item => item.startedAt))
+    render('💓', labels, oldest)
+  }, heartbeatMs)
+  heartbeat?.unref?.()
 
   return {
-    step: (_key, detail, tier) => {
+    step: (key, detail, tier) => {
       const label = `${phase} · ${detail}`
-      reporter.concernStart(label, tier)
       const rendered = tier ? `${label} · ${tier}` : label
-      if (!isTTY && rendered !== lastNonTtyLabel) {
-        log(`⏳ ${rendered}`)
-        lastNonTtyLabel = rendered
-      }
+      const previous = active.get(key)
+      const startedAt = previous?.startedAt ?? now()
+      if (previous?.label === rendered) return
+      active.set(key, { label: rendered, startedAt })
+      render('⏳', rendered, startedAt)
+    },
+    done: key => {
+      if (completed.has(key)) return
+      const current = active.get(key)?.label ?? `${phase} · ${key}`
+      active.delete(key)
+      completed.add(key)
+      render('✅', current)
     },
-    done: key => reporter.concernDone(key),
-    stop: () => reporter.stop()
+    stop: () => {
+      clearIntervalFn(heartbeat)
+    }
   }
 }
 
@@ -181,6 +231,7 @@ function branchName(ref) {
  * @param {Array<{ref:string, oid:string, date:string}>} refs сирі refs
  * @param {Map<string,string>} worktrees branch→path
  * @param {Map<string,string>} worktreeCommits checkout HEAD OID→path
+ * @param {string[]} protectedBranches захищені policy branches
  * @returns {Array<{ref:string, oid:string, date:string, worktree:string|null,aliases:string[]}>} refs
  */
 export function dedupeRefs(refs, worktrees, worktreeCommits = new Map(), protectedBranches = ['main']) {
@@ -471,7 +522,7 @@ export async function callRunner(runner, prompt, cwd, deps = {}, tier = 'max') {
  * @returns {Promise<{ok:boolean,text:string,error:string|null,tier:'min'|'max',validation?:object,attempts:Array<object>}>} результат
  */
 export async function callWithValidatedFallback(args) {
-  const { runner, prompt, cwd, validate, deps = {}, log = noop, label = 'LLM', onAttempt = noop } = args
+  const { runner, prompt, cwd, validate, remediate, deps = {}, log = noop, label = 'LLM', onAttempt = noop } = args
   const call = deps.callRunner ?? callRunner
   const attempts = []
   let retryPrompt = prompt
@@ -484,10 +535,18 @@ export async function callWithValidatedFallback(args) {
       attempts.push({ tier, ok: false, validation })
       return { ...outcome, tier, validation, attempts }
     }
-    const validation = await validate(outcome)
-    attempts.push({ tier, ok: outcome.ok, validation })
+    let validation = await validate(outcome)
+    let remediation = null
+    if (!validation.ok && tier === 'min' && remediate) {
+      remediation = await remediate(validation)
+      if (remediation?.attempted) {
+        validation = await validate(outcome)
+        if (validation.ok) log(`↺ ${label}: deterministic fixer усунув min validation failure`)
+      }
+    }
+    attempts.push({ tier, ok: outcome.ok, validation, ...(remediation && { remediation }) })
     if (validation.ok) {
-      return { ...outcome, tier, validation, attempts }
+      return { ...outcome, tier, validation, attempts, ...(remediation?.attempted && { remediated: true }) }
     }
     if (tier === 'min') {
       const reason = (validation.error ?? outcome.error ?? 'невідома помилка validation').slice(0, PROMPT_TEXT_LIMIT)
@@ -655,6 +714,29 @@ function createReconcileWorktree(title, source, cwd, spawnFn) {
   return { branch, cwd: worktreeCwd }
 }
 
+/**
+ * Додає `.worktrees/` до локального Git exclude без tracked-змін у consumer.
+ * Це не замінює repository Vitest excludes, але не лишає root checkout dirty
+ * через керовані або forensic worktree.
+ * @param {string} cwd корінь repository
+ * @param {typeof spawnSync} spawnFn інжект
+ * @returns {boolean} чи локальний exclude було змінено
+ */
+export function ensureLocalWorktreeExclude(cwd, spawnFn = spawnSync) {
+  try {
+    const excludePath = git(['rev-parse', '--git-path', 'info/exclude'], cwd, spawnFn).stdout.trim()
+    if (!excludePath) return false
+    const absoluteExcludePath = isAbsolute(excludePath) ? excludePath : join(cwd, excludePath)
+    const existing = existsSync(absoluteExcludePath) ? readFileSync(absoluteExcludePath, 'utf8') : ''
+    if (existing.split('\n').some(line => line.trim() === '.worktrees/')) return false
+    const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n' : ''
+    appendFileSync(absoluteExcludePath, `${separator}.worktrees/\n`)
+    return true
+  } catch {
+    return false
+  }
+}
+
 /**
  * Прибирає reconciliation worktree або fail-closed лишає source неочищеним.
  * @param {{branch:string,cwd:string}} worktree створений worktree
@@ -811,7 +893,9 @@ export function sourceDirectories(paths) {
  * @returns {string[]} directories
  */
 function changedPaths(cwd, spawnFn) {
-  const tracked = git(['diff', '--name-only', policyBaseRef(cwd), '--'], cwd, spawnFn).stdout.split('\n').filter(Boolean)
+  const tracked = git(['diff', '--name-only', policyBaseRef(cwd), '--'], cwd, spawnFn)
+    .stdout.split('\n')
+    .filter(Boolean)
   const untracked = git(['ls-files', '--others', '--exclude-standard'], cwd, spawnFn).stdout.split('\n').filter(Boolean)
   return [...new Set([...tracked, ...untracked])]
 }
@@ -859,19 +943,67 @@ function validateScopedProjectGates(cwd, spawnFn, onProgress = noop) {
       allowFailure: true
     })
     if (docs.status !== 0) {
-      return { ok: false, error: `doc-files (${path}): ${docs.stderr || docs.stdout}` }
+      return {
+        ok: false,
+        error: `doc-files (${path}): ${docs.stderr || docs.stdout}`,
+        remediation: 'canonical-fixers'
+      }
     }
     onProgress(`scoped lint (${path})`)
     const lint = run('npx', ['@7n/rules', 'lint', '--path', path, '--no-fix'], cwd, spawnFn, {
       allowFailure: true
     })
     if (lint.status !== 0) {
-      return { ok: false, error: `scoped lint (${path}): ${lint.stderr || lint.stdout}` }
+      return {
+        ok: false,
+        error: `scoped lint (${path}): ${lint.stderr || lint.stdout}`,
+        remediation: 'canonical-fixers'
+      }
     }
   }
   return { ok: true }
 }
 
+/**
+ * Запускає canonical fixers у worktree до ескалації min→max. Це прибирає
+ * formatting/CSpell/doc/changelog дефекти без повторного behavioral LLM.
+ * @param {string} cwd worktree
+ * @param {typeof spawnSync} spawnFn інжект
+ * @param {{remediation?:string}} validation провалена validation
+ * @param {(stage:string)=>void} [onProgress] stage callback
+ * @returns {{attempted:boolean,ok:boolean,error?:string}} результат
+ */
+export function remediateBehaviorState(cwd, spawnFn = spawnSync, validation = {}, onProgress = noop) {
+  if (validation.remediation !== 'canonical-fixers') return { attempted: false, ok: false }
+
+  for (const path of changedSourceDirectories(cwd, spawnFn)) {
+    onProgress(`deterministic fix (${path})`)
+    const fixed = run('npx', ['@7n/rules', 'lint', '--path', path], cwd, spawnFn, {
+      allowFailure: true
+    })
+    if (fixed.status !== 0) {
+      return {
+        attempted: true,
+        ok: false,
+        error: `canonical fix (${path}): ${fixed.stderr || fixed.stdout}`
+      }
+    }
+  }
+
+  onProgress('deterministic changelog fix')
+  const changelog = run('npx', ['@7n/rules', 'lint', 'changelog'], cwd, spawnFn, {
+    allowFailure: true
+  })
+  if (changelog.status !== 0) {
+    return {
+      attempted: true,
+      ok: false,
+      error: `canonical changelog fix: ${changelog.stderr || changelog.stdout}`
+    }
+  }
+  return { attempted: true, ok: true }
+}
+
 /**
  * Встановлює frozen Bun dependencies, якщо новий worktree їх ще не має.
  * @param {string} cwd worktree
@@ -947,7 +1079,11 @@ export function validateBehaviorState(cwd, spawnFn = spawnSync, baseline = null,
   onProgress('changelog')
   const changelog = run('npx', ['@7n/rules', 'lint', 'changelog', '--no-fix'], cwd, spawnFn, { allowFailure: true })
   if (changelog.status !== 0) {
-    return { ok: false, error: `changelog gate: ${changelog.stderr || changelog.stdout}` }
+    return {
+      ok: false,
+      error: `changelog gate: ${changelog.stderr || changelog.stdout}`,
+      remediation: 'canonical-fixers'
+    }
   }
   return { ok: true }
 }
@@ -1064,7 +1200,9 @@ 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}`)),
+    remediate: validation =>
+      remediateBehaviorState(worktreeCwd, spawnFn, validation, step => onProgress(`behavior validation: ${step}`))
   })
   if (!outcome.ok) throw new Error(`LLM behavioral verification: ${outcome.error}`)
   return outcome.text.slice(0, PROMPT_TEXT_LIMIT)
@@ -1325,69 +1463,130 @@ async function triageCandidates(args) {
 }
 
 /**
- * Матеріалізує одне triage-рішення у report results.
+ * Матеріалізує одну PR-групу з наперед визначеним progress index.
  * @param {object} args orchestration context
- * @returns {Promise<Array<object>>} results одного source
+ * @returns {Promise<object>} result одного source/group
  */
-async function materializeDecision(args) {
-  const { decision, candidate, runner, rootCwd, baselineCache, deps, spawnFn, log, createPr, progress, prState } = args
-  if (decision.action !== 'pr') {
-    return [
-      {
-        source: decision.source,
-        status: decision.action === 'drop' ? 'drop-recommended' : 'kept',
-        rationale: decision.rationale ?? '',
-        ...(decision.incomplete === true && { incomplete: true }),
-        ...(candidate.oid && { oid: candidate.oid })
-      }
-    ]
+async function materializePrGroup(args) {
+  const {
+    decision,
+    candidate,
+    group,
+    prIndex,
+    prTotal,
+    runner,
+    rootCwd,
+    baselineCache,
+    deps,
+    spawnFn,
+    log,
+    createPr,
+    progress
+  } = args
+  const key = `pr-${prIndex}`
+  const prefix = `${prIndex}/${prTotal} · ${decision.source}`
+  progress.step(key, `${prefix} · worktree`)
+  try {
+    const result = await createPr({
+      candidate: { ...candidate, rationale: decision.rationale },
+      group,
+      runner,
+      rootCwd,
+      baselineCache,
+      deps,
+      spawnFn,
+      log,
+      onProgress: (step, tier) => progress.step(key, `${prefix} · ${step}`, tier)
+    })
+    return {
+      source: decision.source,
+      ...(candidate.oid && { oid: candidate.oid }),
+      ...result
+    }
+  } finally {
+    progress.done(key)
   }
+}
 
-  const results = []
-  for (const group of decision.groups) {
-    prState.index += 1
-    const key = `pr-${prState.index}`
-    const prefix = `${prState.index}/${prState.total} · ${decision.source}`
-    progress.step(key, `${prefix} · worktree`)
-    try {
-      const result = await createPr({
-        candidate: { ...candidate, rationale: decision.rationale },
-        group,
-        runner,
-        rootCwd,
-        baselineCache,
-        deps,
-        spawnFn,
-        log,
-        onProgress: (step, tier) => progress.step(key, `${prefix} · ${step}`, tier)
-      })
-      results.push({
-        source: decision.source,
-        ...(candidate.oid && { oid: candidate.oid }),
-        ...result
-      })
-    } finally {
-      progress.done(key)
+/**
+ * Виконує async jobs із bounded concurrency та стабільним порядком output.
+ * @param {Array<()=>Promise<object>>} jobs jobs
+ * @param {number} concurrency одночасні jobs
+ * @returns {Promise<object[]>} результати в порядку jobs
+ */
+export async function runWithConcurrency(jobs, concurrency) {
+  const results = Array.from({ length: jobs.length })
+  let next = 0
+  /** Виконує наступні jobs до вичерпання спільної черги. */
+  async function worker() {
+    while (next < jobs.length) {
+      const index = next
+      next += 1
+      results[index] = await jobs[index]()
     }
   }
+  const workerCount = Math.min(jobs.length, Math.max(1, concurrency))
+  await Promise.all(Array.from({ length: workerCount }, () => worker()))
   return results
 }
 
 /**
- * Перетворює всі validated decisions у PR/keep/drop results.
+ * Нормалізує bounded concurrency PR-фази.
+ * @param {unknown} value override/env value
+ * @returns {number} 1..MAX_PR_CONCURRENCY
+ */
+export function normalizePrConcurrency(value) {
+  const parsed = Math.trunc(Number(value))
+  if (!Number.isFinite(parsed)) return DEFAULT_PR_CONCURRENCY
+  return Math.min(MAX_PR_CONCURRENCY, Math.max(1, parsed))
+}
+
+/**
+ * Перетворює validated decisions у PR/keep/drop results. Незалежні PR-групи
+ * виконуються паралельно з bounded concurrency, cleanup стартує лише після
+ * завершення всіх jobs.
  * @param {object} args orchestration context
  * @returns {Promise<{bySource:Map<string,object>,results:Array<object>}>} materialized state
  */
 async function materializeDecisions(args) {
-  const { decisions, candidates } = args
+  const { decisions, candidates, prConcurrency, prTotal } = args
   const bySource = new Map(candidates.map(candidate => [candidate.source, candidate]))
-  const results = []
+  const resultSlots = []
+  const jobs = []
+  let prIndex = 0
   for (const decision of decisions) {
     const candidate = bySource.get(decision.source)
     if (!candidate) continue
-    results.push(...(await materializeDecision({ ...args, decision, candidate })))
+    if (decision.action !== 'pr') {
+      resultSlots.push({
+        source: decision.source,
+        status: decision.action === 'drop' ? 'drop-recommended' : 'kept',
+        rationale: decision.rationale ?? '',
+        ...(decision.incomplete === true && { incomplete: true }),
+        ...(candidate.oid && { oid: candidate.oid })
+      })
+      continue
+    }
+    for (const group of decision.groups) {
+      prIndex += 1
+      const fixedIndex = prIndex
+      const resultIndex = resultSlots.length
+      resultSlots.push(null)
+      jobs.push(async () => {
+        resultSlots[resultIndex] = await materializePrGroup({
+          ...args,
+          decision,
+          candidate,
+          group,
+          prIndex: fixedIndex,
+          prTotal
+        })
+        return resultSlots[resultIndex]
+      })
+    }
   }
-  return { bySource, results }
+  await runWithConcurrency(jobs, prConcurrency)
+  return { bySource, results: resultSlots.filter(Boolean) }
 }
 
 /**
@@ -1476,14 +1675,20 @@ export async function runGitReconcileOrchestrator(options = {}) {
   const inventoryFn = deps.inventoryRepository ?? inventoryRepository
   const createPr = deps.createPullRequest ?? createPullRequest
   const cleanup = deps.cleanupSource ?? cleanupSource
-  const reporterFactory = deps.createProgressReporter ?? createProgressReporter
-  const isTTY = options.isTTY ?? process.stdout.isTTY === true
   const now = deps.now ?? (() => performance.now())
+  const setIntervalFn = deps.setIntervalFn ?? setInterval
+  const clearIntervalFn = deps.clearIntervalFn ?? clearInterval
+  const heartbeatMs = deps.heartbeatMs ?? PROGRESS_HEARTBEAT_MS
+  const prConcurrency = normalizePrConcurrency(deps.prConcurrency ?? env.N_GIT_RECONCILE_CONCURRENCY)
   const baselineCache = new Map()
 
   const inventoryStartedAt = now()
   log('⏳ 1/4 inventory')
   const inventory = inventoryFn(rootCwd, { spawnFn })
+  if (deps.ensureLocalWorktreeExclude !== false) {
+    const ensureExclude = deps.ensureLocalWorktreeExclude ?? ensureLocalWorktreeExclude
+    if (ensureExclude(rootCwd, spawnFn)) log('🛡️ Додано `.worktrees/` до локального `.git/info/exclude`')
+  }
   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`
@@ -1495,8 +1700,10 @@ export async function runGitReconcileOrchestrator(options = {}) {
     unitLabel: 'triage-пакетів',
     phase: '2/4 triage',
     log,
-    isTTY,
-    reporterFactory
+    now,
+    heartbeatMs,
+    setIntervalFn,
+    clearIntervalFn
   })
   const triageStartedAt = now()
   let decisions
@@ -1523,11 +1730,12 @@ export async function runGitReconcileOrchestrator(options = {}) {
     unitLabel: 'PR-груп',
     phase: '3/4 PR',
     log,
-    isTTY,
-    reporterFactory
+    now,
+    heartbeatMs,
+    setIntervalFn,
+    clearIntervalFn
   })
   const prStartedAt = now()
-  const prState = { index: 0, total: prTotal }
   let materialized
   try {
     materialized = await materializeDecisions({
@@ -1541,7 +1749,8 @@ export async function runGitReconcileOrchestrator(options = {}) {
       log,
       createPr,
       progress: prProgress,
-      prState
+      prTotal,
+      prConcurrency
     })
   } finally {
     prProgress.stop()
@@ -1555,8 +1764,10 @@ export async function runGitReconcileOrchestrator(options = {}) {
     unitLabel: 'джерел',
     phase: '4/4 cleanup',
     log,
-    isTTY,
-    reporterFactory
+    now,
+    heartbeatMs,
+    setIntervalFn,
+    clearIntervalFn
   })
   const cleanupStartedAt = now()
   const cleanupState = { index: 0 }