@nitra/cursor 9.4.0 → 10.0.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [10.0.0] - 2026-06-14
+
+### Changed
+
+- Інлайн _fix-check/fix-t0 у прямі функції — видалено внутрішні subcommand'и. runFixCheck (scripts/lib/fix/run-fix-check) + listProjectRulesMdcFiles винесено з bin; orchestrator/t0/PostToolUse-хук/lint-конформність кличуть прямо (без subprocess-обгортки). Per-rule ізоляція збережена
+
 ## [9.4.0] - 2026-06-14
 
 ### Changed

package/bin/n-cursor.js

@@ -97,8 +97,7 @@ import { readSkillMetaRaw } from '../scripts/lib/skill-meta.mjs'
 import { injectWorktreeNotice } from '../scripts/lib/worktree-notice.mjs'
 import { injectRootNotice } from '../scripts/lib/root-notice.mjs'
 import { runPostToolUseFixCli } from '../scripts/post-tool-use-fix.mjs'
-import { discoverCheckRulesFromCursorRules } from '../scripts/lib/discover-check-rules-from-cursor.mjs'
-import { listRuleIds } from '../scripts/lib/list-rule-ids.mjs'
+import { listProjectRulesMdcFiles } from '../scripts/lib/list-project-rules-mdc.mjs'
 import { ensureNitraCursorInRootDevDependencies } from '../scripts/ensure-nitra-cursor-dev-dependencies.mjs'
 import { assertCwdIsProjectRoot } from '../scripts/lib/assert-project-root.mjs'
 import { runLintDocker } from '../rules/docker/lint/lint.mjs'
@@ -114,8 +113,6 @@ import { runSkillsCli } from '../scripts/skills-cli.mjs'
 import { runWorktreeCli } from '../scripts/worktree-cli.mjs'
 import { syncSetupBunDepsAction } from '../scripts/sync-setup-bun-deps-action.mjs'
 import { runLint } from '../rules/lint/js/orchestrate.mjs'
-import { formatTimingSummary } from '../scripts/lib/timing-summary.mjs'
-import { ensureHkInstall, ensureTool } from '../scripts/lib/ensure-tool.mjs'
 
 const PACKAGE_NAME = '@nitra/cursor'
 const CONFIG_FILE = '.n-cursor.json'
@@ -525,19 +522,6 @@ function formatPiSkillFrontmatter(skillName, descriptionRaw) {
   return `---\nname: ${skillName}\ndescription: >-\n  ${text}\n---\n\n`
 }
 
-/**
- * Повертає відсортовані імена *.mdc у .cursor/rules поточного проєкту
- * @returns {Promise<string[]>} базові імена файлів (лише .mdc)
- */
-async function listProjectRulesMdcFiles() {
-  const rulesDir = join(cwd(), RULES_DIR)
-  if (!existsSync(rulesDir)) {
-    return []
-  }
-  const names = await readdir(rulesDir)
-  return names.filter(n => n.endsWith('.mdc')).toSorted((a, b) => a.localeCompare(b))
-}
-
 /**
  * Базові імена файлів .mdc, які очікуються згідно з .n-cursor.json (префікс n-).
  * @param {string[]} configRules елементи масиву rules з конфігу
@@ -1242,120 +1226,6 @@ function logRemovedManagedItems(title, basePath, names) {
   }
 }
 
-/**
- * Визначає список правил для fix: явно задані (з валідацією проти available) або
- * discovery з `.cursor/rules/*.mdc`. Друкує діагностику й кидає на невідомих правилах.
- * @param {string[]} requestedRules запитані правила (порожній → discovery)
- * @param {string[]} available доступні в пакеті rule-id
- * @param {boolean} json json-режим (впливає на early-return вивід при порожньому discovery)
- * @returns {Promise<string[]|null>} список id або null — нічого запускати (вивід уже зроблено)
- */
-async function resolveFixRuleIds(requestedRules, available, json) {
-  if (requestedRules.length > 0) {
-    const unknown = requestedRules.filter(id => !available.includes(id))
-    if (unknown.length > 0) {
-      console.error(`❌ Невідомі правила: ${unknown.join(', ')}`)
-      console.log(`   Доступні: ${available.join(', ')}`)
-      throw new Error(`Unknown rules: ${unknown.join(', ')}`)
-    }
-    return requestedRules
-  }
-
-  const mdcFiles = await listProjectRulesMdcFiles()
-  if (mdcFiles.length === 0) {
-    throw new Error(
-      `Немає файлів *.mdc у ${RULES_DIR}/. Запустіть \`npx ${PACKAGE_NAME}\` або вкажіть правила: \`npx ${PACKAGE_NAME} fix bun ga\``
-    )
-  }
-  const idsToRun = discoverCheckRulesFromCursorRules(available, mdcFiles)
-  if (idsToRun.length === 0) {
-    if (json) {
-      process.stdout.write(`${JSON.stringify({ total: 0, failed: 0, rules: [] })}\n`)
-      return null
-    }
-    console.log(
-      `\n🔍 ${PACKAGE_NAME} fix — у ${RULES_DIR}/ немає правил з programmatic перевіркою ` +
-        `(відповідного fix.mjs у пакеті). Нічого не запущено.\n`
-    )
-    return null
-  }
-  return idsToRun
-}
-
-/**
- * Прогоняє `fix.mjs` кожного правила окремим процесом; збирає timings і (для json) per-rule output.
- * @param {string[]} idsToRun правила до запуску
- * @param {boolean} json json-режим — захоплює stdout/stderr у структуру замість inherit у термінал
- * @returns {{ totalFailed: number, timings: {id:string, ms:number, ok:boolean}[], ruleResults: {ruleId:string, ok:boolean, output:string}[] }} підсумок прогону
- */
-function runRuleFixProcesses(idsToRun, json) {
-  let totalFailed = 0
-  const timings = []
-  const ruleResults = []
-  for (const id of idsToRun) {
-    const fixPath = join(BUNDLED_RULES_DIR, id, 'fix.mjs')
-    const startedAt = Date.now()
-    const result = json
-      ? spawnSync('bun', [fixPath], { encoding: 'utf8' })
-      : spawnSync('bun', [fixPath], { stdio: 'inherit' })
-    const ok = result.status === 0
-    timings.push({ id: `fix-${id}`, ms: Date.now() - startedAt, ok })
-    if (json) {
-      ruleResults.push({ ruleId: id, ok, output: `${result.stdout ?? ''}${result.stderr ?? ''}`.trim() })
-    }
-    if (!ok) totalFailed++
-  }
-  return { totalFailed, timings, ruleResults }
-}
-
-/**
- * Spawn-wrapper для `npx \@nitra/cursor fix [<rule>...]`. Один шлях у коді: для кожного правила
- * робить `bun rules/<id>/fix.mjs` як окремий процес. Сам `fix.mjs` читає `.n-cursor.json`,
- * перевіряє whitelist (`runRuleCli`) і друкує per-rule summary.
- *
- * Без аргументів — discover з `.cursor/rules/*.mdc` у проекті-споживачі.
- *
- * Серіалізація паралельних запусків — per-rule, всередині `runStandardRule` (`withLock('fix-<id>')`).
- * На рівні `runFixCommand` локу нема: різні набори правил можуть прогресувати незалежно,
- * а однакові правила серіалізуються в spawn'ах нижче.
- * @param {string[]} requestedRules імена правил; порожній масив — discovery з `.cursor/rules/`
- * @param {{json?: boolean}} [opts] json — друкувати компактний JSON `{total, failed, rules:[{ruleId, ok, output}]}`
- *   замість per-rule stdio + timing (для скілу n-fix: агент читає лише впалі правила, не парсить текст)
- * @returns {Promise<void>}
- */
-async function runFixCommand(requestedRules, opts = {}) {
-  const json = opts.json === true
-  // json-режим — діагностичний read-only вивід для скілу: пропускаємо встановлення
-  // git-hook (`ensureHkInstall` друкує «Installed hk hook…» у stdout і забруднив би
-  // чистий JSON; сам pre-commit hook для діагностики не потрібен).
-  const hkBin = ensureTool('hk')
-  if (!json) ensureHkInstall(hkBin)
-  ensureTool('conftest')
-
-  const available = await listRuleIds(BUNDLED_RULES_DIR)
-  if (available.length === 0) {
-    console.error('❌ Не знайдено жодного правила у пакеті')
-    throw new Error('No rules found')
-  }
-
-  // json-режим: захоплюємо stdout/stderr правила у структуру (а не inherit у термінал),
-  // щоб віддати агенту згруповано {ruleId, ok, output} і він читав лише впалі.
-  const idsToRun = await resolveFixRuleIds(requestedRules, available, json)
-  if (idsToRun === null) return
-
-  const { totalFailed, timings, ruleResults } = runRuleFixProcesses(idsToRun, json)
-
-  if (json) {
-    process.stdout.write(`${JSON.stringify({ total: idsToRun.length, failed: totalFailed, rules: ruleResults })}\n`)
-  } else {
-    process.stdout.write(formatTimingSummary('Fix timing', timings))
-  }
-
-  if (totalFailed > 0) {
-    throw new Error(`${totalFailed} з ${idsToRun.length} правил мають проблеми`)
-  }
-}
-
 /**
  * Читає поле `version` з `package.json` пакету за абсолютним шляхом до його кореня.
  * @param {string} packageRoot корінь пакету (тека з `package.json`)
@@ -1643,13 +1513,6 @@ try {
   }
   await ensureNitraCursorInRootDevDependencies(cwd())
   switch (command) {
-    case '_fix-check': {
-      // Внутрішня команда движка конформності (не публічний API): per-rule fix.mjs run() = детект.
-      // Повертає JSON {total, failed, rules:[{ruleId, ok, output}]} у stdout. Викликається
-      // конформність-фазою `lint` (read-only) і движком orchestrator/t0.
-      await runFixCommand(args, { json: true })
-      break
-    }
     case 'rename-yaml-extensions': {
       const code = await runRenameYamlExtensionsCli(args)
       if (code !== 0) {
@@ -1753,16 +1616,6 @@ try {
 
       break
     }
-    case 'fix-t0': {
-      // Внутрішня фаза движка конформності (не публічний API): T0-auto рівень.
-      // Запускає _fix-check, знаходить violation-output із детермінованим паттерном
-      // (vscode-ext-add, rm-forbidden-file тощо), застосовує програмний фікс (0 LLM),
-      // перевіряє check-gate. Викликається orchestrator.mjs (fix-режим конформності lint).
-      const { runT0AutoCli } = await import('../scripts/lib/fix/t0.mjs')
-      process.exitCode = await runT0AutoCli(args, cwd())
-
-      break
-    }
     case 'change': {
       const { runChangeCli } = await import('../rules/release/change.mjs')
       process.exitCode = await runChangeCli(args)

package/package.json

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

package/rules/lint/js/orchestrate.mjs

@@ -14,7 +14,6 @@
 import { existsSync, readdirSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { spawnSync } from 'node:child_process'
 import { cwd as processCwd } from 'node:process'
 
 import { parseRuleLintSpec, readRuleMetaRaw } from '../../../scripts/lib/rule-meta.mjs'
@@ -23,7 +22,6 @@ import { collectChangedFilesSince, resolveChangedBase } from '../../../scripts/l
 // Цей файл: npm/rules/lint/js/orchestrate.mjs → PACKAGE_ROOT = npm (чотири dirname угору).
 const PACKAGE_ROOT = dirname(dirname(dirname(dirname(fileURLToPath(import.meta.url)))))
 const RULES_DIR = join(PACKAGE_ROOT, 'rules')
-const N_CURSOR_BIN = join(PACKAGE_ROOT, 'bin', 'n-cursor.js')
 
 /**
  * Конформність-фаза lint (whole-repo: config/file/workflow conformance — те, що раніше робив `fix`).
@@ -41,20 +39,11 @@ async function runConformance(cwd, readOnly, log, filter = []) {
     const { runOrchestratorCli } = await import('../../../scripts/lib/fix/orchestrator.mjs')
     return runOrchestratorCli(filter, cwd)
   }
-  const r = spawnSync('bun', [N_CURSOR_BIN, '_fix-check', ...filter], { cwd, encoding: 'utf8', timeout: 600_000 })
-  let parsed = null
-  try {
-    parsed = JSON.parse((r.stdout ?? '').trim())
-  } catch {
-    parsed = null
-  }
-  if (!parsed) {
-    log('❌ lint: конформність — помилка перевірки (_fix-check не повернув JSON)\n')
-    return 1
-  }
-  const failed = parsed.rules.filter(/** @param {{ok:boolean}} x */ x => !x.ok)
+  const { runFixCheck } = await import('../../../scripts/lib/fix/run-fix-check.mjs')
+  const { rules } = await runFixCheck(filter, cwd)
+  const failed = rules.filter(x => !x.ok)
   if (failed.length === 0) return 0
-  log(`❌ lint: конформність — ${failed.length} порушень: ${failed.map(/** @param {{ruleId:string}} x */ x => x.ruleId).join(', ')}\n`)
+  log(`❌ lint: конформність — ${failed.length} порушень: ${failed.map(x => x.ruleId).join(', ')}\n`)
   for (const f of failed) if (f.output) log(`${f.output}\n`)
   return 1
 }

package/scripts/lib/fix/orchestrator.mjs

@@ -1,11 +1,7 @@
 /** @see ./docs/orchestrator.md */
 
-import { spawnSync } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
-import { join } from 'node:path'
-
-const HERE = fileURLToPath(new URL('.', import.meta.url))
-const N_CURSOR_BIN = join(HERE, '../../../bin/n-cursor.js')
+import { runFixCheck } from './run-fix-check.mjs'
+import { runT0AutoCli } from './t0.mjs'
 
 const DEFAULT_MAX_ITER = 3
 const ESCALATE_AFTER = 2
@@ -29,13 +25,13 @@ function parseOrchestratorArgs(args) {
  * @param {string} cwd корінь проєкту
  * @param {string[]} ruleFilter фільтр правил
  * @param {Array<{ ruleId: string }>} failed правила перед кроком
- * @returns {Array<{ ruleId: string, ok: boolean, output: string }>} правила після T0
+ * @returns {Promise<Array<{ ruleId: string, ok: boolean, output: string }>>} правила після T0
  */
-function runT0Step(cwd, ruleFilter, failed) {
-  spawnSync('bun', [N_CURSOR_BIN, 'fix-t0', ...ruleFilter], { cwd, stdio: 'pipe' })
+async function runT0Step(cwd, ruleFilter, failed) {
+  await runT0AutoCli([...ruleFilter], cwd)
 
-  const afterT0 = runFixCheck(cwd, ruleFilter)
-  const failedAfterT0 = afterT0?.rules.filter(r => !r.ok) ?? failed
+  const afterT0 = await runFixCheck(ruleFilter, cwd)
+  const failedAfterT0 = afterT0.rules.filter(r => !r.ok)
   const t0Fixed = failed.filter(r => !failedAfterT0.some(f => f.ruleId === r.ruleId))
 
   if (t0Fixed.length > 0) {
@@ -84,12 +80,7 @@ export async function runOrchestratorCli(args, cwd) {
   const failCount = new Map()
 
   // ── Перша перевірка (тихо) ──
-  const initial = runFixCheck(cwd, ruleFilter)
-  if (!initial) {
-    console.error(`❌ fix: помилка перевірки`)
-    return 1
-  }
-
+  const initial = await runFixCheck(ruleFilter, cwd)
   let failed = initial.rules.filter(r => !r.ok)
   const total = initial.total
 
@@ -104,14 +95,14 @@ export async function runOrchestratorCli(args, cwd) {
   if (ruleFilter.length) console.log(`   filter: ${ruleFilter.join(', ')}`)
 
   for (let iter = 1; iter <= maxIter; iter++) {
-    failed = runT0Step(cwd, ruleFilter, failed)
+    failed = await runT0Step(cwd, ruleFilter, failed)
     if (failed.length === 0) break
 
     await runLlmStep(failed, cwd, failCount, worker)
 
     // Перевірка після LLM
-    const afterLLM = runFixCheck(cwd, ruleFilter)
-    failed = afterLLM?.rules.filter(r => !r.ok) ?? failed
+    const afterLLM = await runFixCheck(ruleFilter, cwd)
+    failed = afterLLM.rules.filter(r => !r.ok)
     if (failed.length === 0) break
   }
 
@@ -123,25 +114,3 @@ export async function runOrchestratorCli(args, cwd) {
   console.log(`❌ fix: ${failed.length} невирішених — ${failed.map(r => r.ruleId).join(', ')}`)
   return 1
 }
-
-/**
- * Внутрішня check-gate: запускає fix-перевірки і повертає структурований результат.
- * Не є публічним CLI — викликається лише оркестратором.
- * @param {string}   cwd корінь проєкту
- * @param {string[]} ruleFilter список ID правил (порожній — усі)
- * @returns {{ total: number, failed: number, rules: Array<{ ruleId: string, ok: boolean, output: string }> } | null} JSON-результат або null якщо stdout порожній/невалідний
- */
-function runFixCheck(cwd, ruleFilter = []) {
-  const r = spawnSync('bun', [N_CURSOR_BIN, '_fix-check', ...ruleFilter], {
-    cwd,
-    encoding: 'utf8',
-    timeout: 120_000
-  })
-  const stdout = r.stdout?.trim()
-  if (!stdout) return null
-  try {
-    return JSON.parse(stdout)
-  } catch {
-    return null
-  }
-}

package/scripts/lib/fix/run-fix-check.mjs

@@ -0,0 +1,76 @@
+/**
+ * Конформність-детект (колишній subcommand `_fix-check`) як ПРЯМА функція — без subprocess-обгортки
+ * `bun n-cursor.js _fix-check`. Викликають конформність-фаза `lint` (read-only), движок
+ * (`orchestrator.mjs`, `t0.mjs`) і PostToolUse-хук.
+ *
+ * Per-rule ізоляція зберігається: кожне `rules/<id>/fix.mjs` усе ще запускається окремим
+ * процесом `bun` (config-loading + whitelist + crash-isolation). Прибрано лише зовнішній
+ * wrapper-subprocess, що його раніше шелили оркестратор/хук.
+ */
+import { spawnSync } from 'node:child_process'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { cwd as processCwd } from 'node:process'
+
+import { listRuleIds } from '../list-rule-ids.mjs'
+import { ensureTool } from '../ensure-tool.mjs'
+import { discoverCheckRulesFromCursorRules } from '../discover-check-rules-from-cursor.mjs'
+import { listProjectRulesMdcFiles } from '../list-project-rules-mdc.mjs'
+
+// Цей файл: npm/scripts/lib/fix/run-fix-check.mjs → npm/rules (чотири dirname угору + rules).
+const BUNDLED_RULES_DIR = join(dirname(dirname(dirname(dirname(fileURLToPath(import.meta.url))))), 'rules')
+
+/**
+ * Визначає id правил для прогону: явні (з валідацією) або discovery з `.cursor/rules/*.mdc`.
+ * @param {string[]} requestedRules запитані (порожній → discovery)
+ * @param {string[]} available доступні rule-id у пакеті
+ * @param {string} cwd корінь
+ * @returns {Promise<string[]>} id для прогону (можливо порожній)
+ * @throws {Error} на невідомих явно заданих правилах
+ */
+async function resolveCheckRuleIds(requestedRules, available, cwd) {
+  if (requestedRules.length > 0) {
+    const unknown = requestedRules.filter(id => !available.includes(id))
+    if (unknown.length > 0) throw new Error(`Unknown rules: ${unknown.join(', ')}`)
+    return requestedRules
+  }
+  const mdcFiles = await listProjectRulesMdcFiles(cwd)
+  if (mdcFiles.length === 0) return []
+  return discoverCheckRulesFromCursorRules(available, mdcFiles)
+}
+
+/**
+ * Прогоняє `fix.mjs` кожного правила окремим процесом, захоплюючи output.
+ * @param {string[]} idsToRun правила
+ * @param {string} cwd корінь
+ * @returns {{ totalFailed:number, rules:Array<{ruleId:string, ok:boolean, output:string}> }} результат
+ */
+function runRuleFixProcesses(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 ok = r.status === 0
+    rules.push({ ruleId: id, ok, output: `${r.stdout ?? ''}${r.stderr ?? ''}`.trim() })
+    if (!ok) totalFailed++
+  }
+  return { totalFailed, rules }
+}
+
+/**
+ * Конформність-детект: per-rule `fix.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()) {
+  ensureTool('conftest')
+  const available = await listRuleIds(BUNDLED_RULES_DIR)
+  if (available.length === 0) return { total: 0, failed: 0, rules: [] }
+
+  const idsToRun = await resolveCheckRuleIds(requestedRules, available, cwd)
+  if (idsToRun.length === 0) return { total: 0, failed: 0, rules: [] }
+
+  const { totalFailed, rules } = runRuleFixProcesses(idsToRun, cwd)
+  return { total: idsToRun.length, failed: totalFailed, rules }
+}

package/scripts/lib/fix/t0.mjs

@@ -1,8 +1,8 @@
 /** @see ./docs/t0.md */
 import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { spawnSync } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
+import { join } from 'node:path'
+
+import { runFixCheck } from './run-fix-check.mjs'
 
 const REC_REQUIRE_RE = /recommendations має містити "[^"]+"/
 const REC_MATCH_ALL_RE = /recommendations має містити "([^"]+)"/g
@@ -109,27 +109,6 @@ export function filterT0AutoRules(failedRules) {
 
 // ─── CLI entry-point ──────────────────────────────────────────────────────────
 
-const HERE = dirname(fileURLToPath(import.meta.url))
-/** Абсолютний шлях до npm/bin/n-cursor.js відносно цього файлу */
-const N_CURSOR_BIN = join(HERE, '../../../bin/n-cursor.js')
-
-/**
- * Запускає `_fix-check` і парсить JSON-результат.
- * @param {string[]} ruleFilter список rule-ids (порожній — усі)
- * @param {string}   cwd  корінь проєкту
- * @returns {{ rules: Array<{ ruleId: string, ok: boolean, output: string }> } | { _empty: true } | { _badJson: true }} JSON або маркер помилки
- */
-function fixCheck(ruleFilter, cwd) {
-  const r = spawnSync('bun', [N_CURSOR_BIN, '_fix-check', ...ruleFilter], { cwd, encoding: 'utf8', timeout: 120_000 })
-  const raw = r.stdout?.trim()
-  if (!raw) return { _empty: true, stderr: r.stderr }
-  try {
-    return JSON.parse(raw)
-  } catch {
-    return { _badJson: true }
-  }
-}
-
 /**
  * Застосовує T0-auto до кожного провального правила, розділяючи на applied/skipped.
  * @param {Array<{ ruleId: string, output: string }>} failed провальні правила
@@ -154,26 +133,16 @@ function applyT0ToFailed(failed, cwd) {
  * CLI підкоманда `n-cursor fix-t0 [rule...]`.
  * Запускає `fix --json`, застосовує T0-auto для кожного violation,
  * повторно перевіряє check-gate, виводить підсумок.
- * @param {string[]} args аргументи підкоманди (опційний список rule-ids)
+ * @param {string[]} args аргументи (опційний список rule-ids)
  * @param {string}   cwd  корінь проєкту
  * @returns {Promise<number>} 0 — T0-auto закрив всі або немає порушень; 1 — лишились
  */
-export function runT0AutoCli(args, cwd) {
+export async function runT0AutoCli(args, cwd) {
   const ruleFilter = args.filter(a => !a.startsWith('--'))
   const verbose = args.includes('--verbose') || args.includes('-v')
 
-  // 1. Запустити fix --json
-  const fixJson = fixCheck(ruleFilter, cwd)
-  if (fixJson._empty) {
-    console.error(`n-cursor fix-t0: fix --json повернув порожній stdout`)
-    console.error(fixJson.stderr?.slice(0, 300) ?? '')
-    return 1
-  }
-  if (fixJson._badJson) {
-    console.error(`n-cursor fix-t0: fix --json повернув невалідний JSON`)
-    return 1
-  }
-
+  // 1. Конформність-детект (пряма функція, без subprocess)
+  const fixJson = await runFixCheck(ruleFilter, cwd)
   const failed = fixJson.rules.filter(r => !r.ok)
   if (failed.length === 0) {
     console.log(`✅ fix-t0: всі правила чисті — T0 не потрібен`)
@@ -195,11 +164,7 @@ export function runT0AutoCli(args, cwd) {
   }
 
   // 4. Check-gate: перевірити лише ті правила, що ми чіпали
-  const recheckJson = fixCheck(applied.map(a => a.ruleId), cwd)
-  if (recheckJson._empty) {
-    console.error(`fix-t0: check-gate: fix --json повернув порожній stdout`)
-    return 1
-  }
+  const recheckJson = await runFixCheck(applied.map(a => a.ruleId), cwd)
   const stillFailed = recheckJson.rules.filter(r => !r.ok)
 
   if (verbose) {

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

@@ -0,0 +1,22 @@
+/**
+ * Список `.mdc`-файлів правил у `.cursor/rules/` проєкту-споживача (відсортований).
+ * Винесено зі `bin/n-cursor.js`, щоб ділити між CLI-dispatch і `run-fix-check` (конформність-детект).
+ */
+import { existsSync } from 'node:fs'
+import { readdir } from 'node:fs/promises'
+import { join } from 'node:path'
+import { cwd as processCwd } from 'node:process'
+
+/** Каталог правил у проєкті-споживачі (відносно кореня). */
+export const CURSOR_RULES_DIR = '.cursor/rules'
+
+/**
+ * @param {string} [cwd] корінь проєкту
+ * @returns {Promise<string[]>} імена `*.mdc` (відсортовані), або `[]` якщо каталогу немає
+ */
+export async function listProjectRulesMdcFiles(cwd = processCwd()) {
+  const dir = join(cwd, CURSOR_RULES_DIR)
+  if (!existsSync(dir)) return []
+  const names = await readdir(dir)
+  return names.filter(n => n.endsWith('.mdc')).toSorted((a, b) => a.localeCompare(b))
+}

package/scripts/post-tool-use-fix.mjs

@@ -8,11 +8,13 @@
  *
  * Контракт:
  * - stdin Claude Code: JSON із `tool_input.file_path`; якщо файлу немає (напр. Bash) — exit 0 (skip);
- * - інакше spawn `_fix-check` (детект усіх правил), exit-код прозоро пробрасуємо (PostToolUse
- *   не блокує turn, але код лишаємо інформативним: 1 — є порушення конформності).
+ * - інакше пряма `runFixCheck` (детект усіх правил, без subprocess-обгортки), exit-код прозоро:
+ *   1 — є порушення конформності (PostToolUse не блокує turn, але код лишаємо інформативним).
  */
-import { spawn } from 'node:child_process'
 import { once } from 'node:events'
+import { cwd as processCwd } from 'node:process'
+
+import { runFixCheck } from './lib/fix/run-fix-check.mjs'
 
 /**
  * Зчитує stdin до EOF як utf8 рядок. На TTY — повертає `''` одразу.
@@ -57,9 +59,9 @@ export function extractFilePath(stdinJson) {
 /**
  * Точка входу. Викликається з `bin/n-cursor.js` коли argv[0] === `post-tool-use-fix`.
  * Параметри доступні для інʼєкції для тестів: `stdinJson` обходить read від `process.stdin`,
- * `spawnFn` — заміна `node:child_process.spawn`.
- * @param {{ stdinJson?: string, spawnFn?: typeof spawn }} [options] параметри для тестів
- * @returns {Promise<number>} exit code (0 — пропущено / конформність ОК; інше — є порушення)
+ * `runFixCheckFn` — заміна `runFixCheck`.
+ * @param {{ stdinJson?: string, runFixCheckFn?: typeof runFixCheck }} [options] параметри для тестів
+ * @returns {Promise<number>} exit code (0 — пропущено / конформність ОК; 1 — є порушення)
  */
 export async function runPostToolUseFixCli(options = {}) {
   const stdinJson = options.stdinJson ?? (await readStdin())
@@ -68,12 +70,15 @@ export async function runPostToolUseFixCli(options = {}) {
   if (filePath === null) {
     return 0
   }
-  const spawnFn = options.spawnFn ?? spawn
-  // Один read-only виклик: детект конформності всіх активованих правил, без роутингу.
-  const child = spawnFn('npx', ['--no', '@nitra/cursor', '_fix-check'], { stdio: 'inherit' })
+  const check = options.runFixCheckFn ?? runFixCheck
+  // Один read-only детект конформності всіх активованих правил (пряма функція, без subprocess).
   try {
-    const [code] = await once(child, 'exit')
-    return code ?? 1
+    const { failed, rules } = await check([], processCwd())
+    if (failed === 0) return 0
+    for (const r of rules.filter(x => !x.ok)) {
+      if (r.output) process.stderr.write(`${r.output}\n`)
+    }
+    return 1
   } catch (error) {
     process.stderr.write(`post-tool-use-fix: не вдалося запустити детект конформності — ${error.message}\n`)
     return 1