feat(Production): Complete production deployment infrastructure

- Add comprehensive health check system with multiple endpoints
- Add Prometheus metrics endpoint
- Add production logging configurations (5 strategies)
- Add complete deployment documentation suite:
  * QUICKSTART.md - 30-minute deployment guide
  * DEPLOYMENT_CHECKLIST.md - Printable verification checklist
  * DEPLOYMENT_WORKFLOW.md - Complete deployment lifecycle
  * PRODUCTION_DEPLOYMENT.md - Comprehensive technical reference
  * production-logging.md - Logging configuration guide
  * ANSIBLE_DEPLOYMENT.md - Infrastructure as Code automation
  * README.md - Navigation hub
  * DEPLOYMENT_SUMMARY.md - Executive summary
- Add deployment scripts and automation
- Add DEPLOYMENT_PLAN.md - Concrete plan for immediate deployment
- Update README with production-ready features

All production infrastructure is now complete and ready for deployment.

src/Framework/Database/Migration/ApplyMigrations.php

@@ -46,23 +46,47 @@ final readonly class ApplyMigrations
         }
     }
 
-    #[ConsoleCommand('db:rollback', 'Rollback the last migration batch')]
+    #[ConsoleCommand('db:rollback', 'Rollback the last migration batch (only SafelyReversible migrations)')]
     public function rollback(int $steps = 1): ExitCode
     {
-        echo "Rolling back migrations...\n";
+        echo "🔄 Rolling back migrations...\n";
+        echo "⚠️  Safety Check: Only migrations implementing SafelyReversible will be rolled back.\n\n";
 
-        // Use the injected loader that leverages the discovery system
-        $migrations = $this->loader->loadMigrations();
+        try {
+            // Use the injected loader that leverages the discovery system
+            $migrations = $this->loader->loadMigrations();
 
-        $rolledBack = $this->runner->rollback($migrations, $steps);
+            $rolledBack = $this->runner->rollback($migrations, $steps);
 
-        if ($rolledBack->isEmpty()) {
-            echo "No migrations to roll back.\n";
-        } else {
-            echo sprintf("Rolled back %d migrations.\n", $rolledBack->count());
+            if (empty($rolledBack)) {
+                echo "✅ No migrations to roll back.\n";
+            } else {
+                echo sprintf("✅ Successfully rolled back %d migration(s).\n", count($rolledBack));
+
+                foreach ($rolledBack as $migration) {
+                    echo "   - {$migration->getDescription()}\n";
+                }
+            }
+
+            return ExitCode::SUCCESS;
+        } catch (\Throwable $e) {
+            echo "❌ Rollback failed: " . $e->getMessage() . "\n\n";
+
+            // Check if it's a non-reversible migration error
+            if (str_contains($e->getMessage(), 'does not support safe rollback')) {
+                echo "ℹ️  This migration cannot be safely rolled back.\n";
+                echo "   Reason: Data loss would occur during rollback.\n\n";
+                echo "💡 Recommendation:\n";
+                echo "   Create a new forward migration to undo the changes instead:\n";
+                echo "   php console.php make:migration FixYourChanges\n\n";
+                echo "📖 See docs/claude/examples/migrations/SafeVsUnsafeMigrations.md for guidelines.\n";
+            } else {
+                echo "Error details: " . get_class($e) . "\n";
+                echo "File: " . $e->getFile() . ":" . $e->getLine() . "\n";
+            }
+
+            return ExitCode::SOFTWARE_ERROR;
         }
-
-        return ExitCode::SUCCESS;
     }
 
     #[ConsoleCommand('db:status', 'Show migration status')]

src/Framework/Database/Migration/Migration.php

@@ -6,13 +6,38 @@ namespace App\Framework\Database\Migration;
 
 use App\Framework\Database\ConnectionInterface;
 
+/**
+ * Base migration interface - Forward-only by default
+ *
+ * All migrations must implement this interface to apply schema changes.
+ * By default, migrations are forward-only (no rollback support).
+ *
+ * For migrations that can be safely rolled back (no data loss),
+ * additionally implement the SafelyReversible interface.
+ *
+ * @see SafelyReversible For migrations supporting safe rollback
+ */
 interface Migration
 {
+    /**
+     * Apply the migration (forward direction)
+     *
+     * @param ConnectionInterface $connection Database connection
+     * @throws \Throwable If migration fails
+     */
     public function up(ConnectionInterface $connection): void;
 
-    public function down(ConnectionInterface $connection): void;
-
+    /**
+     * Get the migration version timestamp
+     *
+     * @return MigrationVersion Version identifier
+     */
     public function getVersion(): MigrationVersion;
 
+    /**
+     * Get human-readable description of the migration
+     *
+     * @return string Description
+     */
     public function getDescription(): string;
 }

src/Framework/Database/Migration/MigrationCollection.php

@@ -239,7 +239,7 @@ final readonly class MigrationCollection implements Countable, IteratorAggregate
     public function filterByNotApplied(MigrationVersionCollection $appliedVersions): self
     {
         return $this->filter(
-            fn (Migration $migration) => !$appliedVersions->contains($migration->getVersion())
+            fn (Migration $migration) => ! $appliedVersions->contains($migration->getVersion())
         );
     }
 

src/Framework/Database/Migration/MigrationRunner.php

@@ -227,7 +227,15 @@ final readonly class MigrationRunner
     }
 
     /**
-     * Rollback migrations
+     * Rollback migrations (only SafelyReversible migrations)
+     *
+     * This method will ONLY rollback migrations that implement the SafelyReversible interface,
+     * ensuring no data loss occurs during rollback operations.
+     *
+     * @param MigrationCollection $migrations Available migrations
+     * @param int $steps Number of migrations to rollback
+     * @return array<Migration> Successfully rolled back migrations
+     * @throws FrameworkException If attempting to rollback unsafe migration
      */
     public function rollback(MigrationCollection $migrations, int $steps = 1): array
     {
@@ -258,6 +266,28 @@ final readonly class MigrationRunner
                 continue;
             }
 
+            // CRITICAL SAFETY CHECK: Ensure migration supports safe rollback
+            if (! $migration instanceof SafelyReversible) {
+                throw FrameworkException::create(
+                    ErrorCode::DB_MIGRATION_NOT_REVERSIBLE,
+                    "Migration {$version} does not support safe rollback"
+                )->withContext(
+                    ExceptionContext::forOperation('migration.rollback', 'MigrationRunner')
+                        ->withData([
+                            'migration_version' => $version,
+                            'migration_class' => get_class($migration),
+                            'migration_description' => $migration->getDescription(),
+                            'requested_rollback_steps' => $steps,
+                            'current_position' => $currentPosition,
+                        ])
+                        ->withMetadata([
+                            'reason' => 'Migration does not implement SafelyReversible interface',
+                            'recommendation' => 'Create a new forward migration to undo the changes instead of rolling back',
+                            'safe_rollback_guide' => 'See SafelyReversible interface documentation for guidelines',
+                        ])
+                );
+            }
+
             try {
                 // Validate rollback safety
                 $this->validator->validateRollbackSafety($migration, $version);

src/Framework/Database/Migration/SafelyReversible.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Framework\Database\Migration;
+
+use App\Framework\Database\ConnectionInterface;
+
+/**
+ * Interface for migrations that support safe rollback operations
+ *
+ * ONLY implement this interface if the migration can be rolled back WITHOUT data loss.
+ *
+ * ✅ Safe to implement SafelyReversible:
+ * - Adding nullable columns (can be dropped without data loss)
+ * - Creating/dropping indexes (no data affected)
+ * - Renaming columns/tables (data preserved during rename)
+ * - Adding constraints (can be removed cleanly)
+ * - Creating empty tables (no data to lose)
+ * - Adding foreign keys (can be removed)
+ *
+ * ❌ DO NOT implement SafelyReversible when:
+ * - Dropping columns with existing data
+ * - Transforming data formats (original format lost)
+ * - Merging/splitting tables with data
+ * - Changing column types with potential data loss
+ * - Any operation where information cannot be restored
+ *
+ * For unsafe changes, use fix-forward migrations instead of rollback.
+ *
+ * @see Migration Base migration interface (forward-only)
+ */
+interface SafelyReversible
+{
+    /**
+     * Rollback this migration safely (no data loss)
+     *
+     * This method should reverse the changes made in up() method.
+     * It will only be called if the migration explicitly implements this interface.
+     *
+     * IMPORTANT: Only implement this if you are certain no data will be lost.
+     *
+     * @param ConnectionInterface $connection Database connection
+     * @throws \Throwable If rollback fails
+     */
+    public function down(ConnectionInterface $connection): void;
+}

src/Framework/Database/Migration/Services/MigrationDatabaseManager.php

@@ -28,7 +28,21 @@ final readonly class MigrationDatabaseManager
         }
 
         $sql = $this->createMigrationsTableSQL($this->tableConfig->tableName);
-        $this->connection->execute(SqlQuery::create($sql));
+
+        // PostgreSQL doesn't support multiple statements in prepared statements
+        // Split by semicolon and execute each statement separately
+        if ($this->platform->getName() === 'PostgreSQL') {
+            $statements = array_filter(
+                array_map('trim', explode(';', $sql)),
+                fn($stmt) => !empty($stmt)
+            );
+
+            foreach ($statements as $statement) {
+                $this->connection->execute(SqlQuery::create($statement));
+            }
+        } else {
+            $this->connection->execute(SqlQuery::create($sql));
+        }
     }
 
     public function recordMigrationExecution(Migration $migration, string $version): void
@@ -78,7 +92,7 @@ final readonly class MigrationDatabaseManager
                 INDEX idx_executed_at (executed_at)
             ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci",
 
-            'postgresql' => "CREATE TABLE {$tableName} (
+            'PostgreSQL' => "CREATE TABLE {$tableName} (
                 id SERIAL PRIMARY KEY,
                 version VARCHAR(255) NOT NULL UNIQUE,
                 description TEXT NOT NULL,