@nitra/cursor 12.3.1 → 12.3.3

package/rules/python/lint/docs/lint.md

@@ -3,324 +3,27 @@ type: JS Module
 title: lint.mjs
 resource: npm/rules/python/lint/lint.mjs
 docgen:
-  crc: 92c8f115
+  crc: 61a1e3c3
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 90
+  issues: internal-name:runStandardLint,judge:inaccurate:0.99
+  judgeModel: openai-codex/gpt-5.4-mini
 ---
 
-Модуль `npm/rules/python/lint/lint.mjs` реалізує крок `lint-python` — частину
-загального лінт-пайплайну монорепозиторію. Крок виконує перевірку Python-частини
-проєкту відповідно до правила `python.mdc` і базується на пакетному менеджері
-[uv](https://docs.astral.sh/uv/).
+## Огляд
 
-Поведінкові ключові точки:
+Забезпечує виконання обов'язкових кроків для валідації Python-коду відповідно до правил, визначених у `python.mdc`, використовуючи інструменти з [uv](https://docs.astral.sh/uv/). Якщо `pyproject.toml` відсутній у корені, процес завершується з кодом 0. Якщо файл присутній, але `uv` не знайдено в PATH, це розглядається як помилка. Обов'язкові кроки включають перевірку актуальності lock-файлу (`uv lock --check`) та збірку середовища (`uv sync --frozen`). Опціональні лінтери (`ruff`, `mypy`) запускаються лише за умови їх доступності через `uv run`. Цей процес реалізує канон патерну `lint-*` (серіалізація через `runStandardLint`).
 
-- Якщо у корені, переданому як `cwd` (за замовчуванням `process.cwd()`), немає
-  файлу `pyproject.toml`, крок завершується успіхом (`exit code 0`) без запуску
-  будь-яких інструментів. Це дозволяє безпечно вмикати крок у репозиторіях
-  без Python-частини.
-- Якщо `pyproject.toml` присутній, але бінарника `uv` немає в `PATH`, крок
-  завершується помилкою. Інших пакет-менеджерів (Poetry, pip, pdm тощо) модуль
-  не підтримує — `uv` є єдиним каноном.
-- Обовʼязкові кроки `uv lock --check` і `uv sync --frozen` запускаються завжди,
-  якщо `uv` доступний.
-- Опційні лінтери (`ruff check --fix`, `ruff format`, `mypy`) запускаються
-  лише якщо вони доступні через `uv run --frozen <tool> --version`. Якщо
-  відповідного інструмента у uv-середовищі немає — крок пропускається з
-  pass-повідомленням (аналогічно «optional vendor-tools» у `php.mdc`).
-- `ruff` працює в auto-fix-режимі (`--fix`, потім `format`), тобто може
-  мутувати робоче дерево, подібно до `markdownlint-cli2 --fix` у `lint-text`
-  чи `clippy --fix` у `lint-rust`.
-- Серіалізація запусків CLI організована через `runStandardLint` (а не через
-  безпосередній `withLock`) — це відповідає канону патерну `lint-*`, описаному
-  в `.cursor/rules/scripts.mdc` (секція «Серіалізація важких CLI-команд»).
+## Поведінка
 
-Файл одночасно є:
+runLintPythonSteps виконує обов'язкові кроки для Python-лінтування за правилом python.mdc на базі [uv](https://docs.astral.sh/uv/). Якщо `pyproject.toml` відсутній, кроки пропускаються. Якщо `uv` не знайдено, виникає помилка. Виконує перевірку актуальності lock-файлу (`uv lock --check`) та збірку середовища (`uv sync --frozen`). Опціонально запускає лінтери (`ruff`, `mypy`) через `uv run`, якщо вони доступні.
+runLintPython серіалізує запуск кроків лінтування Python через механізм `runStandardLint` та повертає код виходу.
 
-1. Бібліотекою (експортує функції `runLintPythonSteps` та `runLintPython`).
-2. CLI-точкою входу — при запуску напряму (`isRunAsCli`) виконує
-   `runLintPython()` і виставляє `process.exitCode`.
+## Публічний API
 
-## Експорти / API
+runLintPythonSteps — Виконує внутрішні етапи перевірки коду Python без блокування.
+runLintPython — Виконує публічну команду перевірки коду Python, забезпечуючи унікальність виконання на основі стану Git-дерева та використовуючи механізм блокування.
 
-| Експорт              | Тип                     | Призначення                                                                                                                                               |
-| -------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `runLintPythonSteps` | `function`              | Виконує внутрішні кроки `lint-python` (без зовнішнього локу). Призначений для повторного використання з обгортки `runStandardLint` та для тестування.     |
-| `runLintPython`      | `() => Promise<number>` | Публічна CLI-форма: запускає `runLintPythonSteps` через `runStandardLint`, який бере глобальний лок `lint-python` і дедупає прогони за станом git-дерева. |
+## Гарантії поведінки
 
-Модуль не має default-export. Усі експорти — іменовані ES Module exports.
-
-Side effect модуля верхнього рівня: якщо файл запущений як CLI
-(`isRunAsCli(import.meta.url)` повертає `true`), на верхньому рівні
-виконується `await runLintPython()` і результат записується у
-`process.exitCode`.
-
-## Функції
-
-### `runTool(label, cmd, args, pass, fail)`
-
-Внутрішня (не експортується) функція-обгортка над `child_process.spawnSync`,
-яка запускає вказаний CLI-крок і репортить результат через колбеки репортера.
-
-- Сигнатура: `runTool(label: string, cmd: string, args: string[], pass: (msg: string) => void, fail: (msg: string) => void): boolean`
-- Параметри:
-  - `label` — людиночитана назва кроку, використовується у повідомленнях
-    (`lint-python: <label> — OK` / `lint-python: <label> — помилка ...`).
-  - `cmd` — абсолютний шлях до виконуваного файлу (наприклад, отриманий через
-    `resolveCmd('uv')`).
-  - `args` — масив аргументів CLI.
-  - `pass` — callback репортера для успіху.
-  - `fail` — callback репортера для невдачі.
-- Повертає: `true`, якщо процес завершився з `status === 0`, інакше `false`.
-- Спосіб запуску: `spawnSync(cmd, args, { stdio: 'inherit', shell: false })`.
-  Це означає, що stdout/stderr CLI-кроку успадковуються від батьківського
-  процесу (видно користувачу), а інтерпретація аргументів shell-ом
-  вимкнена — аргументи передаються «as is».
-- Обробка статусу: якщо `r.status` не число (наприклад, процес був убитий
-  сигналом), у повідомлення про помилку підставляється `1`.
-- Side effects: запуск зовнішнього процесу; запис у stdout/stderr батька;
-  виклик `pass` або `fail` репортера.
-
-### `uvToolAvailable(uv, tool)`
-
-Внутрішня (не експортується) перевірка наявності лінтера всередині
-uv-середовища.
-
-- Сигнатура: `uvToolAvailable(uv: string, tool: string): boolean`
-- Параметри:
-  - `uv` — абсолютний шлях до бінарника `uv`.
-  - `tool` — назва бінарника, що перевіряється (`ruff`, `mypy`, тощо).
-- Повертає: `true`, якщо `uv run --frozen <tool> --version` завершився з
-  кодом `0`, інакше `false`.
-- Спосіб запуску: `spawnSync(uv, ['run', '--frozen', tool, '--version'],
-{ stdio: 'ignore', shell: false })`. `stdio: 'ignore'` гасить весь вивід
-  пробної команди, щоб не засмічувати лог.
-- Side effects: запуск дочірнього процесу `uv run --frozen <tool> --version`.
-  Опція `--frozen` гарантує, що `uv` не намагатиметься оновлювати lock-файл
-  під час перевірки.
-
-### `runLintPythonSteps(cwd?)`
-
-Експортована функція. Виконує всю послідовність кроків `lint-python` без
-зовнішнього серіалізаційного локу.
-
-- Сигнатура: `runLintPythonSteps(cwd?: string): number`
-- Параметри:
-  - `cwd` — корінь репозиторію. За замовчуванням `process.cwd()`.
-- Повертає: код виходу — `0`, якщо всі обовʼязкові кроки пройшли успішно,
-  `1` — якщо хоча б один крок зафейлив. Кінцевий код повертається через
-  `reporter.getExitCode()` (інстансу `createCheckReporter`).
-- Алгоритм:
-  1. Створює репортер: `const reporter = createCheckReporter()`,
-     дістає колбеки `{ pass, fail }`.
-  2. Перевіряє `existsSync(join(cwd, 'pyproject.toml'))`. Якщо файла
-     немає — викликає `pass(...)` з повідомленням «кроки Python пропущено»
-     і повертає `reporter.getExitCode()`.
-  3. `const uv = resolveCmd('uv')` — резолвить абсолютний шлях до `uv`.
-     Якщо `uv` не знайдено — `fail(...)` і повернення коду.
-  4. Виконує `runTool('uv lock --check', uv, ['lock', '--check'], pass, fail)`.
-     За невдачі — повертає поточний код (далі не йде).
-  5. Виконує `runTool('uv sync --frozen', uv, ['sync', '--frozen'], pass,
-fail)`. За невдачі — повертає поточний код.
-  6. Створює локальний хелпер `runOptionalUvTool(tool, label, args)`
-     (див. нижче) і послідовно запускає:
-     - `runOptionalUvTool('ruff', 'ruff check --fix', ['check', '--fix', '.'])`
-     - `runOptionalUvTool('ruff', 'ruff format', ['format', '.'])`
-     - `runOptionalUvTool('mypy', 'mypy', ['.'])`
-       За першої ж справжньої невдачі (повертає `false`) — повернення поточного
-       коду виходу.
-  7. Повертає `reporter.getExitCode()`.
-- Side effects:
-  - Запуск зовнішніх процесів (`uv lock`, `uv sync`, `uv run ruff`,
-    `uv run mypy`).
-  - `ruff check --fix` та `ruff format` можуть **модифікувати файли
-    проєкту** (auto-fix Python-коду).
-  - `uv sync --frozen` може створювати або оновлювати `.venv` (з повним
-    дотриманням `uv.lock`).
-  - Запис у stdout/stderr через `stdio: 'inherit'`.
-
-### `runOptionalUvTool(tool, label, args)` (вкладена у `runLintPythonSteps`)
-
-Внутрішній замикач, доступний лише всередині `runLintPythonSteps`. Захоплює
-`uv`, `pass`, `fail` із зовнішньої області видимості.
-
-- Сигнатура: `runOptionalUvTool(tool: string, label: string, args: string[]): boolean`
-- Параметри:
-  - `tool` — імʼя інструмента (`ruff`, `mypy`).
-  - `label` — назва кроку для повідомлень.
-  - `args` — аргументи, які слід передати інструменту після `uv run --frozen <tool>`.
-- Повертає: `true`, якщо крок успішно завершився **або** інструмент
-  відсутній у uv-середовищі (тоді крок пропускається з pass-повідомленням).
-  `false` повертається тільки коли інструмент доступний і завершився з
-  ненульовим статусом.
-- Логіка:
-  1. `if (!uvToolAvailable(uv, tool))` → `pass(...)` з повідомленням «крок
-     пропущено» і повертає `true` (це коректне продовження пайплайну,
-     інструмент трактується як optional).
-  2. Інакше викликає `runTool(label, uv, ['run', '--frozen', tool, ...args],
-pass, fail)`.
-- Side effects: ті ж, що й у `runTool` / `uvToolAvailable` (запуск дочірніх
-  процесів, оновлення репортера).
-
-### `runLintPython`
-
-Публічна обгортка-стрілкова функція.
-
-- Сигнатура: `runLintPython(): Promise<number>`
-- Параметри: немає.
-- Повертає: `Promise<number>` — код виходу, отриманий з `runStandardLint`.
-- Реалізація: `runStandardLint(import.meta.dirname, runLintPythonSteps)`.
-  Сенс параметрів:
-  - `import.meta.dirname` — директорія самого модуля; використовується
-    `runStandardLint` як ідентифікатор для дедуплікації / стану git-дерева.
-  - `runLintPythonSteps` — функція кроків, яку `runStandardLint` викличе
-    всередині глобального локу `lint-python`.
-- Серіалізація: `runStandardLint` бере глобальний лок `lint-python` (як
-  описано в `scripts.mdc`) та дедупає прогони за станом git-дерева, тому
-  паралельні виклики `runLintPython()` не перетинатимуться по запуску
-  `uv`.
-- Side effects: ті самі, що й у `runLintPythonSteps`, плюс блокування на
-  файловому локу.
-
-## CLI-вхід (верхній рівень модуля)
-
-```js
-if (isRunAsCli(import.meta.url)) {
-  process.exitCode = await runLintPython()
-}
-```
-
-- Перевірка `isRunAsCli(import.meta.url)` встановлює, чи запущений файл
-  безпосередньо як CLI-точка входу (наприклад, `node lint.mjs` або через
-  `n-cursor`), а не імпортований як модуль.
-- Якщо так — виконується top-level `await runLintPython()`, а результат
-  кладеться у `process.exitCode`. Це означає, що Node завершиться з цим
-  кодом після того, як event loop спорожніє.
-- Якщо файл імпортовано як модуль, цей блок не виконується — викликач сам
-  вирішує, як використати експортовані функції.
-
-## Залежності
-
-### Стандартна бібліотека Node.js
-
-- `node:child_process` → `spawnSync` — синхронний запуск зовнішніх процесів
-  (`uv`, `uv run …`).
-- `node:fs` → `existsSync` — перевірка наявності `pyproject.toml`.
-- `node:path` → `join` — побудова повного шляху до `pyproject.toml` від `cwd`.
-
-### Внутрішні модулі репозиторію
-
-- `../../../scripts/cli-entry.mjs` → `isRunAsCli` — детекція CLI-режиму
-  через `import.meta.url`.
-- `../../../scripts/lib/check-reporter.mjs` → `createCheckReporter` —
-  фабрика репортера з методами `pass`, `fail`, `getExitCode`. Цей патерн
-  єдиний для всіх лінт-кроків.
-- `../../../scripts/utils/resolve-cmd.mjs` → `resolveCmd` — пошук
-  виконуваного файлу в `PATH` (повертає абсолютний шлях або `null`).
-- `../../../scripts/lib/run-standard-lint.mjs` → `runStandardLint` —
-  стандартизована обгортка над лінт-кроком (глобальний лок + дедуплікація
-  за станом git-дерева).
-
-### Зовнішні бінарники (runtime-залежності)
-
-- `uv` — обовʼязковий у `PATH`, якщо в репозиторії є `pyproject.toml`.
-- `ruff` — опційний, перевіряється через `uv run --frozen ruff --version`.
-- `mypy` — опційний, перевіряється через `uv run --frozen mypy --version`.
-
-### Артефакти у проєкті
-
-- `pyproject.toml` (у корені `cwd`) — тригер запуску Python-частини.
-- `uv.lock` — використовується `uv lock --check` та `uv sync --frozen`,
-  має бути актуальним.
-
-## Потік виконання / Використання
-
-### Сценарій 1: Python-частини немає
-
-1. `runLintPython()` → `runStandardLint(...)` → `runLintPythonSteps()`.
-2. `existsSync('<cwd>/pyproject.toml')` повертає `false`.
-3. Репортер фіксує pass-повідомлення «немає pyproject.toml у корені — кроки
-   Python пропущено».
-4. Повертається `0`.
-
-### Сценарій 2: Python є, але `uv` не встановлений
-
-1. `existsSync('pyproject.toml')` → `true`.
-2. `resolveCmd('uv')` → `null`.
-3. `fail('lint-python: `uv` не знайдено в PATH ...')`.
-4. Повертається `1`.
-
-### Сценарій 3: Повний прогон з усіма лінтерами
-
-1. `uv lock --check` — перевірка lock-файлу. За невдачі вихід `1`.
-2. `uv sync --frozen` — інсталяція середовища строго за `uv.lock`. За
-   невдачі вихід `1`.
-3. `uvToolAvailable(uv, 'ruff')` → `true` → `uv run --frozen ruff check
---fix .`. Може **змінити файли**.
-4. `uv run --frozen ruff format .`. Також може **змінити файли**.
-5. `uvToolAvailable(uv, 'mypy')` → `true` → `uv run --frozen mypy .`.
-   Лише читає, не змінює дерево.
-6. Якщо всі кроки повернули `0` — підсумок `0`. Інакше — перший
-   ненульовий код розриває послідовність і повертається.
-
-### Сценарій 4: `ruff` або `mypy` не встановлені у uv-середовищі
-
-- Для відповідного інструмента `uvToolAvailable` поверне `false`.
-- Виводиться pass-повідомлення «<tool> недоступний у uv-середовищі —
-  крок пропущено».
-- Інші кроки виконуються штатно.
-
-### Як викликати з коду
-
-```js
-import { runLintPython, runLintPythonSteps } from './lint.mjs'
-
-// Стандартний шлях: з локом, дедуплікацією, асинхронно.
-const code = await runLintPython()
-process.exit(code)
-
-// Прямий виклик без локу (наприклад, у тестах або з власною серіалізацією):
-const codeRaw = runLintPythonSteps('/path/to/repo')
-```
-
-### Як викликати з CLI
-
-Файл є виконуваною точкою входу для лінт-пайплайну. У звичайному монорепо
-він викликається через спільний раннер (`n-cursor`, `bun run lint` тощо).
-Прямий запуск:
-
-```bash
-node npm/rules/python/lint/lint.mjs
-```
-
-Кодом виходу буде число з `runLintPython()` (`0` — OK, `1` — є помилки).
-
-## Rebuild Test
-
-За цією документацією можна відтворити модуль так:
-
-1. Створити ES Module-файл, що імпортує `spawnSync` з `node:child_process`,
-   `existsSync` з `node:fs`, `join` з `node:path`, а також `isRunAsCli`,
-   `createCheckReporter`, `resolveCmd`, `runStandardLint` з відповідних
-   шляхів `../../../scripts/...`.
-2. Реалізувати приватну `runTool(label, cmd, args, pass, fail)`:
-   `spawnSync` з `stdio: 'inherit'`, `shell: false`; при `status === 0`
-   викликати `pass`, інакше `fail` з кодом (типу number або `1` при
-   неприродному завершенні); повертати `boolean`.
-3. Реалізувати `uvToolAvailable(uv, tool)`: `spawnSync(uv, ['run',
-'--frozen', tool, '--version'], { stdio: 'ignore', shell: false })` →
-   `r.status === 0`.
-4. Експортувати `runLintPythonSteps(cwd = process.cwd())`:
-   - створити репортер;
-   - якщо `pyproject.toml` відсутній → `pass(...)` і повернути код;
-   - резолвити `uv`; якщо немає → `fail(...)` і повернути;
-   - послідовно: `uv lock --check`, `uv sync --frozen` (обовʼязкові);
-   - опційні через локальну функцію-замикач `runOptionalUvTool`: `ruff
-check --fix .`, `ruff format .`, `mypy .` — кожен через
-     `uvToolAvailable` + `runTool`;
-   - повернути `reporter.getExitCode()`.
-5. Експортувати `runLintPython = () => runStandardLint(import.meta.dirname,
-runLintPythonSteps)`.
-6. На верхньому рівні: `if (isRunAsCli(import.meta.url)) process.exitCode =
-await runLintPython()`.
-
-Результат повинен поведінково збігтися з оригіналом: ті самі повідомлення,
-ті самі коди виходу, така ж серіалізація та обробка опційних інструментів.
+- Read-only: не виконує операцій запису (ФС/БД).

package/rules/python/lint/lint.mjs

@@ -63,9 +63,11 @@ function uvToolAvailable(uv, tool) {
 /**
  * Внутрішні кроки `lint-python` без локу.
  * @param {string} [cwd] корінь репозиторію
+ * @param {{ readOnly?: boolean }} [opts] readOnly → `ruff` без `--fix`, `ruff format --check` (нуль мутацій, CI/детект)
  * @returns {number} 0 — OK, 1 — є помилки
  */
-export function runLintPythonSteps(cwd = process.cwd()) {
+export function runLintPythonSteps(cwd = process.cwd(), opts = {}) {
+  const readOnly = opts.readOnly === true
   const reporter = createCheckReporter()
   const { pass, fail } = reporter
 
@@ -98,8 +100,10 @@ export function runLintPythonSteps(cwd = process.cwd()) {
     return runTool(label, uv, ['run', '--frozen', tool, ...args], pass, fail)
   }
 
-  if (!runOptionalUvTool('ruff', 'ruff check --fix', ['check', '--fix', '.'])) return reporter.getExitCode()
-  if (!runOptionalUvTool('ruff', 'ruff format', ['format', '.'])) return reporter.getExitCode()
+  const ruffCheck = readOnly ? ['check', '.'] : ['check', '--fix', '.']
+  const ruffFormat = readOnly ? ['format', '--check', '.'] : ['format', '.']
+  if (!runOptionalUvTool('ruff', readOnly ? 'ruff check' : 'ruff check --fix', ruffCheck)) return reporter.getExitCode()
+  if (!runOptionalUvTool('ruff', readOnly ? 'ruff format --check' : 'ruff format', ruffFormat)) return reporter.getExitCode()
   if (!runOptionalUvTool('mypy', 'mypy', ['.'])) return reporter.getExitCode()
 
   return reporter.getExitCode()
@@ -107,10 +111,12 @@ export function runLintPythonSteps(cwd = process.cwd()) {
 
 /**
  * Публічна CLI-форма: серіалізує через `withLock('lint-python')` + дедуп за станом git-дерева.
+ * @param {{ readOnly?: boolean }} [opts] readOnly → детект без мутацій (проброс у кроки)
  * @returns {Promise<number>} код виходу
  */
-export const runLintPython = () => runStandardLint(import.meta.dirname, runLintPythonSteps)
+export const runLintPython = (opts = {}) =>
+  runStandardLint(import.meta.dirname, () => runLintPythonSteps(process.cwd(), opts))
 
 if (isRunAsCli(import.meta.url)) {
-  process.exitCode = await runLintPython()
+  process.exitCode = await runLintPython({ readOnly: process.argv.includes('--read-only') })
 }

package/rules/python/meta.json

@@ -1 +1 @@
-{ "auto": { "glob": "pyproject.toml" } }
+{ "auto": { "glob": "pyproject.toml" }, "lint": "full" }

package/rules/rego/rego.mdc

@@ -1,5 +1,5 @@
 ---
-description: Opa, Rego — інструментарій (VS Code, lint-rego)
+description: Opa, Rego — інструментарій (VS Code, opa/regal)
 version: '1.1'
 globs: "**/*.rego"
 alwaysApply: false
@@ -12,17 +12,13 @@ alwaysApply: false
 ## Перевірка
 
 ```bash
-bun run lint-rego
+n-cursor lint rego
 ```
 
 Цілі — `npm/rules/` (рекурсивно знаходить `.rego` у `<rule>/policy/<concern>/`). Інші *.rego поза деревом додай у `LINT_TARGETS` у `npm/rules/rego/lint/lint.mjs`.
 
 `opa` і `regal` — лише у `PATH`, **не** додавай у `dependencies` / `devDependencies`.
 
-### `package.json`
-
-- Канон `scripts.lint-rego`: [package.json.snippet.json](./policy/package_json/template/package.json.snippet.json)
-
 ### `.vscode/extensions.json`
 
 - Канон `recommendations` має містити `tsandall.opa` (LSP, format-on-save через `opa fmt`): [extensions.json.snippet.json](./policy/vscode_extensions/template/extensions.json.snippet.json)

package/rules/security/policy/package_json/package_json.rego

@@ -5,14 +5,6 @@ package security.package_json
 
 import rego.v1
 
-# ── deny: кожен snippet leaf має співпадати з input ──────────────────────────
-deny contains msg if {
-	some script_name, expected in data.template.snippet.scripts
-	actual := object.get(object.get(input, "scripts", {}), script_name, "")
-	actual != expected
-	msg := sprintf("package.json: scripts.%s має бути %q (security.mdc)", [script_name, expected])
-}
-
 # ── deny: жодного ключа з deny у dependencies/devDependencies ────────────────
 deny contains msg if {
 	some pkg, reason in data.template.deny.dependencies
@@ -25,14 +17,3 @@ deny contains msg if {
 	pkg in object.keys(object.get(input, "devDependencies", {}))
 	msg := sprintf("package.json: devDependencies.%s — %s (security.mdc)", [pkg, reason])
 }
-
-# ── deny: рядкові поля з contains мають містити кожен substring ──────────────
-# Перевіряємо лише наявні поля (якщо `scripts.<name>` відсутній — поле опціональне).
-deny contains msg if {
-	some script_name, needles in data.template.contains.scripts
-	actual := object.get(object.get(input, "scripts", {}), script_name, "")
-	actual != ""
-	some needle in needles
-	not contains(actual, needle)
-	msg := sprintf("package.json: scripts.%s має містити %q (security.mdc)", [script_name, needle])
-}

package/rules/security/security.mdc

@@ -1,5 +1,5 @@
 ---
-description: Локальний та CI-секюріті-лінт через TruffleHog — скрипт `lint-security`, `.trufflehog-exclude`, інтеграція в агрегований `lint`; канонічний placeholder `sample-secret` у прикладних файлах
+description: Локальний та CI-секюріті-лінт через TruffleHog — `.trufflehog-exclude`, канонічний placeholder `sample-secret` у прикладних файлах
 globs: "**/.trufflehog-exclude,**/package.json,**/.github/workflows/**/*.yml"
 alwaysApply: false
 version: '2.1'
@@ -7,10 +7,10 @@ version: '2.1'
 
 [TruffleHog](https://github.com/trufflesecurity/trufflehog) — глобальний CLI (як `shellcheck`, `conftest`); **не** додавай до `dependencies`/`devDependencies`.
 
-## Канон `package.json#scripts`
+## Канон `package.json`
+
+Скан запускається через `n-cursor lint security` (CI — `n-cursor lint security --read-only`); окремого `lint-*` скрипта в `package.json` немає.
 
-- `lint-security` скрипт: [package.json.snippet.json](./policy/package_json/template/package.json.snippet.json)
-- `lint` агрегатор повинен містити: [package.json.contains.json](./policy/package_json/template/package.json.contains.json)
 - Заборонено `trufflehog` у `dependencies`/`devDependencies`: [package.json.deny.json](./policy/package_json/template/package.json.deny.json)
 
 **Зауваження:**
@@ -19,8 +19,7 @@ version: '2.1'
 - `--no-update` — вимикає self-update check (CI-friendly).
 - `--exclude-paths .trufflehog-exclude` — файл з regex-patterns, які треба пропускати (аналог `[allowlist].paths` із gitleaks).
 - `--results=verified,unknown` — показує лише верифіковані секрети + ті, що TruffleHog не зміг перевірити (`unverified` дублікат відсіюється).
-- `--fail` — exit-code `183` за наявності знахідок (потрібно, щоб `bun run lint` падав).
-- Позиція в `lint`: за конвенцією після інших `lint-*` і перед `oxfmt`.
+- `--fail` — exit-code `183` за наявності знахідок (щоб лінт падав).
 
 ## `.trufflehog-exclude` (рекомендована основа)
 

package/rules/style-lint/policy/lint_style_yml/template/lint-style.yml.snippet.yml

@@ -36,4 +36,4 @@ jobs:
       - uses: ./.github/actions/setup-bun-deps
 
       - name: StyleLint
-        run: npx stylelint '**/*.{css,scss,vue}'
+        run: n-cursor lint style-lint --read-only

package/rules/style-lint/policy/package_json/package_json.rego

@@ -10,16 +10,6 @@ package style_lint.package_json
 
 import rego.v1
 
-# ── deny: substring requirements у scripts (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 (style-lint.mdc)", [script_name, needle])
-}
-
 # ── deny: 2-level snippet walker (для stylelint.extends, якщо поле є) ────
 
 deny contains msg if {

package/rules/style-lint/style-lint.mdc

@@ -95,16 +95,17 @@ $white-a1: color.adjust(white, $alpha: -0.85);
 
 - **Джерело правил:** перед тим як писати або суттєво змінювати **`.css`**, **`.scss`** або стилі в **`.vue`**, переглянь у корені проєкту (і в релевантних пакетах монорепо, якщо є) поле **`stylelint`** у **`package.json`** (зокрема `extends`), наявні **`.stylelintrc.*`**, **`stylelint.config.*`** та **`.stylelintignore`**. Не покладайся на «типові» правила stylelint з пам’яті — дотримуйся **проєктного** **`@nitra/stylelint-config`** і будь-яких локальних доповнень у репозиторії.
 - **Форматування** узгоджуй з **`n-text.mdc`** (oxfmt / `.oxfmtrc.json` для css, scss тощо), щоб форматер і stylelint не суперечили один одному.
-- **Запуск stylelint:** лише **`npx stylelint`**. Локально — через скрипт **`lint-style`** (`bun run lint-style`, з `--fix`); у **GitHub Actions** у кроці **`run`** викликай `npx stylelint '**/*.{css,scss,vue}'` напряму **без `--fix`** (CI — read-only, нуль мутацій; не через **`bun run lint-style`**). Не використовуй **`bunx stylelint`**. Після змін запускай **`bun run lint-style`** і виправляй усе, що лишилось після auto-fix; за потреби — повний `bun run lint` (навичка **`/n-lint`**).
+- **Запуск stylelint:** лише через **`n-cursor lint style-lint`** (локально — з auto-fix; у CI — `--read-only`, нуль мутацій). Під капотом — `npx stylelint`; **не** використовуй **`bunx stylelint`**. Після змін запускай **`n-cursor lint style-lint`** і виправляй усе, що лишилось після auto-fix; за потреби — повний прогін `n-cursor lint --full`.
 - **Не розширюй винятки:** не додавай зайві **`stylelint-disable`** без потреби; краще підлаштувати стилі під правила проєкту.
 
 ## Канон
 
 ### `package.json`
 
-- `lint-style` (substring requirement): [package.json.contains.json](./policy/package_json/template/package.json.contains.json)
 - `stylelint.extends`: [package.json.snippet.json](./policy/package_json/template/package.json.snippet.json)
 
+Окремого `lint-style` скрипта немає — запуск через **`n-cursor lint style-lint`** (CI — `--read-only`).
+
 ### `.vscode/extensions.json`
 
 - Канон `recommendations`: [extensions.json.snippet.json](./policy/vscode_extensions/template/extensions.json.snippet.json)
@@ -120,9 +121,6 @@ $white-a1: color.adjust(white, $alpha: -0.85);
 **`package.json`:**
 
 ```json title="package.json"
-  "scripts": {
-    "lint-style": "npx stylelint '**/*.{css,scss,vue}' --fix",
-  },
   "devDependencies": {
     "@nitra/stylelint-config": "^1.4.0"
   },
@@ -131,7 +129,7 @@ $white-a1: color.adjust(white, $alpha: -0.85);
   },
 ```
 
-Додай **`.github/workflows/lint-style.yml`** (лише **`.yml`**, **`ga.mdc`**): після **`checkout`** — локальний composite **`setup-bun-deps`**, далі `npx stylelint '**/*.{css,scss,vue}'` (CI — без `--fix`) у кроці **`run`**. **Не** дублюй окремі кроки **`setup-node`** / **`oven-sh/setup-bun`** / кеш / **`npm install`**.
+Додай **`.github/workflows/lint-style.yml`** (лише **`.yml`**, **`ga.mdc`**): після **`checkout`** — локальний composite **`setup-bun-deps`**, далі `n-cursor lint style-lint --read-only` у кроці **`run`**. **Не** дублюй окремі кроки **`setup-node`** / **`oven-sh/setup-bun`** / кеш / **`npm install`**.
 
 ```yaml title=".github/workflows/lint-style.yml"
 name: StyleLint

package/rules/text/js/formatting.mjs

@@ -94,25 +94,20 @@ function checkTextConfigsExistence(passFn, failFn, cwd) {
 }
 
 /**
- * Перевіряє package.json для текстового стека: складний `lint-text` скрипт і
- * виклик `n-cursor lint-text --read-only` у відповідному workflow (CI — нуль мутацій). Решта (Prettier-заборона,
- * `@nitra/cspell-dict ^2.0.0+`, заборона `markdownlint-cli2` у залежностях,
- * `@nitra/*` гейт) — у Rego (`text.package_json`, `bun.package_json`).
+ * Перевіряє CI-workflow текстового стека: крок `n-cursor lint text --read-only` у
+ * `.github/workflows/lint-text.yml` (CI — нуль мутацій). Окремого `lint-text` скрипта в
+ * `package.json` немає — лінт через `n-cursor lint text`. Решта package.json-перевірок
+ * (Prettier-заборона, `@nitra/cspell-dict`, `@nitra/*` гейт) — у Rego (`text.package_json`, `bun.package_json`).
  * @param {(msg: string) => void} passFn callback при успішній перевірці
  * @param {(msg: string) => void} failFn callback при помилці
  * @param {string} cwd корінь репозиторію
  */
-async function checkPackageJsonText(passFn, failFn, cwd) {
-  const pkgPath = join(cwd, 'package.json')
-  if (!existsSync(pkgPath)) return
-  const pkg = JSON.parse(await readFile(pkgPath, 'utf8'))
-  checkLintTextScript(pkg.scripts?.['lint-text'], passFn, failFn)
-
+async function checkLintTextWorkflow(passFn, failFn, cwd) {
   const lintTextWf = join(cwd, '.github/workflows/lint-text.yml')
   if (existsSync(lintTextWf)) {
     const wf = await readFile(lintTextWf, 'utf8')
     const root = parseWorkflowYaml(wf)
-    const canonRun = 'n-cursor lint-text --read-only'
+    const canonRun = 'n-cursor lint text --read-only'
     const ok = root ? anyRunStepIncludes(root, canonRun) : wf.includes(canonRun)
     if (ok) {
       passFn(`lint-text.yml викликає ${canonRun}`)
@@ -124,25 +119,6 @@ async function checkPackageJsonText(passFn, failFn, cwd) {
   }
 }
 
-/**
- * Перевіряє скрипт lint-text: канонічний — `n-cursor lint-text` (CLI пакета `@nitra/cursor` робить
- * `cspell` → `runShellcheckText()` → `bunx markdownlint-cli2 --fix` → `runV8rWithGlobs()`).
- * Дозволено whitespace навколо команди.
- * @param {unknown} lintText значення `scripts.lint-text` з package.json
- * @param {(msg: string) => void} passFn callback при успішній перевірці
- * @param {(msg: string) => void} failFn callback при помилці
- */
-function checkLintTextScript(lintText, passFn, failFn) {
-  const lt = typeof lintText === 'string' ? lintText.trim() : ''
-  if (lt === 'n-cursor lint-text') {
-    passFn('lint-text делегує CLI n-cursor lint-text (cspell + shellcheck + markdownlint + v8r)')
-  } else {
-    failFn(
-      'package.json: lint-text має бути "n-cursor lint-text" — CLI пакета @nitra/cursor виконує cspell → shellcheck → markdownlint-cli2 → v8r (text.mdc)'
-    )
-  }
-}
-
 /**
  * Перевіряє відповідність проєкту правилам text.mdc.
  * @param {string} [cwd] корінь репозиторію
@@ -166,7 +142,7 @@ export async function check(cwd = process.cwd()) {
     }
   }
 
-  await checkPackageJsonText(pass, fail, cwd)
+  await checkLintTextWorkflow(pass, fail, cwd)
 
   return reporter.getExitCode()
 }

package/rules/text/policy/lint_text/template/lint-text.yml.snippet.yml

@@ -58,4 +58,4 @@ jobs:
           | sh -s -- -b /usr/local/bin
 
       - name: Lint text
-        run: n-cursor lint-text --read-only
+        run: n-cursor lint text --read-only

package/scripts/lib/fix/docs/llm-worker.md

@@ -3,7 +3,7 @@ type: JS Module
 title: llm-worker.mjs
 resource: npm/scripts/lib/fix/llm-worker.mjs
 docgen:
-  crc: de9eb68c
+  crc: 857c510e
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
 ---
@@ -18,7 +18,7 @@ docgen:
 
 ## Публічний API
 
-- `runLlmWorker(ruleId, violationOutput, projectRoot, opts)` — виправляє одне порушення; `opts`: `model`, `feedback`, `caller`. Повертає `{ ok, error, changes, diagnosis }`.
+- `runLlmWorker(ruleId, violationOutput, projectRoot, opts)` — виправляє одне порушення; `opts`: `model`, `feedback`, `caller`, `timeoutMs` (per-tier ліміт виклику; драбина задає коротший для локальних рунгів). Повертає `{ ok, error, changes, diagnosis }`.
 
 ## Гарантії поведінки