@nitra/cursor 12.3.3 → 12.5.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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
+
+- Уніфіковано selection linter-фази: unscoped n-cursor lint бере правила з .n-cursor.json, а meta.json#lint лишається тільки scope-класифікацією.
+
 ## [12.3.3] - 2026-06-20
 
 ### Changed

package/package.json

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

package/rules/bun/bun.mdc

@@ -68,8 +68,8 @@ FROM oven/bun:alpine AS build-env
 
 Лінт запускається через CLI **`n-cursor`**, **не** через `package.json`-скрипти:
 
-- **`n-cursor lint --full`** — весь репо: усі правила (per-file лінтери + конформність) + `oxfmt` у кінці (fix-режим);
-- **`n-cursor lint`** — дельта vs origin (per-file лінтери лише змінених файлів);
+- **`n-cursor lint --full`** — весь репо: активні у `.n-cursor.json` правила (per-file + full лінтери за `meta.json#lint` scope, конформність) + `oxfmt` у кінці (fix-режим);
+- **`n-cursor lint`** — дельта vs origin (активні у `.n-cursor.json` per-file лінтери лише змінених файлів);
 - **`n-cursor lint <rule…>`** — конкретні правила (лінтер + конформність), напр. **`n-cursor lint ga`**.
 
 У кореневому `package.json` **не повинно бути** `lint`/`lint-*` скриптів — єдина точка лінту — CLI `n-cursor`. У CI кожен workflow викликає **`n-cursor lint <rule> --read-only`** напряму (без обгорток).

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/lint/js/docs/orchestrate.md

@@ -11,12 +11,12 @@ docgen:
 
 ## Огляд
 
-Модуль відповідає за визначення та виконання процесу лінтування коду. Функція `selectLintRules` вибирає та сортує ідентифікатори правил лінтування на основі конфігурацій, визначених у meta.json. Функція `runLint` запускає перевірку обраних правил для змінених або всіх файлів репозиторію.
+Модуль відповідає за визначення та виконання процесу лінтування коду. Unscoped linter-фаза бере активні правила з `.n-cursor.json`, а `meta.json#lint` використовує лише як класифікацію scope (`per-file` або `full`). Функція `runLint` запускає перевірку обраних правил для змінених або всіх файлів репозиторію.
 
 ## Поведінка
 
-selectLintRules вибирає і сортує ідентифікатори правил для лінтування на основі їхніх конфігурацій, включаючи можливість включення правил, що застосовуються до всього репозиторію.
-runLint запускає процес лінтування, виконуючи перевірку правил для змінених файлів або для всього репозиторію, залежно від наданих опцій, і може виконувати форматування.
+selectLintRules вибирає і сортує ідентифікатори правил для лінтування з уже активованого списку `.n-cursor.json`, включаючи можливість включення правил, що застосовуються до всього репозиторію.
+runLint запускає процес лінтування, виконуючи перевірку активних правил для змінених файлів або для всього репозиторію, залежно від наданих опцій, і може виконувати форматування. Scoped режим `lint <rule…>` запускає названі правила напряму та не потребує `.n-cursor.json` для linter-фази.
 
 ## Публічний API
 

package/rules/lint/js/orchestrate.mjs

@@ -8,6 +8,7 @@ import { spawnSync } from 'node:child_process'
 import { parseRuleLintSpec, readRuleMetaRaw } from '../../../scripts/lib/rule-meta.mjs'
 import { collectChangedFilesSince, resolveChangedBase } from '../../../scripts/lib/changed-files.mjs'
 import { resolveCmd } from '../../../scripts/utils/resolve-cmd.mjs'
+import { isRuleEnabled, readNCursorConfigLite } from '../../../scripts/lib/read-n-cursor-config-lite.mjs'
 
 // Цей файл: npm/rules/lint/js/orchestrate.mjs → PACKAGE_ROOT = npm (чотири dirname угору).
 const PACKAGE_ROOT = dirname(dirname(dirname(dirname(fileURLToPath(import.meta.url)))))
@@ -42,17 +43,33 @@ async function runConformance(cwd, readOnly, log, filter = []) {
  * Вибирає id правил для контексту, алфавітно.
  * @param {Record<string, {lint?: unknown}>} metaById мапа id → meta-обʼєкт
  * @param {boolean} full `false` → лише `per-file` правила; `true` → усі (`per-file` ∪ `full`)
+ * @param {string[]} enabledRuleIds активні rule-id з `.n-cursor.json`
  * @returns {string[]} відсортовані id
  */
-export function selectLintRules(metaById, full) {
+export function selectLintRules(metaById, full, enabledRuleIds) {
+  const enabled = new Set(enabledRuleIds)
   const out = []
   for (const [id, raw] of Object.entries(metaById)) {
+    if (!enabled.has(id)) continue
     const scope = parseRuleLintSpec(raw?.lint)
     if (scope === 'per-file' || (full && scope === 'full')) out.push(id)
   }
   return out.toSorted((a, b) => a.localeCompare(b))
 }
 
+/**
+ * Активні правила для unscoped linter-фази. `.n-cursor.json` — єдине джерело
+ * whitelist/disable, `meta.json#lint` нижче використовується лише як scope (`per-file`/`full`).
+ * @param {Record<string, unknown>} metaById доступні bundled правила
+ * @param {string} cwd корінь
+ * @returns {Promise<string[]>} активні rule-id з конфіга, що існують у пакеті
+ */
+async function readEnabledLintRuleIds(metaById, cwd) {
+  const config = await readNCursorConfigLite(cwd)
+  if (!config.exists) return []
+  return Object.keys(metaById).filter(id => isRuleEnabled(config, id))
+}
+
 /**
  * Зчитує meta всіх правил пакета.
  * @param {string} rulesDir каталог rules
@@ -130,7 +147,7 @@ async function runFullConformancePhase(cwd, readOnly, log) {
  * @param {(s: string) => void} log логер
  * @returns {Promise<number>} код виходу oxfmt (0 — OK або пропущено)
  */
-async function runFormat(cwd, log) {
+function runFormat(cwd, log) {
   const oxfmt = resolveCmd('oxfmt')
   if (!oxfmt) {
     log('ℹ️  lint: oxfmt недоступний у PATH — формат-крок пропущено.\n')
@@ -201,7 +218,8 @@ export async function runLint(opts = {}) {
   }
 
   const metaById = readAllMeta(rulesDir)
-  const ids = selectLintRules(metaById, full)
+  const enabledRuleIds = await readEnabledLintRuleIds(metaById, cwd)
+  const ids = selectLintRules(metaById, full, enabledRuleIds)
   const perFile = await runPerFileRules(ids, { rulesDir, changed, cwd, readOnly, metaById, log })
   if (perFile.stop) return perFile.code
   let worst = perFile.code
@@ -219,7 +237,7 @@ export async function runLint(opts = {}) {
   // Формат-крок (oxfmt): fix-режим — завжди (будь-який scope); read-only пропускаємо (нуль
   // мутацій). Кастомний rulesDir (юніт-тести) — реальний пакет недоступний, тож пропускаємо.
   if (!readOnly && opts.rulesDir === undefined) {
-    const fmtCode = await runFormat(cwd, log)
+    const fmtCode = runFormat(cwd, log)
     if (fmtCode !== 0) worst = fmtCode
   }
   return worst

package/rules/php/js/docs/index.md

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

package/rules/php/js/docs/lint.md

@@ -0,0 +1,20 @@
+---
+type: JS Module
+title: lint.mjs
+resource: npm/rules/php/js/lint.mjs
+docgen:
+  crc: 7de6b473
+  score: 100
+---
+
+Оркестраторний адаптер правила `php` для `n-cursor lint`. Делегує лінтер-фазу наявній функції `run` із `../lint/lint.mjs` (composer audit, php-cs-fixer у `--dry-run`, phpstan/psalm). Режиму на рівні окремих файлів немає — composer-інструменти працюють по всьому проєкту, тож параметр `files` ігнорується. Інструменти read-only (`--dry-run`/`analyse`), тож мутацій робочого дерева немає.
+
+## Поведінка
+
+1. Викликає `run` — лінтер-фаза php по всьому проєкту.
+2. Повертає код виходу інструменту.
+
+## Гарантії поведінки
+
+- Read-only: інструменти не мутують робоче дерево.
+- Не звертається до мережі напряму (composer-кроки можуть, але це поведінка делегата, не цього модуля).

package/rules/php/js/lint.mjs

@@ -0,0 +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 обхід)
+ * @param {string} [cwd] корінь
+ * @returns {Promise<number>} exit code
+ */
+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/php/php.mdc

@@ -63,9 +63,7 @@ composer audit
 
 ## lint-php
 
-`composer`-інструмененти не мають єдиного CLI, який сам обходить репозиторій, тому `lint-php` зручно делегувати у JS-скрипт-обгортку (як `lint-docker`, `lint-k8s`).
-
-- Канон `package.json#scripts.lint-php` (substring requirement): [package.json.contains.json](./policy/package_json/template/package.json.contains.json)
+`composer`-інструмененти не мають єдиного CLI, який сам обходить репозиторій, тому php-лінт делегується у JS-скрипт-обгортку. Запуск — через **`n-cursor lint php`** (CI — `--read-only`); окремого `package.json`-скрипта немає.
 
 Скрипт `run-php.mjs`:
 

package/rules/php/policy/lint_php_yml/template/lint-php.yml.snippet.yml

@@ -44,4 +44,4 @@ jobs:
         run: composer install --no-interaction --no-progress --prefer-dist
 
       - name: Lint PHP
-        run: bun run lint-php
+        run: n-cursor lint php --read-only

package/rules/python/policy/lint_python_yml/template/lint-python.yml.snippet.yml

@@ -38,4 +38,4 @@ jobs:
         run: uv sync --frozen
 
       - name: Lint Python
-        run: bun run lint-python
+        run: n-cursor lint python --read-only

package/rules/python/python.mdc

@@ -27,9 +27,7 @@ Python-проєкти ведуться **виключно** на [uv](https://do
 
 ## lint-python
 
-Інструменти uv-екосистеми не мають єдиного CLI, що сам обходить репозиторій, тому `lint-python` делегується у JS-скрипт-обгортку (як `lint-php`, `lint-docker`).
-
-- Канон `package.json#scripts.lint-python` (substring requirement): [package.json.contains.json](./policy/package_json/template/package.json.contains.json)
+Інструменти uv-екосистеми не мають єдиного CLI, що сам обходить репозиторій, тому python-лінт делегується у JS-скрипт-обгортку. Запуск — через **`n-cursor lint python`** (CI — `--read-only`); окремого `package.json`-скрипта немає.
 
 Скрипт `rules/python/lint/lint.mjs`:
 

package/rules/rust/js/docs/index.md

@@ -9,3 +9,4 @@ resource: npm/rules/rust/js/
 | Файл | Тип |
 |---|---|
 | [applies.mjs](applies.md) | JS Module |
+| [lint.mjs](lint.md) | JS Module |

package/rules/rust/js/docs/lint.md

@@ -0,0 +1,21 @@
+---
+type: JS Module
+title: lint.mjs
+resource: npm/rules/rust/js/lint.mjs
+docgen:
+  crc: 5d7c4123
+  score: 100
+---
+
+Оркестраторний адаптер правила `rust` для `n-cursor lint`: rustfmt + clippy через `cargo`. Запускається на `n-cursor lint rust`. За відсутності `Cargo.toml` у корені — no-op (вихід 0). `cargo`/`rustfmt`/`clippy` резолвляться з PATH (Rust toolchain через rustup), не з npm-залежностей; якщо `cargo` відсутній за наявного `Cargo.toml` — помилка.
+
+## Поведінка
+
+1. `readOnly` (CI): `cargo fmt --all -- --check` + `cargo clippy --all-targets --all-features -- -D warnings` — детект без мутацій.
+2. fix-режим: `cargo fmt --all` + `cargo clippy --fix` + фінальний `cargo clippy … -D warnings`.
+3. Перший ненульовий cargo-крок спиняє ланцюг і повертає його код.
+
+## Гарантії поведінки
+
+- Read-only за наявності `readOnly`: cargo не мутує робоче дерево (`--check`, без `--fix`).
+- Не звертається до мережі напряму (cargo-кроки можуть тягнути crates, але це поведінка тулчейну).

package/rules/rust/js/lint.mjs

@@ -0,0 +1,79 @@
+/** @see ./docs/lint.md */
+import { spawnSync } from 'node:child_process'
+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'
+
+/**
+ * Запускає cargo-крок і репортить результат.
+ * @param {string} label назва кроку
+ * @param {string} cargo абсолютний шлях до `cargo`
+ * @param {string[]} args аргументи
+ * @param {(m: string) => void} pass callback pass
+ * @param {(m: string) => void} fail callback fail
+ * @returns {boolean} true якщо крок успішний
+ */
+function runCargo(label, cargo, args, pass, fail) {
+  const r = spawnSync(cargo, args, { stdio: 'inherit', shell: false })
+  if (r.status === 0) {
+    pass(`lint-rust: ${label} — OK`)
+    return true
+  }
+  const code = typeof r.status === 'number' ? r.status : 1
+  fail(`lint-rust: ${label} — помилка (код ${code}, rust.mdc)`)
+  return false
+}
+
+/**
+ * Оркестраторний адаптер `n-cursor lint rust`: rustfmt + clippy через cargo. Без `Cargo.toml` —
+ * no-op (0). `cargo`/`rustfmt`/`clippy` — Rust toolchain (rustup), не npm-залежності.
+ * readOnly (CI): `cargo fmt --all -- --check` + `cargo clippy … -D warnings` (нуль мутацій).
+ * fix: `cargo fmt --all` + `cargo clippy --fix` + фінальний `cargo clippy … -D warnings`.
+ * @param {string[] | undefined} _files ігнорується (cargo обходить crate сам)
+ * @param {string} [cwd] корінь
+ * @param {{ readOnly?: boolean }} [opts] readOnly → без мутацій
+ * @returns {number} exit code
+ */
+function runRustLint(cwd = process.cwd(), opts = {}) {
+  const readOnly = opts.readOnly === true
+  const reporter = createCheckReporter()
+  const { pass, fail } = reporter
+
+  if (!existsSync(join(cwd, 'Cargo.toml'))) {
+    pass('lint-rust: немає Cargo.toml — кроки Rust пропущено')
+    return reporter.getExitCode()
+  }
+
+  const cargo = resolveCmd('cargo')
+  if (!cargo) {
+    fail('lint-rust: `cargo` не знайдено в PATH (Rust toolchain через rustup, rust.mdc)')
+    return reporter.getExitCode()
+  }
+
+  const fmtArgs = readOnly ? ['fmt', '--all', '--', '--check'] : ['fmt', '--all']
+  if (!runCargo(readOnly ? 'cargo fmt --check' : 'cargo fmt', cargo, fmtArgs, pass, fail)) {
+    return reporter.getExitCode()
+  }
+
+  if (!readOnly) {
+    const fixArgs = ['clippy', '--fix', '--allow-staged', '--allow-dirty', '--all-targets', '--all-features']
+    if (!runCargo('cargo clippy --fix', cargo, fixArgs, pass, fail)) return reporter.getExitCode()
+  }
+
+  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/rust/rust.mdc

@@ -5,12 +5,10 @@ alwaysApply: false
 version: '1.4'
 ---
 
-**rustfmt** ([rust-lang/rustfmt](https://github.com/rust-lang/rustfmt)) — форматер; **clippy** ([rust-lang/rust-clippy](https://github.com/rust-lang/rust-clippy)) — лінтер. У скрипті **`lint-rust`** локально йдуть три кроки в одному рядку: `cargo fmt --all` → `cargo clippy --fix --allow-staged --allow-dirty --all-targets --all-features` → фінальний `cargo clippy --all-targets --all-features -- -D warnings`. У CI — без `--fix`: `cargo fmt --all -- --check` і `cargo clippy ... -- -D warnings` (див. `lint-rust.yml`).
+**rustfmt** ([rust-lang/rustfmt](https://github.com/rust-lang/rustfmt)) — форматер; **clippy** ([rust-lang/rust-clippy](https://github.com/rust-lang/rust-clippy)) — лінтер. Запуск — через **`n-cursor lint rust`** (адаптер `js/lint.mjs`): локально (fix) `cargo fmt --all` → `cargo clippy --fix --allow-staged --allow-dirty --all-targets --all-features` → фінальний `cargo clippy --all-targets --all-features -- -D warnings`; у `--read-only` (детект) — `cargo fmt --all -- --check` + `cargo clippy ... -- -D warnings`. Окремого `package.json`-скрипта немає. У CI cargo викликається напряму (див. `lint-rust.yml`).
 
 `cargo`, `rustfmt`, `clippy` не додавай у `devDependencies` — це Rust toolchain, ставиться через `rustup` локально або через `dtolnay/rust-toolchain@stable` у CI.
 
-Канон `scripts.lint-rust` (substring requirement): [package.json.contains.json](./policy/package_json/template/package.json.contains.json)
-
 У `.vscode/extensions.json` `recommendations` мають містити `rust-lang.rust-analyzer` і `tamasfe.even-better-toml`: [extensions.json.snippet.json](./policy/vscode_extensions/template/extensions.json.snippet.json)
 
 Канон workflow `.github/workflows/lint-rust.yml`: [lint-rust.yml.snippet.yml](./policy/lint_rust_yml/template/lint-rust.yml.snippet.yml)
@@ -21,7 +19,7 @@ version: '1.4'
 
 Tauri-проєкт завжди має `src-tauri/Cargo.toml`, тому правило `rust` активується автоматично разом з `tauri`. Поділ обов'язків:
 
-- `rust` — `lint-rust` скрипт, `rust-analyzer`, `even-better-toml`, CI workflow.
+- `rust` — лінт через `n-cursor lint rust`, `rust-analyzer`, `even-better-toml`, CI workflow.
 - `tauri` — `tauri-apps.tauri-vscode` (див. **tauri.mdc**).
 
 Обидва правила перевіряють `.vscode/extensions.json` за `contains`-семантикою; конкурентного запису немає.

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"]
-  }
-}

package/rules/php/policy/package_json/package_json.rego

@@ -1,16 +0,0 @@
-# Перевірка `package.json` (php.mdc).
-#
-# Канон надходить через --data: { "template": { "contains": ... } }
-# Структура --data сформована з template/package.json.contains.json.
-# FS-перевірки (`composer.json`, наявність `package.json` як такого) — у JS.
-package php.package_json
-
-import rego.v1
-
-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 (php.mdc)", [script_name, needle])
-}

package/rules/php/policy/package_json/target.json

@@ -1,4 +0,0 @@
-{
-  "$schema": "https://unpkg.com/@nitra/cursor/schemas/target.json",
-  "files": { "single": "package.json" }
-}

package/rules/php/policy/package_json/template/package.json.contains.json

@@ -1,5 +0,0 @@
-{
-  "scripts": {
-    "lint-php": ["bun"]
-  }
-}

package/rules/python/policy/package_json/package_json.rego

@@ -1,16 +0,0 @@
-# Перевірка `package.json` (python.mdc).
-#
-# Канон надходить через --data: { "template": { "contains": ... } }
-# Структура --data сформована з template/package.json.contains.json.
-# FS-перевірки (наявність `package.json` як такого) — у JS.
-package python.package_json
-
-import rego.v1
-
-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 (python.mdc)", [script_name, needle])
-}

package/rules/python/policy/package_json/target.json

@@ -1,4 +0,0 @@
-{
-  "$schema": "https://unpkg.com/@nitra/cursor/schemas/target.json",
-  "files": { "single": "package.json" }
-}

package/rules/python/policy/package_json/template/package.json.contains.json

@@ -1,5 +0,0 @@
-{
-  "scripts": {
-    "lint-python": ["bun"]
-  }
-}

package/rules/rust/policy/package_json/package_json.rego

@@ -1,18 +0,0 @@
-# Перевірка `package.json` для правила rust (rust.mdc).
-#
-# Канон надходить через --data: { "template": { "contains": ... } }
-# Структура --data сформована з template/package.json.contains.json.
-# Перевіряємо substring-вимоги до scripts.lint-rust: усі три кроки
-# (`cargo fmt`, `cargo clippy --fix`, фінальний `cargo clippy ... -D warnings`)
-# мають бути присутніми у значенні скрипта.
-package rust.package_json
-
-import rego.v1
-
-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 (rust.mdc)", [script_name, needle])
-}

package/rules/rust/policy/package_json/target.json

@@ -1,5 +0,0 @@
-{
-  "$schema": "https://unpkg.com/@nitra/cursor/schemas/target.json",
-  "files": { "single": "package.json", "required": true },
-  "missingMessage": "package.json не існує — створи зі scripts.lint-rust (rust.mdc)"
-}

package/rules/rust/policy/package_json/template/package.json.contains.json

@@ -1,9 +0,0 @@
-{
-  "scripts": {
-    "lint-rust": [
-      "cargo fmt --all",
-      "cargo clippy --fix --allow-staged --allow-dirty",
-      "cargo clippy --all-targets --all-features -- -D warnings"
-    ]
-  }
-}