@cleocode/core 2026.4.13 → 2026.4.15

package/dist/release/release-manifest.js

@@ -1,1019 +0,0 @@
-/**
- * Release manifest operations backed by the release_manifests SQLite table.
- *
- * Migrated from .cleo/releases.json to SQLite per T5580.
- * All reads/writes now go through Drizzle ORM via tasks.db.
- *
- * @task T5580
- * @task T4788
- */
-import { execFileSync } from 'node:child_process';
-import { existsSync, renameSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { and, count, desc, eq } from 'drizzle-orm';
-import { createPage } from '../pagination.js';
-import { getCleoDirAbsolute, getProjectRoot } from '../paths.js';
-import * as schema from '../store/tasks-schema.js';
-import { parseChangelogBlocks, writeChangelogSection } from './changelog-writer.js';
-import { resolveChannelFromBranch } from './channel.js';
-import { detectBranchProtection } from './github-pr.js';
-import { getChannelConfig, getGitFlowConfig, getPushMode, loadReleaseConfig, } from './release-config.js';
-import { getVersionBumpConfig } from './version-bump.js';
-async function getDb(cwd) {
-    const { getDb: _getDb } = await import('../store/sqlite.js');
-    return _getDb(cwd);
-}
-function normalizeLimit(limit) {
-    return typeof limit === 'number' && limit > 0 ? limit : undefined;
-}
-function normalizeOffset(offset) {
-    return typeof offset === 'number' && offset > 0 ? offset : undefined;
-}
-function effectivePageLimit(limit, offset) {
-    return limit ?? (offset !== undefined ? 50 : undefined);
-}
-// ── Internal helpers ─────────────────────────────────────────────────
-function isValidVersion(version) {
-    return /^v?\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$/.test(version);
-}
-function validateCalVerWindow(version, now = new Date()) {
-    const normalized = version.startsWith('v') ? version.slice(1) : version;
-    const base = normalized.split('-')[0] ?? normalized;
-    const parts = base.split('.');
-    if (parts.length !== 3) {
-        return { valid: false, message: `Invalid CalVer format: ${version}` };
-    }
-    const tagYear = Number.parseInt(parts[0] ?? '', 10);
-    const tagMonth = Number.parseInt(parts[1] ?? '', 10);
-    if (!Number.isInteger(tagYear) || !Number.isInteger(tagMonth)) {
-        return { valid: false, message: `Invalid CalVer date components: ${version}` };
-    }
-    const currentYear = now.getUTCFullYear();
-    const currentMonth = now.getUTCMonth() + 1;
-    const nextMonth = currentMonth === 12 ? 1 : currentMonth + 1;
-    const nextYear = currentMonth === 12 ? currentYear + 1 : currentYear;
-    const isPreRelease = normalized.includes('-');
-    if (isPreRelease) {
-        const valid = (tagYear === currentYear || tagYear === nextYear) &&
-            (tagMonth === currentMonth || tagMonth === nextMonth);
-        return {
-            valid,
-            message: valid
-                ? `CalVer OK (pre-release): ${version}`
-                : `Pre-release ${version} outside allowed CalVer range ${currentYear}.${currentMonth} or ${nextYear}.${nextMonth}`,
-        };
-    }
-    const valid = tagYear === currentYear && tagMonth === currentMonth;
-    return {
-        valid,
-        message: valid
-            ? `CalVer OK (stable): ${version}`
-            : `${version} does not match current CalVer ${currentYear}.${currentMonth}`,
-    };
-}
-function normalizeVersion(version) {
-    return version.startsWith('v') ? version : `v${version}`;
-}
-function rowToManifest(row) {
-    return {
-        version: row.version,
-        status: row.status,
-        createdAt: row.createdAt,
-        preparedAt: row.preparedAt ?? undefined,
-        committedAt: row.committedAt ?? undefined,
-        taggedAt: row.taggedAt ?? undefined,
-        pushedAt: row.pushedAt ?? undefined,
-        tasks: JSON.parse(row.tasksJson),
-        notes: row.notes ?? undefined,
-        changelog: row.changelog ?? undefined,
-        previousVersion: row.previousVersion ?? undefined,
-        commitSha: row.commitSha ?? undefined,
-        gitTag: row.gitTag ?? undefined,
-    };
-}
-async function findLatestPushedVersion(cwd) {
-    const db = await getDb(cwd);
-    const rows = await db
-        .select({ version: schema.releaseManifests.version })
-        .from(schema.releaseManifests)
-        .where(eq(schema.releaseManifests.status, 'pushed'))
-        .orderBy(desc(schema.releaseManifests.pushedAt))
-        .limit(1)
-        .all();
-    return rows[0]?.version;
-}
-// ── Public API ───────────────────────────────────────────────────────
-/**
- * Prepare a release (create a release manifest entry).
- * @task T4788
- */
-export async function prepareRelease(version, tasks, notes, loadTasksFn, cwd) {
-    if (!version) {
-        throw new Error('version is required');
-    }
-    if (!isValidVersion(version)) {
-        throw new Error(`Invalid version format: ${version} (expected X.Y.Z or YYYY.M.patch)`);
-    }
-    const normalizedVersion = normalizeVersion(version);
-    const db = await getDb(cwd);
-    const existing = await db
-        .select()
-        .from(schema.releaseManifests)
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .limit(1)
-        .all();
-    if (existing.length > 0) {
-        throw new Error(`Release ${normalizedVersion} already exists (status: ${existing[0].status})`);
-    }
-    let releaseTasks = tasks ?? [];
-    if (releaseTasks.length === 0) {
-        const allTasks = await loadTasksFn();
-        releaseTasks = allTasks.filter((t) => t.status === 'done' && t.completedAt).map((t) => t.id);
-    }
-    // Filter out epic IDs
-    const allTasks = await loadTasksFn();
-    const epicIds = new Set(allTasks.filter((t) => allTasks.some((c) => c.parentId === t.id)).map((t) => t.id));
-    releaseTasks = releaseTasks.filter((id) => !epicIds.has(id));
-    const previousVersion = await findLatestPushedVersion(cwd);
-    const now = new Date().toISOString();
-    const id = `rel-${normalizedVersion.replace(/[^a-z0-9]/gi, '-')}`;
-    await db
-        .insert(schema.releaseManifests)
-        .values({
-        id,
-        version: normalizedVersion,
-        status: 'prepared',
-        tasksJson: JSON.stringify(releaseTasks),
-        notes: notes ?? null,
-        previousVersion: previousVersion ?? null,
-        createdAt: now,
-        preparedAt: now,
-    })
-        .run();
-    return {
-        version: normalizedVersion,
-        status: 'prepared',
-        tasks: releaseTasks,
-        taskCount: releaseTasks.length,
-    };
-}
-/**
- * Generate changelog for a release.
- * @task T4788
- */
-export async function generateReleaseChangelog(version, loadTasksFn, cwd) {
-    if (!version) {
-        throw new Error('version is required');
-    }
-    const normalizedVersion = normalizeVersion(version);
-    const db = await getDb(cwd);
-    const rows = await db
-        .select()
-        .from(schema.releaseManifests)
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .limit(1)
-        .all();
-    if (rows.length === 0) {
-        throw new Error(`Release ${normalizedVersion} not found`);
-    }
-    const row = rows[0];
-    const releaseTasks = JSON.parse(row.tasksJson);
-    const allTasks = await loadTasksFn();
-    const taskMap = new Map(allTasks.map((t) => [t.id, t]));
-    const features = [];
-    const fixes = [];
-    const chores = [];
-    const docs = [];
-    const tests = [];
-    const changes = [];
-    /**
-     * Strip conventional commit prefixes from task titles.
-     * e.g. "feat: add auth" → "Add auth", "fix(ui): button" → "Button"
-     */
-    function stripConventionalPrefix(title) {
-        return title.replace(/^(feat|fix|docs?|test|chore|refactor|style|ci|build|perf)(\([^)]+\))?:\s*/i, '');
-    }
-    /**
-     * Capitalize the first character of a string.
-     */
-    function capitalize(s) {
-        return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
-    }
-    /**
-     * Build a changelog entry line for a task.
-     * Uses description to enrich the entry when it's meaningfully different from the title.
-     */
-    function buildEntry(task) {
-        const cleanTitle = capitalize(stripConventionalPrefix(task.title));
-        // Strip newlines and collapse whitespace in description
-        const safeDesc = task.description
-            ?.replace(/\r?\n/g, ' ')
-            .replace(/\s{2,}/g, ' ')
-            .trim();
-        const desc = safeDesc;
-        // Include description only when it's non-trivial and adds information beyond the title.
-        // Skip if: description is empty, identical to title, or a minor rephrasing (≤10% longer, no new words).
-        const shouldIncludeDesc = (() => {
-            if (!desc || desc.length === 0)
-                return false;
-            const titleNorm = cleanTitle
-                .toLowerCase()
-                .replace(/[^a-z0-9\s]/g, '')
-                .trim();
-            const descNorm = desc
-                .toLowerCase()
-                .replace(/[^a-z0-9\s]/g, '')
-                .trim();
-            if (titleNorm === descNorm)
-                return false;
-            if (descNorm.startsWith(titleNorm) && descNorm.length < titleNorm.length * 1.3)
-                return false;
-            // Require description to be at least 20 chars and contain different content
-            return desc.length >= 20;
-        })();
-        if (shouldIncludeDesc) {
-            // Truncate long descriptions to keep changelog readable
-            const descDisplay = desc.length > 150 ? desc.slice(0, 147) + '...' : desc;
-            return `- **${cleanTitle}**: ${descDisplay} (${task.id})`;
-        }
-        return `- ${cleanTitle} (${task.id})`;
-    }
-    /**
-     * Categorize a task into a changelog section.
-     * Priority order:
-     *   1. task.type field ('epic' → skip, others are hints for 'task'/'subtask')
-     *   2. task.labels array
-     *   3. Title keyword scan (with conventional prefix stripped)
-     */
-    function categorizeTask(task) {
-        // Fix A: Skip epics entirely — they are parent containers, not deliverables
-        if (task.type === 'epic')
-            return 'changes'; // Will be filtered out by the caller
-        // Priority 1: task.type field is the most authoritative signal
-        const taskType = (task.type ?? '').toLowerCase();
-        if (taskType === 'test')
-            return 'tests';
-        if (taskType === 'fix' || taskType === 'bugfix')
-            return 'fixes';
-        if (taskType === 'feat' || taskType === 'feature')
-            return 'features';
-        if (taskType === 'docs' || taskType === 'doc')
-            return 'docs';
-        if (taskType === 'chore' || taskType === 'refactor')
-            return 'chores';
-        // Priority 2: conventional commit prefix in raw title
-        if (/^feat(\([^)]+\))?:/.test(task.title.toLowerCase()))
-            return 'features';
-        if (/^fix(\([^)]+\))?:/.test(task.title.toLowerCase()))
-            return 'fixes';
-        if (/^docs?(\([^)]+\))?:/.test(task.title.toLowerCase()))
-            return 'docs';
-        if (/^test(\([^)]+\))?:/.test(task.title.toLowerCase()))
-            return 'tests';
-        if (/^(chore|refactor|style|ci|build|perf)(\([^)]+\))?:/.test(task.title.toLowerCase()))
-            return 'chores';
-        // Priority 3: labels for strong category signals
-        const labels = task.labels ?? [];
-        if (labels.some((l) => ['test', 'testing'].includes(l.toLowerCase())))
-            return 'tests';
-        if (labels.some((l) => ['fix', 'bug', 'bugfix', 'regression'].includes(l.toLowerCase())))
-            return 'fixes';
-        if (labels.some((l) => ['feat', 'feature', 'enhancement', 'add'].includes(l.toLowerCase())))
-            return 'features';
-        if (labels.some((l) => ['docs', 'documentation'].includes(l.toLowerCase())))
-            return 'docs';
-        if (labels.some((l) => ['chore', 'refactor', 'cleanup', 'maintenance'].includes(l.toLowerCase())))
-            return 'chores';
-        // Priority 4: keyword scan on the cleaned title
-        const titleLower = stripConventionalPrefix(task.title).toLowerCase();
-        const rawTitleLower = task.title.toLowerCase();
-        if (titleLower.startsWith('test') ||
-            (titleLower.includes('test') && titleLower.includes('add')))
-            return 'tests';
-        if (titleLower.includes('bug') ||
-            titleLower.startsWith('fix') ||
-            titleLower.includes('regression') ||
-            titleLower.includes('broken'))
-            return 'fixes';
-        if (titleLower.startsWith('add ') ||
-            titleLower.includes('implement') ||
-            titleLower.startsWith('create ') ||
-            titleLower.startsWith('introduce '))
-            return 'features';
-        if (titleLower.startsWith('doc') ||
-            titleLower.includes('documentation') ||
-            titleLower.includes('readme') ||
-            titleLower.includes('changelog'))
-            return 'docs';
-        if (titleLower.startsWith('chore') ||
-            titleLower.includes('refactor') ||
-            titleLower.includes('cleanup') ||
-            titleLower.includes('migrate') ||
-            titleLower.includes('upgrade') ||
-            titleLower.includes('remove ') ||
-            titleLower.startsWith('audit'))
-            return 'chores';
-        // Raw title scan for backward compat
-        if (rawTitleLower.startsWith('feat'))
-            return 'features';
-        return 'changes';
-    }
-    for (const taskId of releaseTasks) {
-        const task = taskMap.get(taskId);
-        if (!task)
-            continue;
-        // Fix A: Filter out epics — they are containers, not changelog entries
-        if (task.type === 'epic')
-            continue;
-        // Also filter by label in case type field is not populated
-        if (task.labels?.some((l) => l.toLowerCase() === 'epic'))
-            continue;
-        // Heuristic: titles starting with "EPIC:" are epics even without type field
-        if (/^epic:/i.test(task.title.trim()))
-            continue;
-        // Filter out research/internal/spike/audit tasks — not user-facing deliverables
-        const labelsLower = (task.labels ?? []).map((l) => l.toLowerCase());
-        if (labelsLower.some((l) => ['research', 'internal', 'spike', 'audit'].includes(l)))
-            continue;
-        if (['spike', 'research'].includes((task.type ?? '').toLowerCase()))
-            continue;
-        if (/^(research|investigate|audit|spike)\s/i.test(task.title.trim()))
-            continue;
-        const category = categorizeTask(task);
-        const entry = buildEntry(task);
-        if (category === 'features')
-            features.push(entry);
-        else if (category === 'fixes')
-            fixes.push(entry);
-        else if (category === 'docs')
-            docs.push(entry);
-        else if (category === 'tests')
-            tests.push(entry);
-        else if (category === 'chores')
-            chores.push(entry);
-        else
-            changes.push(entry);
-    }
-    const sections = [];
-    const date = new Date().toISOString().split('T')[0];
-    sections.push(`## ${normalizedVersion} (${date})`);
-    sections.push('');
-    if (row.notes) {
-        sections.push(row.notes);
-        sections.push('');
-    }
-    if (features.length > 0) {
-        sections.push('### Features');
-        sections.push(...features);
-        sections.push('');
-    }
-    if (fixes.length > 0) {
-        sections.push('### Bug Fixes');
-        sections.push(...fixes);
-        sections.push('');
-    }
-    if (docs.length > 0) {
-        sections.push('### Documentation');
-        sections.push(...docs);
-        sections.push('');
-    }
-    if (tests.length > 0) {
-        sections.push('### Tests');
-        sections.push(...tests);
-        sections.push('');
-    }
-    if (chores.length > 0) {
-        sections.push('### Chores');
-        sections.push(...chores);
-        sections.push('');
-    }
-    if (changes.length > 0) {
-        sections.push('### Changes');
-        sections.push(...changes);
-        sections.push('');
-    }
-    const changelog = sections.join('\n');
-    await db
-        .update(schema.releaseManifests)
-        .set({ changelog })
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .run();
-    // Write or update CHANGELOG.md with section-aware merge
-    const changelogPath = join(cwd ?? process.cwd(), 'CHANGELOG.md');
-    let existingChangelogContent = '';
-    try {
-        existingChangelogContent = await readFile(changelogPath, 'utf8');
-    }
-    catch {
-        // File doesn't exist yet — start fresh
-    }
-    const { customBlocks } = parseChangelogBlocks(existingChangelogContent);
-    // Build the changelog body (content after the ## header line)
-    const changelogBody = sections.slice(2).join('\n'); // skip header + blank line
-    await writeChangelogSection(normalizedVersion.replace(/^v/, ''), changelogBody, customBlocks, changelogPath);
-    return {
-        version: normalizedVersion,
-        changelog,
-        taskCount: releaseTasks.length,
-        sections: {
-            features: features.length,
-            fixes: fixes.length,
-            docs: docs.length,
-            tests: tests.length,
-            chores: chores.length,
-            changes: changes.length,
-        },
-    };
-}
-/**
- * List all releases.
- * @task T4788
- */
-export async function listManifestReleases(optionsOrCwd, cwd) {
-    const options = typeof optionsOrCwd === 'string' || optionsOrCwd === undefined ? {} : optionsOrCwd;
-    const effectiveCwd = typeof optionsOrCwd === 'string' ? optionsOrCwd : cwd;
-    const limit = normalizeLimit(options.limit);
-    const offset = normalizeOffset(options.offset);
-    const pageLimit = effectivePageLimit(limit, offset);
-    const db = await getDb(effectiveCwd);
-    const totalRow = await db.select({ count: count() }).from(schema.releaseManifests).get();
-    const total = totalRow?.count ?? 0;
-    const conditions = options.status ? [eq(schema.releaseManifests.status, options.status)] : [];
-    const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
-    const filteredRow = await db
-        .select({ count: count() })
-        .from(schema.releaseManifests)
-        .where(whereClause)
-        .get();
-    const filtered = filteredRow?.count ?? 0;
-    let query = db
-        .select()
-        .from(schema.releaseManifests)
-        .where(whereClause)
-        .orderBy(desc(schema.releaseManifests.createdAt));
-    if (pageLimit !== undefined) {
-        query = query.limit(pageLimit);
-    }
-    if (offset !== undefined) {
-        query = query.offset(offset);
-    }
-    const rows = await query.all();
-    const latest = await findLatestPushedVersion(effectiveCwd);
-    return {
-        releases: rows.map((r) => ({
-            version: r.version,
-            status: r.status,
-            createdAt: r.createdAt,
-            taskCount: JSON.parse(r.tasksJson).length,
-        })),
-        total,
-        filtered,
-        latest,
-        page: createPage({ total: filtered, limit: pageLimit, offset }),
-    };
-}
-/**
- * Show release details.
- * @task T4788
- */
-export async function showManifestRelease(version, cwd) {
-    if (!version) {
-        throw new Error('version is required');
-    }
-    const normalizedVersion = normalizeVersion(version);
-    const db = await getDb(cwd);
-    const rows = await db
-        .select()
-        .from(schema.releaseManifests)
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .limit(1)
-        .all();
-    if (rows.length === 0) {
-        throw new Error(`Release ${normalizedVersion} not found`);
-    }
-    return rowToManifest(rows[0]);
-}
-/**
- * Mark release as committed (metadata only).
- * @task T4788
- */
-export async function commitRelease(version, cwd) {
-    if (!version) {
-        throw new Error('version is required');
-    }
-    const normalizedVersion = normalizeVersion(version);
-    const db = await getDb(cwd);
-    const rows = await db
-        .select()
-        .from(schema.releaseManifests)
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .limit(1)
-        .all();
-    if (rows.length === 0) {
-        throw new Error(`Release ${normalizedVersion} not found`);
-    }
-    if (rows[0].status !== 'prepared') {
-        throw new Error(`Release ${normalizedVersion} is in state '${rows[0].status}', expected 'prepared'`);
-    }
-    const committedAt = new Date().toISOString();
-    await db
-        .update(schema.releaseManifests)
-        .set({ status: 'committed', committedAt })
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .run();
-    return { version: normalizedVersion, status: 'committed', committedAt };
-}
-/**
- * Mark release as tagged (metadata only).
- * @task T4788
- */
-export async function tagRelease(version, cwd) {
-    if (!version) {
-        throw new Error('version is required');
-    }
-    const normalizedVersion = normalizeVersion(version);
-    const db = await getDb(cwd);
-    const rows = await db
-        .select()
-        .from(schema.releaseManifests)
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .limit(1)
-        .all();
-    if (rows.length === 0) {
-        throw new Error(`Release ${normalizedVersion} not found`);
-    }
-    const taggedAt = new Date().toISOString();
-    await db
-        .update(schema.releaseManifests)
-        .set({ status: 'tagged', taggedAt })
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .run();
-    return { version: normalizedVersion, status: 'tagged', taggedAt };
-}
-/**
- * Run release validation gates.
- * @task T4788
- * @task T5586
- */
-export async function runReleaseGates(version, loadTasksFn, cwd, opts) {
-    if (!version) {
-        throw new Error('version is required');
-    }
-    const normalizedVersion = normalizeVersion(version);
-    const db = await getDb(cwd);
-    const rows = await db
-        .select()
-        .from(schema.releaseManifests)
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .limit(1)
-        .all();
-    if (rows.length === 0) {
-        throw new Error(`Release ${normalizedVersion} not found`);
-    }
-    const row = rows[0];
-    const releaseTasks = JSON.parse(row.tasksJson);
-    const gates = [];
-    gates.push({
-        name: 'version_valid',
-        status: isValidVersion(normalizedVersion) ? 'passed' : 'failed',
-        message: isValidVersion(normalizedVersion)
-            ? 'Version format is valid'
-            : 'Invalid version format',
-    });
-    const releaseConfig = loadReleaseConfig(cwd);
-    if (releaseConfig.versioningScheme === 'calver') {
-        const calver = validateCalVerWindow(normalizedVersion);
-        gates.push({
-            name: 'calver_window',
-            status: calver.valid ? 'passed' : 'failed',
-            message: calver.message,
-        });
-    }
-    gates.push({
-        name: 'has_tasks',
-        status: releaseTasks.length > 0 ? 'passed' : 'failed',
-        message: releaseTasks.length > 0 ? `${releaseTasks.length} tasks included` : 'No tasks in release',
-    });
-    gates.push({
-        name: 'has_changelog',
-        status: row.changelog ? 'passed' : 'failed',
-        message: row.changelog
-            ? 'Changelog generated'
-            : 'No changelog generated. Run release.changelog first.',
-    });
-    const allTasks = await loadTasksFn();
-    const incompleteTasks = releaseTasks.filter((id) => {
-        const task = allTasks.find((t) => t.id === id);
-        return task && task.status !== 'done';
-    });
-    gates.push({
-        name: 'tasks_complete',
-        status: incompleteTasks.length === 0 ? 'passed' : 'failed',
-        message: incompleteTasks.length === 0
-            ? 'All tasks completed'
-            : `${incompleteTasks.length} tasks not completed: ${incompleteTasks.join(', ')}`,
-    });
-    // G2: Build artifact — dist/ must exist (Node projects only)
-    // Monorepo-aware: checks packages/cleo/dist/ first, then root dist/
-    const projectRoot = cwd ?? getProjectRoot();
-    const monorepoDist = join(projectRoot, 'packages', 'cleo', 'dist', 'cli', 'index.js');
-    const rootDist = join(projectRoot, 'dist', 'cli', 'index.js');
-    const distExists = existsSync(monorepoDist) || existsSync(rootDist);
-    const isNodeProject = existsSync(join(projectRoot, 'package.json'));
-    if (isNodeProject) {
-        gates.push({
-            name: 'build_artifact',
-            status: distExists ? 'passed' : 'failed',
-            message: distExists ? 'Build artifacts present' : 'dist/ not built — run: pnpm run build',
-        });
-    }
-    // GD1: Clean working tree (CHANGELOG.md and version bump targets are allowed to be dirty)
-    // Skipped in dry-run mode — dry-run makes no commits so tree cleanliness is irrelevant.
-    // Untracked files (?? lines) are excluded from the dirty check — they do not affect git
-    // commit/tag operations and must not block releases.
-    if (opts?.dryRun) {
-        gates.push({
-            name: 'clean_working_tree',
-            status: 'passed',
-            message: 'Skipped in dry-run mode',
-        });
-    }
-    else {
-        // Dynamically build exclusion set from configured version bump targets + CHANGELOG.md
-        const bumpTargets = getVersionBumpConfig(cwd);
-        const allowedDirty = new Set(['CHANGELOG.md', ...bumpTargets.map((t) => t.file)]);
-        let workingTreeClean = true;
-        let dirtyFiles = [];
-        try {
-            const porcelain = execFileSync('git', ['status', '--porcelain'], {
-                cwd: projectRoot,
-                encoding: 'utf-8',
-                stdio: 'pipe',
-            });
-            dirtyFiles = porcelain
-                .split('\n')
-                .filter((l) => l.trim())
-                // Exclude untracked files (?? prefix) — they don't affect commits or tags
-                .filter((l) => !l.startsWith('?? '))
-                .map((l) => l.slice(3).trim())
-                .filter((f) => !allowedDirty.has(f));
-            workingTreeClean = dirtyFiles.length === 0;
-        }
-        catch {
-            /* git not available — skip */
-        }
-        const excludeList = [...allowedDirty].join(', ');
-        gates.push({
-            name: 'clean_working_tree',
-            status: workingTreeClean ? 'passed' : 'failed',
-            message: workingTreeClean
-                ? `Working tree clean (excluding ${excludeList})`
-                : `Uncommitted changes in: ${dirtyFiles.slice(0, 5).join(', ')}${dirtyFiles.length > 5 ? ` (+${dirtyFiles.length - 5} more)` : ''}`,
-        });
-    }
-    // GD2: Branch target — use GitFlow config if available, else defaults
-    const isPreRelease = normalizedVersion.includes('-');
-    let currentBranch = '';
-    try {
-        currentBranch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-            cwd: projectRoot,
-            encoding: 'utf-8',
-            stdio: 'pipe',
-        }).trim();
-    }
-    catch {
-        /* git not available — skip */
-    }
-    const gitFlowCfg = getGitFlowConfig(releaseConfig);
-    const channelCfg = getChannelConfig(releaseConfig);
-    const expectedBranch = isPreRelease ? gitFlowCfg.branches.develop : gitFlowCfg.branches.main;
-    const isFeatureBranch = currentBranch.startsWith(gitFlowCfg.branches.featurePrefix) ||
-        currentBranch.startsWith(gitFlowCfg.branches.hotfixPrefix) ||
-        currentBranch.startsWith(gitFlowCfg.branches.releasePrefix);
-    const branchOk = !currentBranch || // git unavailable → pass
-        currentBranch === 'HEAD' || // detached HEAD → pass
-        currentBranch === expectedBranch || // exactly right branch → pass
-        (isPreRelease && isFeatureBranch); // feature/hotfix/release branch with pre-release → pass
-    // Resolve channel from current branch
-    const detectedChannel = currentBranch
-        ? resolveChannelFromBranch(currentBranch, channelCfg)
-        : isPreRelease
-            ? 'beta'
-            : 'latest';
-    gates.push({
-        name: 'branch_target',
-        status: branchOk ? 'passed' : 'failed',
-        message: branchOk
-            ? `On correct branch: ${currentBranch} (channel: ${detectedChannel})`
-            : `Expected branch '${expectedBranch}' for ${isPreRelease ? 'pre-release' : 'stable'} release, but on '${currentBranch}'`,
-    });
-    // GD3: Branch protection — detect if push requires a PR (informational, never fails)
-    const pushMode = getPushMode(releaseConfig);
-    let requiresPR = false;
-    if (pushMode === 'pr') {
-        requiresPR = true;
-    }
-    else if (pushMode === 'auto') {
-        try {
-            const protectionResult = await detectBranchProtection(expectedBranch, 'origin', projectRoot);
-            requiresPR = protectionResult.protected;
-        }
-        catch {
-            // Branch protection detection is best-effort; never block release
-            requiresPR = false;
-        }
-    }
-    gates.push({
-        name: 'branch_protection',
-        status: 'passed',
-        message: requiresPR
-            ? `Branch '${expectedBranch}' is protected — release.ship will create a PR`
-            : `Branch '${expectedBranch}' allows direct push`,
-    });
-    const allPassed = gates.every((g) => g.status === 'passed');
-    const metadata = {
-        channel: detectedChannel,
-        requiresPR,
-        targetBranch: expectedBranch,
-        currentBranch,
-    };
-    return {
-        version: normalizedVersion,
-        allPassed,
-        gates,
-        passedCount: gates.filter((g) => g.status === 'passed').length,
-        failedCount: gates.filter((g) => g.status === 'failed').length,
-        metadata,
-    };
-}
-/**
- * Cancel and remove a release in draft or prepared state.
- * Only releases that have not yet been committed to git can be cancelled.
- * For committed/tagged/pushed releases, use rollbackRelease() instead.
- *
- * @task T5602
- */
-export async function cancelRelease(version, projectRoot) {
-    if (!version) {
-        throw new Error('version is required');
-    }
-    const normalizedVersion = normalizeVersion(version);
-    const db = await getDb(projectRoot);
-    const rows = await db
-        .select()
-        .from(schema.releaseManifests)
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .limit(1)
-        .all();
-    if (rows.length === 0) {
-        return {
-            success: false,
-            message: `Release ${normalizedVersion} not found`,
-            version: normalizedVersion,
-        };
-    }
-    const status = rows[0].status;
-    const cancellableStates = ['draft', 'prepared'];
-    if (!cancellableStates.includes(status)) {
-        return {
-            success: false,
-            message: `Cannot cancel a release in '${status}' state. Use 'release rollback' instead.`,
-            version: normalizedVersion,
-        };
-    }
-    await db
-        .delete(schema.releaseManifests)
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .run();
-    return {
-        success: true,
-        message: `Release ${normalizedVersion} cancelled and removed`,
-        version: normalizedVersion,
-    };
-}
-/**
- * Rollback a release.
- * @task T4788
- */
-export async function rollbackRelease(version, reason, cwd) {
-    if (!version) {
-        throw new Error('version is required');
-    }
-    const normalizedVersion = normalizeVersion(version);
-    const db = await getDb(cwd);
-    const rows = await db
-        .select()
-        .from(schema.releaseManifests)
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .limit(1)
-        .all();
-    if (rows.length === 0) {
-        throw new Error(`Release ${normalizedVersion} not found`);
-    }
-    const previousStatus = rows[0].status;
-    await db
-        .update(schema.releaseManifests)
-        .set({ status: 'rolled_back' })
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .run();
-    return {
-        version: normalizedVersion,
-        previousStatus,
-        status: 'rolled_back',
-        reason: reason ?? 'No reason provided',
-    };
-}
-/**
- * Read push policy from project config.
- * Returns undefined if no push config exists.
- */
-async function readPushPolicy(cwd) {
-    const configPath = join(getCleoDirAbsolute(cwd), 'config.json');
-    let config;
-    try {
-        const raw = await readFile(configPath, 'utf-8');
-        config = JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-    if (!config)
-        return undefined;
-    const release = config.release;
-    if (!release)
-        return undefined;
-    return release.push;
-}
-/**
- * Push release to remote via git.
- *
- * Respects config.release.push policy:
- * - remote: override default remote (fallback to 'origin')
- * - requireCleanTree: verify git working tree is clean before push
- * - allowedBranches: verify current branch is in the allowed list
- * - enabled: if false and no explicit push flag, caller should skip
- *
- * @task T4788
- * @task T4276
- */
-export async function pushRelease(version, remote, cwd, opts) {
-    if (!version) {
-        throw new Error('version is required');
-    }
-    const normalizedVersion = normalizeVersion(version);
-    const projectRoot = getProjectRoot(cwd);
-    const pushPolicy = await readPushPolicy(cwd);
-    // Resolve effective push mode: opts.mode > pushPolicy.mode > config > 'direct'
-    const configPushMode = getPushMode(loadReleaseConfig(cwd));
-    const effectivePushMode = opts?.mode ?? pushPolicy?.mode ?? configPushMode;
-    // If branch protection detected and mode allows PR creation, signal PR required
-    if (effectivePushMode === 'pr' || effectivePushMode === 'auto') {
-        const targetRemoteForCheck = remote ?? pushPolicy?.remote ?? 'origin';
-        let branchIsProtected = effectivePushMode === 'pr'; // 'pr' always requires PR
-        if (effectivePushMode === 'auto') {
-            try {
-                const protection = await detectBranchProtection(pushPolicy?.allowedBranches?.[0] ?? 'main', targetRemoteForCheck, projectRoot);
-                branchIsProtected = protection.protected;
-            }
-            catch {
-                // Best-effort; default to direct push if detection fails
-                branchIsProtected = false;
-            }
-        }
-        if (branchIsProtected) {
-            return {
-                version: normalizedVersion,
-                status: 'requires_pr',
-                remote: targetRemoteForCheck,
-                pushedAt: new Date().toISOString(),
-                requiresPR: true,
-            };
-        }
-    }
-    // If push policy says disabled and caller didn't explicitly pass --push, skip
-    if (pushPolicy && pushPolicy.enabled === false && !opts?.explicitPush) {
-        throw new Error('Push is disabled by config (release.push.enabled=false). Use --push to override.');
-    }
-    // Determine remote: explicit param > config > 'origin'
-    const targetRemote = remote ?? pushPolicy?.remote ?? 'origin';
-    // Check requireCleanTree
-    // Untracked files (?? lines) are excluded — they do not affect push operations.
-    if (pushPolicy?.requireCleanTree) {
-        const statusOutput = execFileSync('git', ['status', '--porcelain'], {
-            cwd: projectRoot,
-            timeout: 10000,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        const trackedDirty = statusOutput
-            .split('\n')
-            .filter((l) => l.trim() && !l.startsWith('?? '))
-            .join('\n');
-        if (trackedDirty.trim().length > 0) {
-            throw new Error('Git working tree is not clean. Commit or stash changes before pushing (config: release.push.requireCleanTree=true).');
-        }
-    }
-    // Check allowedBranches
-    if (pushPolicy?.allowedBranches && pushPolicy.allowedBranches.length > 0) {
-        const currentBranch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-            cwd: projectRoot,
-            timeout: 10000,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-        if (!pushPolicy.allowedBranches.includes(currentBranch)) {
-            throw new Error(`Current branch '${currentBranch}' is not in allowed branches: ${pushPolicy.allowedBranches.join(', ')} (config: release.push.allowedBranches).`);
-        }
-    }
-    execFileSync('git', ['push', targetRemote, '--follow-tags'], {
-        cwd: projectRoot,
-        timeout: 60000,
-        encoding: 'utf-8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    return {
-        version: normalizedVersion,
-        status: 'pushed',
-        remote: targetRemote,
-        pushedAt: new Date().toISOString(),
-    };
-}
-/**
- * Update release status after push, with optional provenance fields.
- * @task T4788
- * @task T5580
- */
-export async function markReleasePushed(version, pushedAt, cwd, provenance) {
-    const normalizedVersion = normalizeVersion(version);
-    const db = await getDb(cwd);
-    await db
-        .update(schema.releaseManifests)
-        .set({
-        status: 'pushed',
-        pushedAt,
-        ...(provenance?.commitSha != null ? { commitSha: provenance.commitSha } : {}),
-        ...(provenance?.gitTag != null ? { gitTag: provenance.gitTag } : {}),
-    })
-        .where(eq(schema.releaseManifests.version, normalizedVersion))
-        .run();
-}
-/**
- * One-time migration: read .cleo/releases.json and insert each release into
- * the release_manifests table. Renames the file to releases.json.migrated on success.
- *
- * @task T5580
- */
-export async function migrateReleasesJsonToSqlite(projectRoot) {
-    const releasesPath = join(getCleoDirAbsolute(projectRoot), 'releases.json');
-    if (!existsSync(releasesPath)) {
-        return { migrated: 0 };
-    }
-    let raw;
-    try {
-        const contents = await readFile(releasesPath, 'utf-8');
-        raw = JSON.parse(contents);
-    }
-    catch {
-        return { migrated: 0 };
-    }
-    if (!raw || !Array.isArray(raw.releases)) {
-        return { migrated: 0 };
-    }
-    const db = await getDb(projectRoot);
-    let migrated = 0;
-    for (const r of raw.releases) {
-        // Skip if already exists by version
-        const existing = await db
-            .select({ id: schema.releaseManifests.id })
-            .from(schema.releaseManifests)
-            .where(eq(schema.releaseManifests.version, r.version))
-            .limit(1)
-            .all();
-        if (existing.length > 0)
-            continue;
-        const id = `rel-${r.version.replace(/[^a-z0-9]/gi, '-')}`;
-        await db
-            .insert(schema.releaseManifests)
-            .values({
-            id,
-            version: r.version,
-            status: r.status,
-            tasksJson: JSON.stringify(r.tasks ?? []),
-            notes: r.notes ?? null,
-            changelog: r.changelog ?? null,
-            previousVersion: r.previousVersion ?? null,
-            createdAt: r.createdAt,
-            preparedAt: r.preparedAt ?? null,
-            committedAt: r.committedAt ?? null,
-            taggedAt: r.taggedAt ?? null,
-            pushedAt: r.pushedAt ?? null,
-        })
-            .run();
-        migrated++;
-    }
-    // Rename legacy file on success
-    renameSync(releasesPath, releasesPath + '.migrated');
-    return { migrated };
-}
-//# sourceMappingURL=release-manifest.js.map