Fix: Enterprise cluster restore (postgres user via su)

Critical fixes for enterprise environments where dbbackup runs as
postgres user via 'su postgres' without sudo access:

1. canRestartPostgreSQL(): New function that detects if we can restart
   PostgreSQL. Returns false immediately if running as postgres user
   without sudo access, avoiding wasted time and potential hangs.

2. tryRestartPostgreSQL(): Now calls canRestartPostgreSQL() first to
   skip restart attempts in restricted environments.

3. Changed restart warning from ERROR to WARN level - it's expected
   behavior in enterprise environments, not an error.

4. Context cancellation check: Goroutines now check ctx.Err() before
   starting and properly count cancelled databases as failures.

5. Goroutine accounting: After wg.Wait(), verify all databases were
   accounted for (success + fail = total). Catches goroutine crashes
   or deadlocks.

6. Port argument fix: Always pass -p port to psql for localhost
   restores, fixing non-standard port configurations.

This should fix the issue where cluster restore showed success but
0 databases were actually restored when running on enterprise systems.

bin/README.md

@@ -4,8 +4,8 @@ This directory contains pre-compiled binaries for the DB Backup Tool across mult
 
 ## Build Information
 - **Version**: 3.42.34
-- **Build Time**: 2026-01-15_14:33:12_UTC
-- **Git Commit**: 09a9177
+- **Build Time**: 2026-01-16_13:03:20_UTC
+- **Git Commit**: 3201f0f
 
 ## Recent Updates (v1.1.0)
 - ✅ Fixed TUI progress display with line-by-line output

internal/auth/helper.go

@@ -84,19 +84,13 @@ func findHbaFileViaPostgres() string {
 
 // parsePgHbaConf parses pg_hba.conf and returns the authentication method
 func parsePgHbaConf(path string, user string) AuthMethod {
-	// Try with sudo if we can't read directly
+	// Try to read the file directly - do NOT use sudo as it triggers password prompts
+	// If we can't read pg_hba.conf, we'll rely on connection attempts to determine auth
 	file, err := os.Open(path)
 	if err != nil {
-		// Try with sudo (with timeout)
-		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-		defer cancel()
-
-		cmd := exec.CommandContext(ctx, "sudo", "cat", path)
-		output, err := cmd.Output()
-		if err != nil {
-			return AuthUnknown
-		}
-		return parseHbaContent(string(output), user)
+		// If we can't read the file, return unknown and let the connection determine auth
+		// This avoids sudo password prompts when running as postgres via su
+		return AuthUnknown
 	}
 	defer file.Close()
 

internal/restore/engine.go

@@ -34,6 +34,10 @@ type ProgressCallback func(current, total int64, description string)
 // DatabaseProgressCallback is called with database count progress during cluster restore
 type DatabaseProgressCallback func(done, total int, dbName string)
 
+// DatabaseProgressWithTimingCallback is called with database progress including timing info
+// Parameters: done count, total count, database name, elapsed time for current restore phase, avg duration per DB
+type DatabaseProgressWithTimingCallback func(done, total int, dbName string, phaseElapsed, avgPerDB time.Duration)
+
 // Engine handles database restore operations
 type Engine struct {
 	cfg              *config.Config
@@ -45,8 +49,9 @@ type Engine struct {
 	debugLogPath     string // Path to save debug log on error
 
 	// TUI progress callback for detailed progress reporting
-	progressCallback   ProgressCallback
-	dbProgressCallback DatabaseProgressCallback
+	progressCallback         ProgressCallback
+	dbProgressCallback       DatabaseProgressCallback
+	dbProgressTimingCallback DatabaseProgressWithTimingCallback
 }
 
 // New creates a new restore engine
@@ -112,6 +117,11 @@ func (e *Engine) SetDatabaseProgressCallback(cb DatabaseProgressCallback) {
 	e.dbProgressCallback = cb
 }
 
+// SetDatabaseProgressWithTimingCallback sets a callback for database progress with timing info
+func (e *Engine) SetDatabaseProgressWithTimingCallback(cb DatabaseProgressWithTimingCallback) {
+	e.dbProgressTimingCallback = cb
+}
+
 // reportProgress safely calls the progress callback if set
 func (e *Engine) reportProgress(current, total int64, description string) {
 	if e.progressCallback != nil {
@@ -126,6 +136,13 @@ func (e *Engine) reportDatabaseProgress(done, total int, dbName string) {
 	}
 }
 
+// reportDatabaseProgressWithTiming safely calls the timing-aware callback if set
+func (e *Engine) reportDatabaseProgressWithTiming(done, total int, dbName string, phaseElapsed, avgPerDB time.Duration) {
+	if e.dbProgressTimingCallback != nil {
+		e.dbProgressTimingCallback(done, total, dbName, phaseElapsed, avgPerDB)
+	}
+}
+
 // loggerAdapter adapts our logger to the progress.Logger interface
 type loggerAdapter struct {
 	logger logger.Logger
@@ -425,16 +442,18 @@ func (e *Engine) restorePostgreSQLSQL(ctx context.Context, archivePath, targetDB
 	var cmd []string
 
 	// For localhost, omit -h to use Unix socket (avoids Ident auth issues)
+	// But always include -p for port (in case of non-standard port)
 	hostArg := ""
+	portArg := fmt.Sprintf("-p %d", e.cfg.Port)
 	if e.cfg.Host != "localhost" && e.cfg.Host != "" {
-		hostArg = fmt.Sprintf("-h %s -p %d", e.cfg.Host, e.cfg.Port)
+		hostArg = fmt.Sprintf("-h %s", e.cfg.Host)
 	}
 
 	if compressed {
 		// Use ON_ERROR_STOP=1 to fail fast on first error (prevents millions of errors on truncated dumps)
-		psqlCmd := fmt.Sprintf("psql -U %s -d %s -v ON_ERROR_STOP=1", e.cfg.User, targetDB)
+		psqlCmd := fmt.Sprintf("psql %s -U %s -d %s -v ON_ERROR_STOP=1", portArg, e.cfg.User, targetDB)
 		if hostArg != "" {
-			psqlCmd = fmt.Sprintf("psql %s -U %s -d %s -v ON_ERROR_STOP=1", hostArg, e.cfg.User, targetDB)
+			psqlCmd = fmt.Sprintf("psql %s %s -U %s -d %s -v ON_ERROR_STOP=1", hostArg, portArg, e.cfg.User, targetDB)
 		}
 		// Set PGPASSWORD in the bash command for password-less auth
 		cmd = []string{
@@ -455,6 +474,7 @@ func (e *Engine) restorePostgreSQLSQL(ctx context.Context, archivePath, targetDB
 		} else {
 			cmd = []string{
 				"psql",
+				"-p", fmt.Sprintf("%d", e.cfg.Port),
 				"-U", e.cfg.User,
 				"-d", targetDB,
 				"-v", "ON_ERROR_STOP=1",
@@ -1037,6 +1057,11 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 	var successCount, failCount int32
 	var mu sync.Mutex // Protect shared resources (progress, logger)
 
+	// Timing tracking for restore phase progress
+	restorePhaseStart := time.Now()
+	var completedDBTimes []time.Duration // Track duration for each completed DB restore
+	var completedDBTimesMu sync.Mutex
+
 	// Create semaphore to limit concurrency
 	semaphore := make(chan struct{}, parallelism)
 	var wg sync.WaitGroup
@@ -1062,6 +1087,19 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 				}
 			}()
 
+			// Check for context cancellation before starting
+			if ctx.Err() != nil {
+				e.log.Warn("Context cancelled - skipping database restore", "file", filename)
+				atomic.AddInt32(&failCount, 1)
+				restoreErrorsMu.Lock()
+				restoreErrors = multierror.Append(restoreErrors, fmt.Errorf("%s: restore skipped (context cancelled)", strings.TrimSuffix(strings.TrimSuffix(filename, ".dump"), ".sql.gz")))
+				restoreErrorsMu.Unlock()
+				return
+			}
+
+			// Track timing for this database restore
+			dbRestoreStart := time.Now()
+
 			// Update estimator progress (thread-safe)
 			mu.Lock()
 			estimator.UpdateProgress(idx)
@@ -1074,12 +1112,26 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 
 			dbProgress := 15 + int(float64(idx)/float64(totalDBs)*85.0)
 
+			// Calculate average time per DB and report progress with timing
+			completedDBTimesMu.Lock()
+			var avgPerDB time.Duration
+			if len(completedDBTimes) > 0 {
+				var totalDuration time.Duration
+				for _, d := range completedDBTimes {
+					totalDuration += d
+				}
+				avgPerDB = totalDuration / time.Duration(len(completedDBTimes))
+			}
+			phaseElapsed := time.Since(restorePhaseStart)
+			completedDBTimesMu.Unlock()
+
 			mu.Lock()
 			statusMsg := fmt.Sprintf("Restoring database %s (%d/%d)", dbName, idx+1, totalDBs)
 			e.progress.Update(statusMsg)
 			e.log.Info("Restoring database", "name", dbName, "file", dumpFile, "progress", dbProgress)
-			// Report database progress for TUI
+			// Report database progress for TUI (both callbacks)
 			e.reportDatabaseProgress(idx, totalDBs, dbName)
+			e.reportDatabaseProgressWithTiming(idx, totalDBs, dbName, phaseElapsed, avgPerDB)
 			mu.Unlock()
 
 			// STEP 1: Drop existing database completely (clean slate)
@@ -1144,6 +1196,12 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 				return
 			}
 
+			// Track completed database restore duration for ETA calculation
+			dbRestoreDuration := time.Since(dbRestoreStart)
+			completedDBTimesMu.Lock()
+			completedDBTimes = append(completedDBTimes, dbRestoreDuration)
+			completedDBTimesMu.Unlock()
+
 			atomic.AddInt32(&successCount, 1)
 		}(dbIndex, entry.Name())
 
@@ -1156,6 +1214,35 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 	successCountFinal := int(atomic.LoadInt32(&successCount))
 	failCountFinal := int(atomic.LoadInt32(&failCount))
 
+	// SANITY CHECK: Verify all databases were accounted for
+	// This catches any goroutine that exited without updating counters
+	accountedFor := successCountFinal + failCountFinal
+	if accountedFor != totalDBs {
+		missingCount := totalDBs - accountedFor
+		e.log.Error("INTERNAL ERROR: Some database restore goroutines did not report status",
+			"expected", totalDBs,
+			"success", successCountFinal,
+			"failed", failCountFinal,
+			"unaccounted", missingCount)
+
+		// Treat unaccounted databases as failures
+		failCountFinal += missingCount
+		restoreErrorsMu.Lock()
+		restoreErrors = multierror.Append(restoreErrors, fmt.Errorf("%d database(s) did not complete (possible goroutine crash or deadlock)", missingCount))
+		restoreErrorsMu.Unlock()
+	}
+
+	// CRITICAL: Check if no databases were restored at all
+	if successCountFinal == 0 {
+		e.progress.Fail(fmt.Sprintf("Cluster restore FAILED: 0 of %d databases restored", totalDBs))
+		operation.Fail("No databases were restored")
+
+		if failCountFinal > 0 && restoreErrors != nil {
+			return fmt.Errorf("cluster restore failed: all %d database(s) failed:\n%s", failCountFinal, restoreErrors.Error())
+		}
+		return fmt.Errorf("cluster restore failed: no databases were restored (0 of %d total). Check PostgreSQL logs for details", totalDBs)
+	}
+
 	if failCountFinal > 0 {
 		// Format multi-error with detailed output
 		restoreErrors.ErrorFormat = func(errs []error) string {
@@ -1993,56 +2080,100 @@ func (e *Engine) boostPostgreSQLSettings(ctx context.Context, lockBoostValue int
 			// Wait for PostgreSQL to be ready
 			time.Sleep(3 * time.Second)
 		} else {
-			// Cannot restart - warn user loudly
-			e.log.Error("=" + strings.Repeat("=", 70))
-			e.log.Error("WARNING: max_locks_per_transaction change requires PostgreSQL restart!")
-			e.log.Error("Current value: " + strconv.Itoa(original.MaxLocks) + ", needed: " + strconv.Itoa(lockBoostValue))
-			e.log.Error("Restore may fail with 'out of shared memory' error on BLOB-heavy databases.")
-			e.log.Error("")
-			e.log.Error("To fix manually:")
-			e.log.Error("  1. sudo systemctl restart postgresql")
-			e.log.Error("  2. Or: sudo -u postgres pg_ctl restart -D $PGDATA")
-			e.log.Error("  3. Then re-run the restore")
-			e.log.Error("=" + strings.Repeat("=", 70))
-			// Continue anyway - might work for small restores
+			// Cannot restart - warn user but continue
+			// The setting is written to postgresql.auto.conf and will take effect on next restart
+			e.log.Warn("=" + strings.Repeat("=", 70))
+			e.log.Warn("NOTE: max_locks_per_transaction change requires PostgreSQL restart")
+			e.log.Warn("Current value: " + strconv.Itoa(original.MaxLocks) + ", target: " + strconv.Itoa(lockBoostValue))
+			e.log.Warn("")
+			e.log.Warn("The setting has been saved to postgresql.auto.conf and will take")
+			e.log.Warn("effect on the next PostgreSQL restart. If restore fails with")
+			e.log.Warn("'out of shared memory' errors, ask your DBA to restart PostgreSQL.")
+			e.log.Warn("")
+			e.log.Warn("Continuing with restore - this may succeed if your databases")
+			e.log.Warn("don't have many large objects (BLOBs).")
+			e.log.Warn("=" + strings.Repeat("=", 70))
+			// Continue anyway - might work for small restores or DBs without BLOBs
 		}
 	}
 
 	return original, nil
 }
 
+// canRestartPostgreSQL checks if we have the ability to restart PostgreSQL
+// Returns false if running in a restricted environment (e.g., su postgres on enterprise systems)
+func (e *Engine) canRestartPostgreSQL() bool {
+	// Check if we're running as postgres user - if so, we likely can't restart
+	// because PostgreSQL is managed by init/systemd, not directly by pg_ctl
+	currentUser := os.Getenv("USER")
+	if currentUser == "" {
+		currentUser = os.Getenv("LOGNAME")
+	}
+
+	// If we're the postgres user, check if we have sudo access
+	if currentUser == "postgres" {
+		// 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.Stdin = nil
+		if err := cmd.Run(); err != nil {
+			e.log.Info("Running as postgres user without sudo access - cannot restart PostgreSQL",
+				"user", currentUser,
+				"hint", "Ask system administrator to restart PostgreSQL if needed")
+			return false
+		}
+	}
+
+	return true
+}
+
 // tryRestartPostgreSQL attempts to restart PostgreSQL using various methods
 // Returns true if restart was successful
+// IMPORTANT: Uses short timeouts and non-interactive sudo to avoid blocking on password prompts
+// NOTE: This function will return false immediately if running as postgres without sudo
 func (e *Engine) tryRestartPostgreSQL(ctx context.Context) bool {
+	// First check if we can even attempt a restart
+	if !e.canRestartPostgreSQL() {
+		e.log.Info("Skipping PostgreSQL restart attempt (no privileges)")
+		return false
+	}
+
 	e.progress.Update("Attempting PostgreSQL restart for lock settings...")
 
-	// Method 1: systemctl (most common on modern Linux)
-	cmd := exec.CommandContext(ctx, "sudo", "systemctl", "restart", "postgresql")
-	if err := cmd.Run(); err == nil {
+	// Use short timeout for each restart attempt (don't block on sudo password prompts)
+	runWithTimeout := func(args ...string) bool {
+		cmdCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		cmd := exec.CommandContext(cmdCtx, args[0], args[1:]...)
+		// Set stdin to /dev/null to prevent sudo from waiting for password
+		cmd.Stdin = nil
+		return cmd.Run() == nil
+	}
+
+	// Method 1: systemctl (most common on modern Linux) - use sudo -n for non-interactive
+	if runWithTimeout("sudo", "-n", "systemctl", "restart", "postgresql") {
 		return true
 	}
 
 	// Method 2: systemctl with version suffix (e.g., postgresql-15)
 	for _, ver := range []string{"17", "16", "15", "14", "13", "12"} {
-		cmd = exec.CommandContext(ctx, "sudo", "systemctl", "restart", "postgresql-"+ver)
-		if err := cmd.Run(); err == nil {
+		if runWithTimeout("sudo", "-n", "systemctl", "restart", "postgresql-"+ver) {
 			return true
 		}
 	}
 
 	// Method 3: service command (older systems)
-	cmd = exec.CommandContext(ctx, "sudo", "service", "postgresql", "restart")
-	if err := cmd.Run(); err == nil {
+	if runWithTimeout("sudo", "-n", "service", "postgresql", "restart") {
 		return true
 	}
 
-	// Method 4: pg_ctl as postgres user
-	cmd = exec.CommandContext(ctx, "sudo", "-u", "postgres", "pg_ctl", "restart", "-D", "/var/lib/postgresql/data", "-m", "fast")
-	if err := cmd.Run(); err == nil {
+	// Method 4: pg_ctl as postgres user (if we ARE postgres user, no sudo needed)
+	if runWithTimeout("pg_ctl", "restart", "-D", "/var/lib/postgresql/data", "-m", "fast") {
 		return true
 	}
 
-	// Method 5: Try common PGDATA paths
+	// Method 5: Try common PGDATA paths with pg_ctl directly (for postgres user)
 	pgdataPaths := []string{
 		"/var/lib/pgsql/data",
 		"/var/lib/pgsql/17/data",
@@ -2053,8 +2184,7 @@ func (e *Engine) tryRestartPostgreSQL(ctx context.Context) bool {
 		"/var/lib/postgresql/15/main",
 	}
 	for _, pgdata := range pgdataPaths {
-		cmd = exec.CommandContext(ctx, "sudo", "-u", "postgres", "pg_ctl", "restart", "-D", pgdata, "-m", "fast")
-		if err := cmd.Run(); err == nil {
+		if runWithTimeout("pg_ctl", "restart", "-D", pgdata, "-m", "fast") {
 			return true
 		}
 	}

internal/tui/backup_exec.go

@@ -380,22 +380,83 @@ func (m BackupExecutionModel) View() string {
 			s.WriteString("\n  [KEY]  Press Ctrl+C or ESC to cancel\n")
 		}
 	} else {
-		s.WriteString(fmt.Sprintf("  %s\n\n", m.status))
-
+		// Show completion summary with detailed stats
 		if m.err != nil {
-			s.WriteString(fmt.Sprintf("  [FAIL] Error: %v\n", m.err))
-		} else if m.result != "" {
-			// Parse and display result cleanly
-			lines := strings.Split(m.result, "\n")
-			for _, line := range lines {
-				line = strings.TrimSpace(line)
-				if line != "" {
-					s.WriteString("  " + line + "\n")
+			s.WriteString("\n")
+			s.WriteString(errorStyle.Render("  ╔══════════════════════════════════════════════════════════╗"))
+			s.WriteString("\n")
+			s.WriteString(errorStyle.Render("  ║              [FAIL] BACKUP FAILED                        ║"))
+			s.WriteString("\n")
+			s.WriteString(errorStyle.Render("  ╚══════════════════════════════════════════════════════════╝"))
+			s.WriteString("\n\n")
+			s.WriteString(errorStyle.Render(fmt.Sprintf("    Error: %v", m.err)))
+			s.WriteString("\n")
+		} else {
+			s.WriteString("\n")
+			s.WriteString(successStyle.Render("  ╔══════════════════════════════════════════════════════════╗"))
+			s.WriteString("\n")
+			s.WriteString(successStyle.Render("  ║           [OK] BACKUP COMPLETED SUCCESSFULLY             ║"))
+			s.WriteString("\n")
+			s.WriteString(successStyle.Render("  ╚══════════════════════════════════════════════════════════╝"))
+			s.WriteString("\n\n")
+
+			// Summary section
+			s.WriteString(infoStyle.Render("    ─── Summary ─────────────────────────────────────────────"))
+			s.WriteString("\n\n")
+
+			// Backup type specific info
+			switch m.backupType {
+			case "cluster":
+				s.WriteString("      Type:          Cluster Backup\n")
+				if m.dbTotal > 0 {
+					s.WriteString(fmt.Sprintf("      Databases:     %d backed up\n", m.dbTotal))
 				}
+			case "single":
+				s.WriteString("      Type:          Single Database Backup\n")
+				s.WriteString(fmt.Sprintf("      Database:      %s\n", m.databaseName))
+			case "sample":
+				s.WriteString("      Type:          Sample Backup\n")
+				s.WriteString(fmt.Sprintf("      Database:      %s\n", m.databaseName))
+				s.WriteString(fmt.Sprintf("      Sample Ratio:  %d\n", m.ratio))
 			}
+
+			s.WriteString("\n")
+
+			// Timing section
+			s.WriteString(infoStyle.Render("    ─── Timing ──────────────────────────────────────────────"))
+			s.WriteString("\n\n")
+
+			elapsed := time.Since(m.startTime)
+			s.WriteString(fmt.Sprintf("      Total Time:    %s\n", formatBackupDuration(elapsed)))
+
+			if m.backupType == "cluster" && m.dbTotal > 0 {
+				avgPerDB := elapsed / time.Duration(m.dbTotal)
+				s.WriteString(fmt.Sprintf("      Avg per DB:    %s\n", formatBackupDuration(avgPerDB)))
+			}
+
+			s.WriteString("\n")
+			s.WriteString(infoStyle.Render("    ─────────────────────────────────────────────────────────"))
+			s.WriteString("\n")
 		}
-		s.WriteString("\n  [KEY]  Press Enter or ESC to return to menu\n")
+
+		s.WriteString("\n")
+		s.WriteString("  [KEY]  Press Enter or ESC to return to menu\n")
 	}
 
 	return s.String()
 }
+
+// formatBackupDuration formats duration in human readable format
+func formatBackupDuration(d time.Duration) string {
+	if d < time.Minute {
+		return fmt.Sprintf("%.1fs", d.Seconds())
+	}
+	if d < time.Hour {
+		minutes := int(d.Minutes())
+		seconds := int(d.Seconds()) % 60
+		return fmt.Sprintf("%dm %ds", minutes, seconds)
+	}
+	hours := int(d.Hours())
+	minutes := int(d.Minutes()) % 60
+	return fmt.Sprintf("%dh %dm", hours, minutes)
+}

internal/tui/restore_exec.go

@@ -57,6 +57,10 @@ type RestoreExecutionModel struct {
 	dbTotal int
 	dbDone  int
 
+	// Timing info for database restore phase (ETA calculation)
+	dbPhaseElapsed time.Duration // Elapsed time since restore phase started
+	dbAvgPerDB     time.Duration // Average time per database restore
+
 	// Results
 	done       bool
 	cancelling bool // True when user has requested cancellation
@@ -136,6 +140,10 @@ type sharedProgressState struct {
 	dbTotal int
 	dbDone  int
 
+	// Timing info for database restore phase
+	dbPhaseElapsed time.Duration // Elapsed time since restore phase started
+	dbAvgPerDB     time.Duration // Average time per database restore
+
 	// Rolling window for speed calculation
 	speedSamples []restoreSpeedSample
 }
@@ -163,12 +171,12 @@ func clearCurrentRestoreProgress() {
 	currentRestoreProgressState = nil
 }
 
-func getCurrentRestoreProgress() (bytesTotal, bytesDone int64, description string, hasUpdate bool, dbTotal, dbDone int, speed float64) {
+func getCurrentRestoreProgress() (bytesTotal, bytesDone int64, description string, hasUpdate bool, dbTotal, dbDone int, speed float64, dbPhaseElapsed, dbAvgPerDB time.Duration) {
 	currentRestoreProgressMu.Lock()
 	defer currentRestoreProgressMu.Unlock()
 
 	if currentRestoreProgressState == nil {
-		return 0, 0, "", false, 0, 0, 0
+		return 0, 0, "", false, 0, 0, 0, 0, 0
 	}
 
 	currentRestoreProgressState.mu.Lock()
@@ -179,7 +187,8 @@ func getCurrentRestoreProgress() (bytesTotal, bytesDone int64, description strin
 
 	return currentRestoreProgressState.bytesTotal, currentRestoreProgressState.bytesDone,
 		currentRestoreProgressState.description, currentRestoreProgressState.hasUpdate,
-		currentRestoreProgressState.dbTotal, currentRestoreProgressState.dbDone, speed
+		currentRestoreProgressState.dbTotal, currentRestoreProgressState.dbDone, speed,
+		currentRestoreProgressState.dbPhaseElapsed, currentRestoreProgressState.dbAvgPerDB
 }
 
 // calculateRollingSpeed calculates speed from recent samples (last 5 seconds)
@@ -304,6 +313,21 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 			progressState.bytesDone = 0
 		})
 
+		// Set up timing-aware database progress callback for cluster restore ETA
+		engine.SetDatabaseProgressWithTimingCallback(func(done, total int, dbName string, phaseElapsed, avgPerDB time.Duration) {
+			progressState.mu.Lock()
+			defer progressState.mu.Unlock()
+			progressState.dbDone = done
+			progressState.dbTotal = total
+			progressState.description = fmt.Sprintf("Restoring %s", dbName)
+			progressState.dbPhaseElapsed = phaseElapsed
+			progressState.dbAvgPerDB = avgPerDB
+			progressState.hasUpdate = true
+			// Clear byte progress when switching to db progress
+			progressState.bytesTotal = 0
+			progressState.bytesDone = 0
+		})
+
 		// Store progress state in a package-level variable for the ticker to access
 		// This is a workaround because tea messages can't be sent from callbacks
 		setCurrentRestoreProgress(progressState)
@@ -357,7 +381,7 @@ func (m RestoreExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.elapsed = time.Since(m.startTime)
 
 			// Poll shared progress state for real-time updates
-			bytesTotal, bytesDone, description, hasUpdate, dbTotal, dbDone, speed := getCurrentRestoreProgress()
+			bytesTotal, bytesDone, description, hasUpdate, dbTotal, dbDone, speed, dbPhaseElapsed, dbAvgPerDB := getCurrentRestoreProgress()
 			if hasUpdate && bytesTotal > 0 {
 				m.bytesTotal = bytesTotal
 				m.bytesDone = bytesDone
@@ -370,9 +394,11 @@ func (m RestoreExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				m.phase = "Extracting"
 				m.progress = int((bytesDone * 100) / bytesTotal)
 			} else if hasUpdate && dbTotal > 0 {
-				// Database count progress for cluster restore
+				// Database count progress for cluster restore with timing
 				m.dbTotal = dbTotal
 				m.dbDone = dbDone
+				m.dbPhaseElapsed = dbPhaseElapsed
+				m.dbAvgPerDB = dbAvgPerDB
 				m.showBytes = false
 				m.status = fmt.Sprintf("Restoring database %d of %d...", dbDone+1, dbTotal)
 				m.phase = "Restore"
@@ -518,22 +544,71 @@ func (m RestoreExecutionModel) View() string {
 	s.WriteString("\n")
 
 	if m.done {
-		// Show result
+		// Show result with comprehensive summary
 		if m.err != nil {
-			s.WriteString(errorStyle.Render("[FAIL] Restore Failed"))
+			s.WriteString(errorStyle.Render("╔══════════════════════════════════════════════════════════════╗"))
+			s.WriteString("\n")
+			s.WriteString(errorStyle.Render("║              [FAIL] RESTORE FAILED                           ║"))
+			s.WriteString("\n")
+			s.WriteString(errorStyle.Render("╚══════════════════════════════════════════════════════════════╝"))
 			s.WriteString("\n\n")
-			s.WriteString(errorStyle.Render(fmt.Sprintf("Error: %v", m.err)))
+			s.WriteString(errorStyle.Render(fmt.Sprintf("  Error: %v", m.err)))
 			s.WriteString("\n")
 		} else {
-			s.WriteString(successStyle.Render("[OK] Restore Completed Successfully"))
+			s.WriteString(successStyle.Render("╔══════════════════════════════════════════════════════════════╗"))
+			s.WriteString("\n")
+			s.WriteString(successStyle.Render("║           [OK] RESTORE COMPLETED SUCCESSFULLY                ║"))
+			s.WriteString("\n")
+			s.WriteString(successStyle.Render("╚══════════════════════════════════════════════════════════════╝"))
 			s.WriteString("\n\n")
-			s.WriteString(successStyle.Render(m.result))
+
+			// Summary section
+			s.WriteString(infoStyle.Render("  ─── Summary ───────────────────────────────────────────────"))
+			s.WriteString("\n\n")
+
+			// Archive info
+			s.WriteString(fmt.Sprintf("    Archive:       %s\n", m.archive.Name))
+			if m.archive.Size > 0 {
+				s.WriteString(fmt.Sprintf("    Archive Size:  %s\n", FormatBytes(m.archive.Size)))
+			}
+
+			// Restore type specific info
+			if m.restoreType == "restore-cluster" {
+				s.WriteString(fmt.Sprintf("    Type:          Cluster Restore\n"))
+				if m.dbTotal > 0 {
+					s.WriteString(fmt.Sprintf("    Databases:     %d restored\n", m.dbTotal))
+				}
+				if m.cleanClusterFirst && len(m.existingDBs) > 0 {
+					s.WriteString(fmt.Sprintf("    Cleaned:       %d existing database(s) dropped\n", len(m.existingDBs)))
+				}
+			} else {
+				s.WriteString(fmt.Sprintf("    Type:          Single Database Restore\n"))
+				s.WriteString(fmt.Sprintf("    Target DB:     %s\n", m.targetDB))
+			}
+
 			s.WriteString("\n")
 		}
 
-		s.WriteString(fmt.Sprintf("\nElapsed Time: %s\n", formatDuration(m.elapsed)))
+		// Timing section
+		s.WriteString(infoStyle.Render("  ─── Timing ────────────────────────────────────────────────"))
+		s.WriteString("\n\n")
+		s.WriteString(fmt.Sprintf("    Total Time:    %s\n", formatDuration(m.elapsed)))
+
+		// Calculate and show throughput if we have size info
+		if m.archive.Size > 0 && m.elapsed.Seconds() > 0 {
+			throughput := float64(m.archive.Size) / m.elapsed.Seconds()
+			s.WriteString(fmt.Sprintf("    Throughput:    %s/s (average)\n", FormatBytes(int64(throughput))))
+		}
+
+		if m.dbTotal > 0 && m.err == nil {
+			avgPerDB := m.elapsed / time.Duration(m.dbTotal)
+			s.WriteString(fmt.Sprintf("    Avg per DB:    %s\n", formatDuration(avgPerDB)))
+		}
+
 		s.WriteString("\n")
-		s.WriteString(infoStyle.Render("[KEYS]  Press Enter to continue"))
+		s.WriteString(infoStyle.Render("  ───────────────────────────────────────────────────────────"))
+		s.WriteString("\n\n")
+		s.WriteString(infoStyle.Render("  [KEYS]  Press Enter to continue"))
 	} else {
 		// Show progress
 		s.WriteString(fmt.Sprintf("Phase: %s\n", m.phase))
@@ -549,13 +624,13 @@ func (m RestoreExecutionModel) View() string {
 			s.WriteString(renderDetailedProgressBarWithSpeed(m.bytesDone, m.bytesTotal, m.speed))
 			s.WriteString("\n\n")
 		} else if m.dbTotal > 0 {
-			// Database count progress for cluster restore
+			// Database count progress for cluster restore with timing
 			spinner := m.spinnerFrames[m.spinnerFrame]
 			s.WriteString(fmt.Sprintf("Status: %s %s\n", spinner, m.status))
 			s.WriteString("\n")
 
-			// Show database progress bar
-			s.WriteString(renderDatabaseProgressBar(m.dbDone, m.dbTotal))
+			// Show database progress bar with timing and ETA
+			s.WriteString(renderDatabaseProgressBarWithTiming(m.dbDone, m.dbTotal, m.dbPhaseElapsed, m.dbAvgPerDB))
 			s.WriteString("\n\n")
 		} else {
 			// Show status with rotating spinner (for phases without detailed progress)
@@ -678,6 +753,55 @@ func renderDatabaseProgressBar(done, total int) string {
 	return s.String()
 }
 
+// renderDatabaseProgressBarWithTiming renders a progress bar for database count with timing and ETA
+func renderDatabaseProgressBarWithTiming(done, total int, phaseElapsed, avgPerDB time.Duration) string {
+	var s strings.Builder
+
+	// Calculate percentage
+	percent := 0
+	if total > 0 {
+		percent = (done * 100) / total
+		if percent > 100 {
+			percent = 100
+		}
+	}
+
+	// Render progress bar
+	width := 30
+	filled := (percent * width) / 100
+	barFilled := strings.Repeat("█", filled)
+	barEmpty := strings.Repeat("░", width-filled)
+
+	s.WriteString(successStyle.Render("["))
+	s.WriteString(successStyle.Render(barFilled))
+	s.WriteString(infoStyle.Render(barEmpty))
+	s.WriteString(successStyle.Render("]"))
+
+	// Count and percentage
+	s.WriteString(fmt.Sprintf("  %3d%%  %d / %d databases", percent, done, total))
+
+	// Timing and ETA
+	if phaseElapsed > 0 {
+		s.WriteString(fmt.Sprintf("  [%s", FormatDurationShort(phaseElapsed)))
+
+		// Calculate ETA based on average time per database
+		if avgPerDB > 0 && done < total {
+			remainingDBs := total - done
+			eta := time.Duration(remainingDBs) * avgPerDB
+			s.WriteString(fmt.Sprintf(" / ETA: %s", FormatDurationShort(eta)))
+		} else if done > 0 && done < total {
+			// Fallback: estimate ETA from overall elapsed time
+			avgElapsed := phaseElapsed / time.Duration(done)
+			remainingDBs := total - done
+			eta := time.Duration(remainingDBs) * avgElapsed
+			s.WriteString(fmt.Sprintf(" / ETA: ~%s", FormatDurationShort(eta)))
+		}
+		s.WriteString("]")
+	}
+
+	return s.String()
+}
+
 // formatDuration formats duration in human readable format
 func formatDuration(d time.Duration) string {
 	if d < time.Minute {