@nitra/cursor 12.4.0 → 12.5.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [12.5.0] - 2026-06-21
+
+### Changed
+
+- Уніфіковано image-compress, docker і k8s lint через n-cursor lint <rule> без package.json wrappers; image-compress read-only використовує @nitra/minify-image --json.
+
 ## [12.4.0] - 2026-06-21
 
 ### Changed

package/package.json

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

package/rules/bun/js/layout.mjs

@@ -1,151 +1,19 @@
 /** @see ./docs/layout.md */
 import { existsSync } from 'node:fs'
-import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
 
 import { createCheckReporter } from '../../../scripts/lib/check-reporter.mjs'
 
-/** Розділювач токенів у `scripts.lint` (послідовність пробільних символів). */
-const WHITESPACE_RE = /\s+/u
-
 // Перевірка `devDependencies` кореневого `package.json` (дозволено лише `@nitra/*`)
 // — у rego (`npm/policy/bun/package_json/`). JS-копії `isAllowedRootDevDependency`
 // видалено, щоб не було двох джерел істини.
 
-/**
- * Зчитує `rules` та `disable-rules` з `.n-cursor.json`.
- * @param {string} cwd корінь репозиторію
- * @returns {Promise<{ rules: Set<string>, disabled: Set<string> }>} активні правила і явно вимкнені
- */
-async function loadNCursorRules(cwd) {
-  const empty = { rules: new Set(), disabled: new Set() }
-  const cfgPath = join(cwd, '.n-cursor.json')
-  if (!existsSync(cfgPath)) return empty
-  try {
-    const raw = JSON.parse(await readFile(cfgPath, 'utf8'))
-    const list = Array.isArray(raw?.rules) ? raw.rules.map(String) : []
-    const disabled = Array.isArray(raw?.['disable-rules']) ? raw['disable-rules'].map(String) : []
-    return { rules: new Set(list), disabled: new Set(disabled) }
-  } catch {
-    return empty
-  }
-}
-
-/**
- * Чи містить `scripts.lint` виклик `bun run <script>` у chain'і. Шукаємо саме `bun run <script>`
- * як окремий токен (між пробілами/`&&`), щоб уникнути false-positive на префіксах
- * (`bun run lint-k8s-foo` не матчиться як `bun run lint-k8s`).
- * @param {string} lintScript значення `scripts.lint` (порожній рядок — якщо нема)
- * @param {string} target ім'я скрипта (без префіксів)
- * @returns {boolean} true, якщо chain згадує `bun run <target>`
- */
-function lintChainHasScript(lintScript, target) {
-  if (!lintScript) return false
-  const tokens = lintScript.split(WHITESPACE_RE)
-  return tokens.some((tok, i) => tok === 'bun' && tokens[i + 1] === 'run' && tokens[i + 2] === target)
-}
-
-/**
- * Описує `lint-<id>`-обгортку та правила, що нею володіють. Один скрипт може мати кілька
- * власників (`lint-image` — обслуговує і `image-avif`, і `image-compress`); скрипт вважається
- * «потрібним», якщо **хоч одне** з власних правил активне у `.n-cursor.json:rules`.
- * @typedef {object} RuleScript
- * @property {string[]} rules id правил-власників (>=1); скрипт зобов'язаний існувати, поки активне хоч одне з них
- * @property {string} script ім'я скрипта в `package.json:scripts`
- * @property {string} doc `.mdc`-файл (або кома-список), на який посилається повідомлення check-у
- */
-
-/** @type {RuleScript[]} */
-const RULE_SCRIPTS = [
-  { rules: ['docker'], script: 'lint-docker', doc: 'docker.mdc' },
-  { rules: ['k8s'], script: 'lint-k8s', doc: 'k8s.mdc' },
-  { rules: ['image-avif', 'image-compress'], script: 'lint-image', doc: 'image-avif.mdc / image-compress.mdc' }
-]
-
-/**
- * Загортає кожен ідентифікатор у backticks та зʼєднує через роздільник. Винесено
- * окремою функцією, щоб не нестити template literals у `pass`/`fail`-повідомленнях.
- * @param {string[]} items ідентифікатори правил
- * @param {string} sep роздільник (наприклад `, ` або `/`)
- * @returns {string} рядок виду "`a`, `b`"
- */
-function backtickJoin(items, sep) {
-  return items.map(r => '`' + r + '`').join(sep)
-}
-
-/**
- * Описує стан правил-власників скрипта для повідомлень про reason. Повертає або список увімкнених
- * правил (для passing-кейсу «правило є»), або компактний опис, чому всі вимкнені (для inverse-fail).
- * @param {string[]} owners id правил-власників (>=1)
- * @param {{ rules: Set<string>, disabled: Set<string> }} cursorRules `rules` та `disable-rules`
- * @returns {{ enabled: string[], reason: string }} `enabled` — список з `cursorRules.rules`; `reason` — текст для лога
- */
-function ownerStatus(owners, cursorRules) {
-  const enabled = owners.filter(r => cursorRules.rules.has(r))
-  if (enabled.length > 0) {
-    return { enabled, reason: `правил${enabled.length === 1 ? 'о' : 'а'} ${backtickJoin(enabled, ', ')}` }
-  }
-  if (owners.length === 1) {
-    const [only] = owners
-    const where = cursorRules.disabled.has(only) ? 'в disable-rules' : 'відсутнє в rules'
-    return { enabled, reason: `правило \`${only}\` ${where}` }
-  }
-  const disabledCount = owners.filter(r => cursorRules.disabled.has(r)).length
-  const note = disabledCount === owners.length ? 'усі власники в disable-rules' : 'жоден власник не активний у rules'
-  return { enabled, reason: `${backtickJoin(owners, '/')} — ${note}` }
-}
-
-/**
- * Перевіряє двосторонній зв'язок `rules` ↔ `scripts.lint-<id>` для правил із `lint-<id>`-обгорткою
- * (див. `RULE_SCRIPTS`). Якщо активне хоч одне правило-власник — скрипт мусить існувати; якщо
- * жодне з власників не активне (відсутнє у `rules` або є в `disable-rules`), скрипту і згадки
- * `bun run <script>` у `scripts.lint` бути **не може**. Інакше `bun run lint` падатиме на
- * вимкненому правилі: `n-cursor lint-<id>` ігнорує `.n-cursor.json` і обходить дерево
- * незалежно від конфігу (як було в cursor-репо: `disable-rules: ["k8s"]` + залишений `lint-k8s`
- * ламав chain на template-сорцях власного правила).
- * @param {{ pass: (msg: string) => void, fail: (msg: string) => void }} reporter callback-и `pass`/`fail` для звіту
- * @param {Record<string, string>} scripts scripts з package.json
- * @param {{ rules: Set<string>, disabled: Set<string> }} cursorRules `rules` та `disable-rules`
- */
-function checkCursorRuleScripts(reporter, scripts, cursorRules) {
-  const { pass, fail } = reporter
-  const lintScript = typeof scripts.lint === 'string' ? scripts.lint : ''
-  for (const { rules: owners, script, doc } of RULE_SCRIPTS) {
-    const status = ownerStatus(owners, cursorRules)
-    const present = Boolean(scripts[script])
-    const inChain = lintChainHasScript(lintScript, script)
-    if (status.enabled.length > 0) {
-      if (present) {
-        pass(`package.json: є \`${script}\` (${status.reason} у .n-cursor.json)`)
-      } else {
-        fail(
-          `У .n-cursor.json увімкнено ${status.reason} — додай скрипт \`${script}\` у кореневий package.json (див. ${doc})`
-        )
-      }
-      continue
-    }
-    if (present) {
-      fail(
-        `У .n-cursor.json немає активних власників ${backtickJoin(owners, '/')} — прибери скрипт \`${script}\` з кореневого package.json (див. ${doc})`
-      )
-    }
-    if (inChain) {
-      fail(
-        `У \`scripts.lint\` є \`bun run ${script}\`, але серед \`${owners.join('/')}\` жоден не активний у .n-cursor.json — прибери з ланцюжка lint (див. ${doc})`
-      )
-    }
-    if (!present && !inChain) {
-      pass(`package.json: \`${script}\` відсутній (${status.reason})`)
-    }
-  }
-}
-
 /**
  * Перевіряє відповідність проєкту правилам bun.mdc
  * @param {string} [cwd] корінь репозиторію
  * @returns {Promise<number>} 0 — все OK, 1 — є проблеми
  */
-export async function check(cwd = process.cwd()) {
+export function check(cwd = process.cwd()) {
   const reporter = createCheckReporter()
   const { pass, fail } = reporter
 
@@ -174,17 +42,11 @@ export async function check(cwd = process.cwd()) {
     fail('Відсутній bunfig.toml — створи з [install] linker = "hoisted" (bun.mdc)')
   }
 
-  const cursorRules = await loadNCursorRules(cwd)
-
   const pkgPath = join(cwd, 'package.json')
   if (!existsSync(pkgPath)) {
     fail('Відсутній package.json у корені')
     return reporter.getExitCode()
   }
 
-  const pkg = JSON.parse(await readFile(pkgPath, 'utf8'))
-  const scripts = pkg.scripts && typeof pkg.scripts === 'object' ? pkg.scripts : {}
-  checkCursorRuleScripts(reporter, scripts, cursorRules)
-
   return reporter.getExitCode()
 }

package/rules/bun/policy/package_json/package_json.rego

@@ -9,9 +9,7 @@
 #    (правило `test` enabled завжди — див. `test/auto.md`; published workspace-и не мають
 #     `devDependencies` за `npm-module.mdc`)
 #
-# Перевірки, які ЗАЛИШИЛИСЬ у JS (потребують FS / cross-file):
-#  - `lint-docker` / `lint-k8s` коли `.n-cursor.json:rules` містить відповідне
-#    правило (потрібен другий файл-вхід — у Rego без `--combine` не зробити).
+# Перевірки, які потребують FS / cross-file контексту, лишаються у JS.
 package bun.package_json
 
 import rego.v1
@@ -47,12 +45,3 @@ allowed_root_dev_dependency(name) if {
 	# не мають `devDependencies` (`npm-module.mdc`).
 	name in allowed_root_test_deps
 }
-
-lint_prefixed_scripts := [name |
-	some name, _ in object.get(input, "scripts", {})
-	startswith(name, "lint-")
-]
-
-default lint_script := ""
-
-lint_script := input.scripts.lint if is_string(input.scripts.lint)

package/rules/docker/docker.mdc

@@ -182,15 +182,13 @@ RUN find ./ -type f -name "*.js" -exec gzip -k {} \;
 
 ## lint-docker
 
-CLI **`hadolint`** приймає лише **явні шляхи** (`[DOCKERFILE...]` у **`hadolint --help`**); обхід репозиторію робить CLI **`n-cursor lint-docker`** (реалізація — **`npm/rules/docker/js/run.mjs`**).
+CLI **`hadolint`** приймає лише **явні шляхи** (`[DOCKERFILE...]` у **`hadolint --help`**); обхід репозиторію робить правило **`n-cursor lint docker`** (реалізація — **`npm/rules/docker/js/lint.mjs`**).
 
 **Область lint-docker (вужча, ніж `check docker`):** лише файли з іменем **`Dockerfile`** та **`*.Dockerfile`** (суфікс **`.dockerfile`** без урахування регістру, наприклад **`api.Dockerfile`**). Файли **`Dockerfile.prod`**, **`Containerfile`** тощо **не** входять у **`lint-docker`**; їх ловить **`check docker`** (`rules/docker/fix.mjs`).
 
 Обхід: **`walkDir`** з тими самими пропусками каталогів, що й **`rules/docker/fix.mjs`**. Виклик **`hadolint`** як **нативного бінарника** через **`ensureTool`** (PATH → кеш → авто-install brew/scoop/GitHub Release; **без** `docker run`) — спільна логіка **`npm/rules/docker/lib/docker-hadolint.mjs`**.
 
-- Канон `package.json#scripts.lint-docker`: [package.json.snippet.json](./policy/package_json/template/package.json.snippet.json)
-
-Якщо правило **`docker`** підключено в **`.n-cursor.json`** (масив **`rules`**), у **кореневому** `package.json` **обов'язково** мають бути скрипт **`lint-docker`** і виклик **`bun run lint-docker`** у агрегованому **`lint`** (див. **`bun.mdc`**). Це перевіряє **`npx @nitra/cursor fix bun`**.
+Окремий `package.json`-скрипт `lint-docker` не потрібен і не перевіряється — єдина точка входу для правила: **`n-cursor lint docker`**.
 
 Додай workflow **`.github/workflows/lint-docker.yml`** (гілки **`dev`** і **`main`**, лише **`.yml`**, узгоджено з **`ga.mdc`**):
 
@@ -198,11 +196,9 @@ CLI **`hadolint`** приймає лише **явні шляхи** (`[DOCKERFILE
 
 Локально hadolint авто-встановлюється через **`ensureTool`** (latest, без піну версії). У CI встанови його кроком із workflow-сніпета (curl-download бінарника — без `docker run`).
 
-Кореневий скрипт **`lint`** (див. **`n-bun.mdc`**) **обов'язково** містить **`bun run lint-docker`**, коли в проєкті підключено правило **`docker`**.
-
 ## Запуск
 
-1. **`bun run lint-docker`** — **`run-docker.mjs`**: **`Dockerfile`** та **`*.Dockerfile`** (див. **`lint-docker`**); у CI встанови hadolint (приклад у workflow).
+1. **`n-cursor lint docker`** — **`js/lint.mjs`**: **`Dockerfile`** та **`*.Dockerfile`** (див. **`lint-docker`**); у CI використовуй **`n-cursor lint docker --read-only`** і встанови hadolint (приклад у workflow).
 2. **`npx @nitra/cursor fix docker`** — **`rules/docker/fix.mjs`**, виклик hadolint як у **`docker-hadolint.mjs`** (нативний бінарник через **`ensureTool`**; **без** `docker run`).
 3. Кореневий **`.hadolint.yaml`**: вимкнення правил, trusted registries — [документація](https://github.com/hadolint/hadolint#configure). Щоб не додавати **`# hadolint ignore=DL3007`** у кожному **`FROM`** з **`:latest`**, у корені репозиторію задати глобально:
 

package/rules/docker/lint/docs/lint.md

@@ -148,9 +148,9 @@ if (isRunAsCli(import.meta.url)) {
 
 ## Потік виконання / Використання
 
-### Послідовність дій при `n-cursor lint-docker`
+### Послідовність дій при `n-cursor lint docker`
 
-1. `bin/n-cursor.js` диспатчить підкоманду `lint-docker` на `runLintDocker` із цього модуля.
+1. `bin/n-cursor.js` диспатчить правило `docker` на `npm/rules/docker/js/lint.mjs`, яке використовує `runLintDocker` із цього модуля.
 2. `runLintDocker` → `runStandardLint(import.meta.dirname, runLintDockerSteps)`:
    - бере серіалізаційний лок на ім’я `lint-docker`;
    - перевіряє стан git-дерева; якщо стан збігається з попереднім успішним прогоном — крок може бути пропущено (дедуп);
@@ -167,7 +167,7 @@ if (isRunAsCli(import.meta.url)) {
 
 ### Як це використовується ззовні
 
-- **CLI:** `bun run n-cursor lint-docker` (або відповідний bin-скрипт) — основний сценарій.
+- **CLI:** `n-cursor lint docker` — основний сценарій.
 - **Програмно з інших скриптів:**
 
   ```js

package/rules/docker/meta.json

@@ -1 +1 @@
-{ "auto": { "glob": ["**/Dockerfile", "**/Dockerfile.*"] } }
+{ "auto": { "glob": ["**/Dockerfile", "**/Dockerfile.*"] }, "lint": "full" }

package/rules/docker/policy/lint_docker_yml/lint_docker_yml.rego

@@ -3,7 +3,7 @@
 # Канон надходить через --data: { "template": { "snippet": ... } }
 # Структура --data сформована з template/lint-docker.yml.snippet.yml.
 # Path-маркери, hadolint версія (substring "v2.12.0" у run), setup-bun-deps
-# composite, `bun run lint-docker` substring — все читається з template's snippet.
+# composite, `n-cursor lint docker --read-only` substring — все читається з template's snippet.
 # Універсальні workflow-перевірки — у `ga.workflow_common`.
 package docker.lint_docker_yml
 

package/rules/docker/policy/lint_docker_yml/template/lint-docker.yml.snippet.yml

@@ -38,4 +38,4 @@ jobs:
       - uses: ./.github/actions/setup-bun-deps
 
       - name: Lint Docker
-        run: bun run lint-docker
+        run: n-cursor lint docker --read-only

package/rules/docker/policy/package_json/package_json.rego

@@ -1,9 +1,9 @@
 # Перевірка `package.json` (docker.mdc).
 #
 # Канон надходить через --data: { "template": { "snippet": ... } }
-# Перевіряє ЛИШЕ зміст значення `scripts.lint-docker`, якщо ключ присутній.
-# Умовну обовʼязковість (правило `docker` у `.n-cursor.json` → `scripts.lint-docker`
-# зобовʼязаний існувати) перевіряє `rules/bun/fix.mjs` через cross-file логіку.
+# Backward-compatible: перевіряє ЛИШЕ зміст значення `scripts.lint-docker`, якщо ключ
+# присутній у старому проєкті. Нові проєкти використовують `n-cursor lint docker`
+# напряму, без package.json wrapper.
 package docker.package_json
 
 import rego.v1

package/rules/docker/policy/package_json/template/package.json.snippet.json

@@ -1 +1 @@
-{ "scripts": { "lint-docker": "n-cursor lint-docker" } }
+{ "scripts": { "lint-docker": "n-cursor lint docker" } }

package/rules/image-avif/image-avif.mdc

@@ -5,7 +5,7 @@ globs: "**/*.{png,jpg,jpeg,gif,avif,vue,html}"
 alwaysApply: false
 ---
 
-AVIF-двійники (`<name>.<ext>.avif`) генерує **виключно** `npx @nitra/cursor fix image-avif` — у `lint-image` прапорець `--avif` заборонений (це валідує правило `image-compress`). Перевірка робить чотири кроки в порядку:
+AVIF-двійники (`<name>.<ext>.avif`) генерує **виключно** `npx @nitra/cursor fix image-avif`. Правило `image-compress` відповідає лише за стиснення початкових raster/SVG-файлів через `@nitra/minify-image`, а AVIF лишається окремим правилом. Перевірка робить чотири кроки в порядку:
 
 1. **Pre-scan**: шукає у `.vue`/`.html` хоча б одне raster-посилання, яке потенційно треба переписати на AVIF-двійник (`import x from '...png'` або `<img src="...png" />`). Пакети з opt-out `disable-avif: true` пропускаються. **Якщо жодного raster-посилання не знайдено — `check image-avif` завершується успіхом одразу: ні `npx --avif`, ні rewrite, ні cleanup-сиріт не виконуються** (нічого було б змінювати). Так уникаємо дорогого `npx @nitra/minify-image` у проєктах, де AVIF не вживається.
 2. Запускає `npx @nitra/minify-image --src=. --write --avif` (≥ **3.3.1**) — генерує `<name>.<ext>.avif` поряд з кожним PNG/JPEG/GIF. CLI порівнює sha1 кожного raster-сорсу зі збереженим у `.n-minify-image.tsv` і перезаписує `<source>.avif` при зміні оригіналу.

package/rules/image-avif/js/avif_generation.mjs

@@ -389,7 +389,7 @@ async function cleanupOrphanAvifs(usedAvifAbs, optedOutAbs, ignorePaths, cwd) {
 
 /**
  * Виконує AVIF-етап: запуск AVIF-генерації, авто-заміна raster-посилань у `.vue`/`.html`,
- * видалення AVIF-сиріт. Не валідує `package.json`/`lint-image` — це вже у `image-compress`.
+ * видалення AVIF-сиріт. Не валідує image-compress cache/dependency policy — це окреме правило.
  * @param {string} [cwd] корінь репозиторію
  * @returns {Promise<number>} 0 — все OK, 1 — є проблеми
  */

package/rules/image-avif/js/docs/avif_generation.md

@@ -15,7 +15,7 @@ docgen:
 3. **Rewrite-пасс** — для кожного workspace-пакета (без opt-out) переписує raster-посилання у `.vue`/`.html` на `<...>.avif`, якщо двійник реально існує на диску. Якщо двійника немає (наприклад, оригіналу теж нема) — фейлить конкретне посилання.
 4. **Cleanup-пасс** — видаляє AVIF-сироти (`<...>.avif`, на які не лишилось жодного посилання у `.vue`/`.html` репозиторію), реалізуючи умову «AVIF лишається лише там, де заміна вдалася».
 
-Модуль свідомо не дублює перевірки скрипта `lint-image` (заборона `--avif` у ньому) — це залишається у правилі `image-compress`. Правило `image-avif` самостійне й вмикається лише там, де AVIF підтримується (адмінки), а не у публічних сайтах.
+Модуль свідомо не дублює перевірки cache/dependency policy з правила `image-compress`. Правило `image-avif` самостійне й вмикається лише там, де AVIF підтримується (адмінки), а не у публічних сайтах.
 
 ## Експорти / API
 

package/rules/image-compress/image-compress.mdc

@@ -1,20 +1,19 @@
 ---
-description: Оптимізація raster/SVG через @nitra/minify-image у локальному lint
+description: Оптимізація raster/SVG через @nitra/minify-image у n-cursor lint
 version: '1.2'
 globs: "**/*.{png,jpg,jpeg,gif,svg}"
 alwaysApply: false
 ---
 
-CLI [`@nitra/minify-image`](https://www.npmjs.com/package/@nitra/minify-image) (≥ **3.3.1**) запускається через `npx` і **не** додається в `dependencies` / `devDependencies`. Канонічний `lint-image` — авто-оптимізація з прапорцем `--write`: стискає raster/SVG на місці. **AVIF-генерація (`--avif`) у `lint-image` заборонена** — її виконує окреме правило `image-avif`.
+CLI [`@nitra/minify-image`](https://www.npmjs.com/package/@nitra/minify-image) (≥ **4.0.1**) запускається через `npx` і **не** додається в `dependencies` / `devDependencies`. Запуск — через **`n-cursor lint image-compress`**: локально (fix) виконує `npx @nitra/minify-image --src=. --write`, у `--read-only` виконує `npx @nitra/minify-image --src=. --json` і падає, якщо `summary.needsCompression > 0`. **AVIF-генерація (`--avif`) у `image-compress` не входить** — її виконує окреме правило `image-avif`.
 
-Перевірка лише локальна — у CI `lint-image` не запускаємо. Окремий workflow `lint-image.yml` створювати не треба.
+Окремий workflow `lint-image.yml` створювати не треба; якщо потрібен CI-gate для зображень, використовуй `n-cursor lint image-compress --read-only`.
 
 ## `package.json`
 
-- Канон `lint-image` (substring requirements): [package.json.contains.json](./policy/package_json/template/package.json.contains.json)
 - Заборонені залежності `@nitra/minify-image` у deps/devDeps: [package.json.deny.json](./policy/package_json/template/package.json.deny.json)
 
-Якщо в `package.json` уже є агрегований `lint`, додай у його ланцюжок `bun run lint-image` (як `bun run lint-text`, `bun run lint-js`, `bun run lint-ga`). Так розробник, що локально гонить `bun run lint`, перед фіксацією одразу бачить, чи зросли зображення.
+Окремий `package.json`-скрипт `lint-image` не потрібен і не перевіряється — єдина точка входу `n-cursor lint image-compress`.
 
 ## Кеш
 

package/rules/image-compress/js/docs/index.md

@@ -8,4 +8,5 @@ resource: npm/rules/image-compress/js/
 
 | Файл | Тип |
 |---|---|
+| [lint.mjs](lint.md) | JS Module |
 | [package_setup.mjs](package_setup.md) | JS Module |

package/rules/image-compress/js/docs/lint.md

@@ -0,0 +1,24 @@
+---
+type: JS Module
+title: lint.mjs
+resource: npm/rules/image-compress/js/lint.mjs
+---
+
+Адаптер підключає `@nitra/minify-image` до єдиної точки входу `n-cursor lint image-compress`.
+
+## Поведінка
+
+1. У fix-режимі запускає `npx @nitra/minify-image --src=. --write`.
+2. У read-only режимі запускає `npx @nitra/minify-image --src=. --json`.
+3. Парсить JSON-звіт і падає, якщо `summary.needsCompression > 0`.
+4. Повертає exit code дочірнього процесу або reporter exit code.
+
+## Публічний API
+
+`lint` — оркестраторний entrypoint для правила `image-compress`.
+
+## Гарантії поведінки
+
+- Read-only режим не стискає файли і не пише cache, покладаючись на `--json` detect-mode у `@nitra/minify-image`.
+- Fix-режим делегує запис тільки `@nitra/minify-image --write`.
+- За помилки запуску або невалідного JSON повертає ненульовий exit code.

package/rules/image-compress/js/docs/package_setup.md

@@ -18,7 +18,7 @@ docgen:
 
 ## Публічний API
 
-check — Перевіряє, чи відсутній у `.gitignore` файл `.n-minify-image.tsv` та чи видалено `.minify-image-cache.tsv`. Вказує, що CI-workflow для image не потрібен, оскільки лінтування зображень відбувається лише локально. (image-compress.mdc)
+check — Перевіряє, чи відсутній у `.gitignore` файл `.n-minify-image.tsv` та чи видалено `.minify-image-cache.tsv`. Package-level стискання зображень виконує `n-cursor lint image-compress`, а read-only CI-gate використовує JSON detect-mode `@nitra/minify-image --json`. (image-compress.mdc)
 
 ## Гарантії поведінки
 

package/rules/image-compress/js/lint.mjs

@@ -0,0 +1,78 @@
+/** @see ./docs/lint.md */
+import { spawnSync } from 'node:child_process'
+
+import { createCheckReporter } from '../../../scripts/lib/check-reporter.mjs'
+
+const JSON_MAX_BUFFER = 20 * 1024 * 1024
+
+/**
+ * Парсить JSON-звіт `@nitra/minify-image --json`.
+ * @param {string} stdout stdout дочірнього процесу
+ * @returns {{ summary?: { needsCompression?: unknown, total?: unknown } }} розпарсений звіт
+ */
+function parseMinifyJson(stdout) {
+  return JSON.parse(stdout)
+}
+
+/**
+ * Read-only detect-mode для `image-compress`: `@nitra/minify-image --json` не стискає файли і не
+ * пише cache, але повідомляє скільки зображень не відповідають `.n-minify-image.tsv`.
+ * @param {string} cwd корінь
+ * @returns {number} exit code
+ */
+function runJsonDetect(cwd) {
+  const reporter = createCheckReporter()
+  const { pass, fail } = reporter
+
+  const r = spawnSync('npx', ['@nitra/minify-image', '--src=.', '--json'], {
+    cwd,
+    encoding: 'utf8',
+    env: process.env,
+    maxBuffer: JSON_MAX_BUFFER
+  })
+  if (r.error) {
+    fail(`image-compress: не вдалося запустити npx @nitra/minify-image --json: ${r.error.message}`)
+    return reporter.getExitCode()
+  }
+  if (r.status !== 0) {
+    const detail = [r.stdout, r.stderr].filter(Boolean).join('\n').trim()
+    fail(`image-compress: @nitra/minify-image --json завершився з кодом ${r.status}${detail ? `:\n${detail}` : ''}`)
+    return reporter.getExitCode()
+  }
+
+  let report
+  try {
+    report = parseMinifyJson(r.stdout)
+  } catch {
+    fail('image-compress: @nitra/minify-image --json повернув невалідний JSON')
+    return reporter.getExitCode()
+  }
+
+  const needsCompression = Number(report.summary?.needsCompression ?? 0)
+  const total = Number(report.summary?.total ?? 0)
+  if (needsCompression > 0) {
+    fail(
+      `image-compress: ${needsCompression}/${total} image-файлів потребують стиснення — запусти \`n-cursor lint image-compress\` локально`
+    )
+  } else {
+    pass(`image-compress: ${total} image-файлів синхронізовані з .n-minify-image.tsv`)
+  }
+  return reporter.getExitCode()
+}
+
+/**
+ * Оркестраторний адаптер `n-cursor lint image-compress`.
+ * @param {string[] | undefined} _files ігнорується; `@nitra/minify-image` сам обходить дерево
+ * @param {string} [cwd] корінь
+ * @param {{ readOnly?: boolean }} [opts] readOnly → `--json`, fix → `--write`
+ * @returns {Promise<number>} exit code
+ */
+export function lint(_files, cwd = process.cwd(), opts = {}) {
+  if (opts.readOnly === true) return Promise.resolve(runJsonDetect(cwd))
+  const r = spawnSync('npx', ['@nitra/minify-image', '--src=.', '--write'], { cwd, env: process.env, stdio: 'inherit' })
+  if (r.error) {
+    console.error(`image-compress: не вдалося запустити npx @nitra/minify-image --write: ${r.error.message}`)
+    return Promise.resolve(1)
+  }
+  return Promise.resolve(typeof r.status === 'number' ? r.status : 1)
+}

package/rules/image-compress/meta.json

@@ -1 +1 @@
-{ "auto": { "glob": "**/*.{png,jpg,jpeg,gif,svg}" } }
+{ "auto": { "glob": "**/*.{png,jpg,jpeg,gif,svg}" }, "lint": "full" }

package/rules/image-compress/policy/package_json/package_json.rego

@@ -1,25 +1,11 @@
 # Перевірка `package.json` (image-compress.mdc).
 #
-# Канон надходить через --data: { "template": { "contains": ..., "deny": ... } }
-# Структура --data сформована з template/package.json.{contains,deny}.json.
-#
-# Логіка, що ЛИШАЄТЬСЯ у rego (inverse-patterns, не виносяться у template):
-#  - `--avif` ЗАБОРОНЕНИЙ підрядок у `lint-image` (anti-contains);
-#  - агрегатор `lint` (якщо `lint-image` присутній) має містити `bun run lint-image`.
+# Канон надходить через --data: { "template": { "deny": ... } }.
+# Структура --data сформована з template/package.json.deny.json.
 package image_compress.package_json
 
 import rego.v1
 
-# ── deny: scripts.<name> має містити кожен substring з template.contains ─
-
-deny contains msg if {
-	some script_name, needles in data.template.contains.scripts
-	actual := object.get(object.get(input, "scripts", {}), script_name, "")
-	some needle in needles
-	not contains(actual, needle)
-	msg := sprintf("package.json: scripts.%s має містити %q (image-compress.mdc)", [script_name, needle])
-}
-
 # ── deny: top-level deps/devDeps з template.deny ─────────────────────────
 
 deny contains msg if {
@@ -33,21 +19,3 @@ deny contains msg if {
 	pkg in object.keys(object.get(input, "devDependencies", {}))
 	msg := sprintf("package.json: devDependencies.%s — %s", [pkg, reason])
 }
-
-# ── deny: `--avif` заборонений у `lint-image` (anti-contains, у rego) ────
-
-deny contains msg if {
-	lint_image := object.get(object.get(input, "scripts", {}), "lint-image", "")
-	contains(lint_image, "--avif")
-	msg := "package.json: lint-image не має містити `--avif` — AVIF-генерацію виконує check image-avif (image-compress.mdc)"
-}
-
-# ── deny: агрегатор `lint` (якщо `lint-image` є) ─────────────────────────
-
-deny contains msg if {
-	"lint-image" in object.keys(object.get(input, "scripts", {}))
-	lint := object.get(object.get(input, "scripts", {}), "lint", "")
-	lint != ""
-	not contains(lint, "bun run lint-image")
-	msg := "package.json: агрегований `lint` має містити `bun run lint-image` (image-compress.mdc)"
-}

package/rules/k8s/js/lint.mjs

@@ -0,0 +1,14 @@
+/** @see ./docs/lint.md */
+import { runLintK8s } from '../lint/lint.mjs'
+
+/**
+ * Оркестраторний адаптер `n-cursor lint k8s` (лінтер-фаза): kubeconform + kubescape по деревах
+ * `.../k8s/*.yaml` через `runLintK8s` (read-only тули — мутацій немає, тож `opts` ігнорується).
+ * Структурні k8s.mdc-перевірки (manifest/kustomization/network_policy) — у конформність-фазі.
+ * Без `.../k8s`-маніфестів крок — no-op.
+ * @param {string[] | undefined} _files ігнорується (whole-repo обхід `.../k8s`)
+ * @returns {Promise<number>} exit code
+ */
+export function lint(_files) {
+  return runLintK8s()
+}

package/rules/k8s/k8s.mdc

@@ -43,17 +43,7 @@ alwaysApply: false
 
 Підстав свою `attributes.name` (рядок або regex), якщо ConfigMap зветься інакше; виключай контрольно, а не глобально (не додавай винятки без `attributes.name`/`labels`, бо тоді C-0012 знімається для усіх ConfigMap-ів проєкту і реальні витоки credentials теж пройдуть).
 
-У репозиторії пакета **`@nitra/cursor`** скрипт **`lint-k8s`** делегує до CLI **`n-cursor lint-k8s`** (реалізація — **`npm/rules/k8s/js/run.mjs`**). У інших проєктах достатньо встановити **`@nitra/cursor`** у `devDependencies` — бінарка **`n-cursor`** буде у **`node_modules/.bin/`**.
-
-```json title="package.json"
-{
-  "scripts": {
-    "lint-k8s": "n-cursor lint-k8s"
-  }
-}
-```
-
-Якщо правило **`k8s`** підключено в **`.n-cursor.json`** (масив **`rules`**), у **кореневому** `package.json` **мають** бути скрипт **`lint-k8s`** і виклик **`bun run lint-k8s`** у агрегованому **`lint`** (див. **`bun.mdc`**). Це перевіряє **`npx @nitra/cursor fix bun`**.
+Лінт запускається через правило **`n-cursor lint k8s`** (реалізація — **`npm/rules/k8s/js/lint.mjs`**, делегує kubeconform/kubescape у **`npm/rules/k8s/lint/lint.mjs`**). Окремий `package.json`-скрипт `lint-k8s` не потрібен і не перевіряється.
 
 Додай workflow **`.github/workflows/lint-k8s.yml`** (гілки **`dev`** і **`main`**, лише **`.yml`**, узгоджено з **`ga.mdc`**). **Не** дублюй **`setup-node`**, **`oven-sh/setup-bun`**, **`actions/cache`** і **`bun install`** у job — після **`checkout`** використовуй локальний composite **`setup-bun-deps`** (шлях **`./.github/actions/setup-bun-deps`** або **`./npm/github-actions/setup-bun-deps`**, як у репозиторії). Встановлення **kubeconform** / **kubescape** лишаються окремими кроками.
 
@@ -103,7 +93,7 @@ jobs:
       # (kubectl уже доступний на github-hosted runner'ах: https://github.com/actions/runner-images).
 
       - name: Lint K8s
-        run: bun run lint-k8s
+        run: n-cursor lint k8s --read-only
 ```
 
 ## Deployment: `resources.requests` (CPU і memory)

package/rules/k8s/lint/docs/lint.md

@@ -317,12 +317,10 @@ CLI-режим: при прямому виконанні скрипта (`bun np
 
 ## Потік виконання / Використання
 
-### CLI-режим (підкоманда `lint-k8s`)
+### CLI-режим
 
 ```
-bun run lint-k8s             # через root-script (workspace)
-# або
-n-cursor lint-k8s            # CLI-обгортка
+n-cursor lint k8s            # rule orchestration entrypoint
 # або (наприкінці файлу — прямий запуск)
 bun npm/rules/k8s/lint/lint.mjs
 ```

package/rules/k8s/meta.json

@@ -1 +1 @@
-{ "auto": { "glob": "**/k8s/**" } }
+{ "auto": { "glob": "**/k8s/**" }, "lint": "full" }

package/rules/php/js/lint.mjs

@@ -1,13 +1,15 @@
 /** @see ./docs/lint.md */
 import { run } from '../lint/lint.mjs'
+import { runStandardLint } from '../../../scripts/lib/run-standard-lint.mjs'
 
 /**
  * Оркестраторний адаптер `n-cursor lint php` (лінтер-фаза): composer audit + php-cs-fixer
  * (`--dry-run`) + phpstan/psalm через `run` (read-only — мутацій немає, тож `opts` ігнорується).
  * Структурні php.mdc-перевірки — у конформність-фазі. Без composer-інструментів крок — no-op.
  * @param {string[] | undefined} _files ігнорується (whole-repo обхід)
- * @returns {number} exit code
+ * @param {string} [cwd] корінь
+ * @returns {Promise<number>} exit code
  */
-export function lint(_files) {
-  return run()
+export function lint(_files, cwd = process.cwd()) {
+  return runStandardLint(import.meta.dirname, () => run(cwd))
 }

package/rules/php/lint/lint.mjs

@@ -63,13 +63,14 @@ function runTool(label, abs, args, pass, fail) {
 
 /**
  * Запускає `lint-php`.
+ * @param {string} [cwd] корінь репозиторію
  * @returns {number} 0 — OK, 1 — є помилки
  */
-export function run() {
+export function run(cwd = process.cwd()) {
   const reporter = createCheckReporter()
   const { pass, fail } = reporter
 
-  const root = process.cwd()
+  const root = cwd
   if (!existsSync(join(root, 'composer.json'))) {
     pass('lint-php: немає composer.json у корені — кроки PHP пропущено')
     return reporter.getExitCode()

package/rules/php/meta.json

@@ -1 +1 @@
-{ "auto": { "glob": "composer.json" } }
+{ "auto": { "glob": "composer.json" }, "lint": "full" }

package/rules/rust/js/lint.mjs

@@ -4,6 +4,7 @@ import { existsSync } from 'node:fs'
 import { join } from 'node:path'
 
 import { createCheckReporter } from '../../../scripts/lib/check-reporter.mjs'
+import { runStandardLint } from '../../../scripts/lib/run-standard-lint.mjs'
 import { resolveCmd } from '../../../scripts/utils/resolve-cmd.mjs'
 
 /**
@@ -36,7 +37,7 @@ function runCargo(label, cargo, args, pass, fail) {
  * @param {{ readOnly?: boolean }} [opts] readOnly → без мутацій
  * @returns {number} exit code
  */
-export function lint(_files, cwd = process.cwd(), opts = {}) {
+function runRustLint(cwd = process.cwd(), opts = {}) {
   const readOnly = opts.readOnly === true
   const reporter = createCheckReporter()
   const { pass, fail } = reporter
@@ -65,3 +66,14 @@ export function lint(_files, cwd = process.cwd(), opts = {}) {
   runCargo('cargo clippy -D warnings', cargo, ['clippy', '--all-targets', '--all-features', '--', '-D', 'warnings'], pass, fail)
   return reporter.getExitCode()
 }
+
+/**
+ * Locked orchestration entry point for `n-cursor lint rust`.
+ * @param {string[] | undefined} _files ігнорується (cargo обходить crate сам)
+ * @param {string} [cwd] корінь
+ * @param {{ readOnly?: boolean }} [opts] readOnly → без мутацій
+ * @returns {Promise<number>} exit code
+ */
+export function lint(_files, cwd = process.cwd(), opts = {}) {
+  return runStandardLint(import.meta.dirname, () => runRustLint(cwd, opts))
+}

package/rules/rust/meta.json

@@ -1 +1 @@
-{ "auto": { "glob": "**/Cargo.toml" } }
+{ "auto": { "glob": "**/Cargo.toml" }, "lint": "full" }

package/rules/image-compress/policy/package_json/template/package.json.contains.json

@@ -1,5 +0,0 @@
-{
-  "scripts": {
-    "lint-image": ["npx @nitra/minify-image", "--src=.", "--write"]
-  }
-}