@nitra/cursor 1.19.2 → 1.20.0

package/CHANGELOG.md

@@ -4,6 +4,19 @@
 
 Формат — [Keep a Changelog](https://keepachangelog.com/uk/1.1.0/), нумерація — [SemVer](https://semver.org/lang/uk/).
 
+## [1.20.0] - 2026-05-25
+
+### Added
+
+- **NetworkPolicy: два повних канон-snippets**: `deployment.snippet.yaml` (для `Deployment`/`Job`/`CronJob`/`DaemonSet`) і `statefulset.snippet.yaml` (повний канон для `StatefulSet` з intra-replica правилами). Жодного runtime-merge — JS-генератор/rego обирають один за `kind` workload-у через анотацію `metadata.annotations['nitra.dev/workload-kind']`. Нові publiс exports: `loadSnippetSpec('deployment'|'statefulset')`, `KIND_TO_SNIPPET`, `snippetNameForKind(kind)`. `buildNetworkPolicyYaml(deployName, appLabel, kind)` — `kind` тепер обовʼязковий (throws на невідомий). Rego (`network_policy.rego`) робить superset-перевірку проти обраного канону; safety-net deny на allow-all `egress: [{}]`. GKE NodeLocal DNSCache: link-local `169.254.0.0/16` UDP/TCP 53 — у обох канонах. **Breaking** з v1.19.x: видалено `networkPolicyManifestViolations` (структуру тримає rego); `buildNetworkPolicyYaml` без `kind` тепер throws. Перейменування `common.snippet.yaml` → `deployment.snippet.yaml`; `data.template.snippet` → `data.template.deployment_snippet` у rego.
+- **`rules/js-lint/coverage`**: `parseStrykerReport` тепер зчитує оригінальний код вижилих мутантів (`extractOriginal`), групує по файлах і повертає `survived: [{file, mutants: [{line,col,mutantType,original,replacement}], exampleTest, recommendationText}]`; `findExampleTest` + `extractFirstTestBlock` знаходять і витягують перший тест-блок із тест-файлу поруч — для стилю.
+- **LLM-рекомендації у COVERAGE.md**: коли встановлено `ANTHROPIC_API_KEY`, `n-cursor coverage` робить один Anthropic API-виклик на кожен файл з вижилими мутантами та записує рекомендацію «Що треба протестувати» у секцію `## Recommendations`. Модель: `claude-haiku-4-5-20251001` з prompt caching (`ephemeral`). Без ключа — секція генерується без LLM-тексту.
+- **`rules/js-lint/coverage/lib/generate-recommendation.mjs`**: `generateMutantRecommendation(client, sourceContent, mutants)` — ізольований модуль LLM-виклику.
+- **`@anthropic-ai/sdk`** у dependencies — потрібен для LLM-рекомендацій (опціонально: якщо `ANTHROPIC_API_KEY` не задано, sdk не викликається).
+- **`rules/test/coverage`**: `renderMarkdown` генерує секцію `## Recommendations` з per-file підрозділами (`### <file>`) — таблиця мутантів + приклад тесту + LLM-текст (якщо є).
+- **Stryker incremental mode** у `stryker.config.baseline.mjs`: `incremental: true` + `incrementalFile: 'reports/stryker/stryker-incremental.json'` — Stryker зберігає прогрес між прогонами, відновлює стан після переривання (SIGURG, OOM тощо).
+- **`skills/coverage-fix`**: новий скіл `/n-coverage-fix` — читає `## Recommendations` з COVERAGE.md і ітеративно дописує тести до конвергенції mutation score, включаючи LLM-рекомендації та приклади тестів у промпт агента.
+
 ## [1.19.2] - 2026-05-25
 
 ### Fixed

package/bin/n-cursor.js

@@ -1470,7 +1470,7 @@ try {
       // n-cursor coverage — оркестратор покриття + мутаційного тестування з discovery
       // провайдерів через .n-cursor.json#rules (test.mdc).
       const { runCoverageCli } = await import('../rules/test/coverage/coverage.mjs')
-      process.exitCode = await runCoverageCli()
+      process.exitCode = await runCoverageCli({ fix: args.includes('--fix') })
 
       break
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nitra/cursor",
-  "version": "1.19.2",
+  "version": "1.20.0",
   "description": "CLI для завантаження cursor-правил (префікс n-) у локальний репозиторій",
   "keywords": [
     "cli",
@@ -48,6 +48,8 @@
     "rename-yaml-extensions": "bun ./bin/n-cursor.js rename-yaml-extensions"
   },
   "dependencies": {
+    "@anthropic-ai/claude-code": "^1.0.0",
+    "@anthropic-ai/sdk": "^0.54.0",
     "oxc-parser": "^0.128.0",
     "picomatch": "^4.0.4",
     "smol-toml": "^1.6.1",

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

@@ -6,7 +6,7 @@
  * Контракт провайдера — у docs/superpowers/specs/2026-05-24-coverage-rule-design.md.
  */
 import { spawnSync } from 'node:child_process'
-import { existsSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { mkdtemp, readFile, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
@@ -55,26 +55,132 @@ function parseLcov(text) {
   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 (let i = 0; i < lines.length; i++) {
+    if (startLine === -1 && /^\s*(it|test)\(/.test(lines[i])) startLine = i
+    if (startLine === -1) continue
+    result.push(lines[i])
+    for (const ch of lines[i]) {
+      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(/\.[^.]+$/, '')
+  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 errors виключаються з total.
- * @param {{files:Record<string,{mutants:Array<{status:string}>}>}} report розпарсений mutation.json
- * @returns {{caught:number,total:number}} агрегований mutation score
+ * 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
+ * @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}>}}
  */
-function parseStrykerReport(report) {
+export function parseStrykerReport(report, jsRoot) {
   let caught = 0
   let total = 0
-  for (const file of Object.values(report.files)) {
-    for (const mutant of file.mutants) {
+  /** @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 ?? ''
+          })
+        }
       }
     }
   }
-  return { caught, total }
+
+  const survived = []
+  for (const [file, mutants] of byFile) {
+    survived.push({
+      file,
+      mutants,
+      exampleTest: jsRoot ? findExampleTest(jsRoot, file) : null,
+      recommendationText: null
+    })
+  }
+
+  return { caught, total, survived }
 }
 
 /**
@@ -130,7 +236,7 @@ export async function collect(cwd, opts = {}) {
         'або налаштуй його вручну'
     )
   }
-  const mutation = parseStrykerReport(mutationReport)
+  const { caught, total, survived } = parseStrykerReport(mutationReport, jsRoot)
 
-  return [{ area: 'JS', coverage, mutation }]
+  return [{ area: 'JS', coverage, mutation: { caught, total }, survived }]
 }

package/rules/k8s/js/manifests.mjs

@@ -134,11 +134,12 @@
  * У `kustomization.yaml` overlay, який підключає каталог `…/k8s/…/base`, не додавай окремі YAML-файли з HPA / PDB,
  * поки в наслідуваному `base` у дереві не з'явиться такий Deployment (k8s.mdc).
  */
-import { existsSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { readFile, readdir, stat, unlink, writeFile } from 'node:fs/promises'
 import { basename, dirname, join, relative, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
-import { isSeq, parseAllDocuments, parseDocument } from 'yaml'
+import { isSeq, parseAllDocuments, parseDocument, stringify } from 'yaml'
 
 import { createCheckReporter } from '../../../scripts/lib/check-reporter.mjs'
 import { loadCursorIgnorePaths } from '../../../scripts/lib/load-cursor-config.mjs'
@@ -4242,125 +4243,90 @@ export function pdbManifestViolations(manifest, expectedAppLabel, isDevLike) {
   return errs
 }
 
+const NETWORK_POLICY_SNIPPET_URLS = {
+  deployment: new URL('../policy/network_policy/template/deployment.snippet.yaml', import.meta.url),
+  statefulset: new URL('../policy/network_policy/template/statefulset.snippet.yaml', import.meta.url),
+}
+
+/** @type {Record<string, Record<string, unknown>>} */
+const _snippetCache = {}
+
+/**
+ * Читає snippet-файл і повертає розпарсений spec. Результат кешується в пам'яті процесу.
+ * Кожен snippet — повний самодостатній канон NetworkPolicy для своєї групи workload-типів
+ * (без merge між snippets у runtime).
+ * @param {'deployment' | 'statefulset'} snippetName ім'я сніпету
+ * @returns {{ podSelector?: Record<string, unknown>, policyTypes?: string[], ingress?: unknown[], egress?: unknown[] }}
+ */
+export function loadSnippetSpec(snippetName) {
+  if (_snippetCache[snippetName]) return _snippetCache[snippetName]
+  const url = NETWORK_POLICY_SNIPPET_URLS[snippetName]
+  if (!url) throw new Error(`Unknown NetworkPolicy snippet: ${snippetName}`)
+  const raw = readFileSync(fileURLToPath(url), 'utf8')
+  _snippetCache[snippetName] = /** @type {any} */ (parseDocument(raw).toJS()).spec
+  return _snippetCache[snippetName]
+}
+
+/**
+ * Mapping workload-kind → snippet name. Єдине джерело dispatch'а в JS;
+ * rego використовує симетричний mapping через анотацію `nitra.dev/workload-kind`.
+ * @type {Record<string, 'deployment' | 'statefulset'>}
+ */
+export const KIND_TO_SNIPPET = {
+  Deployment: 'deployment',
+  Job: 'deployment',
+  CronJob: 'deployment',
+  DaemonSet: 'deployment',
+  StatefulSet: 'statefulset',
+}
+
+/**
+ * Обирає snippet name для конкретного workload-kind; throws на невідомий.
+ * @param {string} kind workload-kind
+ * @returns {'deployment' | 'statefulset'}
+ */
+export function snippetNameForKind(kind) {
+  const name = KIND_TO_SNIPPET[kind]
+  if (!name) throw new Error(`Unknown workload kind for NetworkPolicy canon: ${kind}`)
+  return name
+}
+
 /**
- * Канонічний список in-cluster TCP-портів у `to: [{namespaceSelector: {}}]` rule (k8s.mdc).
- * Зовнішній доступ (80/443 → 0.0.0.0/0) і kube-dns (53 UDP/TCP) — окремі rule вище.
- * Catch-all (`namespaceSelector: {}` без `ports:`) — заборонено.
- */
-const NETWORK_POLICY_IN_CLUSTER_DEFAULT_PORTS = [80, 443, 5432, 3306, 1433, 6379, 8080, 4317, 4318]
-
-/**
- * Канонічний блок `spec.egress` NetworkPolicy (k8s.mdc): kube-dns; TCP 80/443 на 0.0.0.0/0;
- * in-cluster `namespaceSelector: {}` зі списком `NETWORK_POLICY_IN_CLUSTER_DEFAULT_PORTS`.
- */
-const NETWORK_POLICY_EGRESS_YAML = `  egress:
-    - to:
-        - namespaceSelector:
-            matchLabels:
-              kubernetes.io/metadata.name: kube-system
-          podSelector:
-            matchLabels:
-              k8s-app: kube-dns
-      ports:
-        - protocol: UDP
-          port: 53
-        - protocol: TCP
-          port: 53
-    - to:
-        - ipBlock:
-            cidr: 0.0.0.0/0
-      ports:
-        - protocol: TCP
-          port: 80
-        - protocol: TCP
-          port: 443
-    - to:
-        - namespaceSelector: {}
-      ports:
-${NETWORK_POLICY_IN_CLUSTER_DEFAULT_PORTS.map(p => `        - protocol: TCP\n          port: ${p}`).join('\n')}
-`
-
-/**
- * Канонічний YAML **NetworkPolicy** для workload з іменем `workloadName` і міткою `app`.
- * @param {string} deployName `metadata.name` workload (Deployment, StatefulSet, …)
- * @param {string} appLabel `spec.selector.matchLabels.app` (або selector у `jobTemplate` для CronJob)
+ * Читає deployment.snippet.yaml і повертає розпарсений spec.
+ * @deprecated Використовуй loadSnippetSpec('deployment')
+ * @returns {{ podSelector: Record<string, unknown>, policyTypes: string[], ingress: unknown[], egress: unknown[] }}
+ */
+export function readNetworkPolicySnippet() {
+  return /** @type {any} */ (loadSnippetSpec('deployment'))
+}
+
+/**
+ * Канонічний YAML **NetworkPolicy** для workload з іменем `deployName`, міткою `app` і типом `kind`.
+ * Snippet обирається за `kind` через `KIND_TO_SNIPPET` (без merge — кожен snippet самодостатній).
+ * Анотація `nitra.dev/workload-kind` додається, щоб rego диспатчив на правильний канон.
+ * @param {string} deployName `metadata.name` workload
+ * @param {string} appLabel `spec.selector.matchLabels.app`
+ * @param {string} kind `kind` workload (обовʼязковий: Deployment | StatefulSet | Job | CronJob | DaemonSet)
  * @returns {string} вміст `networkpolicy.yaml`
  */
-export function buildNetworkPolicyYaml(deployName, appLabel) {
+export function buildNetworkPolicyYaml(deployName, appLabel, kind) {
   const schemaUrl = `${YANNH_BASE}networkpolicy-networking-v1.json`
+  const snippetName = snippetNameForKind(kind)
+  const spec = JSON.parse(JSON.stringify(loadSnippetSpec(snippetName)))
+  spec.podSelector.matchLabels = { app: appLabel }
+  const specYaml = stringify(spec, { indent: 2 }).replaceAll(/^(?!$)/gm, '  ').trimEnd()
   return `# yaml-language-server: $schema=${schemaUrl}
 apiVersion: networking.k8s.io/v1
 kind: NetworkPolicy
 metadata:
   name: ${deployName}
+  annotations:
+    nitra.dev/workload-kind: ${kind}
 spec:
-  podSelector:
-    matchLabels:
-      app: ${appLabel}
-  policyTypes:
-    - Ingress
-    - Egress
-  ingress:
-    - from:
-        - podSelector: {}
-${NETWORK_POLICY_EGRESS_YAML}`
-}
-
-/**
- * Перевіряє **NetworkPolicy** (`networking.k8s.io/v1`): структура й прив'язка до workload.
- * @param {unknown} manifest корінь YAML-документа NetworkPolicy
- * @param {string} expectedDeployName очікуване `metadata.name` workload
- * @param {string} expectedAppLabel очікувана мітка `app` у `podSelector.matchLabels`
- * @returns {string[]} список порушень (порожній — ок)
- */
-export function networkPolicyManifestViolations(manifest, expectedDeployName, expectedAppLabel) {
-  /**
-  @type {string[]}
-   */
-  const errs = []
-  if (manifest === null || manifest === undefined || typeof manifest !== 'object' || Array.isArray(manifest)) {
-    errs.push('NetworkPolicy має бути обʼєктом YAML')
-    return errs
-  }
-  const rec = /** @type {Record<string, unknown>} */ (manifest)
-  if (rec.kind !== 'NetworkPolicy') errs.push(`kind має бути NetworkPolicy (зараз: ${JSON.stringify(rec.kind)})`)
-  if (rec.apiVersion !== 'networking.k8s.io/v1')
-    errs.push(`apiVersion має бути networking.k8s.io/v1 (зараз: ${JSON.stringify(rec.apiVersion)})`)
-  const name = manifestMetadataName(rec)
-  if (name !== expectedDeployName)
-    errs.push(`metadata.name має бути '${expectedDeployName}' (зараз: ${JSON.stringify(name)})`)
-  const spec = rec.spec
-  if (spec === null || spec === undefined || typeof spec !== 'object' || Array.isArray(spec)) {
-    errs.push('spec відсутній або некоректний')
-    return errs
-  }
-  const s = /** @type {Record<string, unknown>} */ (spec)
-  const podSelector = s.podSelector
-  if (
-    podSelector === null ||
-    podSelector === undefined ||
-    typeof podSelector !== 'object' ||
-    Array.isArray(podSelector)
-  ) {
-    errs.push('spec.podSelector відсутній')
-    return errs
-  }
-  const matchLabels = /** @type {Record<string, unknown>} */ (podSelector).matchLabels
-  if (
-    matchLabels === null ||
-    matchLabels === undefined ||
-    typeof matchLabels !== 'object' ||
-    Array.isArray(matchLabels)
-  ) {
-    errs.push('spec.podSelector.matchLabels відсутній')
-    return errs
-  }
-  const app = /** @type {Record<string, unknown>} */ (matchLabels).app
-  if (app !== expectedAppLabel)
-    errs.push(`spec.podSelector.matchLabels.app має бути '${expectedAppLabel}' (зараз: ${JSON.stringify(app)})`)
-  return errs
+${specYaml}`
 }
 
+
 /**
  * Додає `resourceName` у `resources:` kustomization/Component YAML, якщо ще немає; сортує за алфавітом (en).
  * @param {string} raw вміст `kustomization.yaml`
@@ -5126,11 +5092,14 @@ function validateNetworkPolicyForWorkload(npDocs, workloadName, appLabel, worklo
     )
     return
   }
-  const npErrs = networkPolicyManifestViolations(matchedNp, workloadName, appLabel)
-  if (npErrs.length === 0) {
-    passFn(`${npRel}: NetworkPolicy для ${workloadKind} '${workloadName}' валідний (k8s.mdc)`)
+  const spec = /** @type {Record<string, unknown>} */ (matchedNp).spec
+  const foundLabel = networkPolicyPodSelectorAppLabel(spec)
+  if (foundLabel !== appLabel) {
+    fail(
+      `${npRel}: NetworkPolicy '${workloadName}' spec.podSelector.matchLabels.app='${foundLabel}' не відповідає мітці workload '${appLabel}' (k8s.mdc)`
+    )
   } else {
-    for (const e of npErrs) fail(`${npRel}: ${e} (k8s.mdc)`)
+    passFn(`${npRel}: NetworkPolicy для ${workloadKind} '${workloadName}' валідний (k8s.mdc)`)
   }
 }
 
@@ -6332,8 +6301,8 @@ async function appendNetworkPolicyDocuments(npAbs, toAdd, npRel, passFn) {
     const raw = await readFile(npAbs, 'utf8')
     content = raw.trimEnd()
   }
-  const blocks = toAdd.map(({ name, appLabel }, i) => {
-    const block = buildNetworkPolicyYaml(name, appLabel)
+  const blocks = toAdd.map(({ name, appLabel, kind }, i) => {
+    const block = buildNetworkPolicyYaml(name, appLabel, kind)
     return i === 0 && content === '' ? block.trimEnd() : stripYamlLanguageServerModeline(block).trimEnd()
   })
   const joined = blocks.join('\n---\n')
@@ -6401,18 +6370,27 @@ export async function regenerateLegacyNetworkPolicyDocsInFile(npAbs) {
   const needsMigration = docs.some(d => networkPolicyHasLegacyCatchAllEgress(d))
   if (!needsMigration) return false
   /**
-  @type {Array<{ name: string, appLabel: string }>}
+  @type {Array<{ name: string, appLabel: string, kind: string }>}
    */
   const specs = []
   for (const doc of docs) {
     const name = manifestMetadataName(doc)
-    const spec = /** @type {Record<string, unknown>} */ (doc).spec
+    const docRec = /** @type {Record<string, unknown>} */ (doc)
+    const spec = docRec.spec
     const appLabel = networkPolicyPodSelectorAppLabel(spec)
-    if (typeof name === 'string' && name !== '' && appLabel !== '') specs.push({ name, appLabel })
+    const meta = docRec.metadata
+    const annotations = (meta !== null && typeof meta === 'object' && !Array.isArray(meta))
+      ? /** @type {Record<string, unknown>} */ (meta).annotations
+      : null
+    const rawKind = (annotations !== null && typeof annotations === 'object' && !Array.isArray(annotations))
+      ? /** @type {Record<string, unknown>} */ (annotations)['nitra.dev/workload-kind']
+      : null
+    const kind = typeof rawKind === 'string' && rawKind !== '' ? rawKind : 'Deployment'
+    if (typeof name === 'string' && name !== '' && appLabel !== '') specs.push({ name, appLabel, kind })
   }
   if (specs.length === 0) return false
-  const blocks = specs.map(({ name, appLabel }, i) => {
-    const block = buildNetworkPolicyYaml(name, appLabel)
+  const blocks = specs.map(({ name, appLabel, kind }, i) => {
+    const block = buildNetworkPolicyYaml(name, appLabel, kind)
     return i === 0 ? block.trimEnd() : stripYamlLanguageServerModeline(block).trimEnd()
   })
   await writeFile(npAbs, `${blocks.join('\n---\n')}\n`, 'utf8')
@@ -6582,13 +6560,21 @@ function runAllK8sRego(root, yamlFiles, fail) {
   })
 
   /**
-  @type {Array<{ ns: string, dir: string, files: string[] }>}
+  @type {Array<{ ns: string, dir: string, files: string[], templateData?: Record<string, unknown> }>}
    */
   const targets = [
     { ns: 'k8s.manifest', dir: 'k8s/manifest', files: allYaml },
     { ns: 'k8s.gateway', dir: 'k8s/gateway', files: allYaml },
     { ns: 'k8s.hpa_pdb', dir: 'k8s/hpa_pdb', files: allYaml },
-    { ns: 'k8s.network_policy', dir: 'k8s/network_policy', files: allYaml },
+    {
+      ns: 'k8s.network_policy',
+      dir: 'k8s/network_policy',
+      files: allYaml,
+      templateData: {
+        deployment_snippet: loadSnippetSpec('deployment'),
+        statefulset_snippet: loadSnippetSpec('statefulset'),
+      },
+    },
     { ns: 'k8s.kustomization', dir: 'k8s/kustomization', files: kustYaml },
     { ns: 'k8s.svc_yaml', dir: 'k8s/svc_yaml', files: svcYaml },
     { ns: 'k8s.svc_hl_yaml', dir: 'k8s/svc_hl_yaml', files: svcHlYaml },
@@ -6598,7 +6584,7 @@ function runAllK8sRego(root, yamlFiles, fail) {
 
   for (const t of targets) {
     if (t.files.length === 0) continue
-    const violations = runConftestBatch({ policyDirRel: t.dir, namespace: t.ns, files: t.files })
+    const violations = runConftestBatch({ policyDirRel: t.dir, namespace: t.ns, files: t.files, templateData: t.templateData })
     for (const v of violations) {
       fail(`${relOf(v.filename)}: ${v.message}`)
     }

package/rules/k8s/k8s.mdc

@@ -393,7 +393,7 @@ images:
 - **`hpa.yaml`** — `autoscaling/v2`, `HorizontalPodAutoscaler`, **без** `metadata.namespace` (namespace задає kustomization-споживач), `spec.scaleTargetRef.name` **= `metadata.name`** Deployment з base, dev-like значення `minReplicas: 1`, `maxReplicas: 1`.
 - **`pdb.yaml`** — `policy/v1`, `PodDisruptionBudget`, **без** `metadata.namespace`, `spec.selector.matchLabels.app` **= `spec.selector.matchLabels.app`** Deployment, dev-like `minAvailable: 0`.
 
-**Канонічний `base/networkpolicy.yaml`** — `networking.k8s.io/v1`, `NetworkPolicy`, **без** `metadata.namespace` (namespace додає `base/kustomization.yaml`); один або кілька документів (`---`) — по одному на кожен workload (**Deployment** / **StatefulSet** / **DaemonSet** / **Job** / **CronJob**) у тому ж `base/`; `metadata.name` **= `metadata.name`** workload, `spec.podSelector.matchLabels.app` **= мітка `app`** workload. **Ingress:** `from.podSelector: {}` (інші Pod у namespace). **Egress (усі workload-и):** kube-dns (UDP/TCP 53); **TCP 80 і 443** на `0.0.0.0/0` (HTTP/HTTPS назовні, включно з metadata `169.254.169.254:80`); **in-cluster** — `to.namespaceSelector: {}` з **явним списком TCP-портів** (`80, 443, 5432, 3306, 1433, 6379, 8080, 4317, 4318`; трафік на `*.svc` / Pod-и в кластері). Заборонено: `egress: [{}]`; `to.namespaceSelector: {}` без `ports:` (catch-all). Додаткові in-cluster порти можна додати вручну у `ports:` цього rule. Канон: [networkpolicy.snippet.yaml](./policy/network_policy/template/networkpolicy.snippet.yaml). Якщо документа для workload немає — **`check k8s`** дописує його автоматично.
+**Канонічний `base/networkpolicy.yaml`** — `networking.k8s.io/v1`, `NetworkPolicy`, **без** `metadata.namespace` (namespace додає `base/kustomization.yaml`); один або кілька документів (`---`) — по одному на кожен workload (**Deployment** / **StatefulSet** / **DaemonSet** / **Job** / **CronJob**) у тому ж `base/`; `metadata.name` **= `metadata.name`** workload, `spec.podSelector.matchLabels.app` **= мітка `app`** workload. **Ingress:** `from.podSelector: {}` (інші Pod у namespace). **Egress (усі workload-и):** kube-dns через `kube-system` namespaceSelector (UDP/TCP 53); link-local DNS `169.254.0.0/16` (UDP/TCP 53, GKE NodeLocal DNSCache); **TCP 80 і 443** на `0.0.0.0/0` (HTTP/HTTPS назовні); **in-cluster** — `to.namespaceSelector: {}` з **явним списком TCP-портів** (`80, 443, 5432, 3306, 1433, 6379, 8080, 4317, 4318`; трафік на `*.svc` / Pod-и в кластері). **StatefulSet** додатково має egress/ingress `to/from.podSelector: {}` для intra-replica реплікації. Заборонено: `egress: [{}]`; `to.namespaceSelector: {}` без `ports:` (catch-all). Додаткові правила можна дописати поряд — superset-підхід. Канон — два **повних** snippet-файли (без merge у runtime; JS-генератор/rego обирають один за `kind` workload-у через анотацію `metadata.annotations['nitra.dev/workload-kind']`): [deployment.snippet.yaml](./policy/network_policy/template/deployment.snippet.yaml) (для `Deployment`/`Job`/`CronJob`/`DaemonSet`) та [statefulset.snippet.yaml](./policy/network_policy/template/statefulset.snippet.yaml) (для `StatefulSet`; містить deployment-канон + intra-replica правила). Якщо документа для workload немає — **`check k8s`** дописує його автоматично.
 
 Інші назви каталогу (`scale/`, `hpa-component/`, `pdb-component/`) — fail.
 
@@ -490,6 +490,8 @@ apiVersion: networking.k8s.io/v1
 kind: NetworkPolicy
 metadata:
   name: backend-api
+  annotations:
+    nitra.dev/workload-kind: Deployment
 spec:
   podSelector:
     matchLabels:
@@ -513,6 +515,14 @@ spec:
           port: 53
         - protocol: TCP
           port: 53
+    - to:
+        - ipBlock:
+            cidr: 169.254.0.0/16
+      ports:
+        - protocol: UDP
+          port: 53
+        - protocol: TCP
+          port: 53
     - to:
         - ipBlock:
             cidr: 0.0.0.0/0

package/rules/k8s/policy/network_policy/network_policy.rego

@@ -1,31 +1,35 @@
-# Пер-документна структурна перевірка NetworkPolicy (k8s.mdc).
-# Cross-file (metadata.name = workload, podSelector.app = мітка app) — JS
-# (`networkPolicyManifestViolations`, `validateNetworkPolicyForWorkload`).
+# Пер-документна структурна перевірка NetworkPolicy.
+# Cross-file (metadata.name = workload, podSelector.app = мітка app) — JS (validateNetworkPolicyForWorkload).
 #
-# Канон egress: kube-dns; TCP 80/443 на 0.0.0.0/0; інші порти — namespaceSelector: {}
-# (in-cluster, зокрема *.svc). Заборонено egress: [{}] (allow-all).
+# Superset-перевірка egress/ingress: кожне правило з обраного canon-snippet'у
+# має бути присутнє в input (extra-правила дозволені). Канон обирається за
+# анотацією `nitra.dev/workload-kind`:
+#   StatefulSet → data.template.statefulset_snippet (повний канон з intra-replica)
+#   решта      → data.template.deployment_snippet  (повний канон, default fallback)
 #
-# Запуск:
-#   conftest test path/to/networkpolicy.yaml -p npm/policy/k8s/network_policy \
-#     --namespace k8s.network_policy
+# Обидва snippets — самодостатні (без merge на runtime).
+#
+# Snippets передаються через templateData при виклику runConftestBatch для k8s.network_policy.
+#
+# Запуск (dev):
+#   conftest test path/to/networkpolicy.yaml -p npm/rules/k8s/policy/network_policy \
+#     --namespace k8s.network_policy \
+#     --data npm/rules/k8s/policy/network_policy/template/deployment.snippet.yaml \
+#     --data npm/rules/k8s/policy/network_policy/template/statefulset.snippet.yaml
 package k8s.network_policy
 
 import rego.v1
 
-np_kind_template := "kind має бути NetworkPolicy (зараз: %v) (k8s.mdc)"
-
-np_api_template := "apiVersion має бути networking.k8s.io/v1 (зараз: %v) (k8s.mdc)"
-
 deny contains msg if {
 	is_np_doc
 	input.kind != "NetworkPolicy"
-	msg := sprintf(np_kind_template, [input.kind])
+	msg := sprintf("kind має бути NetworkPolicy (зараз: %v) (k8s.mdc)", [input.kind])
 }
 
 deny contains msg if {
 	is_np_doc
 	input.apiVersion != "networking.k8s.io/v1"
-	msg := sprintf(np_api_template, [input.apiVersion])
+	msg := sprintf("apiVersion має бути networking.k8s.io/v1 (зараз: %v) (k8s.mdc)", [input.apiVersion])
 }
 
 deny contains "spec відсутній або некоректний (NetworkPolicy; k8s.mdc)" if {
@@ -42,6 +46,17 @@ deny contains "spec.podSelector.matchLabels відсутній (NetworkPolicy; k
 	not is_object(object.get(selector, "matchLabels", null))
 }
 
+deny contains "spec.podSelector.matchLabels.app відсутній або порожній (NetworkPolicy; k8s.mdc)" if {
+	is_np_doc
+	spec := object.get(input, "spec", null)
+	is_object(spec)
+	selector := object.get(spec, "podSelector", null)
+	is_object(selector)
+	ml := object.get(selector, "matchLabels", null)
+	is_object(ml)
+	object.get(ml, "app", null) == null
+}
+
 deny contains "spec.policyTypes має містити Ingress і Egress (NetworkPolicy; k8s.mdc)" if {
 	is_np_doc
 	spec := object.get(input, "spec", null)
@@ -57,39 +72,56 @@ deny contains "spec.ingress має містити from.podSelector (NetworkPolic
 	not ingress_has_pod_selector_rule(spec)
 }
 
-deny contains "spec.egress має бути непорожнім масивом (NetworkPolicy; k8s.mdc)" if {
-	is_np_doc
-	spec := object.get(input, "spec", null)
-	is_object(spec)
-	not is_non_empty_array(object.get(spec, "egress", null))
+# Dispatch на повний canon-snippet за анотацією nitra.dev/workload-kind.
+# StatefulSet → statefulset_snippet (з intra-replica), решта → deployment_snippet.
+canon_for_kind("StatefulSet") := data.template.statefulset_snippet
+
+canon_for_kind(kind) := data.template.deployment_snippet if {
+	kind != "StatefulSet"
 }
 
-deny contains "spec.egress: заборонено allow-all {} — канон k8s.mdc (80/443 назовні, інше — in-cluster)" if {
-	is_np_doc
-	spec := object.get(input, "spec", null)
-	is_object(spec)
-	egress_allows_all(object.get(spec, "egress", null))
+snippet_name_for_kind("StatefulSet") := "statefulset"
+
+snippet_name_for_kind(kind) := "deployment" if {
+	kind != "StatefulSet"
 }
 
-deny contains "spec.egress: потрібен ipBlock 0.0.0.0/0 з ports 80 і 443 (HTTP/HTTPS назовні; k8s.mdc)" if {
-	is_np_doc
-	spec := object.get(input, "spec", null)
-	is_object(spec)
-	not egress_has_internet_http_https(spec)
+workload_kind := kind if {
+	kind := object.get(object.get(input.metadata, "annotations", {}), "nitra.dev/workload-kind", "")
 }
 
-deny contains "spec.egress: потрібен to.namespaceSelector: {} (інші порти лише in-cluster / *.svc; k8s.mdc)" if {
+# Superset-check egress: кожне канонічне правило має бути в input.spec.egress.
+deny contains msg if {
 	is_np_doc
-	spec := object.get(input, "spec", null)
-	is_object(spec)
-	not egress_has_cluster_namespace_selector(spec)
+	is_object(object.get(input, "spec", null))
+	canon := canon_for_kind(workload_kind)
+	some canon_rule in canon.egress
+	not list_contains(object.get(input.spec, "egress", []), canon_rule)
+	msg := sprintf(
+		"NetworkPolicy %v: відсутнє обовʼязкове egress-правило (%v.snippet.yaml; k8s.mdc): %v",
+		[input.metadata.name, snippet_name_for_kind(workload_kind), json.marshal(canon_rule)],
+	)
 }
 
-deny contains "spec.egress: to.namespaceSelector: {} мусить мати непорожні ports — catch-all заборонено (k8s.mdc)" if {
+# Superset-check ingress.
+deny contains msg if {
 	is_np_doc
-	spec := object.get(input, "spec", null)
-	is_object(spec)
-	cluster_egress_rule_without_ports(spec)
+	is_object(object.get(input, "spec", null))
+	canon := canon_for_kind(workload_kind)
+	some canon_rule in canon.ingress
+	not list_contains(object.get(input.spec, "ingress", []), canon_rule)
+	msg := sprintf(
+		"NetworkPolicy %v: відсутнє обовʼязкове ingress-правило (%v.snippet.yaml; k8s.mdc): %v",
+		[input.metadata.name, snippet_name_for_kind(workload_kind), json.marshal(canon_rule)],
+	)
+}
+
+# Safety-net: allow-all `egress: [{}]` — заборонено навіть як extra-правило.
+deny contains "spec.egress: заборонено allow-all {} — додавай явні правила (k8s.mdc)" if {
+	is_np_doc
+	some rule in object.get(input.spec, "egress", [])
+	is_object(rule)
+	count(object.keys(rule)) == 0
 }
 
 is_np_doc if input.kind == "NetworkPolicy"
@@ -114,68 +146,8 @@ ingress_has_pod_selector_rule(spec) if {
 	object.get(peer, "podSelector", null) != null
 }
 
-is_non_empty_array(x) if {
-	is_array(x)
-	count(x) > 0
-}
-
-egress_allows_all(egress) if {
-	is_array(egress)
-	some rule in egress
-	is_object(rule)
-	count(object.keys(rule)) == 0
-}
-
-egress_has_internet_http_https(spec) if {
-	egress := object.get(spec, "egress", null)
-	is_array(egress)
-	some rule in egress
-	is_object(rule)
-	to_list := object.get(rule, "to", null)
-	is_array(to_list)
-	some peer in to_list
-	is_object(peer)
-	ipb := object.get(peer, "ipBlock", null)
-	is_object(ipb)
-	ipb.cidr == "0.0.0.0/0"
-	ports := object.get(rule, "ports", null)
-	is_array(ports)
-	egress_ports_include(ports, 80)
-	egress_ports_include(ports, 443)
-}
-
-egress_ports_include(ports, want) if {
-	some p in ports
-	is_object(p)
-	p.port == want
-}
-
-egress_has_cluster_namespace_selector(spec) if {
-	egress := object.get(spec, "egress", null)
-	is_array(egress)
-	some rule in egress
-	is_object(rule)
-	to_list := object.get(rule, "to", null)
-	is_array(to_list)
-	some peer in to_list
-	is_object(peer)
-	ns := object.get(peer, "namespaceSelector", null)
-	is_object(ns)
-	count(ns) == 0
-}
-
-cluster_egress_rule_without_ports(spec) if {
-	egress := object.get(spec, "egress", null)
-	is_array(egress)
-	some rule in egress
-	is_object(rule)
-	to_list := object.get(rule, "to", null)
-	is_array(to_list)
-	some peer in to_list
-	is_object(peer)
-	ns := object.get(peer, "namespaceSelector", null)
-	is_object(ns)
-	count(ns) == 0
-	ports := object.get(rule, "ports", [])
-	count(ports) == 0
+list_contains(items, item) if {
+	is_array(items)
+	some i
+	items[i] == item
 }

package/rules/k8s/policy/network_policy/template/{networkpolicy.snippet.yaml → deployment.snippet.yaml}

@@ -20,6 +20,14 @@ spec:
           port: 53
         - protocol: TCP
           port: 53
+    - to:
+        - ipBlock:
+            cidr: 169.254.0.0/16
+      ports:
+        - protocol: UDP
+          port: 53
+        - protocol: TCP
+          port: 53
     - to:
         - ipBlock:
             cidr: 0.0.0.0/0

package/rules/k8s/policy/network_policy/template/statefulset.snippet.yaml

@@ -0,0 +1,67 @@
+spec:
+  podSelector:
+    matchLabels: {}
+  policyTypes:
+    - Ingress
+    - Egress
+  ingress:
+    - from:
+        - podSelector: {}
+    # intra-replica (StatefulSet pod ↔ pod у тому ж namespace — matchLabels:{} лишається без JS-substitution)
+    - from:
+        - podSelector:
+            matchLabels: {}
+  egress:
+    - to:
+        - namespaceSelector:
+            matchLabels:
+              kubernetes.io/metadata.name: kube-system
+          podSelector:
+            matchLabels:
+              k8s-app: kube-dns
+      ports:
+        - protocol: UDP
+          port: 53
+        - protocol: TCP
+          port: 53
+    - to:
+        - ipBlock:
+            cidr: 169.254.0.0/16
+      ports:
+        - protocol: UDP
+          port: 53
+        - protocol: TCP
+          port: 53
+    - to:
+        - ipBlock:
+            cidr: 0.0.0.0/0
+      ports:
+        - protocol: TCP
+          port: 80
+        - protocol: TCP
+          port: 443
+    - to:
+        - namespaceSelector: {}
+      ports:
+        - protocol: TCP
+          port: 80
+        - protocol: TCP
+          port: 443
+        - protocol: TCP
+          port: 5432
+        - protocol: TCP
+          port: 3306
+        - protocol: TCP
+          port: 1433
+        - protocol: TCP
+          port: 6379
+        - protocol: TCP
+          port: 8080
+        - protocol: TCP
+          port: 4317
+        - protocol: TCP
+          port: 4318
+    # intra-replica (StatefulSet pod ↔ pod у тому ж namespace — matchLabels:{} лишається без JS-substitution)
+    - to:
+        - podSelector:
+            matchLabels: {}

package/rules/test/coverage/coverage.mjs

@@ -70,9 +70,11 @@ export function formatScore({ caught, total }) {
 
 /**
  * Рендерить таблицю покриття + мутаційного тестування як Markdown.
+ * Якщо будь-який рядок містить непустий `survived`, додає секцію
+ * `## Вижилі мутанти` з JSON-блоком для `/n-fix-tests`.
  * Без timestamp, щоб git diff рухався лише при зміні метрик.
- * @param {Array<{area:string, coverage:{lines:{covered:number,total:number},functions:{covered:number,total:number}}, mutation:{caught:number,total:number}}>} rows рядки провайдерів
- * @returns {string} Markdown-таблиця з заголовком `# Coverage`
+ * @param {Array<{area:string, coverage:{lines:{covered:number,total:number},functions:{covered:number,total:number}}, mutation:{caught:number,total:number}, survived?: Array<{file:string,line:number,col:number,mutantType:string,original:string,replacement:string}>}>} rows рядки провайдерів
+ * @returns {string} Markdown з заголовком `# Coverage`
  */
 export function renderMarkdown(rows) {
   const lines = [
@@ -87,6 +89,28 @@ export function renderMarkdown(rows) {
         `${row.mutation.caught}/${row.mutation.total} | ${formatScore(row.mutation)} |`
     )
   }
+
+  const allSurvived = rows.flatMap(r => r.survived ?? [])
+  if (allSurvived.length > 0) {
+    lines.push('', '## Recommendations')
+    for (const group of allSurvived) {
+      lines.push('', `### ${group.file}`, '')
+      lines.push('| Рядок | Оригінал | Заміна | Тип |')
+      lines.push('| --- | --- | --- | --- |')
+      for (const m of group.mutants) {
+        lines.push(`| ${m.line} | \`${m.original}\` | \`${m.replacement}\` | ${m.mutantType} |`)
+      }
+      if (group.exampleTest) {
+        lines.push('', `**Приклад тесту** (\`${group.exampleTest.testFile}\`):`, '', '```js')
+        lines.push(group.exampleTest.code ?? '')
+        lines.push('```')
+      }
+      if (group.recommendationText) {
+        lines.push('', '**Що треба протестувати:**', '', group.recommendationText)
+      }
+    }
+  }
+
   return `${lines.join('\n')}\n`
 }
 
@@ -127,7 +151,9 @@ function buildTotalsRow(rows) {
 /**
  * Виконує coverage-pipeline: discovery провайдерів за `.n-cursor.json#rules`,
  * detect+collect для кожного, агрегація, запис COVERAGE.md.
- * @param {{cwd?:string, rulesDir?:string}} [opts] ін'єкція cwd/rulesDir для тестів
+ * При `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 коли жоден провайдер не дав даних)
  */
 export async function runCoverageSteps(opts = {}) {
@@ -154,12 +180,32 @@ export async function runCoverageSteps(opts = {}) {
   const md = renderMarkdown(rows)
   await writeFile(join(cwd, 'COVERAGE.md'), md, 'utf8')
   console.log('✓ COVERAGE.md')
+
+  if (opts.fix) {
+    const allSurvived = rows.flatMap(r => r.survived ?? [])
+    // eslint-disable-next-line no-unsanitized/method -- шлях відносний до пакету, не user-input
+    const { fixSurvivedMutants } = await import(
+      new URL('../../scripts/coverage-fix.mjs', import.meta.url).href
+    )
+    await fixSurvivedMutants(allSurvived, cwd)
+  }
+
   return 0
 }
 
-// Один оркестратор, один callsite — `withLock` викликається напряму, без спільної
-// точки входу. Канонічне обмеження «не імпортуй withLock у lint.mjs/fix.mjs напряму»
-// (scripts.mdc § withLock) націлене на дедуплікацію preamble серед багатьох файлів —
-// для одного coverage-консумера не релевантне (див. C4 у
-// specs/2026-05-24-coverage-rule-design.md).
-export const runCoverageCli = () => withLock('coverage', runCoverageSteps)
+/**
+ * CLI entrypoint для `n-cursor coverage [--fix]`.
+ * Із `--fix`: збирає метрики → запускає агента → повторно збирає метрики.
+ * Без `--fix`: лише збирає метрики.
+ * Лок охоплює кожен coverage-прогін окремо.
+ * @param {{fix?:boolean}} [opts] прапор --fix
+ * @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 code
+}

package/rules/test/js/data/stryker_config/stryker.config.baseline.mjs

@@ -8,5 +8,8 @@ export default {
   tempDirName: 'reports/stryker/.tmp',
   reporters: ['json', 'clear-text'],
   jsonReporter: { fileName: 'reports/stryker/mutation.json' },
-  coverageAnalysis: 'off'
+  coverageAnalysis: 'off',
+  // incremental: зберігає прогрес між прогонами — відновлення після переривання без старту з нуля.
+  incremental: true,
+  incrementalFile: 'reports/stryker/stryker-incremental.json',
 }

package/scripts/coverage-fix.mjs

@@ -0,0 +1,105 @@
+/**
+ * `n-cursor coverage --fix`: запускає Claude Code агента для написання тестів
+ * по вижилих мутантах Stryker. Агент отримує список мутантів з контекстом
+ * (file, line, оригінальний код, вижилий варіант, тип мутації) і самостійно
+ * знаходить або створює відповідні test-файли.
+ *
+ * Залежить від `@anthropic-ai/claude-code` (dependencies у npm/package.json).
+ */
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+/**
+ * @typedef {{line:number, col:number, mutantType:string, original:string, replacement:string}} MutantDetail
+ * @typedef {{file:string, mutants:MutantDetail[], exampleTest:{testFile:string,code:string|null}|null, recommendationText:string|null}} SurvivedFileGroup
+ */
+
+/**
+ * Запускає Claude Code агента для написання тестів по вижилих мутантах.
+ * @param {SurvivedFileGroup[]} survived вижилі мутанти, згруповані по файлах
+ * @param {string} projectRoot абсолютний шлях до кореня проєкту
+ * @returns {Promise<void>}
+ */
+export async function fixSurvivedMutants(survived, projectRoot) {
+  const totalMutants = survived.reduce((s, g) => s + g.mutants.length, 0)
+  if (totalMutants === 0) {
+    console.log('✓ Всі мутанти вбиті — доповнення тестів не потрібне')
+    return
+  }
+
+  const prompt = await buildFixPrompt(survived, projectRoot)
+  console.log(`\n🤖 coverage --fix: запускаю агента для ${totalMutants} вижилих мутантів...\n`)
+
+  // Dynamic import: @anthropic-ai/claude-code завантажується лише при --fix,
+  // щоб не гальмувати звичайний coverage-прогін за відсутності пакету.
+  const { query } = await import('@anthropic-ai/claude-code')
+
+  for await (const msg of query({
+    prompt,
+    options: {
+      cwd: projectRoot,
+      maxTurns: 20,
+      allowedTools: ['Read', 'Edit', 'Bash'],
+    }
+  })) {
+    if (msg.type === 'text') process.stdout.write(msg.text)
+  }
+  process.stdout.write('\n')
+}
+
+/**
+ * Формує rich-промпт для агента: список вижилих мутантів згрупований по файлах,
+ * з контекстом ±3 рядки навколо кожного мутанта з source-файлу.
+ * @param {SurvivedFileGroup[]} survived
+ * @param {string} projectRoot
+ * @returns {Promise<string>}
+ */
+async function buildFixPrompt(survived, projectRoot) {
+  const sections = []
+
+  for (const { file, mutants, exampleTest } of survived) {
+    let srcLines = []
+    try {
+      srcLines = (await readFile(join(projectRoot, file), 'utf8')).split('\n')
+    } catch {
+      // файл може бути недоступним — пропускаємо контекст, але продовжуємо
+    }
+
+    const mutantDescs = mutants.map(m => {
+      const ctxStart = Math.max(0, m.line - 4)
+      const ctxEnd = Math.min(srcLines.length, m.line + 3)
+      const context = srcLines
+        .slice(ctxStart, ctxEnd)
+        .map((l, i) => `${ctxStart + i + 1}: ${l}`)
+        .join('\n')
+      return [
+        `  - Рядок ${m.line}, колонка ${m.col}, тип мутації \`${m.mutantType}\``,
+        `    Оригінал: \`${m.original}\``,
+        `    Вижив варіант: \`${m.replacement}\``,
+        context ? `    Контекст:\n\`\`\`\n${context}\n\`\`\`` : ''
+      ].filter(Boolean).join('\n')
+    }).join('\n')
+
+    const exampleSection = exampleTest?.code
+      ? `\n\nПриклад тесту з \`${exampleTest.testFile}\`:\n\`\`\`js\n${exampleTest.code}\n\`\`\``
+      : ''
+
+    sections.push(`### \`${file}\`${exampleSection}\n${mutantDescs}`)
+  }
+
+  return [
+    'Твоє завдання — написати unit-тести, що вбивають наступні вижилі мутанти Stryker.',
+    'Для кожного мутанта: знайди або створи відповідний test-файл, додай тест-кейс,',
+    'що явно перевіряє цю гілку/умову і провалиться якщо код замінити на "вижилий варіант".',
+    '',
+    '## Вижилі мутанти',
+    '',
+    ...sections,
+    '',
+    '## Правила',
+    '- Не змінюй source-файли — лише test-файли.',
+    '- Використовуй той самий test-фреймворк, що вже в проєкті.',
+    '- Запусти `bun test` (або відповідну команду) після кожного файлу — переконайся, що 0 fail.',
+    '- Якщо мутант охоплений іншим новим тестом — не дублюй.'
+  ].join('\n')
+}

package/skills/fix-tests/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: n-fix-tests
+description: >-
+  Ітеративно дописати тести щоб підвищити mutation score — читає вижилі мутанти з COVERAGE.md і запускає агент до конвергенції
+---
+
+# n-fix-tests — підвищення mutation score
+
+## Мета
+
+Читає структурований JSON-блок вижилих мутантів з `COVERAGE.md` і ітеративно дописує тести що їх вловлюють. Зупиняється коли score перестає покращуватись (конвергенція).
+
+## Передумови
+
+- У `COVERAGE.md` є секція `## Вижилі мутанти` з JSON-блоком
+- Залежності встановлені (`bun i`)
+- `bun run coverage` (або `n-cursor coverage`) доступний
+
+## Workflow
+
+### Крок 1: Зчитай вижилих мутантів
+
+Прочитай `COVERAGE.md`. Знайди секцію `## Вижилі мутанти`. Знайди фенсований блок ` ```json ` у цій секції і розпарси JSON-масив.
+
+Якщо секція відсутня або масив порожній — зупинись з повідомленням:
+`✓ Жодних вижилих мутантів — mutation score повний`
+
+Запамʼятай поточну кількість вижилих: `prevCount = масив.length`
+
+### Крок 2: Знайди test-команду і coverage-команду
+
+Прочитай `package.json` у кореневій директорії.
+
+**test-команда** (перша що існує):
+1. `scripts["test"]` з `package.json`
+2. fallback: `bun test`
+
+**coverage-команда** (перша що існує):
+1. `scripts["coverage"]` з `package.json` → виклик: `bun run coverage`
+2. fallback: `n-cursor coverage`
+
+### Крок 3: Для кожного файлу — спауни Agent
+
+Згрупуй мутанти по полю `file`. Для кожної групи виконай:
+
+**3a. Знайди файли:**
+- Source: `<cwd>/<file>` (прочитай вміст)
+- Test файл (перший що існує):
+  - `<dir>/<basename>.test.<ext>` — поруч із source
+  - `<dir>/tests/<basename>.test.<ext>`
+  - `tests/<basename>.test.<ext>` від кореня
+  - Якщо жоден не знайдено — буде створено поруч із source
+
+**3b. Сформуй промпт для Agent:**
+
+```
+Тобі дані вижилі мутанти зі Stryker для файлу `<file>`.
+Ці мутанти вижили тому що наявні тести НЕ вловили конкретні зміни коду.
+
+**Вихідний код** (`<file>`):
+\`\`\`
+<зміст source-файлу>
+\`\`\`
+
+**Наявні тести** (`<test-file>`):
+\`\`\`
+<зміст test-файлу або "файл ще не існує">
+\`\`\`
+
+**Вижилі мутанти** (кожен — зміна коду що НЕ вловлена):
+<для кожного мутанта:>
+- Рядок <line>, колонка <col>: `<original>` → `<replacement>` (тип мутації: <mutantType>)
+
+**Завдання:**
+Допиши мінімальні test-cases у файл `<test-file>` які б вловили кожен із перелічених мутантів.
+Правила:
+- НЕ видаляй і НЕ змінюй наявні тести
+- Стиль тестів — відповідно до наявного файлу (той самий фреймворк, той самий стиль describe/test)
+- Якщо файл ще не існує — створи його з правильними імпортами відповідно до файлів у тому самому каталозі
+- Після написання запусти: `bun test <test-file>` і переконайся що всі тести проходять (виправ якщо падають)
+```
+
+**3c. Запусти Agent** з цим промптом і дочекайся завершення.
+
+### Крок 4: Перевір що всі тести проходять
+
+```bash
+bun test  # або test-команда з кроку 2
+```
+
+Якщо тести падають — поверни конкретний Agent (для того файлу) з помилкою і попроси виправити.
+
+### Крок 5: Запусти coverage і порівняй
+
+```bash
+bun run coverage  # або coverage-команда з кроку 2
+```
+
+Прочитай новий `COVERAGE.md`, знайди і розпарси JSON-масив вижилих.
+`newCount = новий масив.length`
+
+**Рішення:**
+- Якщо `newCount < prevCount` → повтор з Кроку 1 з оновленим масивом
+- Якщо `newCount >= prevCount` → зупинись:
+  `✓ Конвергенція: mutation score більше не покращується. Вижило: <newCount> мутантів.`
+
+## Зупинка після конвергенції
+
+Конвергенція — нормальний результат. Деякі мутанти не можна вбити (захищений зовнішнім станом, недетермінована логіка тощо). Не намагайся виправити те що не змінилось після ітерації.

package/skills/fix-tests/auto.md

@@ -0,0 +1 @@
+[js-lint]