@7n/rules 1.0.0

package/rules/tauri/linux_deps/main.mjs

@@ -0,0 +1,100 @@
+/**
+ * @see ./docs/main.md
+ *
+ * Read-only detector: у Tauri-проєкті (є `<ws>/src-tauri/Cargo.toml`) job
+ * `.github/workflows/lint-rust.yml` повинен ставити системні залежності Linux
+ * (`apt-get install` з webkit2gtk/appindicator/rsvg dev-пакетами) — інакше
+ * Clippy падає на збірці `-sys`-крейтів (`webkit2gtk-sys`, `gtk-sys`, …),
+ * чиї build-скрипти шукають системні `.pc`-файли через pkg-config (tauri.mdc).
+ * Rustfmt нічого не компілює — вимога стосується саме Clippy-кроку.
+ *
+ * Текстовий (не YAML-AST) аналіз — навмисно, як `rust/toolchain_cache`:
+ * мінімізує diff і зберігає коментарі при автофіксі. Існування самого
+ * lint-rust.yml перевіряє `rust.lint_rust_yml` (policy required) — тут відсутній
+ * файл пропускається без порушення.
+ */
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { createViolationReporter } from '../../../scripts/lib/lint-surface/violation-reporter.mjs'
+import { findSrcTauriDirs } from '../cargo_mutants_config/main.mjs'
+
+/** Стабільні reasons: apt-кроку немає взагалі / у ньому бракує канонічних пакетів. */
+export const MISSING_LINUX_DEPS_STEP = 'missing-linux-deps-step'
+export const MISSING_LINUX_DEPS_PACKAGES = 'missing-linux-deps-packages'
+
+/** Цільовий workflow-файл (канон `rust.lint_rust_yml`). */
+export const LINT_RUST_YML = '.github/workflows/lint-rust.yml'
+
+/**
+ * Канонічні dev-пакети для компіляції Tauri v2 на ubuntu-runner-і:
+ * webkit2gtk-4.1 (WebView), ayatana-appindicator (tray), rsvg (іконки).
+ * Перевірка — підмножина: додаткові пакети в apt-рядку дозволені.
+ */
+export const REQUIRED_LINUX_PACKAGES = Object.freeze([
+  'libwebkit2gtk-4.1-dev',
+  'libayatana-appindicator3-dev',
+  'librsvg2-dev'
+])
+
+const APT_INSTALL_RE = /\bapt-get install\b/u
+
+/**
+ * Результат текстового сканування lint-rust.yml на apt-крок системних залежностей.
+ * @typedef {object} LinuxDepsScan
+ * @property {number} aptLine індекс першого рядка з `apt-get install` (−1, якщо немає)
+ * @property {string[]} missing канонічні пакети, відсутні у вмісті файла
+ */
+
+/**
+ * Сканує вміст workflow: перший `apt-get install`-рядок і перелік канонічних
+ * пакетів, яких немає ніде у файлі (substring — пакет може стояти на
+ * continuation-рядку багаторядкового `run: |`).
+ * @param {string} content вміст workflow-файла
+ * @returns {LinuxDepsScan} результат сканування
+ */
+export function scanLinuxDeps(content) {
+  const lines = content.split('\n')
+  const aptLine = lines.findIndex(l => APT_INSTALL_RE.test(l))
+  const missing = REQUIRED_LINUX_PACKAGES.filter(p => !content.includes(p))
+  return { aptLine, missing }
+}
+
+/**
+ * @param {import('../../../scripts/lib/lint-surface/types.mjs').LintContext} ctx контекст лінт-прогону
+ * @returns {Promise<import('../../../scripts/lib/lint-surface/types.mjs').LintResult>} результат перевірки
+ */
+export async function lint(ctx) {
+  const cwd = ctx.cwd
+  const reporter = createViolationReporter(ctx)
+
+  const srcTauriDirs = await findSrcTauriDirs(cwd)
+  if (srcTauriDirs.length === 0) return reporter.result()
+
+  const abs = join(cwd, LINT_RUST_YML)
+  if (!existsSync(abs)) return reporter.result() // існування файла — rust.lint_rust_yml
+
+  const content = await readFile(abs, 'utf8')
+  const { aptLine, missing } = scanLinuxDeps(content)
+
+  if (aptLine === -1) {
+    reporter.fail(
+      `${LINT_RUST_YML}: Tauri-проєкт потребує кроку системних залежностей Linux (apt-get install ${REQUIRED_LINUX_PACKAGES.join(' ')}) перед Clippy (tauri.mdc)`,
+      { reason: MISSING_LINUX_DEPS_STEP, file: LINT_RUST_YML, data: { kind: MISSING_LINUX_DEPS_STEP } }
+    )
+    return reporter.result()
+  }
+
+  if (missing.length > 0) {
+    reporter.fail(`${LINT_RUST_YML}: apt-крок без канонічних Tauri-пакетів [${missing.join(', ')}] (tauri.mdc)`, {
+      reason: MISSING_LINUX_DEPS_PACKAGES,
+      file: LINT_RUST_YML,
+      data: { kind: MISSING_LINUX_DEPS_PACKAGES, missing }
+    })
+    return reporter.result()
+  }
+
+  reporter.pass(`${LINT_RUST_YML}: системні залежності Tauri (Linux) присутні`)
+  return reporter.result()
+}

package/rules/tauri/main.json

@@ -0,0 +1 @@
+{ "auto": { "predicate": "depInAnyPackageJson", "arg": ["@tauri-apps/api"] } }

package/rules/tauri/main.mdc

@@ -0,0 +1,86 @@
+---
+description: Tauri
+globs: "**/src-tauri/**,**/tauri.conf.json"
+alwaysApply: false
+version: '1.8'
+---
+
+Правило встановлює канонічні вимоги для Tauri-проєктів: виявлення маркерів у монорепо, VS Code-розширення, налаштування mutation-testing для platform bridge, компіляційну ізоляцію agent/LLM-логіки від app-shell, реалізацію Tool Surface поверх Tauri+Rust, реліз-flow через change-файли (тег → DMG/updater-артефакти), автооновлення через спільний `useUpdater()` з `@7n/tauri-components` та верифікацію застосунку LLM-агентом через `tauri-plugin-mcp-bridge`.
+
+## Верифікація LLM-агентом через MCP-міст (замість скриншотів)
+
+Якщо над Tauri-застосунком працює LLM-агент (Claude Code, Cursor тощо), він
+верифікує зміни **програмно** — деревом доступності DOM, кліками за `ref`,
+прямими викликами Rust-команд — а не лише скриншотами. Це забезпечує
+`tauri-plugin-mcp-bridge`: debug-плагін, що піднімає WS-сервер моста
+всередині застосунку, до якого зовні підключається MCP-сервер tauri.
+(Не плутати з **Tool Surface** — `tool-surface.mdc`: той про production
+call surface для UI/оркестратора/LLM, цей — про dev-time верифікацію
+запущеного застосунку.)
+
+### Dev-setup
+
+`src-tauri/Cargo.toml`:
+
+```toml
+[dependencies]
+tauri-plugin-mcp-bridge = "0.11"
+```
+
+Реєстрація плагіна — **лише в debug-збірці** (у release-збірці моста немає):
+
+```rust
+let builder = tauri::Builder::default();
+#[cfg(debug_assertions)]
+let builder = builder.plugin(tauri_plugin_mcp_bridge::init());
+```
+
+WS-сервер моста слухає `0.0.0.0:9223`.
+
+`tauri.conf.json` → `app.withGlobalTauri: true` — **обовʼязково**:
+
+```json title="src-tauri/tauri.conf.json"
+{
+  "app": {
+    "withGlobalTauri": true
+  }
+}
+```
+
+Без `withGlobalTauri` fallback-канал `execute_js` не має як повернути результат — будь-який
+async-скрипт (з `await`/`.then(`/`Promise.`, див. евристику нижче) впаде через
+5с у `Script execution timeout`. `withGlobalTauri` відкриває Tauri API всьому
+JS у webview — прийнятно, бо capabilities однаково обмежують surface;
+проєкти зі стороннім/untrusted контентом у webview мають зважити це окремо.
+
+### Цикл верифікації
+
+Замість скриншотів — послідовність MCP-викликів:
+
+1. `driver_session start` — підключення до моста вже запущеного застосунку (`tauri dev`).
+2. `webview_dom_snapshot type=accessibility` — YAML-дерево з `ref=eN` для кожного елемента.
+3. `webview_interact` — клік/ввід за `ref` з кроку 2.
+4. `webview_execute_js` з `await window.__TAURI__.core.invoke('<команда>', {…})` —
+   пряма звірка бекенд-стану повз UI (Rust-команда, не рендер).
+5. `read_logs source=console` — перевірка консольних помилок/попереджень.
+
+Скриншот — лише щоб показати результат людині, не джерело правди для агента:
+native-скриншот моста не відображає portal-оверлеї (нижче).
+
+### Відомі обмеження моста 0.11.x
+
+- **`ipc_execute_command` не реалізований** — WS-сервер моста дозволяє лише
+  внутрішні команди `plugin:mcp-bridge|*`. Виклик команд застосунку — тільки
+  через `webview_execute_js` + `invoke`, не напряму через `ipc_execute_command`.
+- **`ipc_monitor` перехоплює лише виклики через глобал `window.__TAURI__`.**
+  Стандартний `import { invoke } from '@tauri-apps/api/core'` іде через
+  `__TAURI_INTERNALS__` і в перехоплення не потрапляє.
+- **Евристика native-eval відкидає async-скрипти** — за підрядками `await`,
+  `.then(`, `Promise.` скрипт іде у fallback-канал `execute_js`; без
+  `withGlobalTauri` (вище) fallback не має як повернути результат, і
+  async-скрипт для агента взагалі недоступний.
+- **Native-скриншот не захоплює Quasar/portal-оверлеї** (діалоги, меню) — вони
+  рендеряться поза основним деревом. Перевіряй їх стан через DOM
+  (`document.querySelector('.q-dialog')`), не через скриншот.
+
+Перевірено вживу на проєкті myllm, `tauri-plugin-mcp-bridge` 0.11.2, macOS.

package/rules/tauri/release/concern.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "fixability": "structural",
+  "lint": {
+    "scope": "full",
+    "glob": [".github/workflows/changelog-release.yml", ".github/workflows/release.yml", "**/tauri.conf.json"]
+  }
+}

package/rules/tauri/release/docs/fix-release.md

@@ -0,0 +1,28 @@
+---
+type: JS Module
+title: fix-release.mjs
+resource: npm/rules/tauri/release/fix-release.mjs
+docgen:
+  crc: ed3a25bb
+  model: openai-codex/gpt-5.4-mini
+  score: 100
+  issues: judge:inaccurate:0.97
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+`patterns` вмикає T0-autofix для вже наявних канонічних файлів релізного потоку Tauri: `tauri.conf.json`, `changelog-release.yml` і `release.yml`. Він робить лише детерміновані доповнення до цих файлів на основі `tauri.conf.json` і `latest.json`, щоб привести їх до релізного канону для GitHub Releases через `https://github.com/`. Не створює `*-workflow-missing` і не обробляє `*-invalid-yaml`, `tauri-conf-invalid-json` або `updater-pubkey-missing`: ці стани потребують ручного розв’язання, а `release.yml` і `changelog-release.yml` містять проєкт-специфічні значення, які не варто вигадувати автоматично.
+
+## Поведінка
+
+1. `patterns` запускає цільові T0-autofix-и лише для вже наявних канонічних файлів і працює fail-safe: помилки всередину не пробиває, а відсутні або некоректні чернетки просто лишає без змін.
+2. Для `tauri.conf.json` доповнює updater-канон: вмикає створення updater-артефактів і додає endpoint на `latest.json` у GitHub Releases через `https://github.com/…`, якщо репозиторій походить з поточного `origin`.
+3. Для `changelog-release.yml` добудовує релевантні release-умови лише тоді, коли файл уже існує й коректно читається: додає тригер по `.changes/**`, `workflow_dispatch`, захист від небажаного запуску та потрібні permissions.
+4. Для `release.yml` добудовує release-канон лише тоді, коли файл уже існує й коректно читається: додає теговий тригер `v*`, `workflow_dispatch` і крок синхронізації версії з тегу перед `tauri-action`.
+5. Не створює з нуля відсутні workflow-файли і свідомо не автолікує чернетки з некоректним YAML/JSON та `updater-pubkey-missing`; ці випадки залишає для ручного розв’язання.
+6. Кожен автозастосунок повторно читає поточний вміст, тому зміни залишаються ідемпотентними: повторний запуск не дублює вже доданий канон.
+
+## Гарантії поведінки
+
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).

package/rules/tauri/release/docs/index.md

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

package/rules/tauri/release/docs/main.md

@@ -0,0 +1,32 @@
+---
+type: JS Module
+title: main.mjs
+resource: npm/rules/tauri/release/main.mjs
+docgen:
+  crc: 91e1c73d
+  model: openai-codex/gpt-5.4-mini
+  score: 100
+  issues: judge:inaccurate:0.98
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+`lint` перевіряє готовність Tauri-застосунків у репозиторії до release-потоку на основі `tauri.conf.json` і `latest.json`. Він дає змогу зосередити перевірку на релізних налаштуваннях Tauri, не зачіпаючи `.github` та `.git`.
+
+## Поведінка
+
+1. `lint` знаходить усі workspace-каталоги з Tauri-застосунками, пропускаючи `.github` і `.git`, та бере до уваги лише репозиторії, де є `tauri.conf.json`.
+2. Для кожного такого застосунку `lint` перевіряє готовність `tauri.conf.json` до release: чи увімкнено генерацію updater-артефактів, чи задано public key для updater і чи endpoint веде на `latest.json`.
+3. `lint` контролює наявність `changelog-release.yml` як точки запуску release-процесу з changelog-змін, щоб релізи стартували від змін у `.changes`.
+4. `lint` перевіряє, що `changelog-release.yml` реагує на push у відповідні `.changes`-шляхи для знайдених застосунків, має ручний запуск і захищений від повторного запуску release-циклом.
+5. `lint` перевіряє, що `changelog-release.yml` має достатні права для запуску release-потоку та диспатчу наступного workflow.
+6. `lint` контролює наявність `release.yml` як основного каналу збірки й публікації release-артефактів.
+7. `lint` перевіряє, що `release.yml` запускається на тегах `v*`, підтримує ручний запуск і синхронізує версію в `tauri.conf.json` до кроку публікації через Tauri.
+8. `lint` не змінює файли, працює read-only і повертає результат у fail-safe режимі: помилки фіксуються як порушення, а не пробиваються назовні винятками.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).
+- Свідомо пропускає шляхи: `.github`, `.git`.

package/rules/tauri/release/fix-release.mjs

@@ -0,0 +1,353 @@
+/**
+ * T0-autofix для `tauri/release` — детерміновані доповнення вже існуючих
+ * канонічних файлів (tauri.conf.json, changelog-release.yml, release.yml).
+ *
+ * Свідомо НЕ створює файли з нуля (`*-workflow-missing`) і не чіпає
+ * `*-invalid-yaml`/`tauri-conf-invalid-json`/`updater-pubkey-missing`:
+ * реальний вміст release.yml/changelog-release.yml по чотирьох референс-репо
+ * глибоко проєкт-специфічний (назви build-артефактів, Infisical project-slug/identity-id,
+ * android-job) — правдоподібний, але вигаданий шаблон гірший за явну
+ * mdc-вимогу зробити це вручну. pubkey — реальний ключ підпису, не для
+ * автогенерації. Усі патерни читають вихідний файл і re-detect-ять стан
+ * заново (idempotent), як cargo_mutants_config.
+ */
+import { existsSync } from 'node:fs'
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { spawnSync } from 'node:child_process'
+import { dirname, join } from 'node:path'
+
+import { parseDocument } from 'yaml'
+
+import { parseWorkflowYaml, flattenWorkflowSteps, getStepRun, getStepUses } from '../../../scripts/lib/gha-workflow.mjs'
+import { CHANGELOG_RELEASE_WORKFLOW, RELEASE_WORKFLOW, findTauriAppDirs, hasWorkflowDispatch } from './main.mjs'
+
+const GITHUB_REMOTE_RE = /github\.com[:/]([\w.-]+)\/([\w.-]+?)(?:\.git)?$/u
+const VERSION_WORD_RE = /version/iu
+
+/**
+ * Визначає `owner/repo` з `git remote get-url origin` (https чи ssh форма).
+ * @param {string} cwd корінь репо
+ * @returns {{owner: string, repo: string} | null} пара owner/repo або null, якщо не вдалось розпарсити
+ */
+function resolveGithubOwnerRepo(cwd) {
+  const res = spawnSync('git', ['-C', cwd, 'remote', 'get-url', 'origin'], { encoding: 'utf8' })
+  if (res.status !== 0) return null
+  const m = GITHUB_REMOTE_RE.exec(res.stdout.trim())
+  return m ? { owner: m[1], repo: m[2] } : null
+}
+
+/**
+ * Доповнює `tauri.conf.json` канонічними updater-полями (createUpdaterArtifacts, endpoints).
+ * pubkey НЕ чіпаємо — реальний ключ підпису не генерується автоматично.
+ * @param {string} cwd корінь репо
+ * @returns {Promise<string[]>} абсолютні шляхи змінених файлів
+ */
+async function fixTauriConfFiles(cwd) {
+  const apps = await findTauriAppDirs(cwd)
+  const touched = []
+  const ownerRepo = resolveGithubOwnerRepo(cwd)
+  for (const app of apps) {
+    let conf
+    try {
+      conf = JSON.parse(await readFile(app.tauriConfPath, 'utf8'))
+    } catch {
+      continue
+    }
+    let changed = false
+
+    if (conf?.bundle?.createUpdaterArtifacts !== true) {
+      conf.bundle = { ...conf.bundle, createUpdaterArtifacts: true }
+      changed = true
+    }
+
+    const endpoints = conf?.plugins?.updater?.endpoints
+    const hasLatestJsonEndpoint =
+      Array.isArray(endpoints) &&
+      endpoints.some(e => typeof e === 'string' && e.endsWith('/releases/latest/download/latest.json'))
+    if (!hasLatestJsonEndpoint && ownerRepo) {
+      const endpoint = `https://github.com/${ownerRepo.owner}/${ownerRepo.repo}/releases/latest/download/latest.json`
+      conf.plugins = {
+        ...conf.plugins,
+        updater: { ...conf.plugins?.updater, endpoints: [...(Array.isArray(endpoints) ? endpoints : []), endpoint] }
+      }
+      changed = true
+    }
+
+    if (!changed) continue
+    await writeFile(app.tauriConfPath, `${JSON.stringify(conf, null, 2)}\n`, 'utf8')
+    touched.push(app.tauriConfPath)
+  }
+  return touched
+}
+
+/**
+ * Доповнює `changelog-release.yml` канонічними ключами (paths, dispatch, guard, permissions)
+ * — лише якщо файл вже існує й парситься; scaffold-з-нуля не робимо (див. header-коментар).
+ * @param {string} cwd корінь репо
+ * @returns {Promise<string[]>} абсолютні шляхи змінених файлів (0 чи 1 елемент)
+ */
+async function fixChangelogReleaseWorkflow(cwd) {
+  const path = join(cwd, CHANGELOG_RELEASE_WORKFLOW)
+  if (!existsSync(path)) return []
+  const raw = await readFile(path, 'utf8')
+  const parsedRoot = parseWorkflowYaml(raw)
+  if (!parsedRoot) return []
+
+  const apps = await findTauriAppDirs(cwd)
+  const doc = parseDocument(raw)
+  if (doc.errors?.length) return []
+  let changed = false
+
+  const paths = doc.getIn(['on', 'push', 'paths'])
+  const expectedSuffixes = apps.map(a => {
+    const prefix = a.ws === '.' ? '' : `${a.ws}/`
+    return `${prefix}.changes/**`
+  })
+  const hasChangesPath =
+    paths?.toJSON && Array.isArray(paths.toJSON()) && expectedSuffixes.some(s => paths.toJSON().includes(s))
+  if (!hasChangesPath && expectedSuffixes.length > 0) {
+    const seq = doc.createNode(
+      Array.isArray(paths?.toJSON()) ? [...paths.toJSON(), expectedSuffixes[0]] : [expectedSuffixes[0]]
+    )
+    doc.setIn(['on', 'push', 'paths'], seq)
+    changed = true
+  }
+
+  if (!hasWorkflowDispatch(parsedRoot)) {
+    doc.setIn(['on', 'workflow_dispatch'], doc.createNode({}))
+    changed = true
+  }
+
+  const jobIds = Object.keys(parsedRoot.jobs ?? {})
+  const guardedJobId = jobIds.find(id => {
+    const guard = parsedRoot.jobs[id]?.if
+    return typeof guard === 'string' && guard.includes('head_commit.message') && guard.includes('release:')
+  })
+  const jobIdWithPermissions = jobIds.find(id => {
+    const permissions = parsedRoot.jobs[id]?.permissions
+    return permissions?.contents === 'write' && permissions?.actions === 'write'
+  })
+  const targetJobId = jobIds[0]
+  if (targetJobId && !guardedJobId) {
+    doc.setIn(['jobs', targetJobId, 'if'], "!startsWith(github.event.head_commit.message, 'release:')")
+    changed = true
+  }
+  if (targetJobId && !jobIdWithPermissions) {
+    doc.setIn(['jobs', targetJobId, 'permissions', 'contents'], 'write')
+    doc.setIn(['jobs', targetJobId, 'permissions', 'actions'], 'write')
+    changed = true
+  }
+
+  if (targetJobId && insertPushAuthStep(doc, parsedRoot, targetJobId)) changed = true
+
+  if (!changed) return []
+  await writeFile(path, doc.toString(), 'utf8')
+  return [path]
+}
+
+/**
+ * Вставляє канонічний push-auth крок перед першим run-кроком job-а (release-командою),
+ * якщо його ще нема: checkout із persist-credentials: false (ga-канон; у checkout@v6 це
+ * й дефолт) не лишає токена — release-push мовчки падає.
+ * @param {import('yaml').Document} doc YAML-документ changelog-release.yml
+ * @param {Record<string, unknown>} parsedRoot розпарсений workflow
+ * @param {string} targetJobId job, куди вставляти крок
+ * @returns {boolean} чи було вставлено крок
+ */
+function insertPushAuthStep(doc, parsedRoot, targetJobId) {
+  const allSteps = flattenWorkflowSteps(parsedRoot)
+  const hasPushAuth = allSteps.some(s => {
+    const run = getStepRun(s.step)
+    return run.includes('remote set-url') && run.includes('x-access-token')
+  })
+  if (hasPushAuth) return false
+  const jobSteps = doc.getIn(['jobs', targetJobId, 'steps'])
+  if (!jobSteps?.items) return false
+  const authStep = doc.createNode({
+    name: 'Configure git identity + push auth',
+    run:
+      'git config user.name "github-actions[bot]"\n' +
+      'git config user.email "github-actions[bot]@users.noreply.github.com"\n' +
+      `git remote set-url origin "https://x-access-token:\${{ secrets.GITHUB_TOKEN }}@github.com/\${{ github.repository }}.git"`
+  })
+  const steps = allSteps.filter(s => s.jobId === targetJobId)
+  const firstRunIdx = steps.findIndex(s => getStepRun(s.step) !== '')
+  jobSteps.items.splice(firstRunIdx === -1 ? jobSteps.items.length : firstRunIdx, 0, authStep)
+  return true
+}
+
+/**
+ * Створює `<ws>/.changes/.gitkeep` для кожного Tauri-застосунку — щоб paths-glob
+ * релізного тригера матчив tracked-файл і після того, як реліз спожив change-файли.
+ * @param {string} cwd корінь репо
+ * @returns {Promise<string[]>} абсолютні шляхи створених файлів
+ */
+async function fixChangesGitkeep(cwd) {
+  const apps = await findTauriAppDirs(cwd)
+  const touched = []
+  for (const app of apps) {
+    const rel = app.ws === '.' ? '.changes/.gitkeep' : `${app.ws}/.changes/.gitkeep`
+    const abs = join(cwd, rel)
+    if (existsSync(abs)) continue
+    await mkdir(dirname(abs), { recursive: true })
+    await writeFile(abs, '', 'utf8')
+    touched.push(abs)
+  }
+  return touched
+}
+
+/**
+ * Додає `# zizmor: ignore[cache-poisoning]` до рядків `Swatinem/rust-cache` у release.yml —
+ * текстова трансформація (коментарі не живуть у розпарсеному YAML), idempotent.
+ * @param {string} cwd корінь репо
+ * @returns {Promise<string[]>} абсолютні шляхи змінених файлів (0 чи 1 елемент)
+ */
+async function fixRustCacheZizmorIgnore(cwd) {
+  const path = join(cwd, RELEASE_WORKFLOW)
+  if (!existsSync(path)) return []
+  const raw = await readFile(path, 'utf8')
+  const lines = raw.split('\n')
+  let changed = false
+  const next = lines.map(line => {
+    if (!line.includes('Swatinem/rust-cache') || line.includes('zizmor: ignore[cache-poisoning]')) return line
+    changed = true
+    return `${line.trimEnd()} # zizmor: ignore[cache-poisoning]`
+  })
+  if (!changed) return []
+  await writeFile(path, next.join('\n'), 'utf8')
+  return [path]
+}
+
+/**
+ * Доповнює `release.yml` канонічними ключами (tags, dispatch, крок sync версії перед
+ * `tauri-apps/tauri-action`) — лише якщо файл вже існує й парситься.
+ * @param {string} cwd корінь репо
+ * @returns {Promise<string[]>} абсолютні шляхи змінених файлів (0 чи 1 елемент)
+ */
+async function fixReleaseWorkflow(cwd) {
+  const path = join(cwd, RELEASE_WORKFLOW)
+  if (!existsSync(path)) return []
+  const raw = await readFile(path, 'utf8')
+  const parsedRoot = parseWorkflowYaml(raw)
+  if (!parsedRoot) return []
+
+  const apps = await findTauriAppDirs(cwd)
+  const doc = parseDocument(raw)
+  if (doc.errors?.length) return []
+  let changed = false
+
+  const tags = doc.getIn(['on', 'push', 'tags'])
+  const hasTagTrigger = tags?.toJSON && Array.isArray(tags.toJSON()) && tags.toJSON().includes('v*')
+  if (!hasTagTrigger) {
+    doc.setIn(['on', 'push', 'tags'], doc.createNode([...(Array.isArray(tags?.toJSON()) ? tags.toJSON() : []), 'v*']))
+    changed = true
+  }
+
+  if (!hasWorkflowDispatch(parsedRoot)) {
+    doc.setIn(['on', 'workflow_dispatch'], doc.createNode({}))
+    changed = true
+  }
+
+  const allSteps = flattenWorkflowSteps(parsedRoot)
+  const jobIds = [...new Set(allSteps.map(s => s.jobId))]
+  for (const jobId of jobIds) {
+    const steps = allSteps.filter(s => s.jobId === jobId)
+    const actionIdx = steps.findIndex(s => getStepUses(s.step).startsWith('tauri-apps/tauri-action'))
+    if (actionIdx === -1) continue
+    const syncIdx = steps.findIndex(
+      s => getStepRun(s.step).includes('tauri.conf.json') && VERSION_WORD_RE.test(getStepRun(s.step))
+    )
+    if (syncIdx !== -1 && syncIdx < actionIdx) continue
+
+    const app = apps[0]
+    const tauriConfRel = app ? app.tauriConfPath.slice(cwd.length + 1) : 'src-tauri/tauri.conf.json'
+    const syncStep = doc.createNode({
+      name: 'Sync app version from tag',
+      run: `VER="\${GITHUB_REF_NAME#v}"\nnode -e "const fs=require('fs');const f='${tauriConfRel}';const c=JSON.parse(fs.readFileSync(f));c.version=process.argv[1];fs.writeFileSync(f,JSON.stringify(c,null,2)+'\\n')" "$VER"`
+    })
+    const jobSteps = doc.getIn(['jobs', jobId, 'steps'])
+    if (!jobSteps?.items) continue
+    jobSteps.items.splice(actionIdx, 0, syncStep)
+    changed = true
+  }
+
+  if (!changed) return []
+  await writeFile(path, doc.toString(), 'utf8')
+  return [path]
+}
+
+/** @type {import('../../../scripts/lib/lint-surface/types.mjs').T0Pattern[]} */
+export const patterns = [
+  {
+    id: 'release-tauri-conf-canon',
+    test: violations =>
+      violations.some(v => v.reason === 'updater-artifacts-disabled' || v.reason === 'updater-endpoint-missing'),
+    apply: async (_violations, ctx) => {
+      const touchedFiles = await fixTauriConfFiles(ctx.cwd)
+      for (const f of touchedFiles) ctx.recordWrite?.(f)
+      return touchedFiles.length > 0
+        ? { touchedFiles, message: `tauri.conf.json updater-канон доповнено: ${touchedFiles.length} файл(ів)` }
+        : { touchedFiles: [] }
+    }
+  },
+  {
+    id: 'release-changelog-release-augment',
+    test: violations =>
+      violations.some(v =>
+        [
+          'changelog-release-paths-missing',
+          'changelog-release-no-dispatch',
+          'changelog-release-no-guard',
+          'changelog-release-permissions-missing',
+          'changelog-release-push-auth-missing'
+        ].includes(v.reason)
+      ),
+    apply: async (_violations, ctx) => {
+      const touchedFiles = await fixChangelogReleaseWorkflow(ctx.cwd)
+      for (const f of touchedFiles) ctx.recordWrite?.(f)
+      return touchedFiles.length > 0
+        ? { touchedFiles, message: `${CHANGELOG_RELEASE_WORKFLOW}: канонічні ключі доповнено` }
+        : { touchedFiles: [] }
+    }
+  },
+  {
+    id: 'release-release-workflow-augment',
+    test: violations =>
+      violations.some(v =>
+        [
+          'release-workflow-no-tag-trigger',
+          'release-workflow-no-dispatch',
+          'release-workflow-version-sync-order'
+        ].includes(v.reason)
+      ),
+    apply: async (_violations, ctx) => {
+      const touchedFiles = await fixReleaseWorkflow(ctx.cwd)
+      for (const f of touchedFiles) ctx.recordWrite?.(f)
+      return touchedFiles.length > 0
+        ? { touchedFiles, message: `${RELEASE_WORKFLOW}: канонічні ключі доповнено` }
+        : { touchedFiles: [] }
+    }
+  },
+  {
+    id: 'release-changes-gitkeep',
+    test: violations => violations.some(v => v.reason === 'changes-gitkeep-missing'),
+    apply: async (_violations, ctx) => {
+      const touchedFiles = await fixChangesGitkeep(ctx.cwd)
+      for (const f of touchedFiles) ctx.recordWrite?.(f)
+      return touchedFiles.length > 0
+        ? { touchedFiles, message: `.changes/.gitkeep створено: ${touchedFiles.length} файл(ів)` }
+        : { touchedFiles: [] }
+    }
+  },
+  {
+    id: 'release-rust-cache-zizmor-ignore',
+    test: violations => violations.some(v => v.reason === 'release-workflow-rust-cache-zizmor'),
+    apply: async (_violations, ctx) => {
+      const touchedFiles = await fixRustCacheZizmorIgnore(ctx.cwd)
+      for (const f of touchedFiles) ctx.recordWrite?.(f)
+      return touchedFiles.length > 0
+        ? { touchedFiles, message: `${RELEASE_WORKFLOW}: zizmor ignore[cache-poisoning] на rust-cache` }
+        : { touchedFiles: [] }
+    }
+  }
+]