@7n/test 0.13.0 → 0.14.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.14.1] - 2026-07-11
+
+### Changed
+
+- fix(coverage): самодостатній JS-колектор — без залежності від @nitra/cursor providers
+
+## [0.14.0] - 2026-07-11
+
+### Added
+
+- Ланцюжки (chains) @nitra/llm-lib ^1.1.0: mutant-classify — chain per mutant (tier1/tier2 = кроки, cache hit без chain), test-generate — chain per file (header + local/cloud спроби + vitest/length-retry = кроки), test-fix — chain per прогін (batch-виклики = кроки); адаптер callText/callAgent прокидає opts.chain. Аналітика ланцюжків — n-llm-chains-report і вкладка «Ланцюжки» в myllm.
+
+### Changed
+
+- підняти @7n/llm-lib до ^2.0.2 (rename @nitra/llm-lib → @7n/llm-lib уже застосовано в dacc051; нова мажорна версія без змін API — chains/компресія/body-capture, лише перейменування пакета)
+
 ## [0.13.0] - 2026-07-05
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/test",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "description": "CLI-утиліта @7n/test",
   "keywords": [
     "7n",
@@ -41,7 +41,7 @@
   "dependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.3",
     "@nitra/check-env": "^4.2.1",
-    "@nitra/llm-lib": "^1.0.0",
+    "@7n/llm-lib": "^2.0.2",
     "@vitest/coverage-v8": "^4.1.9",
     "rollup": "^4.62.2",
     "vitest": "^4.1.9",

package/src/coverage/aggregate.mjs

@@ -0,0 +1,31 @@
+/**
+ * Сумування coverage/mutation totals — спільна утиліта для collector-ів
+ * (js-collector.mjs) і оркестратора (coverage.mjs). Винесено в окремий модуль,
+ * щоб уникнути циклічного імпорту collector ↔ orchestrator.
+ */
+
+/**
+ * Сума двох coverage-totals.
+ * @param {{lines:{covered:number,total:number}, functions:{covered:number,total:number}}} a перший subtotal
+ * @param {{lines:{covered:number,total:number}, functions:{covered:number,total:number}}} b другий subtotal
+ * @returns {{lines:{covered:number,total:number}, functions:{covered:number,total:number}}} сумарні lines/functions
+ */
+export function addCoverage(a, b) {
+  return {
+    lines: { covered: a.lines.covered + b.lines.covered, total: a.lines.total + b.lines.total },
+    functions: {
+      covered: a.functions.covered + b.functions.covered,
+      total: a.functions.total + b.functions.total
+    }
+  }
+}
+
+/**
+ * Сума двох mutation-counts.
+ * @param {{caught:number,total:number}} a перший subtotal
+ * @param {{caught:number,total:number}} b другий subtotal
+ * @returns {{caught:number,total:number}} сумарні caught/total
+ */
+export function addMutation(a, b) {
+  return { caught: a.caught + b.caught, total: a.total + b.total }
+}

package/src/coverage/coverage.mjs

@@ -1,65 +1,27 @@
 /**
- * Канонічна команда `n coverage`: збирає метрики покриття + мутаційного
- * тестування з усіх провайдерів, чиє правило активне в `.n-cursor.json#rules`,
- * агрегує та записує COVERAGE.md у корінь проєкту.
+ * Канонічна команда `@7n/test coverage`: збирає метрики покриття + мутаційного
+ * тестування через вбудований JS-колектор (`js-collector.mjs`), агрегує та
+ * записує COVERAGE.md у корінь проєкту.
  *
- * Discovery провайдерів — за `.n-cursor.json#rules`: для кожного `ruleId` зі
- * списку шукаємо `<rulesDir>/<ruleId>/coverage/coverage.mjs` і динамічно
- * імпортуємо. Якщо файлу немає — провайдер для цього правила відсутній (skip
- * silently, не помилка).
- *
- * `rulesDir` резолвиться з `node_modules/@nitra/cursor/rules` у cwd проєкту.
- * Override — через `opts.rulesDir` у `runCoverageSteps`.
+ * Самодостатній — не залежить від `@nitra/cursor` (раніше — provider-discovery
+ * за `.n-cursor.json#rules` через `<rulesDir>/<ruleId>/coverage/coverage.mjs`;
+ * provider-підсистема видалена з `@nitra/cursor` 2026-07-10, лишаючи оркестратор
+ * без жодного провайдера). Наразі підтримується лише JS/TS (`js-collector.mjs`);
+ * інші мови (Rust тощо) — не покриті, до появи власного колектора тут.
  *
  * Лок — прямий виклик `withLock('coverage', steps)`.
  */
-import { existsSync } from 'node:fs'
 import { readFile, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
-import { pathToFileURL } from 'node:url'
 
 import { applyVerdicts } from '../coverage-classify/apply.mjs'
 import { classify } from '../coverage-classify/index.mjs'
 import { collectChangedFilesSince, resolveChangedBase } from '../scripts/lib/changed-files.mjs'
-import { readNCursorConfigLite } from '../scripts/lib/read-n-cursor-config-lite.mjs'
 import { withLock } from '../scripts/utils/with-lock.mjs'
+import { addCoverage, addMutation } from './aggregate.mjs'
+import { collect as collectJs, detect as detectJs } from './js-collector.mjs'
 
-/**
- * Знаходить rulesDir @nitra/cursor у node_modules проєкту.
- * @param {string} cwd корінь проєкту
- * @returns {string|null} абсолютний шлях до rules/ або null
- */
-function resolveDefaultRulesDir(cwd) {
-  const localPath = join(cwd, 'node_modules', '@nitra', 'cursor', 'rules')
-  if (existsSync(localPath)) return localPath
-  return null
-}
-
-/**
- * Сума двох coverage-totals.
- * @param {{lines:{covered:number,total:number}, functions:{covered:number,total:number}}} a перший subtotal
- * @param {{lines:{covered:number,total:number}, functions:{covered:number,total:number}}} b другий subtotal
- * @returns {{lines:{covered:number,total:number}, functions:{covered:number,total:number}}} сумарні lines/functions
- */
-export function addCoverage(a, b) {
-  return {
-    lines: { covered: a.lines.covered + b.lines.covered, total: a.lines.total + b.lines.total },
-    functions: {
-      covered: a.functions.covered + b.functions.covered,
-      total: a.functions.total + b.functions.total
-    }
-  }
-}
-
-/**
- * Сума двох mutation-counts.
- * @param {{caught:number,total:number}} a перший subtotal
- * @param {{caught:number,total:number}} b другий subtotal
- * @returns {{caught:number,total:number}} сумарні caught/total
- */
-export function addMutation(a, b) {
-  return { caught: a.caught + b.caught, total: a.total + b.total }
-}
+export { addCoverage, addMutation }
 
 /**
  * Форматує covered/total як `XX.XX% (covered/total)`.
@@ -166,23 +128,6 @@ export function renderMarkdown(rows, allowedGaps = []) {
   return `${lines.join('\n')}\n`
 }
 
-/**
- * Завантажує provider-модуль з `<rulesDir>/<ruleId>/coverage/coverage.mjs`.
- * Повертає null коли:
- *   - файлу немає (rule без coverage-провайдера),
- *   - файл існує, але не експортує `detect` + `collect` як функції.
- * @param {string} rulesDir корінь rules/ (з @nitra/cursor або override)
- * @param {string} ruleId id правила з `.n-cursor.json#rules`
- * @returns {Promise<{detect:(cwd:string)=>Promise<boolean>, collect:(cwd:string)=>Promise<Array<object>>}|null>} provider-модуль або null
- */
-async function loadProvider(rulesDir, ruleId) {
-  const providerPath = join(rulesDir, ruleId, 'coverage', 'coverage.mjs')
-  if (!existsSync(providerPath)) return null
-  const mod = await import(pathToFileURL(providerPath).href)
-  if (typeof mod.detect !== 'function' || typeof mod.collect !== 'function') return null
-  return mod
-}
-
 /**
  * Будує підсумковий рядок «Разом» через сумування всіх coverage/mutation.
  * @param {Array<{area:string, coverage:object, mutation:object}>} rows рядки провайдерів без totals
@@ -225,43 +170,24 @@ export function resolveChangedScope(cwd) {
 }
 
 /**
- * Виконує coverage-pipeline: discovery провайдерів за `.n-cursor.json#rules`,
- * detect+collect для кожного, агрегація, запис COVERAGE.md.
- * @param {{cwd?:string, rulesDir?:string, fix?:boolean, changed?:boolean}} [opts]
+ * Виконує coverage-pipeline: JS-колектор (detect+collect), агрегація, запис COVERAGE.md.
+ * @param {{cwd?:string, fix?:boolean, changed?:boolean}} [opts]
  * @returns {Promise<number>} exit code (0 OK, 1 помилка)
  */
 export async function runCoverageSteps(opts = {}) {
   const cwd = opts.cwd ?? process.cwd()
-  const rulesDir = opts.rulesDir ?? resolveDefaultRulesDir(cwd)
-
-  if (!rulesDir) {
-    console.error(
-      '✗ Не знайдено @nitra/cursor у node_modules. ' +
-        'Встанови @nitra/cursor як devDependency або передай rulesDir через opts.'
-    )
-    return 1
-  }
-
-  const config = await readNCursorConfigLite(cwd)
   const scope = opts.changed ? resolveChangedScope(cwd) : null
   const collectOpts = scope ? { changedFiles: scope.files, base: scope.base } : {}
-  const rows = []
 
-  for (const ruleId of config.rules) {
-    if (config.disableRules.includes(ruleId)) continue
-    const provider = await loadProvider(rulesDir, ruleId)
-    if (!provider) continue
-    if (!(await provider.detect(cwd))) continue
-    console.log(`→ ${ruleId} coverage…`)
-    rows.push(...(await provider.collect(cwd, collectOpts)))
-  }
+  const applicable = await detectJs(cwd)
+  const rows = applicable ? await collectJs(cwd, collectOpts) : []
 
   if (rows.length === 0) {
     if (opts.changed) {
-      console.log('✓ coverage --changed: немає змінених файлів у scope провайдерів — пропускаю')
+      console.log('✓ coverage --changed: немає змінених файлів у scope — пропускаю')
       return 0
     }
-    console.error('✗ Жодного провайдера покриття не знайдено для активних правил у .n-cursor.json#rules')
+    console.error('✗ Coverage: не знайдено тестів (vitest не задекларовано, або жоден workspace не має тестів)')
     return 1
   }
 
@@ -301,15 +227,15 @@ export async function runCoverageSteps(opts = {}) {
 }
 
 /**
- * CLI entrypoint для `n coverage [--fix] [--changed]`.
- * @param {{fix?:boolean, changed?:boolean, rulesDir?:string}} [opts]
+ * CLI entrypoint для `@7n/test coverage [--fix] [--changed]`.
+ * @param {{cwd?:string, fix?:boolean, changed?:boolean}} [opts]
  * @returns {Promise<number>} exit code
  */
 export async function runCoverageCli(opts = {}) {
   const code = await withLock('coverage', () => runCoverageSteps(opts))
   if (code === 0 && opts.fix) {
     console.log('\n♻️  Повторний coverage після агента…\n')
-    return withLock('coverage', () => runCoverageSteps({ fix: false, changed: opts.changed, rulesDir: opts.rulesDir }))
+    return withLock('coverage', () => runCoverageSteps({ cwd: opts.cwd, fix: false, changed: opts.changed }))
   }
   return code
 }

package/src/coverage/js-collector.mjs

@@ -0,0 +1,437 @@
+/**
+ * Самодостатній JS/TS coverage + mutation-testing колектор: збирає метрики покриття
+ * (`vitest run --coverage`) і мутаційного тестування (Stryker з vitest-runner + perTest).
+ * Не залежить від `@nitra/cursor` — раніше жив там як rule-провайдер
+ * (`rules/js/coverage/coverage.mjs`), видалений разом з усією provider-підсистемою
+ * (2026-07-10). Тепер — вбудований collector `@7n/test coverage`.
+ */
+import { spawnSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { mkdtemp, readFile, rm } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import { tmpdir } from 'node:os'
+import { dirname, isAbsolute, join, relative } from 'node:path'
+
+import { resolveAllJsRoots } from '../lib/resolve-js-root.mjs'
+import { addCoverage, addMutation } from './aggregate.mjs'
+
+const TEST_BLOCK_START = /^\s*(it|test)\(/
+const FILE_EXTENSION = /\.[^.]+$/
+/** JS/TS-розширення — файли, які мутує Stryker і покриває vitest. */
+const JS_FILE = /\.(c|m)?[jt]sx?$/
+/** Тест-файли (`*.test.*` / `*.spec.*`) — НЕ production-код, не йдуть у Stryker `--mutate`. */
+const TEST_FILE = /\.(test|spec)\.[^.]+$/
+
+/**
+ * Звужує список змінених файлів (relative до cwd) до тих, що лежать під `jsRoot`,
+ * мають JS/TS-розширення, і рібейзить їх відносно `jsRoot`.
+ * @param {string[]} changedFiles relative-до-cwd шляхи змінених файлів
+ * @param {string} cwd корінь проєкту
+ * @param {string} jsRoot абсолютний шлях workspace-кореня
+ * @returns {string[]} JS-файли під jsRoot, шляхи relative до jsRoot
+ */
+export function scopeToRoot(changedFiles, cwd, jsRoot) {
+  const out = []
+  for (const f of changedFiles) {
+    if (!JS_FILE.test(f)) continue
+    const rel = relative(jsRoot, join(cwd, f))
+    if (rel.startsWith('..') || isAbsolute(rel)) continue
+    out.push(rel)
+  }
+  return out
+}
+
+const VITEST_HINT =
+  'js coverage: vitest відсутній у package.json — додай `vitest`, `@vitest/coverage-v8` та `@stryker-mutator/vitest-runner` у devDependencies (див. test.mdc)'
+
+/**
+ * Чи у пакеті встановлено vitest (через dependencies або devDependencies).
+ * @param {{dependencies?: Record<string,string>, devDependencies?: Record<string,string>}} pkg package.json
+ * @returns {boolean} true, якщо `vitest` декларовано хоча б в одному dep-section
+ */
+function hasVitestDep(pkg) {
+  return Boolean(pkg.devDependencies?.vitest) || Boolean(pkg.dependencies?.vitest)
+}
+
+/**
+ * Чи колектор застосовний у поточному cwd. Активується, коли `vitest`
+ * декларовано хоча б в одному JS-root АБО у кореневому `package.json`
+ * (workspace-проєкт із hoisted node_modules — типовий патерн bun monorepo).
+ * Інакше silent skip із hint у stderr (одноразово).
+ * @param {string} cwd корінь проєкту
+ * @returns {Promise<boolean>} true, якщо проєкт сумісний з vitest-based coverage
+ */
+export async function detect(cwd) {
+  const jsRoots = await resolveAllJsRoots(cwd)
+  if (jsRoots.length === 0) return false
+  for (const jsRoot of jsRoots) {
+    const pkgPath = join(jsRoot, 'package.json')
+    if (!existsSync(pkgPath)) continue
+    const pkg = JSON.parse(await readFile(pkgPath, 'utf8'))
+    if (hasVitestDep(pkg)) return true
+  }
+  const rootInJsRoots = jsRoots.includes(cwd)
+  if (!rootInJsRoots) {
+    const rootPkgPath = join(cwd, 'package.json')
+    if (existsSync(rootPkgPath)) {
+      const rootPkg = JSON.parse(await readFile(rootPkgPath, 'utf8'))
+      if (hasVitestDep(rootPkg)) return true
+    }
+  }
+  if (!detect._hinted) {
+    console.error(VITEST_HINT)
+    detect._hinted = true
+  }
+  return false
+}
+
+/**
+ * Парс lcov.info: сумує LF/LH (рядки) і FNF/FNH (функції) по всіх records.
+ * @param {string} text вміст lcov.info
+ * @returns {{lines:{covered:number,total:number}, functions:{covered:number,total:number}}} агреговані totals
+ */
+function parseLcov(text) {
+  const acc = { lines: { covered: 0, total: 0 }, functions: { covered: 0, total: 0 } }
+  for (const line of text.split('\n')) {
+    if (line.startsWith('LF:')) acc.lines.total += Number(line.slice(3))
+    else if (line.startsWith('LH:')) acc.lines.covered += Number(line.slice(3))
+    else if (line.startsWith('FNF:')) acc.functions.total += Number(line.slice(4))
+    else if (line.startsWith('FNH:')) acc.functions.covered += Number(line.slice(4))
+  }
+  return acc
+}
+
+/**
+ * Витягує оригінальний фрагмент коду з рядків файлу за позицією мутанта.
+ * @param {string[]} fileLines рядки файлу (0-indexed)
+ * @param {{start:{line:number,column:number},end:{line:number,column:number}}} loc позиція (рядки 1-indexed)
+ * @returns {string} оригінальний текст мутанта
+ */
+function extractOriginal(fileLines, loc) {
+  const startLine = loc.start.line - 1
+  const endLine = loc.end.line - 1
+  if (startLine === endLine) {
+    return fileLines[startLine]?.slice(loc.start.column, loc.end.column) ?? ''
+  }
+  const parts = []
+  for (let i = startLine; i <= endLine; i++) {
+    const line = fileLines[i] ?? ''
+    if (i === startLine) parts.push(line.slice(loc.start.column))
+    else if (i === endLine) parts.push(line.slice(0, loc.end.column))
+    else parts.push(line)
+  }
+  return parts.join('\n')
+}
+
+/**
+ * Витягує перший `it(` або `test(` блок з вмісту тест-файлу.
+ * Відстежує глибину `{}` для коректного завершення.
+ * @param {string} content вміст тест-файлу
+ * @returns {string | null} перший тест-блок або null
+ */
+export function extractFirstTestBlock(content) {
+  const lines = content.split('\n')
+  let startLine = -1
+  let depth = 0
+  let inBlock = false
+  const result = []
+  for (const [i, line] of lines.entries()) {
+    if (startLine === -1 && TEST_BLOCK_START.test(line)) startLine = i
+    if (startLine === -1) continue
+    result.push(line)
+    for (const ch of line) {
+      if (ch === '{') {
+        depth++
+        inBlock = true
+      } else if (ch === '}') depth--
+    }
+    if (inBlock && depth === 0) break
+  }
+  return result.length > 0 ? result.join('\n') : null
+}
+
+/**
+ * Шукає тест-файл для заданого source-файлу і повертає перший тест-блок як приклад стилю.
+ * Кандидати: `<base>.test.js`, `<base>.test.mjs`, `<dir>/tests/<name>.test.js`.
+ * @param {string} jsRoot абсолютний шлях до JS-кореня
+ * @param {string} filename відносний шлях source-файлу (від jsRoot)
+ * @returns {{testFile:string, code:string|null} | null} null — якщо тест-файл не знайдено
+ */
+export function findExampleTest(jsRoot, filename) {
+  const base = filename.replace(FILE_EXTENSION, '')
+  const candidates = [`${base}.test.js`, `${base}.test.mjs`, `${base}.test.ts`]
+  const lastSlash = base.lastIndexOf('/')
+  if (lastSlash !== -1) {
+    const dir = base.slice(0, lastSlash)
+    const name = base.slice(lastSlash + 1)
+    candidates.push(`${dir}/tests/${name}.test.js`, `${dir}/tests/${name}.test.mjs`)
+  }
+  for (const rel of candidates) {
+    const full = join(jsRoot, rel)
+    if (!existsSync(full)) continue
+    const content = readFileSync(full, 'utf8')
+    return { testFile: rel, code: extractFirstTestBlock(content) }
+  }
+  return null
+}
+
+/**
+ * Парс Stryker mutation.json: Killed+Timeout → caught; Survived+NoCoverage → до total.
+ * Compile/Runtime помилки виключаються з total.
+ * Survived мутанти групуються по файлах з exampleTest.
+ * @param {{files:Record<string,{mutants:Array<{status:string,mutatorName?:string,replacement?:string,location?:{start:{line:number,column:number},end:{line:number,column:number}}}>}>}} report Stryker mutation.json
+ * @param {string|null} [jsRoot] корінь для читання source-рядків і пошуку тест-файлів
+ * @returns {{caught:number,total:number,survived:Array<{file:string,mutants:Array<{line:number,col:number,mutantType:string,original:string,replacement:string}>,exampleTest:{testFile:string,code:string|null}|null,recommendationText:string|null}>}} результат парсу: caught/total та згруповані survived мутанти
+ */
+export function parseStrykerReport(report, jsRoot) {
+  let caught = 0
+  let total = 0
+  /** @type {Map<string, Array<{line:number,col:number,mutantType:string,original:string,replacement:string}>>} */
+  const byFile = new Map()
+
+  for (const [filePath, fileData] of Object.entries(report.files)) {
+    let fileLines = null
+    for (const mutant of fileData.mutants) {
+      if (mutant.status === 'Killed' || mutant.status === 'Timeout') {
+        caught += 1
+        total += 1
+      } else if (mutant.status === 'Survived' || mutant.status === 'NoCoverage') {
+        total += 1
+        if (mutant.status === 'Survived' && jsRoot && mutant.location) {
+          if (!fileLines) {
+            try {
+              fileLines = readFileSync(join(jsRoot, filePath), 'utf8').split('\n')
+            } catch {
+              fileLines = []
+            }
+          }
+          if (!byFile.has(filePath)) byFile.set(filePath, [])
+          byFile.get(filePath).push({
+            line: mutant.location.start.line,
+            col: mutant.location.start.column,
+            mutantType: mutant.mutatorName ?? 'Unknown',
+            original: extractOriginal(fileLines, mutant.location),
+            replacement: mutant.replacement ?? ''
+          })
+        }
+      }
+    }
+  }
+
+  const survived = []
+  for (const [file, mutants] of byFile) {
+    survived.push({
+      file,
+      mutants,
+      exampleTest: jsRoot ? findExampleTest(jsRoot, file) : null,
+      recommendationText: null
+    })
+  }
+
+  return { caught, total, survived }
+}
+
+/**
+ * Шлях до локально встановленого Stryker core-bin (поряд із плагінами на кшталт
+ * `@stryker-mutator/vitest-runner`). Запуск саме його через `node` — не `npx`/`bunx` —
+ * дає Stryker побачити локальні плагіни при plugin-discovery.
+ * @returns {string | null} абсолютний шлях `bin/stryker.js` або `null`, якщо не встановлено
+ */
+let strykerBinCache
+
+/**
+ * Резолвить локальний Stryker core bin (мемоізовано).
+ * @returns {string | null} абсолютний шлях `bin/stryker.js` або `null`
+ */
+function resolveLocalStrykerBin() {
+  if (strykerBinCache !== undefined) return strykerBinCache
+  try {
+    // `exports` у core НЕ відкриває `./bin/stryker.js`, тож резолвимо package.json
+    // (доступний) і беремо шлях bin звідти. Ключ bin зазвичай `stryker`; як запас —
+    // перше значення map'и.
+    const require = createRequire(import.meta.url)
+    const pkgJsonPath = require.resolve('@stryker-mutator/core/package.json')
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf8'))
+    const binRel = typeof pkg.bin === 'string' ? pkg.bin : (pkg.bin?.stryker ?? Object.values(pkg.bin ?? {})[0])
+    strykerBinCache = binRel ? join(dirname(pkgJsonPath), binRel) : null
+  } catch {
+    strykerBinCache = null
+  }
+  return strykerBinCache
+}
+
+const defaultRunner = {
+  runJsCoverage({ cwd, lcovDir, base }) {
+    // base !== undefined ⇔ --changed-режим: vitest сам рахує зачеплені змінами тести
+    // через граф імпортів. `--changed <base>` порівнює base↔робоче дерево (committed і
+    // uncommitted разом); `--changed` без аргументу — uncommitted vs HEAD.
+    const changedArgs = base === undefined ? [] : base === null ? ['--changed'] : ['--changed', base]
+    const r = spawnSync(
+      'bunx',
+      [
+        'vitest',
+        'run',
+        '--passWithNoTests',
+        '--coverage',
+        '--coverage.reporter=lcov',
+        `--coverage.reportsDirectory=${lcovDir}`,
+        ...changedArgs
+      ],
+      { cwd, stdio: 'inherit', env: process.env }
+    )
+    return r.status ?? 1
+  },
+  runStryker({ cwd, mutate }) {
+    // Plugin-discovery Stryker (`@stryker-mutator/*`) globиться відносно CORE-install-каталогу
+    // (`core/dist/src/di/plugin-loader.js` → `../../../../../@stryker-mutator/*`). Тож core
+    // МАЄ вантажитись із проєктного `node_modules`, де поряд лежить `@stryker-mutator/vitest-runner`.
+    // `npx`/`bunx` тягнуть core у власний кеш (`_npx/<hash>`, `bunx-temp`) БЕЗ плагінів → воркери
+    // падають `Cannot find TestRunner plugin "vitest"`. Тому резолвимо локальний core-bin через
+    // `import.meta.url` і запускаємо його через `node`. Fallback на `npx`, якщо не встановлено.
+    // mutate (непорожній) ⇔ --changed-режим: мутуємо лише змінені production-файли цього root.
+    const mutateArgs = mutate && mutate.length > 0 ? ['--mutate', mutate.join(',')] : []
+    const strykerBin = resolveLocalStrykerBin()
+    const r = strykerBin
+      ? spawnSync(strykerBin, ['run', ...mutateArgs], { cwd, stdio: 'inherit', env: process.env })
+      : spawnSync('npx', ['@stryker-mutator/core', 'run', ...mutateArgs], { cwd, stdio: 'inherit', env: process.env })
+    return r.status ?? 1
+  }
+}
+
+/**
+ * Збирає метрики покриття + мутаційного тестування для **одного** JS-root.
+ *
+ * Full-режим (`scope === null`): vitest на всьому suite + Stryker на всіх файлах
+ * config-глоба. Пропускає workspace без тестів (повертає `null`): vitest пройшов з
+ * `--passWithNoTests`, але lcov порожній — нема сенсу запускати Stryker.
+ *
+ * Changed-режим (`scope = { files, base }`): vitest `--changed <base>` (лише
+ * зачеплені тести) + Stryker `--mutate` лише по змінених production-файлах. Тут
+ * **не** пропускаємо на порожньому lcov — змінений src без тестів має дати
+ * NoCoverage-мутанти (gate впаде, як і має). Якщо змінено лише тест-файли (нема
+ * production-src) — Stryker не запускаємо (мутувати нічого), повертаємо лише coverage.
+ *
+ * Реальні помилки (vitest exit ≠ 0, відсутній mutation.json попри запуск Stryker)
+ * кидаються — у multi-root режимі це не маскує справжній збій.
+ * @param {string} jsRoot абсолютний шлях до workspace-кореня
+ * @param {string} cwd корінь проєкту (для рібейзингу `survived[].file`)
+ * @param {{runJsCoverage:Function, runStryker:Function}} runner spawn-ін'єкція
+ * @param {{files:string[], base:string|null}|null} [scope] changed-scope (null = full-режим)
+ * @returns {Promise<{coverage:object, mutation:{caught:number,total:number}, survived:Array<object>} | null>} результати або null коли full-режим і workspace без тестів
+ */
+async function collectOneRoot(jsRoot, cwd, runner, scope = null) {
+  const wsRel = relative(cwd, jsRoot)
+  // У changed-режимі production-файли для мутації = змінені JS цього root без тест-файлів.
+  const mutateSrc = scope ? scope.files.filter(f => !TEST_FILE.test(f)) : null
+
+  // 1. Coverage через vitest run --passWithNoTests --coverage (+ --changed у changed-режимі)
+  const lcovDir = await mkdtemp(join(tmpdir(), 'js-cov-'))
+  let coverage
+  try {
+    const code = await runner.runJsCoverage(scope ? { cwd: jsRoot, lcovDir, base: scope.base } : { cwd: jsRoot, lcovDir })
+    if (code !== 0) throw new Error(`JS coverage exit ${code}`)
+    const lcovPath = join(lcovDir, 'lcov.info')
+    coverage = existsSync(lcovPath)
+      ? parseLcov(await readFile(lcovPath, 'utf8'))
+      : { lines: { covered: 0, total: 0 }, functions: { covered: 0, total: 0 } }
+  } finally {
+    await rm(lcovDir, { recursive: true, force: true })
+  }
+
+  // Full-режим: порожній lcov ⇔ vitest не знайшов тестів → пропускаємо workspace,
+  // щоб не ганяти Stryker марно. У changed-режимі НЕ пропускаємо (див. JSDoc).
+  if (!scope) {
+    const hasTests = coverage.lines.total > 0 || coverage.functions.total > 0
+    if (!hasTests) return null
+  }
+
+  // Changed-режим без production-src (змінено лише тест-файли) → мутувати нічого.
+  if (scope && mutateSrc.length === 0) {
+    return { coverage, mutation: { caught: 0, total: 0 }, survived: [] }
+  }
+
+  // 2. Mutation через Stryker (у changed-режимі — лише по mutateSrc)
+  await runner.runStryker(scope ? { cwd: jsRoot, mutate: mutateSrc } : { cwd: jsRoot })
+  const mutationPath = join(jsRoot, 'reports', 'stryker', 'mutation.json')
+  if (!existsSync(mutationPath)) {
+    throw new Error(
+      'js coverage: stryker не залишив mutation.json — ' +
+        'переконайся що встановлено canonical stryker.config.mjs (vitest-runner, perTest), ' +
+        'або налаштуй його вручну'
+    )
+  }
+  const mutationReport = JSON.parse(await readFile(mutationPath, 'utf8'))
+  const parsed = parseStrykerReport(mutationReport, jsRoot)
+
+  return {
+    coverage,
+    mutation: { caught: parsed.caught, total: parsed.total },
+    survived: parsed.survived.map(group => ({
+      ...group,
+      file: wsRel === '' ? group.file : join(wsRel, group.file),
+      exampleTest: group.exampleTest
+        ? {
+            ...group.exampleTest,
+            testFile: wsRel === '' ? group.exampleTest.testFile : join(wsRel, group.exampleTest.testFile)
+          }
+        : null
+    }))
+  }
+}
+
+/**
+ * Збирає JS-метрики покриття + мутаційного тестування. У monorepo ітерує усі
+ * JS-roots з `resolveAllJsRoots()` (включно з glob-патернами `cf/*`), запускає
+ * vitest+Stryker у кожному та сумує lcov/mutation через `addCoverage`/`addMutation`.
+ * Workspaces без тестів пропускаються (див. `collectOneRoot`).
+ * Якщо тестів немає у жодному workspace — повертає `[]`.
+ * Шляхи у `survived` рібейзяться відносно `cwd`, щоб `coverage-fix.mjs`
+ * знаходив джерела через `join(projectRoot, file)`.
+ *
+ * Changed-режим (`opts.changedFiles` задано): кожен root отримує лише свої змінені
+ * JS-файли (`scopeToRoot`); roots без змінених JS пропускаються повністю (ні vitest,
+ * ні Stryker). Якщо змін нема ніде — повертає `[]` без error-логу (оркестратор
+ * трактує порожній changed-scope як pass).
+ * @param {string} cwd корінь проєкту
+ * @param {{runner?: typeof defaultRunner, changedFiles?: string[], base?: string|null}} [opts] runner-ін'єкція + changed-scope
+ * @returns {Promise<Array<{area:string, coverage:object, mutation:{caught:number,total:number}, survived:Array<object>}>>} рядок `JS` або `[]` коли тестів/змін нема ніде
+ */
+export async function collect(cwd, opts = {}) {
+  const runner = opts.runner ?? defaultRunner
+  const changed = Array.isArray(opts.changedFiles)
+  const jsRoots = await resolveAllJsRoots(cwd)
+  if (jsRoots.length === 0) throw new Error('js coverage: package.json не знайдено')
+
+  const results = []
+  for (const jsRoot of jsRoots) {
+    let scope = null
+    if (changed) {
+      const files = scopeToRoot(opts.changedFiles, cwd, jsRoot)
+      if (files.length === 0) continue // root без змінених JS — пропускаємо
+      scope = { files, base: opts.base ?? null }
+    }
+    const r = await collectOneRoot(jsRoot, cwd, runner, scope)
+    if (r !== null) results.push(r)
+  }
+
+  if (results.length === 0) {
+    // Changed-режим: нема змінених JS у жодному root → тихо порожньо (це pass, не помилка).
+    if (changed) return []
+    console.error(
+      'js coverage: жоден workspace не має тестів ' +
+        '(`*.test.{js,mjs}` у `tests/` або поряд із джерелом) — ' +
+        'додай тести або запусти `npx @7n/test` для генерації'
+    )
+    return []
+  }
+
+  let coverage = { lines: { covered: 0, total: 0 }, functions: { covered: 0, total: 0 } }
+  let mutation = { caught: 0, total: 0 }
+  const survived = []
+  for (const r of results) {
+    coverage = addCoverage(coverage, r.coverage)
+    mutation = addMutation(mutation, r.mutation)
+    survived.push(...r.survived)
+  }
+  return [{ area: 'JS', coverage, mutation, survived }]
+}

package/src/coverage-classify/docs/index.md

@@ -3,7 +3,7 @@ type: JS Module
 title: index.mjs
 resource: npm/src/coverage-classify/index.mjs
 docgen:
-  crc: bc7320ff
+  crc: 6f120c02
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
 ---
 

package/src/coverage-classify/index.mjs

@@ -10,7 +10,8 @@
 import { join } from 'node:path'
 
 import { callText } from '../lib/llm.mjs'
-import { CLOUD_MIN, LOCAL_MIN } from '@nitra/llm-lib/model-tiers'
+import { CLOUD_MIN, LOCAL_MIN } from '@7n/llm-lib/model-tiers'
+import { startChain } from '@7n/llm-lib/chain'
 import { deriveCacheKey, readCache, writeCache } from './cache.mjs'
 import { buildUserPrompt, SYSTEM_PROMPT } from './prompt.mjs'
 import { parseVerdict } from './verdict-schema.mjs'
@@ -26,52 +27,77 @@ const FALLBACK_VERDICT = {
  * @param {string} prompt
  * @param {string} model provider/model-id або '' для pi-дефолту
  * @param {string} cwd
+ * @param {{chain?: object}} [callOpts] chain handle поточного мутанта
  * @returns {Promise<string>}
  */
-function callModel(prompt, model, cwd) {
-  return callText(prompt, { cwd, ...(model && { model }) })
+function callModel(prompt, model, cwd, { chain } = {}) {
+  return callText(prompt, { cwd, chain, ...(model && { model }) })
 }
 
 /**
  * Два тири: tier1 (local-min) → tier2 (cloud-min) → FALLBACK_VERDICT.
+ * Кожен мутант — окремий ланцюжок (kind: mutant-classify): tier1 = крок 1,
+ * tier2 = крок 2; fallback-вердикт = outcome:'fail' (LLM не впорався).
  * @param {{file: string, mutants: object[]}} group
  * @param {object} mutant
  * @param {string} cwd
- * @param {(prompt: string, model: string, cwd: string) => Promise<string>} callModelFn
+ * @param {(prompt: string, model: string, cwd: string, callOpts?: {chain?: object}) => Promise<string>} callModelFn
  * @param {string} tier1 model-spec першого тиру ('' = pi-дефолт)
  * @param {string} tier2 model-spec другого тиру ('' = pi-дефолт)
+ * @param {typeof startChain} makeChain фабрика ланцюжка
  * @returns {Promise<object>} verdict
  */
-async function classifyOne(group, mutant, cwd, callModelFn, tier1, tier2) {
+async function classifyOne(group, mutant, cwd, callModelFn, tier1, tier2, makeChain) {
   const prompt = `${SYSTEM_PROMPT}\n\n${buildUserPrompt({ ...mutant, file: group.file }, cwd)}`
   const loc = `${group.file}:${mutant.line}:${mutant.col}`
+  const chain = makeChain({ kind: 'mutant-classify', unit: loc, cwd })
 
   try {
-    const text = await callModelFn(prompt, tier1, cwd)
-    return parseVerdict(text)
+    const text = await callModelFn(prompt, tier1, cwd, { chain })
+    const verdict = parseVerdict(text)
+    chain.end({ outcome: 'success', extra: verdictExtra(verdict, mutant) })
+    return verdict
   } catch {
     try {
-      const text = await callModelFn(prompt, tier2, cwd)
-      return parseVerdict(text)
+      const text = await callModelFn(prompt, tier2, cwd, { chain })
+      const verdict = parseVerdict(text)
+      chain.end({ outcome: 'success', extra: verdictExtra(verdict, mutant) })
+      return verdict
     } catch (error) {
       console.warn(`⚠ coverage classify: ${loc} both tiers failed: ${error.message}`)
+      chain.end({ outcome: 'fail', extra: { error: String(error.message ?? error).slice(0, 200) } })
       return { ...FALLBACK_VERDICT }
     }
   }
 }
 
+/**
+ * Extra-поля фінального chain-запису мутанта.
+ * @param {{verdict: string, confidence: number}} verdict розпарсений вердикт
+ * @param {{replacement?: string}} mutant мутант
+ * @returns {object} extra
+ */
+function verdictExtra(verdict, mutant) {
+  return {
+    verdict: verdict.verdict,
+    confidence: verdict.confidence,
+    replacement: String(mutant.replacement ?? '').slice(0, 120)
+  }
+}
+
 /**
  * Класифікує survived мутантів через pi (N_LOCAL_MIN_MODEL → N_CLOUD_MIN_MODEL → fallback).
  * @param {Array<{file: string, mutants: object[], exampleTest?: object|null, recommendationText?: string|null}>} survived
  * @param {string} cwd
- * @param {{cachePath?: string, callModel?: (prompt: string, model: string, cwd: string) => Promise<string>,
- *   tier1?: string, tier2?: string}} [opts] `tier1`/`tier2` — явні model-specs (дефолт: LOCAL_MIN/CLOUD_MIN пакета;
- *   інжектовні, бо тир-константи фіксуються при імпорті й у тестах не стабляться через env)
+ * @param {{cachePath?: string, callModel?: (prompt: string, model: string, cwd: string, callOpts?: {chain?: object}) => Promise<string>,
+ *   tier1?: string, tier2?: string, startChain?: typeof startChain}} [opts] `tier1`/`tier2` — явні model-specs (дефолт: LOCAL_MIN/CLOUD_MIN пакета;
+ *   інжектовні, бо тир-константи фіксуються при імпорті й у тестах не стабляться через env); `startChain` — фабрика ланцюжка (інжект для тестів)
  * @returns {Promise<Array<{key: string, verdict: object}>>}
  */
 export async function classify(survived, cwd, opts = {}) {
   const cachePath = opts.cachePath ?? join(cwd, 'npm/reports/coverage-classify.cache.json')
   const callModelFn = opts.callModel ?? callModel
+  const makeChain = opts.startChain ?? startChain
   const tier1 = opts.tier1 ?? LOCAL_MIN
   const tier2 = opts.tier2 ?? CLOUD_MIN
   const cacheModel = `${tier1 || 'default'}+${tier2 || 'cloud'}`
@@ -99,7 +125,7 @@ export async function classify(survived, cwd, opts = {}) {
         }
       }
       if (!verdict) {
-        verdict = await classifyOne(group, mutant, cwd, callModelFn, tier1, tier2)
+        verdict = await classifyOne(group, mutant, cwd, callModelFn, tier1, tier2, makeChain)
         if (cacheKey) {
           cache.entries[cacheKey] = { ...verdict, classifiedAt: new Date().toISOString() }
         }

package/src/coverage-fix.mjs

@@ -9,7 +9,7 @@
 import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { env } from 'node:process'
-import { CLOUD_MAX } from '@nitra/llm-lib/model-tiers'
+import { CLOUD_MAX } from '@7n/llm-lib/model-tiers'
 import { callAgent } from './lib/llm.mjs'
 
 const MODEL = env.N_CURSOR_COVERAGE_FIX_MODEL ?? CLOUD_MAX
@@ -41,7 +41,7 @@ export async function fixSurvivedMutants(survived, projectRoot, opts = {}) {
 }
 
 /**
- * Викликає агента через @nitra/llm-lib (SDK-embed, live-output до stdout) —
+ * Викликає агента через `@7n/llm-lib` (SDK-embed, live-output до stdout) —
  * заміна колишнього spawnSync pi CLI.
  * @param {string} prompt текст промпта
  * @param {string} model  provider/model-id або '' для pi-дефолту

package/src/docs/assess-need.md

@@ -3,7 +3,7 @@ type: JS Module
 title: assess-need.mjs
 resource: npm/src/assess-need.mjs
 docgen:
-  crc: 960f8332
+  crc: 20c3d440
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
 ---
 

package/src/docs/coverage-fix.md

@@ -3,7 +3,7 @@ type: JS Module
 title: coverage-fix.mjs
 resource: npm/src/coverage-fix.mjs
 docgen:
-  crc: d0a20c67
+  crc: db577cf1
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
 ---
 

package/src/docs/fix-tests.md

@@ -3,7 +3,7 @@ type: JS Module
 title: fix-tests.mjs
 resource: npm/src/fix-tests.mjs
 docgen:
-  crc: 6597b7fc
+  crc: 713e7889
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
 ---
 

package/src/docs/gen-tests.md

@@ -3,7 +3,7 @@ type: JS Module
 title: gen-tests.mjs
 resource: npm/src/gen-tests.mjs
 docgen:
-  crc: 99d3e9b7
+  crc: 0183f9b9
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
 ---
 

package/src/fix-tests.mjs

@@ -20,8 +20,9 @@ import { tmpdir } from 'node:os'
 import { join, relative } from 'node:path'
 import { env } from 'node:process'
 import { callText, MEMORY_ERROR_RE } from './lib/llm.mjs'
-import { CLOUD_MAX } from '@nitra/llm-lib/model-tiers'
-import { budgetFor, capText, packBatch } from '@nitra/llm-lib/prompt-budget'
+import { CLOUD_MAX } from '@7n/llm-lib/model-tiers'
+import { startChain } from '@7n/llm-lib/chain'
+import { budgetFor, capText, packBatch } from '@7n/llm-lib/prompt-budget'
 import { findTestRules } from './gen-tests.mjs'
 import { parseFailingTests } from './coverage-per-file.mjs'
 import { resolveVitestRun } from './lib/vitest-shim.mjs'
@@ -322,17 +323,28 @@ function writeFixedFiles(fixed, remaining, dir) {
  * @param {string} dir project root
  * @param {{
  *   failures?: Array<{file: string, errors: string[]}>,
- *   callTextFn?: (prompt: string, opts?: object) => Promise<string>
- * }} [opts] overrides for callText and pre-fetched failures
+ *   callTextFn?: (prompt: string, opts?: object) => Promise<string>,
+ *   startChain?: typeof startChain
+ * }} [opts] overrides for callText, pre-fetched failures і фабрика ланцюжка (інжект для тестів)
  * @returns {Promise<{count: number, fixed: number, remaining: number}>} fix result summary
  */
 export async function fixFailingTests(dir, opts = {}) {
-  const callTextFn =
-    opts.callTextFn ?? (prompt => callText(prompt, { model: MODEL, cwd: dir, maxTokens: budgetFor('fix').maxTokens }))
   const failures = opts.failures ?? (await getFailingTests(dir))
 
   if (failures.length === 0) return { count: 0, fixed: 0, remaining: 0 }
 
+  // Один ланцюжок на прогін: батчі змішують файли, per-file chain неможливий
+  // без ламання батчингу; кожен batch-виклик = крок.
+  const chain = (opts.startChain ?? startChain)({
+    kind: 'test-fix',
+    unit: `fix:${failures.length}files`,
+    cwd: dir
+  })
+  let batches = 0
+  const callTextFn =
+    opts.callTextFn ??
+    (prompt => callText(prompt, { model: MODEL, cwd: dir, maxTokens: budgetFor('fix').maxTokens, chain }))
+
   console.log(`\n🔧 Виправляю ${failures.length} падаючих test-файлів (pi text mode)...\n`)
   for (const f of failures) {
     console.log(`  • ${f.file} (${f.errors.length} помилок)`)
@@ -342,50 +354,64 @@ export async function fixFailingTests(dir, opts = {}) {
   let remaining = failures
   const attempts = new Map()
   let prevDeferred = new Set()
-  for (;;) {
-    // Спроби рахуються per-file (лише коли файл реально був у батчі),
-    // тож deferred-черга не з'їдає ліміт файлів, які ще не пробували
-    const eligible = remaining
-      .filter(f => (attempts.get(f.file) ?? 0) < MAX_FIX_ATTEMPTS)
-      // Анти-starvation: відкладені минулого разу файли йдуть першими
-      .toSorted((a, b) => (prevDeferred.has(b.file) ? 1 : 0) - (prevDeferred.has(a.file) ? 1 : 0))
-    if (eligible.length === 0) break
-
-    const batch = buildFixTestsBatch(eligible, dir)
-    if (batch.deferred.length) {
-      console.log(
-        `  📦 батч: ${batch.included.length} файлів, відкладено на наступний прохід: ${batch.deferred.length}`
+  try {
+    for (;;) {
+      // Спроби рахуються per-file (лише коли файл реально був у батчі),
+      // тож deferred-черга не з'їдає ліміт файлів, які ще не пробували
+      const eligible = remaining
+        .filter(f => (attempts.get(f.file) ?? 0) < MAX_FIX_ATTEMPTS)
+        // Анти-starvation: відкладені минулого разу файли йдуть першими
+        .toSorted((a, b) => (prevDeferred.has(b.file) ? 1 : 0) - (prevDeferred.has(a.file) ? 1 : 0))
+      if (eligible.length === 0) break
+
+      const batch = buildFixTestsBatch(eligible, dir)
+      if (batch.deferred.length) {
+        console.log(
+          `  📦 батч: ${batch.included.length} файлів, відкладено на наступний прохід: ${batch.deferred.length}`
+        )
+      }
+      for (const file of batch.included) attempts.set(file, (attempts.get(file) ?? 0) + 1)
+      prevDeferred = new Set(batch.deferred)
+
+      let response
+      try {
+        batches++
+        response = await callTextFn(batch.prompt)
+      } catch (error) {
+        // memory-guard: не звичайна per-file помилка — RAM-стеля фіксована, продовжувати
+        // до наступного файлу немає сенсу. Пробиваємо нагору до CLI, аби процес завершився.
+        if (MEMORY_ERROR_RE.test(error.message ?? '')) throw error
+        console.error(`  ✗ pi помилка: ${error.message}`)
+        break
+      }
+
+      const fixed = parseFixedFiles(response)
+
+      if (fixed.length === 0) {
+        console.error('  ✗ pi не повернула виправлений код')
+        break
+      }
+
+      const includedSet = new Set(batch.included)
+      writeFixedFiles(
+        fixed,
+        eligible.filter(f => includedSet.has(f.file)),
+        dir
       )
-    }
-    for (const file of batch.included) attempts.set(file, (attempts.get(file) ?? 0) + 1)
-    prevDeferred = new Set(batch.deferred)
 
-    let response
-    try {
-      response = await callTextFn(batch.prompt)
-    } catch (error) {
-      // memory-guard: не звичайна per-file помилка — RAM-стеля фіксована, продовжувати
-      // до наступного файлу немає сенсу. Пробиваємо нагору до CLI, аби процес завершився.
-      if (MEMORY_ERROR_RE.test(error.message ?? '')) throw error
-      console.error(`  ✗ pi помилка: ${error.message}`)
-      break
+      remaining = await getFailingTests(dir)
     }
-
-    const fixed = parseFixedFiles(response)
-
-    if (fixed.length === 0) {
-      console.error('  ✗ pi не повернула виправлений код')
-      break
-    }
-
-    const includedSet = new Set(batch.included)
-    writeFixedFiles(
-      fixed,
-      eligible.filter(f => includedSet.has(f.file)),
-      dir
-    )
-
-    remaining = await getFailingTests(dir)
+  } finally {
+    const fixedSoFar = failures.length - remaining.length
+    chain.end({
+      outcome: remaining.length === 0 ? 'success' : fixedSoFar > 0 ? 'partial' : 'fail',
+      extra: {
+        files: failures.map(f => f.file),
+        batches,
+        fixed: fixedSoFar,
+        remaining: remaining.length
+      }
+    })
   }
 
   const fixedCount = failures.length - remaining.length

package/src/gen-tests.mjs

@@ -18,7 +18,8 @@ import { spawnSync } from 'node:child_process'
 import { join, relative, dirname } from 'node:path'
 import { callText, MEMORY_ERROR_RE } from './lib/llm.mjs'
 import { env } from 'node:process'
-import { budgetFor } from '@nitra/llm-lib/prompt-budget'
+import { budgetFor } from '@7n/llm-lib/prompt-budget'
+import { startChain } from '@7n/llm-lib/chain'
 import { resolveVitestRun } from './lib/vitest-shim.mjs'
 import { extractExportsWithComplexity } from './classify-exports.mjs'
 import { analyzeModule } from './lib/ast-analyze.mjs'
@@ -1149,9 +1150,10 @@ function resolveLocalModel(opts) {
  * @param {PiCallFn} callTextFn cloud LLM caller
  * @param {PiCallFn | null} localFn local LLM caller
  * @param {GenerateOneFn | undefined} generateOne custom single-file generator
+ * @param {typeof startChain} [makeChain] фабрика ланцюжка (інжект для тестів)
  * @returns {Promise<void>} resolves after generation for this file completes
  */
-async function generateTestsForFile(fileInfo, dir, callTextFn, localFn, generateOne) {
+async function generateTestsForFile(fileInfo, dir, callTextFn, localFn, generateOne, makeChain = startChain) {
   console.log(`  → ${fileInfo.file} (${fileInfo.pct.toFixed(1)}%)`)
 
   if (generateOne) {
@@ -1159,13 +1161,26 @@ async function generateTestsForFile(fileInfo, dir, callTextFn, localFn, generate
     return
   }
 
-  const exportsInfo = extractExportsWithComplexity(readSourceSnippet(join(dir, fileInfo.file)))
-  if (localFn && exportsInfo.length > 0) {
-    await generatePerExport(fileInfo, dir, callTextFn, localFn)
-    return
-  }
+  // Ланцюжок файлу: усі виклики (header, per-export local/cloud спроби,
+  // vitest-retry, length-retry) — кроки одного chain.
+  const chain = makeChain({ kind: 'test-generate', unit: fileInfo.file, cwd: dir })
+  const chainedCloud = (prompt, callOpts = {}) => callTextFn(prompt, { ...callOpts, chain })
+  const chainedLocal = localFn ? (prompt, callOpts = {}) => localFn(prompt, { ...callOpts, chain }) : null
+  let failed = null
+  try {
+    const exportsInfo = extractExportsWithComplexity(readSourceSnippet(join(dir, fileInfo.file)))
+    if (chainedLocal && exportsInfo.length > 0) {
+      await generatePerExport(fileInfo, dir, chainedCloud, chainedLocal)
+      return
+    }
 
-  await generateOneTest(fileInfo, dir, callTextFn)
+    await generateOneTest(fileInfo, dir, chainedCloud)
+  } catch (error) {
+    failed = String(error.message ?? error).slice(0, 200)
+    throw error
+  } finally {
+    chain.end({ outcome: failed ? 'fail' : 'success', extra: failed ? { error: failed } : {} })
+  }
 }
 
 /**

package/src/index.js

@@ -11,9 +11,22 @@ export async function run(args) {
     console.log('  Runs coverage analysis, generates missing tests, then mutation testing.')
     console.log('  --no-mutation  Skip mutation testing phase.')
     console.log('  Defaults to current directory when no argument is given.')
+    console.log('Usage: n coverage [--fix] [--changed]')
+    console.log('  Coverage + mutation testing only (no test generation) — writes COVERAGE.md.')
+    console.log('  --fix      Agent fixes survived mutants, then re-runs coverage.')
+    console.log('  --changed  Scope to files changed vs merge-base with main — no COVERAGE.md write.')
     return 0
   }
 
+  if (first === 'coverage') {
+    const { runCoverageCli } = await import('./coverage/coverage.mjs')
+    return runCoverageCli({
+      cwd: getCwd(),
+      fix: flags.includes('--fix'),
+      changed: flags.includes('--changed')
+    })
+  }
+
   const dir = first ? resolve(first) : getCwd()
   const noMutation = flags.includes('--no-mutation')
   const { runAutoTest } = await import('./run.mjs')

package/src/lib/docs/llm.md

@@ -3,12 +3,12 @@ type: JS Module
 title: llm.mjs
 resource: npm/src/lib/llm.mjs
 docgen:
-  crc: 41c6ec97
+  crc: b126a1aa
 ---
 
 ## Огляд
 
-Тонкий адаптер @7n/test над пакетом `@nitra/llm-lib` (Ф3 спеки llm-lib-extraction у репо cursor): зберігає звичний контракт `callText`/`callAgent` для внутрішніх колерів (gen-tests, fix-tests, assess-need, coverage-classify, coverage-fix), а транспорт, registry і трасування повністю живуть у пакеті. Замінив колишній `pi-client.mjs` з власним SDK-плюмбінгом, retry/backoff і прямим omlx-HTTP.
+Тонкий адаптер @7n/test над пакетом `@7n/llm-lib` (Ф3 спеки llm-lib-extraction у репо cursor): зберігає звичний контракт `callText`/`callAgent` для внутрішніх колерів (gen-tests, fix-tests, assess-need, coverage-classify, coverage-fix), а транспорт, registry і трасування повністю живуть у пакеті. Замінив колишній `pi-client.mjs` з власним SDK-плюмбінгом, retry/backoff і прямим omlx-HTTP.
 
 ## Поведінка
 

package/src/lib/llm.mjs

@@ -1,5 +1,5 @@
 /**
- * Тонкий адаптер @7n/test над @nitra/llm-lib (Ф3 спеки llm-lib-extraction):
+ * Тонкий адаптер `@7n/test` над `@7n/llm-lib` (Ф3 спеки llm-lib-extraction):
  * зберігає звичний контракт `callText`/`callAgent` для внутрішніх колерів,
  * але транспорт/registry/trace повністю живуть у пакеті.
  *
@@ -10,10 +10,10 @@
  * подвоєння `maxTokens` на обрізаній відповіді (`stopReason: 'length'`):
  * це семантичний повтор без пауз, а не очікування зайнятого сервера.
  */
-import { MEMORY_ERROR_RE, runOneShot } from '@nitra/llm-lib/one-shot'
-import { runAgentSkill } from '@nitra/llm-lib/agent-skill'
+import {  runOneShot } from '@7n/llm-lib/one-shot'
+import { runAgentSkill } from '@7n/llm-lib/agent-skill'
+
 
-export { MEMORY_ERROR_RE }
 
 /**
  * Стеля відповіді моделі для подвоєння на `stopReason: 'length'` — межа
@@ -33,6 +33,7 @@ const AGENT_TIMEOUT_MS = 900_000
  * @param {string} [opts.model] provider/model-id (напр. "openai/gpt-5.5"); без значення — default pi
  * @param {number} [opts.maxTokens] стеля відповіді для цього виклику; на
  *   `stopReason: 'length'` виклик повторюється один раз із подвоєною стелею
+ * @param {object} [opts.chain] chain handle (`@7n/llm-lib/chain`) — виклик стає кроком ланцюжка
  * @param {object} [opts.deps] інжекти для тестів (прокидаються у runOneShot)
  * @returns {Promise<string>} текстова відповідь моделі
  */
@@ -44,6 +45,7 @@ export async function callText(prompt, opts = {}) {
     timeoutMs: 0,
     cwd: opts.cwd,
     caller: '7n-test:text',
+    chain: opts.chain ?? null,
     deps: opts.deps
   })
   if (r.error) throw new Error(r.error)
@@ -66,6 +68,7 @@ export async function callText(prompt, opts = {}) {
  * @param {string} cwd робоча директорія, куди агент може писати файли
  * @param {object} [opts] додаткові параметри
  * @param {string} [opts.model] provider/model-id або '' для pi-дефолту
+ * @param {object} [opts.chain] chain handle (`@7n/llm-lib/chain`) — виклик стає кроком ланцюжка
  * @param {object} [opts.deps] інжекти для тестів (прокидаються у runAgentSkill)
  * @returns {Promise<void>} проміс завершується після виконання агента
  */
@@ -77,7 +80,10 @@ export async function callAgent(prompt, cwd, opts = {}) {
     timeoutMs: AGENT_TIMEOUT_MS,
     maxTokens: 0, // без стелі: агент пише цілі тест-файли (паритет зі старим CLI-шляхом)
     caller: 'agent:7n-test',
+    chain: opts.chain ?? null,
     deps: opts.deps
   })
   if (r.error) throw new Error(r.error)
 }
+
+export {MEMORY_ERROR_RE} from '@7n/llm-lib/one-shot'

package/src/lib/resolve-js-root.mjs

@@ -0,0 +1,60 @@
+/**
+ * Резолвить корінь(и) JS-коду в проєкті: для workspace-projects — усі workspaces
+ * (з підтримкою glob-патернів типу `cf/*`), для single-package — корінь cwd.
+ */
+import { existsSync } from 'node:fs'
+import { glob, readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+const WORKSPACE_GLOB_IGNORE = ['**/node_modules/**', '**/.git/**']
+const PACKAGE_JSON_SUFFIX_RE = /[/\\]package\.json$/
+
+/**
+ * Розгортає один workspace-патерн у список абсолютних шляхів каталогів з package.json.
+ * Літеральні патерни перевіряються через existsSync; glob-патерни — через node:fs/promises#glob.
+ * @param {string} cwd корінь проєкту
+ * @param {string} pattern workspace-патерн з package.json (наприклад, `app` або `cf/*`)
+ * @returns {Promise<string[]>} абсолютні шляхи до workspace-каталогів
+ */
+async function expandWorkspacePattern(cwd, pattern) {
+  if (!pattern.includes('*')) {
+    const wsPath = join(cwd, pattern)
+    return existsSync(join(wsPath, 'package.json')) ? [wsPath] : []
+  }
+  const results = []
+  for await (const rel of glob(`${pattern}/package.json`, { cwd, exclude: WORKSPACE_GLOB_IGNORE })) {
+    const wsRel = rel.replace(PACKAGE_JSON_SUFFIX_RE, '')
+    results.push(join(cwd, wsRel))
+  }
+  return results.toSorted()
+}
+
+/**
+ * @param {string} cwd корінь проєкту (де кореневий package.json)
+ * @returns {Promise<string|null>} абсолютний шлях до JS-root або null без кореневого package.json
+ */
+export async function resolveJsRoot(cwd) {
+  const roots = await resolveAllJsRoots(cwd)
+  if (roots.length === 0) return null
+  return roots[0]
+}
+
+/**
+ * Plural-варіант: повертає всі JS-roots проєкту. Для workspace-projects — кожен
+ * workspace з власним `package.json` (з розгортанням glob-патернів); для
+ * single-package — `[cwd]`. Порожній масив без кореневого package.json.
+ * @param {string} cwd корінь проєкту
+ * @returns {Promise<string[]>} абсолютні шляхи до всіх JS-roots
+ */
+export async function resolveAllJsRoots(cwd) {
+  const rootPkgPath = join(cwd, 'package.json')
+  if (!existsSync(rootPkgPath)) return []
+  const rootPkg = JSON.parse(await readFile(rootPkgPath, 'utf8'))
+  const patterns = Array.isArray(rootPkg.workspaces) ? rootPkg.workspaces : []
+  if (patterns.length === 0) return [cwd]
+  const roots = []
+  for (const pattern of patterns) {
+    roots.push(...(await expandWorkspacePattern(cwd, pattern)))
+  }
+  return roots.length > 0 ? roots : [cwd]
+}