v5.4.5: Fix disk space estimation for cluster archives

- Use 1.2x multiplier for cluster .tar.gz (pre-compressed dumps)
- Use 5x multiplier for single .sql.gz files (was 7x)
- New CheckSystemMemoryWithType() for archive-aware estimation
- 119GB archive now estimates ~143GB instead of ~833GB

CHANGELOG.md

@@ -5,6 +5,35 @@ All notable changes to dbbackup will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [5.4.5] - 2026-02-02
+
+### Fixed
+- **Accurate Disk Space Estimation for Cluster Archives**
+  - Fixed WARNING showing 836GB for 119GB archive - was using wrong compression multiplier
+  - Cluster archives (.tar.gz) contain pre-compressed .dump files → now uses 1.2x multiplier
+  - Single SQL files (.sql.gz) still use 5x multiplier (was 7x, slightly optimized)
+  - New `CheckSystemMemoryWithType(size, isClusterArchive)` method for accurate estimates
+  - 119GB cluster archive now correctly estimates ~143GB instead of ~833GB
+
+## [5.4.4] - 2026-02-02
+
+### Fixed
+- **TUI Header Separator Fix** - Capped separator length at 40 chars to prevent line overflow on wide terminals
+
+## [5.4.3] - 2026-02-02
+
+### Fixed
+- **Bulletproof SIGINT Handling** - Zero zombie processes guaranteed
+  - All external commands now use `cleanup.SafeCommand()` with process group isolation
+  - `KillCommandGroup()` sends signals to entire process group (-pgid)
+  - No more orphaned pg_restore/pg_dump/psql/pigz processes on Ctrl+C
+  - 16 files updated with proper signal handling
+
+- **Eliminated External gzip Process** - The `zgrep` command was spawning `gzip -cdfq`
+  - Replaced with in-process pgzip decompression in `preflight.go`
+  - `estimateBlobsInSQL()` now uses pure Go pgzip.NewReader
+  - Zero external gzip processes during restore
+
 ## [5.1.22] - 2026-02-01
 
 ### Added

cmd/native_backup.go

@@ -1,7 +1,6 @@
 package cmd
 
 import (
-	"compress/gzip"
 	"context"
 	"fmt"
 	"io"
@@ -12,6 +11,8 @@ import (
 	"dbbackup/internal/database"
 	"dbbackup/internal/engine/native"
 	"dbbackup/internal/notify"
+
+	"github.com/klauspost/pgzip"
 )
 
 // runNativeBackup executes backup using native Go engines
@@ -58,10 +59,13 @@ func runNativeBackup(ctx context.Context, db database.Database, databaseName, ba
 	}
 	defer file.Close()
 
-	// Wrap with compression if enabled
+	// Wrap with compression if enabled (use pgzip for parallel compression)
 	var writer io.Writer = file
 	if cfg.CompressionLevel > 0 {
-		gzWriter := gzip.NewWriter(file)
+		gzWriter, err := pgzip.NewWriterLevel(file, cfg.CompressionLevel)
+		if err != nil {
+			return fmt.Errorf("failed to create gzip writer: %w", err)
+		}
 		defer gzWriter.Close()
 		writer = gzWriter
 	}

cmd/native_restore.go

@@ -0,0 +1,93 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"time"
+
+	"dbbackup/internal/database"
+	"dbbackup/internal/engine/native"
+	"dbbackup/internal/notify"
+
+	"github.com/klauspost/pgzip"
+)
+
+// runNativeRestore executes restore using native Go engines
+func runNativeRestore(ctx context.Context, db database.Database, archivePath, targetDB string, cleanFirst, createIfMissing bool, startTime time.Time, user string) error {
+	// Initialize native engine manager
+	engineManager := native.NewEngineManager(cfg, log)
+
+	if err := engineManager.InitializeEngines(ctx); err != nil {
+		return fmt.Errorf("failed to initialize native engines: %w", err)
+	}
+	defer engineManager.Close()
+
+	// Check if native engine is available for this database type
+	dbType := detectDatabaseTypeFromConfig()
+	if !engineManager.IsNativeEngineAvailable(dbType) {
+		return fmt.Errorf("native restore engine not available for database type: %s", dbType)
+	}
+
+	// Open archive file
+	file, err := os.Open(archivePath)
+	if err != nil {
+		return fmt.Errorf("failed to open archive: %w", err)
+	}
+	defer file.Close()
+
+	// Detect if file is gzip compressed
+	var reader io.Reader = file
+	if isGzipFile(archivePath) {
+		gzReader, err := pgzip.NewReader(file)
+		if err != nil {
+			return fmt.Errorf("failed to create gzip reader: %w", err)
+		}
+		defer gzReader.Close()
+		reader = gzReader
+	}
+
+	log.Info("Starting native restore",
+		"archive", archivePath,
+		"database", targetDB,
+		"engine", dbType,
+		"clean_first", cleanFirst,
+		"create_if_missing", createIfMissing)
+
+	// Perform restore using native engine
+	if err := engineManager.RestoreWithNativeEngine(ctx, reader, targetDB); err != nil {
+		auditLogger.LogRestoreFailed(user, targetDB, err)
+		if notifyManager != nil {
+			notifyManager.Notify(notify.NewEvent(notify.EventRestoreFailed, notify.SeverityError, "Native restore failed").
+				WithDatabase(targetDB).
+				WithError(err))
+		}
+		return fmt.Errorf("native restore failed: %w", err)
+	}
+
+	restoreDuration := time.Since(startTime)
+
+	log.Info("Native restore completed successfully",
+		"database", targetDB,
+		"duration", restoreDuration,
+		"engine", dbType)
+
+	// Audit log: restore completed
+	auditLogger.LogRestoreComplete(user, targetDB, restoreDuration)
+
+	// Notify: restore completed
+	if notifyManager != nil {
+		notifyManager.Notify(notify.NewEvent(notify.EventRestoreCompleted, notify.SeverityInfo, "Native restore completed").
+			WithDatabase(targetDB).
+			WithDuration(restoreDuration).
+			WithDetail("engine", dbType))
+	}
+
+	return nil
+}
+
+// isGzipFile checks if file has gzip extension
+func isGzipFile(path string) bool {
+	return len(path) > 3 && path[len(path)-3:] == ".gz"
+}

cmd/restore.go

@@ -37,6 +37,8 @@ var (
 	restoreTarget        string
 	restoreVerbose       bool
 	restoreNoProgress    bool
+	restoreNoTUI         bool // Disable TUI for maximum performance (benchmark mode)
+	restoreQuiet         bool // Suppress all output except errors
 	restoreWorkdir       string
 	restoreCleanCluster  bool
 	restoreDiagnose      bool   // Run diagnosis before restore
@@ -326,6 +328,9 @@ func init() {
 	restoreSingleCmd.Flags().StringVar(&restoreProfile, "profile", "balanced", "Resource profile: conservative, balanced, turbo (--jobs=8), max-performance")
 	restoreSingleCmd.Flags().BoolVar(&restoreVerbose, "verbose", false, "Show detailed restore progress")
 	restoreSingleCmd.Flags().BoolVar(&restoreNoProgress, "no-progress", false, "Disable progress indicators")
+	restoreSingleCmd.Flags().BoolVar(&restoreNoTUI, "no-tui", false, "Disable TUI for maximum performance (benchmark mode)")
+	restoreSingleCmd.Flags().BoolVar(&restoreQuiet, "quiet", false, "Suppress all output except errors")
+	restoreSingleCmd.Flags().IntVar(&restoreJobs, "jobs", 0, "Number of parallel pg_restore jobs (0 = auto, like pg_restore -j)")
 	restoreSingleCmd.Flags().StringVar(&restoreEncryptionKeyFile, "encryption-key-file", "", "Path to encryption key file (required for encrypted backups)")
 	restoreSingleCmd.Flags().StringVar(&restoreEncryptionKeyEnv, "encryption-key-env", "DBBACKUP_ENCRYPTION_KEY", "Environment variable containing encryption key")
 	restoreSingleCmd.Flags().BoolVar(&restoreDiagnose, "diagnose", false, "Run deep diagnosis before restore to detect corruption/truncation")
@@ -347,6 +352,8 @@ func init() {
 	restoreClusterCmd.Flags().StringVar(&restoreWorkdir, "workdir", "", "Working directory for extraction (use when system disk is small, e.g. /mnt/storage/restore_tmp)")
 	restoreClusterCmd.Flags().BoolVar(&restoreVerbose, "verbose", false, "Show detailed restore progress")
 	restoreClusterCmd.Flags().BoolVar(&restoreNoProgress, "no-progress", false, "Disable progress indicators")
+	restoreClusterCmd.Flags().BoolVar(&restoreNoTUI, "no-tui", false, "Disable TUI for maximum performance (benchmark mode)")
+	restoreClusterCmd.Flags().BoolVar(&restoreQuiet, "quiet", false, "Suppress all output except errors")
 	restoreClusterCmd.Flags().StringVar(&restoreEncryptionKeyFile, "encryption-key-file", "", "Path to encryption key file (required for encrypted backups)")
 	restoreClusterCmd.Flags().StringVar(&restoreEncryptionKeyEnv, "encryption-key-env", "DBBACKUP_ENCRYPTION_KEY", "Environment variable containing encryption key")
 	restoreClusterCmd.Flags().BoolVar(&restoreDiagnose, "diagnose", false, "Run deep diagnosis on all dumps before restore")
@@ -713,6 +720,23 @@ func runRestoreSingle(cmd *cobra.Command, args []string) error {
 			WithDetail("archive", filepath.Base(archivePath)))
 	}
 
+	// Check if native engine should be used for restore
+	if cfg.UseNativeEngine {
+		log.Info("Using native engine for restore", "database", targetDB)
+		err = runNativeRestore(ctx, db, archivePath, targetDB, restoreClean, restoreCreate, startTime, user)
+
+		if err != nil && cfg.FallbackToTools {
+			log.Warn("Native engine restore failed, falling back to external tools", "error", err)
+			// Continue with tool-based restore below
+		} else {
+			// Native engine succeeded or no fallback configured
+			if err == nil {
+				log.Info("[OK] Restore completed successfully (native engine)", "database", targetDB)
+			}
+			return err
+		}
+	}
+
 	if err := engine.RestoreSingle(ctx, archivePath, targetDB, restoreClean, restoreCreate); err != nil {
 		auditLogger.LogRestoreFailed(user, targetDB, err)
 		// Notify: restore failed

docs/RESTORE_PERFORMANCE.md

@@ -0,0 +1,247 @@
+# Restore Performance Optimization Guide
+
+## Quick Start: Fastest Restore Command
+
+```bash
+# For single database (matches pg_restore -j8 speed)
+dbbackup restore single backup.dump.gz \
+  --confirm \
+  --profile turbo \
+  --jobs 8
+
+# For cluster restore (maximum speed)
+dbbackup restore cluster backup.tar.gz \
+  --confirm \
+  --profile max-performance \
+  --jobs 16 \
+  --parallel-dbs 8 \
+  --no-tui \
+  --quiet
+```
+
+## Performance Profiles
+
+| Profile | Jobs | Parallel DBs | Best For |
+|---------|------|--------------|----------|
+| `conservative` | 1 | 1 | Resource-constrained servers, production with other services |
+| `balanced` | auto | auto | Default, most scenarios |
+| `turbo` | 8 | 4 | Fast restores, matches `pg_restore -j8` |
+| `max-performance` | 16 | 8 | Dedicated restore operations, benchmarking |
+
+## New Performance Flags (v5.4.0+)
+
+### `--no-tui`
+Disables the Terminal User Interface completely for maximum performance.
+Use this for scripted/automated restores where visual progress isn't needed.
+
+```bash
+dbbackup restore single backup.dump.gz --confirm --no-tui
+```
+
+### `--quiet`
+Suppresses all output except errors. Combine with `--no-tui` for minimal overhead.
+
+```bash
+dbbackup restore single backup.dump.gz --confirm --no-tui --quiet
+```
+
+### `--jobs N`
+Sets the number of parallel pg_restore workers. Equivalent to `pg_restore -jN`.
+
+```bash
+# 8 parallel restore workers
+dbbackup restore single backup.dump.gz --confirm --jobs 8
+```
+
+### `--parallel-dbs N`
+For cluster restores only. Sets how many databases to restore simultaneously.
+
+```bash
+# 4 databases restored in parallel, each with 8 jobs
+dbbackup restore cluster backup.tar.gz --confirm --parallel-dbs 4 --jobs 8
+```
+
+## Benchmarking Your Restore Performance
+
+Use the included benchmark script to identify bottlenecks:
+
+```bash
+./scripts/benchmark_restore.sh backup.dump.gz test_database
+```
+
+This will test:
+1. `dbbackup` with TUI (default)
+2. `dbbackup` without TUI (`--no-tui --quiet`)
+3. `dbbackup` max performance profile
+4. Native `pg_restore -j8` baseline
+
+## Expected Performance
+
+With optimal settings, `dbbackup restore` should match native `pg_restore -j8`:
+
+| Database Size | pg_restore -j8 | dbbackup turbo |
+|---------------|----------------|----------------|
+| 1 GB | ~2 min | ~2 min |
+| 10 GB | ~15 min | ~15-17 min |
+| 100 GB | ~2.5 hr | ~2.5-3 hr |
+| 500 GB | ~12 hr | ~12-13 hr |
+
+If `dbbackup` is significantly slower (>2x), check:
+1. TUI overhead: Test with `--no-tui --quiet`
+2. Profile setting: Use `--profile turbo` or `--profile max-performance`
+3. PostgreSQL config: See optimization section below
+
+## PostgreSQL Configuration for Bulk Restore
+
+Add these settings to `postgresql.conf` for faster restores:
+
+```ini
+# Memory
+maintenance_work_mem = 2GB        # Faster index builds
+work_mem = 256MB                  # Faster sorts
+
+# WAL
+max_wal_size = 10GB               # Less frequent checkpoints
+checkpoint_timeout = 30min        # Less frequent checkpoints
+wal_buffers = 64MB                # Larger WAL buffer
+
+# For restore operations only (revert after!)
+synchronous_commit = off          # Async commits (safe for restore)
+full_page_writes = off            # Skip for bulk load
+autovacuum = off                  # Skip during restore
+```
+
+Or apply temporarily via session:
+```sql
+SET maintenance_work_mem = '2GB';
+SET work_mem = '256MB';
+SET synchronous_commit = off;
+```
+
+## Troubleshooting Slow Restores
+
+### Symptom: 3x slower than pg_restore
+
+**Likely causes:**
+1. Using `conservative` profile (default for cluster restores)
+2. Large objects detected, forcing sequential mode
+3. TUI refresh causing overhead
+
+**Fix:**
+```bash
+# Force turbo profile with explicit parallelism
+dbbackup restore cluster backup.tar.gz \
+  --confirm \
+  --profile turbo \
+  --jobs 8 \
+  --parallel-dbs 4 \
+  --no-tui
+```
+
+### Symptom: Lock exhaustion errors
+
+Error: `out of shared memory` or `max_locks_per_transaction`
+
+**Fix:**
+```sql
+-- Increase lock limit (requires restart)
+ALTER SYSTEM SET max_locks_per_transaction = 4096;
+SELECT pg_reload_conf();
+```
+
+### Symptom: High CPU but slow restore
+
+**Likely cause:** Single-threaded restore (jobs=1)
+
+**Check:** Look for `--jobs=1` or `--jobs=0` in logs
+
+**Fix:**
+```bash
+dbbackup restore single backup.dump.gz --confirm --jobs 8
+```
+
+### Symptom: Low CPU but slow restore
+
+**Likely cause:** I/O bottleneck or PostgreSQL waiting on disk
+
+**Check:** 
+```bash
+iostat -x 1    # Check disk utilization
+```
+
+**Fix:**
+- Use SSD storage
+- Increase `wal_buffers` and `max_wal_size`
+- Use `--parallel-dbs 1` to reduce I/O contention
+
+## Architecture: How Restore Works
+
+```
+dbbackup restore
+    │
+    ├── Archive Detection (format, compression)
+    │
+    ├── Pre-flight Checks
+    │   ├── Disk space verification
+    │   ├── PostgreSQL version compatibility
+    │   └── Lock limit checking
+    │
+    ├── Extraction (for cluster backups)
+    │   └── Parallel pgzip decompression
+    │
+    ├── Database Restore (parallel)
+    │   ├── Worker pool (--parallel-dbs)
+    │   └── Each worker runs pg_restore -j (--jobs)
+    │
+    └── Post-restore
+        ├── Index rebuilding (if dropped)
+        └── ANALYZE tables
+```
+
+## TUI vs No-TUI Performance
+
+The TUI adds minimal overhead when using async progress updates (default).
+However, for maximum performance:
+
+| Mode | Tick Rate | Overhead |
+|------|-----------|----------|
+| TUI enabled | 250ms (4Hz) | ~1-3% |
+| `--no-tui` | N/A | 0% |
+| `--no-tui --quiet` | N/A | 0% |
+
+For production batch restores, always use `--no-tui --quiet`.
+
+## Monitoring Restore Progress
+
+### With TUI
+Progress is shown automatically with:
+- Phase indicators (Extracting → Globals → Databases)
+- Per-database progress with timing
+- ETA calculations
+- Speed in MB/s
+
+### Without TUI
+Monitor via PostgreSQL:
+```sql
+-- Check active restore connections
+SELECT count(*), state 
+FROM pg_stat_activity 
+WHERE datname = 'your_database' 
+GROUP BY state;
+
+-- Check current queries
+SELECT pid, now() - query_start as duration, query
+FROM pg_stat_activity
+WHERE datname = 'your_database'
+AND state = 'active'
+ORDER BY duration DESC;
+```
+
+## Best Practices Summary
+
+1. **Use `--profile turbo` for production restores** - matches `pg_restore -j8`
+2. **Use `--no-tui --quiet` for scripted/batch operations** - zero overhead
+3. **Set `--jobs 8`** (or number of cores) for maximum parallelism
+4. **For cluster restores, use `--parallel-dbs 4`** - balances I/O and speed
+5. **Tune PostgreSQL** - `maintenance_work_mem`, `max_wal_size`
+6. **Run benchmark script** - identify your specific bottlenecks

internal/backup/engine.go

@@ -3,14 +3,12 @@ package backup
 import (
 	"archive/tar"
 	"bufio"
-	"compress/gzip"
 	"context"
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
 	"io"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strconv"
@@ -20,6 +18,7 @@ import (
 	"time"
 
 	"dbbackup/internal/checks"
+	"dbbackup/internal/cleanup"
 	"dbbackup/internal/cloud"
 	"dbbackup/internal/config"
 	"dbbackup/internal/database"
@@ -651,7 +650,7 @@ func (e *Engine) executeCommandWithProgress(ctx context.Context, cmdArgs []strin
 
 	e.log.Debug("Executing backup command with progress", "cmd", cmdArgs[0], "args", cmdArgs[1:])
 
-	cmd := exec.CommandContext(ctx, cmdArgs[0], cmdArgs[1:]...)
+	cmd := cleanup.SafeCommand(ctx, cmdArgs[0], cmdArgs[1:]...)
 
 	// Set environment variables for database tools
 	cmd.Env = os.Environ()
@@ -697,9 +696,9 @@ func (e *Engine) executeCommandWithProgress(ctx context.Context, cmdArgs []strin
 	case cmdErr = <-cmdDone:
 		// Command completed (success or failure)
 	case <-ctx.Done():
-		// Context cancelled - kill process to unblock
-		e.log.Warn("Backup cancelled - killing process")
-		cmd.Process.Kill()
+		// Context cancelled - kill entire process group
+		e.log.Warn("Backup cancelled - killing process group")
+		cleanup.KillCommandGroup(cmd)
 		<-cmdDone // Wait for goroutine to finish
 		cmdErr = ctx.Err()
 	}
@@ -755,7 +754,7 @@ func (e *Engine) monitorCommandProgress(stderr io.ReadCloser, tracker *progress.
 // Uses in-process pgzip for parallel compression (2-4x faster on multi-core systems)
 func (e *Engine) executeMySQLWithProgressAndCompression(ctx context.Context, cmdArgs []string, outputFile string, tracker *progress.OperationTracker) error {
 	// Create mysqldump command
-	dumpCmd := exec.CommandContext(ctx, cmdArgs[0], cmdArgs[1:]...)
+	dumpCmd := cleanup.SafeCommand(ctx, cmdArgs[0], cmdArgs[1:]...)
 	dumpCmd.Env = os.Environ()
 	if e.cfg.Password != "" {
 		dumpCmd.Env = append(dumpCmd.Env, "MYSQL_PWD="+e.cfg.Password)
@@ -817,8 +816,8 @@ func (e *Engine) executeMySQLWithProgressAndCompression(ctx context.Context, cmd
 	case dumpErr = <-dumpDone:
 		// mysqldump completed
 	case <-ctx.Done():
-		e.log.Warn("Backup cancelled - killing mysqldump")
-		dumpCmd.Process.Kill()
+		e.log.Warn("Backup cancelled - killing mysqldump process group")
+		cleanup.KillCommandGroup(dumpCmd)
 		<-dumpDone
 		return ctx.Err()
 	}
@@ -847,7 +846,7 @@ func (e *Engine) executeMySQLWithProgressAndCompression(ctx context.Context, cmd
 // Uses in-process pgzip for parallel compression (2-4x faster on multi-core systems)
 func (e *Engine) executeMySQLWithCompression(ctx context.Context, cmdArgs []string, outputFile string) error {
 	// Create mysqldump command
-	dumpCmd := exec.CommandContext(ctx, cmdArgs[0], cmdArgs[1:]...)
+	dumpCmd := cleanup.SafeCommand(ctx, cmdArgs[0], cmdArgs[1:]...)
 	dumpCmd.Env = os.Environ()
 	if e.cfg.Password != "" {
 		dumpCmd.Env = append(dumpCmd.Env, "MYSQL_PWD="+e.cfg.Password)
@@ -896,8 +895,8 @@ func (e *Engine) executeMySQLWithCompression(ctx context.Context, cmdArgs []stri
 	case dumpErr = <-dumpDone:
 		// mysqldump completed
 	case <-ctx.Done():
-		e.log.Warn("Backup cancelled - killing mysqldump")
-		dumpCmd.Process.Kill()
+		e.log.Warn("Backup cancelled - killing mysqldump process group")
+		cleanup.KillCommandGroup(dumpCmd)
 		<-dumpDone
 		return ctx.Err()
 	}
@@ -952,7 +951,7 @@ func (e *Engine) createSampleBackup(ctx context.Context, databaseName, outputFil
 			Format:     "plain",
 		})
 
-		cmd := exec.CommandContext(ctx, schemaCmd[0], schemaCmd[1:]...)
+		cmd := cleanup.SafeCommand(ctx, schemaCmd[0], schemaCmd[1:]...)
 		cmd.Env = os.Environ()
 		if e.cfg.Password != "" {
 			cmd.Env = append(cmd.Env, "PGPASSWORD="+e.cfg.Password)
@@ -991,7 +990,7 @@ func (e *Engine) backupGlobals(ctx context.Context, tempDir string) error {
 	globalsFile := filepath.Join(tempDir, "globals.sql")
 
 	// CRITICAL: Always pass port even for localhost - user may have non-standard port
-	cmd := exec.CommandContext(ctx, "pg_dumpall", "--globals-only",
+	cmd := cleanup.SafeCommand(ctx, "pg_dumpall", "--globals-only",
 		"-p", fmt.Sprintf("%d", e.cfg.Port),
 		"-U", e.cfg.User)
 
@@ -1035,8 +1034,8 @@ func (e *Engine) backupGlobals(ctx context.Context, tempDir string) error {
 	case cmdErr = <-cmdDone:
 		// Command completed normally
 	case <-ctx.Done():
-		e.log.Warn("Globals backup cancelled - killing pg_dumpall")
-		cmd.Process.Kill()
+		e.log.Warn("Globals backup cancelled - killing pg_dumpall process group")
+		cleanup.KillCommandGroup(cmd)
 		<-cmdDone
 		return ctx.Err()
 	}
@@ -1272,7 +1271,7 @@ func (e *Engine) verifyClusterArchive(ctx context.Context, archivePath string) e
 	}
 
 	// Verify tar.gz structure by reading header
-	gzipReader, err := gzip.NewReader(file)
+	gzipReader, err := pgzip.NewReader(file)
 	if err != nil {
 		return fmt.Errorf("invalid gzip format: %w", err)
 	}
@@ -1431,7 +1430,7 @@ func (e *Engine) executeCommand(ctx context.Context, cmdArgs []string, outputFil
 
 	// For custom format, pg_dump handles everything (writes directly to file)
 	// NO GO BUFFERING - pg_dump writes directly to disk
-	cmd := exec.CommandContext(ctx, cmdArgs[0], cmdArgs[1:]...)
+	cmd := cleanup.SafeCommand(ctx, cmdArgs[0], cmdArgs[1:]...)
 
 	// Start heartbeat ticker for backup progress
 	backupStart := time.Now()
@@ -1500,9 +1499,9 @@ func (e *Engine) executeCommand(ctx context.Context, cmdArgs []string, outputFil
 	case cmdErr = <-cmdDone:
 		// Command completed (success or failure)
 	case <-ctx.Done():
-		// Context cancelled - kill process to unblock
-		e.log.Warn("Backup cancelled - killing pg_dump process")
-		cmd.Process.Kill()
+		// Context cancelled - kill entire process group
+		e.log.Warn("Backup cancelled - killing pg_dump process group")
+		cleanup.KillCommandGroup(cmd)
 		<-cmdDone // Wait for goroutine to finish
 		cmdErr = ctx.Err()
 	}
@@ -1537,7 +1536,7 @@ func (e *Engine) executeWithStreamingCompression(ctx context.Context, cmdArgs []
 	}
 
 	// Create pg_dump command
-	dumpCmd := exec.CommandContext(ctx, cmdArgs[0], cmdArgs[1:]...)
+	dumpCmd := cleanup.SafeCommand(ctx, cmdArgs[0], cmdArgs[1:]...)
 	dumpCmd.Env = os.Environ()
 	if e.cfg.Password != "" && e.cfg.IsPostgreSQL() {
 		dumpCmd.Env = append(dumpCmd.Env, "PGPASSWORD="+e.cfg.Password)
@@ -1613,9 +1612,9 @@ func (e *Engine) executeWithStreamingCompression(ctx context.Context, cmdArgs []
 	case dumpErr = <-dumpDone:
 		// pg_dump completed (success or failure)
 	case <-ctx.Done():
-		// Context cancelled/timeout - kill pg_dump to unblock
-		e.log.Warn("Backup timeout - killing pg_dump process")
-		dumpCmd.Process.Kill()
+		// Context cancelled/timeout - kill pg_dump process group
+		e.log.Warn("Backup timeout - killing pg_dump process group")
+		cleanup.KillCommandGroup(dumpCmd)
 		<-dumpDone // Wait for goroutine to finish
 		dumpErr = ctx.Err()
 	}

internal/cleanup/command.go

@@ -0,0 +1,154 @@
+//go:build !windows
+// +build !windows
+
+package cleanup
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"syscall"
+	"time"
+
+	"dbbackup/internal/logger"
+)
+
+// SafeCommand creates an exec.Cmd with proper process group setup for clean termination.
+// This ensures that child processes (e.g., from pipelines) are killed when the parent is killed.
+func SafeCommand(ctx context.Context, name string, args ...string) *exec.Cmd {
+	cmd := exec.CommandContext(ctx, name, args...)
+
+	// Set up process group for clean termination
+	// This allows killing the entire process tree when cancelled
+	cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setpgid: true, // Create new process group
+		Pgid:    0,    // Use the new process's PID as the PGID
+	}
+
+	return cmd
+}
+
+// TrackedCommand creates a command that is tracked for cleanup on shutdown.
+// When the handler shuts down, this command will be killed if still running.
+type TrackedCommand struct {
+	*exec.Cmd
+	log  logger.Logger
+	name string
+}
+
+// NewTrackedCommand creates a tracked command
+func NewTrackedCommand(ctx context.Context, log logger.Logger, name string, args ...string) *TrackedCommand {
+	tc := &TrackedCommand{
+		Cmd:  SafeCommand(ctx, name, args...),
+		log:  log,
+		name: name,
+	}
+	return tc
+}
+
+// StartWithCleanup starts the command and registers cleanup with the handler
+func (tc *TrackedCommand) StartWithCleanup(h *Handler) error {
+	if err := tc.Cmd.Start(); err != nil {
+		return err
+	}
+
+	// Register cleanup function
+	pid := tc.Cmd.Process.Pid
+	h.RegisterCleanup(fmt.Sprintf("kill-%s-%d", tc.name, pid), func(ctx context.Context) error {
+		return tc.Kill()
+	})
+
+	return nil
+}
+
+// Kill terminates the command and its process group
+func (tc *TrackedCommand) Kill() error {
+	if tc.Cmd.Process == nil {
+		return nil // Not started or already cleaned up
+	}
+
+	pid := tc.Cmd.Process.Pid
+
+	// Get the process group ID
+	pgid, err := syscall.Getpgid(pid)
+	if err != nil {
+		// Process might already be gone
+		return nil
+	}
+
+	tc.log.Debug("Terminating process", "name", tc.name, "pid", pid, "pgid", pgid)
+
+	// Try graceful shutdown first (SIGTERM to process group)
+	if err := syscall.Kill(-pgid, syscall.SIGTERM); err != nil {
+		tc.log.Debug("SIGTERM failed, trying SIGKILL", "error", err)
+	}
+
+	// Wait briefly for graceful shutdown
+	done := make(chan error, 1)
+	go func() {
+		_, err := tc.Cmd.Process.Wait()
+		done <- err
+	}()
+
+	select {
+	case <-time.After(3 * time.Second):
+		// Force kill after timeout
+		tc.log.Debug("Process didn't stop gracefully, sending SIGKILL", "name", tc.name, "pid", pid)
+		if err := syscall.Kill(-pgid, syscall.SIGKILL); err != nil {
+			tc.log.Debug("SIGKILL failed", "error", err)
+		}
+		<-done // Wait for Wait() to finish
+
+	case <-done:
+		// Process exited
+	}
+
+	tc.log.Debug("Process terminated", "name", tc.name, "pid", pid)
+	return nil
+}
+
+// WaitWithContext waits for the command to complete, handling context cancellation properly.
+// This is the recommended way to wait for commands, as it ensures proper cleanup on cancellation.
+func WaitWithContext(ctx context.Context, cmd *exec.Cmd, log logger.Logger) error {
+	if cmd.Process == nil {
+		return fmt.Errorf("process not started")
+	}
+
+	// Wait for command in a goroutine
+	cmdDone := make(chan error, 1)
+	go func() {
+		cmdDone <- cmd.Wait()
+	}()
+
+	select {
+	case err := <-cmdDone:
+		return err
+
+	case <-ctx.Done():
+		// Context cancelled - kill process group
+		log.Debug("Context cancelled, terminating process", "pid", cmd.Process.Pid)
+
+		// Get process group and kill entire group
+		pgid, err := syscall.Getpgid(cmd.Process.Pid)
+		if err == nil {
+			// Kill process group
+			syscall.Kill(-pgid, syscall.SIGTERM)
+
+			// Wait briefly for graceful shutdown
+			select {
+			case <-cmdDone:
+				// Process exited
+			case <-time.After(2 * time.Second):
+				// Force kill
+				syscall.Kill(-pgid, syscall.SIGKILL)
+				<-cmdDone
+			}
+		} else {
+			// Fallback to killing just the process
+			cmd.Process.Kill()
+			<-cmdDone
+		}
+
+		return ctx.Err()
+	}
+}

internal/cleanup/command_windows.go

@@ -0,0 +1,99 @@
+//go:build windows
+// +build windows
+
+package cleanup
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"time"
+
+	"dbbackup/internal/logger"
+)
+
+// SafeCommand creates an exec.Cmd with proper setup for clean termination on Windows.
+func SafeCommand(ctx context.Context, name string, args ...string) *exec.Cmd {
+	cmd := exec.CommandContext(ctx, name, args...)
+	// Windows doesn't use process groups the same way as Unix
+	// exec.CommandContext will handle termination via the context
+	return cmd
+}
+
+// TrackedCommand creates a command that is tracked for cleanup on shutdown.
+type TrackedCommand struct {
+	*exec.Cmd
+	log  logger.Logger
+	name string
+}
+
+// NewTrackedCommand creates a tracked command
+func NewTrackedCommand(ctx context.Context, log logger.Logger, name string, args ...string) *TrackedCommand {
+	tc := &TrackedCommand{
+		Cmd:  SafeCommand(ctx, name, args...),
+		log:  log,
+		name: name,
+	}
+	return tc
+}
+
+// StartWithCleanup starts the command and registers cleanup with the handler
+func (tc *TrackedCommand) StartWithCleanup(h *Handler) error {
+	if err := tc.Cmd.Start(); err != nil {
+		return err
+	}
+
+	// Register cleanup function
+	pid := tc.Cmd.Process.Pid
+	h.RegisterCleanup(fmt.Sprintf("kill-%s-%d", tc.name, pid), func(ctx context.Context) error {
+		return tc.Kill()
+	})
+
+	return nil
+}
+
+// Kill terminates the command on Windows
+func (tc *TrackedCommand) Kill() error {
+	if tc.Cmd.Process == nil {
+		return nil
+	}
+
+	tc.log.Debug("Terminating process", "name", tc.name, "pid", tc.Cmd.Process.Pid)
+
+	if err := tc.Cmd.Process.Kill(); err != nil {
+		tc.log.Debug("Kill failed", "error", err)
+		return err
+	}
+
+	tc.log.Debug("Process terminated", "name", tc.name, "pid", tc.Cmd.Process.Pid)
+	return nil
+}
+
+// WaitWithContext waits for the command to complete, handling context cancellation properly.
+func WaitWithContext(ctx context.Context, cmd *exec.Cmd, log logger.Logger) error {
+	if cmd.Process == nil {
+		return fmt.Errorf("process not started")
+	}
+
+	cmdDone := make(chan error, 1)
+	go func() {
+		cmdDone <- cmd.Wait()
+	}()
+
+	select {
+	case err := <-cmdDone:
+		return err
+
+	case <-ctx.Done():
+		log.Debug("Context cancelled, terminating process", "pid", cmd.Process.Pid)
+		cmd.Process.Kill()
+
+		select {
+		case <-cmdDone:
+		case <-time.After(5 * time.Second):
+			// Already killed, just wait for it
+		}
+
+		return ctx.Err()
+	}
+}

internal/cleanup/handler.go

@@ -0,0 +1,242 @@
+// Package cleanup provides graceful shutdown and resource cleanup functionality
+package cleanup
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+	"time"
+
+	"dbbackup/internal/logger"
+)
+
+// CleanupFunc is a function that performs cleanup with a timeout context
+type CleanupFunc func(ctx context.Context) error
+
+// Handler manages graceful shutdown and resource cleanup
+type Handler struct {
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	cleanupFns []cleanupEntry
+	mu         sync.Mutex
+
+	shutdownTimeout time.Duration
+	log             logger.Logger
+
+	// Track if shutdown has been initiated
+	shutdownOnce sync.Once
+	shutdownDone chan struct{}
+}
+
+type cleanupEntry struct {
+	name string
+	fn   CleanupFunc
+}
+
+// NewHandler creates a shutdown handler
+func NewHandler(log logger.Logger) *Handler {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	h := &Handler{
+		ctx:             ctx,
+		cancel:          cancel,
+		cleanupFns:      make([]cleanupEntry, 0),
+		shutdownTimeout: 30 * time.Second,
+		log:             log,
+		shutdownDone:    make(chan struct{}),
+	}
+
+	return h
+}
+
+// Context returns the shutdown context
+func (h *Handler) Context() context.Context {
+	return h.ctx
+}
+
+// RegisterCleanup adds a named cleanup function
+func (h *Handler) RegisterCleanup(name string, fn CleanupFunc) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	h.cleanupFns = append(h.cleanupFns, cleanupEntry{name: name, fn: fn})
+}
+
+// SetShutdownTimeout sets the maximum time to wait for cleanup
+func (h *Handler) SetShutdownTimeout(d time.Duration) {
+	h.shutdownTimeout = d
+}
+
+// Shutdown triggers graceful shutdown
+func (h *Handler) Shutdown() {
+	h.shutdownOnce.Do(func() {
+		h.log.Info("Initiating graceful shutdown...")
+
+		// Cancel context first (stops all ongoing operations)
+		h.cancel()
+
+		// Run cleanup functions
+		h.runCleanup()
+
+		close(h.shutdownDone)
+	})
+}
+
+// ShutdownWithSignal triggers shutdown due to an OS signal
+func (h *Handler) ShutdownWithSignal(sig os.Signal) {
+	h.log.Info("Received signal, initiating graceful shutdown", "signal", sig.String())
+	h.Shutdown()
+}
+
+// Wait blocks until shutdown is complete
+func (h *Handler) Wait() {
+	<-h.shutdownDone
+}
+
+// runCleanup executes all cleanup functions in LIFO order
+func (h *Handler) runCleanup() {
+	h.mu.Lock()
+	fns := make([]cleanupEntry, len(h.cleanupFns))
+	copy(fns, h.cleanupFns)
+	h.mu.Unlock()
+
+	if len(fns) == 0 {
+		h.log.Info("No cleanup functions registered")
+		return
+	}
+
+	h.log.Info("Running cleanup functions", "count", len(fns))
+
+	// Create timeout context for cleanup
+	ctx, cancel := context.WithTimeout(context.Background(), h.shutdownTimeout)
+	defer cancel()
+
+	// Run all cleanups in LIFO order (most recently registered first)
+	var failed int
+	for i := len(fns) - 1; i >= 0; i-- {
+		entry := fns[i]
+
+		h.log.Debug("Running cleanup", "name", entry.name)
+
+		if err := entry.fn(ctx); err != nil {
+			h.log.Warn("Cleanup function failed", "name", entry.name, "error", err)
+			failed++
+		} else {
+			h.log.Debug("Cleanup completed", "name", entry.name)
+		}
+	}
+
+	if failed > 0 {
+		h.log.Warn("Some cleanup functions failed", "failed", failed, "total", len(fns))
+	} else {
+		h.log.Info("All cleanup functions completed successfully")
+	}
+}
+
+// RegisterSignalHandler sets up signal handling for graceful shutdown
+func (h *Handler) RegisterSignalHandler() {
+	sigChan := make(chan os.Signal, 2)
+	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM, syscall.SIGINT)
+
+	go func() {
+		// First signal: graceful shutdown
+		sig := <-sigChan
+		h.ShutdownWithSignal(sig)
+
+		// Second signal: force exit
+		sig = <-sigChan
+		h.log.Warn("Received second signal, forcing exit", "signal", sig.String())
+		os.Exit(1)
+	}()
+}
+
+// ChildProcessCleanup creates a cleanup function for killing child processes
+func (h *Handler) ChildProcessCleanup() CleanupFunc {
+	return func(ctx context.Context) error {
+		h.log.Info("Cleaning up orphaned child processes...")
+
+		if err := KillOrphanedProcesses(h.log); err != nil {
+			h.log.Warn("Failed to kill some orphaned processes", "error", err)
+			return err
+		}
+
+		h.log.Info("Child process cleanup complete")
+		return nil
+	}
+}
+
+// DatabasePoolCleanup creates a cleanup function for database connection pools
+// poolCloser should be a function that closes the pool
+func DatabasePoolCleanup(log logger.Logger, name string, poolCloser func()) CleanupFunc {
+	return func(ctx context.Context) error {
+		log.Debug("Closing database connection pool", "name", name)
+		poolCloser()
+		log.Debug("Database connection pool closed", "name", name)
+		return nil
+	}
+}
+
+// FileCleanup creates a cleanup function for file handles
+func FileCleanup(log logger.Logger, path string, file *os.File) CleanupFunc {
+	return func(ctx context.Context) error {
+		if file == nil {
+			return nil
+		}
+
+		log.Debug("Closing file", "path", path)
+		if err := file.Close(); err != nil {
+			return fmt.Errorf("failed to close file %s: %w", path, err)
+		}
+		return nil
+	}
+}
+
+// TempFileCleanup creates a cleanup function that closes and removes a temp file
+func TempFileCleanup(log logger.Logger, file *os.File) CleanupFunc {
+	return func(ctx context.Context) error {
+		if file == nil {
+			return nil
+		}
+
+		path := file.Name()
+		log.Debug("Removing temporary file", "path", path)
+
+		// Close file first
+		if err := file.Close(); err != nil {
+			log.Warn("Failed to close temp file", "path", path, "error", err)
+		}
+
+		// Remove file
+		if err := os.Remove(path); err != nil {
+			if !os.IsNotExist(err) {
+				return fmt.Errorf("failed to remove temp file %s: %w", path, err)
+			}
+		}
+
+		log.Debug("Temporary file removed", "path", path)
+		return nil
+	}
+}
+
+// TempDirCleanup creates a cleanup function that removes a temp directory
+func TempDirCleanup(log logger.Logger, path string) CleanupFunc {
+	return func(ctx context.Context) error {
+		if path == "" {
+			return nil
+		}
+
+		log.Debug("Removing temporary directory", "path", path)
+
+		if err := os.RemoveAll(path); err != nil {
+			if !os.IsNotExist(err) {
+				return fmt.Errorf("failed to remove temp dir %s: %w", path, err)
+			}
+		}
+
+		log.Debug("Temporary directory removed", "path", path)
+		return nil
+	}
+}

internal/config/profile.go

@@ -37,7 +37,7 @@ func GetRestoreProfile(profileName string) (*RestoreProfile, error) {
 			MemoryConservative: false,
 		}, nil
 
-	case "aggressive", "performance", "max":
+	case "aggressive", "performance":
 		return &RestoreProfile{
 			Name:               "aggressive",
 			ParallelDBs:        -1, // Auto-detect based on resources
@@ -61,19 +61,20 @@ func GetRestoreProfile(profileName string) (*RestoreProfile, error) {
 		// Matches native pg_restore -j8 performance
 		return &RestoreProfile{
 			Name:               "turbo",
-			ParallelDBs:        2, // 2 DBs in parallel (I/O balanced)
+			ParallelDBs:        4, // 4 DBs in parallel (balanced I/O)
 			Jobs:               8, // pg_restore --jobs=8
 			DisableProgress:    false,
 			MemoryConservative: false,
 		}, nil
 
-	case "max-performance":
+	case "max-performance", "maxperformance", "max":
 		// Maximum performance for high-end servers
+		// Use for dedicated restore operations where speed is critical
 		return &RestoreProfile{
 			Name:               "max-performance",
-			ParallelDBs:        4,
-			Jobs:               8,
-			DisableProgress:    false,
+			ParallelDBs:        8,    // 8 DBs in parallel
+			Jobs:               16,   // pg_restore --jobs=16
+			DisableProgress:    true, // Reduce TUI overhead
 			MemoryConservative: false,
 		}, nil
 
@@ -126,13 +127,17 @@ func GetProfileDescription(profileName string) string {
 
 	switch profile.Name {
 	case "conservative":
-		return "Conservative: --parallel=1, single-threaded, minimal memory usage. Best for resource-constrained servers or when other services are running."
+		return "Conservative: --jobs=1, single-threaded, minimal memory usage. Best for resource-constrained servers."
 	case "potato":
 		return "Potato Mode: Same as conservative, for servers running on a potato 🥔"
 	case "balanced":
 		return "Balanced: Auto-detect resources, moderate parallelism. Good default for most scenarios."
 	case "aggressive":
-		return "Aggressive: Maximum parallelism, all available resources. Best for dedicated database servers with ample resources."
+		return "Aggressive: Maximum parallelism, all available resources. Best for dedicated database servers."
+	case "turbo":
+		return "Turbo: --jobs=8, 4 parallel DBs. Matches pg_restore -j8 speed. Great for production restores."
+	case "max-performance":
+		return "Max-Performance: --jobs=16, 8 parallel DBs, TUI disabled. For dedicated restore operations."
 	default:
 		return profile.Name
 	}
@@ -141,9 +146,11 @@ func GetProfileDescription(profileName string) string {
 // ListProfiles returns a list of all available profiles with descriptions
 func ListProfiles() map[string]string {
 	return map[string]string{
-		"conservative": GetProfileDescription("conservative"),
-		"balanced":     GetProfileDescription("balanced"),
-		"aggressive":   GetProfileDescription("aggressive"),
-		"potato":       GetProfileDescription("potato"),
+		"conservative":    GetProfileDescription("conservative"),
+		"balanced":        GetProfileDescription("balanced"),
+		"turbo":           GetProfileDescription("turbo"),
+		"max-performance": GetProfileDescription("max-performance"),
+		"aggressive":      GetProfileDescription("aggressive"),
+		"potato":          GetProfileDescription("potato"),
 	}
 }

internal/restore/diagnose.go

@@ -8,12 +8,12 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"regexp"
 	"strings"
 	"time"
 
+	"dbbackup/internal/cleanup"
 	"dbbackup/internal/fs"
 	"dbbackup/internal/logger"
 
@@ -568,7 +568,7 @@ func (d *Diagnoser) verifyWithPgRestore(filePath string, result *DiagnoseResult)
 	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeoutMinutes)*time.Minute)
 	defer cancel()
 
-	cmd := exec.CommandContext(ctx, "pg_restore", "--list", filePath)
+	cmd := cleanup.SafeCommand(ctx, "pg_restore", "--list", filePath)
 	output, err := cmd.CombinedOutput()
 
 	if err != nil {

internal/restore/engine.go

@@ -17,6 +17,7 @@ import (
 	"time"
 
 	"dbbackup/internal/checks"
+	"dbbackup/internal/cleanup"
 	"dbbackup/internal/config"
 	"dbbackup/internal/database"
 	"dbbackup/internal/fs"
@@ -333,13 +334,14 @@ func (e *Engine) restorePostgreSQLDump(ctx context.Context, archivePath, targetD
 
 	cmd := e.db.BuildRestoreCommand(targetDB, archivePath, opts)
 
-	// Start heartbeat ticker for restore progress
+	// Start heartbeat ticker for restore progress (10s interval to reduce overhead)
 	restoreStart := time.Now()
 	heartbeatCtx, cancelHeartbeat := context.WithCancel(ctx)
-	heartbeatTicker := time.NewTicker(5 * time.Second)
+	heartbeatTicker := time.NewTicker(10 * time.Second)
 	defer heartbeatTicker.Stop()
 	defer cancelHeartbeat()
 
+	// Run heartbeat in background - no mutex needed as progress.Update is thread-safe
 	go func() {
 		for {
 			select {
@@ -498,7 +500,7 @@ func (e *Engine) checkDumpHasLargeObjects(archivePath string) bool {
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
-	cmd := exec.CommandContext(ctx, "pg_restore", "-l", archivePath)
+	cmd := cleanup.SafeCommand(ctx, "pg_restore", "-l", archivePath)
 	output, err := cmd.Output()
 
 	if err != nil {
@@ -591,7 +593,7 @@ func (e *Engine) executeRestoreCommand(ctx context.Context, cmdArgs []string) er
 func (e *Engine) executeRestoreCommandWithContext(ctx context.Context, cmdArgs []string, archivePath, targetDB string, format ArchiveFormat) error {
 	e.log.Info("Executing restore command", "command", strings.Join(cmdArgs, " "))
 
-	cmd := exec.CommandContext(ctx, cmdArgs[0], cmdArgs[1:]...)
+	cmd := cleanup.SafeCommand(ctx, cmdArgs[0], cmdArgs[1:]...)
 
 	// Set environment variables
 	cmd.Env = append(os.Environ(),
@@ -661,9 +663,9 @@ func (e *Engine) executeRestoreCommandWithContext(ctx context.Context, cmdArgs [
 	case cmdErr = <-cmdDone:
 		// Command completed (success or failure)
 	case <-ctx.Done():
-		// Context cancelled - kill process
-		e.log.Warn("Restore cancelled - killing process")
-		cmd.Process.Kill()
+		// Context cancelled - kill entire process group
+		e.log.Warn("Restore cancelled - killing process group")
+		cleanup.KillCommandGroup(cmd)
 		<-cmdDone
 		cmdErr = ctx.Err()
 	}
@@ -771,7 +773,7 @@ func (e *Engine) executeRestoreWithDecompression(ctx context.Context, archivePat
 	defer gz.Close()
 
 	// Start restore command
-	cmd := exec.CommandContext(ctx, restoreCmd[0], restoreCmd[1:]...)
+	cmd := cleanup.SafeCommand(ctx, restoreCmd[0], restoreCmd[1:]...)
 	cmd.Env = append(os.Environ(),
 		fmt.Sprintf("PGPASSWORD=%s", e.cfg.Password),
 		fmt.Sprintf("MYSQL_PWD=%s", e.cfg.Password),
@@ -875,7 +877,7 @@ func (e *Engine) executeRestoreWithPgzipStream(ctx context.Context, archivePath,
 		if e.cfg.Host != "localhost" && e.cfg.Host != "" {
 			args = append([]string{"-h", e.cfg.Host}, args...)
 		}
-		cmd = exec.CommandContext(ctx, "psql", args...)
+		cmd = cleanup.SafeCommand(ctx, "psql", args...)
 		cmd.Env = append(os.Environ(), fmt.Sprintf("PGPASSWORD=%s", e.cfg.Password))
 	} else {
 		// MySQL - use MYSQL_PWD env var to avoid password in process list
@@ -884,7 +886,7 @@ func (e *Engine) executeRestoreWithPgzipStream(ctx context.Context, archivePath,
 			args = append(args, "-h", e.cfg.Host)
 		}
 		args = append(args, "-P", fmt.Sprintf("%d", e.cfg.Port), targetDB)
-		cmd = exec.CommandContext(ctx, "mysql", args...)
+		cmd = cleanup.SafeCommand(ctx, "mysql", args...)
 		// Pass password via environment variable to avoid process list exposure
 		cmd.Env = os.Environ()
 		if e.cfg.Password != "" {
@@ -1321,7 +1323,7 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string, preExtr
 			}
 		} else if strings.HasSuffix(dumpFile, ".dump") {
 			// Validate custom format dumps using pg_restore --list
-			cmd := exec.CommandContext(ctx, "pg_restore", "--list", dumpFile)
+			cmd := cleanup.SafeCommand(ctx, "pg_restore", "--list", dumpFile)
 			output, err := cmd.CombinedOutput()
 			if err != nil {
 				dbName := strings.TrimSuffix(entry.Name(), ".dump")
@@ -1369,7 +1371,7 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string, preExtr
 	if statErr == nil && archiveStats != nil {
 		backupSizeBytes = archiveStats.Size()
 	}
-	memCheck := guard.CheckSystemMemory(backupSizeBytes)
+	memCheck := guard.CheckSystemMemoryWithType(backupSizeBytes, true) // true = cluster archive with pre-compressed dumps
 	if memCheck != nil {
 		if memCheck.Critical {
 			e.log.Error("🚨 CRITICAL MEMORY WARNING", "error", memCheck.Recommendation)
@@ -1688,8 +1690,9 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string, preExtr
 			isCompressedSQL := strings.HasSuffix(dumpFile, ".sql.gz")
 
 			// Start heartbeat ticker to show progress during long-running restore
+			// Use 15s interval to reduce mutex contention during parallel restores
 			heartbeatCtx, cancelHeartbeat := context.WithCancel(ctx)
-			heartbeatTicker := time.NewTicker(5 * time.Second)
+			heartbeatTicker := time.NewTicker(15 * time.Second)
 			go func() {
 				for {
 					select {
@@ -2119,7 +2122,7 @@ func (e *Engine) restoreGlobals(ctx context.Context, globalsFile string) error {
 		args = append([]string{"-h", e.cfg.Host}, args...)
 	}
 
-	cmd := exec.CommandContext(ctx, "psql", args...)
+	cmd := cleanup.SafeCommand(ctx, "psql", args...)
 
 	cmd.Env = append(os.Environ(), fmt.Sprintf("PGPASSWORD=%s", e.cfg.Password))
 
@@ -2181,8 +2184,8 @@ func (e *Engine) restoreGlobals(ctx context.Context, globalsFile string) error {
 	case cmdErr = <-cmdDone:
 		// Command completed
 	case <-ctx.Done():
-		e.log.Warn("Globals restore cancelled - killing process")
-		cmd.Process.Kill()
+		e.log.Warn("Globals restore cancelled - killing process group")
+		cleanup.KillCommandGroup(cmd)
 		<-cmdDone
 		cmdErr = ctx.Err()
 	}
@@ -2223,7 +2226,7 @@ func (e *Engine) checkSuperuser(ctx context.Context) (bool, error) {
 		args = append([]string{"-h", e.cfg.Host}, args...)
 	}
 
-	cmd := exec.CommandContext(ctx, "psql", args...)
+	cmd := cleanup.SafeCommand(ctx, "psql", args...)
 
 	// Always set PGPASSWORD (empty string is fine for peer/ident auth)
 	cmd.Env = append(os.Environ(), fmt.Sprintf("PGPASSWORD=%s", e.cfg.Password))
@@ -2258,7 +2261,7 @@ func (e *Engine) terminateConnections(ctx context.Context, dbName string) error
 		args = append([]string{"-h", e.cfg.Host}, args...)
 	}
 
-	cmd := exec.CommandContext(ctx, "psql", args...)
+	cmd := cleanup.SafeCommand(ctx, "psql", args...)
 
 	// Always set PGPASSWORD (empty string is fine for peer/ident auth)
 	cmd.Env = append(os.Environ(), fmt.Sprintf("PGPASSWORD=%s", e.cfg.Password))
@@ -2294,7 +2297,7 @@ func (e *Engine) dropDatabaseIfExists(ctx context.Context, dbName string) error
 	if e.cfg.Host != "localhost" && e.cfg.Host != "127.0.0.1" && e.cfg.Host != "" {
 		revokeArgs = append([]string{"-h", e.cfg.Host}, revokeArgs...)
 	}
-	revokeCmd := exec.CommandContext(ctx, "psql", revokeArgs...)
+	revokeCmd := cleanup.SafeCommand(ctx, "psql", revokeArgs...)
 	revokeCmd.Env = append(os.Environ(), fmt.Sprintf("PGPASSWORD=%s", e.cfg.Password))
 	revokeCmd.Run() // Ignore errors - database might not exist
 
@@ -2313,7 +2316,7 @@ func (e *Engine) dropDatabaseIfExists(ctx context.Context, dbName string) error
 	if e.cfg.Host != "localhost" && e.cfg.Host != "127.0.0.1" && e.cfg.Host != "" {
 		forceArgs = append([]string{"-h", e.cfg.Host}, forceArgs...)
 	}
-	forceCmd := exec.CommandContext(ctx, "psql", forceArgs...)
+	forceCmd := cleanup.SafeCommand(ctx, "psql", forceArgs...)
 	forceCmd.Env = append(os.Environ(), fmt.Sprintf("PGPASSWORD=%s", e.cfg.Password))
 
 	output, err := forceCmd.CombinedOutput()
@@ -2336,7 +2339,7 @@ func (e *Engine) dropDatabaseIfExists(ctx context.Context, dbName string) error
 			args = append([]string{"-h", e.cfg.Host}, args...)
 		}
 
-		cmd := exec.CommandContext(ctx, "psql", args...)
+		cmd := cleanup.SafeCommand(ctx, "psql", args...)
 		cmd.Env = append(os.Environ(), fmt.Sprintf("PGPASSWORD=%s", e.cfg.Password))
 
 		output, err = cmd.CombinedOutput()
@@ -2370,7 +2373,7 @@ func (e *Engine) ensureMySQLDatabaseExists(ctx context.Context, dbName string) e
 		"-e", fmt.Sprintf("CREATE DATABASE IF NOT EXISTS `%s`", dbName),
 	}
 
-	cmd := exec.CommandContext(ctx, "mysql", args...)
+	cmd := cleanup.SafeCommand(ctx, "mysql", args...)
 	cmd.Env = os.Environ()
 	if e.cfg.Password != "" {
 		cmd.Env = append(cmd.Env, "MYSQL_PWD="+e.cfg.Password)
@@ -2408,7 +2411,7 @@ func (e *Engine) ensurePostgresDatabaseExists(ctx context.Context, dbName string
 			args = append([]string{"-h", e.cfg.Host}, args...)
 		}
 
-		cmd := exec.CommandContext(ctx, "psql", args...)
+		cmd := cleanup.SafeCommand(ctx, "psql", args...)
 
 		// Always set PGPASSWORD (empty string is fine for peer/ident auth)
 		cmd.Env = append(os.Environ(), fmt.Sprintf("PGPASSWORD=%s", e.cfg.Password))
@@ -2465,7 +2468,7 @@ func (e *Engine) ensurePostgresDatabaseExists(ctx context.Context, dbName string
 		createArgs = append([]string{"-h", e.cfg.Host}, createArgs...)
 	}
 
-	createCmd := exec.CommandContext(ctx, "psql", createArgs...)
+	createCmd := cleanup.SafeCommand(ctx, "psql", createArgs...)
 
 	// Always set PGPASSWORD (empty string is fine for peer/ident auth)
 	createCmd.Env = append(os.Environ(), fmt.Sprintf("PGPASSWORD=%s", e.cfg.Password))
@@ -2485,7 +2488,7 @@ func (e *Engine) ensurePostgresDatabaseExists(ctx context.Context, dbName string
 			simpleArgs = append([]string{"-h", e.cfg.Host}, simpleArgs...)
 		}
 
-		simpleCmd := exec.CommandContext(ctx, "psql", simpleArgs...)
+		simpleCmd := cleanup.SafeCommand(ctx, "psql", simpleArgs...)
 		simpleCmd.Env = append(os.Environ(), fmt.Sprintf("PGPASSWORD=%s", e.cfg.Password))
 
 		output, err = simpleCmd.CombinedOutput()
@@ -2550,7 +2553,7 @@ func (e *Engine) detectLargeObjectsInDumps(dumpsDir string, entries []os.DirEntr
 		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
 		defer cancel()
 
-		cmd := exec.CommandContext(ctx, "pg_restore", "-l", dumpFile)
+		cmd := cleanup.SafeCommand(ctx, "pg_restore", "-l", dumpFile)
 		output, err := cmd.Output()
 
 		if err != nil {
@@ -2874,7 +2877,7 @@ func (e *Engine) canRestartPostgreSQL() bool {
 		// Try a quick sudo check - if this fails, we can't restart
 		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
 		defer cancel()
-		cmd := exec.CommandContext(ctx, "sudo", "-n", "true")
+		cmd := cleanup.SafeCommand(ctx, "sudo", "-n", "true")
 		cmd.Stdin = nil
 		if err := cmd.Run(); err != nil {
 			e.log.Info("Running as postgres user without sudo access - cannot restart PostgreSQL",
@@ -2904,7 +2907,7 @@ func (e *Engine) tryRestartPostgreSQL(ctx context.Context) bool {
 	runWithTimeout := func(args ...string) bool {
 		cmdCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
-		cmd := exec.CommandContext(cmdCtx, args[0], args[1:]...)
+		cmd := cleanup.SafeCommand(cmdCtx, args[0], args[1:]...)
 		// Set stdin to /dev/null to prevent sudo from waiting for password
 		cmd.Stdin = nil
 		return cmd.Run() == nil

internal/restore/error_report.go

@@ -7,12 +7,12 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"time"
 
+	"dbbackup/internal/cleanup"
 	"dbbackup/internal/config"
 	"dbbackup/internal/logger"
 
@@ -568,7 +568,7 @@ func getCommandVersion(cmd string, arg string) string {
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
-	output, err := exec.CommandContext(ctx, cmd, arg).CombinedOutput()
+	output, err := cleanup.SafeCommand(ctx, cmd, arg).CombinedOutput()
 	if err != nil {
 		return ""
 	}

internal/restore/fast_restore.go

@@ -0,0 +1,314 @@
+// Package restore provides database restore functionality
+// fast_restore.go implements high-performance restore optimizations
+package restore
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"dbbackup/internal/cleanup"
+	"dbbackup/internal/config"
+	"dbbackup/internal/logger"
+)
+
+// FastRestoreConfig contains performance-tuning options for high-speed restore
+type FastRestoreConfig struct {
+	// ParallelJobs is the number of parallel pg_restore workers (-j flag)
+	// Equivalent to pg_restore -j8
+	ParallelJobs int
+
+	// ParallelDBs is the number of databases to restore concurrently
+	// For cluster restores only
+	ParallelDBs int
+
+	// DisableTUI disables all TUI updates for maximum performance
+	DisableTUI bool
+
+	// QuietMode suppresses all output except errors
+	QuietMode bool
+
+	// DropIndexes drops non-PK indexes before restore, rebuilds after
+	DropIndexes bool
+
+	// DisableTriggers disables triggers during restore
+	DisableTriggers bool
+
+	// OptimizePostgreSQL applies session-level optimizations
+	OptimizePostgreSQL bool
+
+	// AsyncProgress uses non-blocking progress updates
+	AsyncProgress bool
+
+	// ProgressInterval is the minimum time between progress updates
+	// Higher values = less overhead, default 250ms
+	ProgressInterval time.Duration
+}
+
+// DefaultFastRestoreConfig returns optimal settings for fast restore
+func DefaultFastRestoreConfig() *FastRestoreConfig {
+	return &FastRestoreConfig{
+		ParallelJobs:       8,                      // Match pg_restore -j8
+		ParallelDBs:        4,                      // 4 databases at once
+		DisableTUI:         false,                  // TUI enabled by default
+		QuietMode:          false,                  // Show progress
+		DropIndexes:        false,                  // Risky, opt-in only
+		DisableTriggers:    false,                  // Risky, opt-in only
+		OptimizePostgreSQL: true,                   // Safe optimizations
+		AsyncProgress:      true,                   // Non-blocking updates
+		ProgressInterval:   250 * time.Millisecond, // 4Hz max
+	}
+}
+
+// TurboRestoreConfig returns maximum performance settings
+// Use for dedicated restore scenarios where speed is critical
+func TurboRestoreConfig() *FastRestoreConfig {
+	return &FastRestoreConfig{
+		ParallelJobs:       8,                      // Match pg_restore -j8
+		ParallelDBs:        8,                      // 8 databases at once
+		DisableTUI:         false,                  // TUI still useful
+		QuietMode:          false,                  // Show progress
+		DropIndexes:        false,                  // Too risky for auto
+		DisableTriggers:    false,                  // Too risky for auto
+		OptimizePostgreSQL: true,                   // Safe optimizations
+		AsyncProgress:      true,                   // Non-blocking updates
+		ProgressInterval:   500 * time.Millisecond, // 2Hz for less overhead
+	}
+}
+
+// MaxPerformanceConfig returns settings that prioritize speed over safety
+// WARNING: Only use when you can afford a restart if something fails
+func MaxPerformanceConfig() *FastRestoreConfig {
+	return &FastRestoreConfig{
+		ParallelJobs:       16,              // Maximum parallelism
+		ParallelDBs:        16,              // Maximum concurrency
+		DisableTUI:         true,            // No TUI overhead
+		QuietMode:          true,            // Minimal output
+		DropIndexes:        true,            // Drop/rebuild for speed
+		DisableTriggers:    true,            // Skip trigger overhead
+		OptimizePostgreSQL: true,            // All optimizations
+		AsyncProgress:      true,            // Non-blocking
+		ProgressInterval:   1 * time.Second, // Minimal updates
+	}
+}
+
+// PostgreSQLSessionOptimizations are session-level settings that speed up bulk loading
+var PostgreSQLSessionOptimizations = []string{
+	"SET maintenance_work_mem = '1GB'", // Faster index builds
+	"SET work_mem = '256MB'",           // Faster sorts and hashes
+	"SET synchronous_commit = 'off'",   // Async commits (safe for restore)
+	"SET wal_level = 'minimal'",        // Minimal WAL (if possible)
+	"SET max_wal_size = '10GB'",        // Reduce checkpoint frequency
+	"SET checkpoint_timeout = '30min'", // Less frequent checkpoints
+	"SET autovacuum = 'off'",           // Skip autovacuum during restore
+	"SET full_page_writes = 'off'",     // Skip for bulk load
+	"SET wal_buffers = '64MB'",         // Larger WAL buffer
+}
+
+// ApplySessionOptimizations applies PostgreSQL session optimizations for bulk loading
+func ApplySessionOptimizations(ctx context.Context, cfg *config.Config, log logger.Logger) error {
+	// Build psql command to apply settings
+	args := []string{"-p", fmt.Sprintf("%d", cfg.Port), "-U", cfg.User}
+	if cfg.Host != "localhost" && cfg.Host != "" {
+		args = append([]string{"-h", cfg.Host}, args...)
+	}
+
+	// Only apply settings that don't require superuser or server restart
+	safeOptimizations := []string{
+		"SET maintenance_work_mem = '1GB'",
+		"SET work_mem = '256MB'",
+		"SET synchronous_commit = 'off'",
+	}
+
+	for _, sql := range safeOptimizations {
+		cmdArgs := append(args, "-c", sql)
+		cmd := cleanup.SafeCommand(ctx, "psql", cmdArgs...)
+		cmd.Env = append(cmd.Environ(), fmt.Sprintf("PGPASSWORD=%s", cfg.Password))
+
+		if err := cmd.Run(); err != nil {
+			log.Debug("Could not apply optimization (may require superuser)", "sql", sql, "error", err)
+			// Continue - these are optional optimizations
+		} else {
+			log.Debug("Applied optimization", "sql", sql)
+		}
+	}
+
+	return nil
+}
+
+// AsyncProgressReporter provides non-blocking progress updates
+type AsyncProgressReporter struct {
+	mu          sync.RWMutex
+	lastUpdate  time.Time
+	minInterval time.Duration
+	bytesTotal  int64
+	bytesDone   int64
+	dbsTotal    int
+	dbsDone     int
+	currentDB   string
+	callbacks   []func(bytesDone, bytesTotal int64, dbsDone, dbsTotal int, currentDB string)
+	updateChan  chan struct{}
+	stopChan    chan struct{}
+	stopped     bool
+}
+
+// NewAsyncProgressReporter creates a new async progress reporter
+func NewAsyncProgressReporter(minInterval time.Duration) *AsyncProgressReporter {
+	apr := &AsyncProgressReporter{
+		minInterval: minInterval,
+		updateChan:  make(chan struct{}, 100), // Buffered to avoid blocking
+		stopChan:    make(chan struct{}),
+	}
+
+	// Start background updater
+	go apr.backgroundUpdater()
+
+	return apr
+}
+
+// backgroundUpdater runs in background and throttles updates
+func (apr *AsyncProgressReporter) backgroundUpdater() {
+	ticker := time.NewTicker(apr.minInterval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-apr.stopChan:
+			return
+		case <-ticker.C:
+			apr.flushUpdate()
+		case <-apr.updateChan:
+			// Drain channel, actual update happens on ticker
+			for len(apr.updateChan) > 0 {
+				<-apr.updateChan
+			}
+		}
+	}
+}
+
+// flushUpdate sends update to all callbacks
+func (apr *AsyncProgressReporter) flushUpdate() {
+	apr.mu.RLock()
+	bytesDone := apr.bytesDone
+	bytesTotal := apr.bytesTotal
+	dbsDone := apr.dbsDone
+	dbsTotal := apr.dbsTotal
+	currentDB := apr.currentDB
+	callbacks := apr.callbacks
+	apr.mu.RUnlock()
+
+	for _, cb := range callbacks {
+		cb(bytesDone, bytesTotal, dbsDone, dbsTotal, currentDB)
+	}
+}
+
+// UpdateBytes updates byte progress (non-blocking)
+func (apr *AsyncProgressReporter) UpdateBytes(done, total int64) {
+	apr.mu.Lock()
+	apr.bytesDone = done
+	apr.bytesTotal = total
+	apr.mu.Unlock()
+
+	// Non-blocking send
+	select {
+	case apr.updateChan <- struct{}{}:
+	default:
+	}
+}
+
+// UpdateDatabases updates database progress (non-blocking)
+func (apr *AsyncProgressReporter) UpdateDatabases(done, total int, current string) {
+	apr.mu.Lock()
+	apr.dbsDone = done
+	apr.dbsTotal = total
+	apr.currentDB = current
+	apr.mu.Unlock()
+
+	// Non-blocking send
+	select {
+	case apr.updateChan <- struct{}{}:
+	default:
+	}
+}
+
+// OnProgress registers a callback for progress updates
+func (apr *AsyncProgressReporter) OnProgress(cb func(bytesDone, bytesTotal int64, dbsDone, dbsTotal int, currentDB string)) {
+	apr.mu.Lock()
+	apr.callbacks = append(apr.callbacks, cb)
+	apr.mu.Unlock()
+}
+
+// Stop stops the background updater
+func (apr *AsyncProgressReporter) Stop() {
+	apr.mu.Lock()
+	if !apr.stopped {
+		apr.stopped = true
+		close(apr.stopChan)
+	}
+	apr.mu.Unlock()
+}
+
+// GetProfileForRestore returns the appropriate FastRestoreConfig based on profile name
+func GetProfileForRestore(profileName string) *FastRestoreConfig {
+	switch strings.ToLower(profileName) {
+	case "turbo":
+		return TurboRestoreConfig()
+	case "max-performance", "maxperformance", "max":
+		return MaxPerformanceConfig()
+	case "balanced":
+		return DefaultFastRestoreConfig()
+	case "conservative":
+		cfg := DefaultFastRestoreConfig()
+		cfg.ParallelJobs = 2
+		cfg.ParallelDBs = 1
+		cfg.ProgressInterval = 100 * time.Millisecond
+		return cfg
+	default:
+		return DefaultFastRestoreConfig()
+	}
+}
+
+// RestorePerformanceMetrics tracks restore performance for analysis
+type RestorePerformanceMetrics struct {
+	StartTime      time.Time
+	EndTime        time.Time
+	TotalBytes     int64
+	TotalDatabases int
+	ParallelJobs   int
+	ParallelDBs    int
+	Profile        string
+	TUIEnabled     bool
+
+	// Calculated metrics
+	Duration       time.Duration
+	ThroughputMBps float64
+	DBsPerMinute   float64
+}
+
+// Calculate computes derived metrics
+func (m *RestorePerformanceMetrics) Calculate() {
+	m.Duration = m.EndTime.Sub(m.StartTime)
+	if m.Duration.Seconds() > 0 {
+		m.ThroughputMBps = float64(m.TotalBytes) / m.Duration.Seconds() / 1024 / 1024
+		m.DBsPerMinute = float64(m.TotalDatabases) / m.Duration.Minutes()
+	}
+}
+
+// String returns a human-readable summary
+func (m *RestorePerformanceMetrics) String() string {
+	m.Calculate()
+	return fmt.Sprintf(
+		"Restore completed: %d databases, %.2f GB in %s (%.1f MB/s, %.1f DBs/min) [profile=%s, jobs=%d, parallel_dbs=%d, tui=%v]",
+		m.TotalDatabases,
+		float64(m.TotalBytes)/1024/1024/1024,
+		m.Duration.Round(time.Second),
+		m.ThroughputMBps,
+		m.DBsPerMinute,
+		m.Profile,
+		m.ParallelJobs,
+		m.ParallelDBs,
+		m.TUIEnabled,
+	)
+}

internal/restore/large_db_guard.go

@@ -6,11 +6,11 @@ import (
 	"database/sql"
 	"fmt"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"strings"
 	"syscall"
 
+	"dbbackup/internal/cleanup"
 	"dbbackup/internal/config"
 	"dbbackup/internal/logger"
 )
@@ -358,6 +358,14 @@ func (g *LargeDBGuard) WarnUser(strategy *RestoreStrategy, silentMode bool) {
 
 // CheckSystemMemory validates system has enough memory for restore
 func (g *LargeDBGuard) CheckSystemMemory(backupSizeBytes int64) *MemoryCheck {
+	return g.CheckSystemMemoryWithType(backupSizeBytes, false)
+}
+
+// CheckSystemMemoryWithType validates system memory with archive type awareness
+// isClusterArchive: true for .tar.gz cluster backups (contain pre-compressed .dump files)
+//
+//	false for single .sql.gz files (compressed SQL that expands significantly)
+func (g *LargeDBGuard) CheckSystemMemoryWithType(backupSizeBytes int64, isClusterArchive bool) *MemoryCheck {
 	check := &MemoryCheck{
 		BackupSizeGB: float64(backupSizeBytes) / (1024 * 1024 * 1024),
 	}
@@ -374,8 +382,18 @@ func (g *LargeDBGuard) CheckSystemMemory(backupSizeBytes int64) *MemoryCheck {
 	check.SwapTotalGB = float64(memInfo.SwapTotal) / (1024 * 1024 * 1024)
 	check.SwapFreeGB = float64(memInfo.SwapFree) / (1024 * 1024 * 1024)
 
-	// Estimate uncompressed size (typical compression ratio 5:1 to 10:1)
-	estimatedUncompressedGB := check.BackupSizeGB * 7 // Conservative estimate
+	// Estimate uncompressed size based on archive type:
+	// - Cluster archives (.tar.gz): contain pre-compressed .dump files, ratio ~1.2x
+	// - Single SQL files (.sql.gz): compressed SQL expands significantly, ratio ~5-7x
+	var compressionMultiplier float64
+	if isClusterArchive {
+		compressionMultiplier = 1.2 // tar.gz with already-compressed .dump files
+		g.log.Debug("Using cluster archive compression ratio", "multiplier", compressionMultiplier)
+	} else {
+		compressionMultiplier = 5.0 // Conservative for gzipped SQL (was 7, reduced to 5)
+		g.log.Debug("Using single file compression ratio", "multiplier", compressionMultiplier)
+	}
+	estimatedUncompressedGB := check.BackupSizeGB * compressionMultiplier
 
 	// Memory requirements
 	// - PostgreSQL needs ~2-4GB for shared_buffers
@@ -572,7 +590,7 @@ func (g *LargeDBGuard) RevertMySQLSettings() []string {
 // Uses pg_restore -l which outputs a line-by-line listing, then streams through it
 func (g *LargeDBGuard) StreamCountBLOBs(ctx context.Context, dumpFile string) (int, error) {
 	// pg_restore -l outputs text listing, one line per object
-	cmd := exec.CommandContext(ctx, "pg_restore", "-l", dumpFile)
+	cmd := cleanup.SafeCommand(ctx, "pg_restore", "-l", dumpFile)
 
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
@@ -609,7 +627,7 @@ func (g *LargeDBGuard) StreamCountBLOBs(ctx context.Context, dumpFile string) (i
 // StreamAnalyzeDump analyzes a dump file using streaming to avoid memory issues
 // Returns: blobCount, estimatedObjects, error
 func (g *LargeDBGuard) StreamAnalyzeDump(ctx context.Context, dumpFile string) (blobCount, totalObjects int, err error) {
-	cmd := exec.CommandContext(ctx, "pg_restore", "-l", dumpFile)
+	cmd := cleanup.SafeCommand(ctx, "pg_restore", "-l", dumpFile)
 
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {

internal/restore/preflight.go

@@ -1,18 +1,22 @@
 package restore
 
 import (
+	"bufio"
 	"context"
 	"database/sql"
 	"fmt"
 	"os"
-	"os/exec"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strconv"
 	"strings"
 	"time"
 
+	"dbbackup/internal/cleanup"
+
 	"github.com/dustin/go-humanize"
+	"github.com/klauspost/pgzip"
 	"github.com/shirou/gopsutil/v3/mem"
 )
 
@@ -381,7 +385,7 @@ func (e *Engine) countBlobsInDump(ctx context.Context, dumpFile string) int {
 	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
 	defer cancel()
 
-	cmd := exec.CommandContext(ctx, "pg_restore", "-l", dumpFile)
+	cmd := cleanup.SafeCommand(ctx, "pg_restore", "-l", dumpFile)
 	output, err := cmd.Output()
 	if err != nil {
 		return 0
@@ -398,24 +402,51 @@ func (e *Engine) countBlobsInDump(ctx context.Context, dumpFile string) int {
 }
 
 // estimateBlobsInSQL samples compressed SQL for lo_create patterns
+// Uses in-process pgzip decompression (NO external gzip process)
 func (e *Engine) estimateBlobsInSQL(sqlFile string) int {
-	// Use zgrep for efficient searching in gzipped files
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	// Count lo_create calls (each = one large object)
-	cmd := exec.CommandContext(ctx, "zgrep", "-c", "lo_create", sqlFile)
-	output, err := cmd.Output()
+	// Open the gzipped file
+	f, err := os.Open(sqlFile)
 	if err != nil {
-		// Also try SELECT lo_create pattern
-		cmd2 := exec.CommandContext(ctx, "zgrep", "-c", "SELECT.*lo_create", sqlFile)
-		output, err = cmd2.Output()
-		if err != nil {
-			return 0
-		}
+		e.log.Debug("Cannot open SQL file for BLOB estimation", "file", sqlFile, "error", err)
+		return 0
+	}
+	defer f.Close()
+
+	// Create pgzip reader for parallel decompression
+	gzReader, err := pgzip.NewReader(f)
+	if err != nil {
+		e.log.Debug("Cannot create pgzip reader", "file", sqlFile, "error", err)
+		return 0
+	}
+	defer gzReader.Close()
+
+	// Scan for lo_create patterns
+	// We use a regex to match both "lo_create" and "SELECT lo_create" patterns
+	loCreatePattern := regexp.MustCompile(`lo_create`)
+	
+	scanner := bufio.NewScanner(gzReader)
+	// Use larger buffer for potentially long lines
+	buf := make([]byte, 0, 256*1024)
+	scanner.Buffer(buf, 10*1024*1024)
+
+	count := 0
+	linesScanned := 0
+	maxLines := 1000000 // Limit scanning for very large files
+
+	for scanner.Scan() && linesScanned < maxLines {
+		line := scanner.Text()
+		linesScanned++
+		
+		// Count all lo_create occurrences in the line
+		matches := loCreatePattern.FindAllString(line, -1)
+		count += len(matches)
 	}
 
-	count, _ := strconv.Atoi(strings.TrimSpace(string(output)))
+	if err := scanner.Err(); err != nil {
+		e.log.Debug("Error scanning SQL file", "file", sqlFile, "error", err, "lines_scanned", linesScanned)
+	}
+
+	e.log.Debug("BLOB estimation from SQL file", "file", sqlFile, "lo_create_count", count, "lines_scanned", linesScanned)
 	return count
 }
 

internal/restore/safety.go

@@ -8,6 +8,7 @@ import (
 	"os/exec"
 	"strings"
 
+	"dbbackup/internal/cleanup"
 	"dbbackup/internal/config"
 	"dbbackup/internal/fs"
 	"dbbackup/internal/logger"
@@ -419,7 +420,7 @@ func (s *Safety) checkPostgresDatabaseExists(ctx context.Context, dbName string)
 	}
 	args = append([]string{"-h", host}, args...)
 
-	cmd := exec.CommandContext(ctx, "psql", args...)
+	cmd := cleanup.SafeCommand(ctx, "psql", args...)
 
 	// Set password if provided
 	if s.cfg.Password != "" {
@@ -447,7 +448,7 @@ func (s *Safety) checkMySQLDatabaseExists(ctx context.Context, dbName string) (b
 		args = append([]string{"-h", s.cfg.Host}, args...)
 	}
 
-	cmd := exec.CommandContext(ctx, "mysql", args...)
+	cmd := cleanup.SafeCommand(ctx, "mysql", args...)
 
 	if s.cfg.Password != "" {
 		cmd.Env = append(os.Environ(), fmt.Sprintf("MYSQL_PWD=%s", s.cfg.Password))
@@ -493,7 +494,7 @@ func (s *Safety) listPostgresUserDatabases(ctx context.Context) ([]string, error
 	}
 	args = append([]string{"-h", host}, args...)
 
-	cmd := exec.CommandContext(ctx, "psql", args...)
+	cmd := cleanup.SafeCommand(ctx, "psql", args...)
 
 	// Set password - check config first, then environment
 	env := os.Environ()
@@ -542,7 +543,7 @@ func (s *Safety) listMySQLUserDatabases(ctx context.Context) ([]string, error) {
 		args = append([]string{"-h", s.cfg.Host}, args...)
 	}
 
-	cmd := exec.CommandContext(ctx, "mysql", args...)
+	cmd := cleanup.SafeCommand(ctx, "mysql", args...)
 
 	if s.cfg.Password != "" {
 		cmd.Env = append(os.Environ(), fmt.Sprintf("MYSQL_PWD=%s", s.cfg.Password))

internal/restore/version_check.go

@@ -3,11 +3,11 @@ package restore
 import (
 	"context"
 	"fmt"
-	"os/exec"
 	"regexp"
 	"strconv"
 	"time"
 
+	"dbbackup/internal/cleanup"
 	"dbbackup/internal/database"
 )
 
@@ -54,7 +54,7 @@ func GetDumpFileVersion(dumpPath string) (*VersionInfo, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
-	cmd := exec.CommandContext(ctx, "pg_restore", "-l", dumpPath)
+	cmd := cleanup.SafeCommand(ctx, "pg_restore", "-l", dumpPath)
 	output, err := cmd.CombinedOutput()
 	if err != nil {
 		return nil, fmt.Errorf("failed to read dump file metadata: %w (output: %s)", err, string(output))

internal/tui/restore_exec.go

@@ -16,6 +16,7 @@ import (
 	"dbbackup/internal/config"
 	"dbbackup/internal/database"
 	"dbbackup/internal/logger"
+	"dbbackup/internal/progress"
 	"dbbackup/internal/restore"
 )
 
@@ -75,6 +76,13 @@ type RestoreExecutionModel struct {
 	overallPhase   int // 1=Extracting, 2=Globals, 3=Databases
 	extractionDone bool
 
+	// Rich progress view for cluster restores
+	richProgressView *RichClusterProgressView
+	unifiedProgress  *progress.UnifiedClusterProgress
+	useRichProgress  bool // Whether to use the rich progress view
+	termWidth        int  // Terminal width for rich progress
+	termHeight       int  // Terminal height for rich progress
+
 	// Results
 	done       bool
 	cancelling bool // True when user has requested cancellation
@@ -108,6 +116,11 @@ func NewRestoreExecution(cfg *config.Config, log logger.Logger, parent tea.Model
 		details:           []string{},
 		spinnerFrames:     spinnerFrames, // Use package-level constant
 		spinnerFrame:      0,
+		// Initialize rich progress view for cluster restores
+		richProgressView: NewRichClusterProgressView(),
+		useRichProgress:  restoreType == "restore-cluster",
+		termWidth:        80,
+		termHeight:       24,
 	}
 }
 
@@ -121,7 +134,7 @@ func (m RestoreExecutionModel) Init() tea.Cmd {
 type restoreTickMsg time.Time
 
 func restoreTickCmd() tea.Cmd {
-	return tea.Tick(time.Millisecond*100, func(t time.Time) tea.Msg {
+	return tea.Tick(time.Millisecond*250, func(t time.Time) tea.Msg {
 		return restoreTickMsg(t)
 	})
 }
@@ -176,6 +189,9 @@ type sharedProgressState struct {
 	// Throttling to prevent excessive updates (memory optimization)
 	lastSpeedSampleTime time.Time     // Last time we added a speed sample
 	minSampleInterval   time.Duration // Minimum interval between samples (100ms)
+
+	// Unified progress tracker for rich display
+	unifiedProgress *progress.UnifiedClusterProgress
 }
 
 type restoreSpeedSample struct {
@@ -231,6 +247,18 @@ func getCurrentRestoreProgress() (bytesTotal, bytesDone int64, description strin
 		currentRestoreProgressState.phase3StartTime
 }
 
+// getUnifiedProgress returns the unified progress tracker if available
+func getUnifiedProgress() *progress.UnifiedClusterProgress {
+	currentRestoreProgressMu.Lock()
+	defer currentRestoreProgressMu.Unlock()
+
+	if currentRestoreProgressState == nil {
+		return nil
+	}
+
+	return currentRestoreProgressState.unifiedProgress
+}
+
 // calculateRollingSpeed calculates speed from recent samples (last 5 seconds)
 func calculateRollingSpeed(samples []restoreSpeedSample) float64 {
 	if len(samples) < 2 {
@@ -332,6 +360,11 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 		progressState := &sharedProgressState{
 			speedSamples: make([]restoreSpeedSample, 0, 100),
 		}
+
+		// Initialize unified progress tracker for cluster restores
+		if restoreType == "restore-cluster" {
+			progressState.unifiedProgress = progress.NewUnifiedClusterProgress("restore", archive.Path)
+		}
 		engine.SetProgressCallback(func(current, total int64, description string) {
 			progressState.mu.Lock()
 			defer progressState.mu.Unlock()
@@ -342,10 +375,19 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 			progressState.overallPhase = 1
 			progressState.extractionDone = false
 
+			// Update unified progress tracker
+			if progressState.unifiedProgress != nil {
+				progressState.unifiedProgress.SetPhase(progress.PhaseExtracting)
+				progressState.unifiedProgress.SetExtractProgress(current, total)
+			}
+
 			// Check if extraction is complete
 			if current >= total && total > 0 {
 				progressState.extractionDone = true
 				progressState.overallPhase = 2
+				if progressState.unifiedProgress != nil {
+					progressState.unifiedProgress.SetPhase(progress.PhaseGlobals)
+				}
 			}
 
 			// Throttle speed samples to prevent memory bloat (max 10 samples/sec)
@@ -384,6 +426,13 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 			// Clear byte progress when switching to db progress
 			progressState.bytesTotal = 0
 			progressState.bytesDone = 0
+
+			// Update unified progress tracker
+			if progressState.unifiedProgress != nil {
+				progressState.unifiedProgress.SetPhase(progress.PhaseDatabases)
+				progressState.unifiedProgress.SetDatabasesTotal(total, nil)
+				progressState.unifiedProgress.StartDatabase(dbName, 0)
+			}
 		})
 
 		// Set up timing-aware database progress callback for cluster restore ETA
@@ -406,6 +455,13 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 			// Clear byte progress when switching to db progress
 			progressState.bytesTotal = 0
 			progressState.bytesDone = 0
+
+			// Update unified progress tracker
+			if progressState.unifiedProgress != nil {
+				progressState.unifiedProgress.SetPhase(progress.PhaseDatabases)
+				progressState.unifiedProgress.SetDatabasesTotal(total, nil)
+				progressState.unifiedProgress.StartDatabase(dbName, 0)
+			}
 		})
 
 		// Set up weighted (bytes-based) progress callback for accurate cluster restore progress
@@ -424,6 +480,14 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 			if progressState.phase3StartTime.IsZero() {
 				progressState.phase3StartTime = time.Now()
 			}
+
+			// Update unified progress tracker
+			if progressState.unifiedProgress != nil {
+				progressState.unifiedProgress.SetPhase(progress.PhaseDatabases)
+				progressState.unifiedProgress.SetDatabasesTotal(dbTotal, nil)
+				progressState.unifiedProgress.StartDatabase(dbName, bytesTotal)
+				progressState.unifiedProgress.UpdateDatabaseProgress(bytesDone)
+			}
 		})
 
 		// Store progress state in a package-level variable for the ticker to access
@@ -489,11 +553,30 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 
 func (m RestoreExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		// Update terminal dimensions for rich progress view
+		m.termWidth = msg.Width
+		m.termHeight = msg.Height
+		if m.richProgressView != nil {
+			m.richProgressView.SetSize(msg.Width, msg.Height)
+		}
+		return m, nil
+
 	case restoreTickMsg:
 		if !m.done {
 			m.spinnerFrame = (m.spinnerFrame + 1) % len(m.spinnerFrames)
 			m.elapsed = time.Since(m.startTime)
 
+			// Advance spinner for rich progress view
+			if m.richProgressView != nil {
+				m.richProgressView.AdvanceSpinner()
+			}
+
+			// Update unified progress reference
+			if m.useRichProgress && m.unifiedProgress == nil {
+				m.unifiedProgress = getUnifiedProgress()
+			}
+
 			// Poll shared progress state for real-time updates
 			// Note: dbPhaseElapsed is now calculated in realtime inside getCurrentRestoreProgress()
 			bytesTotal, bytesDone, description, hasUpdate, dbTotal, dbDone, speed, dbPhaseElapsed, dbAvgPerDB, currentDB, overallPhase, extractionDone, dbBytesTotal, dbBytesDone, _ := getCurrentRestoreProgress()
@@ -782,7 +865,16 @@ func (m RestoreExecutionModel) View() string {
 	} else {
 		// Show unified progress for cluster restore
 		if m.restoreType == "restore-cluster" {
-			// Calculate overall progress across all phases
+			// Use rich progress view when we have unified progress data
+			if m.useRichProgress && m.unifiedProgress != nil {
+				// Render using the rich cluster progress view
+				s.WriteString(m.richProgressView.RenderUnified(m.unifiedProgress))
+				s.WriteString("\n")
+				s.WriteString(infoStyle.Render("[KEYS]  Press Ctrl+C to cancel"))
+				return s.String()
+			}
+
+			// Fallback: Calculate overall progress across all phases
 			// Phase 1: Extraction (0-60%)
 			// Phase 2: Globals (60-65%)
 			// Phase 3: Databases (65-100%)

internal/tui/rich_cluster_progress.go

@@ -0,0 +1,344 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"dbbackup/internal/progress"
+)
+
+// RichClusterProgressView renders detailed cluster restore progress
+type RichClusterProgressView struct {
+	width         int
+	height        int
+	spinnerFrames []string
+	spinnerFrame  int
+}
+
+// NewRichClusterProgressView creates a new rich progress view
+func NewRichClusterProgressView() *RichClusterProgressView {
+	return &RichClusterProgressView{
+		width:  80,
+		height: 24,
+		spinnerFrames: []string{
+			"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏",
+		},
+	}
+}
+
+// SetSize updates the terminal size
+func (v *RichClusterProgressView) SetSize(width, height int) {
+	v.width = width
+	v.height = height
+}
+
+// AdvanceSpinner moves to the next spinner frame
+func (v *RichClusterProgressView) AdvanceSpinner() {
+	v.spinnerFrame = (v.spinnerFrame + 1) % len(v.spinnerFrames)
+}
+
+// RenderUnified renders progress from UnifiedClusterProgress
+func (v *RichClusterProgressView) RenderUnified(p *progress.UnifiedClusterProgress) string {
+	if p == nil {
+		return ""
+	}
+
+	snapshot := p.GetSnapshot()
+	return v.RenderSnapshot(&snapshot)
+}
+
+// RenderSnapshot renders progress from a ProgressSnapshot
+func (v *RichClusterProgressView) RenderSnapshot(snapshot *progress.ProgressSnapshot) string {
+	if snapshot == nil {
+		return ""
+	}
+
+	var b strings.Builder
+	b.Grow(2048)
+
+	// Header with overall progress
+	b.WriteString(v.renderHeader(snapshot))
+	b.WriteString("\n\n")
+
+	// Overall progress bar
+	b.WriteString(v.renderOverallProgress(snapshot))
+	b.WriteString("\n\n")
+
+	// Phase-specific details
+	b.WriteString(v.renderPhaseDetails(snapshot))
+
+	// Performance metrics
+	if v.height > 15 {
+		b.WriteString("\n")
+		b.WriteString(v.renderMetricsFromSnapshot(snapshot))
+	}
+
+	return b.String()
+}
+
+func (v *RichClusterProgressView) renderHeader(snapshot *progress.ProgressSnapshot) string {
+	elapsed := time.Since(snapshot.StartTime)
+
+	// Calculate ETA based on progress
+	overall := v.calculateOverallPercent(snapshot)
+	var etaStr string
+	if overall > 0 && overall < 100 {
+		eta := time.Duration(float64(elapsed) / float64(overall) * float64(100-overall))
+		etaStr = fmt.Sprintf("ETA: %s", formatDuration(eta))
+	} else if overall >= 100 {
+		etaStr = "Complete!"
+	} else {
+		etaStr = "ETA: calculating..."
+	}
+
+	title := "Cluster Restore Progress"
+	// Cap separator at 40 chars to avoid long lines on wide terminals
+	sepLen := maxInt(0, v.width-len(title)-4)
+	if sepLen > 40 {
+		sepLen = 40
+	}
+	separator := strings.Repeat("━", sepLen)
+
+	return fmt.Sprintf("%s %s\n  Elapsed: %s | %s",
+		title, separator,
+		formatDuration(elapsed), etaStr)
+}
+
+func (v *RichClusterProgressView) renderOverallProgress(snapshot *progress.ProgressSnapshot) string {
+	overall := v.calculateOverallPercent(snapshot)
+
+	// Phase indicator
+	phaseLabel := v.getPhaseLabel(snapshot)
+
+	// Progress bar
+	barWidth := v.width - 20
+	if barWidth < 20 {
+		barWidth = 20
+	}
+	bar := v.renderProgressBarWidth(overall, barWidth)
+
+	return fmt.Sprintf("  Overall: %s %3d%%\n  Phase: %s", bar, overall, phaseLabel)
+}
+
+func (v *RichClusterProgressView) getPhaseLabel(snapshot *progress.ProgressSnapshot) string {
+	switch snapshot.Phase {
+	case progress.PhaseExtracting:
+		return fmt.Sprintf("📦 Extracting archive (%s / %s)",
+			FormatBytes(snapshot.ExtractBytes), FormatBytes(snapshot.ExtractTotal))
+	case progress.PhaseGlobals:
+		return "🔧 Restoring globals (roles, tablespaces)"
+	case progress.PhaseDatabases:
+		return fmt.Sprintf("🗄️  Databases (%d/%d) %s",
+			snapshot.DatabasesDone, snapshot.DatabasesTotal, snapshot.CurrentDB)
+	case progress.PhaseVerifying:
+		return fmt.Sprintf("✅ Verifying (%d/%d)", snapshot.VerifyDone, snapshot.VerifyTotal)
+	case progress.PhaseComplete:
+		return "🎉 Complete!"
+	case progress.PhaseFailed:
+		return "❌ Failed"
+	default:
+		return string(snapshot.Phase)
+	}
+}
+
+func (v *RichClusterProgressView) calculateOverallPercent(snapshot *progress.ProgressSnapshot) int {
+	// Use the same logic as UnifiedClusterProgress
+	phaseWeights := map[progress.Phase]int{
+		progress.PhaseExtracting: 20,
+		progress.PhaseGlobals:    5,
+		progress.PhaseDatabases:  70,
+		progress.PhaseVerifying:  5,
+	}
+
+	switch snapshot.Phase {
+	case progress.PhaseIdle:
+		return 0
+	case progress.PhaseExtracting:
+		if snapshot.ExtractTotal > 0 {
+			return int(float64(snapshot.ExtractBytes) / float64(snapshot.ExtractTotal) * float64(phaseWeights[progress.PhaseExtracting]))
+		}
+		return 0
+	case progress.PhaseGlobals:
+		return phaseWeights[progress.PhaseExtracting] + phaseWeights[progress.PhaseGlobals]
+	case progress.PhaseDatabases:
+		basePercent := phaseWeights[progress.PhaseExtracting] + phaseWeights[progress.PhaseGlobals]
+		if snapshot.DatabasesTotal == 0 {
+			return basePercent
+		}
+		dbProgress := float64(snapshot.DatabasesDone) / float64(snapshot.DatabasesTotal)
+		if snapshot.CurrentDBTotal > 0 {
+			currentProgress := float64(snapshot.CurrentDBBytes) / float64(snapshot.CurrentDBTotal)
+			dbProgress += currentProgress / float64(snapshot.DatabasesTotal)
+		}
+		return basePercent + int(dbProgress*float64(phaseWeights[progress.PhaseDatabases]))
+	case progress.PhaseVerifying:
+		basePercent := phaseWeights[progress.PhaseExtracting] + phaseWeights[progress.PhaseGlobals] + phaseWeights[progress.PhaseDatabases]
+		if snapshot.VerifyTotal > 0 {
+			verifyProgress := float64(snapshot.VerifyDone) / float64(snapshot.VerifyTotal)
+			return basePercent + int(verifyProgress*float64(phaseWeights[progress.PhaseVerifying]))
+		}
+		return basePercent
+	case progress.PhaseComplete:
+		return 100
+	default:
+		return 0
+	}
+}
+
+func (v *RichClusterProgressView) renderPhaseDetails(snapshot *progress.ProgressSnapshot) string {
+	var b strings.Builder
+
+	switch snapshot.Phase {
+	case progress.PhaseExtracting:
+		pct := 0
+		if snapshot.ExtractTotal > 0 {
+			pct = int(float64(snapshot.ExtractBytes) / float64(snapshot.ExtractTotal) * 100)
+		}
+		bar := v.renderMiniProgressBar(pct)
+		b.WriteString(fmt.Sprintf("  📦 Extraction: %s %d%%\n", bar, pct))
+		b.WriteString(fmt.Sprintf("     %s / %s\n",
+			FormatBytes(snapshot.ExtractBytes), FormatBytes(snapshot.ExtractTotal)))
+
+	case progress.PhaseDatabases:
+		b.WriteString("  📊 Databases:\n\n")
+
+		// Show completed databases if any
+		if snapshot.DatabasesDone > 0 {
+			avgTime := time.Duration(0)
+			if len(snapshot.DatabaseTimes) > 0 {
+				var total time.Duration
+				for _, t := range snapshot.DatabaseTimes {
+					total += t
+				}
+				avgTime = total / time.Duration(len(snapshot.DatabaseTimes))
+			}
+			b.WriteString(fmt.Sprintf("     ✓ %d completed (avg: %s)\n",
+				snapshot.DatabasesDone, formatDuration(avgTime)))
+		}
+
+		// Show current database
+		if snapshot.CurrentDB != "" {
+			spinner := v.spinnerFrames[v.spinnerFrame]
+			pct := 0
+			if snapshot.CurrentDBTotal > 0 {
+				pct = int(float64(snapshot.CurrentDBBytes) / float64(snapshot.CurrentDBTotal) * 100)
+			}
+			bar := v.renderMiniProgressBar(pct)
+
+			phaseElapsed := time.Since(snapshot.PhaseStartTime)
+			b.WriteString(fmt.Sprintf("     %s %-20s %s %3d%%\n",
+				spinner, truncateString(snapshot.CurrentDB, 20), bar, pct))
+			b.WriteString(fmt.Sprintf("        └─ %s / %s (running %s)\n",
+				FormatBytes(snapshot.CurrentDBBytes), FormatBytes(snapshot.CurrentDBTotal),
+				formatDuration(phaseElapsed)))
+		}
+
+		// Show remaining count
+		remaining := snapshot.DatabasesTotal - snapshot.DatabasesDone
+		if snapshot.CurrentDB != "" {
+			remaining--
+		}
+		if remaining > 0 {
+			b.WriteString(fmt.Sprintf("     ⏳ %d remaining\n", remaining))
+		}
+
+	case progress.PhaseVerifying:
+		pct := 0
+		if snapshot.VerifyTotal > 0 {
+			pct = snapshot.VerifyDone * 100 / snapshot.VerifyTotal
+		}
+		bar := v.renderMiniProgressBar(pct)
+		b.WriteString(fmt.Sprintf("  ✅ Verification: %s %d%%\n", bar, pct))
+		b.WriteString(fmt.Sprintf("     %d / %d databases verified\n",
+			snapshot.VerifyDone, snapshot.VerifyTotal))
+
+	case progress.PhaseComplete:
+		elapsed := time.Since(snapshot.StartTime)
+		b.WriteString(fmt.Sprintf("  🎉 Restore complete!\n"))
+		b.WriteString(fmt.Sprintf("     %d databases restored in %s\n",
+			snapshot.DatabasesDone, formatDuration(elapsed)))
+
+	case progress.PhaseFailed:
+		b.WriteString("  ❌ Restore failed:\n")
+		for _, err := range snapshot.Errors {
+			b.WriteString(fmt.Sprintf("     • %s\n", truncateString(err, v.width-10)))
+		}
+	}
+
+	return b.String()
+}
+
+func (v *RichClusterProgressView) renderMetricsFromSnapshot(snapshot *progress.ProgressSnapshot) string {
+	var b strings.Builder
+	b.WriteString("  📈 Performance:\n")
+
+	elapsed := time.Since(snapshot.StartTime)
+	if elapsed > 0 {
+		// Calculate throughput from extraction phase if we have data
+		if snapshot.ExtractBytes > 0 && elapsed.Seconds() > 0 {
+			throughput := float64(snapshot.ExtractBytes) / elapsed.Seconds()
+			b.WriteString(fmt.Sprintf("     Throughput: %s/s\n", FormatBytes(int64(throughput))))
+		}
+
+		// Database timing info
+		if len(snapshot.DatabaseTimes) > 0 {
+			var total time.Duration
+			for _, t := range snapshot.DatabaseTimes {
+				total += t
+			}
+			avg := total / time.Duration(len(snapshot.DatabaseTimes))
+			b.WriteString(fmt.Sprintf("     Avg DB time: %s\n", formatDuration(avg)))
+		}
+	}
+
+	return b.String()
+}
+
+// Helper functions
+
+func (v *RichClusterProgressView) renderProgressBarWidth(pct, width int) string {
+	if width < 10 {
+		width = 10
+	}
+	filled := (pct * width) / 100
+	empty := width - filled
+
+	bar := strings.Repeat("█", filled) + strings.Repeat("░", empty)
+	return "[" + bar + "]"
+}
+
+func (v *RichClusterProgressView) renderMiniProgressBar(pct int) string {
+	width := 20
+	filled := (pct * width) / 100
+	empty := width - filled
+	return strings.Repeat("█", filled) + strings.Repeat("░", empty)
+}
+
+func truncateString(s string, maxLen int) string {
+	if len(s) <= maxLen {
+		return s
+	}
+	if maxLen < 4 {
+		return s[:maxLen]
+	}
+	return s[:maxLen-3] + "..."
+}
+
+func maxInt(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func formatNumShort(n int64) string {
+	if n >= 1e9 {
+		return fmt.Sprintf("%.1fB", float64(n)/1e9)
+	} else if n >= 1e6 {
+		return fmt.Sprintf("%.1fM", float64(n)/1e6)
+	} else if n >= 1e3 {
+		return fmt.Sprintf("%.1fK", float64(n)/1e3)
+	}
+	return fmt.Sprintf("%d", n)
+}

internal/tui/settings.go

@@ -94,6 +94,11 @@ func NewSettingsModel(cfg *config.Config, log logger.Logger, parent tea.Model) S
 				c.CPUWorkloadType = workloads[nextIdx]
 
 				// Recalculate Jobs and DumpJobs based on workload type
+				// If CPUInfo is nil, try to detect it first
+				if c.CPUInfo == nil && c.AutoDetectCores {
+					_ = c.OptimizeForCPU() // This will detect CPU and set CPUInfo
+				}
+
 				if c.CPUInfo != nil && c.AutoDetectCores {
 					switch c.CPUWorkloadType {
 					case "cpu-intensive":

main.go

@@ -16,7 +16,7 @@ import (
 
 // Build information (set by ldflags)
 var (
-	version   = "5.3.0"
+	version   = "5.4.5"
 	buildTime = "unknown"
 	gitCommit = "unknown"
 )

scripts/benchmark_restore.sh

@@ -0,0 +1,225 @@
+#!/bin/bash
+# =============================================================================
+# dbbackup Restore Performance Benchmark Script
+# =============================================================================
+# This script helps identify restore performance bottlenecks by comparing:
+# 1. dbbackup restore with TUI
+# 2. dbbackup restore without TUI (--no-tui --quiet)
+# 3. Native pg_restore -j8 baseline
+#
+# Usage:
+#   ./benchmark_restore.sh backup_file.dump.gz [target_database]
+#
+# Requirements:
+#   - dbbackup binary in PATH or current directory
+#   - PostgreSQL tools (pg_restore, psql)
+#   - A backup file to test with
+# =============================================================================
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Parse arguments
+BACKUP_FILE="${1:-}"
+TARGET_DB="${2:-benchmark_restore_test}"
+
+if [ -z "$BACKUP_FILE" ]; then
+    echo -e "${RED}Error: Backup file required${NC}"
+    echo "Usage: $0 backup_file.dump.gz [target_database]"
+    exit 1
+fi
+
+if [ ! -f "$BACKUP_FILE" ]; then
+    echo -e "${RED}Error: Backup file not found: $BACKUP_FILE${NC}"
+    exit 1
+fi
+
+# Find dbbackup binary
+DBBACKUP=""
+if command -v dbbackup &> /dev/null; then
+    DBBACKUP="dbbackup"
+elif [ -f "./dbbackup" ]; then
+    DBBACKUP="./dbbackup"
+elif [ -f "./bin/dbbackup_linux_amd64" ]; then
+    DBBACKUP="./bin/dbbackup_linux_amd64"
+else
+    echo -e "${RED}Error: dbbackup binary not found${NC}"
+    exit 1
+fi
+
+echo -e "${BLUE}======================================================${NC}"
+echo -e "${BLUE}  dbbackup Restore Performance Benchmark${NC}"
+echo -e "${BLUE}======================================================${NC}"
+echo ""
+echo -e "Backup file: ${GREEN}$BACKUP_FILE${NC}"
+echo -e "Target database: ${GREEN}$TARGET_DB${NC}"
+echo -e "dbbackup binary: ${GREEN}$DBBACKUP${NC}"
+echo ""
+
+# Get backup file size
+BACKUP_SIZE=$(stat -c%s "$BACKUP_FILE" 2>/dev/null || stat -f%z "$BACKUP_FILE" 2>/dev/null)
+BACKUP_SIZE_MB=$((BACKUP_SIZE / 1024 / 1024))
+echo -e "Backup size: ${GREEN}${BACKUP_SIZE_MB} MB${NC}"
+echo ""
+
+# Function to drop test database
+drop_test_db() {
+    echo -e "${YELLOW}Dropping test database...${NC}"
+    psql -c "DROP DATABASE IF EXISTS $TARGET_DB;" postgres 2>/dev/null || true
+}
+
+# Function to create test database
+create_test_db() {
+    echo -e "${YELLOW}Creating test database...${NC}"
+    psql -c "CREATE DATABASE $TARGET_DB;" postgres 2>/dev/null || true
+}
+
+# Function to get PostgreSQL settings
+get_pg_settings() {
+    echo -e "\n${BLUE}=== PostgreSQL Configuration ===${NC}"
+    psql -c "
+        SELECT name, setting, unit 
+        FROM pg_settings 
+        WHERE name IN (
+            'max_connections',
+            'shared_buffers',
+            'work_mem',
+            'maintenance_work_mem',
+            'max_wal_size',
+            'max_locks_per_transaction',
+            'synchronous_commit',
+            'wal_level'
+        )
+        ORDER BY name;
+    " postgres 2>/dev/null || echo "(Could not query settings)"
+}
+
+# Function to run benchmark test
+run_benchmark() {
+    local name="$1"
+    local cmd="$2"
+    
+    echo -e "\n${BLUE}=== Test: $name ===${NC}"
+    echo -e "Command: ${YELLOW}$cmd${NC}"
+    
+    drop_test_db
+    create_test_db
+    
+    # Run the restore and capture time
+    local start_time=$(date +%s.%N)
+    eval "$cmd" 2>&1 | tail -20
+    local exit_code=$?
+    local end_time=$(date +%s.%N)
+    
+    local duration=$(echo "$end_time - $start_time" | bc)
+    local throughput=$(echo "scale=2; $BACKUP_SIZE_MB / $duration" | bc)
+    
+    if [ $exit_code -eq 0 ]; then
+        echo -e "${GREEN}✓ Success${NC}"
+        echo -e "Duration: ${GREEN}${duration}s${NC}"
+        echo -e "Throughput: ${GREEN}${throughput} MB/s${NC}"
+    else
+        echo -e "${RED}✗ Failed (exit code: $exit_code)${NC}"
+    fi
+    
+    echo "$name,$duration,$throughput,$exit_code" >> benchmark_results.csv
+}
+
+# Initialize results file
+echo "test_name,duration_seconds,throughput_mbps,exit_code" > benchmark_results.csv
+
+# Get system info
+echo -e "\n${BLUE}=== System Information ===${NC}"
+echo -e "CPU cores: $(nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 'unknown')"
+echo -e "Memory: $(free -h 2>/dev/null | grep Mem | awk '{print $2}' || echo 'unknown')"
+echo -e "Disk: $(df -h . | tail -1 | awk '{print $4}' || echo 'unknown') available"
+
+get_pg_settings
+
+echo -e "\n${BLUE}=== Starting Benchmarks ===${NC}"
+echo -e "${YELLOW}This may take a while depending on backup size...${NC}"
+
+# Test 1: dbbackup with TUI (default)
+run_benchmark "dbbackup_with_tui" \
+    "$DBBACKUP restore single '$BACKUP_FILE' --target '$TARGET_DB' --confirm --profile turbo"
+
+# Test 2: dbbackup without TUI
+run_benchmark "dbbackup_no_tui" \
+    "$DBBACKUP restore single '$BACKUP_FILE' --target '$TARGET_DB' --confirm --no-tui --quiet --profile turbo"
+
+# Test 3: dbbackup max performance
+run_benchmark "dbbackup_max_perf" \
+    "$DBBACKUP restore single '$BACKUP_FILE' --target '$TARGET_DB' --confirm --no-tui --quiet --profile max-performance --jobs 8"
+
+# Test 4: Native pg_restore baseline (if custom format)
+if [[ "$BACKUP_FILE" == *.dump* ]]; then
+    RESTORE_FILE="$BACKUP_FILE"
+    if [[ "$BACKUP_FILE" == *.gz ]]; then
+        echo -e "\n${YELLOW}Decompressing for pg_restore baseline...${NC}"
+        RESTORE_FILE="/tmp/benchmark_restore_temp.dump"
+        gunzip -c "$BACKUP_FILE" > "$RESTORE_FILE"
+    fi
+    
+    run_benchmark "pg_restore_j8" \
+        "pg_restore -j8 --no-owner --no-privileges -d '$TARGET_DB' '$RESTORE_FILE'"
+    
+    # Cleanup temp file
+    [ "$RESTORE_FILE" != "$BACKUP_FILE" ] && rm -f "$RESTORE_FILE"
+fi
+
+# Cleanup
+drop_test_db
+
+# Print summary
+echo -e "\n${BLUE}======================================================${NC}"
+echo -e "${BLUE}  Benchmark Results Summary${NC}"
+echo -e "${BLUE}======================================================${NC}"
+echo ""
+column -t -s',' benchmark_results.csv 2>/dev/null || cat benchmark_results.csv
+echo ""
+
+# Calculate speedup
+if [ -f benchmark_results.csv ]; then
+    TUI_TIME=$(grep "dbbackup_with_tui" benchmark_results.csv | cut -d',' -f2)
+    NO_TUI_TIME=$(grep "dbbackup_no_tui" benchmark_results.csv | cut -d',' -f2)
+    
+    if [ -n "$TUI_TIME" ] && [ -n "$NO_TUI_TIME" ]; then
+        SPEEDUP=$(echo "scale=2; $TUI_TIME / $NO_TUI_TIME" | bc)
+        echo -e "TUI overhead: ${YELLOW}${SPEEDUP}x${NC} (TUI time / no-TUI time)"
+        
+        if (( $(echo "$SPEEDUP > 2.0" | bc -l) )); then
+            echo -e "${RED}⚠ TUI is causing significant slowdown!${NC}"
+            echo -e "   Consider using --no-tui --quiet for production restores"
+        elif (( $(echo "$SPEEDUP > 1.2" | bc -l) )); then
+            echo -e "${YELLOW}⚠ TUI adds some overhead${NC}"
+        else
+            echo -e "${GREEN}✓ TUI overhead is minimal${NC}"
+        fi
+    fi
+fi
+
+echo ""
+echo -e "${BLUE}Results saved to: ${GREEN}benchmark_results.csv${NC}"
+echo ""
+
+# Performance recommendations
+echo -e "${BLUE}=== Performance Recommendations ===${NC}"
+echo ""
+echo "For fastest restores:"
+echo "  1. Use --profile turbo or --profile max-performance"
+echo "  2. Use --jobs 8 (or higher for more cores)"
+echo "  3. Use --no-tui --quiet for batch/scripted restores"
+echo "  4. Ensure PostgreSQL has:"
+echo "     - maintenance_work_mem = 1GB+"
+echo "     - max_wal_size = 10GB+"
+echo "     - synchronous_commit = off (for restores only)"
+echo ""
+echo "Example optimal command:"
+echo -e "  ${GREEN}$DBBACKUP restore single backup.dump.gz --confirm --profile max-performance --jobs 8 --no-tui --quiet${NC}"
+echo ""

scripts/test-sigint-cleanup.sh

@@ -0,0 +1,192 @@
+#!/bin/bash
+# scripts/test-sigint-cleanup.sh
+# Test script to verify clean shutdown on SIGINT (Ctrl+C)
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+BINARY="$PROJECT_DIR/dbbackup"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo "=== SIGINT Cleanup Test ==="
+echo ""
+echo "Project: $PROJECT_DIR"
+echo "Binary: $BINARY"
+echo ""
+
+# Check if binary exists
+if [ ! -f "$BINARY" ]; then
+    echo -e "${YELLOW}Binary not found, building...${NC}"
+    cd "$PROJECT_DIR"
+    go build -o dbbackup .
+fi
+
+# Create a test backup file if it doesn't exist
+TEST_BACKUP="/tmp/test-sigint-backup.sql.gz"
+if [ ! -f "$TEST_BACKUP" ]; then
+    echo -e "${YELLOW}Creating test backup file...${NC}"
+    echo "-- Test SQL file for SIGINT testing" | gzip > "$TEST_BACKUP"
+fi
+
+echo "=== Phase 1: Pre-test Cleanup ==="
+echo "Killing any existing dbbackup processes..."
+pkill -f "dbbackup" 2>/dev/null || true
+sleep 1
+
+echo ""
+echo "=== Phase 2: Check Initial State ==="
+
+echo "Checking for orphaned processes..."
+INITIAL_PROCS=$(pgrep -f "pg_dump|pg_restore|dbbackup" 2>/dev/null | wc -l)
+echo "Initial related processes: $INITIAL_PROCS"
+
+echo ""
+echo "Checking for temp files..."
+INITIAL_TEMPS=$(ls /tmp/dbbackup-* 2>/dev/null | wc -l || echo "0")
+echo "Initial temp files: $INITIAL_TEMPS"
+
+echo ""
+echo "=== Phase 3: Start Test Operation ==="
+
+# Start a TUI operation that will hang (version is fast, but menu would wait)
+echo "Starting dbbackup TUI (will be interrupted)..."
+
+# Run in background with PTY simulation (needed for TUI)
+cd "$PROJECT_DIR"
+timeout 30 script -q -c "$BINARY" /dev/null &
+PID=$!
+
+echo "Process started: PID=$PID"
+sleep 2
+
+# Check if process is running
+if ! kill -0 $PID 2>/dev/null; then
+    echo -e "${YELLOW}Process exited quickly (expected for non-interactive test)${NC}"
+    echo "This is normal - the TUI requires a real TTY"
+    PID=""
+else
+    echo "Process is running"
+    
+    echo ""
+    echo "=== Phase 4: Check Running State ==="
+    
+    echo "Child processes of $PID:"
+    pgrep -P $PID 2>/dev/null | while read child; do
+        ps -p $child -o pid,ppid,cmd 2>/dev/null || true
+    done
+    
+    echo ""
+    echo "=== Phase 5: Send SIGINT ==="
+    echo "Sending SIGINT to process $PID..."
+    kill -SIGINT $PID 2>/dev/null || true
+    
+    echo "Waiting for cleanup (max 10 seconds)..."
+    for i in {1..10}; do
+        if ! kill -0 $PID 2>/dev/null; then
+            echo ""
+            echo -e "${GREEN}Process exited after ${i} seconds${NC}"
+            break
+        fi
+        sleep 1
+        echo -n "."
+    done
+    echo ""
+    
+    # Check if still running
+    if kill -0 $PID 2>/dev/null; then
+        echo -e "${RED}Process still running after 10 seconds!${NC}"
+        echo "Force killing..."
+        kill -9 $PID 2>/dev/null || true
+    fi
+fi
+
+sleep 2  # Give OS time to clean up
+
+echo ""
+echo "=== Phase 6: Post-Shutdown Verification ==="
+
+# Check for zombie processes
+ZOMBIES=$(ps aux 2>/dev/null | grep -E "dbbackup|pg_dump|pg_restore" | grep -v grep | grep defunct | wc -l)
+echo "Zombie processes: $ZOMBIES"
+
+# Check for orphaned children
+if [ -n "$PID" ]; then
+    ORPHANS=$(pgrep -P $PID 2>/dev/null | wc -l || echo "0")
+    echo "Orphaned children of original process: $ORPHANS"
+else
+    ORPHANS=0
+fi
+
+# Check for leftover related processes
+LEFTOVER_PROCS=$(pgrep -f "pg_dump|pg_restore" 2>/dev/null | wc -l || echo "0")
+echo "Leftover pg_dump/pg_restore processes: $LEFTOVER_PROCS"
+
+# Check for temp files
+TEMP_FILES=$(ls /tmp/dbbackup-* 2>/dev/null | wc -l || echo "0")
+echo "Temporary files: $TEMP_FILES"
+
+# Database connections check (if psql available and configured)
+if command -v psql &> /dev/null; then
+    echo ""
+    echo "Checking database connections..."
+    DB_CONNS=$(psql -t -c "SELECT count(*) FROM pg_stat_activity WHERE application_name LIKE '%dbbackup%';" 2>/dev/null | tr -d ' ' || echo "N/A")
+    echo "Database connections with 'dbbackup' in name: $DB_CONNS"
+else
+    echo "psql not available - skipping database connection check"
+    DB_CONNS="N/A"
+fi
+
+echo ""
+echo "=== Test Results ==="
+
+PASSED=true
+
+if [ "$ZOMBIES" -gt 0 ]; then
+    echo -e "${RED}❌ FAIL: $ZOMBIES zombie process(es) found${NC}"
+    PASSED=false
+else
+    echo -e "${GREEN}✓ No zombie processes${NC}"
+fi
+
+if [ "$ORPHANS" -gt 0 ]; then
+    echo -e "${RED}❌ FAIL: $ORPHANS orphaned child process(es) found${NC}"
+    PASSED=false
+else
+    echo -e "${GREEN}✓ No orphaned children${NC}"
+fi
+
+if [ "$LEFTOVER_PROCS" -gt 0 ]; then
+    echo -e "${YELLOW}⚠ WARNING: $LEFTOVER_PROCS leftover pg_dump/pg_restore process(es)${NC}"
+    echo "  These may be from other operations"
+fi
+
+if [ "$TEMP_FILES" -gt "$INITIAL_TEMPS" ]; then
+    NEW_TEMPS=$((TEMP_FILES - INITIAL_TEMPS))
+    echo -e "${RED}❌ FAIL: $NEW_TEMPS new temporary file(s) left behind${NC}"
+    ls -la /tmp/dbbackup-* 2>/dev/null || true
+    PASSED=false
+else
+    echo -e "${GREEN}✓ No new temporary files left behind${NC}"
+fi
+
+if [ "$DB_CONNS" != "N/A" ] && [ "$DB_CONNS" -gt 0 ]; then
+    echo -e "${RED}❌ FAIL: $DB_CONNS database connection(s) still active${NC}"
+    PASSED=false
+elif [ "$DB_CONNS" != "N/A" ]; then
+    echo -e "${GREEN}✓ No lingering database connections${NC}"
+fi
+
+echo ""
+if [ "$PASSED" = true ]; then
+    echo -e "${GREEN}=== ✓ ALL TESTS PASSED ===${NC}"
+    exit 0
+else
+    echo -e "${RED}=== ✗ SOME TESTS FAILED ===${NC}"
+    exit 1
+fi