@nitra/cursor 3.9.0 → 3.11.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [3.11.0] - 2026-06-02
+
+### Changed
+
+- coverage: scoped режим --changed — flow-турнікет (DEFAULT_GATES) перевіряє лише змінені від base_commit файли (vitest --changed + Stryker --mutate), однаково для закомічених і незакомічених змін; повний coverage лишається для bun run coverage / n-coverage-fix
+
+## [3.10.0] - 2026-06-01
+
+### Added
+
+- rust coverage: incremental mutation через CARGO_MUTANTS_BASE_REF → cargo-mutants --in-diff (мутуємо лише змінене у <ref>...HEAD)
+- rust coverage: CARGO_MUTANTS_BASELINE=skip → cargo-mutants --baseline skip (пропуск немутованого baseline коли тести вже зелені); rust.mdc — гайд по CI-кешу target/ для coverage-job
+
+### Removed
+
+- internal: видалено мертвий JS-код — 19 експортованих функцій/констант, що викликались лише з тестів (k8s manifests: 5 предикатів, мігрованих у rego; gha-workflow: 9 предикатів, мігрованих у rego ga.workflow_common + 1 каскадний; abie/text/dispatcher: kustomizationHasAbieNginxRunHttpRoutePatch, getV8rCatalogPath, SUBCOMMANDS, resolveFlow) разом з їхніми тестами й осиротілими хелперами
+
 ## [3.9.0] - 2026-06-01
 
 ### Changed

package/bin/n-cursor.js

@@ -1527,9 +1527,10 @@ try {
     }
     case 'coverage': {
       // n-cursor coverage — оркестратор покриття + мутаційного тестування з discovery
-      // провайдерів через .n-cursor.json#rules (test.mdc).
+      // провайдерів через .n-cursor.json#rules (test.mdc). --changed звужує scope до
+      // змінених від base файлів (flow-турнікет: лише vitest/Stryker по diff).
       const { runCoverageCli } = await import('../rules/test/coverage/coverage.mjs')
-      process.exitCode = await runCoverageCli({ fix: args.includes('--fix') })
+      process.exitCode = await runCoverageCli({ fix: args.includes('--fix'), changed: args.includes('--changed') })
 
       break
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nitra/cursor",
-  "version": "3.9.0",
+  "version": "3.11.0",
   "description": "CLI для завантаження cursor-правил (префікс n-) у локальний репозиторій",
   "keywords": [
     "cli",

package/rules/abie/lib/kustomization-patches.mjs

@@ -211,14 +211,3 @@ export function validateAbieNginxRunHttpRoutePatches(
   }
   return null
 }
-
-/**
- * Чи kustomization містить валідні patch для HTTPRoute (ua).
- * @param {string} raw повний текст kustomization.yaml
- * @param {'ua'} mode опис.
- * @returns {boolean} результат
- */
-export function kustomizationHasAbieNginxRunHttpRoutePatch(raw, mode) {
-  const combined = getCombinedNginxRunPatchTextFromKustomization(raw)
-  return validateAbieNginxRunHttpRoutePatches(combined, mode, raw) === null
-}

package/rules/flow/flow.mdc

@@ -79,7 +79,11 @@ Composer, Claude Code) працює **Пасивний Турнікет**: ти,
    ```
 
    Проганяє Quality Gates (lint + coverage). Повертає `0` (pass) або `1` із
-   виводом проваленого gate.
+   виводом проваленого gate. **Обидва гейти перевіряють лише змінені файли**
+   (diff від `base_commit`): `lint` — quick-режим, `coverage --changed` — vitest
+   `--changed` + Stryker `--mutate` по diff. Працює однаково, незалежно від того,
+   чи зміни вже закомічені у worktree. Повний coverage (увесь проєкт) — окремо:
+   `bun run coverage` або `/n-coverage-fix`.
 
 6. **Review (adversarial)** — рекомендовано перед release:
 

package/rules/js-lint/coverage/coverage.mjs

@@ -10,13 +10,36 @@ import { spawnSync } from 'node:child_process'
 import { existsSync, readFileSync } from 'node:fs'
 import { mkdtemp, readFile, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
-import { join, relative } from 'node:path'
+import { isAbsolute, join, relative } from 'node:path'
 
 import { resolveAllJsRoots } from '../../../scripts/utils/resolve-js-root.mjs'
 import { addCoverage, addMutation } from '../../test/coverage/coverage.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-lint coverage: vitest відсутній у package.json — додай `vitest`, `@vitest/coverage-v8` та `@stryker-mutator/vitest-runner` у devDependencies (див. test.mdc)'
 
@@ -217,7 +240,11 @@ export function parseStrykerReport(report, jsRoot) {
  * у такому випадку сигналізує "no tests" → collectOneRoot пропускає workspace.
  */
 const defaultRunner = {
-  runJsCoverage({ cwd, lcovDir }) {
+  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',
       [
@@ -226,13 +253,14 @@ const defaultRunner = {
         '--passWithNoTests',
         '--coverage',
         '--coverage.reporter=lcov',
-        `--coverage.reportsDirectory=${lcovDir}`
+        `--coverage.reportsDirectory=${lcovDir}`,
+        ...changedArgs
       ],
       { cwd, stdio: 'inherit', env: process.env }
     )
     return r.status ?? 1
   },
-  runStryker({ cwd }) {
+  runStryker({ cwd, mutate }) {
     // `npx`, не `bunx`: bunx завжди ставить пакет у `T/bunx-<uid>-<pkg>@latest` і запускає
     // Stryker звідти. Плагін-discovery у Stryker (`@stryker-mutator/*`) globится відносно
     // CORE-install-каталогу (`core/dist/src/di/plugin-loader.js` → `../../../../../@stryker-mutator/*`),
@@ -240,30 +268,48 @@ const defaultRunner = {
     // встановлений `@stryker-mutator/vitest-runner` залишається невидимим, і workers падають з
     // `Cannot find TestRunner plugin "vitest"`. `npx` ходить угору по `node_modules/.bin/` і
     // запускає Stryker з локального hoisted-install, де поряд лежить vitest-runner.
-    const r = spawnSync('npx', ['@stryker-mutator/core', 'run'], { cwd, stdio: 'inherit', env: process.env })
+    // mutate (непорожній) ⇔ --changed-режим: мутуємо лише змінені production-файли цього root.
+    const mutateArgs = mutate && mutate.length > 0 ? ['--mutate', mutate.join(',')] : []
+    const r = spawnSync('npx', ['@stryker-mutator/core', 'run', ...mutateArgs], {
+      cwd,
+      stdio: 'inherit',
+      env: process.env
+    })
     return r.status ?? 1
   }
 }
 
 /**
  * Збирає метрики покриття + мутаційного тестування для **одного** JS-root.
- * Пропускає workspace без тестів (повертає `null`): vitest у такому випадку
- * пройшов з `--passWithNoTests`, але lcov порожній — нема сенсу запускати
- * Stryker. Реальні помилки (vitest exit ≠ 0, mutation.json відсутній попри
- * наявні тести) кидаються — у multi-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-ін'єкція
- * @returns {Promise<{coverage:object, mutation:{caught:number,total:number}, survived:Array<object>} | null>} результати або null коли workspace без тестів
+ * @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) {
+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
+  // 1. Coverage через vitest run --passWithNoTests --coverage (+ --changed у changed-режимі)
   const lcovDir = await mkdtemp(join(tmpdir(), 'js-lint-cov-'))
   let coverage
   try {
-    const code = await runner.runJsCoverage({ cwd: jsRoot, lcovDir })
+    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)
@@ -273,13 +319,20 @@ async function collectOneRoot(jsRoot, cwd, runner) {
     await rm(lcovDir, { recursive: true, force: true })
   }
 
-  // Порожній lcov ⇔ vitest з --passWithNoTests не знайшов тестів. Пропускаємо
-  // workspace, щоб не запускати Stryker марно і не псувати агрегат.
-  const hasTests = coverage.lines.total > 0 || coverage.functions.total > 0
-  if (!hasTests) return null
+  // Full-режим: порожній lcov ⇔ vitest не знайшов тестів → пропускаємо workspace,
+  // щоб не ганяти Stryker марно. У changed-режимі НЕ пропускаємо (див. JSDoc).
+  if (!scope) {
+    const hasTests = coverage.lines.total > 0 || coverage.functions.total > 0
+    if (!hasTests) return null
+  }
 
-  // 2. Mutation через Stryker
-  await runner.runStryker({ cwd: jsRoot })
+  // 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(
@@ -317,22 +370,36 @@ async function collectOneRoot(jsRoot, cwd, runner) {
  * з зрозумілим повідомленням ("Жодного провайдера покриття не знайдено").
  * Шляхи у `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}} [opts] runner-ін'єкція для тестів
- * @returns {Promise<Array<{area:string, coverage:object, mutation:{caught:number,total:number}, survived:Array<object>}>>} рядок `JS` або `[]` коли тестів нема ніде
+ * @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-lint coverage: package.json не знайдено')
 
   const results = []
   for (const jsRoot of jsRoots) {
-    const r = await collectOneRoot(jsRoot, cwd, runner)
+    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-lint coverage: жоден workspace не має тестів ' +
         '(`*.test.{js,mjs}` у `tests/` або поряд із джерелом) — ' +

package/rules/k8s/js/manifests.mjs

@@ -431,56 +431,6 @@ function pushStringPaths(arr, acc) {
 /** Префікс `apiVersion` для маніфесту Kustomize **Kustomization**. */
 const KUSTOMIZE_CONFIG_API_PREFIX = 'kustomize.config.k8s.io/'
 
-/**
- * Чи послідовність непорожніх рядків відсортована за `localeCompare` (en, ascending).
- * @param {string[]} paths рядки для перевірки
- * @returns {boolean} `true` якщо послідовність відсортована
- */
-function stringPathsAreSortedEn(paths) {
-  for (let i = 1; i < paths.length; i++) {
-    if (paths[i - 1].localeCompare(paths[i], 'en', { sensitivity: 'base' }) > 0) {
-      return false
-    }
-  }
-  return true
-}
-
-/**
- * Порушення сорту **`resources`**: лише для **`kustomize.config.k8s.io/…`**, **`kind: Kustomization`**.
- * Порожні рядки в списку ігноруються (як у `pushStringPaths`).
- * @param {unknown} obj корінь першого YAML-документа
- * @returns {string | null} причина або `null`, якщо обмеження не застосовується
- */
-export function kustomizationResourcesSortedAlphabeticallyViolation(obj) {
-  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) return null
-  const rec = /** @type {Record<string, unknown>} */ (obj)
-  if (rec.kind !== 'Kustomization') return null
-  const av = rec.apiVersion
-  if (typeof av !== 'string' || !av.startsWith(KUSTOMIZE_CONFIG_API_PREFIX)) return null
-  const res = rec.resources
-  if (res === undefined) return null
-  if (!Array.isArray(res)) {
-    return 'Kustomization.resources має бути масивом (k8s.mdc)'
-  }
-  /**
-  @type {string[]}
-   */
-  const paths = []
-  for (const [i, item] of res.entries()) {
-    if (typeof item !== 'string') {
-      return `Kustomization.resources[${i}] — очікується рядок-шлях (k8s.mdc)`
-    }
-    const t = item.trim()
-    if (t !== '') paths.push(t)
-  }
-  if (paths.length < 2) return null
-  if (!stringPathsAreSortedEn(paths)) {
-    const want = paths.toSorted((a, b) => a.localeCompare(b, 'en', { sensitivity: 'base' }))
-    return `Kustomization.resources має бути за алфавітом (en). Зараз: ${paths.join(', ')}; очікувано: ${want.join(', ')} (k8s.mdc)`
-  }
-  return null
-}
-
 // Plan B: per-document `resources[]` sort у Kustomization — у rego-пакеті
 // `k8s.kustomization`, викликається з `runAllK8sRego` на початку `check()`.
 // JS-orchestrator validateKustomizationResourcesSortedAlphabetically видалено.
@@ -2159,36 +2109,6 @@ export function collectJson6902OperationsFromPatchText(patchText) {
   return []
 }
 
-/**
- * Шляхи JSON Patch, де в одному наборі операцій є і **remove**, і **add** (k8s.mdc: краще **replace**).
- * @param {Array<{ op: string, path: string }>} ops нормалізовані **op**
- * @returns {string[]} унікальні **path** з порушенням (відсортовано)
- */
-export function json6902PathsWithRemoveAndAddOnSamePath(ops) {
-  /**
-  @type {Map<string, Set<string>>}
-   */
-  const byPath = new Map()
-  for (const { op, path } of ops) {
-    if (path) {
-      if (!byPath.has(path)) {
-        byPath.set(path, new Set())
-      }
-      byPath.get(path).add(op)
-    }
-  }
-  /**
-  @type {string[]}
-   */
-  const out = []
-  for (const [path, set] of byPath) {
-    if (set.has('remove') && set.has('add')) {
-      out.push(path)
-    }
-  }
-  return out.toSorted((a, b) => a.localeCompare(b))
-}
-
 // Plan B: вся audit-ланка JSON6902 (failIfJson6902RemoveAddConflictOnSamePath,
 // auditJson6902PatchExternalFile, auditOneKustomizationJson6902Patch,
 // auditKustomizationPatchesJson6902) видалена. Per-document inline JSON6902
@@ -2673,34 +2593,9 @@ export function collectDeploymentConfigMapRefs(deployment) {
   return names
 }
 
-/**
- * Чи **Service** містить заборонені анотації GKE у **`metadata.annotations`** (k8s.mdc).
- * @param {unknown} manifest корінь YAML-документа
- * @returns {string | null} текст порушення або null, якщо не Service / анотацій немає / ок
- */
-export function serviceForbiddenGcpAnnotationsViolation(manifest) {
-  if (manifest === null || manifest === undefined || typeof manifest !== 'object' || Array.isArray(manifest))
-    return null
-  const rec = /** @type {Record<string, unknown>} */ (manifest)
-  if (rec.kind !== 'Service') return null
-  const meta = rec.metadata
-  if (meta === null || meta === undefined || typeof meta !== 'object' || Array.isArray(meta)) return null
-  const m = /** @type {Record<string, unknown>} */ (meta)
-  const ann = m.annotations
-  if (ann === null || ann === undefined || typeof ann !== 'object' || Array.isArray(ann)) return null
-  const a = /** @type {Record<string, unknown>} */ (ann)
-  /**
-  @type {string[]}
-   */
-  const found = []
-  for (const key of SERVICE_FORBIDDEN_GCP_ANNOTATION_KEYS) {
-    if (Object.hasOwn(a, key)) {
-      found.push(key)
-    }
-  }
-  if (found.length === 0) return null
-  return `metadata.annotations: прибери заборонені ключі GKE: ${found.join(', ')} (див. k8s.mdc)`
-}
+// Plan B: заборонені GKE-анотації на Service — у rego-пакеті k8s.* (per-document).
+// JS-функцію serviceForbiddenGcpAnnotationsViolation видалено; константа
+// SERVICE_FORBIDDEN_GCP_ANNOTATION_KEYS лишається експортованою (власний тест).
 
 /** Суфікс **`metadata.name`** headless-сервісу поруч із **`svc.yaml`** (див. k8s.mdc). */
 const SVC_HL_NAME_SUFFIX = '-hl'
@@ -4235,15 +4130,6 @@ export function snippetNameForKind(kind) {
   return name
 }
 
-/**
- * Читає deployment.snippet.yaml і повертає розпарсений spec.
- * @deprecated Використовуй loadSnippetSpec('deployment')
- * @returns {{ podSelector: Record<string, unknown>, policyTypes: string[], ingress: unknown[], egress: unknown[] }} розпарсений spec deployment snippet
- */
-export function readNetworkPolicySnippet() {
-  return /** @type {any} */ (loadSnippetSpec('deployment'))
-}
-
 /**
  * No-op fail-callback (повертає аргумент). Використовується як дефолт у `regenerateLegacyNetworkPolicyDocsInFile`,
  * коли caller не передає власний `fail` — щоб `collectHttpRouteIngressForWorkload` не падав.
@@ -5047,17 +4933,6 @@ export async function prodOverlayHpaPdbOverrideNeeds(rootNorm, kustAbs) {
   }
 }
 
-/**
- * Чи прод-оверлей потребує **будь-яких** overrides HPA/PDB у **patches[]** (зведений прапорець).
- * @param {string} rootNorm нормалізований корінь репозиторію
- * @param {string} kustAbs абсолютний шлях до kustomization.yaml
- * @returns {Promise<boolean>} true, якщо потрібен хоча б один тип оверрайду
- */
-export async function prodOverlayNeedsHpaPdbOverrides(rootNorm, kustAbs) {
-  const n = await prodOverlayHpaPdbOverrideNeeds(rootNorm, kustAbs)
-  return n.needsHpaReplicaPatches || n.needsPdbMinAvailablePatch
-}
-
 /**
  * Для прод kustomization.yaml вимагає **patches[]** за потреби: **`/spec/minReplicas`** і **`/spec/maxReplicas`**
  * для **HorizontalPodAutoscaler** (якщо в успадкованому base лишився HPA без delete-patch), **`/spec/minAvailable`**

package/rules/rust/coverage/coverage.mjs

@@ -8,14 +8,16 @@
  */
 import { spawnSync } from 'node:child_process'
 import { existsSync } from 'node:fs'
-import { mkdtemp, readFile, rm } from 'node:fs/promises'
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
 import { cpus, tmpdir } from 'node:os'
-import { join } from 'node:path'
+import { dirname, join } from 'node:path'
 
 import { hasCargoTomlInTree } from '../lib/has-cargo-toml.mjs'
 import { resolveCargoManifest } from '../../../scripts/utils/resolve-cargo-manifest.mjs'
 
 const IGNORED_DIR_NAMES = new Set(['node_modules', '.git', '.next', '.turbo', 'target'])
+/** Rust-релевантні зміни: `.rs`-джерела або маніфести Cargo. */
+const RUST_CHANGE = /(\.rs$)|((^|\/)Cargo\.(toml|lock)$)/
 
 /**
  * Чи провайдер застосовний у поточному cwd.
@@ -33,7 +35,7 @@ export function detect(cwd) {
  * на ≤2 ядрах = 1, на 4 = 2, на 8+ = 4. Стеля 4 — Rust linker bottleneck:
  * вище практичного приросту не дає навіть на 16+ ядрах.
  * @param {string | undefined} envValue значення `process.env.CARGO_MUTANTS_JOBS`
- * @returns {number}
+ * @returns {number} кількість паралельних воркерів (>= 1)
  */
 export function resolveJobs(envValue) {
   if (envValue !== undefined && envValue !== '') {
@@ -43,14 +45,48 @@ export function resolveJobs(envValue) {
   return Math.min(4, Math.max(1, Math.floor(cpus().length / 2)))
 }
 
+/**
+ * Резолвить базовий git-ref для incremental mutation через cargo-mutants `--in-diff`.
+ * Порожнє/відсутнє значення → `null` = повний прогін усіх мутантів (дефолт для `main`).
+ * Непорожнє (напр. `origin/main`) → мутуємо лише змінене у `<ref>...HEAD` (для feature-гілки).
+ * cargo-mutants не має persistent-кешу вердиктів (як Stryker `incremental.json`) — scoping
+ * за git-diff це його штатний аналог «не передивляйся незмінений код».
+ * @param {string | undefined} envValue значення `process.env.CARGO_MUTANTS_BASE_REF`
+ * @returns {string | null} trimmed ref або null
+ */
+export function resolveBaseRef(envValue) {
+  if (envValue === undefined) return null
+  const trimmed = envValue.trim()
+  return trimmed === '' ? null : trimmed
+}
+
+/**
+ * Резолвить режим baseline для cargo-mutants. `CARGO_MUTANTS_BASELINE=skip`
+ * (case-insensitive) → `'skip'` = пропустити немутований baseline build+test:
+ * фіксована економія в один повний `cargo test`, безпечна ЛИШЕ коли тести вже
+ * зелені у попередньому CI-степі (інакше всі вердикти сміттєві). Будь-що інше →
+ * `null` = дефолтний baseline-прогін. Цінність найбільша разом з `--in-diff`,
+ * де baseline — більша частка дрібного прогону.
+ * @param {string | undefined} envValue значення `process.env.CARGO_MUTANTS_BASELINE`
+ * @returns {'skip' | null} режим або null для дефолту
+ */
+export function resolveBaseline(envValue) {
+  return envValue !== undefined && envValue.trim().toLowerCase() === 'skip' ? 'skip' : null
+}
+
 /**
  * Будує argv для `cargo mutants`. `--in-place` навмисно відсутній: cargo-mutants
  * створює власну sandbox-копію в `target/mutants.<i>/`, що обов'язкове для `--jobs > 1`.
- * @param {{ manifestPath: string, outDir: string, jobs: number }} opts
- * @returns {string[]}
+ * `diffPath` (опційно) вмикає `--in-diff` — мутуються лише рядки з цього unified-diff.
+ * `baseline === 'skip'` (опційно) додає `--baseline skip` — без немутованого baseline-прогону.
+ * @param {{ manifestPath: string, outDir: string, jobs: number, diffPath?: string, baseline?: 'skip' | null }} opts параметри запуску
+ * @returns {string[]} argv для cargo
  */
-export function buildCargoMutantsArgs({ manifestPath, outDir, jobs }) {
-  return ['mutants', '--jobs', String(jobs), '-o', outDir, '--manifest-path', manifestPath]
+export function buildCargoMutantsArgs({ manifestPath, outDir, jobs, diffPath, baseline }) {
+  const args = ['mutants', '--jobs', String(jobs), '-o', outDir, '--manifest-path', manifestPath]
+  if (diffPath) args.push('--in-diff', diffPath)
+  if (baseline === 'skip') args.push('--baseline', 'skip')
+  return args
 }
 
 const defaultRunner = {
@@ -61,24 +97,45 @@ const defaultRunner = {
     })
     return { exitCode: r.status ?? 1, stdout: r.stdout?.toString('utf8') ?? '' }
   },
-  runCargoMutants({ manifestPath, outDir }) {
+  runCargoMutants({ manifestPath, outDir, diffPath }) {
     const jobs = resolveJobs(process.env.CARGO_MUTANTS_JOBS)
-    const r = spawnSync('cargo', buildCargoMutantsArgs({ manifestPath, outDir, jobs }), {
+    const baseline = resolveBaseline(process.env.CARGO_MUTANTS_BASELINE)
+    const r = spawnSync('cargo', buildCargoMutantsArgs({ manifestPath, outDir, jobs, diffPath, baseline }), {
       stdio: 'inherit',
       env: process.env
     })
     return r.status ?? 1
+  },
+  runGitDiff({ manifestPath, baseRef }) {
+    // `--relative` + cwd = каталог crate → шляхи в diff збігаються з тим, що
+    // cargo-mutants мутує (relative до package), навіть у monorepo з src-tauri/.
+    // Three-dot `<ref>...HEAD` = зміни гілки від merge-base, а не «з того часу в ref».
+    const r = spawnSync('git', ['diff', '--relative', `${baseRef}...HEAD`], {
+      cwd: dirname(manifestPath),
+      stdio: ['inherit', 'pipe', 'inherit'],
+      env: process.env
+    })
+    return { exitCode: r.status ?? 1, stdout: r.stdout?.toString('utf8') ?? '' }
   }
 }
 
 /**
  * Збирає Rust-метрики покриття + мутаційного тестування.
+ *
+ * Changed-режим (`opts.changedFiles` задано): якщо серед змінених немає Rust-релевантних
+ * файлів (`.rs` / `Cargo.toml` / `Cargo.lock`) — повертає `[]` (skip), щоб JS-only крок
+ * турнікета не ганяв повний `cargo mutants`. Якщо Rust змінено — наразі прогін повний по
+ * crate (per-file scoping cargo-mutants — окремий крок).
  * @param {string} cwd корінь проєкту
- * @param {{runner?: typeof defaultRunner}} [opts] ін'єкція runner-а для тестів
+ * @param {{runner?: typeof defaultRunner, changedFiles?: string[]}} [opts] ін'єкція runner-а + changed-scope
  * @returns {Promise<Array<{area:string, coverage:object, mutation:{caught:number,total:number}}>>} рядки для COVERAGE.md
  */
 export async function collect(cwd, opts = {}) {
   const runner = opts.runner ?? defaultRunner
+  // Changed-режим без Rust-релевантних змін → не запускаємо повний crate-прогін.
+  if (Array.isArray(opts.changedFiles) && !opts.changedFiles.some(f => RUST_CHANGE.test(f))) {
+    return []
+  }
   const manifestPath = await resolveCargoManifest(cwd)
   if (manifestPath === null) {
     throw new Error('rust coverage: Cargo.toml не знайдено (cwd + workspaces)')
@@ -95,13 +152,31 @@ export async function collect(cwd, opts = {}) {
     functions: { covered: totals.functions.covered, total: totals.functions.count }
   }
 
-  // 2. Mutation через cargo mutants
+  // 2. Mutation через cargo mutants.
+  // CARGO_MUTANTS_BASE_REF (напр. `origin/main`) вмикає incremental-режим: мутуємо
+  // лише рядки, змінені у `<baseRef>...HEAD` (`git diff --relative` → cargo-mutants
+  // `--in-diff`). Env не задано — повний прогін усіх мутантів (дефолт для `main`).
+  const baseRef = resolveBaseRef(process.env.CARGO_MUTANTS_BASE_REF)
   const outDir = await mkdtemp(join(tmpdir(), 'rust-mutants-'))
   let mutation
   try {
+    let diffPath
+    if (baseRef !== null) {
+      const { exitCode: diffCode, stdout: diff } = await runner.runGitDiff({ manifestPath, baseRef })
+      if (diffCode !== 0) {
+        // Невідомий ref / не git-репо — не валимо прогін, відкочуємось до повного.
+        process.stderr.write(`rust coverage: git diff проти '${baseRef}' упав — повний mutation-прогін\n`)
+      } else if (diff.trim() === '') {
+        // У `<baseRef>...HEAD` немає змін під цим crate — мутувати нічого.
+        return [{ area: 'Rust', coverage, mutation: { caught: 0, total: 0 } }]
+      } else {
+        diffPath = join(outDir, 'in-diff.patch')
+        await writeFile(diffPath, diff)
+      }
+    }
     // cargo-mutants exit ≠ 0 коли є missed — це нормально, не помилка.
     // Реальний крах — відсутній outcomes.json.
-    await runner.runCargoMutants({ manifestPath, outDir })
+    await runner.runCargoMutants({ manifestPath, outDir, diffPath })
     let outcomes
     try {
       outcomes = JSON.parse(await readFile(join(outDir, 'mutants.out', 'outcomes.json'), 'utf8'))

package/rules/rust/rust.mdc

@@ -2,7 +2,7 @@
 description: Перевірка Rust коду
 globs: "**/{Cargo.toml,Cargo.lock,rustfmt.toml,clippy.toml,.vscode/extensions.json,package.json},**/*.rs"
 alwaysApply: false
-version: '1.2'
+version: '1.4'
 ---
 
 **rustfmt** ([rust-lang/rustfmt](https://github.com/rust-lang/rustfmt)) — форматер; **clippy** ([rust-lang/rust-clippy](https://github.com/rust-lang/rust-clippy)) — лінтер. У скрипті **`lint-rust`** локально йдуть три кроки в одному рядку: `cargo fmt --all` → `cargo clippy --fix --allow-staged --allow-dirty --all-targets --all-features` → фінальний `cargo clippy --all-targets --all-features -- -D warnings`. У CI — без `--fix`: `cargo fmt --all -- --check` і `cargo clippy ... -- -D warnings` (див. `lint-rust.yml`).
@@ -29,3 +29,22 @@ Tauri-проєкт завжди має `src-tauri/Cargo.toml`, тому прав
 ## Покриття + мутаційне тестування Rust
 
 Покриття + мутаційне тестування Rust постачаються через `n-cursor coverage` (правило `test.mdc`). Реалізація провайдера — у `npm/rules/rust/coverage/coverage.mjs`: `cargo llvm-cov --json --summary-only` + `cargo mutants --jobs N` (паралельні воркери, дефолт `min(4, cpus/2)`; override через env `CARGO_MUTANTS_JOBS`). Прапорець `--in-place` прибраний — cargo-mutants створює власну sandbox-копію в `target/mutants.<i>/`, що сумісне з `--jobs > 1`. Бінарники: `cargo install cargo-llvm-cov && cargo install cargo-mutants`.
+
+### Incremental mutation через `--in-diff`
+
+cargo-mutants **не** має persistent-кешу вердиктів між прогонами (на відміну від Stryker `incremental.json`). Штатний аналог «не передивляйся незмінений код» — scoping за git-diff. Вмикається env-змінною **`CARGO_MUTANTS_BASE_REF`**:
+
+- **не задано** (дефолт, типово для `main`) — повний прогін усіх мутантів;
+- задано (напр. `origin/main`, типово для feature-гілки в CI) — мутуються лише рядки, змінені у `<baseRef>...HEAD`. Провайдер бере `git diff --relative <baseRef>...HEAD` з каталогу crate (шляхи в diff збігаються з тим, що мутує cargo-mutants навіть у monorepo з `src-tauri/`), пише його у sandbox і передає cargo-mutants `--in-diff`.
+
+Краєві випадки: порожній diff (немає змін під crate) → mutation `0/0` без запуску cargo-mutants; невідомий ref / не git-репо → попередження у stderr і fallback до повного прогону.
+
+### Пропуск baseline через `CARGO_MUTANTS_BASELINE=skip`
+
+cargo-mutants спершу ганяє немутований baseline (повний build+test), щоб переконатися, що suite зелений. Це **фіксована** вартість, незалежна від кількості мутантів — а отже більша частка дрібного `--in-diff`-прогону. **`CARGO_MUTANTS_BASELINE=skip`** прибирає цей крок (cargo-mutants `--baseline skip`), економлячи один повний `cargo test`.
+
+Безпечно **лише** коли тести вже зелені у попередньому CI-степі (типовий порядок: `cargo test` → потім `n-cursor coverage` зі `skip`). Без цієї гарантії всі вердикти стають сміттєвими, тому дефолт — baseline-прогін. Найкорисніше в парі з `--in-diff`.
+
+### CI-кеш `target/` — множник, без якого scoping невидимий
+
+`--in-diff` ріже **кількість** мутантів, кеш `target/` — **вартість кожної** компіляції; вони множаться. Без кешу холодний CI щоразу перебудовує всі залежності, і baseline-build (для Tauri — хвилини) затьмарює економію від меншої кількості мутантів. У workflow, що викликає `n-cursor coverage` для Rust, став `Swatinem/rust-cache@v2` (кеш `~/.cargo` + `target/`) після `dtolnay/rust-toolchain@stable` — так само, як у `lint-rust.yml`. Sandbox-копії `target/mutants.<i>/` самі не кешуються, але деривуються з кешованих залежностей.

package/rules/test/coverage/coverage.mjs

@@ -19,6 +19,8 @@ import { fileURLToPath, pathToFileURL } from 'node:url'
 
 import { applyVerdicts } from '../../../scripts/coverage-classify/apply.mjs'
 import { classify } from '../../../scripts/coverage-classify/index.mjs'
+import { flowStatePath, readState } from '../../../scripts/dispatcher/lib/state-store.mjs'
+import { collectChangedFilesSince } 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'
 
@@ -194,18 +196,46 @@ async function readClassifyThreshold(cwd) {
   }
 }
 
+/**
+ * Резолвить scope змінених файлів для `--changed`-режиму.
+ *
+ * Base — `metadata.base_commit` зі стану flow (sibling-файл `.flow.json` поруч із
+ * worktree-checkout). `git diff <base>` проти робочого дерева ловить committed і
+ * uncommitted однаково — тож scope не залежить від того, чи executor уже закомітив
+ * крок. Поза flow (нема/пошкоджений стан) — fallback на робоче дерево vs HEAD.
+ * @param {string} cwd корінь проєкту (= worktree-checkout у межах flow)
+ * @returns {{base: string|null, files: string[]}} base-ref і relative-posix список змінених файлів
+ */
+function resolveChangedScope(cwd) {
+  let base = null
+  try {
+    const state = readState(flowStatePath(cwd))
+    base = state?.metadata?.base_commit ?? null
+  } catch {
+    // пошкоджений/несумісний стан — попереджаємо й падаємо на HEAD (working-tree scope).
+    console.error('coverage --changed: стан flow нечитабельний — scope визначається від HEAD робочого дерева')
+    base = null
+  }
+  return { base, files: collectChangedFilesSince(base, cwd) }
+}
+
 /**
  * Виконує coverage-pipeline: discovery провайдерів за `.n-cursor.json#rules`,
  * detect+collect для кожного, агрегація, запис COVERAGE.md.
  * При `opts.fix === true` після запису COVERAGE.md запускає агента (coverage-fix.mjs)
  * для написання тестів по вцілілих мутантах.
- * @param {{cwd?:string, rulesDir?:string, fix?:boolean}} [opts] ін'єкція cwd/rulesDir для тестів; fix — --fix режим
- * @returns {Promise<number>} exit code (0 OK, 1 коли жоден провайдер не дав даних)
+ * При `opts.changed === true` провайдери звужують scope до змінених від base файлів
+ * (для flow-турнікета). Порожній scope (нема релевантних змін) — це pass (exit 0)
+ * без перезапису наявного COVERAGE.md, а НЕ помилка «жодного провайдера».
+ * @param {{cwd?:string, rulesDir?:string, fix?:boolean, changed?:boolean}} [opts] ін'єкція cwd/rulesDir для тестів; fix — --fix режим; changed — scope лише змінених
+ * @returns {Promise<number>} exit code (0 OK, 1 коли жоден провайдер не дав даних у full-режимі)
  */
 export async function runCoverageSteps(opts = {}) {
   const cwd = opts.cwd ?? process.cwd()
   const rulesDir = opts.rulesDir ?? RULES_DIR
   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) {
@@ -214,14 +244,27 @@ export async function runCoverageSteps(opts = {}) {
     if (!provider) continue
     if (!(await provider.detect(cwd))) continue
     console.log(`→ ${ruleId} coverage…`)
-    rows.push(...(await provider.collect(cwd)))
+    rows.push(...(await provider.collect(cwd, collectOpts)))
   }
 
   if (rows.length === 0) {
+    // --changed: порожній scope = «нема релевантних змін» → pass, не чіпаємо COVERAGE.md.
+    if (opts.changed) {
+      console.log('✓ coverage --changed: немає змінених файлів у scope провайдерів — пропускаю')
+      return 0
+    }
     console.error('✗ Жодного провайдера покриття не знайдено для активних правил у .n-cursor.json#rules')
     return 1
   }
 
+  // --changed (турнікет): рішення гейту визначає лише exit-код — vitest/Stryker кинули б помилку
+  // під час collect, якби тести/прогін упали. Тут НЕ перезаписуємо повний COVERAGE.md частковим
+  // scoped-звітом і не ганяємо LLM-класифікацію (зайвий кошт у per-step циклі).
+  if (opts.changed) {
+    console.log('✓ coverage --changed: змінені файли перевірено')
+    return 0
+  }
+
   // LLM-класифікація survived мутантів (graceful skip без API key)
   const allSurvived = rows.flatMap(r => r.survived ?? [])
   let augmentedRows = rows
@@ -256,18 +299,19 @@ export async function runCoverageSteps(opts = {}) {
 }
 
 /**
- * CLI entrypoint для `n-cursor coverage [--fix]`.
+ * CLI entrypoint для `n-cursor coverage [--fix] [--changed]`.
  * Із `--fix`: збирає метрики → запускає агента → повторно збирає метрики.
  * Без `--fix`: лише збирає метрики.
+ * Із `--changed`: звужує scope до змінених від base файлів (flow-турнікет).
  * Лок охоплює кожен coverage-прогін окремо.
- * @param {{fix?:boolean}} [opts] прапор --fix
+ * @param {{fix?:boolean, changed?:boolean}} [opts] прапори --fix / --changed
  * @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 }))
+    return withLock('coverage', () => runCoverageSteps({ fix: false, changed: opts.changed }))
   }
   return code
 }

package/rules/test/test.mdc

@@ -130,6 +130,8 @@ test.skipIf(env.STRYKER_MUTATOR_WORKER)('узгоджені з поточним
 
 Канонічна команда — `n-cursor coverage`: збирає метрики покриття (`vitest run --coverage`, `cargo llvm-cov` тощо) і мутаційного тестування (Stryker з vitest-runner + `coverageAnalysis: 'perTest'`, `cargo-mutants`) з усіх активних провайдерів у `.n-cursor.json#rules` і пише `COVERAGE.md` у корінь проєкту. Лок і дедуп — `withLock('coverage', ...)`.
 
+**Scoped-режим `--changed`** (для flow-турнікета): `n-cursor coverage --changed` звужує scope до файлів, змінених від `base_commit` (зі стану flow `.flow.json`; поза flow — робоче дерево vs HEAD). `git diff <base>` проти робочого дерева ловить committed і uncommitted однаково, тож результат не залежить від того, чи крок уже закомічено. Недосяжний `base` (rebase/force-update) — fail-closed (помилка, не тихий pass). JS-провайдер ганяє `vitest --changed <base>` (лише зачеплені тести) і Stryker `--mutate` по змінених production-файлах (тест-файли відкидаються); roots без змінених JS пропускаються. Rust-провайдер пропускається, якщо не змінено `.rs`/`Cargo.*` (інакше — повний crate-прогін; per-file scoping cargo-mutants — окремий крок). Порожній scope (нема релевантних змін) — pass. У changed-режимі `COVERAGE.md` **не** перезаписується (рішення гейту — лише exit-код) і LLM-класифікація не запускається. `DEFAULT_GATES` турнікета викликає саме `coverage --changed`; повний coverage (увесь проєкт, запис `COVERAGE.md`) лишається для `bun run coverage` / `/n-coverage-fix`.
+
 Провайдери живуть у `npm/rules/<rule>/coverage/coverage.mjs` (постачаються правилами мови/рантайму: `js-lint`, `rust`, у майбутньому `python` тощо). Оркестратор — у `npm/rules/test/coverage/coverage.mjs`.
 
 У `package.json` (корінь) має бути `scripts.coverage` із викликом `n-cursor coverage`:

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

@@ -27,14 +27,6 @@ export const DEFAULT_V8R_GLOBS = ['**/*.json', '**/*.json5', '**/*.yml', '**/*.y
 /** Абсолютний шлях до `schemas/v8r-catalog.json` у корені пакета `@nitra/cursor` (`npm/schemas/`). */
 export const V8R_CATALOG_PATH = join(dirname(fileURLToPath(import.meta.url)), '../../../schemas/v8r-catalog.json')
 
-/**
- * Повертає шлях до каталогу схем v8r для пакета (для тестів і діагностики).
- * @returns {string} абсолютний шлях до v8r-catalog.json
- */
-export function getV8rCatalogPath() {
-  return V8R_CATALOG_PATH
-}
-
 /**
  * Запускає послідовні виклики v8r по glob-ам; не змінює process.exitCode (лише повертає код).
  * @param {string[]} [globs] патерни; за замовчуванням DEFAULT_V8R_GLOBS

package/scripts/dispatcher/index.mjs

@@ -29,9 +29,6 @@ const USAGE = [
   '  npx @nitra/cursor flow repair [--discard-step-work]   # відновлення пошкодженого стану'
 ].join('\n')
 
-/** Підкоманди flow. */
-export const SUBCOMMANDS = ['init', 'spec', 'plan', 'verify', 'review', 'gate', 'release', 'run', 'resume', 'cancel', 'repair']
-
 /**
  * Усі handler-и реальні (Ф1 Spec/Plan + Ф2 Турнікет + Ф4 Активний Раннер).
  * @type {Record<string, (rest: string[], deps: object) => Promise<number>>}

package/scripts/dispatcher/lib/capability.mjs

@@ -57,25 +57,3 @@ export function orchestrationFor(model, matrix) {
 export function polyfillStartable({ hasRunner }) {
   return hasRunner === true
 }
-
-/**
- * Повний резолв: оголошена модель + режим. Кидає, якщо polyfill без runner-а.
- * @param {{ args?: string[], env?: Record<string, string | undefined>, config?: { flow?: { model?: string } }, matrix: object, hasRunner: boolean }} input джерела
- * @returns {{ model: string | null, mode: 'native' | 'polyfill' }} оголошена модель і режим
- */
-export function resolveFlow({ args = [], env = {}, config = {}, matrix, hasRunner }) {
-  const model = declaredModel({
-    cliModel: parseModelFlag(args),
-    envModel: env.N_CURSOR_FLOW_MODEL ?? null,
-    configModel: (config && config.flow && config.flow.model) ?? null
-  })
-  const mode = orchestrationFor(model, matrix)
-  if (mode === 'polyfill' && !polyfillStartable({ hasRunner })) {
-    throw new Error(
-      'n-cursor flow: режим polyfill потребує доступного SubagentRunner ' +
-        '(`claude` або `cursor-agent` у PATH), але жодного не знайдено. ' +
-        'Оголосіть модель із native_workflows (--model) або встановіть CLI-runner.'
-    )
-  }
-  return { model, mode }
-}

package/scripts/dispatcher/lib/reviewer.mjs

@@ -10,10 +10,16 @@
  */
 import { worktreeFingerprint } from '../../utils/worktree-fingerprint.mjs'
 
-/** Канонічні gate-и verify (lint + coverage; coverage включає тести+мутації). */
+/**
+ * Канонічні gate-и verify (lint + coverage; coverage включає тести+мутації).
+ * Обидва — scoped до змінених файлів: `lint` через quick-режим (`changed-files.mjs`),
+ * `coverage --changed` через vitest `--changed`/Stryker `--mutate` по diff від base.
+ * Турнікет (`flow verify`/per-step) перевіряє лише змінене; повний coverage —
+ * окремо (`bun run coverage`, `/n-coverage-fix`).
+ */
 export const DEFAULT_GATES = [
   { name: 'lint', cmd: ['npx', '@nitra/cursor', 'lint'] },
-  { name: 'coverage', cmd: ['npx', '@nitra/cursor', 'coverage'] }
+  { name: 'coverage', cmd: ['npx', '@nitra/cursor', 'coverage', '--changed'] }
 ]
 
 /**

package/scripts/lib/changed-files.mjs

@@ -28,3 +28,31 @@ export function collectChangedFiles(cwd = process.cwd()) {
   const untracked = gitLines(['ls-files', '--others', '--exclude-standard'], cwd)
   return [...new Set([...modified, ...untracked])]
 }
+
+/**
+ * Список змінених + untracked файлів **відносно базового комміту**.
+ *
+ * `git diff <base>` (без `..`/`...`, без `HEAD`) порівнює base-комміт із поточним
+ * **робочим деревом** — тобто однаково ловить і закомічене від base, і staged, і
+ * незакомічені модифікації. Це гарантує однакову поведінку незалежно від того, чи
+ * зміни вже закомічені у worktree (потрібно для flow-турнікета, де executor комітить
+ * кожен крок). Без `base` — fallback на `collectChangedFiles` (робоче дерево vs HEAD).
+ * @param {string|null} [base] базовий комміт (`metadata.base_commit` зі стану flow)
+ * @param {string} [cwd] корінь репо
+ * @returns {string[]} унікальні шляхи (без видалених)
+ */
+export function collectChangedFilesSince(base, cwd = process.cwd()) {
+  if (!base) return collectChangedFiles(cwd)
+  // Fail-closed: недосяжний base (rebase/force-update/shallow prune) інакше дав би `git diff`
+  // exit 128 → порожній список → gate мовчки пройшов би без перевірки. Краще явна помилка.
+  const verify = spawnSync('git', ['rev-parse', '--verify', '--quiet', `${base}^{commit}`], { cwd, encoding: 'utf8' })
+  if (verify.status !== 0 || verify.error) {
+    throw new Error(
+      `collectChangedFilesSince: base-комміт «${base}» недосяжний у ${cwd} ` +
+        '(rebase/force-update?) — coverage --changed не може визначити scope'
+    )
+  }
+  const changed = gitLines(['diff', base, '--name-only', '--diff-filter=ACMR'], cwd)
+  const untracked = gitLines(['ls-files', '--others', '--exclude-standard'], cwd)
+  return [...new Set([...changed, ...untracked])]
+}

package/scripts/lib/gha-workflow.mjs

@@ -8,7 +8,6 @@
  */
 import { parse } from 'yaml'
 
-const CHECKOUT_USES_MARKER = 'actions/checkout@'
 const CHECKOUT_V6_USES = 'actions/checkout@v6'
 const LOCAL_SETUP_BUN_DEPS_MARKER = './.github/actions/setup-bun-deps'
 const BUNX_OXLINT_FIX_RE = /bunx\s+oxlint[^\n]*--fix/u
@@ -69,97 +68,6 @@ export function getStepRun(step) {
   return ''
 }
 
-/** У тексті `run:` зіставляє `\\` одразу перед переносом рядка (типове shell-продовження в bash). */
-const RUN_SHELL_LINE_CONTINUATION_BACKSLASH_RE = /\\\r?\n/
-
-/**
- * Чи містить значення `run:` shell-продовження рядка через зворотний сліш перед переносом (`… \\` + NL).
- * У workflow такі конструкції замінюють на folded block `>-` без зворотних слішів (ga.mdc).
- * @param {string} runText текст з `getStepRun`
- * @returns {boolean} `true`, якщо знайдено `\\` перед новим рядком
- */
-export function runTextHasShellLineContinuationBackslash(runText) {
-  return typeof runText === 'string' && runText.length > 0 && RUN_SHELL_LINE_CONTINUATION_BACKSLASH_RE.test(runText)
-}
-
-/**
- * Повертає кроки, у яких `run:` містить заборонене shell-продовження через `\\`.
- * @param {Record<string, unknown>} root корінь workflow
- * @returns {{ jobId: string, stepIndex: number }[]} список кроків із порушенням
- */
-export function findRunStepsWithShellLineContinuationBackslash(root) {
-  /** @type {{ jobId: string, stepIndex: number }[]} */
-  const out = []
-  for (const { jobId, stepIndex, step } of flattenWorkflowSteps(root)) {
-    const run = getStepRun(step)
-    if (runTextHasShellLineContinuationBackslash(run)) {
-      out.push({ jobId, stepIndex })
-    }
-  }
-  return out
-}
-
-/**
- * Чи є крок, у якого `uses` містить будь-який з підрядків.
- * @param {Record<string, unknown>} root корінь workflow
- * @param {string[]} substrings підрядки для пошуку в `uses`
- * @returns {boolean} `true`, якщо знайдено хоча б один збіг
- */
-export function hasAnyStepUsesContaining(root, substrings) {
-  for (const { step } of flattenWorkflowSteps(root)) {
-    const uses = getStepUses(step)
-    if (substrings.some(s => uses.includes(s))) {
-      return true
-    }
-  }
-  return false
-}
-
-/**
- * Чи перед першим кроком з локальним `setup-bun-deps` у кожному job є `actions/checkout@`.
- * Якщо `setup-bun-deps` у файлі немає — `true`.
- * @param {Record<string, unknown>} root корінь workflow
- * @param {string[]} setupPathSubstrings підрядки `uses`, що означають локальний composite (наприклад `./.github/actions/setup-bun-deps`)
- * @returns {boolean} `false`, якщо є setup без попереднього checkout
- */
-export function hasCheckoutBeforeLocalSetupBunDeps(root, setupPathSubstrings) {
-  for (const [, job] of workflowJobsEntries(root)) {
-    let hasCheckoutStep = false
-    for (const step of workflowJobSteps(job)) {
-      const uses = getStepUses(step)
-      if (uses.includes(CHECKOUT_USES_MARKER)) {
-        hasCheckoutStep = true
-      }
-      if (setupPathSubstrings.some(s => uses.includes(s)) && !hasCheckoutStep) {
-        return false
-      }
-    }
-  }
-  return true
-}
-
-/**
- * Шукає заборонені підрядки лише в `uses` та `run` кроків (не в коментарях YAML поза кроками).
- * @param {Record<string, unknown>} root корінь workflow
- * @param {{ pattern: string, msg: string }[]} forbidden список заборонених фрагментів і повідомлень
- * @returns {{ jobId: string, stepIndex: number, pattern: string, msg: string }[]} знайдені збіги
- */
-export function findForbiddenUsesOrRunPatterns(root, forbidden) {
-  /** @type {{ jobId: string, stepIndex: number, pattern: string, msg: string }[]} */
-  const hits = []
-  for (const { jobId, stepIndex, step } of flattenWorkflowSteps(root)) {
-    const uses = getStepUses(step)
-    const run = getStepRun(step)
-    const blob = `${uses}\n${run}`
-    for (const { pattern, msg } of forbidden) {
-      if (blob.includes(pattern)) {
-        hits.push({ jobId, stepIndex, pattern, msg })
-      }
-    }
-  }
-  return hits
-}
-
 /**
  * Чи є в `on.push.paths` (або `on.pull_request.paths`) елемент з точним значенням.
  * @param {Record<string, unknown>} root корінь workflow
@@ -183,87 +91,6 @@ export function eventPathsIncludeExact(root, event, exact) {
   return paths.includes(exact)
 }
 
-/**
- * Чи містить `on.push.paths` підрядок `npm/**` (npm-module).
- * @param {Record<string, unknown>} root корінь workflow
- * @returns {boolean} `true`, якщо серед `paths` є рядок з `npm/**`
- */
-export function pushPathsIncludeNpmGlob(root) {
-  const on = root?.on
-  if (!on || typeof on !== 'object') {
-    return false
-  }
-  const push = /** @type {Record<string, unknown>} */ (on).push
-  if (!push || typeof push !== 'object') {
-    return false
-  }
-  const paths = push.paths
-  if (!Array.isArray(paths)) {
-    return false
-  }
-  return paths.some(p => typeof p === 'string' && p.includes('npm/**'))
-}
-
-/**
- * Перевіряє наявність `branches` з `main` у `on.push`.
- * @param {Record<string, unknown>} root корінь workflow
- * @returns {boolean} `true`, якщо `main` є в `on.push.branches`
- */
-export function pushHasMainBranch(root) {
-  const on = root?.on
-  if (!on || typeof on !== 'object') {
-    return false
-  }
-  const push = /** @type {Record<string, unknown>} */ (on).push
-  if (!push || typeof push !== 'object') {
-    return false
-  }
-  const branches = push.branches
-  if (!Array.isArray(branches)) {
-    return false
-  }
-  return branches.includes('main')
-}
-
-/**
- * Чи є крок з `uses: JS-DevTools/npm-publish` та `with.package` для npm-пакета.
- * @param {Record<string, unknown>} root корінь workflow
- * @returns {boolean} `true`, якщо знайдено крок publish з `package: npm/package.json`
- */
-export function hasNpmPublishStepWithPackage(root) {
-  for (const { step } of flattenWorkflowSteps(root)) {
-    const uses = getStepUses(step)
-    if (uses.includes('JS-DevTools/npm-publish')) {
-      const w = step.with
-      if (w && typeof w === 'object' && /** @type {Record<string, unknown>} */ (w).package === 'npm/package.json') {
-        return true
-      }
-    }
-  }
-  return false
-}
-
-/**
- * Чи є у job `permissions.id-token: write`.
- * @param {Record<string, unknown>} root корінь workflow
- * @returns {boolean} `true`, якщо OIDC-дозвіл для npm publish налаштований
- */
-export function hasIdTokenWritePermission(root) {
-  const jobs = root?.jobs
-  if (!jobs || typeof jobs !== 'object') {
-    return false
-  }
-  for (const job of Object.values(jobs)) {
-    if (job && typeof job === 'object') {
-      const perm = /** @type {Record<string, unknown>} */ (job).permissions
-      if (perm && typeof perm === 'object' && /** @type {Record<string, unknown>} */ (perm)['id-token'] === 'write') {
-        return true
-      }
-    }
-  }
-  return false
-}
-
 /**
  * Перевірки для `lint-js.yml`: checkout@v6, persist-credentials, setup-bun-deps, run-команди.
  * @param {Record<string, unknown> | null} root корінь workflow або `null` якщо parse не вдався
@@ -322,15 +149,6 @@ export function anyRunStepIncludes(root, needle) {
   return false
 }
 
-/**
- * Чи викликається stylelint у workflow через `npx stylelint` у кроці `run` (вимога для CI).
- * @param {Record<string, unknown>} root корінь workflow
- * @returns {boolean} `true`, якщо умова виконана
- */
-export function anyRunStepIncludesStylelint(root) {
-  return anyRunStepIncludes(root, 'npx stylelint')
-}
-
 /**
  * Повертає jobs як список пар [jobId, job], якщо структура валідна.
  * @param {Record<string, unknown>} root корінь workflow