@nitra/cursor 1.20.0 → 1.22.0

package/.claude-template/settings.template.json

@@ -10,14 +10,14 @@
     ]
   },
   "hooks": {
-    "Stop": [
+    "PostToolUse": [
       {
-        "matcher": "",
+        "matcher": "Edit|Write|MultiEdit",
         "hooks": [
           {
             "type": "command",
-            "command": "npx --no @nitra/cursor stop-hook",
-            "timeout": 60
+            "command": "npx --no @nitra/cursor post-tool-use-fix",
+            "timeout": 300
           }
         ]
       }

package/CHANGELOG.md

@@ -4,6 +4,36 @@
 
 Формат — [Keep a Changelog](https://keepachangelog.com/uk/1.1.0/), нумерація — [SemVer](https://semver.org/lang/uk/).
 
+## [1.22.0] - 2026-05-25
+
+### Added
+
+- **`npx @nitra/cursor lint`** — оркестратор лінт-ланцюжка з тайменгом на кожен крок. Послідовно запускає присутні у root `package.json` скрипти з фіксованого списку (`lint-ga`, `lint-js`, `lint-rego`, `lint-style`, `lint-text`, `lint-security`, `oxfmt`), **fail-fast** на першому ненульовому exit-коді. Наприкінці друкує таблицю `⏱ Lint timing` з часом кожного кроку — для атрибуції повільних кроків замість анонімного `&&`-агрегатора.
+- **`runFixCommand` тепер друкує `⏱ Fix timing`** після прогону всіх `rules/<id>/fix.mjs` — per-rule час + сума. Маркер `❌` на впалих рядках.
+- `npm/scripts/lib/timing-summary.mjs` — чистий форматер `formatTimingSummary(title, entries)` (спільний для fix і lint). 9 тестів у `tests/timing-summary.test.mjs`.
+- `npm/scripts/lib/run-lint-cli.mjs` — `runLintCli({ cwd, spawnSyncFn, now, log, logError })` з DI для юніт-тестів. 7 тестів у `tests/run-lint-cli.test.mjs`.
+
+### Changed
+
+- Кореневий `package.json` цього монорепо: `lint` → `n-cursor lint`; додано окремий скрипт `oxfmt: "oxfmt ."`, який раніше йшов у хвості ланцюжка прямою командою.
+- Скіли `/n-fix` і `/n-lint`: додано вимогу копіювати таблицю `⏱` з виводу інструмента у фінальне резюме відповіді користувачу.
+
+## [1.21.0] - 2026-05-25
+
+### Changed
+
+- **Stop-hook → PostToolUse з маршрутизацією за типом файла** (BREAKING для консьюмерів із кастомним `stop-hook` записом). `.claude-template/settings.template.json` тепер реєструє `PostToolUse` (matcher `Edit|Write|MultiEdit`, timeout 300) із командою `npx --no @nitra/cursor post-tool-use-fix` замість попереднього синхронного `Stop`-хука, що ганяв повний `fix` усіх правил на кожному turn-і. Новий хук читає `tool_input.file_path` зі stdin і запускає `fix` **лише** з релевантними правилами: `*.{mjs,js,cjs,ts,tsx,jsx}` → `js-lint`; `*.vue` → `js-lint style-lint vue`; `*.{css,scss,sass}` → `style-lint`; `**/k8s/**/*.{yaml,yml}` → `k8s`; `*.rego` → `rego`; `Dockerfile`/`*.Dockerfile` → `docker`; `.github/workflows/*.{yml,yaml}` → `ga`; `package.json` → `npm-module bun`; `*.sh` → `security`; `*.md` → `text` (поза `docs/adr/**` — там покриває async `normalize-decisions.sh`).
+- **CLI**: підкоманду `npx @nitra/cursor stop-hook` видалено; замість неї — `npx @nitra/cursor post-tool-use-fix`. `MANAGED_HOOK_COMMAND_MARKER` у `sync-claude-config.mjs` змінено на `@nitra/cursor post-tool-use-fix`; legacy-маркер `@nitra/cursor stop-hook` лишається у `MANAGED_HOOK_COMMAND_MARKERS` для автоматичного cleanup-у старих entries при наступному `npx @nitra/cursor`. `mergeHooks` тепер обходить union usually template+existing events, тому застарілі managed-групи у вже-непотрібних подіях (`Stop` у даному випадку) теж зачищаються.
+
+### Added
+
+- `npm/scripts/post-tool-use-fix.mjs` — реалізація `routeFilePathToRules(filePath)` (чиста функція, picomatch) і `runPostToolUseFixCli({ stdinJson, spawnFn })` (DI-friendly для тестів). 21 тест у `npm/scripts/tests/post-tool-use-fix.test.mjs`.
+- `LEGACY_STOP_HOOK_COMMAND_MARKER` — публічний export для тестів і потенційних консьюмерів, які перевіряють відсутність застарілого хука.
+
+### Removed
+
+- `npm/scripts/claude-stop-hook.mjs` — більше не потрібен.
+
 ## [1.20.0] - 2026-05-25
 
 ### Added

package/bin/n-cursor.js

@@ -9,8 +9,13 @@
  *                                     якщо в корені вже є `.n-cursor.json`, спочатку зчитується конфіг і за потреби дописується `$schema`
  *   `npx \@nitra/cursor fix bun`     — перевірити лише вказані правила (ігнорує `.cursor/rules/`)
  *   `npx \@nitra/cursor rename-yaml-extensions` — k8s `*.yml` → `*.yaml`, `.github` `*.yaml` → `*.yml` (опції: `--dry-run`, `--root=…`; див. bin/rename-yaml-extensions.mjs)
- *   `npx \@nitra/cursor stop-hook`   — точка входу Stop hook Claude Code (читає stdin, виходить 0 при `stop_hook_active`,
- *                                     інакше викликає `fix`); прописується автоматично в `.claude/settings.json`
+ *   `npx \@nitra/cursor post-tool-use-fix` — точка входу PostToolUse hook Claude Code: читає stdin JSON,
+ *                                     дістає `tool_input.file_path`, маршрутизує його у відповідні правила
+ *                                     (`*.mjs` → `js-lint`, `*.vue` → `js-lint style-lint vue` тощо) і викликає
+ *                                     `fix` лише з ними. Прописується автоматично в `.claude/settings.json`.
+ *   `npx \@nitra/cursor lint`        — оркестратор lint-ланцюжка з кореневого `package.json` з тайменгом
+ *                                     кожного `lint-*` / `oxfmt` скрипта (fail-fast); канонічна заміна
+ *                                     раніше ручного `lint-ga && lint-js && …` агрегатора.
  *   `npx \@nitra/cursor lint-ga`     — канонічний lint-ga (ga.mdc): preflight на `shellcheck` →
  *                                     `bunx github-actionlint` → `uvx zizmor --offline --collect=workflows .`
  *   `npx \@nitra/cursor lint-rego`   — канонічний lint-rego (conftest.mdc + rego.mdc):
@@ -83,7 +88,7 @@ import {
   RULE_MIGRATIONS
 } from '../scripts/auto-rules.mjs'
 import { detectAutoSkills } from '../scripts/auto-skills.mjs'
-import { runStopHookCli } from '../scripts/claude-stop-hook.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 { ensureNitraCursorInRootDevDependencies } from '../scripts/ensure-nitra-cursor-dev-dependencies.mjs'
@@ -97,6 +102,8 @@ import { upgradeNitraCursorToLatestAndBunInstall } from '../scripts/upgrade-nitr
 import { runRenameYamlExtensionsCli } from './rename-yaml-extensions.mjs'
 import { runSkillsCli } from '../scripts/skills-cli.mjs'
 import { syncSetupBunDepsAction } from '../scripts/sync-setup-bun-deps-action.mjs'
+import { runLintCli } from '../scripts/lib/run-lint-cli.mjs'
+import { formatTimingSummary } from '../scripts/lib/timing-summary.mjs'
 
 const PACKAGE_NAME = '@nitra/cursor'
 const CONFIG_FILE = '.n-cursor.json'
@@ -1181,12 +1188,19 @@ async function runFixCommand(requestedRules) {
   }
 
   let totalFailed = 0
+  /** @type {{ id: string, ms: number, ok: boolean }[]} */
+  const timings = []
   for (const id of idsToRun) {
     const fixPath = join(BUNDLED_RULES_DIR, id, 'fix.mjs')
+    const startedAt = Date.now()
     const result = spawnSync('bun', [fixPath], { stdio: 'inherit' })
-    if (result.status !== 0) totalFailed++
+    const ok = result.status === 0
+    timings.push({ id: `fix-${id}`, ms: Date.now() - startedAt, ok })
+    if (!ok) totalFailed++
   }
 
+  process.stdout.write(formatTimingSummary('Fix timing', timings))
+
   if (totalFailed > 0) {
     throw new Error(`${totalFailed} з ${idsToRun.length} правил мають проблеми`)
   }
@@ -1427,14 +1441,21 @@ try {
 
       break
     }
-    case 'stop-hook': {
-      // Викликається з .claude/settings.json як Stop hook Claude Code.
-      // Прокидає `check` і поважає stop_hook_active, щоб не зациклюватись.
-      const code = await runStopHookCli()
+    case 'post-tool-use-fix': {
+      // Викликається з .claude/settings.json як PostToolUse hook Claude Code.
+      // Маршрутизує змінений файл у релевантні правила і прокидає `fix` лише з ними.
+      const code = await runPostToolUseFixCli()
       process.exitCode = code
 
       break
     }
+    case 'lint': {
+      // Оркестратор lint-ланцюжка з тайменгом на кожен крок (fail-fast).
+      // Замінює раніше використовуваний агрегатор `bun run lint-ga && bun run lint-js && …` у root package.json.
+      process.exitCode = runLintCli()
+
+      break
+    }
     case 'lint-ga': {
       // Канонічний lint-ga з preflight на shellcheck → actionlint → zizmor → check-ga (ga.mdc).
       // Останній крок (check-ga) async — тому await обов'язковий, інакше process.exitCode буде Promise.
@@ -1488,7 +1509,7 @@ try {
     default: {
       console.error(`❌ Невідома команда: ${command}`)
       console.error(
-        `   Очікується: (без аргументів) синхронізація правил, check, rename-yaml-extensions, stop-hook, lint-ga, lint-rego, lint-k8s, lint-docker, lint-text, coverage, skill`
+        `   Очікується: (без аргументів) синхронізація правил, check, rename-yaml-extensions, post-tool-use-fix, lint, lint-ga, lint-rego, lint-k8s, lint-docker, lint-text, coverage, skill`
       )
       process.exitCode = 1
     }

package/package.json

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

package/rules/adr/adr.mdc

@@ -103,22 +103,12 @@ docs/adr/
 
 ## Stop-hook у `.claude/settings.json`
 
-Канонічний запис, який вставляє sync (поряд із lint stop-hook):
+Канонічний запис, який вставляє sync (поряд із PostToolUse fix-хуком — той живе в іншій події, тут не показаний):
 
 ```json title=".claude/settings.json"
 {
   "hooks": {
     "Stop": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "npx --no @nitra/cursor stop-hook",
-            "timeout": 60
-          }
-        ]
-      },
       {
         "matcher": "",
         "hooks": [
@@ -146,7 +136,7 @@ docs/adr/
 }
 ```
 
-Усі три групи ідентифікуються пакетом за маркером у `command` (`@nitra/cursor stop-hook`, `.claude/hooks/capture-decisions.sh`, `.claude/hooks/normalize-decisions.sh`) — користувацькі hook-групи поряд не чіпаються. Якщо `adr` прибрати з `rules`, обидві ADR-групи автоматично видаляються на наступному `npx @nitra/cursor`.
+Обидві ADR-групи ідентифікуються пакетом за маркером у `command` (`.claude/hooks/capture-decisions.sh`, `.claude/hooks/normalize-decisions.sh`) — користувацькі hook-групи поряд не чіпаються. Якщо `adr` прибрати з `rules`, обидві ADR-групи автоматично видаляються на наступному `npx @nitra/cursor`.
 
 ## Stop-hook у `.cursor/hooks.json`
 

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

@@ -0,0 +1,118 @@
+/**
+ * `n-cursor lint` — оркестратор лінт-ланцюжка з тайменгом на кожен крок.
+ *
+ * Замість агрегатора `bun run lint-ga && bun run lint-js && ... && oxfmt .` у кореневому
+ * `package.json` (де child-процеси анонімні і час кожного не видно), цей орекстратор:
+ *
+ *  - читає `scripts` з кореневого `package.json`,
+ *  - бере **присутні** ключі з фіксованого списку `LINT_SCRIPTS` (відсутні мовчки пропускає),
+ *  - послідовно запускає `bun run <script>`,
+ *  - заміряє час кожного,
+ *  - **fail-fast**: при першому ненульовому exit-коді зупиняється, друкує таблицю
+ *    лише по виконаних і повертає той самий код,
+ *  - друкує підсумкову таблицю `⏱ Lint timing` і повертає 0, якщо все ОК.
+ *
+ * Список + порядок зумисне фіксований: збігається з канонічним ланцюжком, що його раніше
+ * тримав root `package.json`. Динамічний discovery (`scripts/^lint-/`) дав би непередбачуваний
+ * порядок і небажану інтерпретацію кастомних `lint-*` користувача.
+ *
+ * `oxfmt` — окремий рядок поза префіксом `lint-`, ставиться в кінець (як було у `lint`).
+ */
+import { spawnSync as defaultSpawnSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { formatTimingSummary } from './timing-summary.mjs'
+
+/**
+ * Імена npm-скриптів, які `n-cursor lint` запускає **по черзі**, якщо вони є у root `package.json`.
+ * Порядок дзеркалить попередній агрегатор `lint`: cheap-checks першими, формат — в кінці.
+ */
+export const LINT_SCRIPTS = /** @type {const} */ ([
+  'lint-ga',
+  'lint-js',
+  'lint-rego',
+  'lint-style',
+  'lint-text',
+  'lint-security',
+  'oxfmt'
+])
+
+/**
+ * Читає `scripts` з `package.json` у заданій теці. Повертає `null`, якщо файла немає, JSON
+ * некоректний або поля `scripts` нема. Не кидає — викликач сам вирішує, що робити.
+ *
+ * @param {string} root абсолютний шлях до теки з `package.json`
+ * @returns {Record<string, string> | null} мапа scripts або null
+ */
+function readRootScripts(root) {
+  const packageJsonPath = join(root, 'package.json')
+  if (!existsSync(packageJsonPath)) {
+    return null
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
+    const scripts = parsed?.scripts
+    if (!scripts || typeof scripts !== 'object') {
+      return null
+    }
+    return /** @type {Record<string, string>} */ (scripts)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * @typedef {{
+ *   cwd?: string,
+ *   spawnSyncFn?: typeof defaultSpawnSync,
+ *   now?: () => number,
+ *   log?: (text: string) => void,
+ *   logError?: (text: string) => void
+ * }} RunLintCliOptions
+ */
+
+/**
+ * Виконує лінт-ланцюжок з тайменгом. Повертає exit-код, не кидає винятків (для прямого
+ * присвоєння у `process.exitCode`).
+ *
+ * @param {RunLintCliOptions} [options] DI для тестів (мокаємо spawn / fs / clock)
+ * @returns {number} 0 = успіх, ненульовий = code першого впалого скрипта, або 1 при структурних проблемах
+ */
+export function runLintCli(options = {}) {
+  const root = options.cwd ?? process.cwd()
+  const spawnSync = options.spawnSyncFn ?? defaultSpawnSync
+  const now = options.now ?? Date.now
+  const log = options.log ?? (text => process.stdout.write(text))
+  const logError = options.logError ?? (text => process.stderr.write(text))
+
+  const scripts = readRootScripts(root)
+  if (scripts === null) {
+    logError(`❌ n-cursor lint: не знайдено package.json або поля "scripts" у ${root}\n`)
+    return 1
+  }
+
+  const present = LINT_SCRIPTS.filter(name => typeof scripts[name] === 'string' && scripts[name].length > 0)
+  if (present.length === 0) {
+    log('\nℹ️  n-cursor lint: у package.json немає жодного з lint-* / oxfmt скриптів — нічого запускати.\n')
+    return 0
+  }
+
+  /** @type {{ id: string, ms: number, ok: boolean }[]} */
+  const timings = []
+  let failedCode = 0
+  for (const name of present) {
+    const startedAt = now()
+    const result = spawnSync('bun', ['run', name], { stdio: 'inherit', cwd: root })
+    const code = typeof result.status === 'number' ? result.status : 1
+    const ok = code === 0
+    timings.push({ id: name, ms: now() - startedAt, ok })
+    if (!ok) {
+      failedCode = code === 0 ? 1 : code
+      break
+    }
+  }
+
+  log(formatTimingSummary('Lint timing', timings))
+  return failedCode
+}

package/scripts/lib/timing-summary.mjs

@@ -0,0 +1,67 @@
+/**
+ * Формат таблиці-резюме часу виконання для оркестраторів `fix` / `lint`.
+ *
+ * Дві спільні точки використання:
+ *  - `runFixCommand` у `bin/n-cursor.js` — після прогону всіх `rules/<id>/fix.mjs`.
+ *  - `runLintCli` у `scripts/lib/run-lint-cli.mjs` — після прогону `lint-*` скриптів з кореневого `package.json`.
+ *
+ * Чиста функція без I/O — повертає готовий рядок (з фінальним `\n`), друк — на стороні виклику.
+ * Час виводиться як `<ціла>.<десята>s`, навіть для субсекундних інтервалів — щоб одиниця була стабільна.
+ *
+ * Маркер `❌` на рядку — якщо `ok === false`.
+ *
+ * @typedef {{ id: string, ms: number, ok: boolean }} TimingEntry
+ */
+
+/** @type {string} символ горизонтальної риски між списком і `total` */
+const RULER = '─'
+
+/**
+ * Форматує мілісекунди як `<sec>.<десята>s`. Округлення до десятої — нижнє (floor), щоб
+ * однаковий ms давав однаковий вивід у різних таблицях незалежно від платформи (Number.prototype.toFixed
+ * робить round-half-to-even, що для 950ms дає `0.9s` — приймаємо).
+ *
+ * @param {number} ms тривалість у мілісекундах (>= 0)
+ * @returns {string} наприклад `0.0s`, `1.2s`, `12.3s`
+ */
+export function formatDurationMs(ms) {
+  const seconds = Math.max(0, ms) / 1000
+  return `${seconds.toFixed(1)}s`
+}
+
+/**
+ * Рендерить таблицю-резюме у вигляді багаторядкового тексту, готового до stdout.
+ *
+ * Структура:
+ *
+ * ```
+ * ⏱  <title>:
+ *    <id>          <duration>  [❌]
+ *    ...
+ *    ──────────────
+ *    total         <sum>
+ * ```
+ *
+ * Ширина колонки id вирівнюється під найдовший id у списку. Мінімальна ширина riski — 14
+ * (узгоджено з типовою довжиною заголовків `fix-js-lint` / `lint-security`).
+ *
+ * @param {string} title заголовок таблиці (наприклад, `Fix timing` або `Lint timing`)
+ * @param {TimingEntry[]} timings записи в порядку запуску — друкуються як є, не сортуються
+ * @returns {string} готовий до stdout текст з кінцевим `\n`
+ */
+export function formatTimingSummary(title, timings) {
+  if (timings.length === 0) {
+    return ''
+  }
+  const idWidth = Math.max(14, ...timings.map(t => t.id.length))
+  const lines = [`\n⏱  ${title}:`]
+  let totalMs = 0
+  for (const { id, ms, ok } of timings) {
+    totalMs += ms
+    const failMark = ok ? '' : '  ❌'
+    lines.push(`   ${id.padEnd(idWidth)}  ${formatDurationMs(ms)}${failMark}`)
+  }
+  lines.push(`   ${RULER.repeat(idWidth + 2 + 6)}`)
+  lines.push(`   ${'total'.padEnd(idWidth)}  ${formatDurationMs(totalMs)}`)
+  return `${lines.join('\n')}\n`
+}

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

@@ -0,0 +1,129 @@
+/**
+ * PostToolUse hook для Claude Code: точкова маршрутизація `npx @nitra/cursor fix`
+ * за типом зміненого файла. Запускається після кожного `Edit` / `Write` / `MultiEdit`;
+ * замінює дорогий синхронний `Stop`-хук, що ганяв повний `fix` усіх правил на кожному
+ * turn-і.
+ *
+ * Контракт:
+ * - stdin Claude Code: JSON із `tool_input.file_path` (відносний шлях зміненого файла);
+ * - exit 0, якщо файл не маршрутизується (PostToolUse не блокує turn у будь-якому випадку,
+ *   але ми лишаємо exit-код прозорим — для діагностики);
+ * - інакше spawn `npx --no @nitra/cursor fix <rules…>` із пробрасуванням exit-коду.
+ *
+ * Маршрути впорядковані від найбільш специфічного до загального; перший збіг — переможець.
+ * `docs/adr/**\/*.md` свідомо повертає `[]`: ADR-нормалізація вже покривається async
+ * Stop-hook'ом `normalize-decisions.sh` — повторний `fix adr` тут лише сповільнював би turn.
+ */
+import { spawn } from 'node:child_process'
+import { once } from 'node:events'
+
+import picomatch from 'picomatch'
+
+/**
+ * @typedef {object} Route
+ * @property {string} pattern picomatch glob (з підтримкою `**` і `{a,b}`)
+ * @property {string[]} rules ID правил `npm/rules/<id>` (бо `fix.mjs` обов'язковий)
+ */
+
+/** Порядок важливий: специфічні маршрути (`.github/workflows/*`, `**\/k8s/**`) — перед загальними. */
+/** @type {readonly Route[]} */
+const ROUTES = Object.freeze([
+  { pattern: 'docs/adr/**/*.md', rules: [] },
+  { pattern: '.github/workflows/*.{yml,yaml}', rules: ['ga'] },
+  { pattern: '**/k8s/**/*.{yaml,yml}', rules: ['k8s'] },
+  { pattern: '**/*.vue', rules: ['js-lint', 'style-lint', 'vue'] },
+  { pattern: '**/*.{mjs,js,cjs,ts,tsx,jsx}', rules: ['js-lint'] },
+  { pattern: '**/*.{css,scss,sass}', rules: ['style-lint'] },
+  { pattern: '**/*.rego', rules: ['rego'] },
+  { pattern: '{**/,}Dockerfile', rules: ['docker'] },
+  { pattern: '**/*.Dockerfile', rules: ['docker'] },
+  { pattern: '**/*.sh', rules: ['security'] },
+  { pattern: '{**/,}package.json', rules: ['npm-module', 'bun'] },
+  { pattern: '**/*.md', rules: ['text'] }
+])
+
+/**
+ * Повертає список правил, які слід прогнати для зміненого `filePath`.
+ * Перший збіг із `ROUTES` — переможець; невідомі шляхи / некоректні входи → `[]`.
+ * @param {unknown} filePath відносний шлях зміненого файла зі stdin Claude Code
+ * @returns {string[]} ID правил для `npx @nitra/cursor fix`
+ */
+export function routeFilePathToRules(filePath) {
+  if (typeof filePath !== 'string' || filePath === '') {
+    return []
+  }
+  for (const { pattern, rules } of ROUTES) {
+    if (picomatch.isMatch(filePath, pattern, { dot: true })) {
+      return [...rules]
+    }
+  }
+  return []
+}
+
+/**
+ * Зчитує stdin до EOF як utf8 рядок. На TTY — повертає `''` одразу.
+ * @returns {Promise<string>} вміст stdin
+ */
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return ''
+  }
+  process.stdin.setEncoding('utf8')
+  const chunks = []
+  process.stdin.on('data', chunk => {
+    chunks.push(chunk)
+  })
+  try {
+    await once(process.stdin, 'end')
+  } catch {
+    // 'error' на stdin — повертаємо те, що встигли зібрати
+  }
+  return chunks.join('')
+}
+
+/**
+ * Дістає `tool_input.file_path` зі stdin JSON Claude Code. Невалідний JSON
+ * або відсутнє поле → `null` (не помилка: дехто з тулів — напр. Bash — не пише `file_path`).
+ * @param {string} stdinJson сирий вміст stdin
+ * @returns {string | null} відносний шлях або `null`
+ */
+function extractFilePath(stdinJson) {
+  if (!stdinJson) {
+    return null
+  }
+  try {
+    const obj = JSON.parse(stdinJson)
+    const fp = obj?.tool_input?.file_path
+    return typeof fp === 'string' && fp !== '' ? fp : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Точка входу. Викликається з `bin/n-cursor.js` коли argv[0] === `post-tool-use-fix`.
+ * Параметри ін'єктовні для тестів: `stdinJson` обходить read від `process.stdin`,
+ * `spawnFn` — заміна `node:child_process.spawn` (повертає EventEmitter-сумісний об'єкт).
+ * @param {{ stdinJson?: string, spawnFn?: typeof spawn }} [options]
+ * @returns {Promise<number>} exit code (0 — пропущено / fix ОК; інше — exit-код `fix`)
+ */
+export async function runPostToolUseFixCli(options = {}) {
+  const stdinJson = options.stdinJson ?? (await readStdin())
+  const filePath = extractFilePath(stdinJson)
+  if (filePath === null) {
+    return 0
+  }
+  const rules = routeFilePathToRules(filePath)
+  if (rules.length === 0) {
+    return 0
+  }
+  const spawnFn = options.spawnFn ?? spawn
+  const child = spawnFn('npx', ['--no', '@nitra/cursor', 'fix', ...rules], { stdio: 'inherit' })
+  try {
+    const [code] = await once(child, 'exit')
+    return code ?? 1
+  } catch (error) {
+    process.stderr.write(`post-tool-use-fix: не вдалося запустити npx @nitra/cursor fix — ${error.message}\n`)
+    return 1
+  }
+}

package/scripts/sync-claude-config.mjs

@@ -30,8 +30,10 @@ import { existsSync } from 'node:fs'
 import { chmod, mkdir, readFile, readdir, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 
-/** Маркер lint Stop-hook'а (`npx --no \@nitra/cursor stop-hook`). */
-export const MANAGED_HOOK_COMMAND_MARKER = '@nitra/cursor stop-hook'
+/** Маркер PostToolUse fix-hook'а (`npx --no \@nitra/cursor post-tool-use-fix`). */
+export const MANAGED_HOOK_COMMAND_MARKER = '@nitra/cursor post-tool-use-fix'
+/** Legacy-маркер старого Stop-hook'а — лишаємо для cleanup-у при оновленні існуючих інсталяцій. */
+export const LEGACY_STOP_HOOK_COMMAND_MARKER = '@nitra/cursor stop-hook'
 /** Маркер ADR Stop-hook'а — підрядок шляху до bash-скрипта capture-decisions. */
 export const ADR_HOOK_COMMAND_MARKER = '.claude/hooks/capture-decisions.sh'
 /** Маркер ADR Stop-hook'а — підрядок шляху до bash-скрипта normalize-decisions. */
@@ -40,9 +42,13 @@ export const ADR_NORMALIZE_HOOK_COMMAND_MARKER = '.claude/hooks/normalize-decisi
 export const CURSOR_ADR_HOOK_COMMAND_MARKER = '.claude/hooks/capture-decisions.sh'
 /** Маркер Cursor ADR Normalize Stop-hook'а — той самий script path, але в `.cursor/hooks.json`. */
 export const CURSOR_ADR_NORMALIZE_HOOK_COMMAND_MARKER = '.claude/hooks/normalize-decisions.sh'
-/** Усі маркери managed-hook'ів пакета — за ними відрізняємо свої записи від користувацьких. */
+/**
+ * Усі маркери managed-hook'ів пакета — за ними відрізняємо свої записи від користувацьких.
+ * Legacy stop-hook включений сюди, щоб старі entries автоматично видалялись при наступному sync-у.
+ */
 export const MANAGED_HOOK_COMMAND_MARKERS = Object.freeze([
   MANAGED_HOOK_COMMAND_MARKER,
+  LEGACY_STOP_HOOK_COMMAND_MARKER,
   ADR_HOOK_COMMAND_MARKER,
   ADR_NORMALIZE_HOOK_COMMAND_MARKER
 ])
@@ -189,9 +195,13 @@ export function mergeAllowList(existing, fromTemplate) {
 }
 
 /**
- * Зливає hooks-секцію: для кожної події в темплейті видаляємо managed-групи
- * з існуючої конфігурації і додаємо актуальні з темплейту. Немені події в
- * темплейті не чіпаються.
+ * Зливає hooks-секцію. Для **кожної події** з обох сторін:
+ *   1) видаляємо managed-групи з існуючої конфігурації (їх ідентифікують маркери з
+ *      `MANAGED_HOOK_COMMAND_MARKERS`, включно з legacy-маркерами — це автоматично
+ *      прибирає застарілі hook'и при переході на нову версію темплейту);
+ *   2) дописуємо managed-групи з темплейту.
+ * Перебір union-у подій важливий: коли пакет переносить hook між подіями (напр. `Stop`
+ * → `PostToolUse`), старі managed entries у вже-непотрібній події теж мають піти.
  * @param {Record<string, HookGroup[]> | undefined} existing поточна `hooks`-секція з .claude/settings.json
  * @param {Record<string, HookGroup[]> | undefined} fromTemplate цільова `hooks`-секція з темплейту
  * @returns {Record<string, HookGroup[]>} результат злиття (порожні події видаляються)
@@ -199,14 +209,13 @@ export function mergeAllowList(existing, fromTemplate) {
 export function mergeHooks(existing, fromTemplate) {
   /** @type {Record<string, HookGroup[]>} */
   const out = {}
-  for (const [event, groups] of Object.entries(existing ?? {})) {
-    out[event] = Array.isArray(groups) ? [...groups] : []
-  }
-  for (const [event, templateGroups] of Object.entries(fromTemplate ?? {})) {
-    const existingGroups = (out[event] ?? []).filter(g => !isManagedHookGroup(g))
-    out[event] = [...existingGroups, ...(templateGroups ?? [])]
-    if (out[event].length === 0) {
-      delete out[event]
+  const allEvents = new Set([...Object.keys(existing ?? {}), ...Object.keys(fromTemplate ?? {})])
+  for (const event of allEvents) {
+    const existingClean = (existing?.[event] ?? []).filter(g => !isManagedHookGroup(g))
+    const templateGroups = fromTemplate?.[event] ?? []
+    const combined = [...existingClean, ...templateGroups]
+    if (combined.length > 0) {
+      out[event] = combined
     }
   }
   return out

package/scripts/claude-stop-hook.mjs

@@ -1,74 +0,0 @@
-/**
- * Stop-hook для Claude Code: запускається hook'ом із `.claude/settings.json` після того,
- * як агент сигналізує завершення ходу. Прозоро прокидає `npx \@nitra/cursor fix`
- * і повертає його exit code, щоб помилки правил блокували завершення.
- *
- * Захист від нескінченної рекурсії: якщо stdin містить `"stop_hook_active": true`
- * (Claude Code позначає цей прапорець, коли hook сам спричинив повторний Stop),
- * виходимо з кодом 0 без повторного запуску перевірок.
- *
- * Виклик з `bin/n-cursor.js`:
- *   `npx --no \@nitra/cursor stop-hook`
- */
-import { spawn } from 'node:child_process'
-import { once } from 'node:events'
-
-/**
- * Зчитує stdin до EOF як utf8 рядок. Якщо stdin порожній (TTY) — повертає '' одразу.
- * @returns {Promise<string>} вміст stdin
- */
-async function readStdin() {
-  if (process.stdin.isTTY) {
-    return ''
-  }
-  process.stdin.setEncoding('utf8')
-  const chunks = []
-  process.stdin.on('data', chunk => {
-    chunks.push(chunk)
-  })
-  try {
-    await once(process.stdin, 'end')
-  } catch {
-    // 'error' на stdin — повертаємо те, що встигли зібрати
-  }
-  return chunks.join('')
-}
-
-/**
- * Чи stdin вказує, що поточний Stop вже виник через попередній Stop hook
- * (Claude Code передає `stop_hook_active: true`). У такому випадку повторний
- * запуск перевірок створив би нескінченний цикл — пропускаємо.
- * @param {string} stdin сирий вміст stdin
- * @returns {boolean} true, якщо рекурсивний виклик
- */
-export function isRecursiveStopHookCall(stdin) {
-  if (!stdin) {
-    return false
-  }
-  try {
-    const obj = JSON.parse(stdin)
-    return obj?.stop_hook_active === true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Точка входу. Викликається з `bin/n-cursor.js` коли argv[0] === 'stop-hook'.
- * @returns {Promise<number>} exit code (0 — OK / пропуск, 1 — помилки правил)
- */
-export async function runStopHookCli() {
-  const stdin = await readStdin()
-  if (isRecursiveStopHookCall(stdin)) {
-    return 0
-  }
-
-  const child = spawn('npx', ['--no', '@nitra/cursor', 'fix'], { stdio: 'inherit' })
-  try {
-    const [code] = await once(child, 'exit')
-    return code ?? 1
-  } catch (error) {
-    process.stderr.write(`stop-hook: не вдалося запустити npx @nitra/cursor fix — ${error.message}\n`)
-    return 1
-  }
-}