@7n/rules-ci-azure 1.2.1 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [1.4.0] - 2026-07-18
+
+### Added
+
+- Автоміграція легасі сервіс-pipeline-ів до канону: T0-фікс service_deploy_pipeline переписує `.azurepipelines/**` (job plan, легасі `lint --path` → per-domain `lint_<key>` по файлах піддерева, перешивка dependsOn і Skipped-толерантні condition) через yaml Document API зі збереженням коментарів
+
+## [1.3.0] - 2026-07-18
+
+### Added
+
+- Сервіс-орієнтований CI-канон: концерн azure-pipelines/service_deploy_pipeline — форма per-service pipeline у .azurepipelines/ (plan-гейт `ci plan --azure`, per-domain lint-джоби з dependsOn+condition, термінальні джоби зі Skipped-толерантним condition)
+
 ## [1.2.1] - 2026-07-16
 
 ### Fixed

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@7n/rules-ci-azure",
-  "version": "1.2.1",
-  "description": "\u041f\u043b\u0430\u0433\u0456\u043d @7n/rules: \u043a\u0430\u043d\u043e\u043d Azure Pipelines (azure-pipelines.yml) \u2014 \u0441\u0442\u0440\u0443\u043a\u0442\u0443\u0440\u0430, lint-\u0441\u0442\u0435\u043f, VS Code",
+  "version": "1.4.0",
+  "description": "Плагін @7n/rules: канон Azure Pipelines (azure-pipelines.yml) — структура, lint-степ, VS Code",
   "keywords": [
     "azure-pipelines",
     "ci",
@@ -44,5 +44,8 @@
   "engines": {
     "bun": ">=1.3",
     "node": ">=24"
+  },
+  "dependencies": {
+    "yaml": "^2.9.0"
   }
 }

package/rules/azure-pipelines/main.mdc

@@ -1,11 +1,13 @@
 ---
-description: Канон Azure Pipelines — структура azure-pipelines.yml, обов'язковий lint-степ n-rules, розширення VS Code
-version: '1.0'
-globs: "azure-pipelines.yml"
+description: Канон Azure Pipelines — структура azure-pipelines.yml, обов'язковий lint-степ n-rules, сервіс-орієнтовані deploy-pipelines, розширення VS Code
+version: '1.1'
+globs: "azure-pipelines.yml,.azurepipelines/**/*.yml"
 alwaysApply: false
 ---
 
-Правило **azure-pipelines** (плагін `@7n/rules-ci-azure`) перевіряє канонічну структуру `azure-pipelines.yml` у корені репозиторію та налаштування VS Code для роботи з Azure Pipelines. Аналог правила `ga` (плагін `@7n/rules-ci-github`) для репозиторіїв на Azure DevOps.
+Правило **azure-pipelines** (плагін `@7n/rules-ci-azure`) перевіряє канонічну структуру `azure-pipelines.yml` у корені репозиторію, форму сервіс-орієнтованих deploy-pipelines у `.azurepipelines/` та налаштування VS Code для роботи з Azure Pipelines. Аналог правила `ga` (плагін `@7n/rules-ci-github`) для репозиторіїв на Azure DevOps.
+
+Ролі pipeline-ів: **кореневий `azure-pipelines.yml`** — repo-wide лінт (safety-net `--full`), деплой **не гейтить**; **сервісні pipelines** (`.azurepipelines/**/*.yml` із `trigger.paths.include`) — гейтять деплой свого сервісу через plan → lint/test → deploy (концерн `service_deploy_pipeline`).
 
 - `azure-pipelines.yml`:
 
@@ -67,6 +69,14 @@ Substring-перевірки замість exact-match — Azure YAML допу
 
 Канон: [azure-pipelines-lint.yml.snippet.yml](./lint_pipeline/template/azure-pipelines-lint.yml.snippet.yml)
 
+## Сервіс-орієнтовані deploy-pipelines (`.azurepipelines/**/*.yml`, опційно)
+
+Rego-пакет: `azure_pipelines.service_deploy_pipeline`
+
+**Цільові файли:** `.azurepipelines/**/*.yml` крім `templates/**`; сервісним вважається файл із `trigger.paths.include`.
+
+Форма: джоба `plan` (`bunx n-rules ci plan --path <svc> --azure`, крок з `name: plan`) → паралельні `lint_<domain>`-джоби (`dependsOn: plan`, `condition` по `dependencies.plan.outputs['plan.<domain>']`, `lint <domain> --path <svc> --no-fix`) і `run_tests` → термінальні джоби з dependsOn-ланцюгом на всі перевірки та Skipped-толерантним `condition`. Деталі й template-розкладка: [service_deploy_pipeline.mdc](./service_deploy_pipeline/service_deploy_pipeline.mdc); приклад — [deploy-service-pipeline.yml.snippet.yml](./service_deploy_pipeline/template/deploy-service-pipeline.yml.snippet.yml).
+
 ## `.vscode/extensions.json` — розширення для Azure Pipelines
 
 Rego-пакет: `azure_pipelines.vscode_extensions`

package/rules/azure-pipelines/service_deploy_pipeline/concern.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://unpkg.com/@7n/rules/schemas/concern.json",
+  "fixability": "config",
+  "policy": {
+    "files": {
+      "walkGlob": [".azurepipelines/**/*.yml", "!.azurepipelines/templates/**"]
+    }
+  }
+}

package/rules/azure-pipelines/service_deploy_pipeline/docs/fix-service_deploy_pipeline.md

@@ -0,0 +1,31 @@
+---
+type: JS Module
+title: fix-service_deploy_pipeline.mjs
+resource: plugins/ci-azure/rules/azure-pipelines/service_deploy_pipeline/fix-service_deploy_pipeline.mjs
+docgen:
+  crc: 7841b82d
+  model: openai-codex/gpt-5.4-mini
+  tier: cloud-min
+  score: 100
+  issues: judge:inaccurate:0.99
+  judgeModel: openai-codex/gpt-5.4-mini
+---
+
+## Огляд
+
+Файл існує для автоматичного переведення legacy `.azurepipelines/**.yml` у сервіс-канон ADR 260718-0835: він детерміновано переписує pipeline-и, де `trigger.paths.include` не відповідає формі `plan → lint_<domain> → deploy`, бо `lint --path` у `@7n/rules` 1.17 змінив семантику без major-бампа; `plan` додається через `bunx n-rules ci plan --path <svc> --azure`, а `lint_<key>` визначаються за файлами піддерева сервісу тими самими glob-ами, що й `ci plan`. Міграція зберігає коментарі та незачеплене форматування завдяки мутаціям через YAML Document API (`setIn`/`splice`). Також вона підшиває потрібні `dependsOn` і `condition` для нових lint-джоб і не перезаписує нетривіальний `condition`. Файл працює fail-safe: не кидає винятків назовні й за окремих помилок повертає порожнє значення замість exception.
+
+## Поведінка
+
+- `migratePipelineFile` — Мігрує один `.azurepipelines/**.yml` із `trigger.paths.include` до сервіс-канону: за потреби додає `plan`, замінює legacy `lint`-джоби на per-domain `lint_<key>`, підшиває `dependsOn`/`condition` і `--no-fix`, зберігаючи коментарі та форматування; якщо файл поза скоупом, `null` або міграція не вдається, повертає `false` без винятку назовні.
+- `patterns` — Описує rule-pattern, який знаходить порушені service pipeline-и та застосовує автоматичну міграцію до кожного знайденого файлу; помилки окремих файлів перехоплює, а результатом повертає список змінених файлів і повідомлення про кількість мігрованих pipeline-ів.
+
+## Публічний API
+
+- migratePipelineFile — переносить один pipeline-файл у канонічний формат і сигналізує, чи були зміни.
+- patterns — T0-патерн для fix-конвеєра: розпізнає порушені service pipeline-и й застосовує міграцію.
+
+## Гарантії поведінки
+
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).
+- За певних помилок повертає порожнє значення (напр. `null`) замість винятку.

package/rules/azure-pipelines/service_deploy_pipeline/docs/index.md

@@ -0,0 +1,9 @@
+---
+type: Directory Index
+title: plugins/ci-azure/rules/azure-pipelines/service_deploy_pipeline
+resource: plugins/ci-azure/rules/azure-pipelines/service_deploy_pipeline/
+---
+
+| Файл                                                              | Тип       |
+| ----------------------------------------------------------------- | --------- |
+| [fix-service_deploy_pipeline.mjs](fix-service_deploy_pipeline.md) | JS Module |

package/rules/azure-pipelines/service_deploy_pipeline/fix-service_deploy_pipeline.mjs

@@ -0,0 +1,455 @@
+/**
+ * T0-автоміграція легасі сервіс-pipeline-ів до сервіс-канону (ADR 260718-0835).
+ *
+ * Детермінований переписувач `.azurepipelines/**.yml` із `trigger.paths.include`,
+ * що НЕ відповідають формі plan → lint_<domain> → deploy (порушення rego-концерну
+ * service_deploy_pipeline). Семантика `lint --path` змінилась у `@7n/rules` 1.17
+ * (перетин із git-дельтою) без major-бампа — замість ручної міграції консюмерів
+ * (efes: 18 пайплайнів) фікс переводить pipeline одразу в новий канон:
+ *
+ * - додає job `plan` (prep + `bunx n-rules ci plan --path <svc> --azure`, name: plan);
+ * - легасі job із `n-rules lint --path <svc>` (без домену) замінюється на
+ *   per-domain джоби lint_<key> — домени визначаються по ФАЙЛАХ піддерева сервісу
+ *   тими самими glob-ами, що й `ci plan` (computeActiveDomains/domainKey);
+ * - domain-style lint-джоби добираються wiring-ом (dependsOn: plan, condition по
+ *   outputs, `--no-fix`, fetchDepth: 0);
+ * - dependsOn інших джоб перешивається з легасі-імені на нові lint-джоби; джоби
+ *   з прямими deps на умовні lint-джоби без власного condition отримують
+ *   Skipped-толерантний канон (`not(canceled())` + `in(…, 'Succeeded', 'Skipped')`).
+ *
+ * Мутації — через `yaml` Document API (setIn/splice item-ів), щоб зберегти
+ * коментарі та форматування незачеплених частин. Наявний нетривіальний
+ * `condition` НЕ перезаписується (rego лишає deny → ручне рішення автора).
+ * Template-розкладка (`- template:`) не мігрується — фіксеру не видно
+ * розгорнутих джоб.
+ */
+import { readFileSync, writeFileSync, existsSync, statSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+import { parseDocument } from 'yaml'
+
+import { loadEnabledLintRules, computeActiveDomains } from '@7n/rules/scripts/lib/lint-surface/run-detectors.mjs'
+import { collectPathScopedFiles } from '@7n/rules/scripts/lib/lint-surface/path-scope.mjs'
+import { domainKey } from '@7n/rules/scripts/lib/lint-surface/ci-plan.mjs'
+
+const WS_RE = /\s+/u
+
+/** Канонічні prep-кроки, якщо в pipeline немає власного зразка. */
+const CANONICAL_PREP = [
+  { checkout: 'self', fetchDepth: 0 },
+  {
+    script: 'curl -fsSL https://bun.sh/install | bash\necho "##vso[task.prependpath]$HOME/.bun/bin"\n',
+    displayName: 'Install bun'
+  },
+  { script: 'bun install --frozen-lockfile', displayName: 'Install deps' }
+]
+
+/**
+ * Текст команди кроку (`script:` або `bash:`), '' якщо крок не командний.
+ * @param {unknown} step крок джоби (plain JS)
+ * @returns {string} команда або ''
+ */
+function stepCmd(step) {
+  if (!step || typeof step !== 'object') return ''
+  const s = /** @type {Record<string, unknown>} */ (step)
+  if (typeof s.script === 'string') return s.script
+  if (typeof s.bash === 'string') return s.bash
+  return ''
+}
+
+/**
+ * Розбирає команду `n-rules lint …`/`n-rules ci plan …` токенами (без regex —
+ * стійко до багаторядкових script-ів і без бектрекінгу).
+ * @param {string} cmd повний текст команди кроку
+ * @param {string} marker підрядок-початок (`n-rules lint` | `n-rules ci plan`)
+ * @returns {{ domain: string|null, path: string|null }|null} розбір або null, якщо маркера немає
+ */
+function parseNRulesCmd(cmd, marker) {
+  const at = cmd.indexOf(marker)
+  if (at === -1) return null
+  const tokens = cmd
+    .slice(at + marker.length)
+    .split(WS_RE)
+    .filter(Boolean)
+  let domain = null
+  let path = null
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i]
+    if (t === '--path') {
+      path = tokens[i + 1] ?? null
+      i++
+      continue
+    }
+    if (!t.startsWith('-') && domain === null && path === null) domain = t
+  }
+  return { domain, path }
+}
+
+/**
+ * Prep-кроки для нових джоб: зразок із першої джоби, що робить
+ * `bun install` (кроки від початку до нього включно, checkout → fetchDepth: 0),
+ * інакше — канонічний блок.
+ * @param {Array<Record<string, unknown>>} jobs всі джоби pipeline (plain JS)
+ * @returns {Array<Record<string, unknown>>} prep-кроки (plain JS, глибока копія)
+ */
+function derivePrepSteps(jobs) {
+  for (const job of jobs) {
+    const steps = Array.isArray(job.steps) ? job.steps : []
+    const idx = steps.findIndex(s => stepCmd(s).includes('bun install'))
+    if (idx === -1) continue
+    const prep = structuredClone(steps.slice(0, idx + 1))
+    const checkout = prep.find(s => s && typeof s === 'object' && 'checkout' in s)
+    if (checkout) checkout.fetchDepth = 0
+    else prep.unshift({ checkout: 'self', fetchDepth: 0 })
+    return prep
+  }
+  return structuredClone(CANONICAL_PREP)
+}
+
+/**
+ * Збирає всі jobs-послідовності документа: корінь `jobs` і `stages[i].jobs`.
+ * @param {import('yaml').Document} doc YAML-документ
+ * @returns {Array<{ path: Array<string|number>, items: unknown[] }>} шляхи та plain-JS елементи
+ */
+function collectJobSeqs(doc) {
+  const out = []
+  const js = doc.toJS() ?? {}
+  if (Array.isArray(js.jobs)) out.push({ path: ['jobs'], items: js.jobs })
+  if (Array.isArray(js.stages)) {
+    for (const [i, stage] of js.stages.entries()) {
+      if (stage && Array.isArray(stage.jobs)) out.push({ path: ['stages', i, 'jobs'], items: stage.jobs })
+    }
+  }
+  return out
+}
+
+/**
+ * dependsOn джоби як масив імен.
+ * @param {Record<string, unknown>} job джоба (plain JS)
+ * @returns {string[]} імена залежностей
+ */
+function dependsOf(job) {
+  const d = job.dependsOn
+  if (typeof d === 'string') return [d]
+  if (Array.isArray(d)) return d.filter(x => typeof x === 'string')
+  return []
+}
+
+/**
+ * Канонічний Skipped-толерантний condition для джоби з прямими deps.
+ * @param {string[]} deps імена прямих залежностей
+ * @returns {string} вираз condition
+ */
+function skipTolerantCondition(deps) {
+  const parts = ['not(canceled())']
+  for (const d of deps) {
+    if (d === 'plan') parts.push("eq(dependencies.plan.result, 'Succeeded')")
+    else parts.push(`in(dependencies.${d}.result, 'Succeeded', 'Skipped')`)
+  }
+  return `and(${parts.join(', ')})`
+}
+
+/**
+ * Нова per-domain lint-джоба канону.
+ * @param {string} domain rule-id домену
+ * @param {string} servicePath каталог сервісу
+ * @param {Array<Record<string, unknown>>} prep prep-кроки
+ * @returns {Record<string, unknown>} джоба (plain JS)
+ */
+function buildLintJob(domain, servicePath, prep) {
+  const key = domainKey(domain)
+  return {
+    job: `lint_${key}`,
+    dependsOn: 'plan',
+    condition: `eq(dependencies.plan.outputs['plan.${key}'], 'true')`,
+    steps: [
+      ...structuredClone(prep),
+      { script: `bunx n-rules lint ${domain} --path ${servicePath} --no-fix`, displayName: `Lint ${domain}` }
+    ]
+  }
+}
+
+/**
+ * Релевантні домени сервісу: enabled-правила, чиї per-file glob-и матчать
+ * бодай один файл піддерева (та сама таблиця, що `ci plan` по не-дельті).
+ * @param {string} cwd корінь consumer-репо
+ * @param {string} servicePath каталог сервісу
+ * @returns {Promise<string[]>} відсортовані rule-id
+ */
+async function relevantDomains(cwd, servicePath) {
+  const abs = resolve(cwd, servicePath)
+  if (!existsSync(abs) || !statSync(abs).isDirectory()) return []
+  const files = await collectPathScopedFiles(cwd, servicePath)
+  const { byRule, enabledSet } = await loadEnabledLintRules({ cwd })
+  const active = computeActiveDomains(byRule, enabledSet, files)
+  return active
+    .entries()
+    .filter(([, st]) => st.triggered)
+    .map(([id]) => id)
+    .toArray()
+    .toSorted((a, b) => a.localeCompare(b))
+}
+
+/**
+ * Розбір lint-команди джоби: `{ legacy, domain, path, stepIndex }` або null.
+ * @param {Array<Record<string, unknown>>} steps кроки джоби (plain JS)
+ * @returns {{ legacy: boolean, domain: string|null, path: string|null, stepIndex: number }|null} розбір
+ */
+function findLintStep(steps) {
+  for (const [i, step] of steps.entries()) {
+    const cmd = stepCmd(step)
+    const parsed = parseNRulesCmd(cmd, 'n-rules lint')
+    if (!parsed || parsed.path === null) continue
+    return { legacy: parsed.domain === null, domain: parsed.domain, path: parsed.path, stepIndex: i }
+  }
+  return null
+}
+
+/**
+ * Крок 1: вставляє job `plan` на початок першої jobs-послідовності (якщо немає).
+ * @param {import('yaml').Document} doc документ (мутується)
+ * @param {Array<{ path: Array<string|number> }>} seqs jobs-послідовності
+ * @param {Array<Record<string, unknown>>} prep prep-кроки
+ * @param {string} servicePath каталог сервісу
+ * @returns {boolean} чи були зміни
+ */
+function ensurePlanJob(doc, seqs, prep, servicePath) {
+  const planNode = doc.createNode({
+    job: 'plan',
+    steps: [...structuredClone(prep), { script: `bunx n-rules ci plan --path ${servicePath} --azure`, name: 'plan' }]
+  })
+  doc.getIn(seqs[0].path).items.unshift(planNode)
+  return true
+}
+
+/**
+ * Крок 2: замінює легасі lint-джоби на per-domain джоби у своїх послідовностях.
+ * @param {import('yaml').Document} doc документ (мутується)
+ * @param {Array<{ seq: { path: Array<string|number> }, job: Record<string, unknown> }>} legacy легасі-джоби
+ * @param {string[]} domains релевантні домени сервісу
+ * @param {string} servicePath каталог сервісу
+ * @param {Array<Record<string, unknown>>} prep prep-кроки
+ * @returns {{ renames: Map<string, string[]>, changed: boolean }} мапа перейменувань
+ */
+function replaceLegacyJobs(doc, legacy, domains, servicePath, prep) {
+  /** @type {Map<string, string[]>} */
+  const renames = new Map()
+  let changed = false
+  for (const { seq, job } of legacy) {
+    const newJobs = domains.map(d => buildLintJob(d, servicePath, prep))
+    const seqNode = doc.getIn(seq.path)
+    const docIndex = seqNode.items.findIndex(item => item?.toJS?.(doc)?.job === job.job)
+    if (docIndex === -1) continue
+    seqNode.items.splice(docIndex, 1, ...newJobs.map(j => doc.createNode(j)))
+    renames.set(
+      job.job,
+      newJobs.map(j => /** @type {string} */ (j.job))
+    )
+    changed = true
+  }
+  return { renames, changed }
+}
+
+/**
+ * Крок 3 (одна джоба): добирає wiring domain-style lint-джоби —
+ * dependsOn: plan, condition по outputs, `--no-fix`, fetchDepth: 0.
+ * @param {import('yaml').Document} doc документ (мутується)
+ * @param {Array<string|number>} base шлях джоби в документі
+ * @param {Record<string, unknown>} j джоба (plain JS)
+ * @param {{ domain: string|null, stepIndex: number }} found розбір lint-кроку
+ * @returns {boolean} чи були зміни
+ */
+function patchDomainLintJob(doc, base, j, found) {
+  let changed = false
+  const steps = Array.isArray(j.steps) ? j.steps : []
+  if (dependsOf(j).length === 0) {
+    doc.setIn([...base, 'dependsOn'], 'plan')
+    changed = true
+  }
+  if (typeof j.condition !== 'string' && found.domain) {
+    doc.setIn([...base, 'condition'], `eq(dependencies.plan.outputs['plan.${domainKey(found.domain)}'], 'true')`)
+    changed = true
+  }
+  const cmd = stepCmd(steps[found.stepIndex])
+  if (!cmd.includes('--no-fix')) {
+    const key = typeof steps[found.stepIndex].script === 'string' ? 'script' : 'bash'
+    doc.setIn([...base, 'steps', found.stepIndex, key], `${cmd.trimEnd()} --no-fix`)
+    changed = true
+  }
+  const checkoutIdx = steps.findIndex(s => s && typeof s === 'object' && 'checkout' in s)
+  if (checkoutIdx !== -1 && steps[checkoutIdx].fetchDepth !== 0) {
+    doc.setIn([...base, 'steps', checkoutIdx, 'fetchDepth'], 0)
+    changed = true
+  }
+  return changed
+}
+
+/**
+ * Крок 3 (обхід): знаходить усі domain-style lint-джоби, добирає wiring і
+ * доповнює множину імен lint-джоб.
+ * @param {import('yaml').Document} doc документ (мутується)
+ * @param {Array<{ path: Array<string|number> }>} seqs jobs-послідовності
+ * @param {Set<string>} lintJobNames множина lint-джоб (мутується)
+ * @returns {boolean} чи були зміни
+ */
+function patchDomainLintJobs(doc, seqs, lintJobNames) {
+  let changed = false
+  for (const seq of seqs) {
+    const seqNode = doc.getIn(seq.path)
+    for (const [i, itemNode] of seqNode.items.entries()) {
+      const j = itemNode?.toJS?.(doc)
+      if (!j || typeof j.job !== 'string' || j.job === 'plan') continue
+      const found = findLintStep(Array.isArray(j.steps) ? j.steps : [])
+      if (!found || found.legacy) continue
+      lintJobNames.add(j.job)
+      if (patchDomainLintJob(doc, [...seq.path, i], j, found)) changed = true
+    }
+  }
+  return changed
+}
+
+/**
+ * Крок 4: перешиває dependsOn (легасі-ім'я → нові джоби) і ставить
+ * Skipped-толерантний condition джобам із прямими deps на умовні lint-джоби
+ * (лише коли власного condition немає — нетривіальний не перезаписуємо).
+ * @param {import('yaml').Document} doc документ (мутується)
+ * @param {Array<{ path: Array<string|number> }>} seqs jobs-послідовності
+ * @param {Map<string, string[]>} renames легасі-ім'я → нові lint-джоби
+ * @param {Set<string>} lintJobNames множина всіх lint-джоб
+ * @returns {boolean} чи були зміни
+ */
+function rewireDependents(doc, seqs, renames, lintJobNames) {
+  let changed = false
+  for (const seq of seqs) {
+    const seqNode = doc.getIn(seq.path)
+    for (const [i, itemNode] of seqNode.items.entries()) {
+      const j = itemNode?.toJS?.(doc)
+      if (!j || typeof j.job !== 'string' || j.job === 'plan' || lintJobNames.has(j.job)) continue
+      if (rewireOneJob(doc, [...seq.path, i], j, renames, lintJobNames)) changed = true
+    }
+  }
+  return changed
+}
+
+/**
+ * Крок 4 (одна джоба): перешивка dependsOn і Skipped-толерантний condition.
+ * @param {import('yaml').Document} doc документ (мутується)
+ * @param {Array<string|number>} base шлях джоби в документі
+ * @param {Record<string, unknown>} j джоба (plain JS)
+ * @param {Map<string, string[]>} renames легасі-ім'я → нові lint-джоби
+ * @param {Set<string>} lintJobNames множина всіх lint-джоб
+ * @returns {boolean} чи були зміни
+ */
+function rewireOneJob(doc, base, j, renames, lintJobNames) {
+  let deps = dependsOf(j)
+  if (deps.length === 0) return false
+  let changed = false
+  const expanded = deps.flatMap(d => renames.get(d) ?? [d])
+  if (JSON.stringify(expanded) !== JSON.stringify(deps)) {
+    doc.setIn([...base, 'dependsOn'], doc.createNode(expanded))
+    deps = expanded
+    changed = true
+  }
+  const touchesLint = deps.some(d => lintJobNames.has(d))
+  if (touchesLint && typeof j.condition !== 'string') {
+    const withPlan = deps.includes('plan') ? deps : ['plan', ...deps]
+    if (!deps.includes('plan')) doc.setIn([...base, 'dependsOn'], doc.createNode(withPlan))
+    doc.setIn([...base, 'condition'], skipTolerantCondition(withPlan))
+    changed = true
+  }
+  return changed
+}
+
+/**
+ * Аналіз pipeline перед міграцією: послідовності джоб, легасі lint-джоби,
+ * plan-джоба і сервісний каталог. `null` — файл поза скоупом міграції
+ * (без paths-тригера, template-розкладка, немає сервісного каталогу).
+ * @param {import('yaml').Document} doc розпарсений документ
+ * @returns {{ seqs: Array<{ path: Array<string|number>, items: unknown[] }>, allJobs: Array<Record<string, unknown>>, planJob: Record<string, unknown>|undefined, legacy: Array<{ seq: object, job: Record<string, unknown>, path: string|null }>, servicePath: string }|null} аналіз
+ */
+function analyzePipeline(doc) {
+  const js = doc.toJS() ?? {}
+  const servicePaths = js?.trigger?.paths?.include
+  if (!Array.isArray(servicePaths) || servicePaths.length === 0) return null
+
+  const seqs = collectJobSeqs(doc)
+  const allJobs = seqs.flatMap(s => s.items).filter(j => j && typeof j === 'object' && typeof j.job === 'string')
+  if (allJobs.length === 0) return null // template-розкладка — не мігруємо
+
+  const planJob = allJobs.find(j => j.job === 'plan')
+  const legacy = seqs.flatMap(seq =>
+    seq.items
+      .filter(j => j && typeof j === 'object' && typeof j.job === 'string' && j.job !== 'plan')
+      .map(j => ({ seq, job: j, found: findLintStep(Array.isArray(j.steps) ? j.steps : []) }))
+      .filter(x => x.found?.legacy)
+      .map(x => ({ seq: x.seq, job: x.job, path: x.found.path }))
+  )
+
+  // Сервісний каталог: із plan-джоби → з легасі lint-джоби → перший paths.include.
+  const planPath = (Array.isArray(planJob?.steps) ? planJob.steps : [])
+    .map(s => parseNRulesCmd(stepCmd(s), 'n-rules ci plan')?.path)
+    .find(Boolean)
+  const servicePath = planPath ?? legacy[0]?.path ?? servicePaths.find(p => typeof p === 'string')
+  if (typeof servicePath !== 'string') return null
+
+  return { seqs, allJobs, planJob, legacy, servicePath }
+}
+
+/**
+ * Мігрує один pipeline-файл до канону. Повертає true, якщо файл змінено.
+ * @param {string} absPath абсолютний шлях pipeline-файлу
+ * @param {string} cwd корінь consumer-репо
+ * @returns {Promise<boolean>} чи були зміни
+ */
+export async function migratePipelineFile(absPath, cwd) {
+  const prevText = readFileSync(absPath, 'utf8')
+  let doc
+  try {
+    doc = parseDocument(prevText)
+  } catch {
+    return false
+  }
+  const analyzed = analyzePipeline(doc)
+  if (!analyzed) return false
+  const { seqs, allJobs, planJob, legacy, servicePath } = analyzed
+
+  const prep = derivePrepSteps(allJobs)
+  const domains = await relevantDomains(cwd, servicePath)
+  let changed = false
+
+  if (!planJob) changed = ensurePlanJob(doc, seqs, prep, servicePath) || changed
+  const { renames, changed: legacyChanged } = replaceLegacyJobs(doc, legacy, domains, servicePath, prep)
+  changed = legacyChanged || changed
+
+  const lintJobNames = new Set(renames.values().toArray().flat())
+  changed = patchDomainLintJobs(doc, seqs, lintJobNames) || changed
+  changed = rewireDependents(doc, seqs, renames, lintJobNames) || changed
+
+  if (!changed) return false
+  writeFileSync(absPath, doc.toString())
+  return true
+}
+
+export const patterns = [
+  {
+    id: 'azure-service-pipeline-canon-migrate',
+    test: violations => violations.length > 0,
+    async apply(violations, ctx) {
+      const files = [...new Set(violations.map(v => v.file).filter(Boolean))]
+      const touched = []
+      for (const rel of files) {
+        const abs = join(ctx.cwd, rel)
+        if (!existsSync(abs)) continue
+        try {
+          if (await migratePipelineFile(abs, ctx.cwd)) touched.push(abs)
+        } catch {
+          // міграція конкретного файлу не вдалася — лишаємо deny детектору (fail-open до ручного фіксу)
+        }
+      }
+      return {
+        touchedFiles: touched,
+        message: touched.length > 0 ? `мігровано до сервіс-канону: ${touched.length} pipeline(ів)` : null
+      }
+    }
+  }
+]

package/rules/azure-pipelines/service_deploy_pipeline/service_deploy_pipeline.mdc

@@ -0,0 +1,21 @@
+## Rego-gate сервіс-орієнтованих deploy-pipeline (`.azurepipelines/**/*.yml`)
+
+Rego-пакет: `azure_pipelines.service_deploy_pipeline`
+
+Цільові файли: усі `.azurepipelines/**/*.yml`, крім `templates/**` (walkGlob). Дискримінатор — **`trigger.paths.include`**: файл із paths-фільтром вважається сервісним pipeline і мусить відповідати формі; без нього — концерн мовчить. Кореневий `azure-pipelines.yml` (repo-wide лінт, канон `pipeline_common`) поза глобом — він деплой не гейтить.
+
+Канонічна форма per-service pipeline (каталог сервісу — напр. `run/nexus`):
+
+1. **Тригер** — `trigger.paths.include` з каталогом сервісу.
+2. **`plan`-джоба** — `checkout: self` із `fetchDepth: 0` → prep (install bun + `bun install --frozen-lockfile`) → крок `bunx n-rules ci plan --path run/<service> --azure` **з `name: plan`** (downstream читає `dependencies.plan.outputs['plan.<domain>']`).
+3. **`lint_<domain>`-джоби** (паралельно) — `dependsOn: plan`, `condition: eq(dependencies.plan.outputs['plan.<domain>'], 'true')` (ключ = домен із `-`→`_`), крок `bunx n-rules lint <domain> --path run/<service> --no-fix` з `--path` ∈ `trigger.paths.include`, prep у кожній джобі (джоби не шарять ФС).
+4. **`run_tests`** — `dependsOn: plan`, `condition` по `plan.any`; тести лише сервісу (python-стек — uv: `curl … astral.sh/uv/install.sh | sh` + `uv sync --locked`).
+5. **Термінальні джоби** (`build_and_push`/`deploy_*`) — dependsOn-ланцюг **транзитивно досягає** `plan` і всі перевірки; джоба з `dependsOn` на умовні lint-джоби має `condition` з `not(canceled())` та `in(dependencies.<j>.result, 'Succeeded', 'Skipped')` — skipped-лінт не блокує деплой, failed — блокує.
+
+**Template-розкладка** (efes-стиль `- template:` з параметром-каталогом): законна, rego тоді перевіряє лише видиме у файлі — що параметр template-посилання дорівнює одному з `paths.include`; повнота графа всередині шаблону — відповідальність автора за цим каноном (rego не бачить розгорнутий YAML).
+
+**Автоміграція (T0-фікс, `n-rules lint` у fix-режимі):** легасі сервіс-pipeline (inline-джоби, `n-rules lint --path <svc>` без домену) детерміновано переписується до канону — додається job `plan`, легасі lint-джоба замінюється на per-domain `lint_<key>` (домени — по файлах піддерева сервісу, ті самі glob-и, що в `ci plan`), `dependsOn` залежних джоб перешивається, джоби з прямими deps на умовні lint-джоби без власного `condition` отримують Skipped-толерантний канон. Нетривіальний наявний `condition` НЕ перезаписується; template-розкладка не мігрується.
+
+Що НЕ перевіряється: добір доменів під вміст сервісу, зміст test/deploy-кроків, uv-prep, шаблони в `templates/**`.
+
+Канон-snippet (документаційний приклад): [deploy-service-pipeline.yml.snippet.yml](./template/deploy-service-pipeline.yml.snippet.yml)

package/rules/azure-pipelines/service_deploy_pipeline/service_deploy_pipeline.rego

@@ -0,0 +1,281 @@
+# Форма сервіс-орієнтованого deploy-pipeline (`.azurepipelines/**/*.yml`,
+# крім `templates/**`). Дзеркало ga.service_deploy_workflow для Azure Pipelines.
+#
+# Дискримінатор застосовності — НЕ імʼя файлу, а `trigger.paths.include`:
+# файл із paths-фільтром = сервісний pipeline і мусить відповідати формі;
+# файл без нього (repo-wide) — жодних deny. Кореневий azure-pipelines.yml
+# поза walkGlob узагалі (канон pipeline_common).
+#
+# Канон (azure-pipelines.mdc, сніпет template/deploy-service-pipeline.yml.snippet.yml):
+#   plan (checkout fetchDepth:0 + bun install + `bunx n-rules ci plan --path <svc> --azure`,
+#         крок з `name: plan`)
+#     ├─ lint_<domain> × N  (dependsOn: plan; condition по dependencies.plan.outputs['plan.<domain>'];
+#     │                      `bunx n-rules lint <domain> --path <svc> --no-fix`)
+#     ├─ run_tests          (dependsOn: plan)
+#     └─ build_and_push/deploy (dependsOn-ланцюг досягає plan і всі перевірки;
+#                               condition: not(canceled()) + 'Skipped'-толерантність)
+#
+# Template-розкладка (`- template:` з параметром-каталогом) законна: rego тоді
+# перевіряє лише видиме у файлі — наявність template-посилання з параметром,
+# що дорівнює одному з paths.include; повна перевірка графа — .mdc-канон.
+package azure_pipelines.service_deploy_pipeline
+
+import rego.v1
+
+# ── extraction ──────────────────────────────────────────────────────────
+
+service_paths contains p if {
+	some p in input.trigger.paths.include
+	is_string(p)
+}
+
+is_service_pipeline if count(service_paths) > 0
+
+# Джоби на будь-якій глибині (root jobs / stages→jobs).
+all_jobs contains j if {
+	walk(input, [_, j])
+	is_object(j)
+	is_string(object.get(j, "job", 0))
+}
+
+# `- template:`-посилання з параметрами (efes-стиль modulePath).
+template_refs contains t if {
+	walk(input, [_, t])
+	is_object(t)
+	is_string(object.get(t, "template", 0))
+}
+
+template_covers_service if {
+	some t in template_refs
+	some v in object.get(t, "parameters", {})
+	v in service_paths
+}
+
+plan_jobs contains j if {
+	some j in all_jobs
+	j.job == "plan"
+}
+
+plan_runs contains r if {
+	some j in plan_jobs
+	some r in job_cmds(j)
+	contains(r, "n-rules ci plan")
+}
+
+# Lint-джоби (`n-rules lint <domain> … --path …`) з розібраною командою.
+lint_cmds contains cmd if {
+	some j in all_jobs
+	j.job != "plan"
+	some r in job_cmds(j)
+	m := regex.find_all_string_submatch_n(`n-rules lint\s+([a-z0-9-]+)\s+[^\n]*--path\s+(\S+)`, r, 1)
+	count(m) > 0
+	cmd := {"job": j.job, "spec": j, "domain": m[0][1], "path": m[0][2], "run": r}
+}
+
+check_jobs contains cmd.job if some cmd in lint_cmds
+
+# Граф dependsOn і транзитивна досяжність (ланцюг deploy → build → перевірки).
+needs_graph[name] := depends_of(j) if {
+	some j in all_jobs
+	name := j.job
+}
+
+all_needed contains n if {
+	some j in all_jobs
+	some n in depends_of(j)
+}
+
+terminal_jobs contains j.job if {
+	some j in all_jobs
+	j.job != "plan"
+	not j.job in check_jobs
+	not j.job in all_needed
+}
+
+job_by_name[name] := j if {
+	some j in all_jobs
+	name := j.job
+}
+
+# ── deny: plan-джоба ────────────────────────────────────────────────────
+
+deny contains msg if {
+	is_service_pipeline
+	count(all_jobs) > 0
+	count(plan_jobs) == 0
+	not template_covers_service
+	msg := "service-pipeline: немає job `plan` з кроком `bunx n-rules ci plan --path <svc> --azure` (azure-pipelines.mdc: сервіс-канон)"
+}
+
+deny contains msg if {
+	is_service_pipeline
+	count(all_jobs) == 0
+	count(template_refs) > 0
+	not template_covers_service
+	msg := "service-pipeline: `- template:` без параметра-каталогу з trigger.paths.include — гейт не привʼязаний до сервісу (azure-pipelines.mdc)"
+}
+
+deny contains msg if {
+	msg := "service-pipeline: job `plan` без кроку `bunx n-rules ci plan …` (azure-pipelines.mdc: сервіс-канон)"
+	is_service_pipeline
+	some j in plan_jobs
+	count([r | some r in job_cmds(j); contains(r, "n-rules ci plan")]) == 0
+}
+
+deny contains msg if {
+	msg := "service-pipeline: `ci plan` без `--azure` — outputs не стануть змінними джоби (azure-pipelines.mdc)"
+	is_service_pipeline
+	some r in plan_runs
+	not contains(r, "--azure")
+}
+
+deny contains msg if {
+	is_service_pipeline
+	some r in plan_runs
+	m := regex.find_all_string_submatch_n(`n-rules ci plan\s+--path\s+(\S+)`, r, 1)
+	count(m) > 0
+	not m[0][1] in service_paths
+	msg := sprintf("service-pipeline: `ci plan --path %s` ∉ trigger.paths.include — план рахується не для того каталогу (azure-pipelines.mdc)", [m[0][1]])
+}
+
+# Outputs адресуються як dependencies.plan.outputs['plan.<key>'] — крок мусить мати name: plan.
+deny contains msg if {
+	msg := "service-pipeline: крок `ci plan` без `name: plan` — downstream-condition не знайде outputs (azure-pipelines.mdc)"
+	is_service_pipeline
+	some j in plan_jobs
+	count([s | some s in object.get(j, "steps", []); contains(step_cmd(s), "n-rules ci plan"); s.name == "plan"]) == 0
+}
+
+# ── deny: lint-джоби ────────────────────────────────────────────────────
+
+deny contains msg if {
+	is_service_pipeline
+	some cmd in lint_cmds
+	not "plan" in depends_of(cmd.spec)
+	msg := sprintf("%s: lint-джоба мусить мати dependsOn: plan (azure-pipelines.mdc: сервіс-канон)", [cmd.job])
+}
+
+deny contains msg if {
+	is_service_pipeline
+	some cmd in lint_cmds
+	cond := object.get(cmd.spec, "condition", "")
+	not contains(cond, sprintf("dependencies.plan.outputs['plan.%s']", [replace(cmd.domain, "-", "_")]))
+	msg := sprintf("%s: lint-джоба без condition по dependencies.plan.outputs['plan.%s'] — крок не скіпатиметься (azure-pipelines.mdc)", [cmd.job, replace(cmd.domain, "-", "_")])
+}
+
+deny contains msg if {
+	is_service_pipeline
+	some cmd in lint_cmds
+	not cmd.path in service_paths
+	msg := sprintf("%s: `lint %s --path %s` ∉ trigger.paths.include — лінтиться інший каталог (azure-pipelines.mdc)", [cmd.job, cmd.domain, cmd.path])
+}
+
+deny contains msg if {
+	is_service_pipeline
+	some cmd in lint_cmds
+	not contains(cmd.run, "--no-fix")
+	msg := sprintf("%s: `n-rules lint` у CI мусить мати `--no-fix` (azure-pipelines.mdc)", [cmd.job])
+}
+
+deny contains msg if {
+	is_service_pipeline
+	some cmd in lint_cmds
+	not job_has_prep(cmd.spec)
+	msg := sprintf("%s: lint-джоба без prep-кроку `bun install --frozen-lockfile` (джоби не шарять ФС) (azure-pipelines.mdc)", [cmd.job])
+}
+
+# ── deny: fetchDepth для git-дельти ─────────────────────────────────────
+
+deny contains msg if {
+	msg := "plan: checkout мусить мати fetchDepth: 0 — без історії git-дельта `ci plan` не рахується (azure-pipelines.mdc)"
+	is_service_pipeline
+	some j in plan_jobs
+	count([r | some r in job_cmds(j); contains(r, "n-rules ci plan")]) > 0
+	not job_has_full_checkout(j)
+}
+
+deny contains msg if {
+	is_service_pipeline
+	some cmd in lint_cmds
+	not job_has_full_checkout(cmd.spec)
+	msg := sprintf("%s: checkout мусить мати fetchDepth: 0 — без історії `lint --path` не бачить дельти (azure-pipelines.mdc)", [cmd.job])
+}
+
+# ── deny: термінальні (deploy) джоби ────────────────────────────────────
+
+deny contains msg if {
+	is_service_pipeline
+	count(check_jobs) > 0
+	some name in terminal_jobs
+	not "plan" in graph.reachable(needs_graph, {name})
+	msg := sprintf("%s: термінальна джоба не досягає `plan` через dependsOn-ланцюг (azure-pipelines.mdc: сервіс-канон)", [name])
+}
+
+deny contains msg if {
+	is_service_pipeline
+	some name in terminal_jobs
+	some cj in check_jobs
+	not cj in graph.reachable(needs_graph, {name})
+	msg := sprintf("%s: термінальна джоба не досягає перевірки `%s` через dependsOn-ланцюг — деплой не гейтиться нею (azure-pipelines.mdc)", [name, cj])
+}
+
+# Skipped-лінт (умовний гейт спрацював) не мусить блокувати деплой, fail — мусить:
+# канон `and(not(canceled()), in(dependencies.<j>.result, 'Succeeded', 'Skipped'), …)`.
+deny contains msg if {
+	is_service_pipeline
+	some name in terminal_jobs
+	needed := depends_of(job_by_name[name])
+	count([cj | some cj in check_jobs; cj in needed]) > 0
+	cond := object.get(job_by_name[name], "condition", "")
+	not skip_tolerant(cond)
+	msg := sprintf("%s: джоба з dependsOn на умовні lint-джоби мусить мати condition із not(canceled()) і 'Skipped'-толерантністю — інакше skipped-лінт назавжди блокує деплой (azure-pipelines.mdc)", [name])
+}
+
+# ── helpers ─────────────────────────────────────────────────────────────
+
+# dependsOn: string | array → array.
+depends_of(job) := [n] if {
+	n := object.get(job, "dependsOn", [])
+	is_string(n)
+}
+
+depends_of(job) := object.get(job, "dependsOn", []) if is_array(object.get(job, "dependsOn", []))
+
+# Команда кроку: `script:` або `bash:`.
+step_cmd(step) := s if {
+	s := object.get(step, "script", "")
+	s != ""
+}
+
+step_cmd(step) := s if {
+	object.get(step, "script", "") == ""
+	s := object.get(step, "bash", "")
+	s != ""
+}
+
+step_cmd(step) := "" if {
+	object.get(step, "script", "") == ""
+	object.get(step, "bash", "") == ""
+}
+
+job_cmds(job) := [c |
+	some step in object.get(job, "steps", [])
+	c := step_cmd(step)
+	c != ""
+]
+
+job_has_prep(job) if {
+	some c in job_cmds(job)
+	contains(c, "bun install --frozen-lockfile")
+}
+
+job_has_full_checkout(job) if {
+	some step in object.get(job, "steps", [])
+	object.get(step, "checkout", "") != ""
+	step.fetchDepth == 0
+}
+
+skip_tolerant(cond) if {
+	contains(cond, "not(canceled())")
+	contains(cond, "'Skipped'")
+}

package/rules/azure-pipelines/service_deploy_pipeline/template/deploy-service-pipeline.yml.snippet.yml

@@ -0,0 +1,77 @@
+# Документаційний приклад сервіс-орієнтованого deploy-pipeline (azure-pipelines.mdc).
+# Це НЕ deep-subset-канон (перелік сервісів консюмер-специфічний) — форму
+# перевіряє service_deploy_pipeline.rego по всіх `.azurepipelines/**/*.yml`
+# з trigger.paths.include. Плейсхолдер run/<service> заміни на каталог сервісу.
+trigger:
+  branches:
+    include:
+      - dev
+      - main
+  paths:
+    include:
+      - run/<service>
+
+pool:
+  vmImage: ubuntu-latest
+
+jobs:
+  - job: plan
+    steps:
+      - checkout: self
+        fetchDepth: 0
+      - script: |
+          curl -fsSL https://bun.sh/install | bash
+          echo "##vso[task.prependpath]$HOME/.bun/bin"
+        displayName: Install bun
+      - script: bun install --frozen-lockfile
+        displayName: Install deps
+      - script: bunx n-rules ci plan --path run/<service> --azure
+        name: plan # ОБОВʼЯЗКОВО: outputs адресуються як dependencies.plan.outputs['plan.<domain>']
+
+  - job: lint_js
+    dependsOn: plan
+    condition: eq(dependencies.plan.outputs['plan.js'], 'true')
+    steps:
+      - checkout: self
+        fetchDepth: 0
+      - script: |
+          curl -fsSL https://bun.sh/install | bash
+          echo "##vso[task.prependpath]$HOME/.bun/bin"
+        displayName: Install bun
+      - script: bun install --frozen-lockfile
+        displayName: Install deps
+      - script: bunx n-rules lint js --path run/<service> --no-fix
+        displayName: Lint js
+
+  # …lint_<domain> для кожного домену сервісу (python/docker/k8s/security/…)
+  # python-стек: перед тестами ще uv (curl -LsSf https://astral.sh/uv/install.sh | sh + uv sync --locked)
+
+  - job: run_tests
+    dependsOn: plan
+    condition: eq(dependencies.plan.outputs['plan.any'], 'true')
+    steps:
+      - checkout: self
+        fetchDepth: 0
+      - script: |
+          curl -fsSL https://bun.sh/install | bash
+          echo "##vso[task.prependpath]$HOME/.bun/bin"
+        displayName: Install bun
+      - script: bun install --frozen-lockfile
+        displayName: Install deps
+      - script: bun test run/<service>
+        displayName: Tests
+
+  - job: build_and_push
+    dependsOn:
+      - plan
+      - lint_js
+      - run_tests
+    # Skipped-лінт (гейт ci plan) НЕ блокує деплой; failed — блокує.
+    condition: >-
+      and(not(canceled()),
+          eq(dependencies.plan.result, 'Succeeded'),
+          in(dependencies.lint_js.result, 'Succeeded', 'Skipped'),
+          in(dependencies.run_tests.result, 'Succeeded', 'Skipped'))
+    steps:
+      - checkout: self
+      # …кроки build/push/deploy сервісу