claude-git-hooks 2.21.0 → 2.30.1

package/lib/commands/back-merge.js

@@ -0,0 +1,740 @@
+/**
+ * File: back-merge.js
+ * Purpose: back-merge command — post-deploy branch synchronization
+ *
+ * Flow:
+ * 1. Parse args
+ * 2. Validate: git repo, clean tree, warn if not on into-branch
+ * 3. Fetch remote
+ * 4. Detect version from latest local tag
+ * 5. Check divergence: behind=0 → already synced
+ * 6. Find RC branch(es) in remote for cleanup
+ * 7. [--dry-run] Preview + return
+ * 8. Confirm with user (show planned actions)
+ * 9. Tag release: push existing local tag; create locally if missing (unless --skip-tag)
+ * 10. Shadow reset: runShadow(['reset']) (unless --skip-shadow)
+ * 11. Execute merge: checkout into, git merge --no-commit --no-ff --no-verify origin/from
+ * 12. Handle conflicts:
+ *     - version files → git checkout --theirs + stage
+ *     - CHANGELOG → stage as-is (conflict markers) + warn + prompt continue/abort
+ *     - other → git merge --abort + instruct TL
+ * 13. Commit: '[backmerge] Merge {from} (v{version}) into {into}'
+ * 14. Verify sync: getDivergence behind=0
+ * 15. Push into-branch → detect branch protection + show advice
+ * 16. Delete RC branch(es) from remote
+ * 17. Revert follow-up: read revert-log, filter by RC, prompt, apply git revert per entry
+ * 18. Display summary
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import {
+    getCurrentBranch,
+    getRepoRoot,
+    isWorkingDirectoryClean,
+    fetchRemote,
+    getDivergence,
+    getRemoteBranches,
+    checkoutBranch,
+    pushBranch,
+    deleteRemoteBranch,
+    createCommit
+} from '../utils/git-operations.js';
+import {
+    getLatestLocalTag,
+    parseTagVersion,
+    tagExists,
+    createTag,
+    pushTags
+} from '../utils/git-tag-manager.js';
+import { runShadow } from './shadow.js';
+import {
+    showInfo,
+    showSuccess,
+    showError,
+    showWarning,
+    promptConfirmation
+} from '../utils/interactive-ui.js';
+import logger from '../utils/logger.js';
+import { colors, error, checkGitRepo } from './helpers.js';
+
+/** Default source branch for back-merge */
+const DEFAULT_FROM = 'main';
+
+/** Default destination branch for back-merge */
+const DEFAULT_INTO = 'develop';
+
+/** Relative path of the revert log file */
+const REVERT_LOG_RELATIVE_PATH = '.claude/revert-log.json';
+
+/**
+ * Version file basenames — conflicts auto-resolved by accepting source (theirs)
+ * Mirrors shadow.js to keep conflict resolution consistent
+ */
+const VERSION_FILE_NAMES = new Set([
+    'package.json',
+    'package-lock.json',
+    'pom.xml',
+    'build.gradle',
+    'build.gradle.kts',
+    'VERSION',
+    'version.txt'
+]);
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/**
+ * Returns true if the given repo-relative path is a version file
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function _isVersionFile(filePath) {
+    const basename = path.basename(filePath);
+    return VERSION_FILE_NAMES.has(basename) || basename.endsWith('.version');
+}
+
+/**
+ * Returns true if the given repo-relative path is a CHANGELOG file
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function _isChangelogFile(filePath) {
+    const basename = path.basename(filePath).toLowerCase();
+    return basename.startsWith('changelog');
+}
+
+// ─── Argument parsing ────────────────────────────────────────────────────────
+
+/**
+ * Parse CLI args into structured options
+ * @param {string[]} args
+ * @returns {{ from: string, into: string, skipTag: boolean, skipShadow: boolean, dryRun: boolean }}
+ */
+function _parseArgs(args) {
+    const opts = {
+        from: DEFAULT_FROM,
+        into: DEFAULT_INTO,
+        skipTag: false,
+        skipShadow: false,
+        dryRun: false
+    };
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--from' && args[i + 1]) {
+            opts.from = args[++i];
+        } else if (arg === '--into' && args[i + 1]) {
+            opts.into = args[++i];
+        } else if (arg === '--skip-tag') {
+            opts.skipTag = true;
+        } else if (arg === '--skip-shadow') {
+            opts.skipShadow = true;
+        } else if (arg === '--dry-run') {
+            opts.dryRun = true;
+        }
+    }
+
+    return opts;
+}
+
+// ─── Version detection ───────────────────────────────────────────────────────
+
+/**
+ * Detect release version from the latest local tag
+ * @returns {{ version: string|null, tagName: string|null }}
+ */
+function _detectVersion() {
+    const latestTag = getLatestLocalTag();
+    if (!latestTag) {
+        logger.debug('back-merge - _detectVersion', 'No local tags found');
+        return { version: null, tagName: null };
+    }
+    const version = parseTagVersion(latestTag);
+    logger.debug('back-merge - _detectVersion', 'Version detected from local tag', {
+        latestTag,
+        version
+    });
+    return { version, tagName: latestTag };
+}
+
+// ─── RC branch discovery ─────────────────────────────────────────────────────
+
+/**
+ * Find release-candidate branches in remote that match the given version (or any RC if no version)
+ * @param {string|null} version - Version string to match (e.g. '2.28.0'), or null to find all
+ * @returns {string[]} Matching RC branch names (without remote/ prefix)
+ */
+function _findRCBranches(version) {
+    const remoteBranches = getRemoteBranches();
+    const allRC = remoteBranches.filter((b) => b.startsWith('release-candidate/'));
+    if (!version) return allRC;
+    return allRC.filter((b) => b.includes(version));
+}
+
+// ─── Conflict resolution ─────────────────────────────────────────────────────
+
+/**
+ * Abort an in-progress merge and return to the previous branch
+ * @param {string} previousBranch
+ */
+function _abortMergeAndReturn(previousBranch) {
+    try {
+        execSync('git merge --abort', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        logger.debug('back-merge - _abortMergeAndReturn', 'Merge aborted');
+    } catch {
+        // merge may not be in progress — ignore
+    }
+    try {
+        checkoutBranch(previousBranch);
+    } catch {
+        // best-effort return
+    }
+}
+
+/**
+ * Resolve merge conflicts using team-standard patterns.
+ * Returns true if all conflicts were resolved (or if CHANGELOG conflicts need user decision),
+ * false if there are unresolvable conflicts.
+ *
+ * @param {string} previousBranch - Branch to return to on abort
+ * @returns {Promise<boolean>} true = proceed with commit, false = aborted
+ */
+async function _resolveConflicts(previousBranch) {
+    let conflictedFiles = [];
+    try {
+        const raw = execSync('git diff --name-only --diff-filter=U', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+        conflictedFiles = raw ? raw.split(/\r?\n/).filter(Boolean) : [];
+    } catch (e) {
+        showWarning(`Could not list conflicted files: ${e.message}`);
+        _abortMergeAndReturn(previousBranch);
+        return false;
+    }
+
+    if (conflictedFiles.length === 0) {
+        showError('Merge failed — could not determine cause. Check git status.');
+        showWarning('You may need to run: git merge --abort');
+        try {
+            checkoutBranch(previousBranch);
+        } catch {
+            // best-effort
+        }
+        return false;
+    }
+
+    logger.debug('back-merge - _resolveConflicts', 'Conflicts detected', { conflictedFiles });
+
+    const versionConflicts = conflictedFiles.filter(_isVersionFile);
+    const changelogConflicts = conflictedFiles.filter(_isChangelogFile);
+    const otherConflicts = conflictedFiles.filter(
+        (f) => !_isVersionFile(f) && !_isChangelogFile(f)
+    );
+
+    // Other conflicts — cannot auto-resolve: abort and instruct TL
+    if (otherConflicts.length > 0) {
+        showWarning('⚠️  Merge conflict on non-auto-resolvable files — aborting merge.');
+        showWarning('Files requiring manual resolution:');
+        otherConflicts.forEach((f) => showWarning(`   ${f}`));
+        console.log('');
+        console.log('To resolve manually:');
+        console.log(`  1. git checkout ${DEFAULT_INTO} && git merge --no-verify --no-ff origin/${DEFAULT_FROM}`);
+        console.log('  2. Resolve conflicts in the listed files');
+        console.log('  3. git add . && git commit --no-verify');
+        _abortMergeAndReturn(previousBranch);
+        return false;
+    }
+
+    // Auto-resolve version file conflicts: accept source (theirs = from-branch = main)
+    for (const f of versionConflicts) {
+        try {
+            execSync(`git checkout --theirs -- "${f}"`, {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            execSync(`git add -- "${f}"`, {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            logger.debug('back-merge - _resolveConflicts', 'Resolved version conflict (theirs)', {
+                file: f
+            });
+        } catch (e) {
+            showWarning(`Could not auto-resolve version conflict in '${f}': ${e.message}`);
+            _abortMergeAndReturn(previousBranch);
+            return false;
+        }
+    }
+
+    if (versionConflicts.length > 0) {
+        showInfo(
+            `Auto-resolved ${versionConflicts.length} version file conflict(s) — accepted source (main) version.`
+        );
+    }
+
+    // CHANGELOG conflicts: stage as-is (conflict markers remain), warn TL, ask to continue
+    for (const f of changelogConflicts) {
+        try {
+            execSync(`git add -- "${f}"`, {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            showWarning(
+                `⚠️  ${f} has conflict markers — both sides staged. ` +
+                    'Resolve manually after back-merge (destination=Unreleased on top, source=release below).'
+            );
+            logger.debug('back-merge - _resolveConflicts', 'Staged CHANGELOG with conflict markers', {
+                file: f
+            });
+        } catch (e) {
+            showWarning(`Could not stage '${f}' for commit: ${e.message}`);
+            _abortMergeAndReturn(previousBranch);
+            return false;
+        }
+    }
+
+    // Ask user permission to continue with CHANGELOG conflict markers
+    if (changelogConflicts.length > 0) {
+        console.log('');
+        const proceed = await promptConfirmation(
+            'CHANGELOG has conflict markers. Continue with merge commit (you will fix markers after)?',
+            false
+        );
+        if (!proceed) {
+            showInfo('Aborting merge — resolve CHANGELOG conflicts manually.');
+            _abortMergeAndReturn(previousBranch);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// ─── Revert log ──────────────────────────────────────────────────────────────
+
+/**
+ * Read .claude/revert-log.json
+ * @param {string} repoRoot
+ * @returns {Array}
+ */
+function _readRevertLog(repoRoot) {
+    const logPath = path.join(repoRoot, REVERT_LOG_RELATIVE_PATH);
+    if (!fs.existsSync(logPath)) return [];
+    try {
+        return JSON.parse(fs.readFileSync(logPath, 'utf8'));
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Write updated revert log (removes processed entries)
+ * @param {string} repoRoot
+ * @param {Array} entries
+ */
+function _writeRevertLog(repoRoot, entries) {
+    const logPath = path.join(repoRoot, REVERT_LOG_RELATIVE_PATH);
+    fs.writeFileSync(logPath, JSON.stringify(entries, null, 2), 'utf8');
+}
+
+/**
+ * Offer to revert-the-revert for features that were reverted from the closed RC.
+ * Applies `git revert --no-edit <revertHash>` for each confirmed entry.
+ *
+ * @param {string} rcBranch - The RC branch being closed (for filtering)
+ * @param {string} repoRoot
+ * @returns {Promise<void>}
+ */
+async function _revertFollowup(rcBranch, repoRoot) {
+    const allEntries = _readRevertLog(repoRoot);
+    const rcEntries = allEntries.filter((e) => e.rcBranch === rcBranch);
+
+    if (rcEntries.length === 0) {
+        logger.debug('back-merge - _revertFollowup', 'No revert-log entries for this RC', {
+            rcBranch
+        });
+        return;
+    }
+
+    console.log('');
+    console.log('┌─────────────────────────────────────────────────────────────────────────┐');
+    console.log(` 🔄 Reverted features from ${rcBranch}`);
+    console.log('├─────────────────────────────────────────────────────────────────────────┤');
+    rcEntries.forEach((e) => {
+        const date = e.timestamp ? e.timestamp.substring(0, 10) : '?';
+        console.log(` • ${e.taskId.padEnd(12)} reverted ${e.originalHash.substring(0, 7)} on ${date}`);
+        console.log(`   Revert commit: ${e.revertHash.substring(0, 7)}`);
+    });
+    console.log('└─────────────────────────────────────────────────────────────────────────┘');
+    console.log('');
+
+    const apply = await promptConfirmation(
+        `Apply revert-the-revert for ${rcEntries.length} feature(s)? (restores them for next sprint)`,
+        false
+    );
+
+    if (!apply) {
+        console.log('');
+        showInfo('Skipped. To restore manually:');
+        rcEntries.forEach((e) => {
+            console.log(`  git revert --no-edit ${e.revertHash.substring(0, 7)}  # Restores ${e.taskId}`);
+        });
+        console.log('');
+        return;
+    }
+
+    console.log('');
+    let applied = 0;
+    for (const entry of rcEntries) {
+        try {
+            execSync(`git revert --no-edit ${entry.revertHash}`, {
+                encoding: 'utf8',
+                stdio: 'inherit'
+            });
+            showSuccess(`✓ Restored ${entry.taskId} (reverted ${entry.revertHash.substring(0, 7)})`);
+            applied++;
+        } catch (e) {
+            showWarning(
+                `⚠️  Could not revert-the-revert for ${entry.taskId}: ${e.message}`
+            );
+            showWarning(`   Resolve manually: git revert --no-edit ${entry.revertHash.substring(0, 7)}`);
+        }
+    }
+
+    // Remove processed entries from revert-log
+    const remaining = allEntries.filter((e) => e.rcBranch !== rcBranch);
+    try {
+        _writeRevertLog(repoRoot, remaining);
+        logger.debug('back-merge - _revertFollowup', 'Cleaned up revert-log entries', {
+            removed: rcEntries.length,
+            remaining: remaining.length
+        });
+    } catch (e) {
+        showWarning(`Could not update revert-log: ${e.message}`);
+    }
+
+    if (applied > 0) {
+        showSuccess(`✓ Applied ${applied}/${rcEntries.length} revert-the-revert(s)`);
+    }
+}
+
+// ─── Main command ─────────────────────────────────────────────────────────────
+
+/**
+ * Main entry point for `claude-hooks back-merge`
+ * @param {string[]} args - CLI args after 'back-merge'
+ */
+export async function runBackMerge(args) {
+    logger.debug('back-merge', 'Starting back-merge command', { args });
+
+    const opts = _parseArgs(args);
+
+    showInfo(`🔀 Post-deploy back-merge: ${opts.from} → ${opts.into}`);
+    console.log('');
+
+    // 1. Validate: git repo
+    if (!checkGitRepo()) {
+        error('Not a git repository.');
+        process.exit(1);
+    }
+
+    // 2. Validate: clean tree
+    if (!isWorkingDirectoryClean()) {
+        error(
+            'Working directory has uncommitted changes.\n' +
+                '   Please commit or stash your changes before running back-merge.'
+        );
+        process.exit(1);
+    }
+
+    // 3. Warn if not on the into-branch
+    const currentBranch = getCurrentBranch();
+    if (currentBranch !== opts.into) {
+        showWarning(`You are on '${currentBranch}', not '${opts.into}'.`);
+        const continueAnyway = await promptConfirmation(
+            `Continue? (command will checkout '${opts.into}' automatically)`,
+            false
+        );
+        if (!continueAnyway) {
+            showInfo('Aborted.');
+            process.exit(0);
+        }
+        console.log('');
+    }
+
+    // 4. Fetch remote (warn on failure, don't abort)
+    try {
+        fetchRemote();
+        showSuccess('✓ Fetched from remote');
+    } catch (e) {
+        showWarning(`Could not fetch from remote: ${e.message} — results may be stale`);
+    }
+    console.log('');
+
+    // 5. Detect version from latest local tag
+    const { version, tagName } = _detectVersion();
+    if (!version) {
+        showWarning('Could not detect release version from local tags — tag step will be skipped.');
+    } else {
+        showInfo(`Detected release version: ${version} (${tagName})`);
+    }
+    const effectiveSkipTag = opts.skipTag || !version;
+
+    // 6. Check if merge is needed: from behind into?
+    let divergence;
+    try {
+        divergence = getDivergence(opts.into, `origin/${opts.from}`);
+    } catch (e) {
+        showWarning(`Could not check divergence: ${e.message}`);
+        divergence = { ahead: 0, behind: 1 }; // assume merge needed
+    }
+
+    if (divergence.behind === 0) {
+        showSuccess(`'${opts.into}' is already up-to-date with 'origin/${opts.from}' — nothing to merge.`);
+        console.log('');
+        process.exit(0);
+    }
+
+    showInfo(`'${opts.into}' is ${divergence.behind} commit(s) behind 'origin/${opts.from}'`);
+    console.log('');
+
+    // 7. Find RC branches for cleanup
+    const rcBranches = _findRCBranches(version);
+    logger.debug('back-merge', 'RC branches found for cleanup', { rcBranches });
+
+    // 8. Dry-run: preview actions and return
+    if (opts.dryRun) {
+        console.log(`${colors.yellow}═════════════════════════════════════════════════${colors.reset}`);
+        console.log(`${colors.yellow}           DRY RUN — No changes will be made     ${colors.reset}`);
+        console.log(`${colors.yellow}═════════════════════════════════════════════════${colors.reset}`);
+        console.log('');
+        console.log(`${colors.blue}Source:${colors.reset}         origin/${opts.from}`);
+        console.log(`${colors.blue}Destination:${colors.reset}    ${opts.into} (${divergence.behind} commit(s) behind)`);
+
+        if (effectiveSkipTag) {
+            console.log(`${colors.blue}Tag:${colors.reset}            skipped${!version ? ' (no local tag found)' : ' (--skip-tag)'}`);
+        } else {
+            console.log(`${colors.blue}Tag:${colors.reset}            push ${tagName} to remote`);
+        }
+
+        console.log(
+            `${colors.blue}Shadow reset:${colors.reset}   ${opts.skipShadow ? 'skipped (--skip-shadow)' : 'yes → reset shadow to main'}`
+        );
+        console.log(`${colors.blue}Merge commit:${colors.reset}   [backmerge] Merge ${opts.from}${version ? ` (v${version})` : ''} into ${opts.into}`);
+
+        if (rcBranches.length > 0) {
+            console.log(`${colors.blue}RC cleanup:${colors.reset}     delete ${rcBranches.join(', ')}`);
+        } else {
+            console.log(`${colors.blue}RC cleanup:${colors.reset}     no RC branch found to delete`);
+        }
+        console.log('');
+        console.log(`${colors.yellow}Run without --dry-run to apply these changes${colors.reset}`);
+        console.log('');
+        return;
+    }
+
+    // 9. Confirm with user
+    console.log('Planned actions:');
+    if (!effectiveSkipTag) console.log(`  1. Push release tag ${tagName} to remote`);
+    if (!opts.skipShadow) console.log(`  ${effectiveSkipTag ? 1 : 2}. Reset shadow branch to main`);
+    const mergeStep = (effectiveSkipTag ? 0 : 1) + (opts.skipShadow ? 0 : 1) + 1;
+    console.log(`  ${mergeStep}. Merge origin/${opts.from} into ${opts.into}`);
+    console.log(`  ${mergeStep + 1}. Push ${opts.into} to remote`);
+    if (rcBranches.length > 0) {
+        console.log(`  ${mergeStep + 2}. Delete RC branch(es): ${rcBranches.join(', ')}`);
+    }
+    console.log('');
+
+    const confirmed = await promptConfirmation('Proceed with back-merge?', true);
+    if (!confirmed) {
+        showInfo('Back-merge cancelled.');
+        process.exit(0);
+    }
+    console.log('');
+
+    // 10. Tag release (push existing local tag or create + push)
+    let tagStatus = 'skipped';
+    if (!effectiveSkipTag) {
+        showInfo(`Tagging release ${tagName}...`);
+        try {
+            const alreadyOnRemote = await tagExists(tagName, 'remote');
+            if (alreadyOnRemote) {
+                showWarning(`Tag ${tagName} already exists on remote — skipping push.`);
+                tagStatus = `${tagName} already on remote`;
+            } else {
+                const alreadyLocal = await tagExists(tagName, 'local');
+                if (!alreadyLocal) {
+                    // Tag was not created by create-release — create it now
+                    const createResult = createTag(version, `Release version ${version}`);
+                    if (!createResult.success) {
+                        showWarning(`Could not create tag locally: ${createResult.error}`);
+                    }
+                }
+                const pushResult = pushTags(null, tagName);
+                if (pushResult.success) {
+                    showSuccess(`✓ Tag ${tagName} pushed to remote`);
+                    tagStatus = `${tagName} pushed`;
+                } else {
+                    showWarning(`Could not push tag: ${pushResult.error}`);
+                    showWarning(`   Push manually: git push origin ${tagName}`);
+                    tagStatus = 'push failed';
+                }
+            }
+        } catch (e) {
+            showWarning(`Tag step failed: ${e.message}`);
+            tagStatus = 'failed';
+        }
+        console.log('');
+    }
+
+    // 11. Shadow reset (unless --skip-shadow)
+    let shadowStatus = 'skipped';
+    if (!opts.skipShadow) {
+        showInfo('Resetting shadow to main...');
+        console.log('');
+        try {
+            await runShadow(['reset']);
+            shadowStatus = 'reset to main';
+        } catch (e) {
+            showWarning(`Shadow reset failed: ${e.message}`);
+            showWarning('   Reset manually: claude-hooks shadow reset');
+            shadowStatus = 'failed';
+        }
+        console.log('');
+    }
+
+    // 12. Execute merge
+    showInfo(`Merging origin/${opts.from} into ${opts.into}...`);
+    const previousBranch = getCurrentBranch();
+    try {
+        checkoutBranch(opts.into);
+    } catch (e) {
+        showError(`Could not checkout '${opts.into}': ${e.message}`);
+        process.exit(1);
+    }
+
+    let mergeSucceeded = true;
+    try {
+        execSync(`git merge --no-commit --no-ff --no-verify origin/${opts.from}`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+    } catch {
+        mergeSucceeded = false;
+    }
+
+    // 13. Handle conflicts if merge had issues
+    if (!mergeSucceeded) {
+        const resolved = await _resolveConflicts(previousBranch);
+        if (!resolved) {
+            showError('Back-merge aborted due to unresolvable conflicts.');
+            process.exit(1);
+        }
+    }
+
+    // 14. Commit the merge
+    const versionSuffix = version ? ` (v${version})` : '';
+    const commitMsg = `[backmerge] Merge ${opts.from}${versionSuffix} into ${opts.into}`;
+    const commitResult = createCommit(commitMsg, { noVerify: true });
+    if (!commitResult.success) {
+        showError(`Failed to create merge commit: ${commitResult.error}`);
+        showWarning('The merge is staged — commit manually:');
+        showWarning(`  git commit --no-verify -m "${commitMsg}"`);
+        process.exit(1);
+    }
+    showSuccess(`✓ Merge committed: ${commitMsg}`);
+    console.log('');
+
+    // 15. Verify sync
+    try {
+        const postMergeDivergence = getDivergence(opts.into, `origin/${opts.from}`);
+        if (postMergeDivergence.behind === 0) {
+            showSuccess(`✓ '${opts.into}' is now in sync with 'origin/${opts.from}'`);
+        } else {
+            showWarning(
+                `'${opts.into}' still ${postMergeDivergence.behind} commit(s) behind 'origin/${opts.from}' — verify manually.`
+            );
+        }
+    } catch (e) {
+        showWarning(`Could not verify sync: ${e.message}`);
+    }
+    console.log('');
+
+    // 16. Push into-branch
+    showInfo(`Pushing ${opts.into} to remote...`);
+    const pushResult = pushBranch(opts.into);
+    let pushStatus;
+    if (pushResult.success) {
+        showSuccess(`✓ Pushed ${opts.into} to remote`);
+        pushStatus = 'pushed';
+    } else {
+        const isProtected =
+            pushResult.error &&
+            (pushResult.error.includes('protected') ||
+                pushResult.error.includes('hook declined') ||
+                pushResult.error.includes('cannot push'));
+        if (isProtected) {
+            showError(`Push blocked — '${opts.into}' is protected.`);
+            console.log('');
+            console.log(
+                `'${opts.into}' is a protected branch — ask your Tech Lead to temporarily allow pushes, or raise a PR:`
+            );
+            console.log(`  gh pr create --base ${opts.into} --head ${opts.from} --title "${commitMsg}"`);
+        } else {
+            showError(`Push failed: ${pushResult.error}`);
+            console.log('');
+            console.log('Push manually when ready:');
+            console.log(`  git push origin ${opts.into}`);
+        }
+        pushStatus = isProtected ? 'blocked (branch protection)' : 'failed';
+    }
+    console.log('');
+
+    // 17. Delete RC branch(es)
+    const deletedRC = [];
+    const failedRC = [];
+    for (const rc of rcBranches) {
+        showInfo(`Deleting remote branch ${rc}...`);
+        try {
+            deleteRemoteBranch(rc);
+            showSuccess(`✓ Deleted ${rc}`);
+            deletedRC.push(rc);
+        } catch (e) {
+            showWarning(`Could not delete ${rc}: ${e.message}`);
+            showWarning(`   Delete manually: git push origin --delete ${rc}`);
+            failedRC.push(rc);
+        }
+    }
+    if (rcBranches.length > 0) console.log('');
+
+    // 18. Revert follow-up
+    const repoRoot = getRepoRoot();
+    const rcBranchForLog = rcBranches.length > 0 ? rcBranches[0] : null;
+    if (rcBranchForLog) {
+        await _revertFollowup(rcBranchForLog, repoRoot);
+    }
+
+    // 19. Summary
+    console.log('');
+    console.log(`${colors.green}═════════════════════════════════════════════════${colors.reset}`);
+    console.log(`${colors.green}        Back-merge Complete ✅                   ${colors.reset}`);
+    console.log(`${colors.green}═════════════════════════════════════════════════${colors.reset}`);
+    console.log('');
+    console.log(`${colors.blue}Merged:${colors.reset}  origin/${opts.from} → ${opts.into}`);
+    console.log(`${colors.blue}Tag:${colors.reset}     ${tagStatus}`);
+    console.log(`${colors.blue}Shadow:${colors.reset}  ${shadowStatus}`);
+    console.log(`${colors.blue}Push:${colors.reset}    ${pushStatus}`);
+    if (rcBranches.length > 0) {
+        const cleanupStatus =
+            failedRC.length === 0
+                ? `deleted (${deletedRC.join(', ')})`
+                : `partial — ${failedRC.join(', ')} needs manual delete`;
+        console.log(`${colors.blue}RC:${colors.reset}      ${cleanupStatus}`);
+    }
+    console.log('');
+}