@nitra/cursor 12.6.1 → 12.8.0

package/scripts/lib/fix/docs/run-conformance-check.md

@@ -0,0 +1,33 @@
+---
+type: JS Module
+title: run-conformance-check.mjs
+resource: npm/scripts/lib/fix/run-conformance-check.mjs
+docgen:
+  crc: 7a026c26
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 90
+---
+
+## Огляд
+
+Модуль реалізує прямий механізм виконання конформності, викликаючи конформність-фазу `lint`, движок (`orchestrator.mjs`, `t0.mjs`) та PostToolUse-хук. Селекція активних правил здійснюється на основі конфігурації `.n-cursor.json`. Для забезпечення ізоляції, кожен обраний `entrypoint rules/<id>/main.mjs` запускається окремим процесом `bun`.
+
+## Поведінка
+
+resolveCheckRuleIds визначає набір ID правил для прогону, використовуючи `.n-cursor.json` як єдине джерело правди для селекції. Якщо запитані правила надані, вони фільтруються за активністю; інакше, він вибирає активні правила з конфігурації, або, за відсутності конфігурації, використовує зматеріалізовані файли `.cursor/rules/*.mdc` для режиму відладки.
+
+runConformanceCheck виконує перевірку конформності для кожного правила, яке було визначено як активне. Він запускає кожен `check.mjs` окремим процесом `bun` для ізоляції та повертає загальну кількість виконаних, успішних та невдалих перевірок.
+
+## Публічний API
+
+resolveCheckRuleIds — Визначає, які правила будуть застосовані для перевірки, використовуючи `.n-cursor.json` як основне джерело:
+
+- Якщо вказані правила, вони фільтруються до активних у конфігурації.
+- Якщо правила не вказані, беруться всі активні правила з конфігу.
+- Якщо правила не вказані і конфіг відсутній, використовується список правил, що були збережені локально.
+
+runConformanceCheck — Виконує перевірку відповідності для кожного окремого правила без внесення змін.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).

package/scripts/lib/fix/docs/run-fix-check.md

@@ -15,9 +15,9 @@ docgen:
 1. Визначається наявність інструменту `conftest`.
 2. Отримується список усіх доступних ідентифікаторів правил з каталогу правил.
 3. Визначається список ідентифікаторів правил для прогону (`resolveCheckRuleIds`), де `.n-cursor.json` — єдине джерело правди:
-    а. Якщо надано явний список правил — він валідується проти доступних і звужується до активних (вимкнене правило не вмикається навіть на явний запит).
-    б. Якщо явного списку нема й конфіг є — беруться активні правила конфіга (`available ∩ enabled`); `.cursor/rules/*.mdc` ігнорується (фікс дрейфу «enabled, але .mdc нема»).
-    в. Якщо конфіга нема (open-by-default debug) — fallback на скан `.cursor/rules/*.mdc`.
+   а. Якщо надано явний список правил — він валідується проти доступних і звужується до активних (вимкнене правило не вмикається навіть на явний запит).
+   б. Якщо явного списку нема й конфіг є — беруться активні правила конфіга (`available ∩ enabled`); `.cursor/rules/*.mdc` ігнорується (фікс дрейфу «enabled, але .mdc нема»).
+   в. Якщо конфіга нема (open-by-default debug) — fallback на скан `.cursor/rules/*.mdc`.
 4. Якщо визначено ідентифікатори правил для прогону, для кожного ідентифікатора запускається окремий процес `bun` з файлом `fix.mjs` відповідного правила.
 5. Захоплюється вивід кожного процесу.
 6. Підраховується загальна кількість правил, що не пройшли перевірку.

package/scripts/lib/fix/docs/t0.md

@@ -3,26 +3,27 @@ type: JS Module
 title: t0.mjs
 resource: npm/scripts/lib/fix/t0.mjs
 docgen:
-  crc: 524d91e2
+  crc: 49c0669b
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
 ---
 
-Модуль керує детермінованим (без LLM) застосуванням паттернів до виводів порушень конформності. Паттерни: `vscode-ext-add` (дописати розширення), `rm-forbidden-file` (видалити заборонений файл), `changelog-create-change-file` (створити change-файл через канонічну `writeChange` для воркспейсів із «немає change-файлу» — прибирає ескалацію в LLM на цьому кейсі). `filterT0AutoRules` визначає, які правила мають придатний паттерн; `applyT0Auto`/`runT0AutoCli` застосовують. Паттерн може бути sync або async (await нормалізує). Fail-safe: помилки перехоплюються.
+## Огляд
+
+Модуль керує автоматичним застосуванням T0-auto паттернів до виводів порушень. Він визначає, які правила можуть бути оброблені автоматично, використовуючи конфігурації з `extensions.json` та `package-lock.json`. Функціонал реалізовано через публічні функції: `filterT0AutoRules` для визначення правил, `applyT0Auto` для автоматичного застосування паттернів до виводів, та `runT0AutoCli` для запуску процесу. Модуль працює у режимі fail-safe, перехоплюючи помилки та не кидаючи винятків назовні, надаючи звіт про застосовані автоматичні виправлення.
 
 ## Поведінка
 
-applyT0Auto застосовує придатні паттерни до одного виводу порушення (await на apply — паттерн може бути async, як `changelog-create-change-file`).
-filterT0AutoRules повертає id правил, для яких існує придатний паттерн.
-runT0AutoCli запускає T0-auto для всіх провальних правил, повторно перевіряє check-gate і виводить підсумок.
+applyT0Auto застосовує всі визначені T0-auto паттерни до одного виводу порушення, повертаючи результат застосування.
+filterT0AutoRules повертає список ID правил, для яких існує хоча б один T0-auto паттерн, виходячи з виводів порушень.
+runT0AutoCli запускає T0-auto для кожного провального правила, повторно перевіряє конформність та виводить підсумок.
 
 ## Публічний API
 
-applyT0Auto — Впроваджує всі шаблони T0-auto до одного результату виявлених проблем.
-filterT0AutoRules — Визначає, які правила мають хоча б один шаблон T0-auto, виходячи з результату `fix --json`.
-runT0AutoCli — Запускає команду `n-cursor fix-t0 [rule...]`, виконує `fix --json`, застосовує T0-auto до кожної проблеми, повторно перевіряє check-gate та надає звіт.
+applyT0Auto — вносить зміни до виводу порушень, використовуючи всі визначені T0-auto шаблони.
+filterT0AutoRules — визначає, які правила мають принаймні один T0-auto шаблон, ґрунтуючись на виводі порушень у форматі JSON.
+runT0AutoCli — виконує команду `n-cursor fix-t0 [rule...]`, яка застосовує T0-auto до кожного порушення, повторно перевіряє check-gate та надає звіт.
 
 ## Гарантії поведінки
 
 - Перехоплює помилки і не пропускає винятків назовні (fail-safe).
-- Не звертається до мережі.

package/scripts/lib/fix/orchestrator.mjs

@@ -1,7 +1,7 @@
 /** @see ./docs/orchestrator.md */
 
 import { env } from 'node:process'
-import { runFixCheck } from './run-fix-check.mjs'
+import { runConformanceCheck } from './run-conformance-check.mjs'
 import { runT0AutoCli } from './t0.mjs'
 import { logEscalation } from './escalation-log.mjs'
 import { runLlmWorker } from './llm-worker.mjs'
@@ -45,7 +45,14 @@ const CLOUD_TRANSPORT_RE = /etimedout|timed out|pi error/i
 export function buildLadder({ localMin, cloudMin, cloudAvg }) {
   return [
     { tier: 'local-min', model: localMin, feedback: false, local: true, isAvg: false, timeoutMs: LOCAL_TIMEOUT_MS },
-    { tier: 'local-min-retry', model: localMin, feedback: true, local: true, isAvg: false, timeoutMs: LOCAL_TIMEOUT_MS },
+    {
+      tier: 'local-min-retry',
+      model: localMin,
+      feedback: true,
+      local: true,
+      isAvg: false,
+      timeoutMs: LOCAL_TIMEOUT_MS
+    },
     { tier: 'cloud-min', model: cloudMin, feedback: true, local: false, isAvg: false, timeoutMs: CLOUD_TIMEOUT_MS },
     { tier: 'cloud-avg', model: cloudAvg, feedback: true, local: false, isAvg: true, timeoutMs: CLOUD_TIMEOUT_MS }
   ].filter(r => r.model)
@@ -103,7 +110,15 @@ export async function escalateRule(rule, cwd, deps) {
 
     const common = { rung: idx, tier: rung.tier, model: rung.model, withFeedback: rung.feedback }
     if (rung.isAvg && avgBudget - avgUsed <= 0) {
-      record({ ...common, callOk: false, callError: 'cloud-avg cap reached', recheckOk: false, remainingViolation: currentViolation, diagnosis: null, ms: 0 })
+      record({
+        ...common,
+        callOk: false,
+        callError: 'cloud-avg cap reached',
+        recheckOk: false,
+        remainingViolation: currentViolation,
+        diagnosis: null,
+        ms: 0
+      })
       log(`  ⏭️  ${rule.ruleId}: ${rung.tier} пропущено (avg-кеп вичерпано)`)
       continue
     }
@@ -120,7 +135,15 @@ export async function escalateRule(rule, cwd, deps) {
     const recheck = await check([rule.ruleId], cwd)
     const recheckOk = recheck.rules.every(r => r.ok)
     const remaining = recheckOk ? '' : (recheck.rules.find(r => !r.ok)?.output ?? '')
-    record({ ...common, callOk: res.ok, callError: res.error ?? null, recheckOk, remainingViolation: remaining, diagnosis: res.diagnosis ?? null, ms: clock() - startedAt })
+    record({
+      ...common,
+      callOk: res.ok,
+      callError: res.error ?? null,
+      recheckOk,
+      remainingViolation: remaining,
+      diagnosis: res.diagnosis ?? null,
+      ms: clock() - startedAt
+    })
 
     if (recheckOk) {
       log(`  ✅ ${rung.tier} (${rung.model || 'pi'}): ${rule.ruleId}`)
@@ -165,7 +188,7 @@ export function parseOrchestratorArgs(args) {
 async function runT0Step(cwd, ruleFilter, failed) {
   await runT0AutoCli([...ruleFilter], cwd)
 
-  const afterT0 = await runFixCheck(ruleFilter, cwd)
+  const afterT0 = await runConformanceCheck(ruleFilter, cwd)
   const failedAfterT0 = afterT0.rules.filter(r => !r.ok)
   const t0Fixed = failed.filter(r => !failedAfterT0.some(f => f.ruleId === r.ruleId))
 
@@ -186,7 +209,7 @@ export async function runOrchestratorCli(args, cwd) {
   const ladder = buildLadder({ localMin: LOCAL_MIN, cloudMin: CLOUD_MIN, cloudAvg: CLOUD_AVG })
 
   // ── Перша перевірка (тихо) ──
-  const initial = await runFixCheck(ruleFilter, cwd)
+  const initial = await runConformanceCheck(ruleFilter, cwd)
   let failed = initial.rules.filter(r => !r.ok)
   const total = initial.total
 
@@ -220,14 +243,14 @@ export async function runOrchestratorCli(args, cwd) {
     const { avgUsed } = await escalateRule(rule, cwd, {
       ladder,
       worker,
-      check: runFixCheck,
+      check: runConformanceCheck,
       avgBudget
     })
     avgBudget -= avgUsed
   }
 
   // ── Фінальна перевірка ──
-  const finalCheck = await runFixCheck(ruleFilter, cwd)
+  const finalCheck = await runConformanceCheck(ruleFilter, cwd)
   const stillFailed = finalCheck.rules.filter(r => !r.ok)
   if (stillFailed.length === 0) {
     console.log(`✅ fix: ${total} правил — все чисто`)

package/scripts/lib/fix/{run-fix-check.mjs → run-conformance-check.mjs}

@@ -1,11 +1,11 @@
 /**
- * Конформність-детект (колишній subcommand `_fix-check`) як ПРЯМА функція — без subprocess-обгортки
- * `bun n-cursor.js _fix-check`. Викликають конформність-фаза `lint` (read-only), движок
- * (`orchestrator.mjs`, `t0.mjs`) і PostToolUse-хук.
+ * Конформність-детект як ПРЯМА функція — без subprocess-обгортки.
+ * Викликають конформність-фаза `lint` (read-only), движок (`orchestrator.mjs`, `t0.mjs`)
+ * і PostToolUse-хук.
  *
- * Per-rule ізоляція зберігається: кожне `rules/<id>/fix.mjs` усе ще запускається окремим
- * процесом `bun` (crash-isolation). Прибрано лише зовнішній wrapper-subprocess, що його
- * раніше шелили оркестратор/хук.
+ * Per-rule ізоляція зберігається: entrypoint `rules/<id>/main.mjs` кожного правила
+ * запускається окремим процесом `bun` (crash-isolation). Канон — єдиний `main.mjs`
+ * (ADR 2026-06-21); його CLI-блок кличе `runRuleCli(import.meta.dirname)`.
  *
  * Селекція активних правил — виключно тут (`resolveCheckRuleIds` за `.n-cursor.json`);
  * per-rule whitelist у спавнених процесах прибрано як дубль (див. `runRuleCli`).
@@ -21,7 +21,7 @@ import { discoverCheckRulesFromCursorRules } from '../discover-check-rules-from-
 import { listProjectRulesMdcFiles } from '../list-project-rules-mdc.mjs'
 import { isRuleEnabled, readNCursorConfigLite } from '../read-n-cursor-config-lite.mjs'
 
-// Цей файл: npm/scripts/lib/fix/run-fix-check.mjs → npm/rules (чотири dirname угору + rules).
+// Цей файл: npm/scripts/lib/fix/run-conformance-check.mjs → npm/rules (чотири dirname угору + rules).
 const BUNDLED_RULES_DIR = join(dirname(dirname(dirname(dirname(fileURLToPath(import.meta.url))))), 'rules')
 
 /**
@@ -61,16 +61,16 @@ export async function resolveCheckRuleIds(requestedRules, available, cwd) {
 }
 
 /**
- * Прогоняє `fix.mjs` кожного правила окремим процесом, захоплюючи output.
+ * Прогоняє check-entrypoint кожного правила окремим процесом, захоплюючи output.
  * @param {string[]} idsToRun правила
  * @param {string} cwd корінь
  * @returns {{ totalFailed:number, rules:Array<{ruleId:string, ok:boolean, output:string}> }} результат
  */
-function runRuleFixProcesses(idsToRun, cwd) {
+function runRuleCheckProcesses(idsToRun, cwd) {
   let totalFailed = 0
   const rules = []
   for (const id of idsToRun) {
-    const r = spawnSync('bun', [join(BUNDLED_RULES_DIR, id, 'fix.mjs')], { cwd, encoding: 'utf8' })
+    const r = spawnSync('bun', [join(BUNDLED_RULES_DIR, id, 'main.mjs')], { cwd, encoding: 'utf8' })
     const ok = r.status === 0
     rules.push({ ruleId: id, ok, output: `${r.stdout ?? ''}${r.stderr ?? ''}`.trim() })
     if (!ok) totalFailed++
@@ -79,12 +79,12 @@ function runRuleFixProcesses(idsToRun, cwd) {
 }
 
 /**
- * Конформність-детект: per-rule `fix.mjs run()` (= перевірка, без мутацій).
+ * Конформність-детект: per-rule `check.mjs run()` (= перевірка, без мутацій).
  * @param {string[]} [requestedRules] фільтр (порожній → discovery з `.cursor/rules/`)
  * @param {string} [cwd] корінь
  * @returns {Promise<{ total:number, failed:number, rules:Array<{ruleId:string, ok:boolean, output:string}> }>} результат
  */
-export async function runFixCheck(requestedRules = [], cwd = processCwd()) {
+export async function runConformanceCheck(requestedRules = [], cwd = processCwd()) {
   ensureTool('conftest')
   const available = await listRuleIds(BUNDLED_RULES_DIR)
   if (available.length === 0) return { total: 0, failed: 0, rules: [] }
@@ -92,6 +92,6 @@ export async function runFixCheck(requestedRules = [], cwd = processCwd()) {
   const idsToRun = await resolveCheckRuleIds(requestedRules, available, cwd)
   if (idsToRun.length === 0) return { total: 0, failed: 0, rules: [] }
 
-  const { totalFailed, rules } = runRuleFixProcesses(idsToRun, cwd)
+  const { totalFailed, rules } = runRuleCheckProcesses(idsToRun, cwd)
   return { total: idsToRun.length, failed: totalFailed, rules }
 }

package/scripts/lib/fix/t0.mjs

@@ -3,7 +3,7 @@ import { spawnSync } from 'node:child_process'
 import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 
-import { runFixCheck } from './run-fix-check.mjs'
+import { runConformanceCheck } from './run-conformance-check.mjs'
 import { writeChange } from '../../../rules/release/change.mjs'
 
 const REC_REQUIRE_RE = /recommendations має містити "[^"]+"/
@@ -188,7 +188,7 @@ export async function runT0AutoCli(args, cwd) {
   const verbose = args.includes('--verbose') || args.includes('-v')
 
   // 1. Конформність-детект (пряма функція, без subprocess)
-  const fixJson = await runFixCheck(ruleFilter, cwd)
+  const fixJson = await runConformanceCheck(ruleFilter, cwd)
   const failed = fixJson.rules.filter(r => !r.ok)
   if (failed.length === 0) {
     console.log(`✅ fix-t0: всі правила чисті — T0 не потрібен`)
@@ -210,7 +210,10 @@ export async function runT0AutoCli(args, cwd) {
   }
 
   // 4. Check-gate: перевірити лише ті правила, що ми чіпали
-  const recheckJson = await runFixCheck(applied.map(a => a.ruleId), cwd)
+  const recheckJson = await runConformanceCheck(
+    applied.map(a => a.ruleId),
+    cwd
+  )
   const stillFailed = recheckJson.rules.filter(r => !r.ok)
 
   if (verbose) {

package/scripts/lib/list-project-rules-mdc.mjs

@@ -1,6 +1,6 @@
 /**
  * Список `.mdc`-файлів правил у `.cursor/rules/` проєкту-споживача (відсортований).
- * Винесено зі `bin/n-cursor.js`, щоб ділити між CLI-dispatch і `run-fix-check` (конформність-детект).
+ * Винесено зі `bin/n-cursor.js`, щоб ділити між CLI-dispatch і `run-conformance-check` (конформність-детект).
  */
 import { existsSync } from 'node:fs'
 import { readdir } from 'node:fs/promises'

package/scripts/lib/list-rule-ids.mjs

@@ -1,12 +1,21 @@
 /**
- * Перебір `rules/<id>/` директорій з фільтром на наявність `fix.mjs`.
- * Після атомарної міграції `fix.mjs` обов'язковий у кожному правилі — каталог без нього
+ * Перебір `rules/<id>/` директорій з фільтром на наявність entrypoint-а.
+ * Канон (ADR 2026-06-21): єдиний entrypoint `rules/<id>/main.mjs`. Каталог без нього —
  * пропускається (це not-a-rule або заглушка).
  */
 import { existsSync } from 'node:fs'
 import { readdir } from 'node:fs/promises'
 import { join } from 'node:path'
 
+/**
+ * Чи має каталог правила entrypoint `main.mjs`.
+ * @param {string} ruleDir абсолютний шлях `rules/<id>/`
+ * @returns {boolean} true, якщо `main.mjs` існує
+ */
+function hasEntrypoint(ruleDir) {
+  return existsSync(join(ruleDir, 'main.mjs'))
+}
+
 /**
  * @param {string} bundledRulesDir абсолютний шлях до `npm/rules/`
  * @param {string} [filter] id одного правила (через `--rule abie`)
@@ -17,7 +26,7 @@ export async function listRuleIds(bundledRulesDir, filter) {
   const ids = entries
     .filter(e => e.isDirectory() && !e.name.startsWith('.'))
     .map(e => e.name)
-    .filter(id => existsSync(join(bundledRulesDir, id, 'fix.mjs')))
+    .filter(id => hasEntrypoint(join(bundledRulesDir, id)))
     .filter(id => filter === undefined || id === filter)
   return ids.toSorted((a, b) => a.localeCompare(b))
 }

package/scripts/lib/read-n-cursor-config-lite.mjs

@@ -1,12 +1,12 @@
 /**
- * Light read-only `.n-cursor.json` reader для standalone `fix.mjs` invocation.
+ * Light read-only `.n-cursor.json` reader для standalone `check.mjs` invocation.
  *
  * НЕ робить auto-rules detection, merge, schema sync — це справа повного `readConfig` у CLI.
  * Тут лише: прочитати файл (якщо є), повернути `{ rules: string[], disableRules: string[] }`.
  *
  * Спостереження whitelist:
  *   - якщо `.n-cursor.json` НЕМАЄ → правило вважається enabled (поведінка "open by default"),
- *     щоб `bun rules/<id>/fix.mjs` з будь-якої тимчасової директорії працювало для debug.
+ *     щоб `bun rules/<id>/check.mjs` з будь-якої тимчасової директорії працювало для debug.
  *   - якщо файл є з `rules:[…]`, але правила там немає → правило не enabled.
  *   - якщо правило в `disable-rules` → не enabled, навіть якщо у `rules:[…]`.
  */

package/{rules/lint/js/orchestrate.mjs → scripts/lib/run-lint.mjs}

@@ -1,19 +1,40 @@
-/** @see ./docs/orchestrate.md */
+/** @see ./docs/run-lint.md */
 import { existsSync, readdirSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { cwd as processCwd } from 'node:process'
 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'
+import { parseRuleLintSpec, readRuleMetaRaw } from './rule-meta.mjs'
+import { collectChangedFilesSince, resolveChangedBase } from './changed-files.mjs'
+import { resolveCmd } from '../utils/resolve-cmd.mjs'
+import { isRuleEnabled, readNCursorConfigLite } from './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)))))
+// Цей файл: npm/scripts/lib/run-lint.mjs → PACKAGE_ROOT = npm (два dirname угору).
+const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
 const RULES_DIR = join(PACKAGE_ROOT, 'rules')
 
+/**
+ * Чи має правило лінт-поверхню — `meta.json#lint` задано (`per-file`/`full`).
+ * Канонічний сигнал (ADR 2026-06-21): gate за meta, не за наявністю файлу.
+ * @param {Record<string, unknown> | undefined} raw meta-обʼєкт правила
+ * @returns {boolean} true — правило лінтить
+ */
+function hasLintSurface(raw) {
+  return parseRuleLintSpec(raw?.lint) !== null
+}
+
+/**
+ * Резолвить лінт-entrypoint правила: `main.mjs` з експортом `lint` (канон, ADR 2026-06-21).
+ * @param {string} rulesDir каталог rules
+ * @param {string} id rule-id
+ * @returns {string | null} шлях до `main.mjs`, або null якщо файлу нема
+ */
+function resolveLintEntrypoint(rulesDir, id) {
+  const main = join(rulesDir, id, 'main.mjs')
+  return existsSync(main) ? main : null
+}
+
 /**
  * Конформність-фаза lint (whole-repo: config/file/workflow conformance — те, що раніше робив `fix`).
  * Per-file декомпозиції немає, тож виконується лише у `--full`.
@@ -27,11 +48,11 @@ const RULES_DIR = join(PACKAGE_ROOT, 'rules')
  */
 async function runConformance(cwd, readOnly, log, filter = []) {
   if (!readOnly) {
-    const { runOrchestratorCli } = await import('../../../scripts/lib/fix/orchestrator.mjs')
+    const { runOrchestratorCli } = await import('./fix/orchestrator.mjs')
     return runOrchestratorCli(filter, cwd)
   }
-  const { runFixCheck } = await import('../../../scripts/lib/fix/run-fix-check.mjs')
-  const { rules } = await runFixCheck(filter, cwd)
+  const { runConformanceCheck } = await import('./fix/run-conformance-check.mjs')
+  const { rules } = await runConformanceCheck(filter, cwd)
   const failed = rules.filter(x => !x.ok)
   if (failed.length === 0) return 0
   log(`❌ lint: конформність — ${failed.length} порушень: ${failed.map(x => x.ruleId).join(', ')}\n`)
@@ -97,9 +118,9 @@ async function runPerFileRules(ids, ctx) {
   const { rulesDir, changed, cwd, readOnly, metaById, log } = ctx
   let worst = 0
   for (const id of ids) {
-    const lintPath = join(rulesDir, id, 'js', 'lint.mjs')
-    if (!existsSync(lintPath)) {
-      log(`⚠️  lint: правило ${id} має lint-фазу, але немає js/lint.mjs — пропускаю.\n`)
+    const lintPath = resolveLintEntrypoint(rulesDir, id)
+    if (!lintPath) {
+      log(`⚠️  lint: правило ${id} має lint-фазу (meta.lint), але немає main.mjs — пропускаю.\n`)
       continue
     }
     // lintPath = join(rulesDir, id, …) — суто package-internal (rulesDir пакета + id зі
@@ -127,9 +148,7 @@ async function runPerFileRules(ids, ctx) {
  * @returns {Promise<number>} код конформності
  */
 async function runFullConformancePhase(cwd, readOnly, log) {
-  const { escalationLogSize, maybeAnalyzeEscalation, reportRunStats } = await import(
-    '../../../scripts/lib/fix/analyze-escalation.mjs'
-  )
+  const { escalationLogSize, maybeAnalyzeEscalation, reportRunStats } = await import('./fix/analyze-escalation.mjs')
   const escOffset = readOnly ? 0 : escalationLogSize()
   const conformanceCode = await runConformance(cwd, readOnly, log)
   if (!readOnly) {
@@ -160,11 +179,12 @@ function runFormat(cwd, log) {
 }
 
 /**
- * Scoped-режим (`lint <rule…>`): повний прогін НАЗВАНИХ правил — їх лінтер (`js/lint.mjs`,
- * whole-repo) для тих, що його мають, + конформність для всіх названих. Дзеркалить `--full`,
- * але звужено до правил, тож `lint ga` ≡ standalone `lint-ga`. Конформність-only правила
- * (напр. `changelog` із hk) не мають `js/lint.mjs` → проганяється лише їх конформність
- * (зворотна сумісність із колишнім `fix <rule>`). oxfmt у scoped НЕ запускається — це
+ * Scoped-режим (`lint <rule…>`): повний прогін НАЗВАНИХ правил — їх лінтер (entrypoint
+ * `main.mjs::lint`, whole-repo) для тих, що мають лінт-поверхню
+ * (`meta.json#lint`), + конформність для всіх названих. Дзеркалить `--full`, але звужено
+ * до правил, тож `lint ga` ≡ standalone `lint-ga`. Конформність-only правила (напр.
+ * `changelog` із hk) без `meta.lint` → проганяється лише їх конформність (зворотна
+ * сумісність із колишнім `fix <rule>`). oxfmt у scoped НЕ запускається — це
  * таргетований прогін правил, а не глобальне форматування.
  * @param {string[]} rules id названих правил
  * @param {{ cwd: string, readOnly: boolean, rulesDir: string, conformance: boolean, log: (s: string) => void }} ctx контекст (`conformance` — чи запускати конформність; false для юніт-тестів із кастомним rulesDir, де реальний пакет недоступний)
@@ -173,7 +193,7 @@ function runFormat(cwd, log) {
 async function runScopedRules(rules, ctx) {
   const { cwd, readOnly, rulesDir, conformance, log } = ctx
   const metaById = readAllMeta(rulesDir)
-  const linterIds = rules.filter(id => existsSync(join(rulesDir, id, 'js', 'lint.mjs')))
+  const linterIds = rules.filter(id => hasLintSurface(metaById[id]))
   let worst = 0
   if (linterIds.length > 0) {
     const perFile = await runPerFileRules(linterIds, { rulesDir, changed: undefined, cwd, readOnly, metaById, log })

package/scripts/lib/run-rule-cli.mjs

@@ -1,10 +1,10 @@
 /**
- * Standalone CLI runner для одного правила. Викликається з `rules/<id>/fix.mjs`
- * у блоці `if (import.meta.main)` — це робить `bun rules/<id>/fix.mjs` повним
+ * Standalone CLI runner для одного правила. Викликається з `rules/<id>/check.mjs`
+ * у блоці `if (import.meta.main)` — це робить `bun rules/<id>/check.mjs` повним
  * еквівалентом `npx \@nitra/cursor fix <id>`: друкує summary, повертає aggregated exit-code.
  *
  * **Без whitelist-гейту.** Гейтинг активних правил — єдине джерело: `resolveCheckRuleIds`
- * (`scripts/lib/fix/run-fix-check.mjs`) за `.n-cursor.json`. Прямий `bun rules/<id>/fix.mjs` —
+ * (`scripts/lib/fix/run-conformance-check.mjs`) за `.n-cursor.json`. Прямий `bun rules/<id>/check.mjs` —
  * свідомий запуск саме цього правила (debug / override), тож виконується беззастережно;
  * усі автоматичні шляхи (lint-конформність, orchestrator, t0, hook) уже спавнять лише активні.
  *
@@ -15,7 +15,7 @@ import { basename } from 'node:path'
 import { runStandardRule } from './run-standard-rule.mjs'
 import { getOrCreateWalkCache } from '../utils/walk-cache.mjs'
 
-// Re-export для зворотної сумісності: уся `rules/<id>/fix.mjs` уже імпортує `isRunAsCli`
+// Re-export для зворотної сумісності: уся `rules/<id>/check.mjs` уже імпортує `isRunAsCli`
 // саме звідси. Канонічна реалізація — у `scripts/cli-entry.mjs`. Caller передає
 // `import.meta.url`: `if (isRunAsCli(import.meta.url)) …`.
 export { isRunAsCli } from '../cli-entry.mjs'

package/scripts/lib/run-standard-lint.mjs

@@ -7,29 +7,42 @@
  * патчилися в кожному `rules/<rule>/lint/lint.mjs`.
  *
  * Зараз робить рівно одне: серіалізує + дедуплікує запуски через `withLock('lint-<ruleId>')`.
- * `ruleId` виводиться зі шляху: `import.meta.dirname` у `rules/<id>/lint/lint.mjs` → `<id>`.
+ * `ruleId` виводиться зі шляху незалежно від глибини виклику: `rules/<id>` (з `main.mjs`),
+ * `rules/<id>/js` або `rules/<id>/lint` → `<id>` (сегмент одразу після `rules/`).
  *
  * Інтеграція з боку правила:
  *
  * ```js
- * import { runStandardLint } from '../../../scripts/lib/run-standard-lint.mjs'
+ * import { runStandardLint } from '../../scripts/lib/run-standard-lint.mjs'
  *
  * async function runLintFooSteps() { ... }
  *
- * export const runLintFooCli = () => runStandardLint(import.meta.dirname, runLintFooSteps)
+ * export function lint(_files) { return runStandardLint(import.meta.dirname, runLintFooSteps) }
  * ```
  */
-import { basename, dirname } from 'node:path'
+import { basename } from 'node:path'
 
 import { withLock } from '../utils/with-lock.mjs'
 
 /**
- * @param {string} lintDir абсолютний шлях до `rules/<id>/lint/` (передавай `import.meta.dirname`)
+ * Виводить `<id>` зі шляху каталогу правила незалежно від глибини: сегмент одразу після
+ * останнього `rules/`. Fallback — `basename(dir)`, якщо `rules/` у шляху немає.
+ * @param {string} dir абсолютний шлях каталогу (`rules/<id>`, `rules/<id>/js`, …)
+ * @returns {string} rule-id
+ */
+function ruleIdFromDir(dir) {
+  const parts = dir.split(/[/\\]/u)
+  const i = parts.lastIndexOf('rules')
+  return i !== -1 && parts[i + 1] ? parts[i + 1] : basename(dir)
+}
+
+/**
+ * @param {string} lintDir абсолютний шлях до каталогу правила (передавай `import.meta.dirname`)
  * @param {() => number | Promise<number>} stepsFn реальна робота лінту; повертає код виходу
  * @param {{ttl?:number, staleThreshold?:number, waitTimeout?:number, pollInterval?:number, cacheDir?:string, getFingerprint?:() => string | null}} [opts] прокидаються у `withLock`
  * @returns {Promise<number>} код виходу
  */
 export function runStandardLint(lintDir, stepsFn, opts) {
-  const ruleId = basename(dirname(lintDir))
+  const ruleId = ruleIdFromDir(lintDir)
   return withLock(`lint-${ruleId}`, stepsFn, opts)
 }

package/scripts/lib/run-standard-rule.mjs

@@ -1,14 +1,14 @@
 /**
- * Public API per-rule orchestration. Викликається з `rules/<id>/fix.mjs`.
+ * Public API per-rule orchestration. Викликається з `rules/<id>/check.mjs`.
  *
  * Інкапсулює: `discoverOneRule` → `runRule(applies → JS → policy → mdc-refs)`.
  * Локальна логіка в правилах заборонена; розширення поведінки — через `ctx`-опції.
  *
  * Серіалізація: загортає виконання у `withLock('fix-<ruleId>')` — паралельні запуски
- * того самого правила (через `npx \@nitra/cursor fix`, прямий `bun rules/<id>/fix.mjs`
+ * того самого правила (через `npx \@nitra/cursor fix`, прямий `bun rules/<id>/check.mjs`
  * чи `run(ctx)`-композицію) дедупляться за станом git-дерева; різні правила можуть
  * виконуватись паралельно. Точка інтеграції — тут, щоб не дублювати лок у кожному
- * `fix.mjs`.
+ * `check.mjs`.
  */
 import { basename, dirname } from 'node:path'
 
@@ -24,7 +24,7 @@ import { withLock } from '../utils/with-lock.mjs'
  * Зарезервовано на майбутнє (поки не реалізовано — додається, коли з'явиться потреба):
  *   - `skipMdcRefs`, `skipApplies`, `onlyConcerns`.
  * Розширення поведінки правила робиться лише через нові поля тут, не через локальну
- * логіку в `rules/<id>/fix.mjs`.
+ * логіку в `rules/<id>/check.mjs`.
  */
 
 /**

package/scripts/lib/timing-summary.mjs

@@ -2,7 +2,7 @@
  * Формат таблиці-резюме часу виконання для orchestrator `fix` / `lint`.
  *
  * Дві спільні точки використання:
- *  - `runFixCommand` у `bin/n-cursor.js` — після прогону всіх `rules/<id>/fix.mjs`.
+ *  - `runFixCommand` у `bin/n-cursor.js` — після прогону всіх `rules/<id>/check.mjs`.
  *  - `runLintCli` у `scripts/lib/run-lint-cli.mjs` — після прогону `lint-*` скриптів з кореневого `package.json`.
  *
  * Чиста функція без I/O — повертає готовий рядок (з фінальним `\n`), друк — на стороні виклику.

package/scripts/{post-tool-use-fix.mjs → post-tool-use-check.mjs}

@@ -4,17 +4,17 @@
  *
  * Раніше хук маршрутизував змінений файл у релевантні правила й ганяв повний `fix` (автофікс
  * + LLM) — дорого, тож звужували. Тепер хук — **детект** (нуль мутацій, нуль LLM), тож роутинг
- * зайвий: один виклик `_fix-check` (per-rule `fix.mjs run()` = перевірка) по всіх правилах.
+ * зайвий: один виклик `_fix-check` (per-rule `check.mjs run()` = перевірка) по всіх правилах.
  *
  * Контракт:
  * - stdin Claude Code: JSON із `tool_input.file_path`; якщо файлу немає (напр. Bash) — exit 0 (skip);
- * - інакше пряма `runFixCheck` (детект усіх правил, без subprocess-обгортки), exit-код прозоро:
+ * - інакше пряма `runConformanceCheck` (детект усіх правил, без subprocess-обгортки), exit-код прозоро:
  *   1 — є порушення конформності (PostToolUse не блокує turn, але код лишаємо інформативним).
  */
 import { once } from 'node:events'
 import { cwd as processCwd } from 'node:process'
 
-import { runFixCheck } from './lib/fix/run-fix-check.mjs'
+import { runConformanceCheck } from './lib/fix/run-conformance-check.mjs'
 
 /**
  * Зчитує stdin до EOF як utf8 рядок. На TTY — повертає `''` одразу.
@@ -57,20 +57,20 @@ export function extractFilePath(stdinJson) {
 }
 
 /**
- * Точка входу. Викликається з `bin/n-cursor.js` коли argv[0] === `post-tool-use-fix`.
+ * Точка входу. Викликається з `bin/n-cursor.js` коли argv[0] === `post-tool-use-check`.
  * Параметри доступні для інʼєкції для тестів: `stdinJson` обходить read від `process.stdin`,
- * `runFixCheckFn` — заміна `runFixCheck`.
- * @param {{ stdinJson?: string, runFixCheckFn?: typeof runFixCheck }} [options] параметри для тестів
+ * `runConformanceCheckFn` — заміна `runConformanceCheck`.
+ * @param {{ stdinJson?: string, runConformanceCheckFn?: typeof runConformanceCheck }} [options] параметри для тестів
  * @returns {Promise<number>} exit code (0 — пропущено / конформність ОК; 1 — є порушення)
  */
-export async function runPostToolUseFixCli(options = {}) {
+export async function runPostToolUseCheckCli(options = {}) {
   const stdinJson = options.stdinJson ?? (await readStdin())
   const filePath = extractFilePath(stdinJson)
   // Тільки після редагування файлу (Edit/Write/MultiEdit мають file_path); Bash тощо — skip.
   if (filePath === null) {
     return 0
   }
-  const check = options.runFixCheckFn ?? runFixCheck
+  const check = options.runConformanceCheckFn ?? runConformanceCheck
   // Один read-only детект конформності всіх активованих правил (пряма функція, без subprocess).
   try {
     const { failed, rules } = await check([], processCwd())
@@ -80,7 +80,7 @@ export async function runPostToolUseFixCli(options = {}) {
     }
     return 1
   } catch (error) {
-    process.stderr.write(`post-tool-use-fix: не вдалося запустити детект конформності — ${error.message}\n`)
+    process.stderr.write(`post-tool-use-check: не вдалося запустити детект конформності — ${error.message}\n`)
     return 1
   }
 }