@nitra/cursor 1.8.199 → 1.8.200

package/CHANGELOG.md

@@ -4,6 +4,15 @@
 
 Формат — [Keep a Changelog](https://keepachangelog.com/uk/1.1.0/), нумерація — [SemVer](https://semver.org/lang/uk/).
 
+## [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/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.200",
   "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-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()