@nitra/cursor 12.9.0 → 12.10.0

package/scripts/lib/docs/run-standard-lint.md

@@ -8,8 +8,6 @@ docgen:
   score: 90
 ---
 
-## Огляд
-
 Спільна точка входу для канонічних `lint-<rule>` підкоманд `@nitra/cursor`. Файл серіалізує та дедуплікує запуски лінту через `withLock`. `ruleId` визначається зі шляху незалежно від глибини виклику (наприклад, `rules/<id>`). Це дозволяє уніфікувати крос-cutting концерни. Інтеграція з боку правила виглядає так:
 
 - import { runStandardLint } from '../../scripts/lib/run-standard-lint.mjs'

package/scripts/lib/docs/run-standard-rule.md

@@ -8,8 +8,6 @@ docgen:
   score: 70
 ---
 
-## Огляд
-
 Файл надає публічний API для оркестрації правил, який викликається з `rules/<id>/check.mjs`. Він інкапсулює логіку пошуку єдиного правила (`discoverOneRule`) та його виконання (`runRule`). Виконання обертається у `withLock` для дедуплікації паралельних запусків того самого правила на основі стану git-дерева. Локальна логіка в правилах заборонена; розширення поведінки відбувається через `ctx`-опції. Це централізована точка для запуску стандартних правил з кешуванням у межах одного прогону.
 
 ## Поведінка

package/scripts/lib/docs/skill-meta.md

@@ -8,8 +8,6 @@ docgen:
   score: 100
 ---
 
-## Огляд
-
 Спільний парсер метаданих скіла, що зчитує інформацію з `main.json`. Цей файл є єдиним джерелом правди для скіла. Модуль дозволяє визначати умови автоактивації скіла (через поле `auto`), вказувати, чи виконувати скіл в окремому git-worktree (`worktree`), та чи вимагає він запуску з кореня репозиторію (`requireRoot`). Надає константу `SKILL_ALWAYS` для безумовної активації. Хелпер використовується іншими компонентами для уникнення дублювання парсингу. Функції забезпечують перехоплення помилок (fail-safe), повертаючи порожнє значення замість винятків.
 
 ## Поведінка

package/scripts/lib/docs/timing-summary.md

@@ -8,8 +8,6 @@ docgen:
   score: 95
 ---
 
-## Огляд
-
 Форматує тривалість у форматі `<ціла>.<десята>s`. Генерує таблицю-резюме часу виконання для оркестратора `fix` або `lint`, яка включає детальні записи та загальний час прогону. Таблиця містить маркер `❌` для позначення невдач. Функція повертає готовий рядок із фінальним `\n`; друк здійснюється на стороні виклику.
 
 ## Поведінка

package/scripts/lib/docs/worktree-notice.md

@@ -8,8 +8,6 @@ docgen:
   score: 100
 ---
 
-## Огляд
-
 Управляє вставкою інструкцій для виконання команд у ізольованому git-worktree у синкнутий `SKILL.md` (рішення D2 зі spec). Коли `main.json.worktree === true`, інструкції вставляються між маркерами `WORKTREE_START` та `WORKTREE_END`. Це забезпечує ре-синк ідемпотентність: наявний блок замінюється, а при `main.json.worktree === false` — видаляється. Механізм адаптований для агента, який читає `SKILL.md`.
 
 ## Поведінка

package/scripts/lib/fix/docs/analyze-escalation.md

@@ -8,8 +8,6 @@ docgen:
   score: 100
 ---
 
-## Огляд
-
 Аналізує записи рунгів драбини з `escalation-log.mjs` для виявлення шляхів зменшення LLM-залежності у fix-конформності. Лог обробляється за один прогін (від байтового зсуву) або повністю, ділячись на чанки для аналізу хмарною **avg**-моделлю. Мета аналізу — визначити конкретні правки пакета `@nitra/cursor`: (A) новий ДЕТЕРМІНОВАНИЙ T0-патерн (`t0.mjs`), (B) уточнення `.mdc`-інструкцій правила, або (C) зміна скрипта/чека. Результат зберігається у markdown-звіт `.n-cursor/fix-escalation-analysis.md` (append із timestamp) після виклику CLI `n-cursor analyze-escalation`.
 
 ## Поведінка

package/scripts/lib/fix/docs/index.md

@@ -6,13 +6,14 @@ resource: npm/scripts/lib/fix/
 
 # npm/scripts/lib/fix
 
-| Файл                                                  | Тип       |
-| ----------------------------------------------------- | --------- |
-| [analyze-escalation.mjs](analyze-escalation.md)       | JS Module |
-| [escalation-log.mjs](escalation-log.md)               | JS Module |
-| [llm-fix-apply.mjs](llm-fix-apply.md)                 | JS Module |
-| [llm-lint-fix.mjs](llm-lint-fix.md)                   | JS Module |
-| [llm-worker.mjs](llm-worker.md)                       | JS Module |
-| [orchestrator.mjs](orchestrator.md)                   | JS Module |
+| Файл | Тип |
+|---|---|
+| [analyze-escalation.mjs](analyze-escalation.md) | JS Module |
+| [escalation-log.mjs](escalation-log.md) | JS Module |
+| [llm-fix-apply.mjs](llm-fix-apply.md) | JS Module |
+| [llm-lint-fix.mjs](llm-lint-fix.md) | JS Module |
+| [llm-worker.mjs](llm-worker.md) | JS Module |
+| [orchestrator.mjs](orchestrator.md) | JS Module |
 | [run-conformance-check.mjs](run-conformance-check.md) | JS Module |
-| [t0.mjs](t0.md)                                       | JS Module |
+| [t0.mjs](t0.md) | JS Module |
+| [verbose-block.mjs](verbose-block.md) | JS Module |

package/scripts/lib/fix/docs/llm-worker.md

@@ -3,24 +3,34 @@ type: JS Module
 title: llm-worker.mjs
 resource: npm/scripts/lib/fix/llm-worker.mjs
 docgen:
-  crc: 857c510e
+  crc: d6c0b516
   model: omlx/gemma-4-e4b-it-OptiQ-4bit
   score: 100
 ---
 
-Модуль виправляє одне rule-порушення конформності через LLM: читає `.mdc` правила, дістає файли з violation-output, будує prompt і застосовує згенеровані зміни. Підтримує **feedback-режим** драбини ескалації — у повторний виклик передається контекст попереднього рунга, а модель спершу формулює `diagnosis` («чому попередня спроба не вдалася»), тоді виправляє.
+## Огляд
 
-## Поведінка
+Модуль взаємодіє з мовною моделлю для обробки правил та файлів. Він формує запит до моделі, отримує пропозиції щодо змін, які не застосовуються до файлової системи. Функція обробки гарантує перехоплення помилок (fail-safe) та не генерує винятків назовні.
 
-`runLlmWorker` читає `.mdc` правила, читає файли з violation-output, будує prompt і викликає модель через спільний `callLlm` (з міткою `caller` для wire-trace). Відповідь очікується як JSON `{diagnosis, changes}`; зміни застосовуються до файлів повним вмістом.
+## Поведінка
 
-Якщо переданий `feedback`, prompt додає блок попереднього рунга (модель, попередньо змінені файли, помилка) і просить діагностувати причину невдачі у полі `diagnosis`. Результат повертається з `changes` і `diagnosis` навіть при невдачі — щоб драбина (`orchestrator.mjs`) їх залогувала і прокинула далі.
+1. Викликає runLlmWorker для виправлення однієї проблеми.
+2. Зчитує вміст відповідного файлу правила.
+3. Витягує шляхи до файлів, які порушені, з вихідних даних про порушення.
+4. Зчитує вміст цих файлів.
+5. Формує повний текстовий запит для моделі, включаючи правило, вихідні дані про порушення, вміст файлів та, за наявності, контекст попередньої спроби.
+6. Відправляє цей запит моделі.
+7. У разі помилки при виклику моделі, повертає статус невдачі з деталями помилки.
+8. Якщо модель відповідає, парсить її відповідь, щоб отримати діагноз та список змін.
+9. У разі неможливості розібрати відповідь або відсутності змін, повертає статус невдачі.
+10. Якщо зміни успішно отримані, застосовує ці зміни до файлової системи проєкту.
+11. Повертає результат, що містить статус успіху, список застосованих змін, діагноз та метадані про запит.
 
 ## Публічний API
 
-- `runLlmWorker(ruleId, violationOutput, projectRoot, opts)` — виправляє одне порушення; `opts`: `model`, `feedback`, `caller`, `timeoutMs` (per-tier ліміт виклику; драбина задає коротший для локальних рунгів). Повертає `{ ok, error, changes, diagnosis }`.
+runLlmWorker — виправляє одне порушення правила, використовуючи шаблон C1. Повертає результати виправлення чи діагнозу незалежно від успіху, що дозволяє наступним етапам системи отримувати інформацію про спробу. Поля про міркування та підсумок запиту використовуються для детального виводу в режимі `--full`. Дозволяє перевизначити модель, передати контекст попередніх спроб, позначити джерело виклику та встановити ліміти часу для кожного рівня виконання. Керує обсягом токенів, доступних для процесу мислення.
 
 ## Гарантії поведінки
 
-- Перехоплює помилки виклику моделі й не пропускає винятків назовні (fail-safe): дружнє повідомлення для відсутнього API-ключа хмарного провайдера.
-- Звертається до мережі під час виклику моделі (omlx HTTP або pi CLI, залежно від префікса model-id).
+- Read-only: не виконує операцій запису (ФС/БД).
+- Перехоплює помилки і не пропускає винятків назовні (fail-safe).

package/scripts/lib/fix/docs/orchestrator.md

@@ -3,38 +3,62 @@ type: JS Module
 title: orchestrator.mjs
 resource: npm/scripts/lib/fix/orchestrator.mjs
 docgen:
-  crc: 3bb1b761
-  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  crc: 08d96254
+  model: claude-sonnet-4-6
   score: 100
 ---
 
-## Огляд
-
-Модуль відповідає за управління процесом виправлення порушень. Він будує послідовність тирів ескалації за допомогою `buildLadder`, парсить аргументи командного рядка за допомогою `parseOrchestratorArgs` та запускає повний цикл виправлення за допомогою `runOrchestratorCli`. Цей цикл включає автоматичний фікс та ескалацію через LLM-моделі, що реалізується функцією `escalateRule`.
+Оркеструє повний цикл виправлення порушень конформності: детермінований T0-фікс без LLM → LLM-драбина ескалації (local-min → local-min-retry → cloud-min → cloud-avg) → фінальна перевірка. Кожне провальне правило проходить через тири послідовно до першого зеленого re-check або до обриву (no-key, systemic-помилка, cloud transport fail, вичерпаний avg-кеп).
 
 ## Поведінка
 
-buildLadder будує послідовність тирів ескалації для вирішення порушень, від локальних мінімальних моделей до хмарних середніх моделей.
-escalateRule виконує один прогін по послідовності тирів, намагаючись вирішити порушення, використовуючи LLM-моделі та фіксуючи результат.
-parseOrchestratorArgs парсить аргументи командного рядка для визначення максимального ліміту викликів хмарної моделі та фільтра правил.
-runOrchestratorCli керує повним процесом виправлення порушень: виконує початкову перевірку, застосовує детермінований фікс (T0-auto), а потім ініціює LLM-драбину ескалації для невирішених правил.
+### `buildLadder`
 
-## Публічний API
+Будує масив рунгів ескалації з чотирьох тирів:
+
+| Тир               | Модель      | Feedback | Timeout                   |
+| ----------------- | ----------- | -------- | ------------------------- |
+| `local-min`       | `LOCAL_MIN` | ні       | `LOCAL_TIMEOUT_MS` (45s)  |
+| `local-min-retry` | `LOCAL_MIN` | так      | `LOCAL_TIMEOUT_MS`        |
+| `cloud-min`       | `CLOUD_MIN` | так      | `CLOUD_TIMEOUT_MS` (120s) |
+| `cloud-avg`       | `CLOUD_AVG` | так      | `CLOUD_TIMEOUT_MS`        |
+
+Рунги з порожньою моделлю (`''`) відфільтровуються — драбина стискається до доступних тирів.
+
+### `escalateRule`
+
+Проводить одне правило через драбину до першого зеленого re-check. На кожному рунзі:
 
-buildLadder — Створює послідовність моделей для ескалації, обмежуючись лише тирами, які доступні.
+1. Виклик `worker.runLlmWorker` (синхронно) з feedback від попереднього рунга.
+2. Re-check через `check([ruleId], cwd)`.
+3. Запис у escalation-лог (`logEscalation`).
+4. Якщо re-check зелений → `{ resolved: true }`.
+5. Якщо ні → `decideAfterFailure` визначає дію: `break` (no-key або cloud transport fail), `skip-model` (systemic omlx-помилка), або продовжити.
+6. Avg-рунг пропускається, якщо `avgBudget <= 0` (з фіксацією у лог).
 
-local-min — Виконує перший прохід з локальною мінімальною моделлю.
-local-min-retry — Повторює локальний прохід, використовуючи результати попереднього рунгу.
-cloud-min — Виконує прохід з хмарною мінімальною моделлю, використовуючи результати попереднього рунгу.
-cloud-avg — Виконує прохід з хмарною середньою моделлю, використовуючи результати попереднього рунгу та обмеження середнього.
+Після кожного рунга виводить verbose-блок (`printVerboseBlock`), якщо `N_CURSOR_FIX_VERBOSE !== 'off'`.
 
-escalateRule — Застосовує одне правило по драбині ескалації до першого позитивного результату.
-Кожен рунг — Викликає модель з попереднім відгуком, перевіряє правило, фіксує результат у лозі. Зупиняється при певних умовах (відсутність ключа, пропуск моделі, перевищення бюджету).
+### `parseOrchestratorArgs`
 
-parseOrchestratorArgs — Витягує максимальне значення середнього та список фільтрів правил з командного рядка.
+Витягує `--max-avg N` (default: 3) і збирає позиційні аргументи як `ruleFilter`.
+
+### `runOrchestratorCli`
+
+Повний цикл:
+
+1. Початкова conformance-перевірка → якщо чисто, exit 0.
+2. `runT0Step` — детермінований фікс без LLM; якщо після нього чисто, exit 0.
+3. Для кожного правила, що лишилося — `escalateRule` з відстеженням `avgBudget`.
+4. Фінальна перевірка → exit 0 якщо чисто, exit 1 якщо є невирішені.
+
+## Публічний API
 
-runOrchestratorCli — Запускає основну логіку оркестратора на основі аргументів командного рядка.
+- `buildLadder({ localMin, cloudMin, cloudAvg })` — повертає масив рунгів ескалації.
+- `escalateRule(rule, cwd, deps)` — проводить одне правило через драбину; `deps` дозволяє ін'єкцію worker/check/clock для тестів; повертає `{ resolved, avgUsed }`.
+- `parseOrchestratorArgs(args)` — повертає `{ maxAvg, ruleFilter }`.
+- `runOrchestratorCli(args, cwd)` — CLI-точка входу; повертає `Promise<0|1>`.
 
 ## Гарантії поведінки
 
-- Read-only: не виконує операцій запису (ФС/БД).
+- Мутує файли проєкту лише через `worker.runLlmWorker` (apply-changes) і T0-auto.
+- Не кидає винятків назовні: помилки LLM перехоплює worker і повертає як `res.error`.

package/scripts/lib/fix/docs/run-conformance-check.md

@@ -8,8 +8,6 @@ docgen:
   score: 90
 ---
 
-## Огляд
-
 Модуль реалізує прямий механізм виконання конформності, викликаючи конформність-фазу `lint`, движок (`orchestrator.mjs`, `t0.mjs`) та PostToolUse-хук. Селекція активних правил здійснюється на основі конфігурації `.n-cursor.json`. Для забезпечення ізоляції, кожен обраний `entrypoint rules/<id>/main.mjs` запускається окремим процесом `bun`.
 
 ## Поведінка

package/scripts/lib/fix/docs/t0.md

@@ -8,8 +8,6 @@ docgen:
   score: 100
 ---
 
-## Огляд
-
 Модуль керує автоматичним застосуванням паттернів T0-auto до виводів порушень. Він використовує конфігурації з `extensions.json` та `package-lock.json` для визначення правил. Модуль фільтрує правила, які можуть бути автоматично оброблені, застосовує паттерни за допомогою `applyT0Auto`, а потім запускає повний цикл перевірки для всіх провальних правил через `runT0AutoCli`. Усі операції виконуються з механізмом fail-safe, що запобігає виникненню винятків назовні.
 
 ## Поведінка

package/scripts/lib/fix/docs/verbose-block.md

@@ -0,0 +1,27 @@
+---
+type: JS Module
+title: verbose-block.mjs
+resource: npm/scripts/lib/fix/verbose-block.mjs
+docgen:
+  crc: 1a921dca
+  model: omlx/gemma-4-e4b-it-OptiQ-4bit
+  score: 100
+---
+
+Цей файл виводить детальний блок інформації після кожного LLM-рунга у режимі `--full`. Він друкує стислий опис промпту, включаючи деталі про правила, порушення та зворотний зв'язок. Також виводиться монолог моделі, якщо він присутній. Вивід блоку вимикається при встановленні `N_CURSOR_FIX_VERBOSE=off`.
+
+## Поведінка
+
+1. Викликається `printVerboseBlock` для виведення детальної інформації після кожного LLM-рунга у режимі `--full`.
+2. `printVerboseBlock` виводить стислий опис промпту, включаючи ID правила, довжину правила, довжину порушення, кількість та розмір файлів, а також інформацію про зворотний зв'язок (наявність, модель, кількість змін, помилка).
+3. Якщо надано монолог моделі (reasoning), `printVerboseBlock` виводить його, показуючи прев'ю (з можливим зазначенням загальної довжини), і вказує джерело цього монологу.
+4. Якщо монологу моделі немає, `printVerboseBlock` виводить повідомлення про відсутність монологу.
+5. Виведення здійснюється лише якщо змінна середовища `N_CURSOR_FIX_VERBOSE` не встановлена як `off`.
+
+## Публічний API
+
+printVerboseBlock — виводить детальний опис промпту та внутрішній роздум моделі після символу завершення рядка рунга.
+
+## Гарантії поведінки
+
+- Read-only: не виконує операцій запису (ФС/БД).

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

@@ -4,7 +4,7 @@ import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { env } from 'node:process'
 import { resolveModel } from '../../../lib/models.mjs'
-import { callLlm } from '../../../lib/llm.mjs'
+import { callLlmRich } from '../../../lib/llm.mjs'
 import { applyChanges, parseChangesResponse, readFilesForFix } from './llm-fix-apply.mjs'
 
 // Дефолтна модель, коли викликач не задав `opts.model` (legacy/прямі виклики).
@@ -12,6 +12,10 @@ import { applyChanges, parseChangesResponse, readFilesForFix } from './llm-fix-a
 // тут лишається тільки fallback на min-тир. Перевизначення — `N_CURSOR_FIX_MODEL`.
 const MODEL = env.N_CURSOR_FIX_MODEL ?? resolveModel('min')
 
+// Бюджет thinking-токенів для omlx-моделей (Gemma 4 та ін., що підтримують thinking_budget).
+// Значення 0 вимикає thinking. Перевизначення — `N_CURSOR_OMLX_THINKING_BUDGET`.
+const DEFAULT_THINKING_BUDGET = Number(env.N_CURSOR_OMLX_THINKING_BUDGET ?? 4096)
+
 const API_KEY_RE = /api key/i
 
 /**
@@ -112,23 +116,32 @@ function buildPrompt(ruleId, ruleMdc, output, files, feedback = null) {
 }
 
 /**
- * Викликає LLM через спільний `callLlm` (маршрут за префіксом model-id; wire-trace).
+ * Викликає LLM через `callLlmRich` (маршрут за префіксом model-id; wire-trace).
+ * Повертає reasoning поряд із текстом — для verbose-блоку оркестратора.
  * Зберігає дружнє повідомлення про відсутній API-ключ для хмарних провайдерів.
  * @param {string} prompt текст промпта
  * @param {string} model назва моделі (provider/id, `omlx/...` або '')
  * @param {string} caller мітка викликача для wire-trace (`fix:<rule>:<rung>`)
- * @param {number} [timeoutMs] ліміт виклику (драбина задає per-tier; undefined → дефолт callLlm)
- * @returns {{ text: string, error?: string }} текст відповіді або повідомлення про помилку
+ * @param {number} [timeoutMs] ліміт виклику (драбина задає per-tier; undefined → дефолт callLlmRich)
+ * @param {number} [thinkingBudget] бюджет thinking-токенів (лише omlx; 0 = вимкнено)
+ * @returns {{ text: string, reasoning: string|null, reasoningSource: string|null, error?: string }}
  */
-function callModel(prompt, model, caller, timeoutMs) {
+function callModel(prompt, model, caller, timeoutMs, thinkingBudget) {
   try {
-    return { text: callLlm([{ role: 'user', content: prompt }], model, { timeoutMs, caller }) }
+    const { content, reasoning, reasoningSource } = callLlmRich([{ role: 'user', content: prompt }], model, {
+      timeoutMs,
+      caller,
+      thinkingBudget
+    })
+    return { text: content, reasoning, reasoningSource }
   } catch (error) {
     const msg = String(error.message)
     if (API_KEY_RE.test(msg)) {
       const provider = model ? model.split('/')[0] : 'дефолтного провайдера'
       return {
         text: '',
+        reasoning: null,
+        reasoningSource: null,
         error: [
           `pi: немає ключа для ${provider}.`,
           `Встановіть N_CLOUD_MIN_MODEL=provider/model-id`,
@@ -136,7 +149,7 @@ function callModel(prompt, model, caller, timeoutMs) {
         ].join(' ')
       }
     }
-    return { text: '', error: msg }
+    return { text: '', reasoning: null, reasoningSource: null, error: msg }
   }
 }
 
@@ -144,21 +157,24 @@ function callModel(prompt, model, caller, timeoutMs) {
  * LLM-worker: виправляє одне rule-порушення через pi (C1 pattern).
  * Повертає `changes`/`diagnosis` навіть при невдачі — драбина ескалації
  * (`orchestrator.mjs`) логує їх і прокидає як feedback у наступний рунг.
+ * Поля `reasoning`/`reasoningSource`/`promptSummary` використовує оркестратор
+ * для verbose-блоку після кожного рунга (`--full` режим).
  * @param {string} ruleId ID правила
  * @param {string} violationOutput  output з fix check для цього rule
  * @param {string} projectRoot      абсолютний шлях до кореня проєкту
- * @param {{ model?: string, feedback?: object|null, caller?: string, timeoutMs?: number }} opts опції:
+ * @param {{ model?: string, feedback?: object|null, caller?: string, timeoutMs?: number, thinkingBudget?: number }} opts опції:
  *   `model` — перевизначення моделі; `feedback` — контекст попереднього рунга
  *   драбини (retry-with-feedback); `caller` — мітка для wire-trace; `timeoutMs` —
- *   per-tier ліміт виклику (драбина: локалі fail-fast, хмара повний)
- * @returns {{ ok: boolean, error?: string, changes: Array<{path:string}>, diagnosis: string|null }}
- *   статус виправлення, помилка, запропоновані зміни і само-аналіз моделі
+ *   per-tier ліміт виклику (драбина: локалі fail-fast, хмара повний);
+ *   `thinkingBudget` — кількість thinking-токенів для omlx (дефолт `DEFAULT_THINKING_BUDGET`)
+ * @returns {{ ok: boolean, error?: string, changes: Array<{path:string}>, diagnosis: string|null, reasoning: string|null, reasoningSource: string|null, promptSummary: object }}
  */
 export function runLlmWorker(ruleId, violationOutput, projectRoot, opts = {}) {
   const model = opts.model ?? MODEL
   const feedback = opts.feedback ?? null
   const caller = opts.caller ?? 'fix'
   const timeoutMs = opts.timeoutMs
+  const thinkingBudget = opts.thinkingBudget ?? DEFAULT_THINKING_BUDGET
 
   // 1. Читаємо rule .mdc
   const mdcPath = join(projectRoot, '.cursor', 'rules', `n-${ruleId}.mdc`)
@@ -167,24 +183,61 @@ export function runLlmWorker(ruleId, violationOutput, projectRoot, opts = {}) {
   // 2. Витягуємо файли з violation output і читаємо їх
   const files = readFilesForFix(extractFilePaths(violationOutput), projectRoot)
 
-  // 3. Будуємо prompt і викликаємо модель
-  const prompt = buildPrompt(ruleId, ruleMdc, violationOutput, files, feedback)
-  const { text, error: modelError } = callModel(prompt, model, caller, timeoutMs)
+  // 3. Будуємо summary промпту (для verbose-блоку) до виклику моделі
+  const promptSummary = {
+    ruleMdcLen: ruleMdc.length,
+    violationLen: violationOutput.length,
+    filesCount: files.length,
+    filesTotalBytes: files.reduce((s, f) => s + f.content.length, 0),
+    hasFeedback: !!feedback,
+    feedbackModel: feedback?.previousModel ?? null,
+    feedbackChangesCount: feedback?.previousChanges?.length ?? 0,
+    feedbackError: feedback?.previousError ?? null
+  }
 
-  if (modelError) return { ok: false, error: modelError, changes: [], diagnosis: null }
-  if (!text) return { ok: false, error: 'model returned empty response', changes: [], diagnosis: null }
+  // 4. Будуємо prompt і викликаємо модель
+  const prompt = buildPrompt(ruleId, ruleMdc, violationOutput, files, feedback)
+  const {
+    text,
+    error: modelError,
+    reasoning,
+    reasoningSource
+  } = callModel(prompt, model, caller, timeoutMs, thinkingBudget)
+
+  if (modelError)
+    return { ok: false, error: modelError, changes: [], diagnosis: null, reasoning, reasoningSource, promptSummary }
+  if (!text)
+    return {
+      ok: false,
+      error: 'model returned empty response',
+      changes: [],
+      diagnosis: null,
+      reasoning,
+      reasoningSource,
+      promptSummary
+    }
 
-  // 4. Парсимо відповідь
+  // 5. Парсимо відповідь
   const parsed = parseChangesResponse(text)
   if (!parsed) {
-    return { ok: false, error: `cannot parse pi response: ${text.slice(0, 200)}`, changes: [], diagnosis: null }
+    return {
+      ok: false,
+      error: `cannot parse pi response: ${text.slice(0, 200)}`,
+      changes: [],
+      diagnosis: null,
+      reasoning,
+      reasoningSource,
+      promptSummary
+    }
   }
   const diagnosis = typeof parsed.diagnosis === 'string' && parsed.diagnosis ? parsed.diagnosis : null
   const changes = parsed.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 }
+  if (parsed.error)
+    return { ok: false, error: parsed.error, changes, diagnosis, reasoning, reasoningSource, promptSummary }
+  if (changes.length === 0)
+    return { ok: false, error: 'pi returned no changes', changes, diagnosis, reasoning, reasoningSource, promptSummary }
 
-  // 5. Застосовуємо зміни
+  // 6. Застосовуємо зміни
   const applied = applyChanges(changes, projectRoot)
-  return { ...applied, changes, diagnosis }
+  return { ...applied, changes, diagnosis, reasoning, reasoningSource, promptSummary }
 }

package/scripts/lib/fix/orchestrator.mjs

@@ -5,6 +5,7 @@ import { runConformanceCheck } from './run-conformance-check.mjs'
 import { runT0AutoCli } from './t0.mjs'
 import { logEscalation } from './escalation-log.mjs'
 import { runLlmWorker } from './llm-worker.mjs'
+import { printVerboseBlock } from './verbose-block.mjs'
 import { classifyOmlxError } from '../../../lib/llm.mjs'
 import { CLOUD_AVG, CLOUD_MIN, LOCAL_MIN } from '../../../lib/models.mjs'
 
@@ -147,11 +148,20 @@ export async function escalateRule(rule, cwd, deps) {
 
     if (recheckOk) {
       log(`  ✅ ${rung.tier} (${rung.model || 'pi'}): ${rule.ruleId}`)
-      return { resolved: true, avgUsed }
+    } else {
+      const hint = res.error ? ` ❌ ${res.error.slice(0, 120)}` : ' ❌ досі порушено'
+      log(`  ⚡ ${rung.tier} (${rung.model || 'pi'}): ${rule.ruleId}${hint}`)
     }
 
-    const hint = res.error ? ` ❌ ${res.error.slice(0, 120)}` : ' ❌ досі порушено'
-    log(`  ⚡ ${rung.tier} (${rung.model || 'pi'}): ${rule.ruleId}${hint}`)
+    // DEBUG
+    console.error(
+      `[DBG] verbose check: VERBOSE=${env.N_CURSOR_FIX_VERBOSE} promptSummary=${JSON.stringify(res.promptSummary)} reasoning=${res.reasoning}`
+    )
+    if (env.N_CURSOR_FIX_VERBOSE !== 'off' && res.promptSummary) {
+      printVerboseBlock(rule.ruleId, res.promptSummary, res.reasoning ?? null, res.reasoningSource ?? null)
+    }
+
+    if (recheckOk) return { resolved: true, avgUsed }
 
     // Feedback для наступного рунга + оновлений violation.
     feedback = { previousModel: rung.model, previousChanges: res.changes ?? [], previousError: res.error ?? null }

package/scripts/lib/fix/verbose-block.mjs

@@ -0,0 +1,82 @@
+/**
+ * Verbose-блок після кожного LLM-рунга у `--full` режимі.
+ * Друкує стислий опис промпту і thinking-монолог моделі (якщо є).
+ * Вимикається через `N_CURSOR_FIX_VERBOSE=off`.
+ */
+
+const THINKING_PREVIEW_LEN = 500
+
+/**
+ * Форматує рядок файлів для prompt-блоку.
+ * @param {number} count кількість файлів
+ * @param {number} totalBytes сумарний розмір у байтах
+ * @returns {string}
+ */
+function formatFiles(count, totalBytes) {
+  if (count === 0) return '(none)'
+  const kb = (totalBytes / 1024).toFixed(1)
+  const word = count === 1 ? 'файл' : count < 5 ? 'файли' : 'файлів'
+  return `${count} ${word} (${kb} KB)`
+}
+
+/**
+ * Форматує рядок feedback для prompt-блоку.
+ * @param {boolean} hasFeedback чи є feedback
+ * @param {string|null} feedbackModel модель попереднього рунга
+ * @param {number} feedbackChangesCount кількість змін попереднього рунга
+ * @param {string|null} feedbackError помилка попереднього рунга
+ * @returns {string}
+ */
+function formatFeedback(hasFeedback, feedbackModel, feedbackChangesCount, feedbackError) {
+  if (!hasFeedback) return '(none)'
+  const parts = []
+  if (feedbackModel) parts.push(`model=${feedbackModel}`)
+  parts.push(`${feedbackChangesCount} changes`)
+  if (feedbackError) parts.push(`error="${feedbackError.slice(0, 60)}"`)
+  return parts.join(', ')
+}
+
+/**
+ * Друкує verbose-блок після рядка рунга (`⚡`/`✅`).
+ * Містить стислий опис промпту і thinking-монолог моделі (якщо є).
+ * Не викликається якщо `N_CURSOR_FIX_VERBOSE=off`.
+ * @param {string} ruleId ID правила
+ * @param {{ ruleMdcLen: number, violationLen: number, filesCount: number, filesTotalBytes: number, hasFeedback: boolean, feedbackModel: string|null, feedbackChangesCount: number, feedbackError: string|null }} promptSummary стислий опис промпту
+ * @param {string|null} reasoning thinking-монолог моделі
+ * @param {string|null} reasoningSource джерело reasoning ('field'|'think_tag'|'truncated'|null)
+ */
+export function printVerboseBlock(ruleId, promptSummary, reasoning, reasoningSource) {
+  const {
+    ruleMdcLen,
+    violationLen,
+    filesCount,
+    filesTotalBytes,
+    hasFeedback,
+    feedbackModel,
+    feedbackChangesCount,
+    feedbackError
+  } = promptSummary
+
+  console.log(``)
+  console.log(`  prompt:`)
+  console.log(`    rule:      n-${ruleId}.mdc (${ruleMdcLen} chars)`)
+  console.log(`    violation: ${violationLen} chars`)
+  console.log(`    files:     ${formatFiles(filesCount, filesTotalBytes)}`)
+  console.log(`    feedback:  ${formatFeedback(hasFeedback, feedbackModel, feedbackChangesCount, feedbackError)}`)
+
+  if (reasoning) {
+    const preview =
+      reasoning.length > THINKING_PREVIEW_LEN
+        ? reasoning.slice(0, THINKING_PREVIEW_LEN) + ` … (+${reasoning.length - THINKING_PREVIEW_LEN} chars)`
+        : reasoning
+    console.log(``)
+    console.log(`  thinking [${reasoningSource}, ${reasoning.length} chars]:`)
+    for (const line of preview.split('\n')) {
+      console.log(`    ${line}`)
+    }
+  } else {
+    console.log(``)
+    console.log(`  thinking: (none)`)
+  }
+  console.log(``)
+}