@nitra/cursor 1.8.199 → 1.8.201

package/CHANGELOG.md

@@ -4,6 +4,28 @@
 
 Формат — [Keep a Changelog](https://keepachangelog.com/uk/1.1.0/), нумерація — [SemVer](https://semver.org/lang/uk/).
 
+## [1.8.201] - 2026-05-07
+
+### Changed
+
+- `check-hasura.mjs`: `INTERNAL_HASURA_URL_RE` тепер приймає **обидва** кластерні DNS-суфікси у `HASURA_GRAPHQL_ENDPOINT` — `<cluster>.internal` (GKE/GCP, наприклад `abie-dev` / `abie-ua`) **і** `cluster.local` (стандартний k8s / Yandex Cloud). Раніше regex вимагав літеральний `.internal` у кінці, тож URL виду `http://apruv-h-hl.ru-apruv.svc.cluster.local:8080` (типовий для YC-кластера ru) помилково відхилявся. `parseInternalHasuraEndpoint` для YC повертає `cluster: 'cluster.local'` як повний суфікс, для GKE — ім'я кластера без `.internal` (зворотньо сумісно з попередньою поведінкою). Текст помилки в `checkEnvFile` оновлено — згадує обидва допустимі формати.
+- `abie.mdc` (v1.17 → v1.19): нова секція «Внутрішньокластерні URL у env-файлах (dev / ua / ru)». Правило стосується **будь-якого** internal URL у env-файлах abie-проєкту — не лише `HASURA_GRAPHQL_ENDPOINT`, а й KVCMS, `auth-run-hl`, `file-link-hl` тощо. Таблиця `dev.env` / `ua.env` / `ru.env` → namespace-префікс + DNS-суфікс кластера (dev → `abie-dev.internal` + `dev-…`, ua → `abie-ua.internal` + `ua-…`, ru → `cluster.local` + `ru-…`); приклади з двома сервісами в одному файлі (Hasura + KVCMS). Загальне правило про **внутрішній** URL замість публічного домену для `HASURA_GRAPHQL_ENDPOINT` лишається у `hasura.mdc` (для nitra та abie).
+
+### Added
+
+- `check-abie.mjs`: новий валідатор `validateAbieEnvInternalUrls` (`String.prototype.matchAll` за `ABIE_INTERNAL_URL_GLOBAL_RE`) і helper `abieEnvNameFromBasename`. У функції `check()` додано крок `ensureAbieEnvFilesMatchClusterDns`, що сканує всі `*.env`-файли (basename `dev.env` / `ua.env` / `ru.env` опційно з провідною крапкою; `.env` без імені пропускається — як у `check-hasura.mjs`) і для **кожного** знайденого URL виду `http://<svc>.<ns>.svc.<dns>` перевіряє відповідність DNS-суфікса й namespace-префікса середовищу env-файла. Помилки додаються через `fail`, без зупинки на першому файлі — звіт показує всі порушення в усіх env-файлах одразу.
+- `tests/check-hasura.test.mjs`: тести `parseInternalHasuraEndpoint` для GKE-style `abie-dev.internal` / `abie-ua.internal` та YC-style `cluster.local`; негативний кейс на сторонній суфікс (`svc.example.com`); інтеграційний тест `check()` для `hasura/.ru.env` з `cluster.local`.
+- `tests/check-abie.test.mjs`: 7 unit-тестів на `abieEnvNameFromBasename` і `validateAbieEnvInternalUrls` (узгоджений dev/ua/ru, URL без порту, dev URL у ua-файлі, internal-суфікс у ru-файлі, ігнорування зовнішніх `https://` / `localhost`, кілька URL з різними порушеннями) і 4 інтеграційні (`.dev.env`+`.ua.env`+`.ru.env` узгоджені — 0; ua з dev URL у KVCMS — 1; ru з `.internal` замість `cluster.local` — 1; `.env` без імені пропускається).
+
+## [1.8.200] - 2026-05-07
+
+### Added
+
+- `policy/ga/clean-ga-workflows.rego` + новий PoC-крок у `scripts/lint-ga.mjs`: запускає `conftest test` на `.github/workflows/clean-ga-workflows.yml` проти Rego-полісі (структура `name` / `on` / `concurrency` / `jobs.cleanup_old_workflows.steps[0]`). Якщо `conftest` не в PATH — `ℹ` skip без помилки (паралельні JS-перевірки в `check-ga.mjs` залишаються джерелом істини). Додав `policy` у `files` пакету.
+- `check-k8s.mjs`: структурний сорт `patches[]` у `kustomization.yaml` за tuple `[target.kind, target.name, target.namespace, path]` (`localeCompare('en', base)`); поля `target.group` / `target.version` у tuple не входять (діє правило «patches[].target: лише kind і name»). Додатково: вміст inline `patches[i].patch` (literal block scalar — масив JSON6902) сортується за `path`, **але лише** коли всі ops — `add` / `replace` і всі `path` попарно дизʼюнктні (жоден не префікс іншого) — інакше порядок не чіпається, бо `move` / `copy` / `test` / `remove` чи спільні шляхи семантично залежні (RFC 6902). Експортовані чисті валідатори: `kustomizationPatchesSortedViolation`, `kustomizationInlinePatchOpsSortedViolation`.
+- `tests/check-k8s-schema.test.mjs`: тести на обидва нові валідатори (приклад із `k8s.mdc`: `ReferenceGrant atlas/apruv` → `apruv/atlas`; `add /spec/minReplicas` + `replace /spec/maxReplicas` → пересорт за `path`; пропуск для `test` / `move` / `copy` / `remove` і недизʼюнктних шляхів типу `/spec` vs `/spec/template`).
+- `mdc/k8s.mdc`: розділ «Структурний сорт `patches[]` і inline JSON6902» з обома прикладами «❌/✅».
+
 ## [1.8.199] - 2026-05-07
 
 ### Added

package/mdc/abie.mdc

@@ -1,7 +1,7 @@
 ---
 description: Правила для проєктів AbInBev Efes
 alwaysApply: true
-version: '1.17'
+version: '1.19'
 ---
 
 Правило **abie** для споживачів **@nitra/cursor**: **k8s** (Deployment + **HealthCheckPolicy** у **`hc.yaml`**, overlay **ua** / **ru** — **nodeSelector**, **HTTPRoute** (будь-який непорожній **`target.name`**, для спільних сервісів **`auth-run-hl`** / **`file-link-hl`** — **`namespace: dev`** у base та patch **`…/backendRefs/…/namespace`** у **ua** / **ru**), у overlay **ru** — кожен **Service** (у т. ч. **headless** / **`-hl`**) → **`spec.type: NodePort`** через **JSON6902** у **`kustomization.yaml`**, видалення **HealthCheckPolicy** у **ru**), гілки **dev**, **ua**, **ru** у **clean-merged-branch**, а також заборона тримати артефакти **Firebase Hosting** у **підкаталогах першого рівня** (безпосередні діти кореня репозиторію; у самому корені ці імена не вимагаються до видалення).
@@ -332,6 +332,46 @@ spec:
         preem: 'true' # буде замінено через kustomize
 ```
 
+## Внутрішньокластерні URL у env-файлах (dev / ua / ru)
+
+Правило стосується **будь-якого** внутрішньокластерного URL у env-файлах abie-проєкту, а не лише `HASURA_GRAPHQL_ENDPOINT`. Це може бути URL до Hasura, KVCMS, `auth-run-hl`, `file-link-hl` чи будь-якого іншого Service у кластері — у всіх випадках DNS-суфікс і namespace-префікс мають відповідати **середовищу** з імені env-файлу.
+
+abie-проєкти живуть у **трьох різних кластерах** (dev / ua у GKE, ru у Yandex Cloud), тож DNS-суфікс і namespace у URL відрізняються між `*.env`-файлами:
+
+| env-файл (basename) | namespace-префікс у URL | DNS-суфікс кластера | примітка |
+| --- | --- | --- | --- |
+| `dev.env`, `.dev.env` | `dev-…` | `abie-dev.internal` | GKE-кластер dev |
+| `ua.env`, `.ua.env` | `ua-…` | `abie-ua.internal` | GKE-кластер ua |
+| `ru.env`, `.ru.env` | `ru-…` | `cluster.local` | YC-кластер ru, стандартний k8s DNS |
+
+Канонічна форма URL — `http://<service>.<namespace>.svc.<cluster-dns-suffix>:<port>`. Для GKE (dev / ua) суфікс — `<cluster>.internal`; для YC (ru) — фіксований `cluster.local` (у YC у DNS сервісу немає окремого імені кластера).
+
+Приклади для одного env-файлу з двома сервісами (Hasura + KVCMS):
+
+```env title="hasura/.dev.env"
+HASURA_GRAPHQL_ENDPOINT=http://apruv-h-hl.dev-apruv.svc.abie-dev.internal:8080
+KVCMS_URL=http://kvcms-hl.dev-apruv.svc.abie-dev.internal:8080
+```
+
+```env title="hasura/.ua.env"
+HASURA_GRAPHQL_ENDPOINT=http://apruv-h-hl.ua-apruv.svc.abie-ua.internal:8080
+KVCMS_URL=http://kvcms-hl.ua-apruv.svc.abie-ua.internal:8080
+```
+
+```env title="hasura/.ru.env"
+HASURA_GRAPHQL_ENDPOINT=http://apruv-h-hl.ru-apruv.svc.cluster.local:8080
+KVCMS_URL=http://kvcms-hl.ru-apruv.svc.cluster.local:8080
+```
+
+`<namespace>` (наприклад `dev-apruv` / `ua-apruv` / `ru-apruv`) — `metadata.name` цільового namespace після kustomize-overlay для відповідного середовища; `<service>` — `metadata.name` headless Service (`-hl`) того сервісу, до якого йде URL.
+
+**Перевірка `check-abie.mjs`** сканує всі `*.env` файли, basename яких збігається з `dev.env` / `ua.env` / `ru.env` (з провідною крапкою чи без), знаходить **усі** internal URL (`http://<svc>.<ns>.svc.<dns>` — як для Hasura-ендпоінта, так і для KVCMS чи будь-якого іншого) і вимагає, щоб для кожного:
+
+- DNS-суфікс відповідав env: `abie-dev.internal` / `abie-ua.internal` / `cluster.local`;
+- namespace починався з `dev-` / `ua-` / `ru-` відповідно.
+
+Загальне правило про **внутрішній** URL (не публічний домен) для `HASURA_GRAPHQL_ENDPOINT` лишається у **`hasura.mdc`** (для nitra і abie) — `check-hasura.mjs` приймає обидва кластерні DNS-формати (`<cluster>.internal` і `cluster.local`).
+
 ## Firebase Hosting
 
 У **кожному** підкаталозі, що лежить **безпосередньо** в корені репозиторію, не тримати конфіг і кеш **Firebase Hosting**: у таких каталогах не повинно бути **`.firebaserc`**, **`firebase.json`** та каталогу **`.firebase/`** (у **самому** корені репозиторію ці імена перевіркою abie **не** розглядаються; `node_modules` / `.git` зі скану вилучаються).

package/mdc/k8s.mdc

@@ -531,6 +531,52 @@ patches:
 
 **Виняток:** залишай `group` / `version`, лише якщо в дереві overlay реально співіснують ресурси з однаковими `kind`+`name`, але різними API-групами/версіями (наприклад, дві CRD з одним `kind`). У такому разі вкажи мінімальний набір полів, потрібний для дисамбігуації.
 
+### Структурний сорт `patches[]` і inline JSON6902
+
+`patches[]` у `kustomization.yaml` має бути відсортовано за tuple **`target.kind` → `target.name` → `target.namespace` → `path`** (`localeCompare('en', { sensitivity: 'base' })`). Це робить діфи передбачуваними і прибирає «гойдання» порядку при додаванні нових цілей. Поля `target.group` / `target.version` у tuple не входять — для них діє правило «patches[].target: лише kind і name».
+
+```yaml
+# ❌ atlas йде перед apruv
+patches:
+  - target:
+      kind: ReferenceGrant
+      name: atlas-to-base
+  - target:
+      kind: ReferenceGrant
+      name: apruv-to-base
+
+# ✅
+patches:
+  - target:
+      kind: ReferenceGrant
+      name: apruv-to-base
+  - target:
+      kind: ReferenceGrant
+      name: atlas-to-base
+```
+
+Усередині кожного inline `patches[i].patch` (literal block scalar — масив JSON6902-операцій) операції теж сортуються за **`path`**, **але лише** коли набір «безпечний»: усі ops — `add` / `replace` і всі `path` попарно дизʼюнктні (жоден не префікс іншого, наприклад `/spec` і `/spec/replicas`). Інакше порядок не чіпається — у `move` / `copy` / `test` / `remove` чи на спільних шляхах послідовність ops семантично значуща (RFC 6902), і пересорт ламає логіку.
+
+```yaml
+# ❌ minReplicas перед maxReplicas (за алфавітом max < min)
+patch: |-
+  - op: add
+    path: /spec/minReplicas
+    value: 2
+  - op: replace
+    path: /spec/maxReplicas
+    value: 10
+
+# ✅
+patch: |-
+  - op: replace
+    path: /spec/maxReplicas
+    value: 10
+  - op: add
+    path: /spec/minReplicas
+    value: 2
+```
+
 ## Перевірка
 
 **`npx @nitra/cursor check k8s`** — програмні критерії в **JSDoc на початку** **`npm/scripts/check-k8s.mjs`**. Якщо під **`k8s`** немає **`*.yaml`** — крок пропущено. Канон **`$schema`** для редактора — розділ **«Визначення схеми YAML`** нижче.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nitra/cursor",
-  "version": "1.8.199",
+  "version": "1.8.201",
   "description": "CLI для завантаження cursor-правил (префікс n-) у локальний репозиторій",
   "keywords": [
     "cli",
@@ -27,6 +27,7 @@
     "mdc",
     "bin",
     "github-actions",
+    "policy",
     "schemas",
     "scripts",
     "skills",

package/policy/ga/clean-ga-workflows.rego

@@ -0,0 +1,133 @@
+# PoC-порт перевірки `validateCleanGaWorkflows` з `npm/scripts/check-ga.mjs`.
+#
+# Запуск (локально):
+#   conftest test .github/workflows/clean-ga-workflows.yml -p npm/policy/ga
+#
+# Conftest читає YAML і дає його в `input`. Кожне правило `deny contains msg if { … }`,
+# що матчиться, друкується як порушення; пустий список — exit 0.
+#
+# Rego v1 синтаксис (OPA 1.x за замовчуванням; `import rego.v1` робить файл портованим
+# і на старі OPA 0.x): `contains` для partial set rules, `if` перед тілом правила.
+package main
+
+import rego.v1
+
+# GHA YAML quirk: ключ `on:` парситься як YAML 1.1 boolean `true`, після чого conftest
+# серіалізує його в Rego-input як рядок `"true"`. Тому `input.on` / `input["on"]` /
+# `input[true]` всі недоступні; реальний шлях — `input["true"]`. Виносимо в alias, щоб
+# решта правил читалася як `gha_on.schedule` без бойлерплейту.
+gha_on := input["true"]
+
+# `${{ … }}` — це шаблонний синтаксис GitHub Actions, але `{{` у Rego починає
+# string interpolation. Збираємо очікувані рядки з фрагментів, як це зроблено в
+# check-ga.mjs, щоб і Rego-парсер, і людина-читач не плуталися.
+expected_concurrency_group := concat("", ["$", "{{ github.ref }}-$", "{{ github.workflow }}"])
+
+expected_github_token := concat("", ["$", "{{ github.token }}"])
+
+expected_name := "Clean action for removing completed workflow runs"
+
+expected_cron := "0 1 16 * *"
+
+# --- name --------------------------------------------------------------------
+
+deny contains msg if {
+	input.name != expected_name
+	msg := sprintf("clean-ga-workflows.yml: name має бути %q (ga.mdc)", [expected_name])
+}
+
+# --- on.schedule.cron --------------------------------------------------------
+
+deny contains msg if {
+	not has_expected_cron
+	msg := sprintf("clean-ga-workflows.yml: on.schedule має містити cron: '%s' (ga.mdc)", [expected_cron])
+}
+
+has_expected_cron if {
+	gha_on.schedule[_].cron == expected_cron
+}
+
+# --- on.workflow_dispatch ----------------------------------------------------
+
+deny contains msg if {
+	not has_workflow_dispatch
+	msg := "clean-ga-workflows.yml: має бути workflow_dispatch: {} (ga.mdc)"
+}
+
+has_workflow_dispatch if {
+	is_object(gha_on.workflow_dispatch)
+}
+
+# --- concurrency -------------------------------------------------------------
+
+deny contains msg if {
+	not is_object(input.concurrency)
+	msg := sprintf(
+		"clean-ga-workflows.yml: відсутня секція concurrency — додай concurrency.group: %s і cancel-in-progress: true (ga.mdc)",
+		[expected_concurrency_group],
+	)
+}
+
+deny contains msg if {
+	is_object(input.concurrency)
+	input.concurrency.group != expected_concurrency_group
+	msg := sprintf("clean-ga-workflows.yml: concurrency.group має бути %s (ga.mdc)", [expected_concurrency_group])
+}
+
+deny contains msg if {
+	is_object(input.concurrency)
+	input.concurrency["cancel-in-progress"] != true
+	msg := "clean-ga-workflows.yml: concurrency.cancel-in-progress має бути true (ga.mdc)"
+}
+
+# --- jobs.cleanup_old_workflows ---------------------------------------------
+
+deny contains msg if {
+	not input.jobs.cleanup_old_workflows
+	msg := "clean-ga-workflows.yml: jobs.cleanup_old_workflows відсутній (ga.mdc)"
+}
+
+deny contains msg if {
+	job := input.jobs.cleanup_old_workflows
+	job["runs-on"] != "ubuntu-latest"
+	msg := "clean-ga-workflows.yml: runs-on має бути ubuntu-latest (ga.mdc)"
+}
+
+deny contains msg if {
+	perms := input.jobs.cleanup_old_workflows.permissions
+	not actions_write_contents_read(perms)
+	msg := "clean-ga-workflows.yml: permissions мають бути actions: write, contents: read (ga.mdc)"
+}
+
+actions_write_contents_read(perms) if {
+	perms.actions == "write"
+	perms.contents == "read"
+}
+
+# --- jobs.cleanup_old_workflows.steps[0] ------------------------------------
+
+step0 := input.jobs.cleanup_old_workflows.steps[0]
+
+deny contains msg if {
+	step0.name != "Delete workflow runs"
+	msg := "clean-ga-workflows.yml: перший крок має мати name: Delete workflow runs (ga.mdc)"
+}
+
+deny contains msg if {
+	step0.uses != "dmvict/clean-workflow-runs@v1"
+	msg := "clean-ga-workflows.yml: перший крок має uses: dmvict/clean-workflow-runs@v1 (ga.mdc)"
+}
+
+# Триплет полів `with`: token (gh-токен), save_period=31, save_min_runs_number=0.
+# В JS-перевірці помилка спільна для всіх трьох — лишаємо такий самий формат, щоб
+# повідомлення збігалися. Окремі правила нижче роблять діагноз точнішим.
+deny contains msg if {
+	not step0_with_canonical
+	msg := "clean-ga-workflows.yml: with має містити token/save_period/save_min_runs_number як у ga.mdc"
+}
+
+step0_with_canonical if {
+	step0.with.token == expected_github_token
+	step0.with.save_period == 31
+	step0.with.save_min_runs_number == 0
+}

package/scripts/check-abie.mjs

@@ -37,10 +37,17 @@
  *
  * **Service (overlay ru):** для кожного **Service**, оголошеного в YAML під **`…/k8s/…`**, де шлях **не** проходить через **`k8s/ua/`** чи **`k8s/ru/`** (маніфести base / спільного шару, у т. ч. **headless** з **`clusterIP: None`** і **`-hl`**), якщо ще не **NodePort** / **LoadBalancer** / **ExternalName**,
  * у файлі **`k8s/ru/kustomization.yaml`** того ж пакета (overlay середовища **ru**) — inline **JSON6902** на **`kind: Service`** з тим самим **`target.name`**: **`path: /spec/type`**, **`value: NodePort`**; якщо в base було **`spec.clusterIP: None`** — **`op: remove`** для **`/spec/clusterIP`**; якщо в base **явно** задано **`spec.clusterIPs`** — також **`remove`** для **`/spec/clusterIPs`** (інакше **API** може залишити **`None`** для **NodePort**; без ключа **`clusterIPs`** у base **`remove`** на **`/spec/clusterIPs`** ламає **`kubectl kustomize`**).
+ *
+ * **env→cluster DNS:** abie живе у трьох різних кластерах (GKE dev/ua + YC ru), тож DNS-суфікс і namespace-префікс у будь-якому
+ * **внутрішньокластерному** URL виду `http://<svc>.<ns>.svc.<dns>` мають відповідати імені env-файла. Скануються всі `*.env` файли,
+ * basename яких збігається з `dev.env` / `ua.env` / `ru.env` (опційно з провідною крапкою — `.dev.env` тощо). Для кожного знайденого
+ * internal URL у файлі (не лише `HASURA_GRAPHQL_ENDPOINT`, а й KVCMS, auth-run, file-link тощо) валідатор `validateAbieEnvInternalUrls`
+ * вимагає: для `dev.env` — DNS `abie-dev.internal` і namespace починається з `dev-`; для `ua.env` — `abie-ua.internal` + `ua-`;
+ * для `ru.env` — `cluster.local` + `ru-`. Файл `.env` без імені (локальний для розробника) виключено зі сканування — як і у `check-hasura.mjs`.
  */
 import { existsSync } from 'node:fs'
 import { readdir, readFile } from 'node:fs/promises'
-import { dirname, join, relative } from 'node:path'
+import { basename, dirname, join, relative } from 'node:path'
 
 import { parseAllDocuments } from 'yaml'
 
@@ -119,6 +126,73 @@ const HTTPROUTE_BACKENDREF_PORT_8081_VALUE_FIRST_RE =
 /** Гілки, які мають бути в **`ignore_branches`** за abie.mdc. */
 export const ABIE_REQUIRED_IGNORE_BRANCHES = ['dev', 'ua', 'ru']
 
+/**
+ * Регекс basename env-файлу abie: `dev.env` / `ua.env` / `ru.env`, опційно з провідною крапкою (`.dev.env` тощо).
+ * Файл рівно `.env` (без імені) — виключення з правила: локальний файл розробника, `check-abie` його не сканує
+ * (так само як `check-hasura`, див. `isEnvFile`).
+ */
+const ABIE_ENV_FILE_BASENAME_RE = /^\.?(dev|ua|ru)\.env$/u
+
+/**
+ * Глобальний регекс кластерного internal URL у тексті env-файлу.
+ * Використовується з `String.prototype.matchAll`, тому має флаг `g`.
+ * Дозволяє два DNS-формати: `<cluster>.internal` (GKE) і `cluster.local` (YC / стандартний k8s).
+ * Порт необов'язковий — у KVCMS-конфігах інколи лежить URL без порту (8080 додається сервісом за замовчуванням).
+ */
+const ABIE_INTERNAL_URL_GLOBAL_RE =
+  /\bhttp:\/\/([a-z0-9][a-z0-9-]*)\.([a-z0-9][a-z0-9-]*)\.svc\.((?:[a-z0-9][a-z0-9-]*\.internal)|cluster\.local)(?::\d+)?(?:\/[^\s"'`]*)?/giu
+
+/**
+ * Очікуваний кластерний DNS-суфікс і namespace-префікс для кожного env-файлу abie.
+ * `dev` / `ua` живуть у GKE з власним `<cluster>.internal`; `ru` — у YC, де DNS-суфікс
+ * стандартний `cluster.local` (без імені кластера).
+ */
+const ABIE_ENV_CLUSTER_DNS_MAP = Object.freeze({
+  dev: Object.freeze({ clusterDns: 'abie-dev.internal', namespacePrefix: 'dev-' }),
+  ua: Object.freeze({ clusterDns: 'abie-ua.internal', namespacePrefix: 'ua-' }),
+  ru: Object.freeze({ clusterDns: 'cluster.local', namespacePrefix: 'ru-' })
+})
+
+/**
+ * Дістає ім'я env (`dev` / `ua` / `ru`) з basename env-файлу abie.
+ * Для не-abie env-файлів (наприклад `production.env`, `.env` без імені) повертає `null`.
+ * @param {string} basenameOfEnvFile basename файла (без шляху)
+ * @returns {('dev' | 'ua' | 'ru') | null} ім'я env або `null`
+ */
+export function abieEnvNameFromBasename(basenameOfEnvFile) {
+  const m = basenameOfEnvFile.match(ABIE_ENV_FILE_BASENAME_RE)
+  return m ? /** @type {'dev' | 'ua' | 'ru'} */ (m[1]) : null
+}
+
+/**
+ * Сканує вміст env-файлу abie і повертає помилки невідповідності кластерного DNS / namespace
+ * для кожного знайденого internal URL. URL шукається глобально (`matchAll`), тож одне й те саме
+ * порушення в кількох змінних дасть стільки ж окремих помилок.
+ * @param {string} content вміст env-файлу (UTF-8)
+ * @param {'dev' | 'ua' | 'ru'} envName ім'я env, отримане з `abieEnvNameFromBasename`
+ * @returns {string[]} порожній масив, якщо все OK; інакше — список повідомлень про порушення
+ */
+export function validateAbieEnvInternalUrls(content, envName) {
+  const expected = ABIE_ENV_CLUSTER_DNS_MAP[envName]
+  if (!expected) return []
+  /** @type {string[]} */
+  const errors = []
+  for (const match of content.matchAll(ABIE_INTERNAL_URL_GLOBAL_RE)) {
+    const [fullUrl, , namespace, clusterDns] = match
+    if (clusterDns !== expected.clusterDns) {
+      errors.push(
+        `${fullUrl}: кластерний DNS "${clusterDns}" не відповідає env "${envName}" (очікується "${expected.clusterDns}")`
+      )
+    }
+    if (!namespace.startsWith(expected.namespacePrefix)) {
+      errors.push(
+        `${fullUrl}: namespace "${namespace}" не починається з "${expected.namespacePrefix}" (env "${envName}")`
+      )
+    }
+  }
+  return errors
+}
+
 /**
  * Чи відносний шлях вказує на **`ru/kustomization.yaml`** (сегмент **`ru`** перед ім'ям файлу) — специфіка abie overlay.
  * @param {string} rel шлях від кореня репозиторію
@@ -2078,6 +2152,70 @@ async function ensureAbieNginxSidecarForHasura(root, yamlFilesAbs, fail, passFn)
   }
 }
 
+/**
+ * Збирає всі `*.env` файли в дереві (за виключенням `node_modules`, `.git` та інших службових каталогів),
+ * basename яких — abie env-файл (`dev.env` / `ua.env` / `ru.env` опційно з провідною крапкою). Файл `.env`
+ * без імені виключається — як і у `check-hasura.mjs`.
+ * @param {string} root корінь репозиторію
+ * @param {string[]} ignorePaths абсолютні шляхи каталогів, повністю виключених з обходу
+ * @returns {Promise<string[]>} відсортовані абсолютні шляхи env-файлів abie
+ */
+async function collectAbieEnvFiles(root, ignorePaths) {
+  /** @type {string[]} */
+  const out = []
+  await walkDir(
+    root,
+    absPath => {
+      if (abieEnvNameFromBasename(basename(absPath)) !== null) {
+        out.push(absPath)
+      }
+    },
+    ignorePaths
+  )
+  return out.toSorted((a, b) => a.localeCompare(b))
+}
+
+/**
+ * Сканує всі `*.env` файли abie (`.dev.env` / `.ua.env` / `.ru.env`) і для кожного знайденого
+ * **внутрішньокластерного** URL (`http://<svc>.<ns>.svc.<dns>`) перевіряє, що DNS-суфікс і namespace-префікс
+ * відповідають середовищу env-файла. Не лише `HASURA_GRAPHQL_ENDPOINT`, а й будь-який сервіс у env (KVCMS,
+ * `auth-run-hl`, `file-link-hl` тощо) мусить мати кластер, що відповідає env: dev → `abie-dev.internal`,
+ * ua → `abie-ua.internal`, ru → `cluster.local`.
+ * @param {string} root корінь репозиторію
+ * @param {string[]} ignorePaths абсолютні шляхи каталогів, повністю виключених з обходу
+ * @param {(msg: string) => void} pass успішне повідомлення
+ * @param {(msg: string) => void} fail повідомлення про порушення
+ * @returns {Promise<void>}
+ */
+async function ensureAbieEnvFilesMatchClusterDns(root, ignorePaths, pass, fail) {
+  const envFiles = await collectAbieEnvFiles(root, ignorePaths)
+  if (envFiles.length === 0) {
+    pass('Не знайдено dev.env / ua.env / ru.env у репозиторії — перевірку env→cluster DNS пропущено (abie.mdc)')
+    return
+  }
+  for (const abs of envFiles) {
+    const rel = relative(root, abs).replaceAll('\\', '/') || abs
+    const envName = abieEnvNameFromBasename(basename(abs))
+    if (envName === null) continue
+    let raw
+    try {
+      raw = await readFile(abs, 'utf8')
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error)
+      fail(`${rel}: не вдалося прочитати (${msg})`)
+      continue
+    }
+    const errors = validateAbieEnvInternalUrls(raw, envName)
+    if (errors.length === 0) {
+      pass(`${rel}: усі внутрішні URL відповідають env "${envName}" (abie.mdc)`)
+    } else {
+      for (const err of errors) {
+        fail(`${rel}: ${err} (abie.mdc)`)
+      }
+    }
+  }
+}
+
 /**
  * Перевіряє відповідність проєкту правилам abie.mdc.
  * @returns {Promise<number>} 0 — все OK, 1 — є проблеми
@@ -2129,5 +2267,8 @@ export async function check() {
   pass('Перевіряємо nginx-sidecar для Hasura WebSocket у ru (abie.mdc)')
   await ensureAbieNginxSidecarForHasura(root, yamlFiles, fail, pass)
 
+  pass('Перевіряємо env→cluster DNS у dev.env / ua.env / ru.env (abie.mdc)')
+  await ensureAbieEnvFilesMatchClusterDns(root, ignorePaths, pass, fail)
+
   return reporter.getExitCode()
 }

package/scripts/check-hasura.mjs

@@ -7,10 +7,11 @@
  * вказує на `https://github.com/nitra/...` або `https://github.com/abinbevefes/...`
  * (інші репозиторії пропускаються без помилок — як у check-abie).
  *
- * Очікуваний формат URL:
- *   `http://<service>.<namespace>.svc.<cluster>.internal:<port>`
- *
- * приклад: `http://contract-h.ua-contract.svc.abie-ua.internal:8080`
+ * Очікуваний формат URL — два варіанти кластерного DNS-суфікса:
+ *  - GKE / GCP: `http://<service>.<namespace>.svc.<cluster>.internal:<port>`
+ *    приклад: `http://contract-h.ua-contract.svc.abie-ua.internal:8080`
+ *  - стандартний k8s / Yandex Cloud: `http://<service>.<namespace>.svc.cluster.local:<port>`
+ *    приклад: `http://apruv-h-hl.ru-apruv.svc.cluster.local:8080`
  *
  * Сегменти беруться з `hasura/k8s/base/svc-hl.yaml` (`metadata.name` —
  * має закінчуватись на `-h`, headless-сервіс) і `hasura/k8s/base/namespace.yaml`
@@ -42,12 +43,20 @@ const HASURA_NAMESPACE_FILE = `${HASURA_BASE_DIR}/namespace.yaml`
 
 const ENV_FILE_RE = /\.env$/u
 const HASURA_ENDPOINT_LINE_RE = /^[ \t]*(?:export[ \t]+)?HASURA_GRAPHQL_ENDPOINT[ \t]*=[ \t]*['"]?([^'"\r\n#]+)/mu
-const INTERNAL_HASURA_URL_RE = /^http:\/\/([^./]+)\.([^./]+)\.svc\.([^./]+)\.internal:(\d+)\/?$/u
+// Дозволяємо два DNS-суфікси кластера: `<name>.internal` (GKE/GCP) і `cluster.local`
+// (стандартний k8s / Yandex Cloud). У YC namespace.yaml + cluster mode дають коротший суфікс.
+const INTERNAL_HASURA_URL_RE =
+  /^http:\/\/([^./]+)\.([^./]+)\.svc\.((?:[^./:]+\.internal)|cluster\.local):(\d+)\/?$/u
+const CLUSTER_LOCAL_SUFFIX = 'cluster.local'
+const INTERNAL_DNS_SUFFIX = '.internal'
 
 /**
  * Розбір значення `HASURA_GRAPHQL_ENDPOINT` як внутрішнього кластерного URL.
- * Дозволяє лише `http://` (TLS усередині кластера зайвий), вимагає сегментів
- * `<service>.<namespace>.svc.<cluster>.internal` та явного порту.
+ * Дозволяє лише `http://` (TLS усередині кластера зайвий) та обидва кластерні
+ * DNS-суфікси: `<cluster>.internal` (GKE/GCP) і `cluster.local`
+ * (стандартний k8s / Yandex Cloud). Поле `cluster` для GKE містить ім'я
+ * кластера без `.internal` (наприклад `abie-ua`); для YC — повний суфікс
+ * `cluster.local` (бо своєї «назви кластера» в DNS немає).
  * @param {string} url значення з `.env` (без огорнутих лапок)
  * @returns {{ ok: true, service: string, namespace: string, cluster: string, port: string } | { ok: false }}
  *   розібрані сегменти або `{ ok: false }`, якщо формат не відповідає внутрішньому кластерному URL
@@ -57,7 +66,9 @@ export function parseInternalHasuraEndpoint(url) {
   if (!m) {
     return { ok: false }
   }
-  return { ok: true, service: m[1], namespace: m[2], cluster: m[3], port: m[4] }
+  const suffix = m[3]
+  const cluster = suffix.endsWith(INTERNAL_DNS_SUFFIX) ? suffix.slice(0, -INTERNAL_DNS_SUFFIX.length) : suffix
+  return { ok: true, service: m[1], namespace: m[2], cluster, port: m[4] }
 }
 
 /**
@@ -140,7 +151,7 @@ async function checkEnvFile(relPath, expected, reporter) {
   const parsed = parseInternalHasuraEndpoint(value)
   if (!parsed.ok) {
     // eslint-disable-next-line @microsoft/sdl/no-insecure-url, sonarjs/no-clear-text-protocols -- hasura.mdc вимагає саме http:// для кластерного URL (TLS не використовується)
-    const example = 'http://<service>.<namespace>.svc.<cluster>.internal:<port>'
+    const example = 'http://<service>.<namespace>.svc.<cluster>.internal:<port> або http://<service>.<namespace>.svc.cluster.local:<port>'
     fail(
       `${relPath}: HASURA_GRAPHQL_ENDPOINT="${value}" — потрібен внутрішній кластерний URL виду ${example} (hasura.mdc)`
     )

package/scripts/check-k8s.mjs

@@ -49,6 +49,13 @@
  * завжди має бути непорожнє поле **`namespace:`** (перевірка, якщо файл існує). У **`apiVersion: kustomize.config.k8s.io/…`**, **`kind: Kustomization`**
  * перелік **`resources:`** (лише непорожні рядки) має бути відсортовано за алфавітом (**en**, `localeCompare`).
  *
+ * **Структурний сорт `patches[]` у kustomization.yaml:** масив **`patches`** має бути відсортовано за tuple
+ * **`[target.kind, target.name, target.namespace, path]`** (`localeCompare('en', base)`). Поля **`group`** / **`version`**
+ * у tuple не входять — для них діє правило «patches[].target: лише kind і name». Додатково: вміст
+ * **inline `patches[i].patch`** (literal block scalar — масив JSON6902-операцій) має бути відсортовано за **`path`**,
+ * але **лише** якщо всі операції — **`add`** / **`replace`** і всі **`path`** попарно дизʼюнктні (жоден не префікс іншого).
+ * Інакше порядок не чіпається — `move` / `copy` / `test` / `remove` чи спільні шляхи можуть бути семантично залежні (RFC 6902).
+ *
  * **Inline JSON6902** у **`patches`** (і зовнішні файли з **`patches[].path`** під **`k8s`**, якщо вміст — масив JSON Patch): не допускається пара **`remove`** і **`add`**
  * на один і той самий **`path`** у межах одного фрагмента — потрібен **`op: replace`** (k8s.mdc). **check-k8s** це перевіряє.
  *
@@ -471,6 +478,197 @@ async function validateKustomizationResourcesSortedAlphabetically(root, yamlFile
   }
 }
 
+/**
+ * Лексичне порівняння двох тuplіе рядків через `localeCompare('en', { sensitivity: 'base' })`.
+ * Менший за довжиною список доповнюється порожніми рядками.
+ * @param {string[]} a перший tuple
+ * @param {string[]} b другий tuple
+ * @returns {number} `< 0` якщо `a` менший, `> 0` якщо більший, `0` — рівні
+ */
+function compareStringTuplesEn(a, b) {
+  const n = Math.max(a.length, b.length)
+  for (let i = 0; i < n; i++) {
+    const av = a[i] ?? ''
+    const bv = b[i] ?? ''
+    const c = av.localeCompare(bv, 'en', { sensitivity: 'base' })
+    if (c !== 0) return c
+  }
+  return 0
+}
+
+/**
+ * Чи послідовність tuple-ключів відсортована за `compareStringTuplesEn`.
+ * @param {string[][]} tuples масив tuple-ключів у порядку, як у файлі
+ * @returns {boolean} true, якщо порядок неспадний
+ */
+function stringTuplesAreSortedEn(tuples) {
+  for (let i = 1; i < tuples.length; i++) {
+    if (compareStringTuplesEn(tuples[i - 1], tuples[i]) > 0) return false
+  }
+  return true
+}
+
+/**
+ * Tuple-ключ для сортування одного запису `patches[]` Kustomization.
+ * Порядок ключів: `target.kind` → `target.name` → `target.namespace` → `path`. Відсутні поля = `''`
+ * (порожні раніше за заповнені у `localeCompare` — стабільний детермінізм).
+ * Поля `target.group` / `target.version` навмисно не входять у ключ — у repo діє правило
+ * «patches[].target: лише kind і name», тому опертися на них не можна.
+ * @param {unknown} patchItem елемент масиву `patches[]`
+ * @returns {string[]} tuple для порівняння
+ */
+function kustomizationPatchSortKey(patchItem) {
+  if (patchItem === null || typeof patchItem !== 'object' || Array.isArray(patchItem)) {
+    return ['', '', '', '']
+  }
+  const rec = /** @type {Record<string, unknown>} */ (patchItem)
+  const t = rec.target
+  /** @type {Record<string, unknown>} */
+  const target = t !== null && typeof t === 'object' && !Array.isArray(t) ? /** @type {Record<string, unknown>} */ (t) : {}
+  const kind = typeof target.kind === 'string' ? target.kind : ''
+  const name = typeof target.name === 'string' ? target.name : ''
+  const ns = typeof target.namespace === 'string' ? target.namespace : ''
+  const path = typeof rec.path === 'string' ? rec.path : ''
+  return [kind, name, ns, path]
+}
+
+/**
+ * Короткий ярлик запису `patches[]` для звітів («kind/name», або «path=…», або «#i»).
+ * @param {unknown} patchItem елемент масиву
+ * @param {number} i індекс у масиві (для fallback)
+ * @returns {string} людинозрозумілий ярлик
+ */
+function kustomizationPatchLabel(patchItem, i) {
+  const [kind, name, , path] = kustomizationPatchSortKey(patchItem)
+  if (kind && name) return `${kind}/${name}`
+  if (path) return `path=${path}`
+  return `#${i}`
+}
+
+/**
+ * Порушення сорту **`patches[]`**: лише для **`kustomize.config.k8s.io/…`**, **`kind: Kustomization`**.
+ * Сортування за tuple `[target.kind, target.name, target.namespace, path]` (`localeCompare('en', base)`).
+ * @param {unknown} obj корінь першого YAML-документа kustomization.yaml
+ * @returns {string | null} причина або `null`, якщо обмеження не застосовується чи порядок ОК
+ */
+export function kustomizationPatchesSortedViolation(obj) {
+  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) return null
+  const rec = /** @type {Record<string, unknown>} */ (obj)
+  if (rec.kind !== 'Kustomization') return null
+  const av = rec.apiVersion
+  if (typeof av !== 'string' || !av.startsWith(KUSTOMIZE_CONFIG_API_PREFIX)) return null
+  const patches = rec.patches
+  if (patches === undefined) return null
+  if (!Array.isArray(patches)) {
+    return 'Kustomization.patches має бути масивом (k8s.mdc)'
+  }
+  if (patches.length < 2) return null
+  const keys = patches.map(p => kustomizationPatchSortKey(p))
+  if (stringTuplesAreSortedEn(keys)) return null
+  const order = patches.map((p, i) => ({ p, i, key: keys[i] }))
+  order.sort((a, b) => compareStringTuplesEn(a.key, b.key) || a.i - b.i)
+  const have = patches.map((p, i) => kustomizationPatchLabel(p, i)).join(', ')
+  const want = order.map(x => kustomizationPatchLabel(x.p, x.i)).join(', ')
+  return `Kustomization.patches має бути за алфавітом (target.kind → target.name → target.namespace → path). Зараз: ${have}; очікувано: ${want} (k8s.mdc)`
+}
+
+/** Чи рядок виглядає як JSON-Pointer-шлях `/…` (порожнє і `/` теж приймаються — `/` = корінь). */
+const JSON_POINTER_RE = /^\/[^\s]*$|^$|^\/$/u
+
+/**
+ * Чи кожен `path` у наборі — окремий вузол JSON-Pointer (немає прямого префікс-збігу типу `/spec` vs `/spec/replicas`).
+ * Однакові `path` теж вважаються «недизʼюнктними». Реалізація: `O(n²)` достатня для розмірів реальних patch-наборів.
+ * @param {string[]} paths шляхи у тому ж порядку, що й у файлі
+ * @returns {boolean} true, якщо всі шляхи попарно дизʼюнктні
+ */
+function jsonPointerPathsAreDisjoint(paths) {
+  for (let i = 0; i < paths.length; i++) {
+    for (let j = 0; j < paths.length; j++) {
+      if (i === j) continue
+      if (paths[i] === paths[j]) return false
+      if (paths[j].startsWith(`${paths[i]}/`)) return false
+    }
+  }
+  return true
+}
+
+/**
+ * Парсить рядок JSON6902-патчa в плоский масив операцій `{ op, path }` (без значень).
+ * Повертає `null`, якщо це не YAML-масив об'єктів з полями `op`/`path` як рядки.
+ * @param {string} raw тіло inline `patch:` (literal block scalar)
+ * @returns {{ op: string, path: string }[] | null} нормалізований список ops або `null` за невідповідного формату
+ */
+function parseJson6902OpsFromText(raw) {
+  let parsed
+  try {
+    parsed = parseDocument(raw).toJSON()
+  } catch {
+    return null
+  }
+  if (!Array.isArray(parsed)) return null
+  /** @type {{ op: string, path: string }[]} */
+  const out = []
+  for (const item of parsed) {
+    if (item === null || typeof item !== 'object' || Array.isArray(item)) return null
+    const rec = /** @type {Record<string, unknown>} */ (item)
+    if (typeof rec.op !== 'string' || typeof rec.path !== 'string') return null
+    out.push({ op: rec.op, path: rec.path })
+  }
+  return out
+}
+
+/**
+ * Порушення сорту inline JSON6902-ops у одному `patches[i].patch`.
+ * Сортуємо **тільки** «безпечний» набір: всі `op ∈ { add, replace }` і всі `path` дизʼюнктні
+ * (немає префікс-зв'язку між шляхами). Інакше повертаємо `null` — порядок зберігаємо як у файлі,
+ * бо `move`/`copy`/`test`/`remove` чи спільні шляхи можуть бути семантично залежні (RFC 6902).
+ * @param {string} patchText вміст literal block (inline `patch:`)
+ * @returns {string | null} опис порушення або `null`
+ */
+export function kustomizationInlinePatchOpsSortedViolation(patchText) {
+  const ops = parseJson6902OpsFromText(patchText)
+  if (ops === null) return null
+  if (ops.length < 2) return null
+  for (const o of ops) {
+    if (o.op !== 'add' && o.op !== 'replace') return null
+    if (!JSON_POINTER_RE.test(o.path)) return null
+  }
+  const paths = ops.map(o => o.path)
+  if (!jsonPointerPathsAreDisjoint(paths)) return null
+  /** @type {string[][]} */
+  const keys = paths.map(p => [p])
+  if (stringTuplesAreSortedEn(keys)) return null
+  const want = paths.toSorted((a, b) => a.localeCompare(b, 'en', { sensitivity: 'base' }))
+  return `inline patch (JSON6902) має бути за алфавітом по path. Зараз: ${paths.join(', ')}; очікувано: ${want.join(', ')} (k8s.mdc)`
+}
+
+/**
+ * Усі **`kustomization.yaml`**: `patches[]` відсортовано за `[target.kind, target.name, …]`,
+ * а вміст inline `patches[i].patch` (де всі ops — `add`/`replace` і шляхи дизʼюнктні) — за `path`.
+ * @param {string} root корінь репо
+ * @param {string[]} yamlFilesAbs yaml під k8s
+ * @param {(msg: string) => void} fail функція для фіксації порушення
+ * @returns {Promise<void>} завершується після перевірки всіх kustomization.yaml
+ */
+async function validateKustomizationPatchesStructuralSort(root, yamlFilesAbs, fail) {
+  for (const kustAbs of yamlFilesAbs.filter(p => basename(p).toLowerCase() === 'kustomization.yaml')) {
+    const rel = (relative(root, kustAbs) || kustAbs).replaceAll('\\', '/')
+    const kust = await readFirstYamlObject(kustAbs)
+    if (kust === null) continue
+    const outer = kustomizationPatchesSortedViolation(kust)
+    if (outer !== null) fail(`${rel}: ${outer}`)
+    const patches = kust.patches
+    if (!Array.isArray(patches)) continue
+    for (const [i, p] of patches.entries()) {
+      if (p === null || typeof p !== 'object' || Array.isArray(p)) continue
+      const rec = /** @type {Record<string, unknown>} */ (p)
+      if (typeof rec.patch !== 'string') continue
+      const v = kustomizationInlinePatchOpsSortedViolation(rec.patch)
+      if (v !== null) fail(`${rel}: patches[${i}] (${kustomizationPatchLabel(p, i)}): ${v}`)
+    }
+  }
+}
+
 /**
  * Шляхи з полів Kustomization для resolve відносно каталогу **`kustomization.yaml`**.
  * @param {unknown} obj корінь першого документа Kustomization
@@ -5916,6 +6114,8 @@ export async function check() {
 
   await validateKustomizationResourcesSortedAlphabetically(root, yamlFiles, fail)
 
+  await validateKustomizationPatchesStructuralSort(root, yamlFiles, fail)
+
   await validateKustomizationPatchTargetsResolved(root, yamlFiles, fail)
 
   await validateKustomizeHpaPdbOnlyWithBaseDeployment(root, yamlFiles, fail, pass)

package/scripts/lint-ga.mjs

@@ -1,6 +1,11 @@
 /**
  * CLI-обгортка над канонічним `lint-ga` (ga.mdc): робить preflight на `shellcheck` і `uv` (для `uvx`),
- * тоді послідовно виконує `bunx github-actionlint` і `uvx zizmor --offline --collect=workflows .`.
+ * тоді послідовно виконує `bunx github-actionlint`, `uvx zizmor --offline --collect=workflows .` і
+ * (PoC) `conftest test` на структуру канонічних workflow проти Rego-полісі з `npm/policy/ga/`.
+ *
+ * Conftest-крок навмисно **не** додається в preflight: якщо бінарник не встановлений, виводимо `ℹ`
+ * повідомлення й продовжуємо з кодом 0. Структурні перевірки тих самих workflow паралельно живуть у
+ * `npm/scripts/check-ga.mjs`, тож відсутність conftest не пропускає порушення мовчки.
  *
  * Без preflight `actionlint` (через `bunx github-actionlint`) мовчки пропускає shell-перевірки в
  * `run:` блоках, коли `shellcheck` відсутній у PATH; локально `bun lint-ga` лишається зеленим, а CI
@@ -11,11 +16,29 @@
  *
  * Експортовано окремо `runLintGaCli` — використовується з `bin/n-cursor.js` як підкоманда `lint-ga`.
  */
+import { existsSync } from 'node:fs'
 import { spawnSync } from 'node:child_process'
+import { dirname, join } from 'node:path'
 import { platform } from 'node:process'
+import { fileURLToPath } from 'node:url'
 
 import { resolveCmd } from './utils/resolve-cmd.mjs'
 
+/** Каталог пакету `@nitra/cursor`, від якого ресолвимо вшиту директорію policy/. */
+const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
+
+/** Шлях до Rego-полісі (PoC: лише clean-ga-workflows). У npm-tarball публікується через `files` у package.json. */
+const GA_POLICY_DIR = join(PACKAGE_ROOT, 'policy', 'ga')
+
+/**
+ * Workflow-файли, для яких маємо відповідну Rego-полісі. PoC: один файл; інші підтягуватимемо в міру міграції
+ * перевірок із `npm/scripts/check-ga.mjs`.
+ * @type {Array<{ workflow: string, label: string }>}
+ */
+const CONFTEST_TARGETS = [
+  { workflow: '.github/workflows/clean-ga-workflows.yml', label: 'clean-ga-workflows.yml structure' }
+]
+
 /**
  * Опис залежності preflight-ом: бінарник, для чого потрібен, і команди встановлення.
  * @typedef {object} PreflightDep
@@ -153,5 +176,51 @@ export function runLintGaCli() {
   if (actionlintCode !== 0) return actionlintCode
 
   const zizmorCode = runStep('zizmor', 'uvx', ['zizmor', '--offline', '--collect=workflows', '.'])
-  return zizmorCode
+  if (zizmorCode !== 0) return zizmorCode
+
+  return runConftestStep()
+}
+
+/**
+ * PoC-крок: запускає conftest на YAML workflow проти Rego-полісі з пакету (`policy/ga/`).
+ *
+ * Поведінка fallback:
+ * - якщо `conftest` не знайдено в PATH — друкуємо `ℹ` повідомлення з підказкою встановлення й
+ *   повертаємо 0 (тобто конфтест поки що **не** є обовʼязковою залежністю lint-ga; перевірки лежать
+ *   паралельно в `check-ga.mjs`, і `npx @nitra/cursor check ga` все одно їх запустить);
+ * - якщо `conftest` є й полісі-каталог відсутній (нетипова інсталяція) — також `ℹ` skip;
+ * - якщо є цільовий workflow і conftest — запускаємо `conftest test <workflow> -p <policy-dir>` і
+ *   повертаємо його exit-код, щоб порушення зупиняли lint-ga, як це робить actionlint/zizmor.
+ *
+ * Локальний `conftest` встановлюється через `brew install conftest` / `go install ...` — деталі в
+ * https://www.conftest.dev/install/.
+ * @returns {number} 0 — OK або skip, інакше — exit-код conftest
+ */
+function runConftestStep() {
+  const conftestBin = resolveCmd('conftest')
+  if (!conftestBin) {
+    console.log(
+      '\nℹ conftest не знайдено в PATH — пропускаю PoC-перевірку структури workflow через Rego-полісі.\n' +
+        '   Встанови, щоб запустити її локально: brew install conftest (macOS) або https://www.conftest.dev/install/'
+    )
+    return 0
+  }
+
+  if (!existsSync(GA_POLICY_DIR)) {
+    console.log(`\nℹ Каталог Rego-полісі не знайдено (${GA_POLICY_DIR}) — пропускаю conftest.`)
+    return 0
+  }
+
+  for (const target of CONFTEST_TARGETS) {
+    if (!existsSync(target.workflow)) continue
+    const code = runStep(`conftest (${target.label})`, conftestBin, [
+      'test',
+      target.workflow,
+      '-p',
+      GA_POLICY_DIR,
+      '--no-color'
+    ])
+    if (code !== 0) return code
+  }
+  return 0
 }

package/scripts/lint-rego.mjs

@@ -0,0 +1,70 @@
+/**
+ * Запуск `regal lint` по Rego-полісі репозиторію (`conftest.mdc`).
+ *
+ * Regal (https://docs.styra.com/regal) — статичний лінтер Rego, який ловить v0-синтаксис,
+ * неявні set-rules та інші відхилення від `rego.v1`. Без preflight-у на наявність бінарника
+ * лінт мовчки злетить з невиразним повідомленням від shell — тут друкуємо явний install-hint
+ * (як це робить `lint-ga.mjs` для shellcheck/uv).
+ *
+ * Цілі лінту: `npm/policy/` (місце, де поки що живуть Rego-полісі пакета `@nitra/cursor`).
+ * Якщо в репозиторії з’являться інші *.rego поза цим деревом, додай шлях у `LINT_TARGETS` —
+ * `regal lint` приймає кілька шляхів і сам рекурсивно обходить директорії.
+ */
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import { resolveCmd } from './utils/resolve-cmd.mjs'
+
+/** Шляхи з Rego-полісі (відносно cwd). Існують не всі на ранніх стадіях — фільтруємо нижче. */
+const LINT_TARGETS = ['npm/policy']
+
+/**
+ * Друкує підказку зі встановлення `regal`.
+ * @returns {void}
+ */
+function printRegalInstallHints() {
+  process.stderr.write(
+    [
+      '❌ regal не знайдено в PATH.',
+      '   Без нього не перевіряється rego.v1 синтаксис у *.rego (правило `conftest`).',
+      '   Встанови:',
+      '     macOS:    brew install regal',
+      '     Universal: https://docs.styra.com/regal#installation',
+      ''
+    ].join('\n')
+  )
+}
+
+/**
+ * Запускає `regal lint` по існуючих цілях. Якщо жодної цілі немає — пропускає лінт із кодом 0.
+ * @param {string} [cwd] робочий каталог (за замовчуванням `process.cwd()`)
+ * @returns {number} 0 — OK або skip; інакше код виходу regal
+ */
+export function runLintRego(cwd = process.cwd()) {
+  const root = resolve(cwd)
+  const regal = resolveCmd('regal')
+  if (!regal) {
+    printRegalInstallHints()
+    return 1
+  }
+
+  const targets = LINT_TARGETS.filter(rel => existsSync(resolve(root, rel)))
+  if (targets.length === 0) {
+    return 0
+  }
+
+  console.log(`▶ regal lint ${targets.join(' ')}`)
+  const result = spawnSync(regal, ['lint', ...targets], {
+    cwd: root,
+    stdio: 'inherit',
+    env: process.env
+  })
+  if (result.error) {
+    process.stderr.write(`❌ Не вдалося запустити regal: ${result.error.message}\n`)
+    return 1
+  }
+  return result.status ?? 1
+}
+
+process.exitCode = runLintRego()