@7n/rules 1.0.0

package/rules/test/vitest-config-pool-forks/vitest-config-pool-forks.mdc

@@ -0,0 +1,34 @@
+## Vitest: `pool: 'forks'` як захист від race у `process.cwd()`
+
+**`vitest-config-pool-forks`** (`rules/test/js/vitest-config-pool-forks.mjs`) — substring-перевірка `pool: 'forks'` у `vitest.config.mjs` (або legacy `vitest.config.js`; `.mjs` пріоритетніший).
+
+**Чому:** Defense-in-depth проти race у `process.cwd()` між паралельними test файлами. Навіть якщо хтось пропустить заборону `process.chdir`, fork-ізоляція не дасть race у production tree — кожен test-файл отримує власний процес зі своїм `cwd`.
+
+Якщо `vitest.config.mjs` / `vitest.config.js` відсутній — перевірка пропускається (pass без помилки).
+
+**Canonical `vitest.config.mjs`** (для довідки — `pool: 'forks'` + `include` + `coverage`) — у `rules/test/js/data/vitest_config/vitest.config.baseline.js`:
+
+- `environment: 'node'`
+- `coverage.provider: 'v8'` з lcov+text-summary репортами
+- `include: ['**/*.test.{js,mjs}', 'tests/**/*.test.{js,mjs}']` — підхоплює тести у `tests/`-піддиректоріях і top-level integration suites у `<root>/tests/`
+
+У `package.json#scripts` має бути `"test": "bun run --bun vitest run"` (substring `vitest` + `--bun`; допустимі локальні розширення-обгортки) та опційно `"test:watch": "vitest"`.
+
+**Frontend-варіант (Vue/Vite + happy-dom):**
+
+Для проєктів зі своїм `vite.config.js` `vitest.config.mjs` має повторно використовувати vite-плагіни та aliases і перемкнути `environment` на `'happy-dom'` (або `'jsdom'`):
+
+```js
+import { defineConfig, mergeConfig } from 'vitest/config'
+import viteConfig from './vite.config.js'
+
+export default mergeConfig(viteConfig, defineConfig({
+  test: {
+    include: ['**/*.test.{js,mjs}', 'tests/**/*.test.{js,mjs}'],
+    environment: 'happy-dom',
+    coverage: { provider: 'v8', reporter: ['lcov', 'text-summary'] }
+  }
+}))
+```
+
+Концерн ставить node-варіант baseline; перехід на frontend — ручна модифікація, після якої концерн уже не перетирає (idempotent).

package/rules/text/cspell/concern.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "fixability": "config",
+  "policy": {
+    "files": {
+      "single": ".cspell.json"
+    }
+  }
+}

package/rules/text/cspell/cspell.mdc

@@ -0,0 +1,41 @@
+## Перевірка `.cspell.json` — структура та canonical import
+
+Rego-пакет: `text.cspell`
+
+Цільовий файл: `.cspell.json`
+
+**Що перевіряється:**
+
+- `version` — має відповідати канону (наразі `"0.2"`)
+- `useGitignore` — має бути `true`: cspell поважає всі `.gitignore` репо, тож білд-артефакти (`target/`, `dist/` тощо) не потрапляють у прогін і не потребують дублювання в `ignorePaths`
+- `gitignoreRoot` — має бути `"."`: обмежує збір `.gitignore` коренем репо. Без цього cspell підіймається каталогами вище і в git-worktree застосовує `.gitignore` основного дерева (патерн на кшталт `.claude/worktrees/` матчить усе) → «Files checked: 0», делта-лінт мовчки зелений при червоному CI
+- `language` — поле обов'язкове (presence-only, значення довільне, наприклад `"en,uk"`)
+- `ignorePaths` — масив має бути надмножиною канонічних glob-ів, включно з `docs/adr/**`
+- `import` — має містити підрядок `@nitra/cspell-dict`; заборонені будь-які записи з підрядком `@cspell/dict-` (використовуй лише `@nitra/cspell-dict`)
+
+**Приклади:**
+
+✓ правильно:
+
+```json
+{
+  "version": "0.2",
+  "language": "en,uk",
+  "useGitignore": true,
+  "gitignoreRoot": ".",
+  "import": ["@nitra/cspell-dict/cspell-ext.json"],
+  "ignorePaths": ["**/node_modules/**", "**/.git/**", "docs/adr/**"]
+}
+```
+
+✗ неправильно:
+
+```json
+{
+  "version": "0.1",
+  "import": ["@cspell/dict-de"],
+  "ignorePaths": []
+}
+```
+
+(відсутнє `language`, застарілий `version`, заборонений `@cspell/dict-`, не всі canonical `ignorePaths`)

package/rules/text/cspell/cspell.rego

@@ -0,0 +1,71 @@
+# Перевірка `.cspell.json` (text.mdc).
+#
+# Канон надходить через --data: { "template": { "snippet": ..., "contains": ..., "deny": ... } }
+# Структура --data сформована з template/.cspell.json.{snippet,contains,deny}.json.
+#
+# Логіка, що ЛИШАЄТЬСЯ у rego (inverse — не виноситься у template):
+#  - `language` має бути присутнє (presence-only).
+package text.cspell
+
+import rego.v1
+
+# ── deny: top-level snippet leafs (version etc) ──────────────────────────
+
+deny contains msg if {
+	some key, expected_value in data.template.snippet
+	not is_array(expected_value)
+	not is_object(expected_value)
+	actual := object.get(input, key, null)
+	actual != expected_value
+	msg := sprintf(".cspell.json: %s має бути %v (text.mdc)", [key, expected_value])
+}
+
+# ── deny: ignorePaths subset-of ──────────────────────────────────────────
+
+deny contains msg if {
+	some field, expected_values in data.template.snippet
+	is_array(expected_values)
+	is_array(object.get(input, field, null))
+	actual_set := {v | some v in input[field]}
+	some required in expected_values
+	not required in actual_set
+	msg := sprintf(".cspell.json %s: додай %q (text.mdc)", [field, required])
+}
+
+# ── deny: language presence (inverse, in rego) ───────────────────────────
+
+deny contains msg if {
+	not object.get(input, "language", false)
+	msg := ".cspell.json: відсутнє поле language (text.mdc)"
+}
+
+# ── deny: import substrings required (contains) ─────────────────────────
+
+deny contains msg if {
+	some field, needles in data.template.contains
+	imports := object.get(input, field, [])
+	is_array(imports)
+	some needle in needles
+	not has_substring_in_array(imports, needle)
+	msg := sprintf(".cspell.json: %s має містити %q (text.mdc)", [field, needle])
+}
+
+# ── deny: import substrings forbidden ────────────────────────────────────
+
+deny contains msg if {
+	imports := object.get(input, "import", [])
+	is_array(imports)
+	some forbidden, reason in data.template.deny["import-substrings"]
+	some imp in imports
+	is_string(imp)
+	contains(imp, forbidden)
+	msg := sprintf(".cspell.json import містить заборонений %q — %s", [imp, reason])
+}
+
+# ── helpers ──────────────────────────────────────────────────────────────
+
+has_substring_in_array(arr, needle) if {
+	some item in arr
+	is_string(item)
+	contains(item, needle)
+}

package/rules/text/cspell/docs/fix-cspell.md

@@ -0,0 +1,36 @@
+---
+type: JS Module
+title: fix-cspell.mjs
+resource: npm/rules/text/cspell/fix-cspell.mjs
+docgen:
+  crc: 554ef39d
+  model: manual
+  tier: local-min
+---
+
+## Огляд
+
+T0-autofix для policy-concern-а `text/cspell`: приводить `.cspell.json` до канону **merge-записом**, а не wholesale-перезаписом. Причина — інцидент у consumer-репо (nitra/task), де скаффолд-перезапис зніс локальний масив `words` і repo-специфічні `ignorePaths` (`target/**`, `src-tauri/gen/**`). Канон читається з template концерну (`template/.cspell.json.snippet.json`, `template/.cspell.json.contains.json`), не з тексту violation.
+
+## Поведінка
+
+- Патерн `cspell-merge` застосовується, коли серед violations концерну є `policy-file-missing` або `policy-deny`.
+- Відсутній `.cspell.json` → створюється зі snippet-канону, `import`-потреб із contains і дефолтним `language: "en,uk"`.
+- Наявний `.cspell.json` → merge:
+  - масиви зі snippet (`ignorePaths`) — union: існуючі елементи лишаються попереду, відсутні канонічні дописуються в кінець;
+  - скаляри зі snippet (`version`) — виставляються в канонічне значення;
+  - contains (`import`) — якщо жоден існуючий запис не містить потрібного підрядка (`@nitra/cspell-dict`), підрядок дописується окремим елементом;
+  - `language` — presence-only: дефолт додається лише коли поля немає, кастомне значення не перезаписується.
+- Без змін (уже канонічний конфіг) → файл не записується взагалі (`touchedFiles: []`) — ідемпотентність байт-у-байт.
+- Запис — `JSON.stringify(cfg, null, 2)` + завершальний `\n`; перед записом викликається `ctx.recordWrite`.
+
+## Гарантії поведінки
+
+- Існуючі `words`, `flagWords`, `ignorePaths` і будь-які інші поля конфігу **ніколи не видаляються і не перезаписуються** — канонічне лише додається.
+- Заборонені import-и (`@cspell/dict-*`) не вирізаються автоматично — їх видалення лишається ручним рішенням.
+- Невалідний JSON у `.cspell.json` → файл не чіпається, патерн повертає `{ touchedFiles: [] }` (без винятків назовні).
+- Відсутні/невалідні template-файли канону → патерн no-op.
+
+## Де використовується
+
+Central fix-pipeline (`scripts/lib/lint-surface/run-fix.mjs`) підхоплює `patterns` з `fix-cspell.mjs` як T0 концерну `text/cspell`; оскільки концерн має `fixability: "config"`, LLM-ladder для нього не запускається — цей детермінований merge є єдиним авто-фіксом.

package/rules/text/cspell/docs/index.md

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

package/rules/text/cspell/fix-cspell.mjs

@@ -0,0 +1,115 @@
+/**
+ * T0-autofix для policy-concern-а `text/cspell`: merge-запис `.cspell.json` замість
+ * wholesale-перезапису (інцидент nitra/task: скаффолд-перезапис зніс локальні `words`
+ * і repo-специфічні `ignorePaths` на кшталт `target/**`).
+ *
+ * Канон читається з template концерну (ctx.concernDir), не з тексту violation:
+ * snippet (`version`, `ignorePaths`) + contains (`import`-підрядки). Гарантії merge:
+ * існуючі `words`/`flagWords`/`ignorePaths` і будь-які інші поля ЗБЕРІГАЮТЬСЯ,
+ * канонічне лише ДОДАЄТЬСЯ — нічого не видаляється мовчки. Заборонені import-и
+ * (`@cspell/dict-*`) НЕ вирізаються автоматично: видалення — ручне рішення.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+/**
+ * Читає JSON-файл template-а; відсутній або невалідний → null.
+ * @param {string} path абсолютний шлях
+ * @returns {object|null} розпарсений об'єкт або null
+ */
+function readTemplateJson(path) {
+  if (!existsSync(path)) return null
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Merge канону snippet-а у конфіг: масиви — union (існуючі елементи попереду, без
+ * видалень), скаляри — канонічне значення (напр. `version`), об'єкти — не чіпаємо
+ * (rego їх не перевіряє). Мутує `cfg`.
+ * @param {Record<string, unknown>} cfg поточний `.cspell.json`
+ * @param {Record<string, unknown>} snippet канон з `.cspell.json.snippet.json`
+ * @returns {string[]} людиночитані описи внесених змін (порожньо — без змін)
+ */
+function mergeSnippet(cfg, snippet) {
+  const changes = []
+  for (const [key, canonical] of Object.entries(snippet)) {
+    if (Array.isArray(canonical)) {
+      const existing = Array.isArray(cfg[key]) ? cfg[key] : []
+      const toAdd = canonical.filter(v => !existing.includes(v))
+      if (toAdd.length === 0) continue
+      cfg[key] = [...existing, ...toAdd]
+      changes.push(`${key}: +${toAdd.length}`)
+    } else if (typeof canonical !== 'object' && cfg[key] !== canonical) {
+      cfg[key] = canonical
+      changes.push(`${key}=${String(canonical)}`)
+    }
+  }
+  return changes
+}
+
+/**
+ * Merge contains-канону: для кожного `field` кожен needle-підрядок має зустрічатись
+ * у масиві — інакше дописуємо needle як окремий елемент (існуючі записи не чіпаємо).
+ * Мутує `cfg`.
+ * @param {Record<string, unknown>} cfg поточний `.cspell.json`
+ * @param {Record<string, string[]>} contains канон з `.cspell.json.contains.json`
+ * @returns {string[]} описи внесених змін
+ */
+function mergeContains(cfg, contains) {
+  const changes = []
+  for (const [field, needles] of Object.entries(contains)) {
+    const arr = Array.isArray(cfg[field]) ? cfg[field] : []
+    const missing = needles.filter(n => arr.every(item => !(typeof item === 'string' && item.includes(n))))
+    if (missing.length === 0) continue
+    cfg[field] = [...arr, ...missing]
+    changes.push(`${field}: +${missing.join(', ')}`)
+  }
+  return changes
+}
+
+/** @type {import('../../../scripts/lib/lint-surface/types.mjs').T0Pattern[]} */
+export const patterns = [
+  {
+    id: 'cspell-merge',
+    test: violations => violations.some(v => v.reason === 'policy-file-missing' || v.reason === 'policy-deny'),
+    apply: (violations, ctx) => {
+      if (!ctx.concernDir) return { touchedFiles: [] }
+      const snippet = readTemplateJson(join(ctx.concernDir, 'template', '.cspell.json.snippet.json'))
+      const contains = readTemplateJson(join(ctx.concernDir, 'template', '.cspell.json.contains.json'))
+      if (!snippet && !contains) return { touchedFiles: [] }
+
+      const cfgPath = join(ctx.cwd, '.cspell.json')
+      const created = !existsSync(cfgPath)
+      /** @type {Record<string, unknown>} */
+      let cfg = {}
+      if (!created) {
+        try {
+          cfg = JSON.parse(readFileSync(cfgPath, 'utf8'))
+        } catch {
+          return { touchedFiles: [] } // невалідний JSON — не чіпаємо детермінованим фіксом
+        }
+      }
+
+      const changes = [...mergeSnippet(cfg, snippet ?? {}), ...mergeContains(cfg, contains ?? {})]
+      // `language` — presence-only канон (rego, inverse): додаємо дефолт лише коли поля немає.
+      if (!cfg.language) {
+        cfg.language = 'en,uk'
+        changes.push('language=en,uk')
+      }
+      if (changes.length === 0 && !created) return { touchedFiles: [] }
+
+      ctx.recordWrite?.(cfgPath)
+      writeFileSync(cfgPath, `${JSON.stringify(cfg, null, 2)}\n`)
+      return {
+        touchedFiles: [cfgPath],
+        message: created
+          ? `.cspell.json створено зі snippet (${changes.join('; ')})`
+          : `.cspell.json merge: ${changes.join('; ')}`
+      }
+    }
+  }
+]

package/rules/text/cspell/template/.cspell.json.contains.json

@@ -0,0 +1,3 @@
+{
+  "import": ["@nitra/cspell-dict"]
+}

package/rules/text/cspell/template/.cspell.json.deny.json

@@ -0,0 +1,5 @@
+{
+  "import-substrings": {
+    "@cspell/dict-": "використовуй лише @nitra/cspell-dict (text.mdc)"
+  }
+}

package/rules/text/cspell/template/.cspell.json.snippet.json

@@ -0,0 +1,15 @@
+{
+  "version": "0.2",
+  "useGitignore": true,
+  "gitignoreRoot": ".",
+  "ignorePaths": [
+    "**/node_modules/**",
+    "**/vscode-extension/**",
+    "**/.git/**",
+    ".vscode",
+    "report",
+    "*.svg",
+    "**/k8s/**/*.yaml",
+    "docs/adr/**"
+  ]
+}

package/rules/text/cspell-fix/concern.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "lint": {
+    "scope": "per-file",
+    "glob": ["**/*"]
+  }
+}

package/rules/text/cspell-fix/docs/fix-worker.md

@@ -0,0 +1,38 @@
+---
+type: JS Module
+title: fix-worker.mjs
+resource: npm/rules/text/cspell-fix/fix-worker.mjs
+docgen:
+  crc: 59f849d4
+  model: openai-codex/gpt-5.5
+---
+
+## Огляд
+
+`text/cspell-fix` обробляє знахідки cspell з “Unknown word”, класифікує їх через `omlx` у bounded JSON і дописує валідні доменні слова до `.cspell.json#words`, щоб наступна перевірка не вважала їх помилками.
+
+Імовірні одруки не застосовуються автоматично, бо безпечність такого виправлення не гарантована. Успішність lint-процесу визначає повторна canonical-перевірка після worker-а, а не сам worker.
+
+Класифікація використовує `N_LOCAL_MIN_MODEL`; tier-aware routing і cloud-tier fallback у цьому кроці не виконуються.
+
+Конфіги, на які спирається код: .cspell.json
+
+## Поведінка
+
+1. `fixWorker` запускає виправлення для проблем орфографічного словника, коли доступна модель класифікації та інструмент перевірки тексту.
+
+2. Якщо перевірка не знаходить невідомих слів, `fixWorker` завершується без змін.
+
+3. Знайдені невідомі слова передаються на bounded-класифікацію, щоб відокремити валідні доменні слова від імовірних одруків.
+
+4. Валідні слова додаються до словника проєкту в `.cspell.json`, щоб наступні перевірки не підсвічували їх як помилки.
+
+5. Імовірні одруки не виправляються автоматично, бо безпечне застосування таких змін потребує людського рішення.
+
+6. `fixWorker` не визначає успішність усього lint-процесу: остаточний результат має підтвердити повторна canonical-перевірка після виконання worker-а.
+
+7. `fixWorker` повертає перелік змінених файлів і коротку телеметрію про класифікацію, додані слова, одруки та обрізання великого набору знахідок.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).

package/rules/text/cspell-fix/docs/index.md

@@ -0,0 +1,12 @@
+---
+type: Directory Index
+title: npm/rules/text/cspell-fix
+resource: npm/rules/text/cspell-fix/
+---
+
+# npm/rules/text/cspell-fix
+
+| Файл                            | Тип       |
+| ------------------------------- | --------- |
+| [fix-worker.mjs](fix-worker.md) | JS Module |
+| [main.mjs](main.md)             | JS Module |

package/rules/text/cspell-fix/docs/main.md

@@ -0,0 +1,32 @@
+---
+type: JS Module
+title: main.mjs
+resource: npm/rules/text/cspell-fix/main.mjs
+docgen:
+  crc: 22853b73
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+---
+
+## Огляд
+
+Реалізує інтеграцію `cspell` у текстовий лінт за схемою класифікації (`docs/specs/2026-06-15-opportunistic-llm-fix-tier.md`): замість переписування файлів невідомі слова класифікуються LLM-ом, валідні терміни дописуються у словник `.cspell.json`, ймовірні одруки лишаються на ручний перегляд. Цей модуль — read-only детект і shared-хелпери класифікації; сама LLM-класифікація виконується у `fix-worker.mjs` (Central Runner Pipeline).
+
+## Поведінка
+
+`detectCspell` запускає `cspell` над переданими файлами (або всім репо) і повертає код виходу разом із виводом. Якщо cspell перевірив **нуль файлів** (усі цілі підпадають під `ignorePaths` з `.cspell.json`, напр. `docs/specs/**`) — це трактується як чисто (`code: 0`), а не як порушення: інакше файли поза скоупом cspell хибно блокували б PostToolUse hook.
+
+`unknownWords` видобуває унікальні невідомі слова з виводу `cspell`. `runCspellText` виконує read-only детект: чисто → `0`; інакше друкує вивід cspell і повертає його код. Коли delta явно передала файли, а cspell перевірив нуль із них, у stderr друкується попередження (без фейлу): та сама сигнатура буває і легітимною (усі файли під `ignorePaths`), і симптомом зламаного скоупу — напр., у git-worktree без `gitignoreRoot` у `.cspell.json` cspell застосовував `.gitignore` основного репо і мовчки ігнорував усе. `lint` загортає це у `LintResult` (порожній delta-перелік файлів → одразу чисто).
+
+## Публічний API
+
+- `detectCspell` — запускає `cspell` над файлами/репо, нормалізує «нуль файлів перевірено» в успіх.
+- `unknownWords` — унікальні невідомі слова з виводу `cspell`.
+- `appendWordsToDict` — дописує нові слова до `.cspell.json#words` (sorted/dedup), повертає кількість доданих.
+- `classifyPrompt` / `parseClassify` — формує LLM-промпт класифікації і парсить bounded JSON-відповідь (використовуються `fix-worker.mjs`).
+- `runCspellText` — read-only детект: cspell по delta-файлах або всьому репо.
+- `lint` — read-only detector для delta/full lint-прогону.
+
+## Гарантії поведінки
+
+- Модуль не мутує нічого: запис у `.cspell.json` виконує лише `fix-worker.mjs` через `appendWordsToDict`.
+- Файли поза скоупом `cspell` (ignorePaths) ніколи не трактуються як порушення.

package/rules/text/cspell-fix/fix-worker.mjs

@@ -0,0 +1,73 @@
+/**
+ * fix-worker для `text/cspell-fix` (spec docs/specs/2026-06-29-unified-lint-surface.md §"fix-worker.mjs"):
+ * cspell не має нативного `--fix`, класифікує "Unknown word" знахідки через omlx (bounded JSON) і
+ * дописує валідні слова у `.cspell.json#words` — та сама логіка, що раніше жила inline в
+ * `runCspellText`/`text/check`. Одруки НЕ виправляються авто (апплай небезпечний).
+ *
+ * Контракт: worker не знає tier ladder і не вирішує success — це робить canonical `lint()` re-check
+ * після worker-а (Central Runner Pipeline). Поточна реалізація використовує єдину локальну модель
+ * (`N_LOCAL_MIN_MODEL`) незалежно від `ctx.tier`/`ctx.model` — повноцінна tier-aware маршрутизація
+ * (cloud-tier fallback для класифікації) лишається за межами цього кроку (§8 Phase 2 у спеці).
+ */
+import { join } from 'node:path'
+
+import { resolveCmd } from '../../../scripts/utils/resolve-cmd.mjs'
+import { runOneShot } from '@7n/llm-lib/one-shot'
+import {
+  MAX_CLASSIFY_WORDS,
+  appendWordsToDict,
+  classifyPrompt,
+  detectCspell,
+  fixModel,
+  parseClassify,
+  unknownWords
+} from './main.mjs'
+
+/**
+ * @typedef {import('../../../scripts/lib/lint-surface/types.mjs').LintViolation} LintViolation
+ * @typedef {import('../../../scripts/lib/lint-surface/types.mjs').FixContext} FixContext
+ */
+
+/**
+ * @param {LintViolation[]} violations concern-scoped violations (лише `text/cspell-fix`).
+ * @param {FixContext} ctx контекст одного fix-attempt-у.
+ * @returns {Promise<{ touchedFiles: string[], telemetry?: object }>} torched files (`.cspell.json`, якщо дописано слова) + телеметрія.
+ */
+export async function fixWorker(violations, ctx) {
+  const model = ctx.model || fixModel()
+  if (!model) return { touchedFiles: [] }
+
+  const bin = resolveCmd('npx')
+  if (!bin) return { touchedFiles: [] }
+
+  const first = detectCspell(ctx.cwd, bin, ctx.files)
+  if (first.code === 0) return { touchedFiles: [] }
+
+  const words = unknownWords(first.out)
+  const batch = words.slice(0, MAX_CLASSIFY_WORDS)
+  if (batch.length === 0) return { touchedFiles: [] }
+
+  const res = await runOneShot({
+    messages: [{ role: 'user', content: classifyPrompt(batch) }],
+    modelSpec: model,
+    caller: 'cspell-classify',
+    cwd: ctx.cwd,
+    signal: ctx.signal
+  })
+  if (res.error) return { touchedFiles: [] }
+
+  const parsed = parseClassify(res.content)
+  if (!parsed) return { touchedFiles: [] }
+
+  const valid = parsed.filter(x => x.verdict === 'valid' && typeof x.w === 'string').map(x => x.w)
+  const typos = parsed.filter(x => x.verdict === 'typo' && typeof x.w === 'string')
+  const added = appendWordsToDict(ctx.cwd, valid)
+
+  const touchedFiles = added > 0 ? [join(ctx.cwd, '.cspell.json')] : []
+  for (const a of touchedFiles) ctx.recordWrite?.(a)
+
+  return {
+    touchedFiles,
+    telemetry: { classified: batch.length, added, typos: typos.length, truncated: words.length > batch.length }
+  }
+}