@7n/rules-lang-js 0.3.1 → 0.4.1

package/rules/js/dep-policy/dep-policy.mdc

@@ -0,0 +1,36 @@
+## Залежнісна політика (що не додавати)
+
+`@e18e/eslint-plugin` окремо не додавай — він уже в залежностях `@nitra/eslint-config` (з **3.8.0**), oxlint підвантажує його з `node_modules`. Пакети `oxlint`/`eslint`/`jscpd`/`knip` теж не додавай у `devDependencies` без потреби монорепо — `bunx` тягне їх ad-hoc.
+
+### Заборона `ua-parser-js`
+
+Пакет **`ua-parser-js`** заборонений починаючи з версії **2.x**, де ліцензія змінилась з MIT на **AGPL-3.0** — несумісну з комерційним використанням у закритому SaaS. Замінити на **`bowser`** (MIT, ~6 KB gzip):
+
+```javascript title="❌ до"
+import { UAParser } from 'ua-parser-js'
+const parser = new UAParser(userAgent)
+const result = parser.getResult()
+const browserName = result.browser.name
+```
+
+```javascript title="✅ після"
+import Bowser from 'bowser'
+const browser = Bowser.getParser(userAgent)
+const browserName = browser.getBrowserName()
+```
+
+Bowser надає ті самі поля: `getBrowserName()`, `getOSName()`, `getPlatform().vendor`. Міграція займає кілька рядків; логіка не змінюється.
+
+### Заборона `@nitra/as-integrations-fastify`
+
+Пакет **`@nitra/as-integrations-fastify`** заборонений у **`dependencies`**, **`peerDependencies`** та в import-specifier-ах. Це чистий републіш upstream, застряглий на peer `@apollo/server: "^4.0.0"`, тож на Apollo 5 `bun install` дає `warn: incorrect peer dependency`. Заміна — upstream **`@as-integrations/fastify`** (**`^3.1.0`**): peer `@apollo/server: "^4.0.0 || ^5.0.0"` + `fastify: "^5.3.0"`.
+
+Міграція — лише specifier у трьох місцях: залежність у `package.json`, `import`, та `vi.mock(...)` / `await import(...)` у тестах. **Код не міняється**, експорти ті самі: `default` → `fastifyApollo`, named → `fastifyApolloDrainPlugin`.
+
+```javascript title="❌ до"
+import fastifyApollo, { fastifyApolloDrainPlugin } from '@nitra/as-integrations-fastify'
+```
+
+```javascript title="✅ після"
+import fastifyApollo, { fastifyApolloDrainPlugin } from '@as-integrations/fastify'
+```

package/rules/js/dep-policy/docs/main.md

@@ -0,0 +1,35 @@
+---
+type: JS Module
+title: main.mjs
+resource: plugins/lang-js/rules/js/dep-policy/main.mjs
+docgen:
+  crc: 8acb4c08
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  issues: judge:inaccurate:0.98
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Файл сканує всі JS/TS-файли у поточному робочому каталозі, виключаючи конфігураційно визначені шляхи. Завдяки публічній функції main, він перевіряє відповідність усіх імпортів у коді політиці залежностей, визначеній у dep-policy.mdc. Ця **read-only** операція виявляє та фіксує будь-які імпорти, заборонені в dep-policy.mdc, надаючи підказки заміни з js.mdc. Механізм працює з fail-safe принципом, перехоплюючи помилки та не дозволяючи виняткам виходити назовні.
+
+## Поведінка
+
+Поведінка:
+
+1. Виконується функція main.
+2. Аналізуються всі JS/TS-файли у поточному робочому каталозі, виключаючи шляхи, визначені конфігурацією.
+3. Для кожного файлу витягуються всі імпорти (статичні, динамічні та виклики require).
+4. Знаходяться імпорти, які знаходяться у списку заборонених especifiers (dep-policy.mdc).
+5. Якщо знайдений імпорт заборонений, реєструється помилка, яка вказує на шлях до файлу, заборонений імпорт та підказку про його заміну (js.mdc).
+6. Після перевірки всіх файлів, якщо заборонених імпортів не знайдено, реєструється повідомлення про успішне завершення перевірки.
+
+## Публічний API
+
+main — перевіряє імпорти у файлах JavaScript та TypeScript на відповідність політиці залежностей.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).

package/rules/js/dep-policy/main.mjs

@@ -0,0 +1,99 @@
+/** @see ./docs/dep-policy.md */
+import { readFile } from 'node:fs/promises'
+import { relative } from 'node:path'
+
+import { parseSync } from 'oxc-parser'
+
+import { createViolationReporter } from '@7n/rules/scripts/lib/lint-surface/violation-reporter.mjs'
+import { loadCursorIgnorePaths } from '@7n/rules/scripts/lib/load-cursor-config.mjs'
+import { walkDir } from '@7n/rules/scripts/utils/walkDir.mjs'
+import {
+  dynamicImportModule,
+  langFromPath,
+  requireCallModule,
+  walkAstWithAncestors
+} from '@7n/rules/scripts/utils/ast-scan-utils.mjs'
+
+const JS_SOURCE_RE = /\.(?:[cm]?[jt]sx?)$/u
+
+/**
+ * Пакети, заборонені як import-specifier у будь-якому JS/TS-файлі.
+ * Ключ — specifier, значення — підказка про заміну.
+ */
+const BANNED_SPECIFIERS = new Map([
+  ['@nitra/as-integrations-fastify', 'використовуй @as-integrations/fastify'],
+  [
+    'ua-parser-js',
+    'замінити на bowser (MIT, ~6 KB) — npm i bowser. ua-parser-js v2 змінив ліцензію на AGPL-3.0, несумісну з комерційним використанням'
+  ]
+])
+
+/**
+ * Витягає з джерела всі import-specifier'и (static + dynamic + require).
+ * @param {string} source текст файлу
+ * @param {string} filePath шлях до файлу (для вибору мови OXC-парсера)
+ * @returns {string[]} список specifier'ів
+ */
+function extractImportSpecifiers(source, filePath) {
+  /** @type {string[]} */
+  const result = []
+  let parsed
+  try {
+    parsed = parseSync(filePath, source, { lang: langFromPath(filePath) })
+  } catch {
+    return result
+  }
+  for (const imp of parsed?.module?.staticImports ?? []) {
+    if (typeof imp?.moduleRequest?.value === 'string') result.push(imp.moduleRequest.value)
+  }
+  const program = parsed?.program
+  if (program && typeof program === 'object') {
+    walkAstWithAncestors(program, [], node => {
+      const dyn = dynamicImportModule(node)
+      if (dyn !== null) result.push(dyn)
+      const req = requireCallModule(node)
+      if (req !== null) result.push(req)
+    })
+  }
+  return result
+}
+
+/**
+ * Сканує всі JS/TS-файли проєкту на заборонені import-specifier'и (dep-policy.mdc).
+ * @param {import('@7n/rules/scripts/lib/lint-surface/types.mjs').LintContext} ctx контекст лінту
+ * @returns {Promise<import('@7n/rules/scripts/lib/lint-surface/types.mjs').LintResult>} Результат лінту з переліком порушень.
+ */
+export async function lint(ctx) {
+  const reporter = createViolationReporter(ctx)
+  const cwd = ctx.cwd
+  const ignorePaths = await loadCursorIgnorePaths(cwd)
+
+  const files = []
+  await walkDir(
+    cwd,
+    p => {
+      if (JS_SOURCE_RE.test(p)) files.push(p)
+    },
+    ignorePaths
+  )
+
+  let violations = 0
+  for (const absPath of files) {
+    const source = await readFile(absPath, 'utf8')
+    const specifiers = extractImportSpecifiers(source, absPath)
+    for (const spec of specifiers) {
+      const hint = BANNED_SPECIFIERS.get(spec)
+      if (hint !== undefined) {
+        const rel = relative(cwd, absPath)
+        reporter.fail(`${rel}: заборонений import '${spec}' — ${hint} (js.mdc dep-policy)`)
+        violations += 1
+      }
+    }
+  }
+
+  if (violations === 0) {
+    reporter.pass(`dep-policy: перевірено ${files.length} файлів — заборонених import-specifier'ів немає (js.mdc)`)
+  }
+
+  return reporter.result()
+}

package/rules/js/docs/index.md

@@ -0,0 +1,11 @@
+---
+type: Directory Index
+title: npm/rules/js
+resource: plugins/lang-js/rules/js/
+---
+
+# npm/rules/js
+
+| Файл                | Тип       |
+| ------------------- | --------- |
+| [main.mjs](main.md) | JS Module |

package/rules/js/eslint/concern.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "skipLocalTier": true,
+  "lint": {
+    "scope": "per-file",
+    "glob": ["**/*.{js,mjs,cjs,jsx,ts,tsx,vue}"]
+  }
+}

package/rules/js/eslint/docs/fix-eslint.md

@@ -0,0 +1,50 @@
+---
+type: JS Module
+title: fix-eslint.mjs
+resource: plugins/lang-js/rules/js/eslint/fix-eslint.mjs
+docgen:
+  crc: 38b4978d
+  model: manual
+---
+
+## Огляд
+
+T0-autofix для `js/eslint`, два патерни в порядку застосування. `js-eslint-autofix`:
+детермінований прогін лінтерів у fix-режимі (`oxlint --fix` + `eslint --fix`) по файлах, де
+детектор знайшов порушення — виправляє лише авто-fixable правила. `js-eslint-mechanical-text-fix`:
+для правил, які `--fix` НЕ покриває (suggestion-only у власній реалізації інструментів, перевірено
+емпірично на реальних lint-прогонах), але заміна на позначеному `data.line` текстуально однозначна
+й безпечна без AST-парсингу. Усе, що лишається непокритим — детектору на повторну перевірку, а
+далі LLM-ладдеру. Запис незворотний (поза rollback).
+
+## Поведінка
+
+`js-eslint-autofix`:
+- Збирає унікальні файли з порушень концерну, лишає лише js-сімейство (`.mjs/.cjs/.js/.jsx/.ts/.tsx/.vue`).
+- Послідовно застосовує `oxlint --fix` (CLI) і `eslint --fix` (через API з `outputFixes`).
+- До списку змінених потрапляють лише файли, чий вміст фактично змінився (порівняння до/після).
+
+`js-eslint-mechanical-text-fix`:
+- `MECHANICAL_TEXT_FIXES` — реєстр `{ reasons, replace }`: `reasons` покриває обидва формати
+  `violation.reason` (eslint `"plugin/rule"`, oxlint `"plugin(rule)"` — той самий rule різні тули
+  віддають по-різному); `replace(line)` — чиста функція рядка, `null` якщо шаблон не знайдено.
+- Групує порушення за файлом, для кожного цільового `data.line` (1-indexed) застосовує
+  відповідну `replace`; рядок без очікуваного шаблону (файл змінився з моменту detect-у) —
+  пропускається без гадання.
+- Наразі покриває `unicorn/prefer-number-is-safe-integer` (`Number.isInteger` → `Number.isSafeInteger`).
+
+## Публічний API
+
+- `patterns` — масив T0-патернів (`id` / `test` / `apply`), що його споживає центральний fix-pipeline:
+  `js-eslint-autofix` (лінтери в fix-режимі), `js-eslint-mechanical-text-fix` (текстові заміни для
+  suggestion-only правил).
+
+## Гарантії поведінки
+
+- `js-eslint-autofix`: якщо серед порушень немає js-файлів — лінтери не запускаються, змін немає.
+- `js-eslint-mechanical-text-fix`: пише лише файли з реальною зміною рядка (шаблон збігся); не
+  чіпає рядки поза `MECHANICAL_TEXT_FIXES`-реєстром.
+- Обидва патерни повертають лише фактично змінені файли; перед записом кожен реєструється через
+  `recordWrite`.
+- Межа CI: модуль належить fix-фазі; у `--no-fix` (CI) не запускається — узгоджено із
+  забороною `oxlint --fix`/`eslint --fix` у CI.

package/rules/js/eslint/docs/fix-worker.md

@@ -0,0 +1,31 @@
+---
+type: JS Module
+title: fix-worker.mjs
+resource: plugins/lang-js/rules/js/eslint/fix-worker.mjs
+docgen:
+  crc: 6371bb44
+  model: manual
+---
+
+## Огляд
+
+Custom fix-worker `js/eslint` (перекриває дефолтний `default-worker.mjs`): замість одного `runAgentFix`-виклику з усіма порушеннями з усіх файлів concern-а — окрема агентна сесія на кожен файл, ПАРАЛЕЛЬНО (обмежений пул, не більше `MAX_PARALLEL_FILES`). Мотивація й еволюція дизайну — `docs/adr/260718-0754-js-eslint-fix-worker-per-session-overhead.md`: послідовна версія стабільно впиралась у timeout на всіх 4 rung-ах драбини (local-min→cloud-avg); профайлінг реального прогону показав, що домінує кількість/довжина раундів моделі на файл, а не фіксовані bootstrap-витрати сесії — тож паралелізм (кілька файлів одночасно замість черги) дає пряме пришвидшення незалежно від причини.
+
+## Поведінка
+
+1. Групує вхідні `violations` за `file`; порушення без `file` ігноруються.
+2. Дедлайн — `DEADLINE_FRACTION` (0.8) від `ctx.timeoutMs`; гейтить лише СТАРТ нового файлу з черги (не скасовує вже запущені).
+3. `runPooled` — обмежений пул воркерів (`MAX_PARALLEL_FILES=4`): при `files.length ≤ MAX_PARALLEL_FILES` усі файли стартують майже одночасно й отримують практично весь бюджет незалежно один від одного; при більшій кількості черга природно звужує бюджет пізніших хвиль (`callTimeoutMs` рахується в момент старту файлу з черги, не наперед).
+4. На кожен файл — окремий `runAgentFix` із `targetFiles: [file]` і власним `verify` (`verifyFile`): item-scoped canonical re-detect лише цього файлу, не всього concern-а — інакше evidence-гейт хибно вважав би файл незакритим через порушення в ІНШИХ файлах.
+5. Один файл, що завершився з `error` АБО кинув виняток (try/catch у тілі воркера), не обриває пул — пропускається, решта файлів обробляються незалежно.
+6. Повертає лише `touchedFiles` з успішних (`!error`) викликів; success rung-а все одно визначає whole-concern canonical re-detect runner-а (`runRung`), не цей worker.
+
+## Публічний API
+
+- `fixWorker(violations, ctx)` — контракт `FixWorkerFn`; резолвиться автоматично замість `default-worker.mjs`, бо лежить як `fix-worker.mjs` поруч із `main.mjs` concern-а.
+
+## Гарантії поведінки
+
+- Пише лише у файли з переданих `violations` (`targetFiles: [file]` на кожен виклик) — той самий semantic-collateral guard, що й у дефолтного worker-а.
+- `recordWrite` (не durable) на кожен файл: rollback-контракт незмінний — якщо після worker-а в concern-і лишилось хоч одне порушення будь-де, `runRung` відкочує ВСІ правки цього rung-а, включно з уже полагодженими файлами.
+- Конкурентні виклики `recordWrite` безпечні: central snapshot — синхронні Map-операції без `await` усередині, event loop не перериває їх посеред виконання.

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

@@ -0,0 +1,11 @@
+---
+type: Directory Index
+title: npm/rules/js/eslint
+resource: plugins/lang-js/rules/js/eslint/
+---
+
+| Файл                            | Тип       |
+| ------------------------------- | --------- |
+| [fix-eslint.mjs](fix-eslint.md) | JS Module |
+| [fix-worker.mjs](fix-worker.md) | JS Module |
+| [main.mjs](main.md)             | JS Module |

package/rules/js/eslint/docs/main.md

@@ -0,0 +1,35 @@
+---
+type: JS Module
+title: main.mjs
+resource: plugins/lang-js/rules/js/eslint/main.mjs
+docgen:
+  crc: 8710f72f
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+  issues: judge:inaccurate:0.99
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Цей файл надає публічний інтерфейс для валідації коду, використовуючи інструменти Oxlint та ESLint. Він дозволяє визначати набір JavaScript-файлів для аналізу через функцію `filterJsFiles` та виконувати сам процес лінтингу за допомогою функції `lint`. Компонент є read-only, оскільки не здійснює змін до файлової системи чи баз даних. У разі виявлення помилок, механізм забезпечує fail-safe режим, перехоплюючи їх та не викликаючи винятків назовні.
+
+## Поведінка
+
+Поведінка:
+filterJsFiles фільтрує список вказаних файлів, залишаючи лише ті, що відповідають розширенням JavaScript.
+lint запускає лінтинг для файлів. Якщо передаються файли, він аналізує їх на наявність порушень; якщо не передані, він виконує повний аналіз проекту.
+
+## Публічний API
+
+filterJsFiles — відбирає файли для подальшої обробки.
+lint — проводить статичний аналіз коду (пофайлово або по всьому проєкту).
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).
+
+**warnIgnored: false.** ESLint конструюється з `warnIgnored: false` — файли з delta-списку, що матчать ignore-патерни `eslint.config.js` (наприклад, синковані `.pi/extensions/**` чи згенеровані `npm/types/**`), не рахуються порушеннями.
+
+**Worktree-чекаути ігноруються.** Обидва інструменти виключають `.worktrees/**` і `.claude/worktrees/**` (копії репо від сесійних git-worktree, яких споживацький конфіг зазвичай не виключає): ESLint — через global ignores у `overrideConfig`, oxlint — через `--ignore-pattern`. Діє і у full-режимі, і для явно переданих файлів.

package/rules/js/eslint/fix-eslint.mjs

@@ -0,0 +1,160 @@
+/** @see ./docs/fix-eslint.md */
+
+/**
+ * T0-autofix для `js/eslint` — детермінований прогін лінтерів у fix-режимі
+ * (`oxlint --fix` + `eslint --fix`) на файлах, де детектор знайшов порушення.
+ * Виправляє лише авто-fixable правила; решта лишається детектору на re-check
+ * (далі — LLM-ладдер). Запис permanent (поза rollback).
+ *
+ * Межа CI: цей модуль — частина fix-фази (`lint` без `--no-fix`); сам по собі
+ * detector-шлях його не вантажить. У CI (`--no-fix`) fix не запускається —
+ * узгоджено із забороною `oxlint --fix`/`eslint --fix` у CI (js.mdc / lint_js_yml).
+ */
+import { spawnSync } from 'node:child_process'
+import { readFileSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import { ESLint } from 'eslint'
+
+import { filterJsFiles } from './main.mjs'
+
+/**
+ * Вміст файлу або null, якщо не читається (видалений/недоступний).
+ * @param {string} abs абсолютний шлях
+ * @returns {string|null} вміст або null
+ */
+function readOrNull(abs) {
+  try {
+    return readFileSync(abs, 'utf8')
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Прогін `oxlint --fix` + `eslint --fix` по списку js-файлів. Повертає абсолютні
+ * шляхи фактично змінених файлів (порівняння до/після).
+ * @param {string[]} jsFiles posix-relative js-файли
+ * @param {string} cwd корінь проєкту
+ * @returns {Promise<string[]>} абсолютні шляхи змінених файлів
+ */
+async function runLinterFix(jsFiles, cwd) {
+  const abs = jsFiles.map(f => resolve(cwd, f))
+  const before = new Map(abs.map(a => [a, readOrNull(a)]))
+
+  // oxlint --fix (CLI): авто-fixable oxc-правила.
+  spawnSync('bunx', ['oxlint', '--fix', ...jsFiles], { cwd, encoding: 'utf8' })
+
+  // eslint --fix (API): outputFixes пише виправлені файли на диск.
+  const eslint = new ESLint({ cwd, fix: true })
+  const results = await eslint.lintFiles(abs)
+  await ESLint.outputFixes(results)
+
+  /** @type {string[]} */
+  const touched = []
+  for (const a of abs) {
+    if (readOrNull(a) !== before.get(a)) touched.push(a)
+  }
+  return touched
+}
+
+/**
+ * Реєстр "механічних" правил `js/eslint`: `oxlint --fix`/`eslint --fix` (T0
+ * `js-eslint-autofix` вище) їх НЕ покриває (suggestion-only у власній реалізації
+ * інструментів — перевірено емпірично: лишаються порушеними після `--fix` на
+ * реальних прогонах), але текстуальна заміна на позначеному рядку однозначна й
+ * безпечна без повного AST-парсингу — проста заміна ідентифікатора/API-виклику.
+ * `reasons` — обидва формати `reason` з `main.mjs` (`f.rule`): eslint (`ruleId`,
+ * `"plugin/rule"`) і oxlint (`d.code`, `"plugin(rule)"`) — те саме правило різні
+ * тули віддають по-різному.
+ * @type {Array<{ reasons: string[], replace: (line: string) => string|null }>}
+ */
+const MECHANICAL_TEXT_FIXES = [
+  {
+    // Number.isInteger(x) не ловить x поза Number.MIN/MAX_SAFE_INTEGER — сама заміна
+    // імені методу семантично точна для рядка, що ЛИШЕ так і викликає isInteger.
+    reasons: ['unicorn/prefer-number-is-safe-integer', 'unicorn(prefer-number-is-safe-integer)'],
+    replace: line =>
+      line.includes('Number.isInteger') ? line.replaceAll('Number.isInteger', 'Number.isSafeInteger') : null
+  }
+]
+
+/**
+ * Знаходить механічний фікс для reason-у порушення (обидва формати tool-у).
+ * @param {string} reason `violation.reason`
+ * @returns {((line: string) => string|null)|null} replace-функція або null
+ */
+function mechanicalFixFor(reason) {
+  return MECHANICAL_TEXT_FIXES.find(f => f.reasons.includes(reason))?.replace ?? null
+}
+
+/**
+ * Застосовує механічні текстові заміни по конкретних рядках (`data.line`, 1-indexed)
+ * файлу. Рядок без збігу очікуваного шаблону (файл змінився з моменту detect-у) —
+ * пропускається, не гадаємо.
+ * @param {string} content вміст файлу
+ * @param {Array<{ line: number, replace: (line: string) => string|null }>} targets рядки й replace-функції
+ * @returns {string|null} новий вміст або null, якщо жоден рядок не змінився
+ */
+function applyMechanicalLineFixes(content, targets) {
+  const lines = content.split('\n')
+  let changed = false
+  for (const { line, replace } of targets) {
+    const idx = line - 1
+    if (idx < 0 || idx >= lines.length) continue
+    const next = replace(lines[idx])
+    if (next !== null && next !== lines[idx]) {
+      lines[idx] = next
+      changed = true
+    }
+  }
+  return changed ? lines.join('\n') : null
+}
+
+/** @type {import('@7n/rules/scripts/lib/lint-surface/types.mjs').T0Pattern[]} */
+export const patterns = [
+  {
+    id: 'js-eslint-autofix',
+    test: violations => violations.some(v => v.file),
+    apply: async (violations, ctx) => {
+      const files = [...new Set(violations.map(v => v.file).filter(Boolean))]
+      const jsFiles = filterJsFiles(files)
+      if (jsFiles.length === 0) return { touchedFiles: [] }
+      const touchedFiles = await runLinterFix(jsFiles, ctx.cwd)
+      for (const a of touchedFiles) ctx.recordWrite?.(a)
+      return touchedFiles.length > 0
+        ? { touchedFiles, message: `oxlint/eslint --fix: ${touchedFiles.length} файл(ів)` }
+        : { touchedFiles: [] }
+    }
+  },
+  {
+    id: 'js-eslint-mechanical-text-fix',
+    test: violations => violations.some(v => v.file && v.data?.line && mechanicalFixFor(v.reason)),
+    apply: (violations, ctx) => {
+      /** @type {Map<string, Array<{ line: number, replace: (line: string) => string|null }>>} */
+      const byFile = new Map()
+      for (const v of violations) {
+        const replace = v.file && v.data?.line ? mechanicalFixFor(v.reason) : null
+        if (!replace) continue
+        const arr = byFile.get(v.file)
+        const target = { line: v.data.line, replace }
+        if (arr) arr.push(target)
+        else byFile.set(v.file, [target])
+      }
+      const touchedFiles = []
+      for (const [rel, targets] of byFile) {
+        const abs = resolve(ctx.cwd, rel)
+        const content = readOrNull(abs)
+        if (content === null) continue
+        const next = applyMechanicalLineFixes(content, targets)
+        if (next === null) continue
+        ctx.recordWrite?.(abs)
+        writeFileSync(abs, next)
+        touchedFiles.push(abs)
+      }
+      return touchedFiles.length > 0
+        ? { touchedFiles, message: `механічні текстові заміни: ${touchedFiles.length} файл(ів)` }
+        : { touchedFiles: [] }
+    }
+  }
+]

package/rules/js/eslint/fix-worker.mjs

@@ -0,0 +1,139 @@
+/**
+ * fix-worker для `js/eslint`: окрема агентна сесія НА ФАЙЛ замість одного великого промпту
+ * на всі файли concern-а одразу. Дефолтний worker (`default-worker.mjs`) шле ВСІ порушення
+ * з УСІХ файлів в один `runAgentFix`-виклик — на реальних lint-прогонах (tauri-components)
+ * це давало 100% timeout на всіх 4 rung-ах драбини (local-min→cloud-avg), навіть коли
+ * порушень було лише 20-90 у 1-3 файлах: одна сесія жонглює кількома файлами одразу і не
+ * встигає в rung-таймаут.
+ *
+ * Файли обробляються ПАРАЛЕЛЬНО (обмежений пул, `MAX_PARALLEL_FILES`), не послідовно —
+ * ADR docs/adr/260718-0754-js-eslint-fix-worker-per-session-overhead.md. Профайлінг
+ * реального прогону (2026-07-18, trace `runAgentFix`) спростував гіпотезу про фіксовані
+ * bootstrap-витрати сесії: `dispatch.test.js` (2 порушення) — 9 раундів моделі, 29.4с;
+ * тривіальний фікс так само вимагав багато tool-раундів, а не одноразової плати за bootstrap.
+ * Оскільки домінує саме кількість/довжина turn-раундів, а не старт сесії, паралелізм
+ * (кілька файлів одночасно замість черги) дає пряме пришвидшення незалежно від причини —
+ * секвенційна версія витрачала весь бюджет rung-а на 1 файл, лишаючи іншим 0 шансів
+ * навіть стартувати.
+ *
+ * Rollback-контракт незмінний: `recordWrite` (не durable) на кожен файл — правки наявного
+ * стороннього коду. Якщо після worker-а `runRung`-ів canonical re-detect (whole-concern)
+ * знайде хоч одне порушення будь-де, увесь rung однаково відкотиться (S1) — той самий
+ * контракт, що й у дефолтного worker-а; паралелізм підвищує ймовірність, що ЦЕЙ rung
+ * дійде до 0 порушень, а не замінює rollback-семантику. `snapshot.record`/`recordWrite` —
+ * синхронні Map-операції без `await` усередині, тож конкурентні виклики безпечні (Node
+ * event loop не перериває синхронний блок).
+ *
+ * Дедлайн (`DEADLINE_FRACTION` від `ctx.timeoutMs`, той самий підхід, що й
+ * `doc-files/check/fix-worker.mjs`) гейтить лише СТАРТ нового файлу з черги — не
+ * скасовує вже запущені. При files.length ≤ MAX_PARALLEL_FILES усі стартують майже
+ * одночасно й отримують практично весь бюджет незалежно один від одного (справжній
+ * паралелізм); при більшій кількості — черга природно звужує бюджет пізніших хвиль
+ * (`callTimeoutMs` рахується в момент старту, не наперед), не даючи перевищити
+ * backstop ×1.25 runner-а.
+ * @typedef {import('@7n/rules/scripts/lib/lint-surface/types.mjs').FixWorkerFn} FixWorkerFn
+ */
+import { resolve } from 'node:path'
+
+import { anchoredEnabled } from '@7n/rules/scripts/lib/lint-surface/default-worker.mjs'
+import { renderViolations } from '@7n/rules/scripts/lib/lint-surface/render.mjs'
+import { lint } from './main.mjs'
+
+/** Частка ctx.timeoutMs, після якої черга не стартує новий файл (запас до backstop ×1.25). */
+const DEADLINE_FRACTION = 0.8
+
+/** Максимум файлів, що обробляються одночасно (без необмеженого burst на великих concern-ах). */
+const MAX_PARALLEL_FILES = 4
+
+/**
+ * Item-scoped (один файл) canonical re-detect для evidence-гейта `runAgentFix` —
+ * НЕ те саме, що whole-concern `ctx.verify` з `runRung` (той перевірив би ВСІ файли
+ * concern-а й дав би хибний "не готово" навіть коли саме ЦЕЙ файл уже чистий).
+ * @param {string} cwd абсолютний корінь проєкту
+ * @param {string} ruleId id правила
+ * @param {string} concernId id concern-а
+ * @param {string} file posix-relative шлях файлу, що перевіряється
+ * @returns {Promise<{ ok: boolean, output: string }>} вердикт verify-петлі
+ */
+async function verifyFile(cwd, ruleId, concernId, file) {
+  const { violations: after } = await lint({ cwd, ruleId, concernId, files: [file] })
+  const stamped = after.map(v => ({ ...v, ruleId, concernId }))
+  return { ok: stamped.length === 0, output: renderViolations(stamped) }
+}
+
+/**
+ * Обробляє `items` обмеженим пулом воркерів (не більше `MAX_PARALLEL_FILES` одночасно) —
+ * власна черга замість `Promise.all(items.map(...))`, щоб великий concern не відкрив
+ * необмежену кількість конкурентних агентних сесій одразу.
+ * @param {string[]} items елементи черги (шляхи файлів)
+ * @param {(item: string) => Promise<void>} worker обробник одного елемента; винятки ловить сам
+ * @returns {Promise<void>}
+ */
+async function runPooled(items, worker) {
+  const queue = [...items]
+  const runnerCount = Math.min(MAX_PARALLEL_FILES, items.length)
+  await Promise.all(
+    Array.from({ length: runnerCount }, async () => {
+      let item
+      while ((item = queue.shift())) {
+        await worker(item)
+      }
+    })
+  )
+}
+
+/** @type {FixWorkerFn} */
+export async function fixWorker(violations, ctx) {
+  // lazy import — тримає detect-шлях вільним від pi/oxc (read-only --no-fix не вантажить їх).
+  const [{ runAgentFix }, { isLocalModel }, { extractContext }] = await Promise.all([
+    import('@7n/llm-lib/agent-fix'),
+    import('@7n/llm-lib/model-tiers'),
+    import('@7n/rules/scripts/utils/ast-extract.mjs')
+  ])
+
+  /** @type {Map<string, import('@7n/rules/scripts/lib/lint-surface/types.mjs').LintViolation[]>} */
+  const byFile = new Map()
+  for (const v of violations) {
+    if (!v.file) continue
+    const arr = byFile.get(v.file)
+    if (arr) arr.push(v)
+    else byFile.set(v.file, [v])
+  }
+  const files = byFile.keys().toArray()
+  if (files.length === 0) return { touchedFiles: [] }
+
+  const deadlineAt = ctx.timeoutMs ? Date.now() + Math.round(ctx.timeoutMs * DEADLINE_FRACTION) : null
+  const anchoredEdits = anchoredEnabled(ctx.model, isLocalModel)
+
+  const touchedFiles = []
+  await runPooled(files, async file => {
+    if (deadlineAt && Date.now() >= deadlineAt) return
+    const callTimeoutMs = deadlineAt ? Math.max(1000, deadlineAt - Date.now()) : ctx.timeoutMs
+
+    let res
+    try {
+      res = await runAgentFix(ctx.ruleId, renderViolations(byFile.get(file)), ctx.cwd, {
+        model: ctx.model,
+        tier: ctx.tier,
+        timeoutMs: callTimeoutMs,
+        feedback: ctx.feedback ?? null,
+        caller: `fix:${ctx.ruleId}/${ctx.concernId}:${ctx.tier}:${file}`,
+        recordWrite: ctx.recordWrite,
+        chain: ctx.chain ?? null,
+        targetFiles: [file],
+        verify: () => verifyFile(ctx.cwd, ctx.ruleId, ctx.concernId, file),
+        verifyMax: ctx.verifyMax,
+        anchoredEdits,
+        deps: { astContext: p => extractContext(resolve(ctx.cwd, p)) }
+      })
+    } catch {
+      // Один файл впав винятком — не валимо решту паралельних воркерів у пулі; whole-concern
+      // canonical re-detect runner-а (не цей worker) визначить, чи rung закрито.
+      return
+    }
+
+    if (!res.error) touchedFiles.push(...(res.touchedFiles ?? []))
+  })
+
+  return { touchedFiles }
+}