fix(restore): add 100ms delay between database restores

Ensures PostgreSQL fully closes connections before starting next
restore, preventing potential connection pool exhaustion during
rapid sequential cluster restores.

CHANGELOG.md

@@ -5,6 +5,68 @@ 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).
 
+## [3.42.50] - 2026-01-16 "Ctrl+C Signal Handling Fix"
+
+### Fixed - Proper Ctrl+C/SIGINT Handling in TUI
+- **Added tea.InterruptMsg handling** - Bubbletea v1.3+ sends `InterruptMsg` for SIGINT signals
+  instead of a `KeyMsg` with "ctrl+c", causing cancellation to not work
+- **Fixed cluster restore cancellation** - Ctrl+C now properly cancels running restore operations
+- **Fixed cluster backup cancellation** - Ctrl+C now properly cancels running backup operations
+- **Added interrupt handling to main menu** - Proper cleanup on SIGINT from menu
+- **Orphaned process cleanup** - `cleanup.KillOrphanedProcesses()` called on all interrupt paths
+
+### Changed
+- All TUI execution views now handle both `tea.KeyMsg` ("ctrl+c") and `tea.InterruptMsg`
+- Context cancellation properly propagates to child processes via `exec.CommandContext`
+- No zombie pg_dump/pg_restore/gzip processes left behind on cancellation
+
+## [3.42.49] - 2026-01-16 "Unified Cluster Backup Progress"
+
+### Added - Unified Progress Display for Cluster Backup
+- **Combined overall progress bar** for cluster backup showing all phases:
+  - Phase 1/3: Backing up Globals (0-15% of overall)
+  - Phase 2/3: Backing up Databases (15-90% of overall)
+  - Phase 3/3: Compressing Archive (90-100% of overall)
+- **Current database indicator** - Shows which database is currently being backed up
+- **Phase-aware progress tracking** - New fields in backup progress state:
+  - `overallPhase` - Current phase (1=globals, 2=databases, 3=compressing)
+  - `phaseDesc` - Human-readable phase description
+- **Dual progress bars** for cluster backup:
+  - Overall progress bar showing combined operation progress
+  - Database count progress bar showing individual database progress
+
+### Changed
+- Cluster backup TUI now shows unified progress display matching restore
+- Progress callbacks now include phase information
+- Better visual feedback during entire cluster backup operation
+
+## [3.42.48] - 2026-01-15 "Unified Cluster Restore Progress"
+
+### Added - Unified Progress Display for Cluster Restore
+- **Combined overall progress bar** showing progress across all restore phases:
+  - Phase 1/3: Extracting Archive (0-60% of overall)
+  - Phase 2/3: Restoring Globals (60-65% of overall)
+  - Phase 3/3: Restoring Databases (65-100% of overall)
+- **Current database indicator** - Shows which database is currently being restored
+- **Phase-aware progress tracking** - New fields in progress state:
+  - `overallPhase` - Current phase (1=extraction, 2=globals, 3=databases)
+  - `currentDB` - Name of database currently being restored
+  - `extractionDone` - Boolean flag for phase transition
+- **Dual progress bars** for cluster restore:
+  - Overall progress bar showing combined operation progress
+  - Phase-specific progress bar (extraction bytes or database count)
+
+### Changed
+- Cluster restore TUI now shows unified progress display
+- Progress callbacks now set phase and current database information
+- Extraction completion triggers automatic transition to globals phase
+- Database restore phase shows current database name with spinner
+
+### Improved
+- Better visual feedback during entire cluster restore operation
+- Clear phase indicators help users understand restore progress
+- Overall progress percentage gives better time estimates
+
 ## [3.42.35] - 2026-01-15 "TUI Detailed Progress"
 
 ### Added - Enhanced TUI Progress Display

bin/README.md

@@ -3,9 +3,9 @@
 This directory contains pre-compiled binaries for the DB Backup Tool across multiple platforms and architectures.
 
 ## Build Information
-- **Version**: 3.42.34
+- **Version**: 3.42.50
-- **Build Time**: 2026-01-16_13:17:19_UTC
+- **Build Time**: 2026-01-16_14:53:54_UTC
-- **Git Commit**: 9d95a19
+- **Git Commit**: 5728b46
 
 ## Recent Updates (v1.1.0)
 - ✅ Fixed TUI progress display with line-by-line output

internal/dedup/chunker_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"crypto/rand"
 	"io"
+	mathrand "math/rand"
 	"testing"
 )
 
@@ -100,12 +101,15 @@ func TestChunker_Deterministic(t *testing.T) {
 
 func TestChunker_ShiftedData(t *testing.T) {
 	// Test that shifted data still shares chunks (the key CDC benefit)
+	// Use deterministic random data for reproducible test results
+	rng := mathrand.New(mathrand.NewSource(42))
+	
 	original := make([]byte, 100*1024)
-	rand.Read(original)
+	rng.Read(original)
 
 	// Create shifted version (prepend some bytes)
 	prefix := make([]byte, 1000)
-	rand.Read(prefix)
+	rng.Read(prefix)
 	shifted := append(prefix, original...)
 
 	// Chunk both

internal/restore/engine.go

@@ -1203,6 +1203,9 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 			completedDBTimesMu.Unlock()
 
 			atomic.AddInt32(&successCount, 1)
+			
+			// Small delay to ensure PostgreSQL fully closes connections before next restore
+			time.Sleep(100 * time.Millisecond)
 		}(dbIndex, entry.Name())
 
 		dbIndex++

internal/tui/backup_exec.go

@@ -39,6 +39,8 @@ type BackupExecutionModel struct {
 	dbTotal      int
 	dbDone       int
 	dbName       string // Current database being backed up
+	overallPhase int    // 1=globals, 2=databases, 3=compressing
+	phaseDesc    string // Description of current phase
 }
 
 // sharedBackupProgressState holds progress state that can be safely accessed from callbacks
@@ -47,6 +49,8 @@ type sharedBackupProgressState struct {
 	dbTotal      int
 	dbDone       int
 	dbName       string
+	overallPhase int    // 1=globals, 2=databases, 3=compressing
+	phaseDesc    string // Description of current phase
 	hasUpdate    bool
 }
 
@@ -68,12 +72,12 @@ func clearCurrentBackupProgress() {
 	currentBackupProgressState = nil
 }
 
-func getCurrentBackupProgress() (dbTotal, dbDone int, dbName string, hasUpdate bool) {
+func getCurrentBackupProgress() (dbTotal, dbDone int, dbName string, overallPhase int, phaseDesc string, hasUpdate bool) {
 	currentBackupProgressMu.Lock()
 	defer currentBackupProgressMu.Unlock()
 
 	if currentBackupProgressState == nil {
-		return 0, 0, "", false
+		return 0, 0, "", 0, "", false
 	}
 
 	currentBackupProgressState.mu.Lock()
@@ -83,7 +87,8 @@ func getCurrentBackupProgress() (dbTotal, dbDone int, dbName string, hasUpdate b
 	currentBackupProgressState.hasUpdate = false
 
 	return currentBackupProgressState.dbTotal, currentBackupProgressState.dbDone,
-		currentBackupProgressState.dbName, hasUpdate
+		currentBackupProgressState.dbName, currentBackupProgressState.overallPhase,
+		currentBackupProgressState.phaseDesc, hasUpdate
 }
 
 func NewBackupExecution(cfg *config.Config, log logger.Logger, parent tea.Model, ctx context.Context, backupType, dbName string, ratio int) BackupExecutionModel {
@@ -171,6 +176,8 @@ func executeBackupWithTUIProgress(parentCtx context.Context, cfg *config.Config,
 			progressState.dbDone = done
 			progressState.dbTotal = total
 			progressState.dbName = currentDB
+			progressState.overallPhase = 2 // Phase 2: Backing up databases
+			progressState.phaseDesc = fmt.Sprintf("Phase 2/3: Databases (%d/%d)", done, total)
 			progressState.hasUpdate = true
 			progressState.mu.Unlock()
 		})
@@ -223,11 +230,13 @@ func (m BackupExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.spinnerFrame = (m.spinnerFrame + 1) % len(spinnerFrames)
 
 			// Poll for database progress updates from callbacks
-			dbTotal, dbDone, dbName, hasUpdate := getCurrentBackupProgress()
+			dbTotal, dbDone, dbName, overallPhase, phaseDesc, hasUpdate := getCurrentBackupProgress()
 			if hasUpdate {
 				m.dbTotal = dbTotal
 				m.dbDone = dbDone
 				m.dbName = dbName
+				m.overallPhase = overallPhase
+				m.phaseDesc = phaseDesc
 			}
 
 			// Update status based on progress and elapsed time
@@ -286,6 +295,20 @@ func (m BackupExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		return m, nil
 
+	case tea.InterruptMsg:
+		// Handle Ctrl+C signal (SIGINT) - Bubbletea v1.3+ sends this instead of KeyMsg for ctrl+c
+		if !m.done && !m.cancelling {
+			m.cancelling = true
+			m.status = "[STOP]  Cancelling backup... (please wait)"
+			if m.cancel != nil {
+				m.cancel()
+			}
+			return m, nil
+		} else if m.done {
+			return m.parent, tea.Quit
+		}
+		return m, nil
+
 	case tea.KeyMsg:
 		switch msg.String() {
 		case "ctrl+c", "esc":
@@ -361,19 +384,68 @@ func (m BackupExecutionModel) View() string {
 
 	// Status display
 	if !m.done {
-		// Show database progress bar if we have progress data (cluster backup)
+		// Unified progress display for cluster backup
+		if m.backupType == "cluster" {
+			// Calculate overall progress across all phases
+			// Phase 1: Globals (0-15%)
+			// Phase 2: Databases (15-90%)
+			// Phase 3: Compressing (90-100%)
+			overallProgress := 0
+			phaseLabel := "Starting..."
+
+			elapsedSec := int(time.Since(m.startTime).Seconds())
+
+			if m.overallPhase == 2 && m.dbTotal > 0 {
+				// Phase 2: Database backups - contributes 15-90%
+				dbPct := int((int64(m.dbDone) * 100) / int64(m.dbTotal))
+				overallProgress = 15 + (dbPct * 75 / 100)
+				phaseLabel = m.phaseDesc
+			} else if elapsedSec < 5 {
+				// Initial setup
+				overallProgress = 2
+				phaseLabel = "Phase 1/3: Initializing..."
+			} else if m.dbTotal == 0 {
+				// Phase 1: Globals backup (before databases start)
+				overallProgress = 10
+				phaseLabel = "Phase 1/3: Backing up Globals"
+			}
+
+			// Header with phase and overall progress
+			s.WriteString(infoStyle.Render("  ─── Cluster Backup Progress ──────────────────────────────"))
+			s.WriteString("\n\n")
+			s.WriteString(fmt.Sprintf("    %s\n\n", phaseLabel))
+
+			// Overall progress bar
+			s.WriteString("    Overall: ")
+			s.WriteString(renderProgressBar(overallProgress))
+			s.WriteString(fmt.Sprintf("  %d%%\n", overallProgress))
+
+			// Phase-specific details
 			if m.dbTotal > 0 && m.dbDone > 0 {
-			// Show progress bar instead of spinner when we have real progress
+				// Show current database being backed up
+				s.WriteString("\n")
+				spinner := spinnerFrames[m.spinnerFrame]
+				if m.dbName != "" && m.dbDone <= m.dbTotal {
+					s.WriteString(fmt.Sprintf("    Current: %s %s\n", spinner, m.dbName))
+				}
+				s.WriteString("\n")
+
+				// Database progress bar
 				progressBar := renderBackupDatabaseProgressBar(m.dbDone, m.dbTotal, m.dbName, 50)
 				s.WriteString(progressBar + "\n")
-			s.WriteString(fmt.Sprintf("  %s\n", m.status))
 			} else {
-			// Show spinner during initial phases
+				// Intermediate phase (globals)
-			if m.cancelling {
+				spinner := spinnerFrames[m.spinnerFrame]
-				s.WriteString(fmt.Sprintf("  %s %s\n", spinnerFrames[m.spinnerFrame], m.status))
+				s.WriteString(fmt.Sprintf("\n    %s %s\n\n", spinner, m.status))
-			} else {
-				s.WriteString(fmt.Sprintf("  %s %s\n", spinnerFrames[m.spinnerFrame], m.status))
 			}
+
+			s.WriteString("\n")
+			s.WriteString(infoStyle.Render("  ───────────────────────────────────────────────────────────"))
+			s.WriteString("\n\n")
+		} else {
+			// Single/sample database backup - simpler display
+			spinner := spinnerFrames[m.spinnerFrame]
+			s.WriteString(fmt.Sprintf("  %s %s\n", spinner, m.status))
 		}
 
 		if !m.cancelling {

internal/tui/menu.go

@@ -188,6 +188,21 @@ func (m *MenuModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		return m, nil
 
+	case tea.InterruptMsg:
+		// Handle Ctrl+C signal (SIGINT) - Bubbletea v1.3+ sends this
+		if m.cancel != nil {
+			m.cancel()
+		}
+
+		// Clean up any orphaned processes before exit
+		m.logger.Info("Cleaning up processes before exit (SIGINT)")
+		if err := cleanup.KillOrphanedProcesses(m.logger); err != nil {
+			m.logger.Warn("Failed to clean up all processes", "error", err)
+		}
+
+		m.quitting = true
+		return m, tea.Quit
+
 	case tea.KeyMsg:
 		switch msg.String() {
 		case "ctrl+c", "q":

internal/tui/restore_exec.go

@@ -57,10 +57,18 @@ type RestoreExecutionModel struct {
 	dbTotal int
 	dbDone  int
 
+	// Current database being restored (for detailed display)
+	currentDB string
+
 	// 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
 
+	// Overall progress tracking for unified display
+	overallPhase   int // 1=Extracting, 2=Globals, 3=Databases
+	extractionDone bool
+	extractionTime time.Duration // How long extraction took (for ETA calc)
+
 	// Results
 	done       bool
 	cancelling bool // True when user has requested cancellation
@@ -140,10 +148,17 @@ type sharedProgressState struct {
 	dbTotal int
 	dbDone  int
 
+	// Current database being restored
+	currentDB string
+
 	// Timing info for database restore phase
 	dbPhaseElapsed time.Duration // Elapsed time since restore phase started
 	dbAvgPerDB     time.Duration // Average time per database restore
 
+	// Overall phase tracking (1=Extract, 2=Globals, 3=Databases)
+	overallPhase   int
+	extractionDone bool
+
 	// Rolling window for speed calculation
 	speedSamples []restoreSpeedSample
 }
@@ -171,12 +186,12 @@ func clearCurrentRestoreProgress() {
 	currentRestoreProgressState = nil
 }
 
-func getCurrentRestoreProgress() (bytesTotal, bytesDone int64, description string, hasUpdate bool, dbTotal, dbDone int, speed float64, dbPhaseElapsed, dbAvgPerDB time.Duration) {
+func getCurrentRestoreProgress() (bytesTotal, bytesDone int64, description string, hasUpdate bool, dbTotal, dbDone int, speed float64, dbPhaseElapsed, dbAvgPerDB time.Duration, currentDB string, overallPhase int, extractionDone bool) {
 	currentRestoreProgressMu.Lock()
 	defer currentRestoreProgressMu.Unlock()
 
 	if currentRestoreProgressState == nil {
-		return 0, 0, "", false, 0, 0, 0, 0, 0
+		return 0, 0, "", false, 0, 0, 0, 0, 0, "", 0, false
 	}
 
 	currentRestoreProgressState.mu.Lock()
@@ -188,7 +203,9 @@ func getCurrentRestoreProgress() (bytesTotal, bytesDone int64, description strin
 	return currentRestoreProgressState.bytesTotal, currentRestoreProgressState.bytesDone,
 		currentRestoreProgressState.description, currentRestoreProgressState.hasUpdate,
 		currentRestoreProgressState.dbTotal, currentRestoreProgressState.dbDone, speed,
-		currentRestoreProgressState.dbPhaseElapsed, currentRestoreProgressState.dbAvgPerDB
+		currentRestoreProgressState.dbPhaseElapsed, currentRestoreProgressState.dbAvgPerDB,
+		currentRestoreProgressState.currentDB, currentRestoreProgressState.overallPhase,
+		currentRestoreProgressState.extractionDone
 }
 
 // calculateRollingSpeed calculates speed from recent samples (last 5 seconds)
@@ -288,6 +305,14 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 			progressState.bytesTotal = total
 			progressState.description = description
 			progressState.hasUpdate = true
+			progressState.overallPhase = 1
+			progressState.extractionDone = false
+
+			// Check if extraction is complete
+			if current >= total && total > 0 {
+				progressState.extractionDone = true
+				progressState.overallPhase = 2
+			}
 
 			// Add speed sample for rolling window calculation
 			progressState.speedSamples = append(progressState.speedSamples, restoreSpeedSample{
@@ -307,6 +332,9 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 			progressState.dbDone = done
 			progressState.dbTotal = total
 			progressState.description = fmt.Sprintf("Restoring %s", dbName)
+			progressState.currentDB = dbName
+			progressState.overallPhase = 3
+			progressState.extractionDone = true
 			progressState.hasUpdate = true
 			// Clear byte progress when switching to db progress
 			progressState.bytesTotal = 0
@@ -320,6 +348,9 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 			progressState.dbDone = done
 			progressState.dbTotal = total
 			progressState.description = fmt.Sprintf("Restoring %s", dbName)
+			progressState.currentDB = dbName
+			progressState.overallPhase = 3
+			progressState.extractionDone = true
 			progressState.dbPhaseElapsed = phaseElapsed
 			progressState.dbAvgPerDB = avgPerDB
 			progressState.hasUpdate = true
@@ -381,28 +412,46 @@ 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, dbPhaseElapsed, dbAvgPerDB := getCurrentRestoreProgress()
+			bytesTotal, bytesDone, description, hasUpdate, dbTotal, dbDone, speed, dbPhaseElapsed, dbAvgPerDB, currentDB, overallPhase, extractionDone := getCurrentRestoreProgress()
-			if hasUpdate && bytesTotal > 0 {
+			if hasUpdate && bytesTotal > 0 && !extractionDone {
+				// Phase 1: Extraction
 				m.bytesTotal = bytesTotal
 				m.bytesDone = bytesDone
 				m.description = description
 				m.showBytes = true
 				m.speed = speed
+				m.overallPhase = 1
+				m.extractionDone = false
 
 				// Update status to reflect actual progress
 				m.status = description
-				m.phase = "Extracting"
+				m.phase = "Phase 1/3: Extracting Archive"
 				m.progress = int((bytesDone * 100) / bytesTotal)
 			} else if hasUpdate && dbTotal > 0 {
-				// Database count progress for cluster restore with timing
+				// Phase 3: Database restores
 				m.dbTotal = dbTotal
 				m.dbDone = dbDone
 				m.dbPhaseElapsed = dbPhaseElapsed
 				m.dbAvgPerDB = dbAvgPerDB
+				m.currentDB = currentDB
+				m.overallPhase = overallPhase
+				m.extractionDone = extractionDone
 				m.showBytes = false
-				m.status = fmt.Sprintf("Restoring database %d of %d...", dbDone+1, dbTotal)
+
-				m.phase = "Restore"
+				if dbDone < dbTotal {
+					m.status = fmt.Sprintf("Restoring: %s", currentDB)
+				} else {
+					m.status = "Finalizing..."
+				}
+				m.phase = fmt.Sprintf("Phase 3/3: Databases (%d/%d)", dbDone, dbTotal)
 				m.progress = int((dbDone * 100) / dbTotal)
+			} else if hasUpdate && extractionDone && dbTotal == 0 {
+				// Phase 2: Globals restore (brief phase between extraction and databases)
+				m.overallPhase = 2
+				m.extractionDone = true
+				m.showBytes = false
+				m.status = "Restoring global objects (roles, tablespaces)..."
+				m.phase = "Phase 2/3: Restoring Globals"
 			} else {
 				// Fallback: Update status based on elapsed time to show progress
 				// This provides visual feedback even though we don't have real-time progress
@@ -487,6 +536,21 @@ func (m RestoreExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		return m, nil
 
+	case tea.InterruptMsg:
+		// Handle Ctrl+C signal (SIGINT) - Bubbletea v1.3+ sends this instead of KeyMsg for ctrl+c
+		if !m.done && !m.cancelling {
+			m.cancelling = true
+			m.status = "[STOP]  Cancelling restore... (please wait)"
+			m.phase = "Cancelling"
+			if m.cancel != nil {
+				m.cancel()
+			}
+			return m, nil
+		} else if m.done {
+			return m.parent, tea.Quit
+		}
+		return m, nil
+
 	case tea.KeyMsg:
 		switch msg.String() {
 		case "ctrl+c", "esc":
@@ -610,36 +674,88 @@ func (m RestoreExecutionModel) View() string {
 		s.WriteString("\n\n")
 		s.WriteString(infoStyle.Render("  [KEYS]  Press Enter to continue"))
 	} else {
-		// Show progress
+		// Show unified progress for cluster restore
+		if m.restoreType == "restore-cluster" {
+			// Calculate overall progress across all phases
+			// Phase 1: Extraction (0-60%)
+			// Phase 2: Globals (60-65%)
+			// Phase 3: Databases (65-100%)
+			overallProgress := 0
+			phaseLabel := "Starting..."
+
+			if m.showBytes && m.bytesTotal > 0 {
+				// Phase 1: Extraction - contributes 0-60%
+				extractPct := int((m.bytesDone * 100) / m.bytesTotal)
+				overallProgress = (extractPct * 60) / 100
+				phaseLabel = "Phase 1/3: Extracting Archive"
+			} else if m.extractionDone && m.dbTotal == 0 {
+				// Phase 2: Globals restore
+				overallProgress = 62
+				phaseLabel = "Phase 2/3: Restoring Globals"
+			} else if m.dbTotal > 0 {
+				// Phase 3: Database restores - contributes 65-100%
+				dbPct := int((int64(m.dbDone) * 100) / int64(m.dbTotal))
+				overallProgress = 65 + (dbPct * 35 / 100)
+				phaseLabel = fmt.Sprintf("Phase 3/3: Databases (%d/%d)", m.dbDone, m.dbTotal)
+			}
+
+			// Header with phase and overall progress
+			s.WriteString(infoStyle.Render("  ─── Cluster Restore Progress ─────────────────────────────"))
+			s.WriteString("\n\n")
+			s.WriteString(fmt.Sprintf("    %s\n\n", phaseLabel))
+
+			// Overall progress bar
+			s.WriteString("    Overall: ")
+			s.WriteString(renderProgressBar(overallProgress))
+			s.WriteString(fmt.Sprintf("  %d%%\n", overallProgress))
+
+			// Phase-specific details
+			if m.showBytes && m.bytesTotal > 0 {
+				// Show extraction details
+				s.WriteString("\n")
+				s.WriteString(fmt.Sprintf("    %s\n", m.status))
+				s.WriteString("\n")
+				s.WriteString(renderDetailedProgressBarWithSpeed(m.bytesDone, m.bytesTotal, m.speed))
+				s.WriteString("\n")
+			} else if m.dbTotal > 0 {
+				// Show current database being restored
+				s.WriteString("\n")
+				spinner := m.spinnerFrames[m.spinnerFrame]
+				if m.currentDB != "" && m.dbDone < m.dbTotal {
+					s.WriteString(fmt.Sprintf("    Current: %s %s\n", spinner, m.currentDB))
+				} else if m.dbDone >= m.dbTotal {
+					s.WriteString(fmt.Sprintf("    %s Finalizing...\n", spinner))
+				}
+				s.WriteString("\n")
+
+				// Database progress bar with timing
+				s.WriteString(renderDatabaseProgressBarWithTiming(m.dbDone, m.dbTotal, m.dbPhaseElapsed, m.dbAvgPerDB))
+				s.WriteString("\n")
+			} else {
+				// Intermediate phase (globals)
+				spinner := m.spinnerFrames[m.spinnerFrame]
+				s.WriteString(fmt.Sprintf("\n    %s %s\n\n", spinner, m.status))
+			}
+
+			s.WriteString("\n")
+			s.WriteString(infoStyle.Render("  ───────────────────────────────────────────────────────────"))
+			s.WriteString("\n\n")
+		} else {
+			// Single database restore - simpler display
 			s.WriteString(fmt.Sprintf("Phase: %s\n", m.phase))
 
 			// Show detailed progress bar when we have byte-level information
-		// In this case, hide the spinner for cleaner display
 			if m.showBytes && m.bytesTotal > 0 {
-			// Status line without spinner (progress bar provides activity indication)
 				s.WriteString(fmt.Sprintf("Status: %s\n", m.status))
 				s.WriteString("\n")
-
-			// Render schollz-style progress bar with bytes, rolling speed, ETA
 				s.WriteString(renderDetailedProgressBarWithSpeed(m.bytesDone, m.bytesTotal, m.speed))
 				s.WriteString("\n\n")
-		} else if m.dbTotal > 0 {
-			// 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 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)
 				spinner := m.spinnerFrames[m.spinnerFrame]
 				s.WriteString(fmt.Sprintf("Status: %s %s\n", spinner, m.status))
 				s.WriteString("\n")
 
-			if m.restoreType == "restore-single" {
+				// Fallback to simple progress bar
-				// Fallback to simple progress bar for single database restore
 				progressBar := renderProgressBar(m.progress)
 				s.WriteString(progressBar)
 				s.WriteString(fmt.Sprintf("  %d%%\n", m.progress))

main.go

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