@7n/rules 1.8.3 → 1.9.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [1.9.0] - 2026-07-17
+
+### Added
+
+- `skill pi/cursor/codex taze` тепер виконується через оркестратор (`npm/skills/taze/js/orchestrate.mjs`) замість одного величезного непрозорого ходу на весь монорепо: детерміновані кроки (бекап/масовий bump/diff/прибирання) без LLM, і по одному ізольованому, обмеженому виклику раннера на кожен major-пакет — падіння/timeout одного пакета не втрачає прогрес по інших
+
+## [1.8.4] - 2026-07-17
+
+### Fixed
+
+- text/run-v8r: включати причину провалу v8r (stdout+stderr, без noise) у violation-повідомлення замість голого коду виходу
+- k8s/manifests: форматування tests/check-schema.test.mjs (oxfmt)
+
 ## [1.8.3] - 2026-07-17
 
 ### Changed

package/package.json

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

package/rules/text/run-v8r/docs/main.md

@@ -3,7 +3,8 @@ type: JS Module
 title: main.mjs
 resource: npm/rules/text/run-v8r/main.mjs
 docgen:
-  crc: 804dce1c
+  crc: 5c8aab7b
+  model: manual
 ---
 
 ## Огляд
@@ -20,18 +21,20 @@ docgen:
 - `V8R_CACHE_TTL_SECONDS` — TTL HTTP-кешу v8r (доба замість дефолтних 600 с): fallback-фетчі schemastore не повторюються на кожен прогін.
 - `resolveCustomCatalogSchemas()` — читає джерельний каталог, повертає масив схем у форматі v8r `customCatalog.schemas` (ключ `location`, локальні шляхи — абсолютні).
 - `writeResolvedV8rConfig()` — записує `{ cacheTtl, customCatalog: { schemas } }` у `RESOLVED_V8R_CONFIG_PATH` (побічний ефект: файлова операція запису, поза rollback-механізмом лінт-пайплайна).
-- `runV8rWithGlobs(globs?)` — послідовно запускає `v8r` для кожного glob-у з `V8R_CONFIG_FILE`, вказаним на резольвнутий конфіг; при коді 0/98 вивід приховано, інакше друкується й повертається код першого невдалого прогону.
-- `runV8rWithFiles(files)` — delta-режим: один запуск `v8r` по конкретних існуючих шляхах (код 98 неможливий), порожній список — одразу 0.
+- `runV8rWithGlobs(globs?)` — послідовно запускає `v8r` для кожного glob-у з `V8R_CONFIG_FILE`, вказаним на резольвнутий конфіг; повертає `{ code, detail }` (не голий код): при `code` 0/98 вивід приховано, `detail` порожній; інакше `detail` друкується й повертається код першого невдалого прогону.
+- `runV8rWithFiles(files)` — delta-режим: один запуск `v8r` по конкретних існуючих шляхах (код 98 неможливий), порожній список — одразу `{ code: 0, detail: '' }`.
+- `extractFailureLines(combinedText)` — фільтрує `ℹ`-шум і bunx install-вивід з об'єднаного `stdout+stderr` одного запуску `v8r`, лишаючи предметну деталь (`✖ …`-заголовки, ajv-причини). Обидва потоки об'єднуються навмисно: `v8r` непослідовно розкидає деталь між ними залежно від типу помилки (schema violation — причина в stdout, заголовок у stderr; "не знайдено схему" — усе в stderr).
 - `warnAboutRemoteSchemaFallback(stderrText)` — парсить stderr `v8r` і на кожен файл, чию схему знайдено мережевим fallback-ом (schemastore, не customCatalog), друкує в stdout пораду додати схему в каталог.
 - `stripBunNodeShimDirs(pathValue)` — прибирає з PATH shim-теки `bun-node-*`, які `bun run --bun` додає з підміненим `node`: дочірній `v8r` (node-shebang) інакше виконувався б під bun і падав на непідтримуваному `node:sea`. Дочірній процес `v8r` завжди отримує очищений PATH.
-- `lint(ctx)` — detector `text/run-v8r`: `ctx.files` → delta по відфільтрованих розширеннях, без `ctx.files` → full за `DEFAULT_V8R_GLOBS`.
+- `lint(ctx)` — detector `text/run-v8r`: `ctx.files` → delta по відфільтрованих розширеннях, без `ctx.files` → full за `DEFAULT_V8R_GLOBS`. Порушення несе `detail` (якщо є) у тексті `fail()`-повідомлення — без нього LLM fix-worker бачив лише "щось не пройшло" й незмінно провалював усі rung-и драбини (не мав інформації, що саме виправляти).
 
 ## Публічний API
 
 - `DEFAULT_V8R_GLOBS`, `V8R_CATALOG_PATH`, `RESOLVED_V8R_CONFIG_PATH`, `V8R_CACHE_TTL_SECONDS` — константи.
 - `resolveCustomCatalogSchemas()` — обчислені схеми customCatalog.
 - `writeResolvedV8rConfig()` — матеріалізація тимчасового конфігу, повертає його шлях.
-- `runV8rWithGlobs(globs?)`, `runV8rWithFiles(files)` — точки входу перевірки (full/delta).
+- `runV8rWithGlobs(globs?)`, `runV8rWithFiles(files)` — точки входу перевірки (full/delta), повертають `{ code, detail }`.
+- `extractFailureLines(combinedText)` — фільтр noise-рядків для деталі провалу.
 - `warnAboutRemoteSchemaFallback(stderrText)` — попередження про мережевий fallback схем.
 - `stripBunNodeShimDirs(pathValue)` — PATH без shim-тек `bun-node-*` (для дочірнього v8r).
 - `lint(ctx)` — інтеграція в lint-пайплайн.

package/rules/text/run-v8r/main.mjs

@@ -114,17 +114,28 @@ export function writeResolvedV8rConfig() {
 
 const PROCESSING_LINE_RE = /^ℹ Processing (.+)$/u
 const FOUND_REMOTE_SCHEMA_RE = /^ℹ Found schema in (https?:\/\/\S+)/u
-const FAILURE_LINE_RE = /^✖ .+$/mu
+const NOISE_LINE_RE = /^(?:ℹ .*|Resolving dependencies|Resolved, downloaded and extracted.*|Saved lockfile)$/u
 
 /**
- * Витягує лише рядки `✖ …` (конкретні помилки валідації) з raw stdout v8r — без `ℹ`-шуму
- * (Pre-warming the cache, Processing <file>, Found schema in …) і без `✔ … is valid` по
- * пройдених файлах. Використовується для non-verbose підсумку при невдалому прогоні.
- * @param {string} stdoutText захоплений stdout одного запуску v8r
- * @returns {string} рядки `✖ …`, з'єднані `\n` (порожній рядок, якщо збігів нема)
+ * Прибирає v8r/bunx noise-рядки (весь `ℹ`-статус: Loaded config file, Patterns and relative
+ * paths, Pre-warming the cache, Processing <file>, Found schema in …, Validating …; і службовий
+ * вивід bunx-встановлення Resolving/Resolved/Saved lockfile) з об'єднаного stdout+stderr одного
+ * запуску —
+ * лишає предметну деталь (`✖ …`-заголовки й ajv-причини на кшталт "must NOT have additional
+ * properties…"). Обидва потоки об'єднуються НАВМИСНО: v8r непослідовно розкидає ці рядки між
+ * stdout/stderr залежно від типу помилки — при порушенні схеми ajv-причина йде у stdout, а
+ * `✖ … is invalid`-заголовок у stderr; при "не знайдено схему" все йде у stderr, stdout
+ * порожній. Фільтр лише за stdout (як раніше) на другому випадку повертав би зовсім порожню
+ * деталь — і LLM fix-worker (як і non-verbose CLI-підсумок) не бачив би жодної причини провалу.
+ * @param {string} combinedText stdout + '\n' + stderr одного запуску v8r
+ * @returns {string} відфільтровані непорожні рядки, join('\n') (порожній рядок, якщо деталі нема)
  */
-export function extractFailureLines(stdoutText) {
-  return (stdoutText.match(FAILURE_LINE_RE) ?? []).join('\n')
+export function extractFailureLines(combinedText) {
+  return combinedText
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line.length > 0 && !NOISE_LINE_RE.test(line))
+    .join('\n')
 }
 
 /**
@@ -168,11 +179,16 @@ export function stripBunNodeShimDirs(pathValue) {
 
 /**
  * Один виклик `bun x v8r <targets...>` з підготовленим `customCatalog`-конфігом.
+ * `detail` (рядки `✖ …`) обчислюється завжди, незалежно від `verbose` — потрібен викликачу
+ * (`lint()`) для вбудовування у violation-повідомлення, яке бачить LLM fix-worker: без нього
+ * fix-ladder отримує лише "щось не пройшло" й не має шансів вгадати, що саме (спостережено —
+ * усі 4 rung-и незмінно падають у timeout на v8r-порушеннях).
  * @param {string[]} targets glob-и або конкретні шляхи файлів
  * @param {string} configPath шлях до `V8R_CONFIG_FILE`
  * @param {boolean} [verbose] друкувати повний raw stdout/stderr v8r при помилці; інакше — лише
  *   рядки `✖ …` без `ℹ`-шуму (Pre-warming the cache, Processing <file>, Found schema in …)
- * @returns {{ exitError: true } | { exitError: false, code: number }} помилка spawn або код v8r (0/98 — трактує викликач)
+ * @returns {{ exitError: true } | { exitError: false, code: number, detail: string }} помилка
+ *   spawn або код v8r (0/98 — трактує викликач) + деталь `✖ …`-рядків
  */
 function runOneV8rInvocation(targets, configPath, verbose = false) {
   const bunPath = resolveCmd('bun') ?? process.execPath
@@ -192,16 +208,17 @@ function runOneV8rInvocation(targets, configPath, verbose = false) {
   warnAboutRemoteSchemaFallback(result.stderr ?? '')
 
   const exitCode = result.status ?? 1
+  let detail = ''
   if (exitCode !== 0 && exitCode !== 98) {
+    detail = extractFailureLines(`${result.stdout ?? ''}\n${result.stderr ?? ''}`)
     if (verbose) {
       if (result.stdout?.length) process.stdout.write(result.stdout)
       if (result.stderr?.length) process.stderr.write(result.stderr)
-    } else {
-      const failureLines = extractFailureLines(result.stdout ?? '')
-      if (failureLines.length) process.stdout.write(`${failureLines}\n`)
+    } else if (detail.length) {
+      process.stdout.write(`${detail}\n`)
     }
   }
-  return { exitError: false, code: exitCode }
+  return { exitError: false, code: exitCode, detail }
 }
 
 /**
@@ -210,24 +227,25 @@ function runOneV8rInvocation(targets, configPath, verbose = false) {
  * glob не знаходить файлів, і тоді решта розширень не перевіряються в тому ж виклику.
  * @param {string[]} [globs] патерни; за замовчуванням DEFAULT_V8R_GLOBS
  * @param {boolean} [verbose] друкувати повний raw вивід v8r при помилці (див. runOneV8rInvocation)
- * @returns {number} 0 — OK, 1 — помилка spawn, 2 — немає каталогу схем, інше — код v8r
+ * @returns {{ code: number, detail: string }} `code`: 0 — OK, 1 — помилка spawn, 2 — немає
+ *   каталогу схем, інше — код v8r; `detail` — рядки `✖ …` (порожньо, якщо `code` не про валідацію)
  */
 export function runV8rWithGlobs(globs = DEFAULT_V8R_GLOBS, verbose = false) {
   if (!existsSync(V8R_CATALOG_PATH)) {
     process.stderr.write(
       `run-v8r: не знайдено каталог схем за шляхом ${V8R_CATALOG_PATH} (очікується npm/schemas/v8r-catalog.json у пакеті)\n`
     )
-    return 2
+    return { code: 2, detail: '' }
   }
 
   const configPath = writeResolvedV8rConfig()
 
   for (const pattern of globs) {
     const r = runOneV8rInvocation([pattern], configPath, verbose)
-    if (r.exitError) return 1
-    if (r.code !== 0 && r.code !== 98) return r.code
+    if (r.exitError) return { code: 1, detail: '' }
+    if (r.code !== 0 && r.code !== 98) return { code: r.code, detail: r.detail }
   }
-  return 0
+  return { code: 0, detail: '' }
 }
 
 /**
@@ -235,21 +253,33 @@ export function runV8rWithGlobs(globs = DEFAULT_V8R_GLOBS, verbose = false) {
  * бо кожен переданий шлях уже існує (не glob), тож код 98 "порожній glob" тут не виникає.
  * @param {string[]} files абсолютні або відносні до cwd v8r-процесу шляхи файлів
  * @param {boolean} [verbose] друкувати повний raw вивід v8r при помилці (див. runOneV8rInvocation)
- * @returns {number} 0 — OK, 1 — помилка spawn, 2 — немає каталогу схем, інше — код v8r
+ * @returns {{ code: number, detail: string }} `code`: 0 — OK, 1 — помилка spawn, 2 — немає
+ *   каталогу схем, інше — код v8r; `detail` — рядки `✖ …` (порожньо, якщо `code` не про валідацію)
  */
 export function runV8rWithFiles(files, verbose = false) {
-  if (files.length === 0) return 0
+  if (files.length === 0) return { code: 0, detail: '' }
   if (!existsSync(V8R_CATALOG_PATH)) {
     process.stderr.write(
       `run-v8r: не знайдено каталог схем за шляхом ${V8R_CATALOG_PATH} (очікується npm/schemas/v8r-catalog.json у пакеті)\n`
     )
-    return 2
+    return { code: 2, detail: '' }
   }
 
   const configPath = writeResolvedV8rConfig()
   const r = runOneV8rInvocation(files, configPath, verbose)
-  if (r.exitError) return 1
-  return r.code === 98 ? 0 : r.code
+  if (r.exitError) return { code: 1, detail: '' }
+  return { code: r.code === 98 ? 0 : r.code, detail: r.detail }
+}
+
+/**
+ * Будує violation-повідомлення з опційною деталлю `✖ …`-рядків v8r — без неї LLM fix-worker
+ * бачить лише "щось не пройшло" й не має інформації, який файл/поле саме порушує схему.
+ * @param {string} detail рядки `✖ …` з `runV8rWithGlobs`/`runV8rWithFiles` (може бути порожнім)
+ * @returns {string} повне повідомлення для `fail()`
+ */
+function v8rFailMessage(detail) {
+  const base = 'v8r schema-валідація json/yaml/toml не пройшла (text.mdc)'
+  return detail ? `${base}:\n${detail}` : base
 }
 
 /**
@@ -264,19 +294,19 @@ export function lint(ctx) {
   const verbose = ctx.verbose === true
 
   if (ctx.files === undefined) {
-    const code = runV8rWithGlobs(DEFAULT_V8R_GLOBS, verbose)
-    if (code !== 0) fail('v8r schema-валідація json/yaml/toml не пройшла (text.mdc)', 'v8r')
+    const { code, detail } = runV8rWithGlobs(DEFAULT_V8R_GLOBS, verbose)
+    if (code !== 0) fail(v8rFailMessage(detail), 'v8r')
     return reporter.result()
   }
 
   const files = ctx.files.filter(f => V8R_EXT_RE.test(f))
   if (files.length === 0) return reporter.result()
-  const code = runV8rWithFiles(files, verbose)
-  if (code !== 0) fail('v8r schema-валідація json/yaml/toml не пройшла (text.mdc)', 'v8r')
+  const { code, detail } = runV8rWithFiles(files, verbose)
+  if (code !== 0) fail(v8rFailMessage(detail), 'v8r')
   return reporter.result()
 }
 
 if (isRunAsCli(import.meta.url)) {
   const globs = process.argv.length > 2 ? process.argv.slice(2) : DEFAULT_V8R_GLOBS
-  process.exitCode = runV8rWithGlobs(globs)
+  process.exitCode = runV8rWithGlobs(globs).code
 }

package/scripts/docs/skills-cli.md

@@ -3,7 +3,7 @@ type: JS Module
 title: skills-cli.mjs
 resource: npm/scripts/skills-cli.mjs
 docgen:
-  crc: 1a8f83e4
+  crc: 12d3bf6d
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
 ---
 

package/scripts/skills-cli.mjs

@@ -8,6 +8,13 @@
  * (napi-міст до `llm_cascade::acp`, без власного JSON-RPC у JS); deprecated
  * `claude` — окремий JS-шим (`./lib/acp-runner.mjs`), бо Rust-крейт його не моделює.
  *
+ * `skill <runner> taze` — виняток із загального шляху "весь SKILL.md одним промптом":
+ * делегує в `../skills/taze/js/orchestrate.mjs`, який детерміновано (без LLM) робить
+ * бекап/масовий bump/diff/прибирання і лише по одному ОБМЕЖЕНОМУ виклику `<runner>`
+ * на кожен major-пакет — замість одного величезного непрозорого ходу на весь монорепо
+ * (той, single-shot, раніше зависав без діагностики; per-пакет виклики успадковують
+ * власний timeout раннера, і падіння одного пакета не втрачає прогрес по інших).
+ *
  * Підтримувані формати:
  *   `npx \@7n/rules skill list`
  *   `npx \@7n/rules skill taze`
@@ -202,6 +209,32 @@ async function runLlmCli(kind, prompt, projectDir, logError, deps = {}) {
   }
 }
 
+/**
+ * Виконує `taze` через оркестратор (`../skills/taze/js/orchestrate.mjs`) замість
+ * загального одноходового шляху — детерміновані кроки без LLM (бекап/bump/diff/
+ * прибирання) + по одному обмеженому виклику обраного `runner` на кожен major-пакет.
+ * @param {'pi' | 'cursor' | 'codex'} runner раннер для per-пакетних викликів
+ * @param {string} projectDir корінь проєкту (де лежить package.json)
+ * @param {(line: string) => void} log вивід прогресу/звіту
+ * @param {(line: string) => void} logError вивід помилок
+ * @param {{ runTazeOrchestrator?: (opts: object) => Promise<{ ok: boolean, report: string }> }} [deps] інжект для тестів
+ * @returns {Promise<number>} exit code (0 — усі major-пакети ok)
+ */
+async function runTazeOrchestratorCli(runner, projectDir, log, logError, deps = {}) {
+  let orchestrate = deps.runTazeOrchestrator
+  if (!orchestrate) {
+    const orchestrateModule = await import('../skills/taze/js/orchestrate.mjs')
+    orchestrate = orchestrateModule.runTazeOrchestrator
+  }
+  try {
+    const result = await orchestrate({ cwd: projectDir, runner, log, deps })
+    return result.ok ? 0 : 1
+  } catch (error) {
+    logError(error instanceof Error ? error.message : String(error))
+    return 1
+  }
+}
+
 /**
  * Корінь пакета `@7n/rules` (каталог з `skills/`, `rules/`, …).
  * @param {string} [fromModuleUrl] для тестів — `import.meta.url`, відносно якого шукати корінь
@@ -245,6 +278,15 @@ export async function runSkillsCli(argv, options = {}) {
       if (!second) {
         throw new Error(`Skill name is required after "${first}"`)
       }
+      if (first !== 'claude' && normalizeSkillId(second) === 'taze') {
+        return await runTazeOrchestratorCli(
+          /** @type {'pi' | 'cursor' | 'codex'} */ (first),
+          projectDir,
+          log,
+          logError,
+          deps
+        )
+      }
       const task = rest.join(' ')
       const prompt = buildSkillPrompt(skillsRoot, second, task, projectDir)
       if (first === 'pi') {

package/skills/taze/SKILL.md

@@ -13,6 +13,27 @@ version: '1.1'
 
 Оновити всі модулі проекту (npm/bun-залежності, а за наявності `Cargo.toml` — і Rust-крейти) до останніх версій, виявити major-оновлення, перевірити сумісність змін з кодом проекту і за потреби зрефакторити несумісні місця.
 
+## Оркестрація (npm/bun-гілка) — не одним промптом
+
+`npx @7n/rules skill pi|cursor|codex taze` **не** передає цей файл одним суцільним
+промптом в один агентський хід — так робив старий дизайн, і саме тому реальний
+прогін міг зависати без жодної діагностики (один величезний непрозорий хід на
+весь монорепо, без проміжних зупинок для перевірки прогресу). Замість цього `npm/skills/taze/js/orchestrate.mjs`:
+
+1. Детерміновано, без LLM, виконує кроки 1-3 нижче (бекап → `bunx taze -w -r latest` → `bun install` → `n-rules taze diff`).
+2. Для кожного **окремого** major-пакета з diff-у — один ізольований, обмежений виклик обраного раннера (кроки 4-6, лише для цього пакета; промпт генерує `buildDependencyPrompt`, не цей SKILL.md).
+3. Детерміновано прибирає бекапи (крок 7) і компонує звіт (крок 8) з результатів усіх ітерацій.
+
+Переваги: падіння/timeout на одному пакеті не втрачає прогрес по інших; кожен
+виклик успадковує власний timeout раннера (короткий, бо скоуп малий — один
+пакет, не весь монорепо); видно прогрес по пакетах, а не чорну скриньку.
+
+Кроки 1-8 нижче лишаються джерелом правди щодо ЗМІСТУ роботи (що саме робить
+кожен крок) — оркестратор їх виконує програмно (1-3/7/8) або як промпт на
+один пакет (4-6). Пряме читання цього файлу одним агентом (як SKILL.md для
+інших скілів) досі стосується лише **Rust-гілки** (нижче) — вона оркестратором
+не покрита.
+
 ## Передумови
 
 - Чисте робоче дерево (`git status` без незакомічених змін у `package.json` / `bun.lock` / `node_modules`) — інакше різницю не відрізнити від оновлення.

package/skills/taze/js/docs/index.md

@@ -4,8 +4,7 @@ title: npm/skills/taze/js
 resource: npm/skills/taze/js/
 ---
 
-# npm/skills/taze/js
-
-| Файл                | Тип       |
-| ------------------- | --------- |
-| [diff.mjs](diff.md) | JS Module |
+| Файл                              | Тип       |
+| --------------------------------- | --------- |
+| [diff.mjs](diff.md)               | JS Module |
+| [orchestrate.mjs](orchestrate.md) | JS Module |

package/skills/taze/js/docs/orchestrate.md

@@ -0,0 +1,44 @@
+---
+type: JS Module
+title: orchestrate.mjs
+resource: npm/skills/taze/js/orchestrate.mjs
+docgen:
+  crc: 37e2a3e9
+  model: openai-codex/gpt-5.4-mini
+  tier: cloud-min
+  score: 100
+  issues: judge:inaccurate:0.98
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Файл об’єднує публічні дії `buildDependencyPrompt`, `callRunner`, `backupWorkspacePackageFiles`, `cleanupBackups`, `findCargoManifests`, `formatReport`, `runTazeOrchestrator`, щоб узгодити оновлення залежностей за даними з `main.json` і `package.json`. Він працює read-only: не пише у ФС/БД, має кешування в межах прогону, свідомо пропускає шляхи `node_modules`, тимчасово зберігає бекапи `package.json` у воркспейсах і прибирає їх після завершення. Результат проходу оформлюється через `formatReport` як підсумок змін і стану оновлення.
+
+## Поведінка
+
+- **buildDependencyPrompt** — формує текст завдання для перевірки major-оновлення одного пакета й подальшого сумісного рефакторингу.
+- **callRunner** — запускає один ітеративний LLM-виклик у вибраному раннері та повертає результат разом із зібраним текстом відповіді.
+- **backupWorkspacePackageFiles** — створює тимчасові бекапи `package.json` у воркспейсах для подальшого порівняння змін.
+- **cleanupBackups** — прибирає тимчасові бекапи `package.json` після завершення прогону.
+- **findCargoManifests** — знаходить `Cargo.toml` поза `node_modules`, `.worktrees` і `target` для інформаційного підсумку.
+- **formatReport** — збирає лаконічний Markdown-звіт про minor/patch, major-оновлення, Rust-крейти та загальний обсяг змін.
+- **runTazeOrchestrator** — виконує повний прогін taze: перевіряє worktree з `main.json`, робить бекап, оновлює залежності з `package.json`, обробляє major-оновлення по одному пакету, прибирає бекапи й повертає підсумок.
+
+## Публічний API
+
+- buildDependencyPrompt — Готує промпт для одного LLM-кроку taze: тільки breaking changes, сумісність і рефакторинг для одного major-пакета. Перші кроки аналізу та фінальну збірку звіту робить оркестратор без LLM.
+- callRunner — Запускає один ітеративний виклик через вибраний раннер. Для `pi` бере текст із stdout вбудованого pi-агента, для `cursor` і `codex` отримує його напряму через ACP-міст.
+- backupWorkspacePackageFiles — Зберігає копії `package.json` усіх workspace-пакетів перед змінами, щоб потім відрізнити major і minor оновлення.
+- cleanupBackups — Видаляє тимчасові копії `package.json` після завершення роботи.
+- findCargoManifests — Находить `Cargo.toml` у репозиторії поза службовими директоріями; використовується лише для огляду Rust-крейтів.
+- formatReport — Складає фінальний звіт із результатів усіх ітерацій без окремого LLM-запиту.
+- runTazeOrchestrator — Керує taze від початку до кінця: робить бекап, масово оновлює версії, збирає diff, прибирає тимчасові файли й формує звіт. Для кожного major-пакета окремо запускає обмежений LLM-виклик, щоб збій одного пакета не зупиняв інші.
+
+Конфіги: `package.json`, `main.json`
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).
+- Кешує результати в межах одного прогону.
+- Свідомо пропускає шляхи: `node_modules`.

package/skills/taze/js/orchestrate.mjs

@@ -0,0 +1,272 @@
+/** @see ./docs/orchestrate.md */
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { copyFile, rm } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { getMonorepoPackageRootDirs } from '../../../scripts/lib/workspaces.mjs'
+import { collectTazeDiff } from './diff.mjs'
+
+/** Суфікс бекапу package.json — той самий, що й у `diff.mjs`/кроці 1 SKILL.md. */
+const BACKUP_SUFFIX = '.taze-bak'
+
+/**
+ * Промпт ОДНОГО ітеративного виклику — лише кроки 4-6 SKILL.md (breaking
+ * changes → сумісність коду → рефакторинг) для ОДНОГО major-пакета. Кроки
+ * 1-3/7/8 виконує оркестратор детерміновано, без LLM.
+ * @param {{workspace: string, pkg: string, from: string, to: string}} entry запис major-diff (з `collectTazeDiff`)
+ * @returns {string} готовий промпт
+ */
+export function buildDependencyPrompt({ workspace, pkg, from, to }) {
+  return [
+    '# Major-оновлення одного пакета: перевірка сумісності й рефакторинг',
+    '',
+    `Пакет \`${pkg}\` у воркспейсі \`${workspace}\`: **${from} → ${to}** — вже застосовано в package.json/bun.lock (кроки 1-3 виконано детерміновано, без тебе). Твоя задача — лише breaking-changes-перевірка й, за потреби, рефакторинг.`,
+    '',
+    '## Кроки',
+    `1. Зібрати breaking changes цього оновлення: CHANGELOG/Releases репозиторію модуля (поле \`repository\` у \`node_modules/${pkg}/package.json\`), або git/diff між закешованою старою версією (\`~/.bun/install/cache/${pkg}@<стара-версія>/\`) і новою (\`node_modules/${pkg}/\`).`,
+    `2. Знайти використання зачепленого API в коді проєкту (\`rg -n\` по імпортах/викликах \`${pkg}\`).`,
+    '3. Сумісно — нічого не робити. Несумісно — застосувати міграцію (перейменувати імпорт, оновити сигнатуру виклику, замінити видалену опцію еквівалентом).',
+    '4. Якщо були правки — запусти `npx @7n/rules lint`, typecheck/test якщо є в проєкті.',
+    '5. Нетривіальна/неоднозначна міграція — не вгадуй, залиш TODO-коментар із посиланням на CHANGELOG.',
+    '',
+    'У відповіді одним абзацом підсумуй: сумісно / зрефакторено (які файли) / TODO (чому).'
+  ].join('\n')
+}
+
+/**
+ * Диспетчер одного ітеративного виклику на обраний раннер. `pi` — вбудований
+ * pi-агент (`@7n/llm-lib/agent-skill`; текст перехоплюється через `deps.out`,
+ * бо `runAgentSkill` не повертає його напряму — лише стрімить у stdout).
+ * `cursor`/`codex` — napi-міст ACP (`@7n/llm-lib/acp`; текст — прямий return,
+ * idle-timeout і видимість прогресу вже вбудовані в сам міст).
+ * @param {'pi' | 'cursor' | 'codex'} runner раннер
+ * @param {string} prompt промпт для одного пакета
+ * @param {string} cwd робочий каталог
+ * @param {{ runAgentSkill?: (prompt: string, opts?: object) => Promise<{ok: boolean, error: string|null}>, runAcpAgent?: (kind: string, prompt: string, cwd: string) => Promise<string> }} [deps] інжекти для тестів
+ * @returns {Promise<{ ok: boolean, text: string, error: string|null }>} результат виклику
+ */
+export async function callRunner(runner, prompt, cwd, deps = {}) {
+  if (runner === 'pi') {
+    let runAgentSkill = deps.runAgentSkill
+    if (!runAgentSkill) {
+      const agentSkillModule = await import('@7n/llm-lib/agent-skill')
+      runAgentSkill = agentSkillModule.runAgentSkill
+    }
+    let text = ''
+    const result = await runAgentSkill(prompt, {
+      skillId: 'taze',
+      tier: 'avg',
+      cwd,
+      deps: { out: chunk => (text += chunk) }
+    })
+    return { ok: result.ok, text, error: result.error }
+  }
+
+  let runAcpAgent = deps.runAcpAgent
+  if (!runAcpAgent) {
+    const acpModule = await import('@7n/llm-lib/acp')
+    runAcpAgent = acpModule.runAcpAgent
+  }
+  try {
+    const text = await runAcpAgent(runner, prompt, cwd)
+    return { ok: true, text, error: null }
+  } catch (error) {
+    return { ok: false, text: '', error: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+/**
+ * Перевіряє, що `cwd` — ізольований worktree (`main.json.worktree: true`,
+ * той самий контракт, що й для інших worktree-only скілів). Раніше цю
+ * гарантію тримав агент, читаючи SKILL.md-preflight як частину промпту;
+ * оркестратор більше НЕ годує SKILL.md жодному викликові, тож без цієї
+ * перевірки `bunx taze -w -r latest`/`bun install` мовчки виконались би
+ * прямо в основному дереві виклику. Кидає, якщо `git rev-parse --show-toplevel`
+ * не містить `.worktrees` як сегмент шляху (покриває і `npx \@7n/mt worktree
+ * create`-конвенцію `.worktrees/`, і сесійну `.claude/worktrees/`).
+ * @param {string} cwd каталог для перевірки
+ * @param {typeof spawnSync} spawnFn інжект для тестів
+ * @returns {void}
+ */
+function assertRunningInWorktree(cwd, spawnFn) {
+  const result = spawnFn('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' })
+  const toplevel = result.status === 0 ? result.stdout.trim() : ''
+  const segments = new Set(toplevel.replaceAll('\\', '/').split('/'))
+  if (!segments.has('.worktrees')) {
+    throw new Error(
+      `taze: "${cwd}" не в ізольованому worktree (git toplevel: "${toplevel || '?'}"). ` +
+        'main.json.worktree=true вимагає окремого дерева — створи його спершу (див. SKILL.md preflight), не запускай taze в основному дереві.'
+    )
+  }
+}
+
+/**
+ * Синхронно виконує детерміновану команду (bunx/bun/find), кидає з
+ * exit-кодом+stderr при провалі.
+ * @param {string} cmd бінарник
+ * @param {string[]} args аргументи
+ * @param {string} cwd робочий каталог
+ * @param {typeof spawnSync} spawnFn інжект для тестів
+ * @returns {string} stdout
+ */
+function runCommand(cmd, args, cwd, spawnFn) {
+  const result = spawnFn(cmd, args, { cwd, encoding: 'utf8' })
+  if (result.status !== 0) {
+    throw new Error(`${cmd} ${args.join(' ')} → exit ${result.status}: ${result.stderr || result.stdout}`)
+  }
+  return result.stdout
+}
+
+/**
+ * Бекапить package.json кожного воркспейсу (крок 1 SKILL.md) — потрібно для
+ * класифікації major/minor через `collectTazeDiff` після bump-у.
+ * @param {string} cwd корінь репо
+ * @param {{ getMonorepoPackageRootDirs?: (cwd: string) => Promise<string[]>, copyFile?: (src: string, dest: string) => Promise<void> }} [deps] інжекти
+ * @returns {Promise<string[]>} відносні шляхи воркспейсів, що мали package.json
+ */
+export async function backupWorkspacePackageFiles(cwd, deps = {}) {
+  const getRoots = deps.getMonorepoPackageRootDirs ?? getMonorepoPackageRootDirs
+  const copy = deps.copyFile ?? copyFile
+  const roots = await getRoots(cwd)
+  const backedUp = []
+  for (const ws of roots) {
+    const pkgPath = join(cwd, ws, 'package.json')
+    if (!existsSync(pkgPath)) continue
+    await copy(pkgPath, `${pkgPath}${BACKUP_SUFFIX}`)
+    backedUp.push(ws)
+  }
+  return backedUp
+}
+
+/**
+ * Прибирає бекапи package.json після завершення (крок 7 SKILL.md).
+ * @param {string} cwd корінь репо
+ * @param {string[]} workspaces воркспейси з бекапом (з `backupWorkspacePackageFiles`)
+ * @param {{ rm?: (path: string, opts?: object) => Promise<void> }} [deps] інжект
+ * @returns {Promise<void>}
+ */
+export async function cleanupBackups(cwd, workspaces, deps = {}) {
+  const remove = deps.rm ?? rm
+  for (const ws of workspaces) {
+    await remove(join(cwd, ws, `package.json${BACKUP_SUFFIX}`), { force: true })
+  }
+}
+
+/**
+ * Знаходить Cargo.toml поза node_modules/.worktrees/target (крок 0.2
+ * SKILL.md). Лише інформаційно — v1 оркестратора Rust-крейти не оновлює
+ * (немає детермінованого cargo-diff-еквівалента `collectTazeDiff`,
+ * класифікація major там ручна за SKILL.md).
+ * @param {string} cwd корінь репо
+ * @param {{ spawnFn?: typeof spawnSync }} [deps] інжект
+ * @returns {string[]} відносні шляхи знайдених Cargo.toml
+ */
+export function findCargoManifests(cwd, deps = {}) {
+  const spawnFn = deps.spawnFn ?? spawnSync
+  const result = spawnFn(
+    'find',
+    [
+      '.',
+      '-name',
+      'Cargo.toml',
+      '-not',
+      '-path',
+      '*/node_modules/*',
+      '-not',
+      '-path',
+      '*/.worktrees/*',
+      '-not',
+      '-path',
+      '*/target/*'
+    ],
+    { cwd, encoding: 'utf8' }
+  )
+  return (result.stdout ?? '')
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean)
+}
+
+/**
+ * Компонує підсумковий звіт (крок 8 SKILL.md) детерміновано з результатів
+ * ітерацій — без окремого LLM-виклику для самого звіту.
+ * @param {{ minorPatch: number, totalChanged: number, results: Array<{pkg:string, workspace:string, from:string, to:string, ok:boolean, error:string|null}>, rustCrates: string[] }} args дані звіту
+ * @returns {string} markdown-звіт
+ */
+export function formatReport({ minorPatch, totalChanged, results, rustCrates }) {
+  const lines = [
+    '## taze: підсумок',
+    '',
+    `- **Оновлено (minor/patch):** ${minorPatch}`,
+    `- **Major-оновлення:** ${results.length}`
+  ]
+  for (const r of results) {
+    const status = r.ok ? '✅' : '❌'
+    const errorSuffix = r.error ? ` — ${r.error}` : ''
+    lines.push(`  ${status} \`${r.pkg}\` (${r.workspace}): ${r.from} → ${r.to}${errorSuffix}`)
+  }
+  if (rustCrates.length > 0) {
+    lines.push(
+      '',
+      `- **Rust-крейти (${rustCrates.length}), потребують ручного прогону Rust-гілки SKILL.md:** ${rustCrates.join(', ')}`
+    )
+  }
+  lines.push('', `- **Всього змінено:** ${totalChanged}`)
+  return lines.join('\n')
+}
+
+/**
+ * Оркеструє taze: детерміновані кроки (бекап → масовий bump → diff →
+ * прибирання → звіт) без LLM, і по одному ізольованому, обмеженому по
+ * обсягу виклику `callRunner` на кожен major-пакет (кроки 4-6 SKILL.md) —
+ * замість одного величезного непрозорого ходу на весь монорепо. Кожен
+ * виклик успадковує власний timeout/idle-timeout раннера, тож падіння
+ * одного пакета не втрачає прогрес по інших.
+ * @param {{
+ *   cwd?: string,
+ *   runner?: 'pi' | 'cursor' | 'codex',
+ *   log?: (line: string) => void,
+ *   deps?: { spawnFn?: typeof spawnSync, collectTazeDiff?: (cwd: string) => Promise<object>, callRunner?: (runner: string, prompt: string, cwd: string, deps: object) => Promise<{ok: boolean, text: string, error: string|null}> } & Record<string, unknown>
+ * }} [options] опції + інжекти для тестів
+ * @returns {Promise<{ ok: boolean, report: string, results: Array<object> }>} результат
+ */
+export async function runTazeOrchestrator(options = {}) {
+  const cwd = options.cwd ?? process.cwd()
+  const runner = options.runner ?? 'pi'
+  const log = options.log ?? (line => console.log(line))
+  const deps = options.deps ?? {}
+  const spawnFn = deps.spawnFn ?? spawnSync
+
+  assertRunningInWorktree(cwd, spawnFn)
+
+  const rustCrates = findCargoManifests(cwd, { spawnFn })
+
+  log('📦 Бекап package.json...')
+  const backedUpWorkspaces = await backupWorkspacePackageFiles(cwd, deps)
+
+  log('⬆️  bunx taze -w -r latest...')
+  runCommand('bunx', ['taze', '-w', '-r', 'latest'], cwd, spawnFn)
+  log('📥 bun install...')
+  runCommand('bun', ['install'], cwd, spawnFn)
+
+  const collectDiff = deps.collectTazeDiff ?? collectTazeDiff
+  const diff = await collectDiff(cwd)
+  log(`🔍 diff: ${diff.major.length} major, ${diff.minorPatch} minor/patch`)
+
+  const results = []
+  const call = deps.callRunner ?? callRunner
+  for (const entry of diff.major) {
+    log(`🔧 ${entry.pkg} (${entry.workspace}): ${entry.from} → ${entry.to}...`)
+    const outcome = await call(runner, buildDependencyPrompt(entry), cwd, deps)
+    results.push({ ...entry, ...outcome })
+    log(outcome.ok ? `  ✅ ${entry.pkg}` : `  ❌ ${entry.pkg}: ${outcome.error}`)
+  }
+
+  await cleanupBackups(cwd, backedUpWorkspaces, deps)
+
+  const report = formatReport({ minorPatch: diff.minorPatch, totalChanged: diff.totalChanged, results, rustCrates })
+  log(report)
+
+  return { ok: results.every(r => r.ok), report, results }
+}