spectrum-cli 3.0.1 → 3.1.1

package/CHANGELOG.md

@@ -5,6 +5,34 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 🚀 [3.1.1] - 2026-09-24
+
+### 🪲 Fixed
+
+- Хотфиксы создают раздел с 🩹 и поддерживают запуск подготовки из main/master.
+- Дата раздела changelog необязательна; опубликованная история в прежнем формате сохраняется.
+- Исправлены проверка корня репозитория и сравнение CRLF/LF в release/hotfix на Windows.
+
+## 🚀 [3.1.0] - 2026-09-24
+
+### 🆕 Added
+
+- Добавлен цикл хотфикса: подготовка changelog без merge, публикация stable-тега и перенос исправления в dev.
+
+### 🛠 Changed
+
+- Релизы используют теги release/X.Y.Z, хотфиксы — hotfix/X.Y.Z; старые vX.Y.Z продолжают учитываться.
+
+### 🪲 Fixed
+
+- Повторный release start дополняет открытый релиз, сохраняя версию и удаляя использованные fragments.
+
+## 🚀 [3.0.2] - 2026-09-15
+
+### 🆕 Added
+
+- `spectrum release start` проверяет, что текущая dev-ветка содержит `origin/main` или `origin/master`.
+
 ## 🚀 [3.0.1] - 2026-08-31
 
 ### 🪲 Fixed

package/README.md

@@ -38,9 +38,14 @@ spectrum -v | --version
 
 # 🚀 Управление релизами
 spectrum release start               # Схлопнуть fragments и атомарно отправить release commit в dev и main/master
-spectrum release deploy              # Создать стабильный тег vX.Y.Z из заголовка CHANGELOG
+spectrum release deploy              # Создать стабильный тег release/X.Y.Z из заголовка CHANGELOG
 spectrum release close               # Свести stable main/master в dev
 
+# Срочный patch без переноса незавершённого dev в production
+spectrum hotfix start                # Локальная подготовка 🩹 CHANGELOG на hotfix/* или main/master
+spectrum hotfix deploy               # После merge MR: stable-тег на актуальном main/master
+spectrum hotfix close                # После stable pipeline: main/master → dev
+
 # 📈 Теги chart
 spectrum chart create 1.2.3  # Создать и запушить chart-$name-$version (требует запись в CHANGELOG.md чарта)
 spectrum chart create 1.2.3 --wait   # После пуша тега дождаться публикации версии в Helm-registry
@@ -114,7 +119,7 @@ spectrum-cli/
 | Команда                     | Описание                            |
 | --------------------------- | ----------------------------------- |
 | `spectrum release start`    | Схлопнуть и опубликовать fragments  |
-| `spectrum release deploy`   | Создать стабильный тег vX.Y.Z       |
+| `spectrum release deploy`   | Создать стабильный тег release/X.Y.Z       |
 | `spectrum release close`    | Закрыть релиз                       |
 | `spectrum changelog append` | Создать changelog fragment          |
 | `spectrum changelog check`  | Проверить changelog и fragments     |
@@ -125,9 +130,9 @@ spectrum-cli/
 
 ### 🛡️ Preflight-проверки по командам
 
-- `spectrum release start`: чистая и актуальная dev-ветка, стабильный тег, достижимый из `origin/main` или `origin/master`, отсутствие в `CHANGELOG.md` незакрытых версий новее этого тега, валидные fragments и отсутствие целевых hotfix-веток и тега. Версия вычисляется только из тегов и fragments — `package.json` не читается.
-- `spectrum release deploy`: чистая и актуальная main/master, стабильная версия `X.Y.Z` из верхнего заголовка `CHANGELOG.md`, отсутствие локального и remote-тега `vX.Y.Z`. Команда не создает RC-теги.
-- `spectrum release close`: чистая и актуальная main/master, версия из верхнего заголовка `CHANGELOG.md` и remote-тег `vX.Y.Z`, указывающий на текущий commit.
+- `spectrum release start`: чистая и актуальная dev-ветка, `dev` содержит `origin/main` или `origin/master`, стабильный тег, достижимый из production-ветки, согласованная опубликованная история `CHANGELOG.md` и не более одного открытого релиза. При первом запуске нужны валидные fragments и свободная версия; повторный дополняет открытый раздел без повышения версии. `package.json` не читается.
+- `spectrum release deploy`: чистая и актуальная main/master, стабильная версия `X.Y.Z` из верхнего заголовка `CHANGELOG.md`, отсутствие этой версии среди локальных и remote-тегов всех трёх форм. Команда не создает RC-теги.
+- `spectrum release close`: чистая и актуальная main/master, версия из верхнего заголовка `CHANGELOG.md` и remote stable-тег поддерживаемой формы, указывающий на текущий commit.
 - `spectrum changelog append <message>`: `git-repo`, `changelog-exists`, валидные ID задачи, git identity и тип fragment. Команда не изменяет общий `CHANGELOG.md`.
 - `spectrum changelog check`: `git-repo`, `changelog-exists`, `changelog-prettier-check`, наличие и формат всех changelog fragments.
 - `spectrum chart create <version>`: `git-repo`, `clean-working-tree`, `on-main-branch`, `valid-semver` (переданный `<version>` — semver), `single-chart` (ровно один `charts/<chart-name>/Chart.yaml`), `tag-missing` (тега `chart-<name>-<version>` нет локально и на `origin`).
@@ -141,18 +146,21 @@ spectrum-cli/
 
 Выполняется на `dev`:
 
-1. Проверяет `CHANGELOG.md`, отсутствие релизов новее последнего стабильного тега и все файлы `.changelog/<name>.<type>.md`. Новый релиз нельзя начать, пока предыдущий не получил stable-тег.
-2. После `git fetch origin --prune --tags` находит максимальный стабильный тег `vX.Y.Z`, достижимый из stable-ветки, и применяет к нему максимальное повышение: `breaking` → major, `added` → minor, остальные типы → patch.
-3. Собирает новый релизный блок `## 🚀 [X.Y.Z]` в `CHANGELOG.md` из fragments в стабильном порядке разделов.
-4. Удаляет использованные fragments.
-5. Повторно проверяет формат `CHANGELOG.md`.
-6. Коммитит схлопнутый changelog одним коммитом в `dev` и атомарно пушит этот commit напрямую в `origin/dev` и `origin/main` или `origin/master`, без Merge Request.
+1. Проверяет чистую актуальную dev-ветку, включающую `origin/main` или `origin/master`, changelog и fragments.
+2. После `git fetch origin --prune --tags` находит максимальный stable-тег среди `release/X.Y.Z`, `hotfix/X.Y.Z` и `vX.Y.Z`, достижимый из production-ветки.
+3. Если открытого релиза нет, вычисляет версию по fragments: `breaking` → major, `added` → minor, остальные → patch. Если раздел уже открыт в main/master, сохраняет его версию и дату, объединяет прежние записи с новыми по разделам без дублей. Тип новых fragments не повышает уже выбранную версию.
+4. Форматирует и проверяет `CHANGELOG.md`, затем удаляет использованные fragments.
+5. Коммитит изменения и атомарно пушит dev в `origin/dev` и `origin/main` или `origin/master`, без Merge Request. Если новых записей нет, пустой коммит не создаётся; можно повторить отправку после её сбоя.
+
+Например, повторный `release start` дополняет открытый `1.4.0`; после публикации
+`release/1.4.0` новые fragments уже формируют следующий релиз. Изменение
+опубликованной истории и конфликтующие открытые версии блокируют команду.
 
 Команда не изменяет `package.json`, lock-файлы и не создает `release/*`-веток. Прямой push в stable-ветку должен быть разрешен правилами защиты репозитория; non-fast-forward обновление не выполняется.
 
 ### `spectrum release close`
 
-1. Читает версию из верхнего заголовка `CHANGELOG.md` и проверяет, что стабильный `vX.Y.Z` уже указывает на текущий commit main/master.
+1. Читает версию из верхнего заголовка `CHANGELOG.md` и проверяет, что remote stable-теги этой версии указывают на текущий commit main/master.
 2. Обновляет main/master и dev.
 3. Мержит main/master в dev.
 4. Пушит синхронизированный `dev`.
@@ -160,12 +168,76 @@ spectrum-cli/
 ### `spectrum release deploy`
 
 1. Проверяет актуальную main/master и читает версию `X.Y.Z` из верхнего заголовка `CHANGELOG.md`.
-2. Создает единственный release-тег `vX.Y.Z`.
+2. Создает единственный release-тег `release/X.Y.Z`.
 3. Пушит тег в `origin`. RC-теги CLI не создает.
 
+### Формат стабильных тегов
+
+Новые обычные релизы получают `release/X.Y.Z`, хотфиксы — `hotfix/X.Y.Z`.
+Старый `vX.Y.Z` эквивалентен `release/X.Y.Z`: он участвует в поиске последней
+версии и проверке занятости номера. Старые теги не нужно переименовывать.
+Нумерация общая: после `release/1.2.3` и `hotfix/1.2.4` следующий patch — `1.2.5`.
+Выпустить занятый номер под другим префиксом нельзя. В changelog и версиях
+образов остаётся `X.Y.Z`, без `release/` и `hotfix/`. Это имена **тегов**, не веток.
+
+Все hotfix-команды сначала проверяют ветку: разрешены только `hotfix/*`, `main`
+или `master`. `dev`, `develop`, `feature/*` и detached HEAD отклоняются до fetch.
+Для `start` подходят `hotfix/<TASK>[-slug]` и production-ветка `main/master`,
+содержащая актуальный origin. Локальные исправления и commits допустимы.
+`deploy` и `close` требуют чистый production commit, совпадающий с origin.
+
+### Изолированный цикл хотфикса
+
+Создайте `hotfix/<TASK>` или `hotfix/<TASK>-<slug>` от актуального `origin/main`
+или `origin/master`, либо работайте прямо в актуальной production-ветке
+`main/master`. Включайте только срочное исправление и его patch fragments
+(`fixed`, `security`, `support` либо другой совместимый patch-тип).
+`added` и `breaking` требуют обычного релиза. Все команды запускаются из корня
+репозитория; для `start` нужен Prettier, как для обычной сборки changelog.
+
+1. **`spectrum hotfix start`** обновляет сведения об origin и выбирает опубликованный
+   stable-тег, достижимый из production. Цель — этот stable плюс один patch.
+   Команда формирует верхний раздел `## 🩹 [X.Y.Z] - YYYY-MM-DD` и удаляет только
+   собранные fragments. Она не делает commit, staging, push, merge или tag,
+   не меняет файлы версий и сохраняет посторонние локальные изменения.
+2. Повторный `start` дополняет тот же неопубликованный раздел, сохраняя дату и
+   существующие записи без дублей. Дата необязательна: раздел без даты останется
+   без даты. Старые заголовки с `🚀`, `🩹`, без значка и с датами через точки
+   читаются без переписывания опубликованной истории. Без новых fragments подготовленный раздел
+   остаётся без изменений. Например, от `v6.35.0` первый и повторные запуски
+   готовят `6.35.1`; только после публикации `hotfix/6.35.1` следующий хотфикс получит
+   `6.35.2`. Унаследованные от production fragments не собираются и не меняются.
+3. Проверьте diff, закоммитьте и отправьте исправление по правилам проекта.
+   **В MR из hotfix в production уже должны быть верхний patch-раздел и удаления
+   использованных fragments.** Merge выполняется отдельно после ревью. Если
+   другой хотфикс уже в production, сначала перенесите его изменения в свою
+   ветку и повторите подготовку: пока stable-тега нет, раздел и версия общие.
+4. После доставки подготовленного исправления в production через MR или
+   разрешённый проектом push и проверки RC выполните **`spectrum hotfix deploy`** на чистом
+   `main/master`, точно совпадающем с origin. Команда проверяет следующий patch,
+   неизменность опубликованной истории и отсутствие несобранных hotfix fragments,
+   создаёт `hotfix/X.Y.Z` на проверенном SHA и отправляет **только этот тег**.
+   Повтор после ошибки push допускает существующий локальный тег лишь на том же
+   SHA; опубликованный тег не перемещается. Ветки не сливаются.
+5. После успешного stable pipeline выполните **`spectrum hotfix close`** на том же
+   чистом production commit с тегом `hotfix/X.Y.Z`. Команда обновит `dev/develop` только
+   fast-forward, смержит production в integration и отправит integration.
+   Незавершённая работа и fragments в dev сохраняются. Локальные неопубликованные
+   commits блокируют автоматическую отправку; конфликт остаётся для ручного
+   разрешения, без push. При неуспешном push готового merge проверьте локальный
+   diff и согласуйте ветку вручную — повторный `close` не отправляет локальные
+   commits без проверки.
+
+CLI не проверяет статус CI и не управляет кластером: проверка RC, успешного stable
+pipeline и фактического выката выполняется отдельно в системе доставки. Обычный
+`release start` не используется в этом цикле: он отправляет integration в production.
+`changelog check` проверяет исходные fragments до сборки; после сборки сам `hotfix start`
+проверяет подготовленный раздел. CI проекта должен принимать собранные заметки в MR,
+не требуя повторного fragment для уже включённой записи.
+
 ### Цикл версий и CI
 
-Источник правды о версии — git-тег `vX.Y.Z`. Файлы версий (`package.json`, `Makefile`) не читаются ни CLI, ни CI:
+Источник версии — Git-теги `release/X.Y.Z`, `hotfix/X.Y.Z` и legacy `vX.Y.Z`. Файлы версий (`package.json`, `Makefile`) не читаются ни CLI, ни CI:
 
 | Событие | Источник версии | Артефакт |
 | --- | --- | --- |
@@ -173,11 +245,11 @@ spectrum-cli/
 | коммиты в dev | тег `v1.0.0` + бамп из `.changelog/` | `1.1.0-alpha.SHORTSHA` |
 | `release start` на dev | fragments схлопнуты в `## 🚀 [1.1.0]` | release commit в `dev` и `main/master` |
 | merge в main/master | заголовок CHANGELOG `1.1.0` | `1.1.0-rc.1`, затем `rc.2`, ... |
-| stable-тег `v1.1.0` | git-тег | проверенный RC продвигается в `1.1.0` |
-| merge stable в dev (`release close`) | тег `v1.1.0` + бамп fragments | `X.Y.Z-alpha.SHORTSHA` |
+| stable-тег `release/1.1.0` | git-тег | проверенный RC продвигается в `1.1.0` |
+| merge stable в dev (`release close`) | тег `release/1.1.0` + бамп fragments | `X.Y.Z-alpha.SHORTSHA` |
 
 Номер RC хранится в registry и переиспользуется при retry того же commit SHA.
-Git содержит только стабильные теги `vX.Y.Z`. Stable pipeline проверяет OCI
+Новые stable-теги — `release/X.Y.Z` и `hotfix/X.Y.Z`; старые `vX.Y.Z` сохраняются. Stable pipeline проверяет OCI
 revision обязательных образов и копирует точные RC digest без пересборки. Эту
 CI-часть реализует подключенный release component, а не Spectrum CLI.
 

package/index.js

@@ -4,6 +4,7 @@ const program = new Command();
 
 const git = require("./src/git");
 const release = require("./src/release");
+const hotfix = require("./src/hotfix");
 const changelog = require("./src/changelog");
 const chart = require("./src/chart");
 const token = require("./src/token");
@@ -33,7 +34,7 @@ const releaseCmd = program
 
 releaseCmd
   .command("start")
-  .description("Схлопнуть changelog fragments в dev и создать MR в main/master")
+  .description("Схлопнуть fragments и атомарно отправить release commit в dev и main/master")
   .action(() => runAction(release.releaseStart));
 
 releaseCmd
@@ -43,9 +44,21 @@ releaseCmd
 
 releaseCmd
   .command("deploy")
-  .description("Создать и отправить только стабильный тег vX.Y.Z")
+  .description("Создать и отправить только стабильный тег release/X.Y.Z")
   .action(() => runAction(git.gitCreateTagAndPush));
 
+const hotfixCmd = program.command("hotfix").description("Изолированный цикл срочного patch-релиза");
+
+hotfixCmd.command("start")
+  .description("Подготовить 🩹 CHANGELOG на hotfix/* или main/master, без commit, push и merge")
+  .action(() => runAction(hotfix.hotfixStart));
+hotfixCmd.command("deploy")
+  .description("После merge хотфикса отправить stable-тег с main/master")
+  .action(() => runAction(hotfix.hotfixDeploy));
+hotfixCmd.command("close")
+  .description("После stable pipeline свести production в dev")
+  .action(() => runAction(hotfix.hotfixClose));
+
 // Команды changelog
 const changelogCmd = program
   .command("changelog")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spectrum-cli",
-  "version": "3.0.1",
+  "version": "3.1.1",
   "description": "🚀 Modern CLI for development workflow automation - release management, versioning, and changelog generation",
   "main": "index.js",
   "bin": {

package/src/changelog.js

@@ -270,7 +270,7 @@ function stripLegacyUnreleasedBlock(changelog) {
     return `${changelog.slice(0, unreleasedMatch.index).trimEnd()}\n\n${changelog.slice(end).trimStart()}`;
 }
 
-function renderReleaseBlock(version, fragments, date = new Date().toISOString().slice(0, 10)) {
+function renderReleaseBlock(version, fragments, date = new Date().toISOString().slice(0, 10), marker = '🚀') {
     const fragmentsByType = new Map();
     for (const fragment of fragments) {
         const entries = fragmentsByType.get(fragment.type) || [];
@@ -278,7 +278,7 @@ function renderReleaseBlock(version, fragments, date = new Date().toISOString().
         fragmentsByType.set(fragment.type, entries);
     }
 
-    const lines = [`## 🚀 [${version}] - ${date}`];
+    const lines = [`## ${marker ? `${marker} ` : ''}[${version}]${date ? ` - ${date}` : ''}`];
     for (const [type, config] of Object.entries(FRAGMENT_TYPES)) {
         const entries = fragmentsByType.get(type);
         if (!entries || entries.length === 0) continue;

package/src/git.js

@@ -89,7 +89,7 @@ function gitCreateTagAndPush() {
             { name: 'changelog-release-version', run: requireChangelogReleaseVersion },
             {
                 name: 'tag-missing',
-                run: (ctx) => requireTagMissing(`v${ctx.version}`)
+                run: (ctx) => requireTagMissing(`release/${ctx.version}`)
             }
         ],
         steps: [
@@ -100,16 +100,16 @@ function gitCreateTagAndPush() {
             {
                 name: 'create-tag',
                 run: (ctx) => {
-                    if (!execCommand(`git tag v${ctx.version}`)) return false;
-                    logSuccess('🔖', 'Создан тег v%s.', ctx.version);
+                    if (!execCommand(`git tag release/${ctx.version}`)) return false;
+                    logSuccess('🔖', 'Создан тег release/%s.', ctx.version);
                     return true;
                 }
             },
             {
                 name: 'push-tag',
                 run: (ctx) => {
-                    if (!execCommand(`git push origin v${ctx.version}`)) return false;
-                    logSuccess('🚀', 'Тег v%s отправлен.', ctx.version);
+                    if (!execCommand(`git push origin refs/tags/release/${ctx.version}:refs/tags/release/${ctx.version}`)) return false;
+                    logSuccess('🚀', 'Тег release/%s отправлен.', ctx.version);
                     return true;
                 }
             }

package/src/hotfix-changelog.js

@@ -0,0 +1,94 @@
+const { FRAGMENT_TYPES, SECTION_TO_TYPE } = require('./changelog-config');
+const { renderReleaseBlock } = require('./changelog');
+
+// Parse release boundaries without rewriting any published text.
+function parseChangelog(text) {
+    const headings = [...text.matchAll(/^## .+$/gm)];
+    const releases = headings.map((heading, index) => {
+        const match = heading[0].match(/^##[ \t]+(?:(🚀|🩹)[ \t]*)?\[(\d+\.\d+\.\d+)\](?:[ \t]+-[ \t]+(\d{4}-\d{2}-\d{2}|\d{4}\.\d{2}\.\d{2}|\d{2}\.\d{2}\.\d{4}))?[ \t]*\r?$/);
+        if (!match) {
+            throw new Error(`Некорректный заголовок CHANGELOG.md: ${heading[0]}. Ожидается ## [X.Y.Z], дата необязательна.`);
+        }
+        // Historical duplicates are preserved; callers validate the pending version and immutable history.
+        return {
+            version: match[2], date: match[3] || null, marker: match[1] || '',
+            text: text.slice(heading.index, headings[index + 1]?.index ?? text.length),
+            body: text.slice(heading.index + heading[0].length, headings[index + 1]?.index ?? text.length),
+        };
+    });
+    return { intro: text.slice(0, headings[0]?.index ?? text.length), releases };
+}
+
+function releaseEntries(release, patchOnly = false) {
+    const entries = [];
+    let type;
+    for (const raw of release.body.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line) continue;
+        if (line.startsWith('### ')) {
+            type = SECTION_TO_TYPE[line];
+            if (!type || (patchOnly && FRAGMENT_TYPES[type].bump !== 'patch')) {
+                throw new Error(patchOnly ? 'Хотфикс допускает только patch-разделы CHANGELOG.md.' : 'Неизвестный раздел CHANGELOG.md.');
+            }
+        } else if (type && line.startsWith('- ')) {
+            entries.push({ type, section: FRAGMENT_TYPES[type].section, entries: [line] });
+        } else if (/^\s+\S/.test(raw) && entries.at(-1)?.type === type) {
+            // Formatters may wrap a bullet or its author link onto indented lines.
+            entries.at(-1).entries[0] += ` ${line}`;
+        } else {
+            throw new Error('Не удалось безопасно дополнить раздел релиза: неизвестный формат записи.');
+        }
+    }
+    if (!entries.length) throw new Error('Раздел релиза пуст.');
+    return entries;
+}
+
+function normalizeLineEndings(text) {
+    return text.replace(/\r\n/g, '\n');
+}
+
+function history(document) {
+    return document.releases.map((release) => normalizeLineEndings(release.text).trim()).join('\n\n');
+}
+
+function pendingDocument(text, stableText, target) {
+    const document = parseChangelog(text);
+    const stable = parseChangelog(stableText);
+    const pending = document.releases[0]?.version === target ? document.releases.shift() : null;
+    if (document.releases.some((release) => release.version === target)) {
+        throw new Error('Новый patch-раздел должен быть единственным и находиться в начале CHANGELOG.md.');
+    }
+    if (history(document) !== history(stable) || normalizeLineEndings(document.intro).trim() !== normalizeLineEndings(stable.intro).trim()) {
+        throw new Error('История CHANGELOG.md отличается от stable: допустим только верхний раздел следующего patch.');
+    }
+    return { document, pending, entries: pending ? releaseEntries(pending, true) : [] };
+}
+
+function prepareChangelog({ text, stableText, productionText, target, fragments, date }) {
+    const current = pendingDocument(text, stableText, target);
+    const production = pendingDocument(productionText, stableText, target);
+    const entryKey = (entry) => `${entry.type}:${entry.entries[0]}`;
+    const currentKeys = new Set(current.entries.map(entryKey));
+    if (production.entries.some((entry) => !currentKeys.has(entryKey(entry)))) {
+        throw new Error('Сначала перенесите в hotfix актуальный раздел из production; его записи нельзя терять.');
+    }
+    if (!fragments.length) {
+        if (!current.pending) throw new Error('Нет новых hotfix fragments или подготовленного раздела.');
+        return text;
+    }
+    const merged = [...current.entries];
+    for (const fragment of fragments) {
+        if (fragment.bump !== 'patch') throw new Error('Хотфикс не может включать minor или major fragments.');
+        for (const line of fragment.entries) {
+            const entry = { ...fragment, entries: [line] };
+            if (!currentKeys.has(entryKey(entry))) merged.push(entry);
+            currentKeys.add(entryKey(entry));
+        }
+    }
+    const block = renderReleaseBlock(target, merged, current.pending ? current.pending.date : date, '🩹');
+    // Preserve the published tail byte-for-byte, including its spacing.
+    const tail = current.document.releases.map((release) => release.text).join('');
+    return `${current.document.intro.trimEnd()}\n\n${block.trim()}\n${tail ? `\n${tail}` : ''}`;
+}
+
+module.exports = { parseChangelog, releaseEntries, pendingDocument, prepareChangelog, normalizeLineEndings };

package/src/hotfix.js

@@ -0,0 +1,223 @@
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const preflight = require('./preflight');
+const { execCommand, logSuccess, logError } = require('./utils');
+const { upVersion, compareVersions } = require('./version');
+const { STABLE_TAG_PATTERNS, parseStableTag, stableTagNames } = require('./stable-tags');
+const { CHANGELOG_FILE, CHANGELOG_DIR, FRAGMENT_TYPES, getFragmentType } = require('./changelog-config');
+const { parseChangelog, pendingDocument, prepareChangelog, normalizeLineEndings } = require('./hotfix-changelog');
+
+function git(...args) {
+    try {
+        return execFileSync('git', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    } catch {
+        throw new Error(`Git не выполнил «${args[0]}». Проверьте доступ к origin, состояние веток и конфликты.`);
+    }
+}
+
+function exists(ref) {
+    try {
+        execFileSync('git', ['show-ref', '--verify', '--quiet', ref], { stdio: 'ignore' });
+        return true;
+    } catch (error) {
+        if (error.status === 1) return false;
+        throw new Error(`Не удалось проверить ref ${ref}.`);
+    }
+}
+
+function ancestor(base, head) {
+    try {
+        execFileSync('git', ['merge-base', '--is-ancestor', base, head], { stdio: 'ignore' });
+        return true;
+    } catch (error) {
+        if (error.status === 1) return false;
+        throw new Error('Не удалось проверить историю Git.');
+    }
+}
+
+function readAt(ref, file = CHANGELOG_FILE) {
+    return git('show', `${ref}:${file}`);
+}
+
+function context(mode) {
+    const root = git('rev-parse', '--show-toplevel').trim();
+    if (path.relative(fs.realpathSync(root), fs.realpathSync(process.cwd())) !== '') {
+        throw new Error('Запустите hotfix из корня репозитория.');
+    }
+    const branch = git('branch', '--show-current').trim();
+    if (!['main', 'master'].includes(branch) && !/^hotfix\/.+/.test(branch)) {
+        throw new Error('Hotfix-команды разрешены только на hotfix/*, main или master (не detached HEAD).');
+    }
+    if (mode !== 'start' && !['main', 'master'].includes(branch)) {
+        throw new Error('hotfix deploy/close выполняются на main/master после merge хотфикса.');
+    }
+    if (mode === 'start' && !['main', 'master'].includes(branch) && !/^hotfix\/[A-Z]+-[0-9]+(?:-[A-Za-z0-9][A-Za-z0-9._-]*)?$/.test(branch)) {
+        throw new Error('hotfix start выполняется на hotfix/<TASK>[-slug], main или master.');
+    }
+    if (mode !== 'start' && git('status', '--porcelain').trim()) {
+        throw new Error('Для deploy/close требуется чистое рабочее дерево.');
+    }
+    if (git('ls-files', '--unmerged').trim()) throw new Error('Сначала разрешите конфликты Git.');
+    git('fetch', 'origin', '--prune', '--tags');
+    const mainBranch = ['master', 'main'].find((name) => exists(`refs/remotes/origin/${name}`));
+    if (!mainBranch) throw new Error('Не найдена production-ветка origin/main или origin/master.');
+    const mainRef = `refs/remotes/origin/${mainBranch}`;
+    const mainSha = git('rev-parse', mainRef).trim();
+    const head = git('rev-parse', 'HEAD').trim();
+    if (['main', 'master'].includes(branch) && branch !== mainBranch) {
+        throw new Error(`Production-ветка origin — ${mainBranch}. Переключитесь на неё или на hotfix/<TASK>[-slug].`);
+    }
+    if (mode === 'start') {
+        if (!ancestor(mainSha, head)) throw new Error('Сначала обновите hotfix из актуальной production-ветки.');
+    } else if (branch !== mainBranch || head !== mainSha) {
+        throw new Error(`Нужна ветка ${mainBranch}, точно совпадающая с origin/${mainBranch}.`);
+    }
+    // Query origin explicitly: a local-only tag must never change the baseline.
+    const remoteTags = new Map(git('ls-remote', '--refs', '--tags', 'origin', ...STABLE_TAG_PATTERNS.map((tag) => `refs/tags/${tag}`))
+        .trim().split('\n').filter(Boolean).map((line) => {
+            const [sha, ref] = line.split(/\s+/);
+            return [ref.slice('refs/tags/'.length), sha];
+        }));
+    const versions = git('tag', '--merged', mainSha, '--list', ...STABLE_TAG_PATTERNS).trim().split('\n')
+        .filter((tag) => parseStableTag(tag) && remoteTags.has(tag))
+        .map((tag) => ({ tag, ...parseStableTag(tag) })).sort((a, b) => compareVersions(a.version, b.version));
+    const latest = versions.at(-1);
+    const stable = latest?.version;
+    if (!stable) throw new Error('Для хотфикса необходим опубликованный stable-тег production.');
+    const stableTag = latest.tag;
+    const stableSha = git('rev-parse', `refs/tags/${stableTag}^{commit}`).trim();
+    for (const tag of stableTagNames(stable).filter((name) => remoteTags.has(name))) {
+        if (git('rev-parse', `refs/tags/${tag}^{commit}`).trim() !== stableSha) {
+            throw new Error(`Конфликт stable-тегов версии ${stable}: разные commits.`);
+        }
+    }
+    const stableText = readAt(`refs/tags/${stableTag}`);
+    const productionText = readAt(mainSha);
+    const target = upVersion(stable, 'patch');
+    return { mainBranch, mainSha, head, remoteTags, stable, stableTag, stableText, productionText, target };
+}
+
+function assertTagAvailable(ctx, allowMatchingLocal = false) {
+    for (const tag of stableTagNames(ctx.target)) {
+        if (ctx.remoteTags.has(tag)) throw new Error(`Тег ${tag} уже опубликован; эту версию нельзя выпустить повторно.`);
+        if (exists(`refs/tags/${tag}`) &&
+            (!allowMatchingLocal || tag !== `hotfix/${ctx.target}` || git('rev-parse', `refs/tags/${tag}^{commit}`).trim() !== ctx.head)) {
+            throw new Error(`Локальный тег ${tag} уже существует. Проверьте его перед продолжением.`);
+        }
+    }
+}
+
+function assertOriginUnchanged(ctx) {
+    const line = git('ls-remote', '--heads', 'origin', `refs/heads/${ctx.mainBranch}`).trim();
+    if (line.split(/\s+/)[0] !== ctx.mainSha) {
+        throw new Error('Production изменилась во время проверки. Обновите ветку и повторите команду.');
+    }
+}
+
+function newFragments(baseRef) {
+    const inherited = git('ls-tree', '-r', '-z', '--name-only', baseRef, '--', `${CHANGELOG_DIR}/`)
+        .split('\0').filter(Boolean);
+    for (const file of inherited) {
+        if (!fs.existsSync(file) || normalizeLineEndings(fs.readFileSync(file, 'utf8')) !== normalizeLineEndings(readAt(baseRef, file))) {
+            throw new Error(`Нельзя изменять унаследованный fragment ${file} в хотфиксе.`);
+        }
+    }
+    if (!fs.existsSync(CHANGELOG_DIR)) return [];
+    return fs.readdirSync(CHANGELOG_DIR).sort().filter((name) => !name.startsWith('.'))
+        .map((name) => `${CHANGELOG_DIR}/${name}`).filter((file) => !inherited.includes(file))
+        .map((filePath) => {
+            const type = getFragmentType(filePath);
+            if (!type || !fs.lstatSync(filePath).isFile()) throw new Error(`Некорректный fragment ${filePath}.`);
+            const content = fs.readFileSync(filePath, 'utf8');
+            const entries = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+            if (!entries.length || entries.some((line) => !line.startsWith('- ') || line.length > 120)) {
+                throw new Error(`Пустой или неверно оформленный fragment ${filePath}: записи «- …», до 120 символов.`);
+            }
+            if (FRAGMENT_TYPES[type].bump !== 'patch') throw new Error(`Хотфикс не допускает minor/major: ${filePath}.`);
+            return { filePath, content, type, ...FRAGMENT_TYPES[type], entries };
+        });
+}
+
+function formatChangelog() {
+    const runner = preflight.getPrettierRunner();
+    if (!runner || !execCommand(`${runner} --write CHANGELOG.md`) || !execCommand(`${runner} --check CHANGELOG.md`)) {
+        throw new Error('Не удалось отформатировать CHANGELOG.md; hotfix fragments сохранены.');
+    }
+}
+
+function run(action) {
+    try {
+        action();
+        return true;
+    } catch (error) {
+        logError('❌', error.message);
+        return false;
+    }
+}
+
+function hotfixStart() {
+    return run(() => {
+        const ctx = context('start');
+        assertTagAvailable(ctx);
+        const fragments = newFragments(ctx.mainSha);
+        const original = fs.readFileSync(CHANGELOG_FILE, 'utf8');
+        const updated = prepareChangelog({ text: original, ...ctx, fragments });
+        assertOriginUnchanged(ctx);
+        if (updated !== original || fragments.length) {
+            try {
+                fs.writeFileSync(CHANGELOG_FILE, updated);
+                formatChangelog();
+                // Formatting must not rewrite published history or lose merged notes.
+                prepareChangelog({ text: fs.readFileSync(CHANGELOG_FILE, 'utf8'), ...ctx, fragments: [] });
+                for (const fragment of fragments) fs.unlinkSync(fragment.filePath);
+            } catch (error) {
+                fs.writeFileSync(CHANGELOG_FILE, original);
+                for (const fragment of fragments) fs.writeFileSync(fragment.filePath, fragment.content);
+                throw error;
+            }
+        }
+        logSuccess('✅', `Хотфикс ${ctx.target} подготовлен локально. Проверьте diff и включите CHANGELOG.md и удаления fragments в MR в ${ctx.mainBranch}.`);
+    });
+}
+
+function hotfixDeploy() {
+    return run(() => {
+        const ctx = context('deploy');
+        const prepared = pendingDocument(ctx.productionText, ctx.stableText, ctx.target);
+        if (!prepared.pending) throw new Error(`В CHANGELOG.md нужен верхний подготовленный раздел ${ctx.target}.`);
+        if (newFragments(`refs/tags/${ctx.stableTag}`).length) throw new Error('В production остались несобранные hotfix fragments.');
+        assertTagAvailable(ctx, true);
+        assertOriginUnchanged(ctx);
+        const tag = `hotfix/${ctx.target}`;
+        if (!exists(`refs/tags/${tag}`)) git('tag', tag, ctx.head);
+        git('push', 'origin', `refs/tags/${tag}:refs/tags/${tag}`);
+        logSuccess('✅', `Опубликован ${tag} на ${ctx.head}. Дождитесь успешного stable pipeline перед hotfix close.`);
+    });
+}
+
+function hotfixClose() {
+    return run(() => {
+        const ctx = context('close');
+        const top = parseChangelog(ctx.productionText).releases[0]?.version;
+        const tag = `hotfix/${ctx.stable}`;
+        if (top !== ctx.stable || !ctx.remoteTags.has(tag) || git('rev-parse', `refs/tags/${tag}^{commit}`).trim() !== ctx.head) {
+            throw new Error('Сначала опубликуйте hotfix/X.Y.Z на текущем production commit.');
+        }
+        const dev = ['develop', 'dev'].find((name) => exists(`refs/remotes/origin/${name}`));
+        if (!dev) throw new Error('Не найдена integration-ветка origin/dev или origin/develop.');
+        const devRef = `refs/remotes/origin/${dev}`;
+        if (exists(`refs/heads/${dev}`) && !ancestor(`refs/heads/${dev}`, devRef)) {
+            throw new Error(`В ${dev} есть локальные непубликуемые commits. Сначала согласуйте их с origin/${dev}.`);
+        }
+        assertOriginUnchanged(ctx);
+        if (exists(`refs/heads/${dev}`)) git('switch', dev);
+        else git('switch', '--track', '-c', dev, devRef);
+        git('merge', '--ff-only', devRef);
+        git('merge', '--no-edit', ctx.head);
+        git('push', 'origin', `refs/heads/${dev}:refs/heads/${dev}`);
+        logSuccess('✅', `Хотфикс ${ctx.stable} сведён в ${dev}; production и файлы версий не изменены.`);
+    });
+}
+
+module.exports = { hotfixStart, hotfixDeploy, hotfixClose };

package/src/open-release.js

@@ -0,0 +1,80 @@
+const fs = require('fs');
+const { execSilent, logError, logSuccess } = require('./utils');
+const { compareVersions } = require('./version');
+const { CHANGELOG_FILE, CHANGELOG_DIR } = require('./changelog-config');
+const { parseChangelog, releaseEntries, normalizeLineEndings } = require('./hotfix-changelog');
+const { renderReleaseBlock, stripLegacyUnreleasedBlock } = require('./changelog');
+const { requireChangelogFragments } = require('./preflight');
+
+function splitOpenRelease(text, stableVersion) {
+    const document = parseChangelog(stripLegacyUnreleasedBlock(text));
+    const pending = document.releases.filter((release) => compareVersions(release.version, stableVersion) > 0);
+    if (pending.length > 1 || (pending.length && document.releases[0] !== pending[0])) {
+        throw new Error('Допустим только один открытый релиз в верхнем разделе CHANGELOG.md.');
+    }
+    const open = pending[0] || null;
+    if (open) document.releases.shift();
+    return { document, open, entries: open ? releaseEntries(open) : [] };
+}
+
+function resolveReleaseState(localText, productionText, stableVersion) {
+    const local = splitOpenRelease(localText, stableVersion);
+    const production = splitOpenRelease(productionText, stableVersion);
+    if (local.open && production.open && local.open.version !== production.open.version) {
+        throw new Error('Открытые версии в dev и production различаются. Сначала согласуйте CHANGELOG.md.');
+    }
+    const history = ({ document }) => document.releases.map((release) => normalizeLineEndings(release.text).trim()).join('\n\n');
+    if (history(local) !== history(production)) {
+        throw new Error('Опубликованная история CHANGELOG.md изменена относительно production.');
+    }
+    return { openReleaseVersion: production.open?.version || local.open?.version || null, local, production };
+}
+
+function requireReleaseState(context) {
+    try {
+        const productionText = execSilent(`git show refs/remotes/origin/${context.mainBranch}:${CHANGELOG_FILE}`);
+        if (productionText === null) throw new Error('Не удалось прочитать CHANGELOG.md из production.');
+        const state = resolveReleaseState(fs.readFileSync(CHANGELOG_FILE, 'utf8'), productionText, context.stableVersion);
+        return { ok: true, data: { openReleaseVersion: state.openReleaseVersion, releaseChangelogState: state } };
+    } catch (error) {
+        return { ok: false, reason: error.message };
+    }
+}
+
+function requireReleaseFragments(context) {
+    try {
+        // Empty is valid only for an already prepared release, including retry after a failed push.
+        const entries = fs.existsSync(CHANGELOG_DIR) ? fs.readdirSync(CHANGELOG_DIR).filter((name) => !name.startsWith('.')) : [];
+        if (context.openReleaseVersion && !entries.length) return { ok: true, data: { changelogFragments: [] } };
+        return requireChangelogFragments();
+    } catch (error) {
+        return { ok: false, reason: error.message };
+    }
+}
+
+function appendOpenRelease(context) {
+    try {
+        const { local, production } = context.releaseChangelogState;
+        const open = production.open || local.open;
+        const keys = new Set();
+        const merged = [];
+        for (const fragment of [...production.entries, ...local.entries, ...context.changelogFragments]) {
+            for (const entry of fragment.entries) {
+                const key = `${fragment.type}:${entry}`;
+                if (!keys.has(key)) merged.push({ ...fragment, entries: [entry] });
+                keys.add(key);
+            }
+        }
+        const block = renderReleaseBlock(open.version, merged, open.date, open.marker);
+        const tail = local.document.releases.map((release) => release.text).join('');
+        const updated = `${local.document.intro.trimEnd()}\n\n${block.trim()}\n${tail ? `\n${tail}` : ''}`;
+        fs.writeFileSync(CHANGELOG_FILE, updated);
+        logSuccess('📋', 'Дополнен открытый релиз %s без повышения версии.', open.version);
+        return true;
+    } catch (error) {
+        logError('❌', 'Не удалось дополнить открытый релиз: %s', error.message);
+        return false;
+    }
+}
+
+module.exports = { resolveReleaseState, requireReleaseState, requireReleaseFragments, appendOpenRelease };

package/src/preflight.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 const fs = require('fs');
+const { parseStableTag, stableTagNames } = require('./stable-tags');
 const path = require('path');
 const { execSilent, execCommand, getCurrentBranch, getMainBranch, getDevelopBranch } = require('./utils');
 const {
@@ -154,6 +155,15 @@ function requireCurrentBranchUpToDateWithRemote() {
     return ok({ currentBranch, upstreamBranch: upstreamBranch.trim() });
 }
 
+function requireDevContainsRemoteMain() {
+    const mainBranch = getMainBranch();
+    const remoteMain = `origin/${mainBranch}`;
+    if (!execCommand(`git merge-base --is-ancestor ${remoteMain} HEAD`)) {
+        return fail(`Текущая ветка не содержит ${remoteMain}. Смержите ${remoteMain} в dev и повторите попытку.`);
+    }
+    return ok({ remoteMain });
+}
+
 function requireFileExists(filePath) {
     if (!fs.existsSync(filePath)) {
         return fail(`Обязательный файл "${filePath}" не существует.`);
@@ -234,7 +244,7 @@ function requireNoPendingRelease(stableVersion) {
 
     if (pendingVersions.length > 0) {
         return fail(
-            `В ${CHANGELOG_FILE} найдены незакрытые релизы новее стабильного тега v${stableVersion}: ${pendingVersions.join(', ')}. ` +
+            `В ${CHANGELOG_FILE} найдены незакрытые релизы новее stable-версии ${stableVersion}: ${pendingVersions.join(', ')}. ` +
             'Сначала выполните "spectrum release deploy", дождитесь успешного stable pipeline и выполните "spectrum release close".'
         );
     }
@@ -244,29 +254,29 @@ function requireNoPendingRelease(stableVersion) {
 
 function requireLatestStableVersion() {
     const mainBranch = getMainBranch();
-    const tagNames = execSilent(`git tag --merged origin/${mainBranch} --list "v*"`);
-    const remoteTagRefs = execSilent('git ls-remote --refs --tags origin "refs/tags/v*"');
+    const tagNames = execSilent(`git tag --merged origin/${mainBranch} --list "release/*" "hotfix/*" "v*"`);
+    const remoteTagRefs = execSilent('git ls-remote --refs --tags origin "refs/tags/release/*" "refs/tags/hotfix/*" "refs/tags/v*"');
     if (tagNames === null || remoteTagRefs === null) {
         return fail(`Не удалось проверить стабильные теги, достижимые из origin/${mainBranch}.`);
     }
 
     const remoteTagNames = new Set();
     for (const line of remoteTagRefs.split('\n')) {
-        const match = line.trim().match(/^[0-9a-f]+\s+refs\/tags\/(v\d+\.\d+\.\d+)$/i);
-        if (match) remoteTagNames.add(match[1]);
+        const match = line.trim().match(/^[0-9a-f]+\s+refs\/tags\/(.+)$/i);
+        if (match && parseStableTag(match[1])) remoteTagNames.add(match[1]);
     }
 
     const versions = new Set();
     for (const line of tagNames.split('\n')) {
         const tagName = line.trim();
-        const match = tagName.match(/^v(\d+\.\d+\.\d+)$/);
-        if (match && remoteTagNames.has(tagName) && STABLE_SEMVER_PATTERN.test(match[1])) {
-            versions.add(match[1]);
+        const parsed = parseStableTag(tagName);
+        if (parsed && remoteTagNames.has(tagName)) {
+            versions.add(parsed.version);
         }
     }
 
     if (versions.size === 0) {
-        return fail(`В origin/${mainBranch} не найден достижимый стабильный тег vX.Y.Z.`);
+        return fail(`В origin/${mainBranch} не найден достижимый stable-тег release/X.Y.Z, hotfix/X.Y.Z или vX.Y.Z.`);
     }
 
     const stableVersion = [...versions].sort(compareStableVersions).at(-1);
@@ -274,34 +284,19 @@ function requireLatestStableVersion() {
 }
 
 function requireStableTagAtHead(version) {
-    if (!STABLE_SEMVER_PATTERN.test(String(version || ''))) {
-        return fail('Для закрытия релиза требуется стабильная версия X.Y.Z.');
-    }
-
+    if (!STABLE_SEMVER_PATTERN.test(String(version || ''))) return fail('Требуется stable-версия X.Y.Z.');
     const head = execSilent('git rev-parse HEAD');
-    const tagRefs = execSilent(`git ls-remote --tags origin "refs/tags/v${version}" "refs/tags/v${version}^{}"`);
-    if (!head || tagRefs === null) {
-        return fail(`Не удалось проверить стабильный тег "v${version}".`);
-    }
-
-    let tagCommit = null;
-    for (const line of tagRefs.split('\n')) {
+    const names = stableTagNames(version);
+    const patterns = names.flatMap((tag) => [`"refs/tags/${tag}"`, `"refs/tags/${tag}^{}"`]).join(' ');
+    const tagRefs = execSilent(`git ls-remote --tags origin ${patterns}`);
+    if (!head || tagRefs === null) return fail(`Не удалось проверить stable-теги версии ${version}.`);
+    const refs = new Map(tagRefs.trim().split('\n').filter(Boolean).map((line) => {
         const [sha, ref] = line.trim().split(/\s+/);
-        if (ref === `refs/tags/v${version}^{}`) {
-            tagCommit = sha;
-            break;
-        }
-        if (ref === `refs/tags/v${version}`) {
-            tagCommit = sha;
-        }
-    }
-
-    if (!tagCommit) {
-        return fail(`Стабильный тег "v${version}" отсутствует в origin.`);
-    }
-    if (tagCommit !== head) {
-        return fail(`Стабильный тег "v${version}" указывает не на текущий commit main/master.`);
-    }
+        return [ref, sha];
+    }));
+    const commits = names.map((tag) => refs.get(`refs/tags/${tag}^{}`) || refs.get(`refs/tags/${tag}`)).filter(Boolean);
+    if (!commits.length) return fail(`Stable-тег версии ${version} отсутствует в origin.`);
+    if (commits.some((commit) => commit !== head)) return fail(`Stable-тег ${version} не совпадает с HEAD или конфликтует с alias.`);
     return ok({ stableVersion: version });
 }
 
@@ -313,16 +308,14 @@ function requireYouTrackTask(task) {
 }
 
 function requireTagMissing(tagName) {
-    const localTag = execSilent(`git tag -l "${tagName}"`);
-    if (localTag && localTag.trim()) {
-        return fail(`Тег "${tagName}" уже существует локально.`);
-    }
-
-    const remoteTag = execSilent(`git ls-remote --tags origin "refs/tags/${tagName}"`);
-    if (remoteTag && remoteTag.trim()) {
-        return fail(`Тег "${tagName}" уже существует на origin.`);
-    }
-
+    const parsed = parseStableTag(tagName);
+    const names = parsed ? stableTagNames(parsed.version) : [tagName];
+    const localTag = execSilent(`git tag -l ${names.map((tag) => `"${tag}"`).join(' ')}`);
+    if (localTag === null) return fail('Не удалось проверить локальные теги.');
+    if (localTag.trim()) return fail(`Версия тега ${tagName} уже существует локально: ${localTag}.`);
+    const remoteTag = execSilent(`git ls-remote --tags origin ${names.map((tag) => `"refs/tags/${tag}"`).join(' ')}`);
+    if (remoteTag === null) return fail('Не удалось проверить теги origin.');
+    if (remoteTag.trim()) return fail(`Версия тега ${tagName} уже существует на origin.`);
     return ok();
 }
 
@@ -344,17 +337,19 @@ function requireReleaseVersionAvailable(version) {
         return fail(`Версия "${version}" уже используется hotfix-веткой в origin.`);
     }
 
-    const localTag = execSilent(`git tag --list "v${version}"`);
+    const names = stableTagNames(version);
+    const localTag = execSilent(`git tag --list ${names.map((tag) => `"${tag}"`).join(' ')}`);
+    if (localTag === null) return fail('Не удалось проверить локальные stable-теги.');
     if (localTag && localTag.trim()) {
-        return fail(`Релизный тег "v${version}" уже существует локально.`);
+        return fail(`Релизный тег версии ${version} уже существует локально.`);
     }
 
-    const remoteTag = execSilent(`git ls-remote --tags origin "refs/tags/v${version}" "refs/tags/v${version}^{}"`);
+    const remoteTag = execSilent(`git ls-remote --tags origin ${names.flatMap((tag) => [`"refs/tags/${tag}"`, `"refs/tags/${tag}^{}"`]).join(' ')}`);
     if (remoteTag === null) {
-        return fail(`Не удалось проверить тег "v${version}" в origin.`);
+        return fail(`Не удалось проверить тег версии ${version} в origin.`);
     }
     if (remoteTag && remoteTag.trim()) {
-        return fail(`Релизный тег "v${version}" уже существует в origin.`);
+        return fail(`Релизный тег версии ${version} уже существует в origin.`);
     }
     return ok();
 }
@@ -772,6 +767,7 @@ module.exports = {
     requireRemoteOrigin,
     requireRemoteReachable,
     requireCurrentBranchUpToDateWithRemote,
+    requireDevContainsRemoteMain,
     requireFileExists,
     getChangelogReleaseVersions,
     getChangelogReleaseVersion,

package/src/release.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 const { goToDevBranch, goToMainBranch, updateCurrentBranch } = require('./git');
 const { changelogBuildRelease, changelogRemoveFragments } = require('./changelog');
-const { logSuccess, logError, execCommand, getCurrentBranch, getMainBranch } = require('./utils');
+const { logSuccess, logError, execCommand, execSilent, getCurrentBranch, getMainBranch } = require('./utils');
+const { requireReleaseState, requireReleaseFragments, appendOpenRelease } = require('./open-release');
 const { runCommand } = require('./command-executor');
 const { upVersion } = require('./version');
 const {
@@ -10,15 +11,14 @@ const {
     requireCurrentBranchUpToDateWithRemote,
     requireMainAndDevBranches,
     requireOnDevBranch,
+    requireDevContainsRemoteMain,
     requireOnMainBranch,
     requireReleaseVersionAvailable,
     requireChangelogReleaseVersion,
-    requireNoPendingRelease,
     requireLatestStableVersion,
     requireStableTagAtHead,
     requireFileExists,
     requireChangelogFormatted,
-    requireChangelogFragments,
     getPrettierRunner
 } = require('./preflight');
 const { CHANGELOG_FILE, CHANGELOG_DIR } = require('./changelog-config');
@@ -65,7 +65,14 @@ function resolveReleaseVersion(stableVersion, fragments) {
 }
 
 function releaseCommit(context) {
-    if (!execCommand(`git add --all -- ${CHANGELOG_FILE} ${CHANGELOG_DIR}`)) return false;
+    const paths = context.changelogFragments?.length ? `${CHANGELOG_FILE} ${CHANGELOG_DIR}` : CHANGELOG_FILE;
+    if (!execCommand(`git add --all -- ${paths}`)) return false;
+    const staged = execSilent('git diff --cached --name-only');
+    if (staged === null) return false;
+    if (!staged.trim()) {
+        logSuccess('📋', 'Новых changelog-записей нет; пустой коммит не создаётся.');
+        return true;
+    }
     if (!execCommand(`git commit --message "📝 Подготовить релиз ${context.newVersion}." --no-verify`)) return false;
 
     logSuccess('📝', 'Коммит со схлопнутыми changelog fragments создан.');
@@ -155,15 +162,18 @@ function releaseStart() {
             { name: 'branch-up-to-date', run: requireCurrentBranchUpToDateWithRemote },
             { name: 'main-and-dev-branches', run: requireMainAndDevBranches },
             { name: 'on-dev-branch', run: requireOnDevBranch },
+            { name: 'dev-contains-main', run: requireDevContainsRemoteMain },
             { name: 'stable-version', run: requireLatestStableVersion },
             { name: 'changelog-exists', run: () => requireFileExists(CHANGELOG_FILE) },
-            { name: 'no-pending-release', run: (ctx) => requireNoPendingRelease(ctx.stableVersion) },
+            { name: 'release-state', run: requireReleaseState },
             { name: 'changelog-prettier-check', run: requireChangelogFormatted },
-            { name: 'changelog-fragments', run: requireChangelogFragments },
+            { name: 'changelog-fragments', run: requireReleaseFragments },
             {
                 name: 'detect-bump-type',
                 run: (ctx) => {
-                    const resolved = resolveReleaseVersion(ctx.stableVersion, ctx.changelogFragments);
+                    const resolved = ctx.openReleaseVersion
+                        ? { bumpType: detectBumpType(ctx.changelogFragments), newVersion: ctx.openReleaseVersion }
+                        : resolveReleaseVersion(ctx.stableVersion, ctx.changelogFragments);
                     if (!resolved) {
                         return { ok: false, reason: 'Не удалось вычислить release-версию от последнего стабильного тега.' };
                     }
@@ -175,10 +185,10 @@ function releaseStart() {
             }
         ],
         steps: [
-            { name: 'build-release-changelog', run: changelogBuildRelease },
-            { name: 'remove-changelog-fragments', run: changelogRemoveFragments },
+            { name: 'build-release-changelog', run: (ctx) => ctx.openReleaseVersion ? appendOpenRelease(ctx) : changelogBuildRelease(ctx) },
             { name: 'format-changelog', run: releaseFormatChangelog },
             { name: 'lint-changelog', run: releaseCheckChangelogLint },
+            { name: 'remove-changelog-fragments', run: (ctx) => !ctx.changelogFragments.length || changelogRemoveFragments(ctx) },
             { name: 'commit-release', run: releaseCommit },
             { name: 'push-dev-and-main', run: releasePush }
         ]

package/src/stable-tags.js

@@ -0,0 +1,15 @@
+const { STABLE_VERSION_PATTERN } = require('./version');
+const STABLE_TAG_PATTERNS = ['release/*', 'hotfix/*', 'v*'];
+
+function parseStableTag(tag) {
+    const match = /^(release\/|hotfix\/|v)(.*)$/.exec(String(tag || ''));
+    if (!match || !STABLE_VERSION_PATTERN.test(match[2])) return null;
+    return { version: match[2], kind: match[1] === 'hotfix/' ? 'hotfix' : 'release' };
+}
+
+function stableTagNames(version) {
+    if (!STABLE_VERSION_PATTERN.test(String(version || ''))) throw new Error('Ожидается stable-версия X.Y.Z.');
+    return [`release/${version}`, `hotfix/${version}`, `v${version}`];
+}
+
+module.exports = { STABLE_TAG_PATTERNS, parseStableTag, stableTagNames };