@7n/rules 1.23.1 → 1.25.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [1.25.0] - 2026-07-19
+
+### Added
+
+- taze: по завершенню переносить зміни з автоствореного worktree назад у вихідне дерево (untracked) і прибирає worktree
+- lint --full: worktree-only гейт (auto-create + bring-back + cleanup), спільна логіка з taze винесена у scripts/lib/auto-worktree.mjs
+
+## [1.24.0] - 2026-07-19
+
+### Added
+
+- Фаза 4b spec lang-plugins-extraction: SKILL-фрагменти плагінів — sync доклеює конвенційні `skills/<id>/SKILL.fragment.md` активних плагінів до синхронізованого SKILL.md між стабільними маркерами (ідемпотентний ре-синк, блок зникає без активних фрагментів). Мовні гілки taze SKILL.md (Rust: детекція/cargo-команди/перевірки; Python: uv-цикл/PEP-класифікація) переїхали у фрагменти lang-плагінів — канон ядра описує npm/bun-гілку і generic-скелет
+
 ## [1.23.1] - 2026-07-18
 
 ### Changed

package/bin/n-rules.js

@@ -84,12 +84,18 @@ import {
   RULE_MIGRATIONS
 } from '../scripts/auto-rules.mjs'
 import { detectAutoSkills } from '../scripts/auto-skills.mjs'
+import {
+  bringChangesBackToOriginal,
+  ensureRunningInWorktree,
+  removeAutoCreatedWorktree
+} from '../scripts/lib/auto-worktree.mjs'
 import { readSkillMetaRaw } from '../scripts/lib/skill-meta.mjs'
 import { injectWorktreeNotice } from '../scripts/lib/worktree-notice.mjs'
+import { collectSkillFragments, injectSkillFragments } from '../scripts/lib/skill-fragments.mjs'
 import { injectRootNotice } from '../scripts/lib/root-notice.mjs'
 import { listProjectRulesMdcFiles } from '../scripts/lib/list-project-rules-mdc.mjs'
 import { ensureNRulesInRootDevDependencies } from '../scripts/ensure-n-rules-dev-dependencies.mjs'
-import { resolvePluginList, resolveRulesDirs } from '../scripts/lib/resolve-plugins.mjs'
+import { resolvePluginList, resolvePlugins, resolveRulesDirs } from '../scripts/lib/resolve-plugins.mjs'
 import { assertCwdIsProjectRoot } from '../scripts/lib/assert-project-root.mjs'
 import { syncClaudeConfig } from '../scripts/sync-claude-config.mjs'
 import { syncGitignoreWorktree } from '../scripts/lib/sync-gitignore-worktree.mjs'
@@ -885,15 +891,19 @@ async function syncAgentsMd(agentsTemplatePath = BUNDLED_AGENTS_TEMPLATE_PATH) {
  * Копіює лише skills зі списку configSkills (джерело: skills/<id>/ у пакеті)
  * @param {string[]} configSkills id без префікса n-
  * @param {string} [bundledSkillsDir] каталог `skills/` у корені пакету-джерела
+ * @param {{ plugins?: unknown } | null} [config] конфіг `.n-rules.json` — активні плагіни для SKILL-фрагментів
  * @returns {Promise<{ success: number, fail: number }>} лічильники успішних і невдалих копіювань
  */
-async function syncSkills(configSkills, bundledSkillsDir = BUNDLED_SKILLS_DIR) {
+async function syncSkills(configSkills, bundledSkillsDir = BUNDLED_SKILLS_DIR, config = null) {
   if (configSkills.length === 0 || !existsSync(bundledSkillsDir)) {
     return { success: 0, fail: 0 }
   }
 
   const skillsRoot = join(cwd(), SKILLS_DIR)
   await mkdir(skillsRoot, { recursive: true })
+  // Активні плагіни — джерело конвенційних фрагментів skills/<id>/SKILL.fragment.md
+  // (фаза 4b spec lang-plugins-extraction): мовні гілки скіла їдуть з плагіном.
+  const activePlugins = resolvePlugins(cwd(), config, { allowInstall: false, quiet: true })
 
   let success = 0
   let fail = 0
@@ -923,6 +933,7 @@ async function syncSkills(configSkills, bundledSkillsDir = BUNDLED_SKILLS_DIR) {
           if (entry.name === 'SKILL.md') {
             content = injectWorktreeNotice(content, worktree)
             content = injectRootNotice(content, rootOnly)
+            content = injectSkillFragments(content, collectSkillFragments(id, activePlugins))
           }
           await writeFile(join(destDir, entry.name), content, 'utf8')
         }
@@ -1487,7 +1498,7 @@ async function runSync() {
 
   await runSyncStep('❌ Skills: ', async () => {
     const { fail: skillFail } = await captureOutput(async () => {
-      const { success: skillOk, fail } = await syncSkills(skills, bundledSkillsDir)
+      const { success: skillOk, fail } = await syncSkills(skills, bundledSkillsDir, config)
       if (skills.length > 0) {
         console.log(`\n🧩 Skills: ${skillOk} скопійовано, ${fail} з помилками`)
       }
@@ -1806,28 +1817,55 @@ try {
           baseRef
         }
         const noFix = args.includes('--no-fix')
+        // `--full` без `--no-fix` мутує ВЕСЬ репо (не лише дельту) — той самий клас
+        // ризику, що й taze: якщо запущено поза .worktrees/, треба ізолювати. `--no-fix`
+        // (detect-only, нуль мутацій) і не-full (дельта, за дизайном працює на живому
+        // дереві задачі, worktree-ізоляція зламала б саму суть дельти) — пропускаємо.
+        const needsWorktreeIsolation = full && !noFix
+        const worktree = needsWorktreeIsolation
+          ? ensureRunningInWorktree(cwdArg, spawnSync, line => console.log(line), {
+              suffix: 'lint',
+              description: 'n-rules lint --full: worktree-only full-repo run'
+            })
+          : { cwd: cwdArg, autoCreated: false, branchArg: null }
+        const runCwd = worktree.cwd
         // Глобальна черга full-прогонів (spec 2026-07-03): одночасно виконується один
         // `lint --full` на машину, паралельні --full чекають лока і бачать чергу та
         // живий прогрес активного прогону; не-full запуски йдуть без лока
         // (див. lint-lock.mjs). Publisher пише знімки прогресу для черги.
         const { withGlobalLintLock, createProgressPublisher } =
           await import('../scripts/lib/lint-surface/lint-lock.mjs')
-        process.exitCode = await withGlobalLintLock({ ...lintOpts, noFix }, async () => {
-          const publisher = lintOpts.full ? createProgressPublisher() : null
-          const runOpts = publisher ? { ...lintOpts, onProgress: publisher.onUpdate } : lintOpts
-          try {
-            if (noFix) {
-              const { detectAll } = await import('../scripts/lib/lint-surface/run-detectors.mjs')
-              // окрема змінна замість (await detectAll(...)).exitCode — no-await-expression-member (oxlint)
-              const detectResult = await detectAll(runOpts)
-              return detectResult.exitCode
+        try {
+          process.exitCode = await withGlobalLintLock({ ...lintOpts, cwd: runCwd, noFix }, async () => {
+            const runOpts = { ...lintOpts, cwd: runCwd }
+            const publisher = runOpts.full ? createProgressPublisher() : null
+            if (publisher) runOpts.onProgress = publisher.onUpdate
+            try {
+              if (noFix) {
+                const { detectAll } = await import('../scripts/lib/lint-surface/run-detectors.mjs')
+                // окрема змінна замість (await detectAll(...)).exitCode — no-await-expression-member (oxlint)
+                const detectResult = await detectAll(runOpts)
+                return detectResult.exitCode
+              }
+              const { runFixPipeline } = await import('../scripts/lib/lint-surface/run-fix.mjs')
+              return await runFixPipeline(runOpts)
+            } finally {
+              publisher?.stop()
+            }
+          })
+        } finally {
+          // Лише для АВТОстворених worktree (лінт уже сидів у своєму — не наш, не чіпаємо).
+          if (worktree.autoCreated) {
+            try {
+              await bringChangesBackToOriginal(runCwd, cwdArg, spawnSync, line => console.log(line))
+            } catch (error) {
+              console.log(
+                `⚠️ Перенесення змін назад провалилось: ${error instanceof Error ? error.message : String(error)}`
+              )
             }
-            const { runFixPipeline } = await import('../scripts/lib/lint-surface/run-fix.mjs')
-            return await runFixPipeline(runOpts)
-          } finally {
-            publisher?.stop()
+            removeAutoCreatedWorktree(worktree.branchArg, cwdArg, spawnSync, line => console.log(line))
           }
-        })
+        }
 
         break
       }

package/package.json

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

package/scripts/lib/auto-worktree.mjs

@@ -0,0 +1,157 @@
+/** @see ./docs/auto-worktree.md */
+import { existsSync } from 'node:fs'
+import { copyFile, mkdir, rm } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+
+/**
+ * Гарантує, що подальші кроки виконуються в ізольованому worktree
+ * (`main.json.worktree: true`-контракт), навіть коли викликач — детермінований
+ * JS-код, що не годує SKILL.md жодному LLM-агенту (тож агентський preflight-блок
+ * з `worktree-notice.mjs` нікому виконувати). Якщо `cwd` вже під `.worktrees/` —
+ * повертає його без змін. Інакше сам створює `.worktrees/<branch>-<suffix>`
+ * (`npx \@7n/mt worktree create`) і ставить залежності (`bun install`).
+ *
+ * **Гейт на чисте дерево.** Auto-create читає стан і потім переносить зміни
+ * назад копіюванням файлів (`bringChangesBackToOriginal`) — а не git merge.
+ * Якщо у вихідному `cwd` вже є незакомічені зміни, вони НЕ потраплять у щойно
+ * створений worktree (той — checkout HEAD), і перенесення назад мовчки
+ * затерло б їх версією з worktree. Тому за замовчуванням (`requireCleanTree:
+ * true`) auto-create кидає на брудному дереві замість ризикувати чужими
+ * незакоміченими правками. Викликач, що гарантує чистоту дерева сам (наприклад
+ * taze — SKILL.md вимагає цього як передумову ще ДО виклику), може передати
+ * `requireCleanTree: false`, щоб не платити за зайву git-команду.
+ * @param {string} cwd каталог для перевірки
+ * @param {typeof import('node:child_process').spawnSync} spawnFn інжект для тестів
+ * @param {(line: string) => void} log колбек прогресу
+ * @param {{ suffix: string, description: string, requireCleanTree?: boolean }} opts `suffix` — коротка (до 10 символів) назва задачі для `<branch>-<suffix>`; `description` — текст для `npx \@7n/mt worktree create`
+ * @returns {{ cwd: string, autoCreated: boolean, branchArg: string|null }} `autoCreated: false` — `cwd` без змін
+ *   (вже worktree); `autoCreated: true` — `cwd` щойно створеного worktree і `branchArg`, з яким його створено
+ */
+export function ensureRunningInWorktree(cwd, spawnFn, log, { suffix, description, requireCleanTree = true }) {
+  const toplevelResult = spawnFn('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' })
+  const toplevel = toplevelResult.status === 0 ? toplevelResult.stdout.trim() : ''
+  const segments = new Set(toplevel.replaceAll('\\', '/').split('/'))
+  if (segments.has('.worktrees')) return { cwd, autoCreated: false, branchArg: null }
+
+  const branchResult = spawnFn('git', ['branch', '--show-current'], { cwd, encoding: 'utf8' })
+  const currentBranch = branchResult.status === 0 ? branchResult.stdout.trim() : ''
+  if (!currentBranch) {
+    throw new Error(
+      `"${cwd}" не в ізольованому worktree (git toplevel: "${toplevel || '?'}"), і поточну гілку визначити не вдалось ` +
+        '(detached HEAD?) — автоматичне створення worktree за конвенцією `<current-branch>-<suffix>` неможливе. Перейди на гілку вручну.'
+    )
+  }
+
+  if (requireCleanTree) {
+    const statusResult = spawnFn('git', ['status', '--porcelain'], { cwd, encoding: 'utf8' })
+    if (statusResult.status === 0 && statusResult.stdout.trim().length > 0) {
+      throw new Error(
+        `"${cwd}" не в ізольованому worktree і має незакомічені зміни — auto-create worktree тут НЕБЕЗПЕЧНИЙ: ` +
+          'перенесення результату назад копіюванням файлів затерло б ці незакомічені правки версією зі свіжого ' +
+          'checkout (worktree = HEAD, без твоїх правок). Закомить/застеш зміни або створи worktree вручну.'
+      )
+    }
+  }
+
+  const branchArg = `${currentBranch}-${suffix}`
+  const pathSegment = branchArg.replaceAll('/', '-')
+  log(`⚠️ "${cwd}" не в ізольованому worktree — створюю ".worktrees/${pathSegment}"...`)
+  runCommand('npx', ['@7n/mt', 'worktree', 'create', branchArg, description], cwd, spawnFn)
+
+  const newCwd = join(cwd, '.worktrees', pathSegment)
+  log('📥 bun install (bootstrap нового дерева)...')
+  runCommand('bun', ['install'], newCwd, spawnFn)
+  return { cwd: newCwd, autoCreated: true, branchArg }
+}
+
+/**
+ * Переносить зміни з автоствореного worktree назад у вихідне дерево як
+ * **untracked/незакомічені** правки (просте копіювання файлів, без git
+ * merge/cherry-pick). Джерело істини — `git status --porcelain` у worktree:
+ * для кожного шляху копіює файл, якщо він існує (модифікація/додавання), або
+ * видаляє його у вихідному дереві, якщо existsSync каже, що в worktree його
+ * вже нема (видалення). Перейменування (`old -> new` у porcelain) переносять
+ * лише нову назву — стара лишається як була, прийнятний компроміс для
+ * інструментів, що самі файли не перейменовують (ефект можливий лише як
+ * побічний результат LLM-рефакторингу чи форматера).
+ * @param {string} worktreeCwd автостворений worktree, з якого переносимо
+ * @param {string} originalCwd вихідне дерево, куди переносимо
+ * @param {typeof import('node:child_process').spawnSync} spawnFn інжект для тестів
+ * @param {(line: string) => void} log колбек прогресу
+ * @param {{ copyFile?: (src: string, dest: string) => Promise<void>, rm?: (path: string, opts?: object) => Promise<void>, mkdir?: (path: string, opts?: object) => Promise<void> }} [deps] інжекти для тестів
+ * @returns {Promise<string[]>} відносні шляхи перенесених файлів
+ */
+export async function bringChangesBackToOriginal(worktreeCwd, originalCwd, spawnFn, log, deps = {}) {
+  const copy = deps.copyFile ?? copyFile
+  const removeFile = deps.rm ?? rm
+  const makeDir = deps.mkdir ?? mkdir
+
+  const statusResult = spawnFn('git', ['status', '--porcelain'], { cwd: worktreeCwd, encoding: 'utf8' })
+  if (statusResult.status !== 0) {
+    log(
+      `⚠️ Не вдалось прочитати git status у "${worktreeCwd}" — зміни НЕ перенесені назад, worktree лишиться для ручного розбору.`
+    )
+    return []
+  }
+
+  const lines = statusResult.stdout.split('\n').filter(Boolean)
+  if (lines.length === 0) {
+    log('ℹ️ Worktree без змін — нічого переносити назад.')
+    return []
+  }
+
+  const brought = []
+  for (const line of lines) {
+    const rest = line.slice(3)
+    const relPath = rest.includes(' -> ') ? rest.split(' -> ', 2)[1] : rest
+    const srcPath = join(worktreeCwd, relPath)
+    const destPath = join(originalCwd, relPath)
+    if (existsSync(srcPath)) {
+      await makeDir(dirname(destPath), { recursive: true })
+      await copy(srcPath, destPath)
+    } else {
+      await removeFile(destPath, { force: true })
+    }
+    brought.push(relPath)
+  }
+  log(`📤 Перенесено назад у "${originalCwd}" як untracked: ${brought.join(', ')}`)
+  return brought
+}
+
+/**
+ * Прибирає автостворений worktree разом з його ефемерною git-гілкою
+ * (`npx \@7n/mt worktree remove <branch>`) — викликати лише ПІСЛЯ
+ * `bringChangesBackToOriginal`, інакше зміни згорять разом з деревом.
+ * Не кидає при провалі — це прибирання, а не крок, від якого залежить
+ * результат прогону; провал лише логується, worktree лишається для
+ * ручного розбору.
+ * @param {string} branchArg гілка, з якою worktree був створений (з `ensureRunningInWorktree`)
+ * @param {string} originalCwd вихідне дерево, звідки виконати `npx \@7n/mt worktree remove`
+ * @param {typeof import('node:child_process').spawnSync} spawnFn інжект для тестів
+ * @param {(line: string) => void} log колбек прогресу
+ * @returns {void}
+ */
+export function removeAutoCreatedWorktree(branchArg, originalCwd, spawnFn, log) {
+  log(`🧹 Прибираю автостворений worktree "${branchArg}"...`)
+  const result = spawnFn('npx', ['@7n/mt', 'worktree', 'remove', branchArg], { cwd: originalCwd, encoding: 'utf8' })
+  if (result.status !== 0) {
+    log(`⚠️ Не вдалось прибрати worktree "${branchArg}" — приберіть вручну (${result.stderr || result.stdout})`)
+  }
+}
+
+/**
+ * Синхронно виконує детерміновану команду (bunx/bun/npx), кидає з
+ * exit-кодом+stderr при провалі.
+ * @param {string} cmd бінарник
+ * @param {string[]} args аргументи
+ * @param {string} cwd робочий каталог
+ * @param {typeof import('node:child_process').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/scripts/lib/docs/auto-worktree.md

@@ -0,0 +1,31 @@
+---
+type: JS Module
+title: auto-worktree.mjs
+resource: npm/scripts/lib/auto-worktree.mjs
+docgen:
+  crc: 8d55dfc5
+  model: openai-codex/gpt-5.4-mini
+  score: 100
+  issues: judge:inaccurate:0.98
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Файл керує запуском у ізольованому worktree, щоб підготувати зміни в окремому середовищі, потім викликати bringChangesBackToOriginal для повернення результату до вихідного дерева і removeAutoCreatedWorktree для очищення тимчасового worktree. Поведінка спирається на конфіг main.json.
+
+## Поведінка
+
+- `ensureRunningInWorktree` — перевіряє, чи виконання вже йде в ізольованому worktree; якщо ні, за потреби створює його для поточної гілки, ставить залежності й повертає новий `cwd`.
+- `bringChangesBackToOriginal` — переносить зміни з автоствореного worktree назад у вихідне дерево як untracked/незакомічені правки, включно з додаванням, оновленням і видаленням файлів; перейменування переносить лише в нову назву.
+- `removeAutoCreatedWorktree` — прибирає автостворений worktree разом із його ефемерною гілкою після перенесення змін назад, а у разі збою лише повідомляє про ручне прибирання.
+
+## Публічний API
+
+- ensureRunningInWorktree — Гарантує ізольований worktree для наступних кроків; якщо вже працюєш у `.worktrees/`, лишає поточний каталог без змін, інакше створює окремий worktree та ставить залежності. За замовчуванням блокує запуск на брудному дереві, щоб не втратити незакомічені правки; це можна послабити лише там, де чистоту вже забезпечили іншим способом.
+- bringChangesBackToOriginal — Повертає зміни з автоствореного worktree у початкове дерево простим копіюванням файлів: нові й змінені файли переносять, видалені — прибирають у вихідному дереві. Працює як перенесення фактичного стану, а не як merge.
+- removeAutoCreatedWorktree — Прибирає тимчасовий worktree та пов’язану з ним ephemeral branch після того, як зміни вже перенесено назад; якщо прибирання не вдалось, залишає worktree для ручного розбору.
+
+## Гарантії поведінки
+
+- (специфічних машинно-виведених гарантій немає)

package/scripts/lib/docs/index.md

@@ -8,6 +8,7 @@ resource: npm/scripts/lib/
 | --------------------------------------------------------------------------- | --------- |
 | [acp-runner.mjs](acp-runner.md)                                             | JS Module |
 | [assert-project-root.mjs](assert-project-root.md)                           | JS Module |
+| [auto-worktree.mjs](auto-worktree.md)                                       | JS Module |
 | [blue-oak.mjs](blue-oak.md)                                                 | JS Module |
 | [changed-files.mjs](changed-files.md)                                       | JS Module |
 | [check-reporter.mjs](check-reporter.md)                                     | JS Module |

package/scripts/lib/docs/skill-fragments.md

@@ -0,0 +1,27 @@
+---
+type: JS Module
+title: skill-fragments.mjs
+resource: npm/scripts/lib/skill-fragments.mjs
+docgen:
+  crc: 8b9c6f98
+---
+
+## Огляд
+
+Фрагменти SKILL.md від плагінів (фаза 4b spec lang-plugins-extraction): плагін шипить конвенційний файл `skills/<skillId>/SKILL.fragment.md` із власною секцією скіла (напр. Rust-гілку taze), а синк доклеює фрагменти активних плагінів до скопійованого `SKILL.md` між стабільними маркерами. Так мовні знання скіла їдуть разом із кодом плагіна, а не сиротіють у ядрі.
+
+## Поведінка
+
+- **collectSkillFragments** — збирає фрагменти скіла з активних плагінів у порядку списку плагінів; відсутній чи порожній файл фрагмента мовчки пропускається.
+- **injectSkillFragments** — вшиває блок фрагментів у текст SKILL.md між маркерами `n-rules:plugin-fragments:start/end` (кожен фрагмент — у власних маркерах з іменем плагіна). Ре-синк ідемпотентний: наявний блок замінюється повністю; порожній список фрагментів — блок прибирається зовсім, текст без блоку не змінюється.
+
+## Публічний API
+
+- FRAGMENTS_START / FRAGMENTS_END — стабільні маркери блоку фрагментів.
+- collectSkillFragments(skillId, plugins) — знайдені фрагменти `{ pluginName, content }`.
+- injectSkillFragments(content, fragments) — текст SKILL.md з актуальним блоком.
+
+## Гарантії поведінки
+
+- Read-only щодо ФС: лише читає файли фрагментів; запис робить викликач (синк).
+- Ідемпотентність вшивання: повторний виклик із тим самим списком не змінює текст.

package/scripts/lib/skill-fragments.mjs

@@ -0,0 +1,59 @@
+/**
+ * Фрагменти SKILL.md від плагінів (фаза 4b spec lang-plugins-extraction).
+ *
+ * Плагін шипить конвенційний файл `skills/<skillId>/SKILL.fragment.md` —
+ * власну секцію скіла (напр. Rust-гілку taze). Під час синку скіла ядро
+ * доклеює фрагменти АКТИВНИХ плагінів до скопійованого `SKILL.md` між
+ * стабільними маркерами — ре-синк ідемпотентний: наявний блок замінюється
+ * повністю, без активних фрагментів — видаляється. Так мовні знання їдуть
+ * разом із кодом плагіна, а не сиротіють у ядрі.
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+/** Маркер початку блоку плагінних фрагментів (стабільний). */
+export const FRAGMENTS_START = '<!-- n-rules:plugin-fragments:start -->'
+/** Маркер кінця блоку плагінних фрагментів. */
+export const FRAGMENTS_END = '<!-- n-rules:plugin-fragments:end -->'
+
+/**
+ * Збирає фрагменти скіла з активних плагінів (у порядку списку плагінів).
+ * @param {string} skillId id скіла без префікса (напр. `taze`)
+ * @param {Array<{ name: string, packageRoot: string }>} plugins активні плагіни (з `resolvePlugins`)
+ * @returns {Array<{ pluginName: string, content: string }>} знайдені фрагменти
+ */
+export function collectSkillFragments(skillId, plugins) {
+  const out = []
+  for (const plugin of plugins) {
+    const fragmentPath = join(plugin.packageRoot, 'skills', skillId, 'SKILL.fragment.md')
+    if (!existsSync(fragmentPath)) continue
+    const content = readFileSync(fragmentPath, 'utf8').trim()
+    if (content !== '') out.push({ pluginName: plugin.name, content })
+  }
+  return out
+}
+
+/**
+ * Вшиває блок фрагментів у текст SKILL.md (перед фінальним переносом рядка).
+ * Наявний блок між маркерами замінюється; порожній список фрагментів — блок
+ * прибирається зовсім.
+ * @param {string} content текст SKILL.md
+ * @param {Array<{ pluginName: string, content: string }>} fragments зібрані фрагменти
+ * @returns {string} текст із актуальним блоком фрагментів
+ */
+export function injectSkillFragments(content, fragments) {
+  const startIdx = content.indexOf(FRAGMENTS_START)
+  const endIdx = content.indexOf(FRAGMENTS_END)
+  let base = content
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    base = content.slice(0, startIdx) + content.slice(endIdx + FRAGMENTS_END.length)
+    base = `${base.trimEnd()}\n`
+  }
+  if (fragments.length === 0) return base
+
+  const parts = fragments.map(
+    f => `<!-- n-rules:plugin:${f.pluginName}:start -->\n\n${f.content}\n\n<!-- n-rules:plugin:${f.pluginName}:end -->`
+  )
+  const block = `${FRAGMENTS_START}\n\n${parts.join('\n\n')}\n\n${FRAGMENTS_END}`
+  return `${base.trimEnd()}\n\n${block}\n`
+}

package/skills/taze/SKILL.md

@@ -1,9 +1,9 @@
 ---
 name: n-taze
 description: >-
-  Оновлення версій модулів проекту (bun/npm; якщо є Cargo.toml — Rust-крейти
-  через cargo-edit; якщо є pyproject.toml — Python-пакети через uv) з
-  аналізом major-змін і автоматичним рефакторингом несумісного коду
+  Оновлення версій модулів проекту (bun/npm вбудовано; інші екосистеми — Rust,
+  Python тощо — через активні lang-плагіни) з аналізом major-змін і
+  автоматичним рефакторингом несумісного коду
 version: '1.2'
 ---
 
@@ -11,63 +11,42 @@ version: '1.2'
 
 ## Мета
 
-Оновити всі модулі проекту (npm/bun-залежності, а за наявності `Cargo.toml`/`pyproject.toml` — і Rust-крейти/Python-пакети) до останніх версій, виявити major-оновлення, перевірити сумісність змін з кодом проекту і за потреби зрефакторити несумісні місця.
+Оновити всі модулі проекту (npm/bun-залежності вбудовано; інші екосистеми — за активними lang-плагінами, їхні гілки описані у фрагментах наприкінці цього файлу) до останніх версій, виявити major-оновлення, перевірити сумісність змін з кодом проекту і за потреби зрефакторити несумісні місця.
 
-## Оркестрація (npm/bun-, Rust- і Python-гілка) — не одним промптом
+## Оркестрація (npm/bun + екосистемні гілки плагінів) — не одним промптом
 
 `npx @7n/rules skill pi|cursor|codex taze` **не** передає цей файл одним суцільним
 промптом в один агентський хід — так робив старий дизайн, і саме тому реальний
 прогін міг зависати без жодної діагностики (один величезний непрозорий хід на
 весь монорепо, без проміжних зупинок для перевірки прогресу). Замість цього `npm/skills/taze/js/orchestrate.mjs`:
 
-1. Детерміновано, без LLM, виконує кроки 1-3 нижче для всіх гілок: npm/bun (бекап → `bunx taze -w -r latest` → `bun install` → `n-rules taze diff`); якщо знайдені `Cargo.toml`, Rust (бекап → `cargo upgrade --incompatible allow` → `cargo update` → `collectCargoDiff` з `cargo-diff.mjs`, детермінований cargo-еквівалент `n-rules taze diff` — парсить кожен `Cargo.toml` через `smol-toml`, класифікує major за тим самим правилом caret-семантики, включно з Cargo-скороченими версіями `"1"`/`"0.4"`); якщо знайдений кореневий `pyproject.toml`, Python (бекап → по кожній прямій залежності `uv remove <pkg>` + `uv add <pkg>[extras] --bounds lower` → `collectUvDiff`, парсить PEP 508/PEP 440 через `smol-toml`, той самий caret-принцип класифікації).
-2. Для кожного **окремого** major-пакета/крейта з diff-у — один ізольований, обмежений виклик обраного раннера (кроки 4-6, лише для цього запису; промпт генерує `buildDependencyPrompt`/`buildCargoDependencyPrompt`/`buildUvDependencyPrompt`, не цей SKILL.md).
+1. Детерміновано, без LLM, виконує кроки 1-3 нижче: npm/bun вбудовано (бекап → `bunx taze -w -r latest` → `bun install` → `n-rules taze diff`), а кожну екосистемну гілку — через її EcosystemProvider (detect → backup → bump → diff; деталі команд — у фрагменті відповідного плагіна наприкінці файлу).
+2. Для кожного **окремого** major-запису з diff-у — один ізольований, обмежений виклик обраного раннера (кроки 4-6, лише для цього запису; промпт генерує `buildDependencyPrompt` ядра або `promptFor` провайдера, не цей SKILL.md).
 3. Детерміновано прибирає бекапи (крок 7) і компонує звіт (крок 8) з результатів усіх ітерацій.
 
 Не-npm екосистеми оркестратор веде через **EcosystemProvider-порт**
 (`@7n/rules/plugin-api`, spec `docs/specs/2026-07-18-lang-plugins-extraction-spec.md`)
-— плагіни, що доставляються автоматично при першому запуску за файловим сигналом
-(extension-point `taze`): Rust — **`@7n/rules-lang-rust`** (кореневий `Cargo.toml`),
-Python — **`@7n/rules-lang-python`** (кореневий `pyproject.toml`). На чисто-JS
-проєкті без цих сигналів у звіті немає навіть згадки про інші екосистеми.
-
-Якщо `Cargo.toml` знайдені, але `cargo-edit` не встановлено — Rust-гілка **не**
-блокує інші гілки: оркестратор пропускає Rust-обробку і в звіті перелічує
-знайдені `Cargo.toml` як такі, що потребують ручного прогону (нижче). Так само,
-якщо `pyproject.toml` знайдений, але `uv` не встановлено — Python-гілка **не**
-блокує інші гілки.
+— lang-плагіни доставляються автоматично при першому запуску за файловим
+сигналом (extension-point `taze`) і додають свої гілки як фрагменти цього
+SKILL.md (блок наприкінці файлу). На чисто-JS проєкті без таких сигналів у
+звіті немає навіть згадки про інші екосистеми. Якщо тулчейн гілки не
+встановлено — вона пропускається з причиною у звіті, не блокуючи інші.
 
 Переваги: падіння/timeout на одному пакеті/крейті не втрачає прогрес по інших;
 кожен виклик успадковує власний timeout раннера (короткий, бо скоуп малий —
 один запис, не весь монорепо); видно прогрес по записах, а не чорну скриньку.
 
-Кроки 1-8 нижче лишаються джерелом правди щодо ЗМІСТУ роботи (що саме робить
-кожен крок) — оркестратор їх виконує програмно (1-3/7/8) або як промпт на
-один запис (4-6) для всіх гілок.
+Кроки 1-8 нижче лишаються джерелом правди щодо ЗМІСТУ роботи npm/bun-гілки
+(і скелетом для екосистемних) — оркестратор їх виконує програмно (1-3/7/8)
+або як промпт на один запис (4-6). Мовні відповідники кроків — у фрагментах
+плагінів наприкінці файлу.
 
 ## Передумови
 
 - Чисте робоче дерево (`git status` без незакомічених змін у `package.json` / `bun.lock` / `node_modules`) — інакше різницю не відрізнити від оновлення.
 - Встановлений `bun` і доступний `bunx`.
 - Запуск з кореня проекту (де лежить `package.json` / `bun.lock`).
-- Якщо в проекті є хоч один `Cargo.toml` (не в `node_modules`/`.worktrees`) — бажано встановлений `cargo-edit` (`cargo install cargo-edit`, дає команду `cargo upgrade`). Без нього major-бампи Rust-залежностей неможливо застосувати детерміновано (голий `cargo update` піднімає лише semver-сумісні версії) — оркестратор пропускає Rust-гілку (без блокування інших гілок) і перелічує знайдені `Cargo.toml` у звіті як такі, що потребують ручного прогону кроків 2-8 нижче.
-- Якщо в проекті є кореневий `pyproject.toml` — бажано встановлений `uv`. Без нього major-бампи Python-залежностей неможливо застосувати детерміновано — оркестратор пропускає Python-гілку (без блокування інших гілок) і перелічує `pyproject.toml` у звіті як такий, що потребує ручного прогону кроків 2-8 нижче.
-
-### 0.2. Детекція Rust-крейтів
-
-```bash
-find . -name Cargo.toml -not -path "*/node_modules/*" -not -path "*/.worktrees/*" -not -path "*/target/*"
-```
-
-Якщо список непорожній — паралельно з npm-гілкою виконуються кроки 1–8 у Rust-варіанті (позначені нижче як «Rust-гілка»). Якщо порожній — Rust-кроки повністю пропускаються.
-
-### 0.3. Детекція Python/uv-проекту
-
-```bash
-test -f pyproject.toml && echo pyproject.toml
-```
-
-v1: лише кореневий `pyproject.toml` (uv-конвенція single-project, без обходу workspace-членів, на відміну від Cargo). Якщо файл існує — паралельно виконуються кроки 1–8 у Python-варіанті (позначені нижче як «Python-гілка»). Якщо відсутній — Python-кроки повністю пропускаються.
+- Передумови екосистемних гілок (інструменти на кшталт cargo-edit чи uv) — у фрагментах плагінів наприкінці файлу; відсутній тулчейн не блокує інші гілки.
 
 ## Workflow
 
@@ -82,20 +61,6 @@ cp bun.lock bun.lock.taze-bak
 
 (У monorepo — також усі `*/package.json` воркспейсів. Файли тимчасові, видалити в кінці.)
 
-**Rust-гілка** — для кожного знайденого на кроці 0.2 `Cargo.toml` (включно з кореневим, якщо є):
-
-```bash
-cp Cargo.toml Cargo.toml.taze-bak
-cp Cargo.lock Cargo.lock.taze-bak   # якщо lock-файл спільний на workspace — достатньо одного бекапу в корені
-```
-
-**Python-гілка** — якщо на кроці 0.3 знайдений `pyproject.toml`:
-
-```bash
-cp pyproject.toml pyproject.toml.taze-bak
-cp uv.lock uv.lock.taze-bak   # якщо є
-```
-
 ### 2. Запустити оновлення
 
 ```bash
@@ -107,27 +72,6 @@ bun install
 - `-r` — рекурсивно по всіх воркспейсах.
 - `latest` — піднімати навіть major.
 
-**Rust-гілка:**
-
-```bash
-cargo upgrade --incompatible allow
-cargo update
-```
-
-- `cargo upgrade` (з `cargo-edit`) переписує вимоги версій у кожному `Cargo.toml` workspace-у на останні; `--incompatible allow` явно дозволяє перетинати major-межу (аналог `-r latest` у taze) — без цього флага incompatible-оновлення за замовчуванням ігноруються.
-- `cargo update` після цього синхронізує `Cargo.lock` з новими вимогами.
-
-**Python-гілка:**
-
-```bash
-for pkg in $(<список прямих залежностей із [project].dependencies>); do
-  uv remove "$pkg"
-  uv add "$pkg" --bounds lower
-done
-```
-
-`uv` **не має** єдиної команди "підняти все до latest, навіть через major" (на відміну від `bunx taze -w -r latest`/`cargo upgrade --incompatible allow`) — підтверджено емпірично: `uv add <pkg>` на вже присутній залежності НЕ переписує specifier без попереднього `uv remove`. `--bounds lower` записує нижню межу без верхньої (`>=<latest>`), коректно зберігає `[extras]`. Провал одного пакета (мережа/резолюція) не втрачає прогрес по інших — оркестратор best-effort відновлює оригінальний рядок, якщо `uv add` не вдався після `uv remove`.
-
 ### 3. Виявити major-оновлення
 
 > **Не порівнюй `package.json` вручну.** Класифікацію semver несе CLI — детерміновано, по всіх воркспейсах.
@@ -140,10 +84,6 @@ n-rules taze diff
 
 Покриває **прямі** залежності з `package.json` (root + воркспейси). Транзитивні major-стрибки (`bun.lock`) — за потреби переглянь окремо; основний ризик breaking-змін — у прямих.
 
-**Rust-гілка (оркестровано)** — `collectCargoDiff` (`npm/skills/taze/js/cargo-diff.mjs`) робить те саме детерміновано: парсить кожен `Cargo.toml.taze-bak`/`Cargo.toml` через `smol-toml`, порівнює `dependencies`/`dev-dependencies`/`build-dependencies` (рядок чи `{ version = "...", features = [...] }`), класифікує за тим самим правилом caret-семантики — Cargo-скорочені версії (`"1"`, `"0.4"`) трактуються як відсутні компоненти = 0. Ручний прогін поза оркестратором — той самий принцип: `diff Cargo.toml.taze-bak Cargo.toml` по рядках `<name> = "<version>"`.
-
-**Python-гілка (оркестровано)** — `collectUvDiff` (`npm/skills/taze/js/uv-diff.mjs`) робить те саме детерміновано: парсить `pyproject.toml.taze-bak`/`pyproject.toml` через `smol-toml`, порівнює `[project].dependencies` (масив PEP 508-рядків, матчинг за іменем пакета — не за позицією), дістає нижню межу PEP 440-специфікатора (`extractLowerBoundVersion`) і класифікує за тим самим правилом caret-семантики. Ручний прогін поза оркестратором — той самий принцип: `diff pyproject.toml.taze-bak pyproject.toml` по записах `[project].dependencies`.
-
 ### 4. Зібрати breaking changes по кожному major-оновленню
 
 Для кожного модуля зі списку зібрати фактичні відмінності одним з джерел (у порядку пріоритету):
@@ -154,10 +94,6 @@ n-rules taze diff
 
 Цікавлять: видалені/перейменовані експорти, змінені сигнатури функцій, змінені типи, змінена поведінка за замовчуванням, видалені CLI-прапорці.
 
-**Rust-гілка** — адресу репозиторію взяти з поля `repository`/`documentation` крейта на `crates.io` (`https://crates.io/crates/<name>`) або з `[package.metadata]`; CHANGELOG зазвичай у `CHANGELOG.md` репозиторію або в GitHub Releases. Якщо немає — `cargo doc` різниця по публічному API (`pub fn`/`pub struct`/`pub trait`) між закешованою старою версією (`~/.cargo/registry/src/*/<name>-<old-version>/`) і новою (`~/.cargo/registry/src/*/<name>-<new-version>/`) через `diff -r src/`.
-
-**Python-гілка** — адресу репозиторію взяти зі сторінки `https://pypi.org/project/<name>/` (поле "Homepage"/"Source"); CHANGELOG зазвичай у `CHANGELOG.md`/`HISTORY.md` репозиторію або в GitHub Releases. Якщо немає — різниця по публічному API між закешованою старою версією (`~/.cache/uv/`) і новою (`.venv/lib/python*/site-packages/<name>/`).
-
 ### 5. Перевірити сумісність з кодом проекту
 
 Для кожного breaking change знайти його використання в коді проекту:
@@ -171,22 +107,6 @@ rg -n "<імпорт|функція|опція>" --type ts --type js --type vue
 - **сумісно** — проект не використовує зачеплене API → нічого не робити.
 - **несумісно** — використання знайдено → перейти до п. 6.
 
-**Rust-гілка:**
-
-```bash
-rg -n "<use-шлях|функція|макрос>" --type rust
-```
-
-Та сама класифікація сумісно/несумісно.
-
-**Python-гілка:**
-
-```bash
-rg -n "<імпорт|функція|клас>" --type py
-```
-
-Та сама класифікація сумісно/несумісно.
-
 ### 6. Рефакторинг несумісних місць
 
 Для кожного несумісного місця — застосувати міграцію згідно з changelog модуля (перейменувати імпорт, оновити сигнатуру виклику, замінити видалену опцію еквівалентом тощо). Після правок:
@@ -197,24 +117,6 @@ bun run typecheck   # якщо є
 bun test            # якщо є
 ```
 
-**Rust-гілка** — після правок:
-
-```bash
-cargo fmt --all -- --check
-cargo clippy --all-targets --all-features -- -D warnings
-cargo test
-```
-
-**Python-гілка** — після правок (залежно від того, що реально налаштовано в проєкті):
-
-```bash
-ruff check .
-mypy .
-pytest
-```
-
-Якщо міграція нетривіальна або неоднозначна — **не вгадувати**, залишити TODO у коді з посиланням на CHANGELOG і винести в підсумковий звіт як ручну дію.
-
 ### 7. Прибрати тимчасові файли
 
 ```bash
@@ -223,20 +125,6 @@ rm package.json.taze-bak bun.lock.taze-bak
 
 (І решту бекапів воркспейсів, якщо створювались.)
 
-**Rust-гілка:**
-
-```bash
-rm Cargo.toml.taze-bak Cargo.lock.taze-bak
-```
-
-(І бекапи по кожному workspace-члену, якщо створювались окремо.)
-
-**Python-гілка:**
-
-```bash
-rm pyproject.toml.taze-bak uv.lock.taze-bak
-```
-
 ### 8. Звіт користувачу
 
 Коротко в одному повідомленні:
@@ -247,12 +135,10 @@ rm pyproject.toml.taze-bak uv.lock.taze-bak
 - **Потребує ручного втручання:** список TODO з причиною (нетривіальна міграція / неоднозначність / падіння тестів).
 - **Стан перевірок:** `lint` / `typecheck` / `test` — pass/fail з номером рядка, де впало.
 
-Якщо на кроці 0.2 знайдені Rust-крейти — додати окрему секцію **Rust-крейти** з тим самим переліком (оновлено / major / зрефакторено / потребує ручного втручання), і в **Стан перевірок** — окремо `cargo fmt` / `cargo clippy` / `cargo test`. Якщо на кроці 0.3 знайдений `pyproject.toml` — так само окрема секція **Python-пакети (uv)**, і в **Стан перевірок** — окремо `ruff` / `mypy` / `pytest`.
+Для кожної обробленої екосистемної гілки — окрема секція з тим самим переліком (оновлено / major / зрефакторено / потребує ручного втручання) і власними перевірками (див. фрагменти плагінів наприкінці файлу).
 
 ## Примітка
 
 - Не запускати `npx @7n/rules lint` паралельно з іншими ESLint-задачами — діє правило з кореневого `CLAUDE.md`.
 - Якщо проект — `npm/` пакет цього репо, після змін у `package.json` / коді треба підняти `version` і додати запис у `CHANGELOG.md` згідно з `npm/CLAUDE.md`.
-- При великій кількості major-оновлень розбити PR по одному модулю на коміт — щоб `git bisect` залишався корисним. Це стосується і Rust-крейтів, і Python-пакетів окремо від npm-пакетів.
-- `cargo upgrade --incompatible allow` редагує `Cargo.toml` навіть для залежностей без доступних breaking changes в змінах API — завжди звіряй крок 4 (CHANGELOG) перед тим, як вважати оновлення безпечним, а не лише факт успішної компіляції.
-- `uv add <pkg>` на вже присутній залежності — no-op (specifier НЕ переписується); детерміновану гілку це не блокує (вона робить `uv remove` спершу), але при ручному прогоні кроків 2-8 легко про це забути.
+- При великій кількості major-оновлень розбити PR по одному модулю на коміт — щоб `git bisect` залишався корисним. Це стосується і пакетів екосистемних гілок окремо від npm-пакетів.

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

@@ -3,7 +3,7 @@ type: JS Module
 title: orchestrate.mjs
 resource: npm/skills/taze/js/orchestrate.mjs
 docgen:
-  crc: bce1f492
+  crc: 6a269363
   model: openai-codex/gpt-5.4-mini
   score: 100
   issues: judge:inaccurate:0.98

package/skills/taze/js/orchestrate.mjs

@@ -1,16 +1,23 @@
 /** @see ./docs/orchestrate.md */
 import { spawnSync } from 'node:child_process'
 import { existsSync } from 'node:fs'
-import { copyFile, mkdir, rm } from 'node:fs/promises'
-import { dirname, join } from 'node:path'
+import { copyFile, rm } from 'node:fs/promises'
+import { join } from 'node:path'
 import { pathToFileURL } from 'node:url'
 
+import {
+  bringChangesBackToOriginal,
+  ensureRunningInWorktree,
+  removeAutoCreatedWorktree
+} from '../../../scripts/lib/auto-worktree.mjs'
 import { assertEcosystemProvider } from '../../../scripts/lib/plugin-api.mjs'
 import { readNRulesConfigLite } from '../../../scripts/lib/read-n-rules-config-lite.mjs'
 import { getHandlers, resolvePlugins } from '../../../scripts/lib/resolve-plugins.mjs'
 import { getMonorepoPackageRootDirs } from '../../../scripts/lib/workspaces.mjs'
 import { collectTazeDiff } from './diff.mjs'
 
+export { bringChangesBackToOriginal, removeAutoCreatedWorktree } from '../../../scripts/lib/auto-worktree.mjs'
+
 /** Суфікс бекапу package.json — той самий, що й у `diff.mjs`/кроці 1 SKILL.md. */
 const BACKUP_SUFFIX = '.taze-bak'
 
@@ -80,125 +87,6 @@ export async function callRunner(runner, prompt, cwd, deps = {}) {
   }
 }
 
-/**
- * Гарантує, що подальші кроки оркестратора виконуються в ізольованому
- * worktree (`main.json.worktree: true`, той самий контракт, що й для інших
- * worktree-only скілів). Оркестратор не годує SKILL.md жодному агенту, тож
- * замість покладатись на агента, що читає SKILL.md-preflight, сам детерміновано
- * створює worktree конвенцією `<current-branch>-taze` (`npx \@7n/mt worktree
- * create`) і ставить залежності — щоб `bunx taze -w -r latest`/`bun install`
- * ніколи не виконались прямо в основному дереві виклику. `autoCreated: true`
- * сигналить викликачеві, що після завершення прогону варто перенести зміни
- * назад (`bringChangesBackToOriginal`) і прибрати worktree
- * (`removeAutoCreatedWorktree`) — а не лишати сирітське дерево.
- * @param {string} cwd каталог для перевірки
- * @param {typeof spawnSync} spawnFn інжект для тестів
- * @param {(line: string) => void} log колбек прогресу
- * @returns {{ cwd: string, autoCreated: boolean, branchArg: string|null }} `autoCreated: false` — `cwd` без змін
- *   (вже worktree); `autoCreated: true` — `cwd` щойно створеного worktree і `branchArg`, з яким його створено
- */
-function ensureRunningInWorktree(cwd, spawnFn, log) {
-  const toplevelResult = spawnFn('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' })
-  const toplevel = toplevelResult.status === 0 ? toplevelResult.stdout.trim() : ''
-  const segments = new Set(toplevel.replaceAll('\\', '/').split('/'))
-  if (segments.has('.worktrees')) return { cwd, autoCreated: false, branchArg: null }
-
-  const branchResult = spawnFn('git', ['branch', '--show-current'], { cwd, encoding: 'utf8' })
-  const currentBranch = branchResult.status === 0 ? branchResult.stdout.trim() : ''
-  if (!currentBranch) {
-    throw new Error(
-      `taze: "${cwd}" не в ізольованому worktree (git toplevel: "${toplevel || '?'}"), і поточну гілку визначити не вдалось ` +
-        '(detached HEAD?) — автоматичне створення worktree за конвенцією `<current-branch>-taze` неможливе. Перейди на гілку вручну.'
-    )
-  }
-
-  const branchArg = `${currentBranch}-taze`
-  const pathSegment = branchArg.replaceAll('/', '-')
-  log(`⚠️ "${cwd}" не в ізольованому worktree — створюю ".worktrees/${pathSegment}"...`)
-  runCommand('npx', ['@7n/mt', 'worktree', 'create', branchArg, 'n-taze: worktree-only skill'], cwd, spawnFn)
-
-  const newCwd = join(cwd, '.worktrees', pathSegment)
-  log('📥 bun install (bootstrap нового дерева)...')
-  runCommand('bun', ['install'], newCwd, spawnFn)
-  return { cwd: newCwd, autoCreated: true, branchArg }
-}
-
-/**
- * Переносить зміни з автоствореного worktree назад у вихідне дерево як
- * **untracked/незакомічені** правки (просте копіювання файлів, без git
- * merge/cherry-pick) — так само, як їх бачив би користувач, якби сам
- * працював у вихідному дереві. Джерело істини — `git status --porcelain`
- * у worktree: для кожного шляху копіює файл, якщо він існує (модифікація/
- * додавання), або видаляє його у вихідному дереві, якщо existsSync каже,
- * що в worktree його вже нема (видалення). Перейменування (`old -> new` у
- * porcelain) переносять лише нову назву — стара лишається як була, це
- * прийнятний компроміс: taze не перейменовує файли сам, ефект можливий
- * лише як побічний результат LLM-рефакторингу.
- * @param {string} worktreeCwd автостворений worktree, з якого переносимо
- * @param {string} originalCwd вихідне дерево, куди переносимо
- * @param {typeof spawnSync} spawnFn інжект для тестів
- * @param {(line: string) => void} log колбек прогресу
- * @param {{ copyFile?: (src: string, dest: string) => Promise<void>, rm?: (path: string, opts?: object) => Promise<void>, mkdir?: (path: string, opts?: object) => Promise<void> }} [deps] інжекти для тестів
- * @returns {Promise<string[]>} відносні шляхи перенесених файлів
- */
-export async function bringChangesBackToOriginal(worktreeCwd, originalCwd, spawnFn, log, deps = {}) {
-  const copy = deps.copyFile ?? copyFile
-  const removeFile = deps.rm ?? rm
-  const makeDir = deps.mkdir ?? mkdir
-
-  const statusResult = spawnFn('git', ['status', '--porcelain'], { cwd: worktreeCwd, encoding: 'utf8' })
-  if (statusResult.status !== 0) {
-    log(
-      `⚠️ Не вдалось прочитати git status у "${worktreeCwd}" — зміни НЕ перенесені назад, worktree лишиться для ручного розбору.`
-    )
-    return []
-  }
-
-  const lines = statusResult.stdout.split('\n').filter(Boolean)
-  if (lines.length === 0) {
-    log('ℹ️ Worktree без змін — нічого переносити назад.')
-    return []
-  }
-
-  const brought = []
-  for (const line of lines) {
-    const rest = line.slice(3)
-    const relPath = rest.includes(' -> ') ? rest.split(' -> ', 2)[1] : rest
-    const srcPath = join(worktreeCwd, relPath)
-    const destPath = join(originalCwd, relPath)
-    if (existsSync(srcPath)) {
-      await makeDir(dirname(destPath), { recursive: true })
-      await copy(srcPath, destPath)
-    } else {
-      await removeFile(destPath, { force: true })
-    }
-    brought.push(relPath)
-  }
-  log(`📤 Перенесено назад у "${originalCwd}" як untracked: ${brought.join(', ')}`)
-  return brought
-}
-
-/**
- * Прибирає автостворений worktree разом з його ефемерною git-гілкою
- * (`npx \@7n/mt worktree remove <branch>`) — викликати лише ПІСЛЯ
- * `bringChangesBackToOriginal`, інакше зміни згорять разом з деревом.
- * Не кидає при провалі — це прибирання, а не крок, від якого залежить
- * результат прогону; провал лише логується, worktree лишається для
- * ручного розбору.
- * @param {string} branchArg гілка, з якою worktree був створений (з `ensureRunningInWorktree`)
- * @param {string} originalCwd вихідне дерево, звідки виконати `npx \@7n/mt worktree remove`
- * @param {typeof spawnSync} spawnFn інжект для тестів
- * @param {(line: string) => void} log колбек прогресу
- * @returns {void}
- */
-export function removeAutoCreatedWorktree(branchArg, originalCwd, spawnFn, log) {
-  log(`🧹 Прибираю автостворений worktree "${branchArg}"...`)
-  const result = spawnFn('npx', ['@7n/mt', 'worktree', 'remove', branchArg], { cwd: originalCwd, encoding: 'utf8' })
-  if (result.status !== 0) {
-    log(`⚠️ Не вдалось прибрати worktree "${branchArg}" — приберіть вручну (${result.stderr || result.stdout})`)
-  }
-}
-
 /**
  * Синхронно виконує детерміновану команду (bunx/bun), кидає з
  * exit-кодом+stderr при провалі.
@@ -430,7 +318,10 @@ export async function runTazeOrchestrator(options = {}) {
   const call = deps.callRunner ?? callRunner
 
   const originalCwd = options.cwd ?? process.cwd()
-  const worktree = ensureRunningInWorktree(originalCwd, spawnFn, log)
+  const worktree = ensureRunningInWorktree(originalCwd, spawnFn, log, {
+    suffix: 'taze',
+    description: 'n-taze: worktree-only skill'
+  })
   const cwd = worktree.cwd
 
   try {