@7n/rules 1.9.0 → 1.11.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [1.11.0] - 2026-07-17
+
+### Added
+
+- js/eslint: fix-worker.mjs з per-file циклом замість одного великого промпту на весь concern — усунення 100% timeout на драбині, виміряно на реальних lint-прогонах
+
+### Fixed
+
+- text/markdownlint: включати причину провалу markdownlint-cli2 у violation-повідомлення; js/knip: fixability=structural (LLM-ладдер завжди приречений на timeout)
+
+## [1.10.0] - 2026-07-17
+
+### Added
+
+- `skill pi/cursor/codex taze` — Rust-гілку (`Cargo.toml`) тепер теж покриває оркестратор: детермінований `collectCargoDiff` (`npm/skills/taze/js/cargo-diff.mjs`, парсинг через `smol-toml`, той самий caret-семантики принцип, що й для npm) замість ручної класифікації, і по одному ізольованому виклику раннера на кожен major-крейт. Якщо `cargo-edit` не встановлено — Rust-гілка пропускається без блокування npm-гілки (перелік Cargo.toml лишається в звіті)
+
 ## [1.9.0] - 2026-07-17
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/rules",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "CLI еталонних правил і skills (префікс n-): синк у репозиторій, дельта-lint, конформність",
   "keywords": [
     "cli",

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

@@ -0,0 +1,30 @@
+---
+type: JS Module
+title: fix-worker.mjs
+resource: npm/rules/js/eslint/fix-worker.mjs
+docgen:
+  crc: 1eb9c7fc
+  model: manual
+---
+
+## Огляд
+
+Custom fix-worker `js/eslint` (перекриває дефолтний `default-worker.mjs`): замість одного `runAgentFix`-виклику з усіма порушеннями з усіх файлів concern-а — окрема агентна сесія на кожен файл, у межах спільного дедлайну rung-а. Мотивація — виміряно на реальних lint-прогонах: одна сесія, що жонглює кількома файлами одразу, стабільно впирається у timeout на всіх 4 rung-ах драбини (local-min→cloud-avg), навіть при малому обсязі порушень; та сама модель, scoped на один файл, укладається в бюджет і закриває більшість порушень.
+
+## Поведінка
+
+1. Групує вхідні `violations` за `file`; порушення без `file` ігноруються.
+2. Дедлайн — `DEADLINE_FRACTION` (0.8) від `ctx.timeoutMs`; цикл перевіряє дедлайн ПЕРЕД стартом кожного файлу і не починає новий, якщо час вичерпано.
+3. Кожен файл отримує РЕШТУ бюджету до дедлайну (не фіксований поділ `timeoutMs / files.length`) — перший (часто найважчий) файл отримує найбільше часу.
+4. На кожен файл — окремий `runAgentFix` із `targetFiles: [file]` і власним `verify` (`verifyFile`): item-scoped canonical re-detect лише цього файлу, не всього concern-а — інакше evidence-гейт хибно вважав би файл незакритим через порушення в ІНШИХ файлах.
+5. Один файл, що завершився з `error`, не обриває цикл — пропускається, наступні файли все одно обробляються в межах дедлайну.
+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-а, включно з уже полагодженими файлами.

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

@@ -0,0 +1,11 @@
+---
+type: Directory Index
+title: npm/rules/js/eslint
+resource: npm/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/fix-worker.mjs

@@ -0,0 +1,99 @@
+/**
+ * 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-таймаут. Виміряно (2026-07-17, ручний timing-експеримент поза pipeline):
+ * одна сесія, scoped на ОДИН найважчий файл (21 порушення), закрила 76% (16/21) за 91с із
+ * бюджету 120с (cloud-min) — per-file scoping вкладається, mega-prompt — ні.
+ *
+ * Rollback-контракт незмінний: `recordWrite` (не durable) на кожен файл — правки наявного
+ * стороннього коду. Якщо після worker-а `runRung`-ів canonical re-detect (whole-concern)
+ * знайде хоч одне порушення будь-де, увесь rung однаково відкотиться (S1) — той самий
+ * контракт, що й у дефолтного worker-а; батчинг підвищує ймовірність, що ЦЕЙ rung дійде
+ * до 0 порушень, а не замінює rollback-семантику.
+ *
+ * Дедлайн (`DEADLINE_FRACTION` від `ctx.timeoutMs`, той самий підхід, що й
+ * `doc-files/check/fix-worker.mjs`): цикл не стартує наступний файл, якщо дедлайн
+ * настав — worker повертає часткову роботу штатно, замість фонової сесії, що триває
+ * поверх backstop ×1.25 runner-а. Кожен файл отримує РЕШТУ бюджету до дедлайну (не
+ * фіксований `timeoutMs / files.length`) — перший (часто найважчий) файл отримує
+ * найбільше часу, а не штучно урізаний рівний шматок.
+ * @typedef {import('../../../scripts/lib/lint-surface/types.mjs').FixWorkerFn} FixWorkerFn
+ */
+import { resolve } from 'node:path'
+
+import { anchoredEnabled } from '../../../scripts/lib/lint-surface/default-worker.mjs'
+import { renderViolations } from '../../../scripts/lib/lint-surface/render.mjs'
+import { lint } from './main.mjs'
+
+/** Частка ctx.timeoutMs, після якої цикл не стартує наступний файл (запас до backstop ×1.25). */
+const DEADLINE_FRACTION = 0.8
+
+/**
+ * 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) }
+}
+
+/** @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('../../../scripts/utils/ast-extract.mjs')
+  ])
+
+  /** @type {Map<string, import('../../../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 = []
+  for (const file of files) {
+    if (deadlineAt && Date.now() >= deadlineAt) break
+    const callTimeoutMs = deadlineAt ? Math.max(1000, deadlineAt - Date.now()) : ctx.timeoutMs
+
+    const 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)) }
+    })
+
+    // Один файл не впорався — не кидаємо, пробуємо решту в межах дедлайну; whole-concern
+    // canonical re-detect runner-а (не цей worker) визначить, чи rung закрито.
+    if (!res.error) touchedFiles.push(...(res.touchedFiles ?? []))
+  }
+
+  return { touchedFiles }
+}

package/rules/js/knip/concern.json

@@ -1,5 +1,6 @@
 {
   "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "fixability": "structural",
   "lint": {
     "scope": "full"
   }

package/rules/text/markdownlint/docs/main.md

@@ -3,38 +3,27 @@ type: JS Module
 title: main.mjs
 resource: npm/rules/text/markdownlint/main.mjs
 docgen:
-  crc: 08324688
-  model: openai-codex/gpt-5.5
-  tier: cloud-avg
-  score: 95
-  issues: anchor-miss:(text.mdc),judge:inaccurate:0.98
-  judgeModel: openai-codex/gpt-5.4-mini
+  crc: 6aec4713
+  model: manual
 ---
 
 ## Огляд
 
-Файл забезпечує markdown-концерн для двох поверхонь: `policy` перевіряє наявність `.markdownlint-cli2.jsonc`, а `lint` запускає markdownlint-cli2 для Markdown/MDC-файлів. Він потрібен, щоб delta- та full-режими однаково застосовували правила markdownlint до релевантних файлів і повертали повідомлення з маркером ``.
+Multi-surface detector `text/markdownlint`: `policy` перевіряє наявність `.markdownlint-cli2.jsonc`, `lint` запускає сам `markdownlint-cli2` (delta — по `ctx.files`, full — за glob `**/*.md`/`**/*.mdc`) і повертає обидва результати в одному `LintResult`.
 
 ## Поведінка
 
-1. `lint` перевіряє markdown-концерн у двох площинах: наявність конфігурації markdownlint і фактичну якість Markdown-документів.
-
-2. `lint` спочатку додає до результату порушення політики, якщо в проєкті немає `.markdownlint-cli2.jsonc`.
-
-3. `lint` у delta-режимі перевіряє лише передані Markdown-файли, а у full-режимі — всі файли Markdown і MDC у робочій директорії.
-
-4. `lint` не запускає markdownlint, якщо серед цільових файлів немає Markdown-документів, і повертає лише вже зібрані порушення політики.
-
-5. `lint` приглушує прямий вивід markdownlint, щоб detector повертав уніфікований результат lint-перевірки без шуму в консолі.
-
-6. `lint` додає порушення з маркером ``, якщо markdownlint знаходить проблеми у Markdown або MDC-файлах.
-
-7. `lint` повертає спільний список порушень для policy- та lint-поверхонь, щоб markdown-концерн поводився як один цілісний detector.
+1. Policy-перевірка (`evaluatePolicyConcern`) додає порушення, якщо `.markdownlint-cli2.jsonc` відсутній.
+2. Якщо серед цільових файлів немає Markdown/MDC — `markdownlint-cli2` не запускається, повертаються лише policy-порушення.
+3. `logMessage` (banner, `Finding:`/`Found:`/`Linting:`/`Summary:` прогрес-текст) — no-op, не деталь порушення.
+4. `logError` (один готовий рядок на порушення від дефолтного форматера markdownlint-cli2: `<file>:<line>:<col> <rule> <опис> [<деталь>]`) — накопичується в масив і вбудовується у violation-повідомлення. Без цього LLM fix-worker (і non-verbose підсумок) бачив лише голе "markdownlint знайшов порушення", без файлу/рядка/правила.
+5. Ненульовий exit-код `markdownlint-cli2` → одне порушення `reason: 'markdownlint'` з накопиченою деталлю.
 
 ## Публічний API
 
-- lint — знаходить для `text.mdc` маркери повідомлень, контролює наявність policy-конфігурації та запускає markdownlint; результати обох етапів збирає в один звіт lint.
+- `lint(ctx)` — detector-контракт unified lint surface; повертає `{ violations }` (policy + lint-порушення разом).
 
 ## Гарантії поведінки
 
-- Read-only: не виконує операцій запису (ФС/БД).
+- Read-only: не пише `.markdownlint-cli2.jsonc` сам — генерація конфігу окремим T0 (не в цьому detector-і).
+- `logError`-деталь — єдине джерело причини провалу; текстові евристики за кодом виходу не використовуються.

package/rules/text/markdownlint/main.mjs

@@ -32,22 +32,30 @@ export async function lint(ctx) {
   const targets = ctx.files === undefined ? DEFAULT_MD_GLOBS : ctx.files.filter(f => MD_EXT_RE.test(f))
   if (targets.length === 0) return { violations }
 
+  // logError отримує один готовий рядок на порушення через default output formatter
+  // markdownlint-cli2 ("<file>:<line>:<col> <rule> <опис> [<деталь>]") — раніше глушився,
+  // detector повертав лише голе "щось не пройшло" без файлу/правила/причини, тож LLM
+  // fix-worker (як і non-verbose підсумок) не мав інформації, що саме виправляти
+  // (той самий патерн, що й text/run-v8r до фіксу). logMessage лишається no-op —
+  // banner/Finding/Found/Linting/Summary прогрес-текст, не деталь порушення.
+  const errorLines = []
   const code = await markdownlintCli2({
     directory: ctx.cwd,
     argv: targets,
     logMessage: () => {
-      // вивід markdownlint-cli2 глушимо — detector лише повертає код
+      // прогрес-статус markdownlint-cli2 (banner, Finding/Found/Linting/Summary) — не деталь
     },
-    logError: () => {
-      // помилки markdownlint-cli2 глушимо — detector лише повертає код
+    logError: message => {
+      errorLines.push(message)
     }
   })
   if (code !== 0) {
+    const detail = errorLines.length > 0 ? `:\n${errorLines.join('\n')}` : ''
     violations.push({
       ruleId: ctx.ruleId,
       concernId: ctx.concernId,
       reason: 'markdownlint',
-      message: 'markdownlint знайшов порушення у *.md/*.mdc (text.mdc)'
+      message: `markdownlint знайшов порушення у *.md/*.mdc (text.mdc)${detail}`
     })
   }
 

package/skills/taze/SKILL.md

@@ -13,33 +13,35 @@ version: '1.1'
 
 Оновити всі модулі проекту (npm/bun-залежності, а за наявності `Cargo.toml` — і Rust-крейти) до останніх версій, виявити major-оновлення, перевірити сумісність змін з кодом проекту і за потреби зрефакторити несумісні місця.
 
-## Оркестрація (npm/bun-гілка) — не одним промптом
+## Оркестрація (npm/bun- і Rust-гілка) — не одним промптом
 
 `npx @7n/rules skill pi|cursor|codex taze` **не** передає цей файл одним суцільним
 промптом в один агентський хід — так робив старий дизайн, і саме тому реальний
 прогін міг зависати без жодної діагностики (один величезний непрозорий хід на
 весь монорепо, без проміжних зупинок для перевірки прогресу). Замість цього `npm/skills/taze/js/orchestrate.mjs`:
 
-1. Детерміновано, без LLM, виконує кроки 1-3 нижче (бекап → `bunx taze -w -r latest` → `bun install` → `n-rules taze diff`).
-2. Для кожного **окремого** major-пакета з diff-у — один ізольований, обмежений виклик обраного раннера (кроки 4-6, лише для цього пакета; промпт генерує `buildDependencyPrompt`, не цей SKILL.md).
+1. Детерміновано, без LLM, виконує кроки 1-3 нижче для обох гілок: npm/bun (бекап → `bunx taze -w -r latest` → `bun install` → `n-rules taze diff`) і, якщо знайдені `Cargo.toml`, Rust (бекап → `cargo upgrade --incompatible allow` → `cargo update` → `collectCargoDiff` з `cargo-diff.mjs`, детермінований cargo-еквівалент `n-rules taze diff` — парсить кожен `Cargo.toml` через `smol-toml`, класифікує major за тим самим правилом caret-семантики, включно з Cargo-скороченими версіями `"1"`/`"0.4"`).
+2. Для кожного **окремого** major-пакета/крейта з diff-у — один ізольований, обмежений виклик обраного раннера (кроки 4-6, лише для цього запису; промпт генерує `buildDependencyPrompt`/`buildCargoDependencyPrompt`, не цей SKILL.md).
 3. Детерміновано прибирає бекапи (крок 7) і компонує звіт (крок 8) з результатів усіх ітерацій.
 
-Переваги: падіння/timeout на одному пакеті не втрачає прогрес по інших; кожен
-виклик успадковує власний timeout раннера (короткий, бо скоуп малий — один
-пакет, не весь монорепо); видно прогрес по пакетах, а не чорну скриньку.
+Якщо `Cargo.toml` знайдені, але `cargo-edit` не встановлено — Rust-гілка **не**
+блокує npm-гілку: оркестратор пропускає Rust-обробку і в звіті перелічує
+знайдені `Cargo.toml` як такі, що потребують ручного прогону (нижче).
+
+Переваги: падіння/timeout на одному пакеті/крейті не втрачає прогрес по інших;
+кожен виклик успадковує власний timeout раннера (короткий, бо скоуп малий —
+один запис, не весь монорепо); видно прогрес по записах, а не чорну скриньку.
 
 Кроки 1-8 нижче лишаються джерелом правди щодо ЗМІСТУ роботи (що саме робить
 кожен крок) — оркестратор їх виконує програмно (1-3/7/8) або як промпт на
-один пакет (4-6). Пряме читання цього файлу одним агентом (як SKILL.md для
-інших скілів) досі стосується лише **Rust-гілки** (нижче) — вона оркестратором
-не покрита.
+один запис (4-6) для обох гілок.
 
 ## Передумови
 
 - Чисте робоче дерево (`git status` без незакомічених змін у `package.json` / `bun.lock` / `node_modules`) — інакше різницю не відрізнити від оновлення.
 - Встановлений `bun` і доступний `bunx`.
 - Запуск з кореня проекту (де лежить `package.json` / `bun.lock`).
-- Якщо в проекті є хоч один `Cargo.toml` (не в `node_modules`/`.worktrees`) — додатково встановлений `cargo-edit` (`cargo install cargo-edit`, дає команду `cargo upgrade`). Без нього major-бампи Rust-залежностей неможливо застосувати детерміновано (голий `cargo update` піднімає лише semver-сумісні версії) — **STOP** і попроси користувача встановити перед продовженням кроку 2 для Rust-гілки.
+- Якщо в проекті є хоч один `Cargo.toml` (не в `node_modules`/`.worktrees`) — бажано встановлений `cargo-edit` (`cargo install cargo-edit`, дає команду `cargo upgrade`). Без нього major-бампи Rust-залежностей неможливо застосувати детерміновано (голий `cargo update` піднімає лише semver-сумісні версії) — оркестратор пропускає Rust-гілку (без блокування npm-гілки) і перелічує знайдені `Cargo.toml` у звіті як такі, що потребують ручного прогону кроків 2-8 нижче.
 
 ### 0.2. Детекція Rust-крейтів
 
@@ -102,7 +104,7 @@ n-rules taze diff
 
 Покриває **прямі** залежності з `package.json` (root + воркспейси). Транзитивні major-стрибки (`bun.lock`) — за потреби переглянь окремо; основний ризик breaking-змін — у прямих.
 
-**Rust-гілка** — для `n-rules taze diff` немає cargo-еквівалента, класифікація ручна: для кожного `Cargo.toml.taze-bak` порівняти версію кожної залежності зі свіжим `Cargo.toml` за тим самим правилом (зміна найлівішої ненульової semver-компоненти = major). Швидкий спосіб — `diff Cargo.toml.taze-bak Cargo.toml` по рядках `<name> = "<version>"` і вручну класифікувати кожну зміну.
+**Rust-гілка (оркестровано)** — `collectCargoDiff` (`npm/skills/taze/js/cargo-diff.mjs`) робить те саме детерміновано: парсить кожен `Cargo.toml.taze-bak`/`Cargo.toml` через `smol-toml`, порівнює `dependencies`/`dev-dependencies`/`build-dependencies` (рядок чи `{ version = "...", features = [...] }`), класифікує за тим самим правилом caret-семантики — Cargo-скорочені версії (`"1"`, `"0.4"`) трактуються як відсутні компоненти = 0. Ручний прогін поза оркестратором — той самий принцип: `diff Cargo.toml.taze-bak Cargo.toml` по рядках `<name> = "<version>"`.
 
 ### 4. Зібрати breaking changes по кожному major-оновленню
 

package/skills/taze/js/cargo-diff.mjs

@@ -0,0 +1,117 @@
+/** @see ./docs/cargo-diff.md */
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { parse as parseToml } from 'smol-toml'
+
+import { isBreaking } from './diff.mjs'
+
+/** Поля Cargo.toml із залежностями, які порівнюємо (аналог DEP_FIELDS у diff.mjs). */
+const CARGO_DEP_FIELDS = ['dependencies', 'dev-dependencies', 'build-dependencies']
+
+/** Дефолтний суфікс бекапу — той самий, що й для package.json (крок 1 SKILL.md, Rust-гілка). */
+const DEFAULT_BACKUP_SUFFIX = '.taze-bak'
+
+// 1-3 числові компоненти (`"1"`, `"0.4"`, `"1.2.3"`), опційний `=`/`~`/`^`/`>=`-префікс.
+//Cargo трактує відсутні компоненти як 0 і для матчингу, і для caret-сумісності —
+// той самий "найлівіша ненульова компонента" принцип, що й у isBreaking з diff.mjs.
+const CARGO_VERSION_RE = /^[\s=~^><]*(\d+)(?:\.(\d+))?(?:\.(\d+))?/
+
+/**
+ * Парсить Cargo-версійний specifier (1-3 компоненти, відсутні → 0).
+ * @param {string} spec версійний specifier із Cargo.toml (`"1"`, `"0.4.2"`, `"=1.2.3"`)
+ * @returns {{major:number, minor:number, patch:number}|null} ядро або null для не-semver
+ */
+export function parseCargoVersion(spec) {
+  if (typeof spec !== 'string') return null
+  const m = CARGO_VERSION_RE.exec(spec)
+  if (!m) return null
+  return { major: Number(m[1]), minor: Number(m[2] ?? 0), patch: Number(m[3] ?? 0) }
+}
+
+/**
+ * Дістає версійний specifier одного запису залежності Cargo.toml — рядок
+ * напряму (`tokio = "1"`), або поле `version` inline-таблиці
+ * (`serde = { version = "1", features = [...] }`).
+ * @param {unknown} value значення запису залежності
+ * @returns {string|null} specifier, або null для path/git-залежності (без номера версії)
+ */
+export function extractCargoVersionSpec(value) {
+  if (typeof value === 'string') return value
+  if (value && typeof value === 'object' && !Array.isArray(value) && typeof value.version === 'string') {
+    return value.version
+  }
+  return null
+}
+
+/**
+ * Порівнює два розпарсені Cargo.toml і повертає зміни залежностей —
+ * той самий контракт, що й `diffPackageJson` у diff.mjs, лише для Cargo.
+ * @param {object} oldManifest розпарсений старий Cargo.toml (бекап)
+ * @param {object} newManifest розпарсений новий Cargo.toml
+ * @param {string} manifest відносний шлях Cargo.toml (мітка джерела запису)
+ * @returns {{major: Array<{manifest:string, pkg:string, from:string, to:string}>, minorPatch:number}} зміни
+ */
+export function diffCargoToml(oldManifest, newManifest, manifest) {
+  const major = []
+  let minorPatch = 0
+  for (const field of CARGO_DEP_FIELDS) {
+    const oldDeps = oldManifest?.[field]
+    const newDeps = newManifest?.[field]
+    if (!oldDeps || !newDeps) continue
+    for (const [crate, oldValue] of Object.entries(oldDeps)) {
+      const newValue = newDeps[crate]
+      if (newValue === undefined) continue
+      const from = extractCargoVersionSpec(oldValue)
+      const to = extractCargoVersionSpec(newValue)
+      if (from === null || to === null || from === to) continue
+      const fromV = parseCargoVersion(from)
+      const toV = parseCargoVersion(to)
+      if (fromV && toV && isBreaking(fromV, toV)) {
+        major.push({ manifest, pkg: crate, from, to })
+      } else {
+        minorPatch += 1
+      }
+    }
+  }
+  return { major, minorPatch }
+}
+
+/**
+ * Читає й парсить TOML-файл, або повертає null, якщо файл відсутній/невалідний.
+ * @param {string} path абсолютний шлях
+ * @returns {Promise<object|null>} розпарсений обʼєкт або null
+ */
+async function readTomlOrNull(path) {
+  if (!existsSync(path)) return null
+  try {
+    return parseToml(await readFile(path, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Збирає diff по всіх Cargo.toml монорепо: для кожного шляху зі списку
+ * порівнює `<manifest>` з `<manifest><backupSuffix>` — той самий контракт,
+ * що й `collectTazeDiff` для package.json.
+ * @param {string} cwd корінь репозиторію
+ * @param {string[]} manifestPaths відносні шляхи Cargo.toml (з `findCargoManifests`)
+ * @param {string} [backupSuffix] суфікс бекап-файлу
+ * @returns {Promise<{major: Array<{manifest:string, pkg:string, from:string, to:string}>, minorPatch:number, totalChanged:number, comparedManifests:number}>} агрегований diff
+ */
+export async function collectCargoDiff(cwd, manifestPaths, backupSuffix = DEFAULT_BACKUP_SUFFIX) {
+  const major = []
+  let minorPatch = 0
+  let comparedManifests = 0
+  for (const manifest of manifestPaths) {
+    const oldManifest = await readTomlOrNull(join(cwd, `${manifest}${backupSuffix}`))
+    const newManifest = await readTomlOrNull(join(cwd, manifest))
+    if (!oldManifest || !newManifest) continue
+    comparedManifests += 1
+    const res = diffCargoToml(oldManifest, newManifest, manifest)
+    major.push(...res.major)
+    minorPatch += res.minorPatch
+  }
+  return { major, minorPatch, totalChanged: major.length + minorPatch, comparedManifests }
+}

package/skills/taze/js/docs/cargo-diff.md

@@ -0,0 +1,41 @@
+---
+type: JS Module
+title: cargo-diff.mjs
+resource: npm/skills/taze/js/cargo-diff.mjs
+docgen:
+  crc: afe20497
+  model: openai-codex/gpt-5.4-mini
+  tier: cloud-min
+  score: 100
+  issues: judge:inaccurate:0.99
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+`package.json`
+
+Файл читає версії з `Cargo.toml`, виділяє специфікації залежностей, порівнює дві версії маніфесту та збирає diff по змінах версій. Для монорепо проходить по списку `Cargo.toml` і агрегує результати для всіх знайдених маніфестів. Усі помилки перехоплює fail-safe: не кидає винятків назовні й за окремих збоїв повертає порожнє значення замість помилки.
+
+## Поведінка
+
+- parseCargoVersion — виділяє версійну частину Cargo-специфікатора й повертає її як нормалізоване числове ядро; для не-версійних значень повертає null.
+- extractCargoVersionSpec — дістає версійний specifier із запису залежності Cargo.toml; для path/git-залежностей без версії повертає null.
+- diffCargoToml — порівнює два розпарсені Cargo.toml і визначає зміни залежностей, розділяючи їх на major та minor/patch.
+- collectCargoDiff — проходить по списку Cargo.toml у монорепо, зіставляє кожен файл із його backup-файлом і збирає агрегований diff; якщо один із файлів відсутній або невалідний, пропускає його без падіння.
+
+## Публічний API
+
+- Конфіги, на які спирається код: `package.json` — джерело списку залежностей і меж для порівняння змін.
+- `parseCargoVersion` — розбирає Cargo-версійний specifier і заповнює відсутні частини нулями.
+- `extractCargoVersionSpec` — дістає версію залежності з запису `Cargo.toml`, як з короткого рядка, так і з inline-таблиці.
+- `diffCargoToml` — порівнює два розібрані `Cargo.toml` і повертає зміни по залежностях.
+- `collectCargoDiff` — збирає diff для всіх `Cargo.toml` у монорепо, зіставляючи кожен маніфест із його backup-версією.
+
+Changelog: не перевіряв — змін у файлах не вносив.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).
+- За певних помилок повертає порожнє значення (напр. `null`) замість винятку.

package/skills/taze/js/docs/index.md

@@ -6,5 +6,6 @@ resource: npm/skills/taze/js/
 
 | Файл                              | Тип       |
 | --------------------------------- | --------- |
+| [cargo-diff.mjs](cargo-diff.md)   | JS Module |
 | [diff.mjs](diff.md)               | JS Module |
 | [orchestrate.mjs](orchestrate.md) | JS Module |

package/skills/taze/js/docs/orchestrate.md

@@ -3,9 +3,8 @@ type: JS Module
 title: orchestrate.mjs
 resource: npm/skills/taze/js/orchestrate.mjs
 docgen:
-  crc: 37e2a3e9
+  crc: 1ff52a80
   model: openai-codex/gpt-5.4-mini
-  tier: cloud-min
   score: 100
   issues: judge:inaccurate:0.98
   judgeModel: openai-codex/gpt-5.4-mini

package/skills/taze/js/orchestrate.mjs

@@ -5,6 +5,7 @@ import { copyFile, rm } from 'node:fs/promises'
 import { join } from 'node:path'
 
 import { getMonorepoPackageRootDirs } from '../../../scripts/lib/workspaces.mjs'
+import { collectCargoDiff } from './cargo-diff.mjs'
 import { collectTazeDiff } from './diff.mjs'
 
 /** Суфікс бекапу package.json — той самий, що й у `diff.mjs`/кроці 1 SKILL.md. */
@@ -34,6 +35,30 @@ export function buildDependencyPrompt({ workspace, pkg, from, to }) {
   ].join('\n')
 }
 
+/**
+ * Промпт ОДНОГО ітеративного виклику для Rust-крейта — Rust-варіант
+ * [`buildDependencyPrompt`] (кроки 4-6 SKILL.md, Rust-гілка), для ОДНОГО
+ * major-крейта. Кроки 1-3/7/8 виконує оркестратор детерміновано, без LLM.
+ * @param {{manifest: string, pkg: string, from: string, to: string}} entry запис major-diff (з `collectCargoDiff`)
+ * @returns {string} готовий промпт
+ */
+export function buildCargoDependencyPrompt({ manifest, pkg, from, to }) {
+  return [
+    '# Major-оновлення одного Rust-крейта: перевірка сумісності й рефакторинг',
+    '',
+    `Крейт \`${pkg}\` у \`${manifest}\`: **${from} → ${to}** — вже застосовано в Cargo.toml/Cargo.lock (кроки 1-3 виконано детерміновано, без тебе). Твоя задача — лише breaking-changes-перевірка й, за потреби, рефакторинг.`,
+    '',
+    '## Кроки',
+    `1. Зібрати breaking changes цього оновлення: адреса репозиторію з поля \`repository\`/\`documentation\` крейта на crates.io (https://crates.io/crates/${pkg}) — CHANGELOG.md репозиторію чи GitHub Releases. Якщо немає — різниця по публічному API (\`pub fn\`/\`pub struct\`/\`pub trait\`) між закешованою старою версією (\`~/.cargo/registry/src/*/${pkg}-<стара-версія>/\`) і новою.`,
+    `2. Знайти використання зачепленого API в коді проєкту (\`rg -n --type rust\` по use-шляхах/викликах \`${pkg}\`).`,
+    '3. Сумісно — нічого не робити. Несумісно — застосувати міграцію (перейменувати use-шлях, оновити сигнатуру виклику, замінити видалений макрос еквівалентом).',
+    '4. Якщо були правки — запусти `cargo fmt --all -- --check`, `cargo clippy --all-targets --all-features -- -D warnings`, `cargo test`.',
+    '5. Нетривіальна/неоднозначна міграція — не вгадуй, залиш TODO-коментар із посиланням на CHANGELOG.',
+    '',
+    'У відповіді одним абзацом підсумуй: сумісно / зрефакторено (які файли) / TODO (чому).'
+  ].join('\n')
+}
+
 /**
  * Диспетчер одного ітеративного виклику на обраний раннер. `pi` — вбудований
  * pi-агент (`@7n/llm-lib/agent-skill`; текст перехоплюється через `deps.out`,
@@ -154,10 +179,54 @@ export async function cleanupBackups(cwd, workspaces, deps = {}) {
 }
 
 /**
- * Знаходить Cargo.toml поза node_modules/.worktrees/target (крок 0.2
- * SKILL.md). Лише інформаційно — v1 оркестратора Rust-крейти не оновлює
- * (немає детермінованого cargo-diff-еквівалента `collectTazeDiff`,
- * класифікація major там ручна за SKILL.md).
+ * Чи встановлений cargo-edit (дає `cargo upgrade`) — без нього неможливо
+ * детерміновано перетнути major-межу Rust-залежностей (голий `cargo update`
+ * піднімає лише semver-сумісні версії; SKILL.md §Передумови).
+ * @param {typeof spawnSync} spawnFn інжект для тестів
+ * @returns {boolean} true — `cargo upgrade` доступна
+ */
+function hasCargoEdit(spawnFn) {
+  return spawnFn('cargo', ['upgrade', '--version'], { encoding: 'utf8' }).status === 0
+}
+
+/**
+ * Бекапить кожен Cargo.toml + спільний кореневий Cargo.lock (крок 1 SKILL.md,
+ * Rust-гілка). v1: один спільний workspace/Cargo.lock у корені `cwd` —
+ * поточна реальна топологія репо (кореневий `Cargo.toml` з `[workspace]` +
+ * члени); кілька незалежних Cargo-workspace під час не підтримується.
+ * @param {string} cwd корінь репо
+ * @param {string[]} manifestPaths відносні шляхи Cargo.toml (з `findCargoManifests`)
+ * @param {{ copyFile?: (src: string, dest: string) => Promise<void> }} [deps] інжект
+ * @returns {Promise<void>}
+ */
+export async function backupCargoManifests(cwd, manifestPaths, deps = {}) {
+  const copy = deps.copyFile ?? copyFile
+  for (const manifest of manifestPaths) {
+    const manifestPath = join(cwd, manifest)
+    if (existsSync(manifestPath)) await copy(manifestPath, `${manifestPath}${BACKUP_SUFFIX}`)
+  }
+  const lockPath = join(cwd, 'Cargo.lock')
+  if (existsSync(lockPath)) await copy(lockPath, `${lockPath}${BACKUP_SUFFIX}`)
+}
+
+/**
+ * Прибирає бекапи Cargo.toml/Cargo.lock після завершення (крок 7 SKILL.md,
+ * Rust-гілка).
+ * @param {string} cwd корінь репо
+ * @param {string[]} manifestPaths відносні шляхи Cargo.toml (з `findCargoManifests`)
+ * @param {{ rm?: (path: string, opts?: object) => Promise<void> }} [deps] інжект
+ * @returns {Promise<void>}
+ */
+export async function cleanupCargoBackups(cwd, manifestPaths, deps = {}) {
+  const remove = deps.rm ?? rm
+  for (const manifest of manifestPaths) {
+    await remove(join(cwd, `${manifest}${BACKUP_SUFFIX}`), { force: true })
+  }
+  await remove(join(cwd, `Cargo.lock${BACKUP_SUFFIX}`), { force: true })
+}
+
+/**
+ * Знаходить Cargo.toml поза node_modules/.worktrees/target (крок 0.2 SKILL.md).
  * @param {string} cwd корінь репо
  * @param {{ spawnFn?: typeof spawnSync }} [deps] інжект
  * @returns {string[]} відносні шляхи знайдених Cargo.toml
@@ -188,13 +257,36 @@ export function findCargoManifests(cwd, deps = {}) {
     .filter(Boolean)
 }
 
+/**
+ * Форматує один рядок результату ітерації (спільний для npm- і Rust-гілки).
+ * @param {{pkg: string, ok: boolean, error: string|null, from: string, to: string}} r результат ітерації
+ * @param {string} scopeLabel мітка джерела (`workspace` для npm, `manifest` для Rust)
+ * @returns {string} один рядок звіту
+ */
+function formatResultLine(r, scopeLabel) {
+  const status = r.ok ? '✅' : '❌'
+  const errorSuffix = r.error ? ` — ${r.error}` : ''
+  return `  ${status} \`${r.pkg}\` (${scopeLabel}): ${r.from} → ${r.to}${errorSuffix}`
+}
+
 /**
  * Компонує підсумковий звіт (крок 8 SKILL.md) детерміновано з результатів
  * ітерацій — без окремого LLM-виклику для самого звіту.
- * @param {{ minorPatch: number, totalChanged: number, results: Array<{pkg:string, workspace:string, from:string, to:string, ok:boolean, error:string|null}>, rustCrates: string[] }} args дані звіту
+ * @param {{
+ *   minorPatch: number,
+ *   totalChanged: number,
+ *   results: Array<{pkg:string, workspace:string, from:string, to:string, ok:boolean, error:string|null}>,
+ *   rust: {
+ *     manifests: string[],
+ *     processed: boolean,
+ *     skippedReason: string|null,
+ *     minorPatch: number,
+ *     results: Array<{pkg:string, manifest:string, from:string, to:string, ok:boolean, error:string|null}>
+ *   }
+ * }} args дані звіту
  * @returns {string} markdown-звіт
  */
-export function formatReport({ minorPatch, totalChanged, results, rustCrates }) {
+export function formatReport({ minorPatch, totalChanged, results, rust }) {
   const lines = [
     '## taze: підсумок',
     '',
@@ -202,17 +294,26 @@ export function formatReport({ minorPatch, totalChanged, results, rustCrates })
     `- **Major-оновлення:** ${results.length}`
   ]
   for (const r of results) {
-    const status = r.ok ? '✅' : '❌'
-    const errorSuffix = r.error ? ` — ${r.error}` : ''
-    lines.push(`  ${status} \`${r.pkg}\` (${r.workspace}): ${r.from} → ${r.to}${errorSuffix}`)
+    lines.push(formatResultLine(r, r.workspace))
   }
-  if (rustCrates.length > 0) {
-    lines.push(
-      '',
-      `- **Rust-крейти (${rustCrates.length}), потребують ручного прогону Rust-гілки SKILL.md:** ${rustCrates.join(', ')}`
-    )
+
+  let rustTotalChanged = 0
+  if (rust.manifests.length > 0) {
+    lines.push('', '### Rust-крейти')
+    if (rust.processed) {
+      lines.push(`- **Оновлено (minor/patch):** ${rust.minorPatch}`, `- **Major-оновлення:** ${rust.results.length}`)
+      for (const r of rust.results) {
+        lines.push(formatResultLine(r, r.manifest))
+      }
+      rustTotalChanged = rust.minorPatch + rust.results.length
+    } else {
+      lines.push(
+        `- ⏭ Пропущено (${rust.skippedReason}) — ${rust.manifests.length} Cargo.toml, онови вручну за Rust-гілкою SKILL.md: ${rust.manifests.join(', ')}`
+      )
+    }
   }
-  lines.push('', `- **Всього змінено:** ${totalChanged}`)
+
+  lines.push('', `- **Всього змінено:** ${totalChanged + rustTotalChanged}`)
   return lines.join('\n')
 }
 
@@ -227,9 +328,9 @@ export function formatReport({ minorPatch, totalChanged, results, rustCrates })
  *   cwd?: string,
  *   runner?: 'pi' | 'cursor' | 'codex',
  *   log?: (line: string) => void,
- *   deps?: { spawnFn?: typeof spawnSync, collectTazeDiff?: (cwd: string) => Promise<object>, callRunner?: (runner: string, prompt: string, cwd: string, deps: object) => Promise<{ok: boolean, text: string, error: string|null}> } & Record<string, unknown>
+ *   deps?: { spawnFn?: typeof spawnSync, collectTazeDiff?: (cwd: string) => Promise<object>, collectCargoDiff?: (cwd: string, manifests: string[]) => Promise<object>, callRunner?: (runner: string, prompt: string, cwd: string, deps: object) => Promise<{ok: boolean, text: string, error: string|null}> } & Record<string, unknown>
  * }} [options] опції + інжекти для тестів
- * @returns {Promise<{ ok: boolean, report: string, results: Array<object> }>} результат
+ * @returns {Promise<{ ok: boolean, report: string, results: Array<object>, rustResults: Array<object> }>} результат
  */
 export async function runTazeOrchestrator(options = {}) {
   const cwd = options.cwd ?? process.cwd()
@@ -237,11 +338,10 @@ export async function runTazeOrchestrator(options = {}) {
   const log = options.log ?? (line => console.log(line))
   const deps = options.deps ?? {}
   const spawnFn = deps.spawnFn ?? spawnSync
+  const call = deps.callRunner ?? callRunner
 
   assertRunningInWorktree(cwd, spawnFn)
 
-  const rustCrates = findCargoManifests(cwd, { spawnFn })
-
   log('📦 Бекап package.json...')
   const backedUpWorkspaces = await backupWorkspacePackageFiles(cwd, deps)
 
@@ -255,7 +355,6 @@ export async function runTazeOrchestrator(options = {}) {
   log(`🔍 diff: ${diff.major.length} major, ${diff.minorPatch} minor/patch`)
 
   const results = []
-  const call = deps.callRunner ?? callRunner
   for (const entry of diff.major) {
     log(`🔧 ${entry.pkg} (${entry.workspace}): ${entry.from} → ${entry.to}...`)
     const outcome = await call(runner, buildDependencyPrompt(entry), cwd, deps)
@@ -265,8 +364,47 @@ export async function runTazeOrchestrator(options = {}) {
 
   await cleanupBackups(cwd, backedUpWorkspaces, deps)
 
-  const report = formatReport({ minorPatch: diff.minorPatch, totalChanged: diff.totalChanged, results, rustCrates })
+  const rustManifests = findCargoManifests(cwd, { spawnFn })
+  let rust = { manifests: rustManifests, processed: false, skippedReason: null, minorPatch: 0, results: [] }
+
+  if (rustManifests.length > 0 && !hasCargoEdit(spawnFn)) {
+    rust.skippedReason =
+      'cargo-edit не встановлено (`cargo install cargo-edit`) — cargo update без нього недетермінований для major'
+    log(`⏭ Rust: ${rust.skippedReason}`)
+  } else if (rustManifests.length > 0) {
+    log('📦 Бекап Cargo.toml/Cargo.lock...')
+    await backupCargoManifests(cwd, rustManifests, deps)
+
+    log('⬆️  cargo upgrade --incompatible allow...')
+    runCommand('cargo', ['upgrade', '--incompatible', 'allow'], cwd, spawnFn)
+    log('🔄 cargo update...')
+    runCommand('cargo', ['update'], cwd, spawnFn)
+
+    const collectCargo = deps.collectCargoDiff ?? collectCargoDiff
+    const cargoDiff = await collectCargo(cwd, rustManifests)
+    log(`🔍 Rust diff: ${cargoDiff.major.length} major, ${cargoDiff.minorPatch} minor/patch`)
+
+    const rustResults = []
+    for (const entry of cargoDiff.major) {
+      log(`🔧 [rust] ${entry.pkg} (${entry.manifest}): ${entry.from} → ${entry.to}...`)
+      const outcome = await call(runner, buildCargoDependencyPrompt(entry), cwd, deps)
+      rustResults.push({ ...entry, ...outcome })
+      log(outcome.ok ? `  ✅ ${entry.pkg}` : `  ❌ ${entry.pkg}: ${outcome.error}`)
+    }
+
+    await cleanupCargoBackups(cwd, rustManifests, deps)
+
+    rust = {
+      manifests: rustManifests,
+      processed: true,
+      skippedReason: null,
+      minorPatch: cargoDiff.minorPatch,
+      results: rustResults
+    }
+  }
+
+  const report = formatReport({ minorPatch: diff.minorPatch, totalChanged: diff.totalChanged, results, rust })
   log(report)
 
-  return { ok: results.every(r => r.ok), report, results }
+  return { ok: results.every(r => r.ok) && rust.results.every(r => r.ok), report, results, rustResults: rust.results }
 }