@nitra/cursor 12.0.3 → 12.2.0

package/scripts/lib/fix/llm-worker.mjs

@@ -7,10 +7,10 @@ import { resolveModel } from '../../../lib/models.mjs'
 import { callLlm } from '../../../lib/llm.mjs'
 import { applyChanges, parseChangesResponse, readFilesForFix } from './llm-fix-apply.mjs'
 
-// Тир за замовчуванням: min → avg при ескалації (каскад local→cloud).
-// Перевизначення через N_CURSOR_FIX_MODEL / N_CURSOR_FIX_MODEL_HEAVY.
-export const MODEL = env.N_CURSOR_FIX_MODEL ?? resolveModel('min')
-export const MODEL_HEAVY = env.N_CURSOR_FIX_MODEL_HEAVY ?? resolveModel('avg')
+// Дефолтна модель, коли викликач не задав `opts.model` (legacy/прямі виклики).
+// Драбина ескалації (`orchestrator.mjs`) завжди передає модель рунга явно, тож
+// тут лишається тільки fallback на min-тир. Перевизначення — `N_CURSOR_FIX_MODEL`.
+const MODEL = env.N_CURSOR_FIX_MODEL ?? resolveModel('min')
 
 const API_KEY_RE = /api key/i
 
@@ -49,13 +49,36 @@ function extractFilePaths(output) {
 
 /**
  * Будує prompt для pi: правило + порушення + поточний вміст файлів.
+ * Будує опційний feedback-блок драбини ескалації: попередній рунг застосував
+ * зміни, але re-check лишився червоним. Просимо модель спершу (в полі `diagnosis`)
+ * сформулювати, **чому** попередня спроба не задовольнила правило, тоді виправити.
+ * @param {{ previousModel?: string, previousChanges?: Array<{path:string}>, previousError?: string|null } | null} feedback контекст попереднього рунга
+ * @returns {string[]} рядки prompt-блоку (порожній масив, якщо feedback немає)
+ */
+function buildFeedbackBlock(feedback) {
+  if (!feedback) return []
+  const changedPaths = (feedback.previousChanges ?? []).map(c => c.path).filter(Boolean)
+  return [
+    ``,
+    `A PREVIOUS attempt (model: ${feedback.previousModel || 'pi'}) did NOT resolve this violation.`,
+    changedPaths.length > 0
+      ? `Previously changed files: ${changedPaths.join(', ')}`
+      : `The previous attempt produced no usable changes.`,
+    feedback.previousError ? `Previous attempt error: ${feedback.previousError}` : ``,
+    `The violation output below is what STILL fails after that attempt.`,
+    `In the "diagnosis" field, briefly state WHY the previous attempt failed, then provide a corrected fix.`
+  ].filter(line => line !== ``)
+}
+
+/**
  * @param {string} ruleId ID правила
  * @param {string} ruleMdc   вміст .mdc-файлу правила
  * @param {string} output    violation output
  * @param {Array<{path:string, content:string}>} files прочитані файли (path + content)
+ * @param {{ previousModel?: string, previousChanges?: Array<{path:string}>, previousError?: string|null } | null} [feedback] контекст попереднього рунга драбини (для retry-with-feedback)
  * @returns {string} текст промпта для pi
  */
-function buildPrompt(ruleId, ruleMdc, output, files) {
+function buildPrompt(ruleId, ruleMdc, output, files, feedback = null) {
   const filesBlock =
     files.length === 0
       ? '(no files identified)'
@@ -63,6 +86,7 @@ function buildPrompt(ruleId, ruleMdc, output, files) {
 
   return [
     `You fix project structure violations. Return ONLY valid JSON — no explanation, no markdown.`,
+    ...buildFeedbackBlock(feedback),
     ``,
     `Rule (n-${ruleId}.mdc):`,
     `---`,
@@ -76,13 +100,14 @@ function buildPrompt(ruleId, ruleMdc, output, files) {
     filesBlock,
     ``,
     `Return JSON with this exact shape:`,
-    `{"changes":[{"path":"relative/path/to/file","content":"full corrected file content"}]}`,
+    `{"diagnosis":"short reason the rule fails (or why prior attempt failed); empty string if first attempt","changes":[{"path":"relative/path/to/file","content":"full corrected file content"}]}`,
     ``,
     `Rules:`,
     `- "path" is relative to the project root`,
     `- "content" is the complete new file content (not a diff)`,
     `- Only include files that actually need to change`,
-    `- If nothing can be fixed automatically, return {"changes":[],"error":"reason"}`
+    `- "diagnosis" is plain text inside the JSON — do NOT emit prose outside the JSON`,
+    `- If nothing can be fixed automatically, return {"diagnosis":"...","changes":[],"error":"reason"}`
   ].join('\n')
 }
 
@@ -91,11 +116,12 @@ function buildPrompt(ruleId, ruleMdc, output, files) {
  * Зберігає дружнє повідомлення про відсутній API-ключ для хмарних провайдерів.
  * @param {string} prompt текст промпта
  * @param {string} model назва моделі (provider/id, `omlx/...` або '')
+ * @param {string} caller мітка викликача для wire-trace (`fix:<rule>:<rung>`)
  * @returns {{ text: string, error?: string }} текст відповіді або повідомлення про помилку
  */
-function callModel(prompt, model) {
+function callModel(prompt, model, caller) {
   try {
-    return { text: callLlm([{ role: 'user', content: prompt }], model, { timeoutMs: 120_000, caller: 'fix' }) }
+    return { text: callLlm([{ role: 'user', content: prompt }], model, { timeoutMs: 120_000, caller }) }
   } catch (error) {
     const msg = String(error.message)
     if (API_KEY_RE.test(msg)) {
@@ -115,14 +141,21 @@ function callModel(prompt, model) {
 
 /**
  * LLM-worker: виправляє одне rule-порушення через pi (C1 pattern).
+ * Повертає `changes`/`diagnosis` навіть при невдачі — драбина ескалації
+ * (`orchestrator.mjs`) логує їх і прокидає як feedback у наступний рунг.
  * @param {string} ruleId ID правила
  * @param {string} violationOutput  output з fix check для цього rule
  * @param {string} projectRoot      абсолютний шлях до кореня проєкту
- * @param {{ model?: string }} opts опції (model — перевизначення моделі)
- * @returns {Promise<{ ok: boolean, error?: string }>} статус виправлення і можлива помилка
+ * @param {{ model?: string, feedback?: object|null, caller?: string }} opts опції:
+ *   `model` — перевизначення моделі; `feedback` — контекст попереднього рунга
+ *   драбини (retry-with-feedback); `caller` — мітка для wire-trace
+ * @returns {{ ok: boolean, error?: string, changes: Array<{path:string}>, diagnosis: string|null }}
+ *   статус виправлення, помилка, запропоновані зміни і само-аналіз моделі
  */
 export function runLlmWorker(ruleId, violationOutput, projectRoot, opts = {}) {
   const model = opts.model ?? MODEL
+  const feedback = opts.feedback ?? null
+  const caller = opts.caller ?? 'fix'
 
   // 1. Читаємо rule .mdc
   const mdcPath = join(projectRoot, '.cursor', 'rules', `n-${ruleId}.mdc`)
@@ -132,20 +165,23 @@ export function runLlmWorker(ruleId, violationOutput, projectRoot, opts = {}) {
   const files = readFilesForFix(extractFilePaths(violationOutput), projectRoot)
 
   // 3. Будуємо prompt і викликаємо модель
-  const prompt = buildPrompt(ruleId, ruleMdc, violationOutput, files)
-  const { text, error: modelError } = callModel(prompt, model)
+  const prompt = buildPrompt(ruleId, ruleMdc, violationOutput, files, feedback)
+  const { text, error: modelError } = callModel(prompt, model, caller)
 
-  if (modelError) return { ok: false, error: modelError }
-  if (!text) return { ok: false, error: 'model returned empty response' }
+  if (modelError) return { ok: false, error: modelError, changes: [], diagnosis: null }
+  if (!text) return { ok: false, error: 'model returned empty response', changes: [], diagnosis: null }
 
   // 4. Парсимо відповідь
   const parsed = parseChangesResponse(text)
-  if (!parsed) return { ok: false, error: `cannot parse pi response: ${text.slice(0, 200)}` }
-  if (parsed.error) return { ok: false, error: parsed.error }
-
+  if (!parsed) {
+    return { ok: false, error: `cannot parse pi response: ${text.slice(0, 200)}`, changes: [], diagnosis: null }
+  }
+  const diagnosis = typeof parsed.diagnosis === 'string' && parsed.diagnosis ? parsed.diagnosis : null
   const changes = parsed.changes ?? []
-  if (changes.length === 0) return { ok: false, error: 'pi returned no changes' }
+  if (parsed.error) return { ok: false, error: parsed.error, changes, diagnosis }
+  if (changes.length === 0) return { ok: false, error: 'pi returned no changes', changes, diagnosis }
 
   // 5. Застосовуємо зміни
-  return applyChanges(changes, projectRoot)
+  const applied = applyChanges(changes, projectRoot)
+  return { ...applied, changes, diagnosis }
 }

package/scripts/lib/fix/orchestrator.mjs

@@ -2,22 +2,137 @@
 
 import { runFixCheck } from './run-fix-check.mjs'
 import { runT0AutoCli } from './t0.mjs'
+import { logEscalation } from './escalation-log.mjs'
+import { runLlmWorker } from './llm-worker.mjs'
+import { classifyOmlxError } from '../../../lib/llm.mjs'
+import { CLOUD_AVG, CLOUD_MIN, LOCAL_MIN } from '../../../lib/models.mjs'
 
-const DEFAULT_MAX_ITER = 3
-const ESCALATE_AFTER = 2
+/**
+ * Дефолтний кеп на виклики хмарної avg-моделі за один прогін (щоб драбина на N
+ * правил не спалила потужну модель). Перевизначення: `--max-avg N`.
+ */
+const DEFAULT_MAX_AVG = 3
+
+/** Маркер дружнього повідомлення про відсутній API-ключ (з `llm-worker.callModel`). */
+const NO_KEY_RE = /немає ключа|api key/i
+
+/**
+ * Будує драбину ескалації за наявними тирами (спека 2026-06-19-fix-escalation-cascade):
+ *  1. `local-min`       — `N_LOCAL_MIN_MODEL`, перший прохід;
+ *  2. `local-min-retry` — той самий локальний, але з feedback попереднього рунга;
+ *  3. `cloud-min`       — `N_CLOUD_MIN_MODEL` (через pi), з feedback;
+ *  4. `cloud-avg`       — `N_CLOUD_AVG_MODEL` (через pi), з feedback, під avg-кепом.
+ * Рунги з незаданим тиром (`''`) відсіюються — драбина стискається до доступних.
+ * @param {{ localMin: string, cloudMin: string, cloudAvg: string }} models тири з env
+ * @returns {Array<{ tier: string, model: string, feedback: boolean, local: boolean, isAvg: boolean }>} драбина
+ */
+export function buildLadder({ localMin, cloudMin, cloudAvg }) {
+  return [
+    { tier: 'local-min', model: localMin, feedback: false, local: true, isAvg: false },
+    { tier: 'local-min-retry', model: localMin, feedback: true, local: true, isAvg: false },
+    { tier: 'cloud-min', model: cloudMin, feedback: true, local: false, isAvg: false },
+    { tier: 'cloud-avg', model: cloudAvg, feedback: true, local: false, isAvg: true }
+  ].filter(r => r.model)
+}
+
+/**
+ * Рішення після провального рунга: чи обірвати драбину / пропустити модель.
+ *  - `break`     — відсутній API-ключ на хмарному (інші хмарні рунги теж без ключа);
+ *  - `skip-model` — systemic-помилка локального тиру (memory-guard/auth/down): повтор
+ *                   тієї ж моделі марний → пропустити рунги з цим model.
+ * @param {{ local: boolean }} rung поточний рунг
+ * @param {string|null|undefined} error помилка виклику worker
+ * @returns {'break'|'skip-model'|null} дія для драбини
+ */
+function decideAfterFailure(rung, error) {
+  if (!error) return null
+  if (NO_KEY_RE.test(error)) return 'break'
+  if (rung.local && classifyOmlxError(error) === 'systemic') return 'skip-model'
+  return null
+}
+
+/**
+ * Проводить ОДНЕ правило по драбині ескалації до першого зеленого re-check.
+ * Кожен рунг: виклик worker (з feedback від попереднього) → re-check цього правила →
+ * запис у escalation-лог («чи допомогло» + diagnosis). Достроковий вихід — `decideAfterFailure`
+ * (обрив на no-key, пропуск моделі на systemic) і вичерпаний avg-кеп (залогувати, не мовчки).
+ * @param {{ ruleId: string, output: string }} rule провальне правило з violation-output
+ * @param {string} cwd корінь проєкту
+ * @param {{
+ *   ladder: Array<{tier:string,model:string,feedback:boolean,local:boolean,isAvg:boolean}>,
+ *   worker: { runLlmWorker: (ruleId: string, violation: string, cwd: string, opts: object) => object },
+ *   check: (rules: string[], cwd: string) => Promise<{rules: Array<{ruleId:string,ok:boolean,output:string}>}>,
+ *   avgBudget: number,
+ *   clock?: () => number,
+ *   log?: (s: string) => void
+ * }} deps інжектовані залежності (worker/check/clock — для тестів)
+ * @returns {Promise<{ resolved: boolean, avgUsed: number }>} чи закрито правило і скільки avg-викликів витрачено
+ */
+export async function escalateRule(rule, cwd, deps) {
+  const { ladder, worker, check, avgBudget } = deps
+  const clock = deps.clock ?? (() => Date.now())
+  const log = deps.log ?? (s => console.log(s))
+  const record = base => logEscalation({ ts: new Date(clock()).toISOString(), ruleId: rule.ruleId, ...base })
+
+  let feedback = null
+  let currentViolation = rule.output
+  const skipModels = new Set()
+  let avgUsed = 0
+
+  for (const [idx, rung] of ladder.entries()) {
+    if (skipModels.has(rung.model)) continue
+
+    const common = { rung: idx, tier: rung.tier, model: rung.model, withFeedback: rung.feedback }
+    if (rung.isAvg && avgBudget - avgUsed <= 0) {
+      record({ ...common, callOk: false, callError: 'cloud-avg cap reached', recheckOk: false, remainingViolation: currentViolation, diagnosis: null, ms: 0 })
+      log(`  ⏭️  ${rule.ruleId}: ${rung.tier} пропущено (avg-кеп вичерпано)`)
+      continue
+    }
+
+    const startedAt = clock()
+    const res = worker.runLlmWorker(rule.ruleId, currentViolation, cwd, {
+      model: rung.model,
+      feedback: rung.feedback ? feedback : null,
+      caller: `fix:${rule.ruleId}:${rung.tier}`
+    })
+    if (rung.isAvg) avgUsed++
+
+    const recheck = await check([rule.ruleId], cwd)
+    const recheckOk = recheck.rules.every(r => r.ok)
+    const remaining = recheckOk ? '' : (recheck.rules.find(r => !r.ok)?.output ?? '')
+    record({ ...common, callOk: res.ok, callError: res.error ?? null, recheckOk, remainingViolation: remaining, diagnosis: res.diagnosis ?? null, ms: clock() - startedAt })
+
+    if (recheckOk) {
+      log(`  ✅ ${rung.tier} (${rung.model || 'pi'}): ${rule.ruleId}`)
+      return { resolved: true, avgUsed }
+    }
+
+    const hint = res.error ? ` ❌ ${res.error.slice(0, 120)}` : ' ❌ досі порушено'
+    log(`  ⚡ ${rung.tier} (${rung.model || 'pi'}): ${rule.ruleId}${hint}`)
+
+    // Feedback для наступного рунга + оновлений violation.
+    feedback = { previousModel: rung.model, previousChanges: res.changes ?? [], previousError: res.error ?? null }
+    currentViolation = remaining || currentViolation
+
+    const action = decideAfterFailure(rung, res.error)
+    if (action === 'break') break
+    if (action === 'skip-model') skipModels.add(rung.model)
+  }
+
+  return { resolved: false, avgUsed }
+}
 
 /**
- * Парсить `--max-iter N` і збирає rule-filter (позиційні аргументи без прапорців).
+ * Парсить `--max-avg N` і збирає rule-filter (позиційні аргументи без прапорців).
  * @param {string[]} args CLI аргументи після 'fix'
- * @returns {{ maxIter: number, ruleFilter: string[] }} ліміт ітерацій і фільтр правил
+ * @returns {{ maxAvg: number, ruleFilter: string[] }} avg-кеп і фільтр правил
  */
-function parseOrchestratorArgs(args) {
-  const maxIterIdx = args.indexOf('--max-iter')
-  const maxIter =
-    maxIterIdx === -1 ? DEFAULT_MAX_ITER : Number(args[maxIterIdx + 1] ?? DEFAULT_MAX_ITER) || DEFAULT_MAX_ITER
-  const skipIdxs = new Set(maxIterIdx === -1 ? [] : [maxIterIdx, maxIterIdx + 1])
-  const ruleFilter = args.filter((a, i) => !a.startsWith('-') && !skipIdxs.has(i))
-  return { maxIter, ruleFilter }
+export function parseOrchestratorArgs(args) {
+  const idx = args.indexOf('--max-avg')
+  const maxAvg = idx === -1 ? DEFAULT_MAX_AVG : Number(args[idx + 1] ?? DEFAULT_MAX_AVG) || DEFAULT_MAX_AVG
+  const skip = new Set(idx === -1 ? [] : [idx, idx + 1])
+  const ruleFilter = args.filter((a, i) => !a.startsWith('-') && !skip.has(i))
+  return { maxAvg, ruleFilter }
 }
 
 /**
@@ -40,77 +155,65 @@ async function runT0Step(cwd, ruleFilter, failed) {
   return failedAfterT0
 }
 
-/**
- * Крок T1: LLM через pi для кожного правила, з ескалацією моделі за провалами.
- * @param {Array<{ ruleId: string, output: string }>} failed правила до фіксу
- * @param {string} cwd корінь проєкту
- * @param {Map<string, number>} failCount ruleId → кількість провалів підряд (мутується)
- * @param {{ runLlmWorker: (ruleId: string, output: string, projectRoot: string, opts: {model: string}) => Promise<{ok: boolean, error?: string}>, MODEL: string, MODEL_HEAVY: string }} worker воркер і моделі
- * @returns {Promise<void>}
- */
-async function runLlmStep(failed, cwd, failCount, { runLlmWorker, MODEL, MODEL_HEAVY }) {
-  for (const rule of failed) {
-    const prevFails = failCount.get(rule.ruleId) ?? 0
-    const model = prevFails >= ESCALATE_AFTER ? MODEL_HEAVY : MODEL
-    const label = model || 'pi'
-
-    const result = await runLlmWorker(rule.ruleId, rule.output, cwd, { model })
-
-    if (result.ok) {
-      console.log(`  ⚡ LLM (${label}): ${rule.ruleId}`)
-      failCount.delete(rule.ruleId)
-    } else {
-      failCount.set(rule.ruleId, prevFails + 1)
-      const hint = (result.error ?? '').slice(0, 200)
-      console.log(`  ⚡ LLM (${label}): ${rule.ruleId} ❌  ${hint}`)
-    }
-  }
-}
-
 /**
  * @param {string[]} args   CLI аргументи після 'fix'
  * @param {string}   cwd    корінь проєкту
  * @returns {Promise<number>}  0 = all clean, 1 = unresolved
  */
 export async function runOrchestratorCli(args, cwd) {
-  const worker = await import('./llm-worker.mjs')
-  const { maxIter, ruleFilter } = parseOrchestratorArgs(args)
-
-  /** @type {Map<string, number>} ruleId → кількість LLM-провалів підряд */
-  const failCount = new Map()
+  const worker = { runLlmWorker }
+  const { maxAvg, ruleFilter } = parseOrchestratorArgs(args)
+  const ladder = buildLadder({ localMin: LOCAL_MIN, cloudMin: CLOUD_MIN, cloudAvg: CLOUD_AVG })
 
   // ── Перша перевірка (тихо) ──
   const initial = await runFixCheck(ruleFilter, cwd)
   let failed = initial.rules.filter(r => !r.ok)
   const total = initial.total
 
-  // Нічого не зламано — коротка відповідь
   if (failed.length === 0) {
     console.log(`✅ fix: ${total} правил — все чисто`)
     return 0
   }
 
-  // Є порушення — показуємо прогрес
   console.log(`🔄 fix: ${failed.length}/${total} порушень (${failed.map(r => r.ruleId).join(', ')})`)
   if (ruleFilter.length) console.log(`   filter: ${ruleFilter.join(', ')}`)
 
-  for (let iter = 1; iter <= maxIter; iter++) {
-    failed = await runT0Step(cwd, ruleFilter, failed)
-    if (failed.length === 0) break
+  // ── T0-auto (детермінований, без LLM) ──
+  failed = await runT0Step(cwd, ruleFilter, failed)
+  if (failed.length === 0) {
+    console.log(`✅ fix: ${total} правил — все чисто`)
+    return 0
+  }
 
-    await runLlmStep(failed, cwd, failCount, worker)
+  // ── LLM-драбина ескалації на правило ──
+  if (ladder.length === 0) {
+    console.log(
+      `❌ fix: ${failed.length} порушень потребують LLM, але жоден тир не заданий ` +
+        `(N_LOCAL_MIN_MODEL / N_CLOUD_MIN_MODEL / N_CLOUD_AVG_MODEL)`
+    )
+    return 1
+  }
+  console.log(`   драбина: ${ladder.map(r => r.tier).join(' → ')} (avg-кеп: ${maxAvg})`)
 
-    // Перевірка після LLM
-    const afterLLM = await runFixCheck(ruleFilter, cwd)
-    failed = afterLLM.rules.filter(r => !r.ok)
-    if (failed.length === 0) break
+  let avgBudget = maxAvg
+  for (const rule of failed) {
+    const { avgUsed } = await escalateRule(rule, cwd, {
+      ladder,
+      worker,
+      check: runFixCheck,
+      avgBudget
+    })
+    avgBudget -= avgUsed
   }
 
-  if (failed.length === 0) {
+  // ── Фінальна перевірка ──
+  const finalCheck = await runFixCheck(ruleFilter, cwd)
+  const stillFailed = finalCheck.rules.filter(r => !r.ok)
+  if (stillFailed.length === 0) {
     console.log(`✅ fix: ${total} правил — все чисто`)
     return 0
   }
 
-  console.log(`❌ fix: ${failed.length} невирішених — ${failed.map(r => r.ruleId).join(', ')}`)
+  console.log(`❌ fix: ${stillFailed.length} невирішених — ${stillFailed.map(r => r.ruleId).join(', ')}`)
   return 1
 }

package/scripts/lib/fix/t0.mjs

@@ -1,13 +1,33 @@
 /** @see ./docs/t0.md */
+import { spawnSync } from 'node:child_process'
 import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 
 import { runFixCheck } from './run-fix-check.mjs'
+import { writeChange } from '../../../rules/release/change.mjs'
 
 const REC_REQUIRE_RE = /recommendations має містити "[^"]+"/
 const REC_MATCH_ALL_RE = /recommendations має містити "([^"]+)"/g
 const FORBIDDEN_FILE_RE = /Знайдено заборонений файл: \S+/
 const FORBIDDEN_FILE_MATCH_ALL_RE = /Знайдено заборонений файл: (\S+)/g
+// Конформність changelog: «<ws>: є релевантні зміни, але немає change-файлу».
+const MISSING_CHANGE_RE = /є релевантні зміни, але немає change-файлу/
+const MISSING_CHANGE_MATCH_ALL_RE = /(?:^|\s)([\w./@-]+): є релевантні зміни, але немає change-файлу/gm
+/** Дефолти autofix-створеного change-файлу (узгоджено з n-changelog.mdc / consistency.mjs). */
+const CHANGE_BUMP = 'patch'
+const CHANGE_SECTION = 'Changed'
+const CHANGE_FALLBACK_MESSAGE = 'оновлення'
+
+/**
+ * Опис для авто-створеного change-файлу: subject останнього коміту, інакше fallback.
+ * @param {string} cwd корінь репозиторію
+ * @returns {string} непорожній опис
+ */
+function autoChangeMessage(cwd) {
+  const r = spawnSync('git', ['log', '-1', '--format=%s'], { cwd, encoding: 'utf8' })
+  const subject = r.status === 0 ? (r.stdout ?? '').trim() : ''
+  return subject || CHANGE_FALLBACK_MESSAGE
+}
 
 /**
  * Патерни T0-auto.
@@ -71,6 +91,31 @@ const PATTERNS = [
       if (removed.length === 0) return { ok: false, action: 'файлів не знайдено' }
       return { ok: true, action: `видалено: ${removed.join(', ')}` }
     }
+  },
+
+  // ── changelog-create-change-file ─────────────────────────────────────────────
+  // Violation: «<ws>: є релевантні зміни, але немає change-файлу»
+  // Fix: створити change-файл через канонічну `writeChange` (без LLM) — той самий
+  // механізм, що autofix changelog-конформності. Прибирає ескалацію в хмару на цьому кейсі.
+  {
+    id: 'changelog-create-change-file',
+    test: out => MISSING_CHANGE_RE.test(out),
+    apply: async (out, cwd) => {
+      const workspaces = Array.from(out.matchAll(MISSING_CHANGE_MATCH_ALL_RE), m => m[1])
+      if (workspaces.length === 0) return { ok: false, action: 'no match' }
+
+      const message = autoChangeMessage(cwd)
+      const created = []
+      for (const ws of workspaces) {
+        try {
+          const rel = await writeChange({ bump: CHANGE_BUMP, section: CHANGE_SECTION, message, ws, cwd })
+          created.push(ws === '.' ? rel : join(ws, rel))
+        } catch (error) {
+          return { ok: false, action: `writeChange ${ws}: ${error.message}` }
+        }
+      }
+      return { ok: true, action: `створено change-файл (${CHANGE_BUMP}/${CHANGE_SECTION}): ${created.join(', ')}` }
+    }
   }
 ]
 
@@ -79,15 +124,16 @@ const PATTERNS = [
  * @param {string} ruleId id правила (для логу)
  * @param {string} violationOutput рядок з поля `output` у `fix --json`
  * @param {string} cwd корінь проєкту
- * @returns {{ applied: boolean, actions: string[] }} результат: чи щось застосовано і список дій
+ * @returns {Promise<{ applied: boolean, actions: string[] }>} результат: чи щось застосовано і список дій
  */
-export function applyT0Auto(ruleId, violationOutput, cwd) {
+export async function applyT0Auto(ruleId, violationOutput, cwd) {
   const actions = []
   let applied = false
 
   for (const p of PATTERNS) {
     if (!p.test(violationOutput)) continue
-    const result = p.apply(violationOutput, cwd)
+    // Патерн може бути sync ({ok,action}) або async (Promise) — await нормалізує обидва.
+    const result = await p.apply(violationOutput, cwd)
     actions.push(`[${p.id}] ${result.action}`)
     if (result.ok) {
       applied = true
@@ -113,13 +159,13 @@ export function filterT0AutoRules(failedRules) {
  * Застосовує T0-auto до кожного провального правила, розділяючи на applied/skipped.
  * @param {Array<{ ruleId: string, output: string }>} failed провальні правила
  * @param {string} cwd корінь проєкту
- * @returns {{ applied: Array<{ ruleId: string, actions: string[] }>, skipped: string[] }} застосовані й пропущені
+ * @returns {Promise<{ applied: Array<{ ruleId: string, actions: string[] }>, skipped: string[] }>} застосовані й пропущені
  */
-function applyT0ToFailed(failed, cwd) {
+async function applyT0ToFailed(failed, cwd) {
   const applied = []
   const skipped = []
   for (const r of failed) {
-    const result = applyT0Auto(r.ruleId, r.output, cwd)
+    const result = await applyT0Auto(r.ruleId, r.output, cwd)
     if (result.applied) {
       applied.push({ ruleId: r.ruleId, actions: result.actions })
     } else {
@@ -150,7 +196,7 @@ export async function runT0AutoCli(args, cwd) {
   }
 
   // 2. Застосувати T0-auto
-  const { applied, skipped } = applyT0ToFailed(failed, cwd)
+  const { applied, skipped } = await applyT0ToFailed(failed, cwd)
 
   if (applied.length === 0) {
     console.log(`⏭️  fix-t0: T0-auto паттерн не підходить для: ${failed.map(r => r.ruleId).join(', ')}`)