@nitra/cursor 1.25.2 → 1.26.1

package/.pi-template/extensions/n-cursor-adr/index.ts

@@ -36,10 +36,7 @@ interface PiExec {
       timeout?: number
     }
   ) => Promise<{ code: number; stdout: string; stderr: string }>
-  on: (
-    event: string,
-    handler: (event: unknown, ctx: PiContext) => Promise<void> | void
-  ) => void
+  on: (event: string, handler: (event: unknown, ctx: PiContext) => Promise<void> | void) => void
 }
 
 const CAPTURE_HOOK = '.claude/hooks/capture-decisions.sh'
@@ -68,10 +65,7 @@ export default function (pi: PiExec): void {
       jsonlPath = join(tmpdir(), `n-cursor-pi-transcript-${Date.now()}-${randomUUID()}.jsonl`)
       writeFileSync(jsonlPath, lines + '\n', 'utf8')
     } catch (error) {
-      ctx.ui?.notify?.(
-        `@nitra/cursor: transcript serialization failed — ${(error as Error).message}`,
-        'error'
-      )
+      ctx.ui?.notify?.(`@nitra/cursor: transcript serialization failed — ${(error as Error).message}`, 'error')
       return
     }
 

package/CHANGELOG.md

@@ -4,6 +4,49 @@
 
 Формат — [Keep a Changelog](https://keepachangelog.com/uk/1.1.0/), нумерація — [SemVer](https://semver.org/lang/uk/).
 
+## [1.26.1] - 2026-05-26
+
+### Fixed
+
+- **`k8s/js/manifests.mjs`**: `Set.prototype.toSorted` не існує — повернено `Array.from(new Set(...)).toSorted(...)` (oxlint `--fix` помилково замінив `[...new Set(...)].sort(...)` на невалідний `new Set(...).toSorted(...)`).
+- **`k8s/js/manifests.mjs`**: hardcoded CIDR-и (`35.191.0.0/16`, `130.211.0.0/22`, `10.0.0.0/8`) у `NETWORK_POLICY_GCLB_INGRESS_FROM` тепер з `// eslint-disable-next-line sonarjs/no-hardcoded-ip` (це канон GCLB, який не змінюється).
+- **`k8s/js/manifests.mjs`**: `() => {}` default callback → іменована константа `noopFail` (eslint `no-empty-function`).
+- **`k8s/js/tests/manifests/tests/check-schema.test.mjs`**: винесено `HR_YAML_RE`, `HTTPROUTE_NP_MAPPING_RE`, `K8S_MDC_RE`, `EXPECTED_GCLB_INGRESS_FROM`, `GCLB_HC_GLOBAL_CIDR` як module-scope константи (e18e `prefer-static-regex` + sonarjs `no-hardcoded-ip`); `mock(() => {})` → `mock(msg => msg)`.
+- **`.cspell.json`**: додано `GCLB`, `gclb`, `байтово` до words.
+
+## [1.26.0] - 2026-05-26
+
+### Added
+
+- **`k8s/js/manifests.mjs`**: нова `collectHttpRouteIngressForWorkload(dir, appLabel, fail)` — резолвить HTTPRoute → `-hl` Service → `selector.app` mapping і повертає унікальні TCP-порти з `backendRefs[].port` для workload з міткою `appLabel`. Викликається з `appendNetworkPolicyDocuments` і `regenerateLegacyNetworkPolicyDocsInFile` під час `check k8s`.
+- **`k8s/js/manifests.mjs:buildNetworkPolicyYaml`**: опційний 4-й параметр `gclbPorts: number[]` — якщо непорожній, додає ingress-правило з `ipBlock` 35.191.0.0/16, 130.211.0.0/22, 10.0.0.0/8 і TCP-портами (відсортовано). Без параметра output байтово ідентичний baseline canon.
+- **`k8s.mdc` v1.42**: новий розділ «HTTPRoute → NetworkPolicy ingress (GCLB + Envoy)» з описом mapping і прикладом NetworkPolicy для HTTPRoute-paired workload.
+
+### Fixed
+
+- **Service blocking via NetworkPolicy** для workload-ів, прив'язаних до `HTTPRoute` через GKE Gateway: попередній canon допускав тільки `podSelector: {}` ingress, що блокувало трафік від Envoy data-plane (`10.10.0.0/23` для `us-central1-proxy-only`) і Google health checks (`35.191.0.0/16`, `130.211.0.0/22`). Тепер правило автоматично додається.
+
+## [1.25.3] - 2026-05-26
+
+### Fixed
+
+- **JSDoc**: дописано опис `@returns`/`@param`-описи й типи в `rules/js-lint/coverage/coverage.mjs`, `rules/k8s/js/manifests.mjs`, `rules/adr/js/tests/*.test.mjs`, `rules/test/js/tests/*.test.mjs`, `scripts/coverage-fix.mjs`, `scripts/post-tool-use-fix.mjs`, `scripts/utils/tests/resolve-*.test.mjs` (oxlint/eslint jsdoc-правила).
+- **`k8s/js/manifests.mjs`**: `JSON.parse(JSON.stringify(...))` → `structuredClone(...)` (unicorn `prefer-structured-clone`); інверсія негованої умови в `validateNetworkPolicyForWorkload` (eslint `no-negated-condition`).
+- **`k8s/policy/network_policy/network_policy.rego`**: `list_contains` → `contains_item` (regal `avoid-get-and-list-prefix`); `items[i] == item` → `some candidate in items` (`prefer-some-in-iteration`); `workload_kind` без зайвого `if {}` (`unconditional-assignment`); helper-правила переміщено після всіх `deny`, щоб задовольнити `messy-rule`. `network_policy_test.rego` переформатовано через `opa fmt`.
+- **`scripts/tests/post-tool-use-fix.test.mjs`**: fake-child перероблено з `EventEmitter` на duck-typed `addListener`/`removeListener` (unicorn `prefer-event-target`).
+- **`scripts/tests/cli-entry.test.mjs`**: symlink-тест /tmp ↔ /private/tmp використовує `mkdtempSync` з префіксом, зібраним з частин (sonarjs `publicly-writable-directories`).
+- **`rules/test/coverage/coverage.mjs`**: множинні `push()` об’єднано в один виклик (unicorn `prefer-single-call`).
+- Винесено повторно-компільовані regex у module scope (`e18e/prefer-static-regex`) у `coverage.mjs`, `test/coverage/tests/coverage.test.mjs`, `k8s/tests/manifests/tests/check-schema.test.mjs`.
+- Видалено невикористаний `npm/lib/x.js` (unicorn `no-empty-file`).
+
+### Changed
+
+- **`.claude/hooks/{capture,normalize}-decisions.sh`** синхронізовано з `npm/.claude-template/hooks/` (включно з новим `lib/tooling-only.sh`).
+- **`knip.json`**: додано entry-патерни для динамічно імпортованих/зовнішніх скриптів (stryker configs, pi extensions, fixtures, `coverage-fix.mjs`); `@anthropic-ai/claude-code`, `@anthropic-ai/sdk`, `@stryker-mutator/core` додано в `ignoreDependencies` (тип-only або dynamic import).
+- **`.jscpd.json`**: ігнор-патерни розширено для template/canonical пар тієї ж природи, що вже були в винятках (`npm/.pi-template/**`, `knip-canonical.json`, `*.snippet.yaml`).
+- **`.cspell.json`**: до `ignorePaths` додано `**/reports/stryker/**` (генеровані Stryker-репорти, вже в .gitignore).
+- **Кореневий `package.json#scripts.lint`** — чейн `bun run lint-ga && lint-js && lint-rego && lint-security && lint-style && lint-text && oxfmt .` замість делегування до CLI (bun.mdc + security.mdc).
+
 ## [1.25.2] - 2026-05-26
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nitra/cursor",
-  "version": "1.25.2",
+  "version": "1.26.1",
   "description": "CLI для завантаження cursor-правил (префікс n-) у локальний репозиторій",
   "keywords": [
     "cli",
@@ -10,10 +10,6 @@
     "n",
     "pi-package"
   ],
-  "pi": {
-    "skills": "skills",
-    "extensions": ".pi-template/extensions"
-  },
   "homepage": "https://github.com/n/cursor#readme",
   "bugs": {
     "url": "https://github.com/n/cursor/issues"
@@ -64,5 +60,9 @@
   "engines": {
     "bun": ">=1.3",
     "node": ">=25"
+  },
+  "pi": {
+    "skills": "skills",
+    "extensions": ".pi-template/extensions"
   }
 }

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

@@ -13,6 +13,9 @@ import { join } from 'node:path'
 
 import { resolveJsRoot } from '../../../scripts/utils/resolve-js-root.mjs'
 
+const TEST_BLOCK_START = /^\s*(it|test)\(/
+const FILE_EXTENSION = /\.[^.]+$/
+
 /**
  * Чи `scripts` містить coverage-сумісну команду.
  * @param {Record<string, string> | undefined} scripts секція scripts з package.json
@@ -89,13 +92,15 @@ export function extractFirstTestBlock(content) {
   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
+  for (const [i, line] of lines.entries()) {
+    if (startLine === -1 && TEST_BLOCK_START.test(line)) 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--
+    result.push(line)
+    for (const ch of line) {
+      if (ch === '{') {
+        depth++
+        inBlock = true
+      } else if (ch === '}') depth--
     }
     if (inBlock && depth === 0) break
   }
@@ -110,7 +115,7 @@ export function extractFirstTestBlock(content) {
  * @returns {{testFile:string, code:string|null} | null} null — якщо тест-файл не знайдено
  */
 export function findExampleTest(jsRoot, filename) {
-  const base = filename.replace(/\.[^.]+$/, '')
+  const base = filename.replace(FILE_EXTENSION, '')
   const candidates = [`${base}.test.js`, `${base}.test.mjs`, `${base}.test.ts`]
   const lastSlash = base.lastIndexOf('/')
   if (lastSlash !== -1) {
@@ -131,9 +136,9 @@ export function findExampleTest(jsRoot, filename) {
  * Парс Stryker mutation.json: Killed+Timeout → caught; Survived+NoCoverage → до total.
  * Compile/Runtime errors виключаються з total.
  * Survived мутанти групуються по файлах з exampleTest.
- * @param {{files:Record<string,{mutants:Array<{status:string,mutatorName?:string,replacement?:string,location?:{start:{line:number,column:number},end:{line:number,column:number}}}>}>}} report
+ * @param {{files:Record<string,{mutants:Array<{status:string,mutatorName?:string,replacement?:string,location?:{start:{line:number,column:number},end:{line:number,column:number}}}>}>}} report Stryker mutation.json
  * @param {string|null} [jsRoot] корінь для читання source-рядків і пошуку тест-файлів
- * @returns {{caught:number,total:number,survived:Array<{file:string,mutants:Array<{line:number,col:number,mutantType:string,original:string,replacement:string}>,exampleTest:{testFile:string,code:string|null}|null,recommendationText:string|null}>}}
+ * @returns {{caught:number,total:number,survived:Array<{file:string,mutants:Array<{line:number,col:number,mutantType:string,original:string,replacement:string}>,exampleTest:{testFile:string,code:string|null}|null,recommendationText:string|null}>}} результат парсу: caught/total та згруповані survived мутанти
  */
 export function parseStrykerReport(report, jsRoot) {
   let caught = 0

package/rules/k8s/js/manifests.mjs

@@ -4245,7 +4245,7 @@ export function pdbManifestViolations(manifest, expectedAppLabel, isDevLike) {
 
 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),
+  statefulset: new URL('../policy/network_policy/template/statefulset.snippet.yaml', import.meta.url)
 }
 
 /** @type {Record<string, Record<string, unknown>>} */
@@ -4256,7 +4256,7 @@ const _snippetCache = {}
  * Кожен snippet — повний самодостатній канон NetworkPolicy для своєї групи workload-типів
  * (без merge між snippets у runtime).
  * @param {'deployment' | 'statefulset'} snippetName ім'я сніпету
- * @returns {{ podSelector?: Record<string, unknown>, policyTypes?: string[], ingress?: unknown[], egress?: unknown[] }}
+ * @returns {{ podSelector?: Record<string, unknown>, policyTypes?: string[], ingress?: unknown[], egress?: unknown[] }} розпарсений spec
  */
 export function loadSnippetSpec(snippetName) {
   if (_snippetCache[snippetName]) return _snippetCache[snippetName]
@@ -4277,13 +4277,13 @@ export const KIND_TO_SNIPPET = {
   Job: 'deployment',
   CronJob: 'deployment',
   DaemonSet: 'deployment',
-  StatefulSet: 'statefulset',
+  StatefulSet: 'statefulset'
 }
 
 /**
  * Обирає snippet name для конкретного workload-kind; throws на невідомий.
  * @param {string} kind workload-kind
- * @returns {'deployment' | 'statefulset'}
+ * @returns {'deployment' | 'statefulset'} snippet name
  */
 export function snippetNameForKind(kind) {
   const name = KIND_TO_SNIPPET[kind]
@@ -4294,27 +4294,64 @@ export function snippetNameForKind(kind) {
 /**
  * Читає deployment.snippet.yaml і повертає розпарсений spec.
  * @deprecated Використовуй loadSnippetSpec('deployment')
- * @returns {{ podSelector: Record<string, unknown>, policyTypes: string[], ingress: unknown[], egress: unknown[] }}
+ * @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` не падав.
+ * @param {string} msg повідомлення помилки
+ * @returns {string} той самий аргумент
+ */
+const noopFail = msg => msg
+
+/**
+ * `from`-peers для HTTPRoute-aware ingress-правила (GCP HC global + Envoy data-plane / proxy-only subnet).
+ * Порядок зафіксовано детерміністичним (HC-global → 10.0.0.0/8). Див. розділ «HTTPRoute → NetworkPolicy ingress» у k8s.mdc.
+ * @type {ReadonlyArray<{ ipBlock: { cidr: string } }>}
+ */
+const NETWORK_POLICY_GCLB_INGRESS_FROM = Object.freeze([
+  // eslint-disable-next-line sonarjs/no-hardcoded-ip
+  { ipBlock: { cidr: '35.191.0.0/16' } },
+  // eslint-disable-next-line sonarjs/no-hardcoded-ip
+  { ipBlock: { cidr: '130.211.0.0/22' } },
+  // eslint-disable-next-line sonarjs/no-hardcoded-ip
+  { ipBlock: { cidr: '10.0.0.0/8' } }
+])
+
 /**
  * Канонічний YAML **NetworkPolicy** для workload з іменем `deployName`, міткою `app` і типом `kind`.
  * Snippet обирається за `kind` через `KIND_TO_SNIPPET` (без merge — кожен snippet самодостатній).
  * Анотація `nitra.dev/workload-kind` додається, щоб rego диспатчив на правильний канон.
+ *
+ * Якщо `gclbPorts` непорожній — після canon ingress-правил додається одне ingress-правило
+ * з фіксованими CIDR-ами (GCP HC global + Envoy data-plane) і відсортованими унікальними TCP-портами
+ * (для HTTPRoute-paired workload-ів; див. `collectHttpRouteIngressForWorkload` і k8s.mdc).
  * @param {string} deployName `metadata.name` workload
  * @param {string} appLabel `spec.selector.matchLabels.app`
  * @param {string} kind `kind` workload (обовʼязковий: Deployment | StatefulSet | Job | CronJob | DaemonSet)
+ * @param {readonly number[]} [gclbPorts] TCP-порти з backendRefs HTTPRoute (опційно)
  * @returns {string} вміст `networkpolicy.yaml`
  */
-export function buildNetworkPolicyYaml(deployName, appLabel, kind) {
+export function buildNetworkPolicyYaml(deployName, appLabel, kind, gclbPorts) {
   const schemaUrl = `${YANNH_BASE}networkpolicy-networking-v1.json`
   const snippetName = snippetNameForKind(kind)
-  const spec = JSON.parse(JSON.stringify(loadSnippetSpec(snippetName)))
+  const spec = structuredClone(loadSnippetSpec(snippetName))
   spec.podSelector.matchLabels = { app: appLabel }
-  const specYaml = stringify(spec, { indent: 2 }).replaceAll(/^(?!$)/gm, '  ').trimEnd()
+  if (Array.isArray(gclbPorts) && gclbPorts.length > 0) {
+    const uniqueSorted = [...new Set(gclbPorts)].toSorted((a, b) => a - b)
+    const gclbRule = {
+      from: structuredClone(NETWORK_POLICY_GCLB_INGRESS_FROM),
+      ports: uniqueSorted.map(port => ({ protocol: 'TCP', port }))
+    }
+    spec.ingress = [...(spec.ingress ?? []), gclbRule]
+  }
+  const specYaml = stringify(spec, { indent: 2 })
+    .replaceAll(/^(?!$)/gm, '  ')
+    .trimEnd()
   return `# yaml-language-server: $schema=${schemaUrl}
 apiVersion: networking.k8s.io/v1
 kind: NetworkPolicy
@@ -4326,6 +4363,126 @@ spec:
 ${specYaml}`
 }
 
+/**
+ * Збирає унікальні TCP-порти з `HTTPRoute.backendRefs`, які адресують workload з міткою `appLabel`.
+ *
+ * Mapping: `backendRef.name` → `Service.metadata.name` у тому ж каталозі → `service.spec.selector.matchLabels.app === appLabel`.
+ * Використовується для побудови HTTPRoute-aware ingress-правила в NetworkPolicy (GCLB + Envoy data-plane CIDR-и; див. k8s.mdc).
+ * @param {string} dir абсолютний каталог
+ * @param {string} appLabel `spec.selector.matchLabels.app` цільового workload
+ * @param {(msg: string) => void} fail callback при read/parse-помилці YAML у каталозі
+ * @returns {Promise<{ ports: number[] } | null>} відсортовані унікальні TCP-порти або null, якщо HTTPRoute не вказує на цей workload
+ */
+export async function collectHttpRouteIngressForWorkload(dir, appLabel, fail) {
+  let entries
+  try {
+    entries = await readdir(dir, { withFileTypes: true })
+  } catch {
+    return null
+  }
+  const yamlFiles = entries
+    .filter(e => e.isFile() && (e.name.endsWith('.yaml') || e.name.endsWith('.yml')))
+    .map(e => join(dir, e.name))
+  if (yamlFiles.length === 0) return null
+
+  /** @type {Array<{ name: string, port: number }>} */
+  const allBackendRefs = []
+  /** @type {Map<string, string>} */
+  const servicesByName = new Map()
+
+  for (const abs of yamlFiles) {
+    let raw
+    try {
+      raw = await readFile(abs, 'utf8')
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error)
+      fail(`${abs}: не вдалося прочитати для GCLB ingress (HTTPRoute → NetworkPolicy mapping; k8s.mdc): ${msg}`)
+      continue
+    }
+    const lines = toLines(raw)
+    const body = lines.length > 0 && MODELINE_RE.test(lines[0]) ? yamlBodyAfterModeline(lines) : lines.join('\n')
+    /** @type {import('yaml').Document[]} */
+    let docs
+    try {
+      docs = parseAllDocuments(body)
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error)
+      fail(`${abs}: не вдалося розпарсити YAML для GCLB ingress (HTTPRoute → NetworkPolicy mapping; k8s.mdc): ${msg}`)
+      continue
+    }
+    for (const doc of docs) {
+      if (doc.errors.length > 0) {
+        fail(
+          `${abs}: YAML містить помилки для GCLB ingress (HTTPRoute → NetworkPolicy mapping; k8s.mdc): ${doc.errors[0].message}`
+        )
+        continue
+      }
+      const rec = asPlainRecord(doc.toJSON())
+      if (rec === null) continue
+      const av = rec.apiVersion
+      if (rec.kind === 'HTTPRoute' && typeof av === 'string' && av.startsWith(GATEWAY_API_GROUP_PREFIX)) {
+        collectHttpRouteBackendRefsInto(rec.spec, allBackendRefs)
+      } else if (rec.kind === 'Service') {
+        const name = manifestMetadataName(rec)
+        if (name !== null) {
+          const app = serviceSelectorAppLabel(rec.spec)
+          if (app !== null) servicesByName.set(name, app)
+        }
+      }
+    }
+  }
+
+  /** @type {Set<number>} */
+  const ports = new Set()
+  for (const { name, port } of allBackendRefs) {
+    const targetApp = servicesByName.get(name)
+    if (targetApp === appLabel) ports.add(port)
+  }
+  if (ports.size === 0) return null
+  return { ports: [...ports].toSorted((a, b) => a - b) }
+}
+
+/**
+ * Витягує мітку `app` з `Service.spec.selector.app` (плоский селектор, без `matchLabels`).
+ * Окремий helper від `appLabelFromSpecSelector` (той — для Deployment/StatefulSet, де `selector.matchLabels.app`).
+ * @param {unknown} spec значення `spec` Service
+ * @returns {string | null} мітка `app` або null
+ */
+function serviceSelectorAppLabel(spec) {
+  if (spec === null || spec === undefined || typeof spec !== 'object' || Array.isArray(spec)) return null
+  const selector = /** @type {Record<string, unknown>} */ (spec).selector
+  if (selector === null || selector === undefined || typeof selector !== 'object' || Array.isArray(selector)) return null
+  const app = /** @type {Record<string, unknown>} */ (selector).app
+  return typeof app === 'string' && app.trim() !== '' ? app : null
+}
+
+/**
+ * Обходить `spec` HTTPRoute (`spec.rules[*].backendRefs[*]`) і додає `(name, port)` у акумулятор.
+ * Дублює walk-логіку `collectGatewayApiRouteBackendServiceNames`, але зберігає `port` поруч з `name`.
+ * @param {unknown} spec значення `spec` маршруту
+ * @param {Array<{ name: string, port: number }>} out акумулятор
+ * @returns {void} результат
+ */
+function collectHttpRouteBackendRefsInto(spec, out) {
+  /**
+   * @param {unknown} node вузол для обходу
+   * @returns {void} результат
+   */
+  function walk(node) {
+    if (node === null || node === undefined) return
+    if (Array.isArray(node)) {
+      for (const x of node) walk(x)
+      return
+    }
+    if (typeof node !== 'object') return
+    if (isGatewayApiBackendRefToService(node)) {
+      const o = /** @type {Record<string, unknown>} */ (node)
+      out.push({ name: String(o.name), port: /** @type {number} */ (o.port) })
+    }
+    for (const v of Object.values(node)) walk(v)
+  }
+  walk(spec)
+}
 
 /**
  * Додає `resourceName` у `resources:` kustomization/Component YAML, якщо ще немає; сортує за алфавітом (en).
@@ -5094,12 +5251,12 @@ function validateNetworkPolicyForWorkload(npDocs, workloadName, appLabel, worklo
   }
   const spec = /** @type {Record<string, unknown>} */ (matchedNp).spec
   const foundLabel = networkPolicyPodSelectorAppLabel(spec)
-  if (foundLabel !== appLabel) {
+  if (foundLabel === appLabel) {
+    passFn(`${npRel}: NetworkPolicy для ${workloadKind} '${workloadName}' валідний (k8s.mdc)`)
+  } else {
     fail(
       `${npRel}: NetworkPolicy '${workloadName}' spec.podSelector.matchLabels.app='${foundLabel}' не відповідає мітці workload '${appLabel}' (k8s.mdc)`
     )
-  } else {
-    passFn(`${npRel}: NetworkPolicy для ${workloadKind} '${workloadName}' валідний (k8s.mdc)`)
   }
 }
 
@@ -6288,23 +6445,30 @@ async function existingNetworkPolicyNames(npAbs) {
 
 /**
  * Дописує відсутні NetworkPolicy-документи у `networkpolicy.yaml` (multi-doc через `---`).
+ * Перед побудовою YAML для кожного workload викликає `collectHttpRouteIngressForWorkload`,
+ * щоб додати GCLB-aware ingress-правило, якщо в каталозі є paired HTTPRoute (k8s.mdc).
  * @param {string} npAbs абсолютний шлях до файлу
  * @param {Array<{ name: string, appLabel: string, kind: string }>} toAdd workload-и без NP
  * @param {string} npRel відносний шлях для повідомлень
+ * @param {(msg: string) => void} fail callback при read/parse-помилках HTTPRoute/Service
  * @param {(msg: string) => void} passFn callback при успіху
  * @returns {Promise<void>} результат
  */
-async function appendNetworkPolicyDocuments(npAbs, toAdd, npRel, passFn) {
+async function appendNetworkPolicyDocuments(npAbs, toAdd, npRel, fail, passFn) {
   if (toAdd.length === 0) return
   let content = ''
   if (existsSync(npAbs)) {
     const raw = await readFile(npAbs, 'utf8')
     content = raw.trimEnd()
   }
-  const blocks = toAdd.map(({ name, appLabel, kind }, i) => {
-    const block = buildNetworkPolicyYaml(name, appLabel, kind)
-    return i === 0 && content === '' ? block.trimEnd() : stripYamlLanguageServerModeline(block).trimEnd()
-  })
+  const dir = dirname(npAbs)
+  const blocks = []
+  for (const [i, { name, appLabel, kind }] of toAdd.entries()) {
+    const gclb = await collectHttpRouteIngressForWorkload(dir, appLabel, fail)
+    const gclbPorts = gclb === null ? undefined : gclb.ports
+    const block = buildNetworkPolicyYaml(name, appLabel, kind, gclbPorts)
+    blocks.push(i === 0 && content === '' ? block.trimEnd() : stripYamlLanguageServerModeline(block).trimEnd())
+  }
   const joined = blocks.join('\n---\n')
   content = content === '' ? `${joined}\n` : `${content}\n---\n${joined}\n`
   await writeFile(npAbs, content, 'utf8')
@@ -6359,11 +6523,14 @@ function networkPolicyPodSelectorAppLabel(spec) {
 
 /**
  * Migrate legacy `networkpolicy.yaml`: якщо хоч один документ має catch-all in-cluster egress —
- * перезаписати **всі** документи у файлі через `buildNetworkPolicyYaml(name, appLabel)`. Деталі — k8s.mdc.
+ * перезаписати **всі** документи у файлі через `buildNetworkPolicyYaml(name, appLabel, kind, gclbPorts)`.
+ * `gclbPorts` витягуються з HTTPRoute paired у тому ж каталозі (див. `collectHttpRouteIngressForWorkload`).
+ * Деталі — k8s.mdc.
  * @param {string} npAbs абсолютний шлях до networkpolicy.yaml
+ * @param {(msg: string) => void} [fail] callback при read/parse-помилці HTTPRoute/Service (опційно — для backward compat)
  * @returns {Promise<boolean>} true якщо файл переписаний
  */
-export async function regenerateLegacyNetworkPolicyDocsInFile(npAbs) {
+export async function regenerateLegacyNetworkPolicyDocsInFile(npAbs, fail) {
   if (!existsSync(npAbs)) return false
   const docs = await readAllDocsByKindFromFile(npAbs, 'NetworkPolicy')
   if (docs.length === 0) return false
@@ -6379,20 +6546,27 @@ export async function regenerateLegacyNetworkPolicyDocsInFile(npAbs) {
     const spec = docRec.spec
     const appLabel = networkPolicyPodSelectorAppLabel(spec)
     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 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, kind }, i) => {
-    const block = buildNetworkPolicyYaml(name, appLabel, kind)
-    return i === 0 ? block.trimEnd() : stripYamlLanguageServerModeline(block).trimEnd()
-  })
+  const dir = dirname(npAbs)
+  const failCb = typeof fail === 'function' ? fail : noopFail
+  const blocks = []
+  for (const [i, { name, appLabel, kind }] of specs.entries()) {
+    const gclb = await collectHttpRouteIngressForWorkload(dir, appLabel, failCb)
+    const gclbPorts = gclb === null ? undefined : gclb.ports
+    const block = buildNetworkPolicyYaml(name, appLabel, kind, gclbPorts)
+    blocks.push(i === 0 ? block.trimEnd() : stripYamlLanguageServerModeline(block).trimEnd())
+  }
   await writeFile(npAbs, `${blocks.join('\n---\n')}\n`, 'utf8')
   return true
 }
@@ -6412,7 +6586,7 @@ async function ensureNetworkPoliciesForWorkloadsInDir(dir, workloads, rootNorm,
   const npAbs = join(dir, NETWORK_POLICY_FILENAME)
   const npRel = (relative(rootNorm, npAbs) || npAbs).replaceAll('\\', '/')
   if (existsSync(npAbs)) {
-    const migrated = await regenerateLegacyNetworkPolicyDocsInFile(npAbs)
+    const migrated = await regenerateLegacyNetworkPolicyDocsInFile(npAbs, fail)
     if (migrated) {
       passFn(`${npRel}: міграція legacy catch-all egress → канон з явними in-cluster портами (k8s.mdc)`)
     }
@@ -6431,7 +6605,7 @@ async function ensureNetworkPoliciesForWorkloadsInDir(dir, workloads, rootNorm,
   }
   if (toAdd.length === 0) return
   try {
-    await appendNetworkPolicyDocuments(npAbs, toAdd, npRel, passFn)
+    await appendNetworkPolicyDocuments(npAbs, toAdd, npRel, fail, passFn)
     const kustAbs = join(dir, 'kustomization.yaml')
     if (existsSync(kustAbs)) {
       const raw = await readFile(kustAbs, 'utf8')
@@ -6572,8 +6746,8 @@ function runAllK8sRego(root, yamlFiles, fail) {
       files: allYaml,
       templateData: {
         deployment_snippet: loadSnippetSpec('deployment'),
-        statefulset_snippet: loadSnippetSpec('statefulset'),
-      },
+        statefulset_snippet: loadSnippetSpec('statefulset')
+      }
     },
     { ns: 'k8s.kustomization', dir: 'k8s/kustomization', files: kustYaml },
     { ns: 'k8s.svc_yaml', dir: 'k8s/svc_yaml', files: svcYaml },
@@ -6584,7 +6758,12 @@ 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, templateData: t.templateData })
+    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

@@ -1,6 +1,6 @@
 ---
 description: K8s YAML — $schema (yaml-language-server); lint-k8s (kubeconform, kubescape); check-k8s
-version: '1.41'
+version: '1.42'
 globs: "**/k8s/**/*.yaml"
 alwaysApply: false
 ---
@@ -414,6 +414,34 @@ images:
 
 **Порядок `resources`:** у маніфесті з **`apiVersion: kustomize.config.k8s.io/…`**, **`kind: Kustomization`**, елементи **`resources:`** (лише непорожні рядки) мають бути **відсортовані за алфавітом (англ. локаль, як `localeCompare('en')` у `rules/k8s/fix.mjs`)**. Поля **`bases`**, **`components`**, **`crds`** цією перевіркою **не** впорядковуються.
 
+### HTTPRoute → NetworkPolicy ingress (GCLB + Envoy)
+
+Якщо в каталозі workload є **`HTTPRoute`** (Gateway API; `apiVersion: gateway.networking.k8s.io/*`) з **`backendRef`** на **`<workload>-hl`** Service (mapping через `service.spec.selector.app`), **`check k8s`** автоматично додає в NetworkPolicy цього workload **ingress-правило** з фіксованим набором CIDR-ів і **TCP-портами з `backendRefs[].port`** (дедуп, відсортовано за зростанням).
+
+Без цього правила трафік від **GKE Gateway** (Envoy data-plane з proxy-only subnet регіону, наприклад `us-central1-proxy-only` = `10.10.0.0/23`) і **Google health checks** (`35.191.0.0/16`, `130.211.0.0/22`) блокується базовим NetworkPolicy (бо canon ingress допускає тільки `podSelector: {}` — intra-namespace pod ↔ pod).
+
+CIDR-набір зафіксовано (без конфігурації):
+
+- `35.191.0.0/16` — GCP HC global
+- `130.211.0.0/22` — GCP HC global (legacy)
+- `10.0.0.0/8` — широкий range, покриває proxy-only subnets усіх регіонів GKE
+
+Приклад згенерованого ingress-правила (поверх baseline canon):
+
+```yaml
+ingress:
+  - from:
+      - podSelector: {}
+  - from:
+      - ipBlock: { cidr: 35.191.0.0/16 }
+      - ipBlock: { cidr: 130.211.0.0/22 }
+      - ipBlock: { cidr: 10.0.0.0/8 }
+    ports:
+      - { protocol: TCP, port: 8080 }
+```
+
+Якщо workload не прив'язаний до жодного HTTPRoute — правило **не** додається; NP лишається baseline (intra-namespace + canon egress). Не-HTTP routes (`GRPCRoute`, `TCPRoute`, `TLSRoute`, `UDPRoute`) поки не покриті — додається лише за HTTPRoute. Алгоритм: функція `collectHttpRouteIngressForWorkload` у **`rules/k8s/js/manifests.mjs`** індексує `HTTPRoute.backendRefs` і `Service` у каталозі, резолвить через `selector.app`, дедуп TCP-портів. Виклики — з `appendNetworkPolicyDocuments` і `regenerateLegacyNetworkPolicyDocsInFile`.
+
 ### Env-залежні межі (за сегментом після `/k8s/`)
 
 **Dev-like середовища** — сегмент `base`, `dev`, або з суфіксом `-qa` (напр. `tr-qa`):
@@ -554,6 +582,34 @@ spec:
           port: 4318
 ```
 
+```yaml title="k8s/base/networkpolicy.yaml — workload з HTTPRoute (з GCLB ingress)"
+# yaml-language-server: $schema=https://raw.githubusercontent.com/yannh/kubernetes-json-schema/master/v1.33.9-standalone-strict/networkpolicy-networking-v1.json
+apiVersion: networking.k8s.io/v1
+kind: NetworkPolicy
+metadata:
+  name: backend-api
+  annotations:
+    nitra.dev/workload-kind: Deployment
+spec:
+  podSelector:
+    matchLabels:
+      app: backend-api
+  policyTypes:
+    - Ingress
+    - Egress
+  ingress:
+    - from:
+        - podSelector: {}
+    - from: # auto-added by check k8s for HTTPRoute-paired workloads
+        - ipBlock: { cidr: 35.191.0.0/16 }
+        - ipBlock: { cidr: 130.211.0.0/22 }
+        - ipBlock: { cidr: 10.0.0.0/8 }
+      ports:
+        - { protocol: TCP, port: 8080 }
+  egress:
+    # ... (ідентично до базового прикладу вище)
+```
+
 ```yaml title="k8s/components/hpa.yaml"
 # yaml-language-server: $schema=https://raw.githubusercontent.com/yannh/kubernetes-json-schema/master/v1.33.9-standalone-strict/horizontalpodautoscaler-autoscaling-v2.json
 apiVersion: autoscaling/v2

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

@@ -72,31 +72,13 @@ deny contains "spec.ingress має містити from.podSelector (NetworkPolic
 	not ingress_has_pod_selector_rule(spec)
 }
 
-# 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"
-}
-
-snippet_name_for_kind("StatefulSet") := "statefulset"
-
-snippet_name_for_kind(kind) := "deployment" if {
-	kind != "StatefulSet"
-}
-
-workload_kind := kind if {
-	kind := object.get(object.get(input.metadata, "annotations", {}), "nitra.dev/workload-kind", "")
-}
-
 # Superset-check egress: кожне канонічне правило має бути в input.spec.egress.
 deny contains msg if {
 	is_np_doc
 	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)
+	not contains_item(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)],
@@ -109,7 +91,7 @@ deny contains msg if {
 	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)
+	not contains_item(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)],
@@ -124,6 +106,22 @@ deny contains "spec.egress: заборонено allow-all {} — додавай
 	count(object.keys(rule)) == 0
 }
 
+# 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"
+}
+
+snippet_name_for_kind("StatefulSet") := "statefulset"
+
+snippet_name_for_kind(kind) := "deployment" if {
+	kind != "StatefulSet"
+}
+
+workload_kind := object.get(object.get(input.metadata, "annotations", {}), "nitra.dev/workload-kind", "")
+
 is_np_doc if input.kind == "NetworkPolicy"
 
 is_np_doc if startswith(object.get(input, "apiVersion", ""), "networking.k8s.io/")
@@ -146,8 +144,8 @@ ingress_has_pod_selector_rule(spec) if {
 	object.get(peer, "podSelector", null) != null
 }
 
-list_contains(items, item) if {
+contains_item(items, item) if {
 	is_array(items)
-	some i
-	items[i] == item
+	some candidate in items
+	candidate == item
 }

package/rules/test/coverage/coverage.mjs

@@ -92,23 +92,15 @@ export function renderMarkdown(rows) {
 
   const allSurvived = rows.flatMap(r => r.survived ?? [])
   if (allSurvived.length > 0) {
-    lines.push('', '## Вижилі мутанти')
-    // JSON-блок для /n-fix-tests skill — парситься скілом для написання тестів
-    lines.push('', '```json')
-    lines.push(JSON.stringify(allSurvived, null, 2))
-    lines.push('```')
+    lines.push('', '## Вижилі мутанти', '', '```json', JSON.stringify(allSurvived, null, 2), '```')
     // Людиночитабельна таблиця
     for (const group of allSurvived) {
-      lines.push('', `### ${group.file}`, '')
-      lines.push('| Рядок | Оригінал | Заміна | Тип |')
-      lines.push('| --- | --- | --- | --- |')
+      lines.push('', `### ${group.file}`, '', '| Рядок | Оригінал | Заміна | Тип |', '| --- | --- | --- | --- |')
       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('```')
+        lines.push('', `**Приклад тесту** (\`${group.exampleTest.testFile}\`):`, '', '```js', group.exampleTest.code ?? '', '```')
       }
       if (group.recommendationText) {
         lines.push('', '**Що треба протестувати:**', '', group.recommendationText)
@@ -189,9 +181,7 @@ export async function runCoverageSteps(opts = {}) {
   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
-    )
+    const { fixSurvivedMutants } = await import(new URL('../../scripts/coverage-fix.mjs', import.meta.url).href)
     await fixSurvivedMutants(allSurvived, cwd)
   }
 

package/rules/test/js/cargo_mutants_config.mjs

@@ -42,9 +42,7 @@ export async function check() {
   }
 
   if (!existsSync(BASELINE_PATH)) {
-    reporter.fail(
-      `.cargo/mutants.toml canonical baseline не знайдено (${BASELINE_PATH}) — перевстанови @nitra/cursor`
-    )
+    reporter.fail(`.cargo/mutants.toml canonical baseline не знайдено (${BASELINE_PATH}) — перевстанови @nitra/cursor`)
     return reporter.getExitCode()
   }
 

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

@@ -11,5 +11,5 @@ export default {
   coverageAnalysis: 'off',
   // incremental: зберігає результати між запусками, відновлює після краш/kill.
   incremental: true,
-  incrementalFile: 'reports/stryker/incremental.json',
+  incrementalFile: 'reports/stryker/incremental.json'
 }

package/rules/test/js/stryker_config.mjs

@@ -49,9 +49,7 @@ export async function check() {
   }
 
   if (!existsSync(BASELINE_PATH)) {
-    reporter.fail(
-      `stryker.config.mjs canonical baseline не знайдено (${BASELINE_PATH}) — перевстанови @nitra/cursor`
-    )
+    reporter.fail(`stryker.config.mjs canonical baseline не знайдено (${BASELINE_PATH}) — перевстанови @nitra/cursor`)
     return reporter.getExitCode()
   }
 

package/scripts/coverage-fix.mjs

@@ -39,7 +39,7 @@ export async function fixSurvivedMutants(survived, projectRoot) {
     options: {
       cwd: projectRoot,
       maxTurns: 20,
-      allowedTools: ['Read', 'Edit', 'Bash'],
+      allowedTools: ['Read', 'Edit', 'Bash']
     }
   })) {
     if (msg.type === 'text') process.stdout.write(msg.text)
@@ -50,9 +50,9 @@ export async function fixSurvivedMutants(survived, projectRoot) {
 /**
  * Формує rich-промпт для агента: список вижилих мутантів згрупований по файлах,
  * з контекстом ±3 рядки навколо кожного мутанта з source-файлу.
- * @param {SurvivedFileGroup[]} survived
- * @param {string} projectRoot
- * @returns {Promise<string>}
+ * @param {SurvivedFileGroup[]} survived групи вижилих мутантів по файлах
+ * @param {string} projectRoot корінь проєкту
+ * @returns {Promise<string>} текст rich-промпту
  */
 async function buildFixPrompt(survived, projectRoot) {
   const sections = []
@@ -60,25 +60,30 @@ async function buildFixPrompt(survived, projectRoot) {
   for (const { file, mutants, exampleTest } of survived) {
     let srcLines = []
     try {
-      srcLines = (await readFile(join(projectRoot, file), 'utf8')).split('\n')
+      const src = await readFile(join(projectRoot, file), 'utf8')
+      srcLines = src.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 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\`\`\``

package/scripts/lib/timing-summary.mjs

@@ -58,9 +58,6 @@ export function formatTimingSummary(title, timings) {
     const failMark = ok ? '' : '  ❌'
     lines.push(`   ${id.padEnd(idWidth)}  ${formatDurationMs(ms)}${failMark}`)
   }
-  lines.push(
-    `   ${RULER.repeat(idWidth + 2 + 6)}`,
-    `   ${'total'.padEnd(idWidth)}  ${formatDurationMs(totalMs)}`
-  )
+  lines.push(`   ${RULER.repeat(idWidth + 2 + 6)}`, `   ${'total'.padEnd(idWidth)}  ${formatDurationMs(totalMs)}`)
   return `${lines.join('\n')}\n`
 }

package/scripts/post-tool-use-fix.mjs

@@ -104,7 +104,7 @@ function extractFilePath(stdinJson) {
  * Точка входу. Викликається з `bin/n-cursor.js` коли argv[0] === `post-tool-use-fix`.
  * Параметри ін'єктовні для тестів: `stdinJson` обходить read від `process.stdin`,
  * `spawnFn` — заміна `node:child_process.spawn` (повертає EventEmitter-сумісний об'єкт).
- * @param {{ stdinJson?: string, spawnFn?: typeof spawn }} [options]
+ * @param {{ stdinJson?: string, spawnFn?: typeof spawn }} [options] параметри для тестів (ін'єкція stdin/spawn)
  * @returns {Promise<number>} exit code (0 — пропущено / fix ОК; інше — exit-код `fix`)
  */
 export async function runPostToolUseFixCli(options = {}) {

package/scripts/sync-claude-config.mjs

@@ -502,7 +502,6 @@ export async function syncPiExtensions(projectRoot, bundledPackageRoot) {
  * Видаляє `.pi/extensions/n-cursor-adr/` директорію з проєкту-споживача.
  * Викликається коли правило `adr` вимкнено у `.n-cursor.json` (симетрично до
  * cleanup-у `.claude/hooks/{capture,normalize}-decisions.sh`).
- *
  * @param {string} projectRoot корінь проєкту-споживача
  * @returns {Promise<{ removed: boolean, path: string }>} чи було щось видалено та відносний шлях
  */

package/skills/fix-tests/SKILL.md

@@ -32,10 +32,12 @@ description: >-
 Прочитай `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`
 
@@ -107,6 +109,7 @@ bun run coverage  # або coverage-команда з кроку 2
 `newCount = новий масив.length`
 
 **Рішення:**
+
 - Якщо `newCount < prevCount` → повтор з Кроку 1 з оновленим масивом
 - Якщо `newCount >= prevCount` → зупинись:
   `✓ Конвергенція: mutation score більше не покращується. Вижило: <newCount> мутантів.`