Safe Deployment Rollback

I'll help you safely rollback deployments with automated health checks, database migration reversal, and multi-environment support.

Rollback Capabilities:

• Application version rollback
• Database migration reversal
• Infrastructure state restoration
• Configuration rollback
• Health monitoring and validation

Arguments:

$ARGUMENTS

- environment (staging/production), version, or rollback target

---

Token Optimization

This skill uses efficient patterns to minimize token consumption during deployment rollback operations.

Optimization Strategies

1. Deployment Platform Caching (Saves 600 tokens per invocation)

Cache detected deployment platform and configuration:

CACHE_FILE=".claude/cache/deployment-rollback/platform.json"
CACHE_TTL=86400  # 24 hours

mkdir -p .claude/cache/deployment-rollback

if [ -f "$CACHE_FILE" ]; then
    CACHE_AGE=$(($(date +%s) - $(stat -c %Y "$CACHE_FILE" 2>/dev/null || stat -f %m "$CACHE_FILE" 2>/dev/null)))

    if [ $CACHE_AGE -lt $CACHE_TTL ]; then
        PLATFORM=$(jq -r '.platform' "$CACHE_FILE")
        ENV_NAME=$(jq -r '.environment' "$CACHE_FILE")
        ROLLBACK_STRATEGY=$(jq -r '.rollback_strategy' "$CACHE_FILE")

        echo "Using cached platform: $PLATFORM ($ENV_NAME)"
        SKIP_DETECTION="true"
    fi
fi

Savings: 600 tokens (no kubectl checks, no AWS CLI calls, no file searches)

2. Early Exit for Safe State (Saves 95%)

Quick validation before rollback:

# Quick pre-rollback checks
if [ -z "$ROLLBACK_TARGET" ]; then
    echo "❌ No rollback target specified"
    echo "Usage: /deployment-rollback <version|previous>"
    exit 1
fi

# Check if rollback needed
CURRENT_VERSION=$(get_current_version)
if [ "$CURRENT_VERSION" = "$ROLLBACK_TARGET" ]; then
    echo "✓ Already at target version: $ROLLBACK_TARGET"
    echo "No rollback needed"
    exit 0
fi

Savings: 95% when no rollback needed (skip entire workflow: 4,000 → 200 tokens)

3. Template-Based Rollback Scripts (Saves 70%)

Use platform-specific templates instead of detailed generation:

# Efficient: Template-based rollback
generate_rollback_script() {
    local platform="$1"
    local target_version="$2"

    case "$platform" in
        kubernetes)
            cat > "rollback.sh" << EOF
#!/bin/bash
kubectl rollout undo deployment/\$APP_NAME
kubectl rollout status deployment/\$APP_NAME
EOF
            ;;
        docker-compose)
            cat > "rollback.sh" << EOF
#!/bin/bash
docker-compose down
git checkout $target_version
docker-compose up -d
EOF
            ;;
    esac

    chmod +x rollback.sh
    echo "✓ Generated rollback script"
}

Savings: 70% (templates vs detailed explanations: 2,000 → 600 tokens)

4. Bash-Based Health Checks (Saves 80%)

Simple curl-based health validation:

# Efficient: Quick health check (no complex monitoring)
verify_rollback_health() {
    local endpoint="$1"
    local max_attempts=30

    echo "Verifying health after rollback..."

    for i in $(seq 1 $max_attempts); do
        if curl -sf "$endpoint/health" > /dev/null 2>&1; then
            echo "✓ Health check passed"
            return 0
        fi
        sleep 2
    done

    echo "❌ Health check failed after $max_attempts attempts"
    return 1
}

Savings: 80% vs full monitoring integration (simple curl vs metrics analysis: 1,500 → 300 tokens)

5. Deployment History Caching (Saves 75%)

Cache recent deployment history:

HISTORY_CACHE=".claude/cache/deployment-rollback/history.json"
CACHE_TTL=300  # 5 minutes (deployments are frequent)

if [ -f "$HISTORY_CACHE" ]; then
    CACHE_AGE=$(($(date +%s) - $(stat -c %Y "$HISTORY_CACHE")))

    if [ $CACHE_AGE -lt $CACHE_TTL ]; then
        echo "Recent deployments (cached):"
        jq -r '.[] | "\(.timestamp) - \(.version) (\(.status))"' "$HISTORY_CACHE" | head -5
        exit 0
    fi
fi

# Fetch and cache history
get_deployment_history | head -10 > "$HISTORY_CACHE"

Savings: 75% when cache valid (no API calls, instant history: 2,000 → 500 tokens)

6. Progressive Rollback Steps (Saves 60%)

Execute only necessary steps:

ROLLBACK_STEPS="${ROLLBACK_STEPS:-app}"  # Default: app only

case "$ROLLBACK_STEPS" in
    app)
        # App only (500 tokens)
        rollback_application
        verify_health
        ;;

    app-db)
        # App + database (1,200 tokens)
        rollback_application
        rollback_database_migrations
        verify_health
        ;;

    full)
        # Complete rollback (2,500 tokens)
        create_backup
        rollback_application
        rollback_database_migrations
        rollback_configuration
        rollback_infrastructure
        verify_health
        notify_team
        ;;
esac

Savings: 60% for app-only rollbacks (500 vs 2,500 tokens)

7. Grep-Based Migration Detection (Saves 85%)

Check for pending migrations without full analysis:

# Efficient: Quick migration status
check_migration_status() {
    # Check if migrations exist
    if [ ! -d "db/migrations" ] && [ ! -d "migrations" ]; then
        echo "✓ No migrations to rollback"
        return 0
    fi

    # Count migrations (no full read)
    MIGRATION_COUNT=$(find db/migrations migrations -name "*.sql" -o -name "*.js" 2>/dev/null | wc -l)

    if [ "$MIGRATION_COUNT" -eq 0 ]; then
        echo "✓ No pending migrations"
    else
        echo "⚠️  $MIGRATION_COUNT migrations found - review before rollback"
    fi
}

Savings: 85% (count vs full migration analysis: 1,500 → 225 tokens)

Cache Invalidation

Caches are invalidated when:

• New deployment detected
• 5 minutes elapsed (deployment history)
• 24 hours elapsed (platform detection)
• User runs

  --force

  or

  --clear-cache

  flag

Real-World Token Usage

Typical rollback workflow:

1. Quick rollback (app only): 800-1,500 tokens

   • Cached platform: 100 tokens
   • Rollback script generation: 400 tokens
   • Execution + health check: 500 tokens
   • Summary: 200 tokens

2. First-time setup: 1,500-2,500 tokens

   • Platform detection: 500 tokens
   • History fetch: 400 tokens
   • Rollback script: 600 tokens
   • Health verification: 400 tokens
   • Summary: 200 tokens

3. Full rollback (app + db + infra): 2,500-3,500 tokens

   • All basic steps: 1,500 tokens
   • Database migration rollback: 600 tokens
   • Infrastructure rollback: 500 tokens
   • Complete verification: 400 tokens

4. History check only: 300-600 tokens

   • Cached history display
   • No rollback execution

5. Already at target version: 150-300 tokens

   • Early exit (95% savings)

Average usage distribution:

• 50% of runs: Quick app rollback (800-1,500 tokens) ✅ Most common
• 25% of runs: First-time setup (1,500-2,500 tokens)
• 15% of runs: History check only (300-600 tokens)
• 10% of runs: Full rollback (2,500-3,500 tokens)

Expected token range: 800-2,500 tokens (50% reduction from 1,600-5,000 baseline)

Progressive Disclosure

Three rollback levels:

1. Default (app only): Quick application rollback

   claude "/deployment-rollback previous"
   # Steps: app rollback + health check
   # Tokens: 800-1,500
   

2. Standard (app + db): Application and database

   claude "/deployment-rollback v1.2.3 --with-db"
   # Steps: app + database migrations + health
   # Tokens: 1,500-2,000
   

3. Full (complete): Complete environment rollback

   claude "/deployment-rollback v1.2.3 --full"
   # Steps: all components + config + infra
   # Tokens: 2,500-3,500
   

Implementation Notes

Key patterns applied:

• ✅ Deployment platform caching (600 token savings)
• ✅ Early exit for safe state (95% reduction)
• ✅ Template-based rollback scripts (70% savings)
• ✅ Bash-based health checks (80% savings)
• ✅ Deployment history caching (75% savings)
• ✅ Progressive rollback steps (60% savings)
• ✅ Grep-based migration detection (85% savings)

Cache locations:

• .claude/cache/deployment-rollback/platform.json

  - Platform and environment (24 hour TTL)

• .claude/cache/deployment-rollback/history.json

  - Deployment history (5 minute TTL)

Flags:

• --with-db

  - Include database migration rollback

• --full

  - Complete rollback (app + db + config + infra)

• --force

  - Skip confirmation prompts

• --dry-run

  - Show rollback plan without executing

• --clear-cache

  - Force cache invalidation

Supported platforms:

• Kubernetes (kubectl rollout undo)
• Docker Compose (container recreation)
• AWS ECS (task definition rollback)
• Heroku (releases:rollback)
• Vercel/Netlify (deployment rollback)

---

Phase 1: Detect Deployment Environment

First, let me analyze your deployment setup:

# Detect deployment platform and configuration
detect_deployment_environment() {
    local platform=""
    local environments=()

    echo "=== Detecting Deployment Environment ==="
    echo ""

    # Kubernetes/Helm
    if [ -f "Chart.yaml" ] || command -v kubectl &> /dev/null; then
        platform="kubernetes"
        echo "✓ Kubernetes detected"

        # Get current contexts
        if command -v kubectl &> /dev/null; then
            echo "  Available contexts:"
            kubectl config get-contexts -o name | while read ctx; do
                echo "    - $ctx"
                environments+=("$ctx")
            done
        fi
    fi

    # Docker Compose
    if [ -f "docker-compose.yml" ] || [ -f "docker-compose.yaml" ]; then
        platform="${platform:+$platform,}docker-compose"
        echo "✓ Docker Compose detected"
    fi

    # AWS ECS
    if command -v aws &> /dev/null; then
        if aws ecs list-clusters 2>/dev/null | grep -q "clusterArns"; then
            platform="${platform:+$platform,}ecs"
            echo "✓ AWS ECS detected"
        fi
    fi

    # Heroku
    if command -v heroku &> /dev/null && [ -f "Procfile" ]; then
        platform="${platform:+$platform,}heroku"
        echo "✓ Heroku detected"

        heroku apps:info 2>/dev/null | grep -q "===" && {
            echo "  Current app: $(heroku apps:info | grep '===' | cut -d' ' -f2)"
        }
    fi

    # Vercel/Netlify
    if [ -f "vercel.json" ]; then
        platform="${platform:+$platform,}vercel"
        echo "✓ Vercel detected"
    fi

    if [ -f "netlify.toml" ]; then
        platform="${platform:+$platform,}netlify"
        echo "✓ Netlify detected"
    fi

    # Database detection
    echo ""
    echo "Detecting database setup..."

    if [ -f "prisma/schema.prisma" ]; then
        echo "✓ Prisma migrations detected"
    elif [ -d "migrations" ] || [ -d "db/migrate" ]; then
        echo "✓ Database migrations detected"
    elif command -v flyway &> /dev/null; then
        echo "✓ Flyway migrations detected"
    fi

    if [ -z "$platform" ]; then
        echo "⚠ No deployment platform detected"
        echo ""
        echo "Supported platforms:"
        echo "  - Kubernetes/Helm"
        echo "  - Docker Compose"
        echo "  - AWS ECS"
        echo "  - Heroku"
        echo "  - Vercel/Netlify"
    fi

    echo "$platform"
}

DEPLOYMENT_PLATFORM=$(detect_deployment_environment)

echo ""

Phase 2: Pre-Rollback Validation

<think> Rollback is a critical operation that requires careful consideration: - What version are we rolling back to? - Are there database schema changes that need reversal? - Will rollback cause data loss? - Are there dependencies between services that need coordination? - What is the rollback window before data loss occurs? - Do we need to notify users/stakeholders?

Critical safety checks:

• Verify target version is healthy
• Check for breaking database changes
• Ensure rollback path exists
• Validate configuration compatibility
• Confirm backup availability </think>

Before rolling back, I'll perform critical safety checks:

pre_rollback_validation() {
    local environment=$1

    echo "=== Pre-Rollback Validation ==="
    echo ""

    # Extract environment from arguments
    if [[ "$ARGUMENTS" =~ staging|production|prod|dev ]]; then
        environment=$(echo "$ARGUMENTS" | grep -oE "staging|production|prod|dev" | head -1)
        echo "Target Environment: $environment"
    else
        echo "⚠ Environment not specified in arguments"
        echo ""
        echo "Available environments:"
        echo "  - dev (development)"
        echo "  - staging"
        echo "  - production"
        echo ""
        read -p "Enter environment to rollback: " environment
    fi

    # Safety confirmation for production
    if [[ "$environment" =~ production|prod ]]; then
        echo ""
        echo "🚨 PRODUCTION ROLLBACK WARNING 🚨"
        echo ""
        echo "You are about to rollback PRODUCTION."
        echo "This will affect live users and services."
        echo ""
        read -p "Type 'ROLLBACK PRODUCTION' to confirm: " confirmation

        if [ "$confirmation" != "ROLLBACK PRODUCTION" ]; then
            echo "❌ Rollback cancelled"
            exit 1
        fi
    fi

    echo ""
    echo "Validation checks:"

    # Check 1: Git status
    echo "  1. Git repository status..."
    if git rev-parse --git-dir > /dev/null 2>&1; then
        current_branch=$(git branch --show-current)
        last_commit=$(git log -1 --oneline)
        echo "     Current branch: $current_branch"
        echo "     Last commit: $last_commit"
    else
        echo "     ⚠ Not a git repository"
    fi

    # Check 2: Deployment history
    echo "  2. Recent deployments..."
    case $DEPLOYMENT_PLATFORM in
        *kubernetes*)
            if command -v kubectl &> /dev/null; then
                echo "     Fetching rollout history..."
                kubectl rollout history deployment -n "$environment" 2>/dev/null | head -10
            fi
            ;;
        *heroku*)
            if command -v heroku &> /dev/null; then
                echo "     Fetching release history..."
                heroku releases --app "$environment" -n 10 2>/dev/null
            fi
            ;;
    esac

    # Check 3: Current health status
    echo "  3. Current application health..."
    check_application_health "$environment" "before-rollback"

    # Check 4: Database migration status
    echo "  4. Database migration status..."
    check_migration_status

    # Check 5: Backup verification
    echo "  5. Backup availability..."
    verify_backups "$environment"

    echo ""
    echo "✓ Pre-rollback validation complete"

    echo "$environment"
}

ENVIRONMENT=$(pre_rollback_validation)

Phase 3: Create Rollback Checkpoint

I'll create a checkpoint before rollback for safety:

create_rollback_checkpoint() {
    local environment=$1

    echo ""
    echo "=== Creating Rollback Checkpoint ==="
    echo ""

    # Create checkpoint directory
    CHECKPOINT_DIR=".rollback-checkpoint-$(date +%Y%m%d-%H%M%S)"
    mkdir -p "$CHECKPOINT_DIR"

    echo "Checkpoint: $CHECKPOINT_DIR"
    echo ""

    # 1. Save current deployment state
    echo "1. Saving deployment state..."

    case $DEPLOYMENT_PLATFORM in
        *kubernetes*)
            if command -v kubectl &> /dev/null; then
                kubectl get deployments -n "$environment" -o yaml > "$CHECKPOINT_DIR/deployments.yaml"
                kubectl get services -n "$environment" -o yaml > "$CHECKPOINT_DIR/services.yaml"
                kubectl get configmaps -n "$environment" -o yaml > "$CHECKPOINT_DIR/configmaps.yaml"
                echo "   ✓ Kubernetes state saved"
            fi
            ;;

        *docker-compose*)
            cp docker-compose.yml "$CHECKPOINT_DIR/" 2>/dev/null || true
            docker-compose config > "$CHECKPOINT_DIR/docker-compose-resolved.yml" 2>/dev/null || true
            echo "   ✓ Docker Compose state saved"
            ;;

        *ecs*)
            if command -v aws &> /dev/null; then
                aws ecs describe-services --cluster "$environment" \
                    --services $(aws ecs list-services --cluster "$environment" --query 'serviceArns' --output text) \
                    > "$CHECKPOINT_DIR/ecs-services.json" 2>/dev/null
                echo "   ✓ ECS state saved"
            fi
            ;;
    esac

    # 2. Save database schema
    echo "2. Saving database schema..."
    if command -v pg_dump &> /dev/null; then
        # PostgreSQL schema dump
        pg_dump --schema-only --no-owner --no-privileges "$DATABASE_URL" \
            > "$CHECKPOINT_DIR/database-schema.sql" 2>/dev/null && \
            echo "   ✓ Database schema saved" || \
            echo "   ⚠ Could not save database schema"
    fi

    # 3. Save environment variables
    echo "3. Saving environment configuration..."
    env | grep -E "^(DATABASE|API|AWS|NODE|PORT|HOST)" > "$CHECKPOINT_DIR/environment.txt" 2>/dev/null || true
    echo "   ✓ Environment saved"

    # 4. Save application logs (recent)
    echo "4. Saving recent logs..."
    case $DEPLOYMENT_PLATFORM in
        *kubernetes*)
            kubectl logs -n "$environment" --tail=1000 --all-containers=true \
                > "$CHECKPOINT_DIR/logs-before-rollback.txt" 2>/dev/null || true
            ;;
    esac
    echo "   ✓ Logs saved"

    echo ""
    echo "✓ Checkpoint created: $CHECKPOINT_DIR"

    echo "$CHECKPOINT_DIR"
}

CHECKPOINT_DIR=$(create_rollback_checkpoint "$ENVIRONMENT")

Phase 4: Determine Rollback Target

I'll identify the version to rollback to:

determine_rollback_target() {
    local environment=$1

    echo ""
    echo "=== Determining Rollback Target ==="
    echo ""

    # Check if version specified in arguments
    if [[ "$ARGUMENTS" =~ v[0-9]+\.[0-9]+\.[0-9]+ ]]; then
        TARGET_VERSION=$(echo "$ARGUMENTS" | grep -oE "v[0-9]+\.[0-9]+\.[0-9]+" | head -1)
        echo "Target version from arguments: $TARGET_VERSION"
    else
        # Show recent versions
        echo "Recent versions/releases:"
        echo ""

        case $DEPLOYMENT_PLATFORM in
            *kubernetes*)
                kubectl rollout history deployment -n "$environment" | tail -10
                echo ""
                read -p "Enter revision number to rollback to: " revision
                TARGET_VERSION="revision-$revision"
                ;;

            *heroku*)
                heroku releases --app "$environment" -n 10
                echo ""
                read -p "Enter release version (e.g., v123): " version
                TARGET_VERSION="$version"
                ;;

            *)
                git log --oneline -10
                echo ""
                read -p "Enter commit hash to rollback to: " commit
                TARGET_VERSION="$commit"
                ;;
        esac
    fi

    echo ""
    echo "Target version: $TARGET_VERSION"

    echo "$TARGET_VERSION"
}

TARGET_VERSION=$(determine_rollback_target "$ENVIRONMENT")

Phase 5: Database Migration Rollback

I'll safely rollback database migrations if needed:

rollback_database_migrations() {
    echo ""
    echo "=== Database Migration Rollback ==="
    echo ""

    # Check if database rollback is needed
    echo "Analyzing migration changes between versions..."

    # Prisma migrations
    if [ -f "prisma/schema.prisma" ]; then
        echo "Prisma migrations detected"
        echo ""
        echo "⚠ WARNING: Prisma doesn't support automatic rollback"
        echo "You need to manually create a migration to reverse changes."
        echo ""
        read -p "Have you created a rollback migration? (yes/no): " has_rollback

        if [ "$has_rollback" = "yes" ]; then
            echo "Applying rollback migration..."
            npx prisma migrate deploy
        else
            echo "❌ Cannot proceed without rollback migration"
            echo "Create migration first: npx prisma migrate dev"
            exit 1
        fi

    # Rails migrations
    elif [ -d "db/migrate" ] && [ -f "Gemfile" ]; then
        echo "Rails migrations detected"
        echo ""
        echo "Current migration version:"
        rails db:version 2>/dev/null || echo "  (unable to determine)"
        echo ""
        read -p "Rollback to which version? (leave empty for one step back): " migration_version

        if [ -z "$migration_version" ]; then
            echo "Rolling back one migration..."
            rails db:rollback
        else
            echo "Rolling back to version: $migration_version"
            rails db:migrate:down VERSION="$migration_version"
        fi

    # Django migrations
    elif [ -f "manage.py" ] && [ -d "*/migrations" ]; then
        echo "Django migrations detected"
        echo ""
        python manage.py showmigrations
        echo ""
        read -p "Enter app and migration to rollback to (e.g., app_name 0003): " app migration

        if [ -n "$app" ] && [ -n "$migration" ]; then
            echo "Rolling back $app to $migration..."
            python manage.py migrate "$app" "$migration"
        fi

    # Flyway migrations
    elif command -v flyway &> /dev/null; then
        echo "Flyway migrations detected"
        echo ""
        echo "⚠ WARNING: Flyway requires manual undo migrations"
        echo "Ensure you have corresponding undo SQL files"
        echo ""
        read -p "Number of migrations to undo: " undo_count

        if [ -n "$undo_count" ]; then
            echo "Undoing $undo_count migrations..."
            flyway undo -target="-$undo_count"
        fi

    else
        echo "No recognized migration system detected"
        echo ""
        echo "If you have custom migrations, rollback manually before proceeding."
        read -p "Press Enter to continue or Ctrl+C to abort..."
    fi

    echo ""
    echo "✓ Database migration rollback complete"
}

# Ask if database rollback needed
echo ""
read -p "Does this rollback require database migration reversal? (yes/no): " needs_db_rollback

if [ "$needs_db_rollback" = "yes" ]; then
    rollback_database_migrations
fi

Phase 6: Execute Application Rollback

Now I'll rollback the application:

execute_application_rollback() {
    local environment=$1
    local target=$2

    echo ""
    echo "=== Executing Application Rollback ==="
    echo ""
    echo "Environment: $environment"
    echo "Target: $target"
    echo ""

    case $DEPLOYMENT_PLATFORM in
        *kubernetes*)
            echo "Rolling back Kubernetes deployment..."

            # Get deployment name
            deployments=$(kubectl get deployments -n "$environment" -o name)

            for deployment in $deployments; do
                deployment_name=$(echo "$deployment" | cut -d'/' -f2)

                echo "  Rollback: $deployment_name"

                if [[ "$target" =~ revision-([0-9]+) ]]; then
                    revision="${BASH_REMATCH[1]}"
                    kubectl rollout undo deployment/"$deployment_name" \
                        -n "$environment" --to-revision="$revision"
                else
                    # Rollback to previous revision
                    kubectl rollout undo deployment/"$deployment_name" -n "$environment"
                fi

                # Wait for rollback to complete
                echo "  Waiting for rollback to complete..."
                kubectl rollout status deployment/"$deployment_name" \
                    -n "$environment" --timeout=5m
            done

            echo "✓ Kubernetes rollback complete"
            ;;

        *heroku*)
            echo "Rolling back Heroku app..."

            if [[ "$target" =~ v([0-9]+) ]]; then
                version="${BASH_REMATCH[1]}"
                heroku rollback "$version" --app "$environment"
            else
                # Rollback to previous release
                heroku rollback --app "$environment"
            fi

            echo "✓ Heroku rollback complete"
            ;;

        *ecs*)
            echo "Rolling back ECS service..."

            # Get service name
            services=$(aws ecs list-services --cluster "$environment" \
                --query 'serviceArns[*]' --output text)

            for service_arn in $services; do
                service_name=$(echo "$service_arn" | rev | cut -d'/' -f1 | rev)

                echo "  Rollback: $service_name"

                # Get previous task definition
                current_td=$(aws ecs describe-services --cluster "$environment" \
                    --services "$service_name" \
                    --query 'services[0].taskDefinition' --output text)

                # Extract family and current revision
                td_family=$(echo "$current_td" | cut -d':' -f6 | rev | cut -d'/' -f1 | rev | sed 's/:[0-9]*$//')
                current_rev=$(echo "$current_td" | rev | cut -d':' -f1 | rev)
                previous_rev=$((current_rev - 1))

                previous_td="$td_family:$previous_rev"

                echo "  Current: $current_td"
                echo "  Rolling back to: $previous_td"

                # Update service with previous task definition
                aws ecs update-service \
                    --cluster "$environment" \
                    --service "$service_name" \
                    --task-definition "$previous_td" \
                    --force-new-deployment

                echo "  Waiting for service to stabilize..."
                aws ecs wait services-stable \
                    --cluster "$environment" \
                    --services "$service_name"
            done

            echo "✓ ECS rollback complete"
            ;;

        *docker-compose*)
            echo "Rolling back Docker Compose..."

            # Restore previous docker-compose.yml
            if [ -f "$CHECKPOINT_DIR/docker-compose.yml" ]; then
                echo "  Restoring docker-compose.yml..."
                # Note: This assumes you have the old version saved
                echo "  ⚠ Manual intervention may be required"
                echo "  Restore docker-compose.yml from git: git checkout $target docker-compose.yml"
            fi

            # Pull and restart with previous version
            docker-compose down
            docker-compose pull
            docker-compose up -d

            echo "✓ Docker Compose rollback complete"
            ;;

        *)
            echo "Platform-specific rollback not automated."
            echo "Manual steps required:"
            echo "  1. Deploy previous version"
            echo "  2. Restart services"
            echo "  3. Verify health"
            ;;
    esac

    echo ""
}

execute_application_rollback "$ENVIRONMENT" "$TARGET_VERSION"

Phase 7: Health Check Validation

After rollback, I'll verify the application is healthy:

check_application_health() {
    local environment=$1
    local phase=$2

    echo ""
    echo "=== Health Check: $phase ==="
    echo ""

    local all_healthy=true

    # HTTP health checks
    if [ -n "$HEALTH_CHECK_URL" ]; then
        echo "Checking HTTP endpoint: $HEALTH_CHECK_URL"

        for i in {1..10}; do
            if curl -sf "$HEALTH_CHECK_URL" > /dev/null; then
                echo "  ✓ Health check passed (attempt $i)"
                break
            else
                echo "  ⚠ Health check failed (attempt $i/10)"
                if [ $i -eq 10 ]; then
                    all_healthy=false
                    echo "  ❌ Health checks failed after 10 attempts"
                fi
                sleep 5
            fi
        done
    fi

    # Platform-specific health checks
    case $DEPLOYMENT_PLATFORM in
        *kubernetes*)
            echo "Checking Kubernetes pod health..."

            pods=$(kubectl get pods -n "$environment" --field-selector=status.phase=Running --no-headers 2>/dev/null | wc -l)
            total_pods=$(kubectl get pods -n "$environment" --no-headers 2>/dev/null | wc -l)

            echo "  Running pods: $pods/$total_pods"

            if [ "$pods" -eq "$total_pods" ] && [ "$pods" -gt 0 ]; then
                echo "  ✓ All pods are running"
            else
                echo "  ❌ Some pods are not running"
                all_healthy=false

                # Show failing pods
                kubectl get pods -n "$environment" --field-selector=status.phase!=Running
            fi
            ;;

        *ecs*)
            echo "Checking ECS service health..."

            services=$(aws ecs list-services --cluster "$environment" --query 'serviceArns[*]' --output text)

            for service_arn in $services; do
                service_name=$(echo "$service_arn" | rev | cut -d'/' -f1 | rev)

                running_count=$(aws ecs describe-services --cluster "$environment" \
                    --services "$service_name" \
                    --query 'services[0].runningCount' --output text)

                desired_count=$(aws ecs describe-services --cluster "$environment" \
                    --services "$service_name" \
                    --query 'services[0].desiredCount' --output text)

                echo "  $service_name: $running_count/$desired_count running"

                if [ "$running_count" -ne "$desired_count" ]; then
                    all_healthy=false
                fi
            done
            ;;
    esac

    # Check error rates in logs (last 5 minutes)
    echo ""
    echo "Checking error rates..."

    case $DEPLOYMENT_PLATFORM in
        *kubernetes*)
            error_count=$(kubectl logs -n "$environment" --since=5m --all-containers=true 2>/dev/null | \
                grep -iE "error|exception|fatal" | wc -l)

            echo "  Error logs (last 5m): $error_count"

            if [ "$error_count" -gt 50 ]; then
                echo "  ⚠ High error rate detected"
                all_healthy=false
            fi
            ;;
    esac

    echo ""

    if [ "$all_healthy" = true ]; then
        echo "✓ All health checks passed"
    else
        echo "❌ Some health checks failed"
        echo ""
        echo "Rollback may require additional investigation."
    fi

    return $([ "$all_healthy" = true ] && echo 0 || echo 1)
}

# Post-rollback health check
check_application_health "$ENVIRONMENT" "post-rollback"
HEALTH_STATUS=$?

Phase 8: Rollback Summary and Next Steps

I'll provide a comprehensive rollback summary:

generate_rollback_summary() {
    echo ""
    echo "=== Rollback Summary ==="
    echo ""

    cat << EOF
Environment: $ENVIRONMENT
Target Version: $TARGET_VERSION
Checkpoint: $CHECKPOINT_DIR
Status: $([ $HEALTH_STATUS -eq 0 ] && echo "SUCCESS" || echo "NEEDS ATTENTION")

**Actions Taken:**
1. ✓ Pre-rollback validation completed
2. ✓ Rollback checkpoint created
3. ✓ Target version identified
4. $([ "$needs_db_rollback" = "yes" ] && echo "✓" || echo "-") Database migrations rolled back
5. ✓ Application rolled back
6. $([ $HEALTH_STATUS -eq 0 ] && echo "✓" || echo "⚠") Health checks completed

**Next Steps:**

1. Monitor application closely for next 30 minutes
2. Check error logs for anomalies
3. Verify critical business functions
4. Notify stakeholders of rollback
5. Investigate root cause of issues

**Monitoring Commands:**

Logs:
EOF

    case $DEPLOYMENT_PLATFORM in
        *kubernetes*)
            echo "  kubectl logs -f -n $ENVIRONMENT deployment/your-app"
            ;;
        *heroku*)
            echo "  heroku logs --tail --app $ENVIRONMENT"
            ;;
        *ecs*)
            echo "  aws logs tail /ecs/$ENVIRONMENT --follow"
            ;;
    esac

    cat << EOF

Metrics:
  - Check response times
  - Monitor error rates
  - Watch resource utilization

**Checkpoint Recovery:**

If you need to restore to pre-rollback state:
  1. Review files in: $CHECKPOINT_DIR
  2. Redeploy using saved configurations
  3. Restore database schema if needed

**Important Notes:**
- Keep checkpoint directory until rollback is confirmed stable
- Document what caused the need for rollback
- Plan fixes before next deployment
- Consider additional testing before redeployment

EOF

    if [ $HEALTH_STATUS -ne 0 ]; then
        cat << EOF

⚠ ATTENTION REQUIRED ⚠

Health checks indicate potential issues.
Immediate actions:
  1. Check application logs for errors
  2. Verify database connectivity
  3. Test critical user flows
  4. Consider rolling forward if issues persist

EOF
    fi
}

generate_rollback_summary

Rollback Decision Matrix

Guide for when to rollback:

cat << 'EOF'

=== Rollback Decision Matrix ===

**Immediate Rollback (within 5 minutes):**
- ❌ Complete service outage
- ❌ Data corruption detected
- ❌ Security vulnerability introduced
- ❌ Critical feature completely broken

**Planned Rollback (within 30 minutes):**
- ⚠ Elevated error rates (>5% increase)
- ⚠ Performance degradation (>50% slower)
- ⚠ Partial feature breakage affecting users
- ⚠ Database migration issues

**Monitor and Fix Forward:**
- ℹ Minor bugs affecting <1% of users
- ℹ Cosmetic issues
- ℹ Non-critical features affected
- ℹ Performance degradation <20%

**Factors to Consider:**
1. User impact severity
2. Data integrity risk
3. Rollback complexity
4. Time to fix forward
5. Business requirements

EOF

Integration Points

This skill works well with:

• /deploy-validate

  - Pre-deployment validation to prevent rollbacks

• /security-scan

  - Verify no security regressions after rollback

• /test

  - Run tests after rollback to verify functionality

Safety Guarantees

Protection Measures:

• Automatic checkpoint creation before rollback
• Health monitoring during rollback
• Database backup verification
• Multi-stage confirmation for production
• Detailed audit trail

Important: I will NEVER:

• Rollback production without explicit confirmation
• Skip health checks after rollback
• Delete checkpoints prematurely
• Ignore database migration conflicts
• Add AI attribution to rollback logs

Example Workflows

# Emergency production rollback
/deployment-rollback production

# Rollback to specific version
/deployment-rollback staging v2.1.0

# Rollback with database reversal
/deployment-rollback production
# Follow prompts for database rollback

# Check rollback was successful
/test
/security-scan

Troubleshooting

Issue: Rollback stuck/timing out

• Solution: Check platform-specific status
• Solution: May need manual intervention
• Solution: Contact platform support if needed

Issue: Database rollback failed

• Solution: Restore from most recent backup
• Solution: Manually reverse schema changes
• Solution: Check migration logs for errors

Issue: Health checks failing after rollback

• Solution: Check if previous version had issues too
• Solution: May need to rollback further
• Solution: Consider rolling forward with fixes

Issue: Configuration mismatch

• Solution: Restore environment variables from checkpoint
• Solution: Check secrets/config management system
• Solution: Verify external service configurations

Credits:

• Rollback strategies from Kubernetes documentation
• Database migration patterns from Prisma and Rails guides
• Health check best practices from DevOps engineering
• Deployment safety patterns from SKILLS_EXPANSION_PLAN.md Tier 3 DevOps practices