fix: max_locks_per_transaction requires PostgreSQL restart

- Fixed critical bug where ALTER SYSTEM + pg_reload_conf() was used
  but max_locks_per_transaction requires a full PostgreSQL restart
- Added automatic restart attempt (systemctl, service, pg_ctl)
- Added loud warnings if restart fails with manual fix instructions
- Updated preflight checks to warn about low max_locks_per_transaction
- This was causing 'out of shared memory' errors on BLOB-heavy restores

CHANGELOG.md

@@ -5,6 +5,36 @@ 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.35] - 2026-01-15 "TUI Detailed Progress"
+
+### Added - Enhanced TUI Progress Display
+- **Detailed progress bar in TUI restore** - schollz-style progress bar with:
+  - Byte progress display (e.g., `245 MB / 1.2 GB`)
+  - Transfer speed calculation (e.g., `45 MB/s`)
+  - ETA prediction for long operations
+  - Unicode block-based visual bar
+- **Real-time extraction progress** - Archive extraction now reports actual bytes processed
+- **Go-native tar extraction** - Uses Go's `archive/tar` + `compress/gzip` when progress callback is set
+- **New `DetailedProgress` component** in TUI package:
+  - `NewDetailedProgress(total, description)` - Byte-based progress
+  - `NewDetailedProgressItems(total, description)` - Item count progress
+  - `NewDetailedProgressSpinner(description)` - Indeterminate spinner
+  - `RenderProgressBar(width)` - Generate schollz-style output
+- **Progress callback API** in restore engine:
+  - `SetProgressCallback(func(current, total int64, description string))` 
+  - Allows TUI to receive real-time progress updates from restore operations
+- **Shared progress state** pattern for Bubble Tea integration
+
+### Changed
+- TUI restore execution now shows detailed byte progress during archive extraction
+- Cluster restore shows extraction progress instead of just spinner
+- Falls back to shell `tar` command when no progress callback is set (faster)
+
+### Technical Details
+- `progressReader` wrapper tracks bytes read through gzip/tar pipeline
+- Throttled progress updates (every 100ms) to avoid UI flooding
+- Thread-safe shared state pattern for cross-goroutine progress updates
+
 ## [3.42.34] - 2026-01-14 "Filesystem Abstraction"
 
 ### Added - spf13/afero for Filesystem Abstraction

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-14_15:59:44_UTC
+- **Build Time**: 2026-01-15_14:33:12_UTC
-- **Git Commit**: ec5e89e
+- **Git Commit**: 09a9177
 
 ## Recent Updates (v1.1.0)
 - ✅ Fixed TUI progress display with line-by-line output

internal/backup/engine.go

@@ -28,14 +28,22 @@ import (
 	"dbbackup/internal/swap"
 )
 
+// ProgressCallback is called with byte-level progress updates during backup operations
+type ProgressCallback func(current, total int64, description string)
+
+// DatabaseProgressCallback is called with database count progress during cluster backup
+type DatabaseProgressCallback func(done, total int, dbName string)
+
 // Engine handles backup operations
 type Engine struct {
-	cfg              *config.Config
+	cfg                *config.Config
-	log              logger.Logger
+	log                logger.Logger
-	db               database.Database
+	db                 database.Database
-	progress         progress.Indicator
+	progress           progress.Indicator
-	detailedReporter *progress.DetailedReporter
+	detailedReporter   *progress.DetailedReporter
-	silent           bool // Silent mode for TUI
+	silent             bool // Silent mode for TUI
+	progressCallback   ProgressCallback
+	dbProgressCallback DatabaseProgressCallback
 }
 
 // New creates a new backup engine
@@ -86,6 +94,30 @@ func NewSilent(cfg *config.Config, log logger.Logger, db database.Database, prog
 	}
 }
 
+// SetProgressCallback sets a callback for detailed progress reporting (for TUI mode)
+func (e *Engine) SetProgressCallback(cb ProgressCallback) {
+	e.progressCallback = cb
+}
+
+// SetDatabaseProgressCallback sets a callback for database count progress during cluster backup
+func (e *Engine) SetDatabaseProgressCallback(cb DatabaseProgressCallback) {
+	e.dbProgressCallback = cb
+}
+
+// reportProgress reports progress to the callback if set
+func (e *Engine) reportProgress(current, total int64, description string) {
+	if e.progressCallback != nil {
+		e.progressCallback(current, total, description)
+	}
+}
+
+// reportDatabaseProgress reports database count progress to the callback if set
+func (e *Engine) reportDatabaseProgress(done, total int, dbName string) {
+	if e.dbProgressCallback != nil {
+		e.dbProgressCallback(done, total, dbName)
+	}
+}
+
 // loggerAdapter adapts our logger to the progress.Logger interface
 type loggerAdapter struct {
 	logger logger.Logger
@@ -465,6 +497,8 @@ func (e *Engine) BackupCluster(ctx context.Context) error {
 			estimator.UpdateProgress(idx)
 			e.printf("   [%d/%d] Backing up database: %s\n", idx+1, len(databases), name)
 			quietProgress.Update(fmt.Sprintf("Backing up database %d/%d: %s", idx+1, len(databases), name))
+			// Report database progress to TUI callback
+			e.reportDatabaseProgress(idx+1, len(databases), name)
 			mu.Unlock()
 
 			// Check database size and warn if very large

internal/restore/diagnose.go

@@ -368,7 +368,7 @@ func (d *Diagnoser) diagnoseSQLScript(filePath string, compressed bool, result *
 		}
 
 		// Store last line for termination check
-		if lineNumber > 0 && (lineNumber%100000 == 0) && d.verbose {
+		if lineNumber > 0 && (lineNumber%100000 == 0) && d.verbose && d.log != nil {
 			d.log.Debug("Scanning SQL file", "lines_processed", lineNumber)
 		}
 	}
@@ -430,9 +430,11 @@ func (d *Diagnoser) diagnoseClusterArchive(filePath string, result *DiagnoseResu
 		}
 	}
 
-	d.log.Info("Verifying cluster archive integrity",
+	if d.log != nil {
-		"size", fmt.Sprintf("%.1f GB", float64(result.FileSize)/(1024*1024*1024)),
+		d.log.Info("Verifying cluster archive integrity",
-		"timeout", fmt.Sprintf("%d min", timeoutMinutes))
+			"size", fmt.Sprintf("%.1f GB", float64(result.FileSize)/(1024*1024*1024)),
+			"timeout", fmt.Sprintf("%d min", timeoutMinutes))
+	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeoutMinutes)*time.Minute)
 	defer cancel()
@@ -561,7 +563,7 @@ func (d *Diagnoser) diagnoseClusterArchive(filePath string, result *DiagnoseResu
 	}
 
 	// For verbose mode, diagnose individual dumps inside the archive
-	if d.verbose && len(dumpFiles) > 0 {
+	if d.verbose && len(dumpFiles) > 0 && d.log != nil {
 		d.log.Info("Cluster archive contains databases", "count", len(dumpFiles))
 		for _, df := range dumpFiles {
 			d.log.Info("  - " + df)
@@ -684,9 +686,11 @@ func (d *Diagnoser) DiagnoseClusterDumps(archivePath, tempDir string) ([]*Diagno
 		}
 	}
 
-	d.log.Info("Listing cluster archive contents",
+	if d.log != nil {
-		"size", fmt.Sprintf("%.1f GB", float64(archiveInfo.Size())/(1024*1024*1024)),
+		d.log.Info("Listing cluster archive contents",
-		"timeout", fmt.Sprintf("%d min", timeoutMinutes))
+			"size", fmt.Sprintf("%.1f GB", float64(archiveInfo.Size())/(1024*1024*1024)),
+			"timeout", fmt.Sprintf("%d min", timeoutMinutes))
+	}
 
 	listCtx, listCancel := context.WithTimeout(context.Background(), time.Duration(timeoutMinutes)*time.Minute)
 	defer listCancel()
@@ -766,7 +770,9 @@ func (d *Diagnoser) DiagnoseClusterDumps(archivePath, tempDir string) ([]*Diagno
 		return []*DiagnoseResult{errResult}, nil
 	}
 
-	d.log.Debug("Archive listing streamed successfully", "total_files", fileCount, "relevant_files", len(files))
+	if d.log != nil {
+		d.log.Debug("Archive listing streamed successfully", "total_files", fileCount, "relevant_files", len(files))
+	}
 
 	// Check if we have enough disk space (estimate 4x archive size needed)
 	// archiveInfo already obtained at function start
@@ -781,7 +787,9 @@ func (d *Diagnoser) DiagnoseClusterDumps(archivePath, tempDir string) ([]*Diagno
 		testCancel()
 	}
 
-	d.log.Info("Archive listing successful", "files", len(files))
+	if d.log != nil {
+		d.log.Info("Archive listing successful", "files", len(files))
+	}
 
 	// Try full extraction - NO TIMEOUT here as large archives can take a long time
 	// Use a generous timeout (30 minutes) for very large archives
@@ -870,11 +878,15 @@ func (d *Diagnoser) DiagnoseClusterDumps(archivePath, tempDir string) ([]*Diagno
 		}
 
 		dumpPath := filepath.Join(dumpsDir, name)
-		d.log.Info("Diagnosing dump file", "file", name)
+		if d.log != nil {
+			d.log.Info("Diagnosing dump file", "file", name)
+		}
 
 		result, err := d.DiagnoseFile(dumpPath)
 		if err != nil {
-			d.log.Warn("Failed to diagnose file", "file", name, "error", err)
+			if d.log != nil {
+				d.log.Warn("Failed to diagnose file", "file", name, "error", err)
+			}
 			continue
 		}
 		results = append(results, result)

internal/restore/engine.go

@@ -1,9 +1,12 @@
 package restore
 
 import (
+	"archive/tar"
+	"compress/gzip"
 	"context"
 	"database/sql"
 	"fmt"
+	"io"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -24,6 +27,13 @@ import (
 	_ "github.com/jackc/pgx/v5/stdlib" // PostgreSQL driver
 )
 
+// ProgressCallback is called with progress updates during long operations
+// Parameters: current bytes/items done, total bytes/items, description
+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)
+
 // Engine handles database restore operations
 type Engine struct {
 	cfg              *config.Config
@@ -33,6 +43,10 @@ type Engine struct {
 	detailedReporter *progress.DetailedReporter
 	dryRun           bool
 	debugLogPath     string // Path to save debug log on error
+
+	// TUI progress callback for detailed progress reporting
+	progressCallback   ProgressCallback
+	dbProgressCallback DatabaseProgressCallback
 }
 
 // New creates a new restore engine
@@ -88,6 +102,30 @@ func (e *Engine) SetDebugLogPath(path string) {
 	e.debugLogPath = path
 }
 
+// SetProgressCallback sets a callback for detailed progress reporting (for TUI mode)
+func (e *Engine) SetProgressCallback(cb ProgressCallback) {
+	e.progressCallback = cb
+}
+
+// SetDatabaseProgressCallback sets a callback for database count progress during cluster restore
+func (e *Engine) SetDatabaseProgressCallback(cb DatabaseProgressCallback) {
+	e.dbProgressCallback = cb
+}
+
+// reportProgress safely calls the progress callback if set
+func (e *Engine) reportProgress(current, total int64, description string) {
+	if e.progressCallback != nil {
+		e.progressCallback(current, total, description)
+	}
+}
+
+// reportDatabaseProgress safely calls the database progress callback if set
+func (e *Engine) reportDatabaseProgress(done, total int, dbName string) {
+	if e.dbProgressCallback != nil {
+		e.dbProgressCallback(done, total, dbName)
+	}
+}
+
 // loggerAdapter adapts our logger to the progress.Logger interface
 type loggerAdapter struct {
 	logger logger.Logger
@@ -1040,6 +1078,8 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 			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
+			e.reportDatabaseProgress(idx, totalDBs, dbName)
 			mu.Unlock()
 
 			// STEP 1: Drop existing database completely (clean slate)
@@ -1146,8 +1186,144 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 	return nil
 }
 
-// extractArchive extracts a tar.gz archive
+// extractArchive extracts a tar.gz archive with progress reporting
 func (e *Engine) extractArchive(ctx context.Context, archivePath, destDir string) error {
+	// If progress callback is set, use Go's archive/tar for progress tracking
+	if e.progressCallback != nil {
+		return e.extractArchiveWithProgress(ctx, archivePath, destDir)
+	}
+
+	// Otherwise use fast shell tar (no progress)
+	return e.extractArchiveShell(ctx, archivePath, destDir)
+}
+
+// extractArchiveWithProgress extracts using Go's archive/tar with detailed progress reporting
+func (e *Engine) extractArchiveWithProgress(ctx context.Context, archivePath, destDir string) error {
+	// Get archive size for progress calculation
+	archiveInfo, err := os.Stat(archivePath)
+	if err != nil {
+		return fmt.Errorf("failed to stat archive: %w", err)
+	}
+	totalSize := archiveInfo.Size()
+
+	// Open the archive file
+	file, err := os.Open(archivePath)
+	if err != nil {
+		return fmt.Errorf("failed to open archive: %w", err)
+	}
+	defer file.Close()
+
+	// Wrap with progress reader
+	progressReader := &progressReader{
+		reader:    file,
+		totalSize: totalSize,
+		callback:  e.progressCallback,
+		desc:      "Extracting archive",
+	}
+
+	// Create gzip reader
+	gzReader, err := gzip.NewReader(progressReader)
+	if err != nil {
+		return fmt.Errorf("failed to create gzip reader: %w", err)
+	}
+	defer gzReader.Close()
+
+	// Create tar reader
+	tarReader := tar.NewReader(gzReader)
+
+	// Extract files
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+		}
+
+		header, err := tarReader.Next()
+		if err == io.EOF {
+			break // End of archive
+		}
+		if err != nil {
+			return fmt.Errorf("failed to read tar header: %w", err)
+		}
+
+		// Sanitize and validate path
+		targetPath := filepath.Join(destDir, header.Name)
+
+		// Security check: ensure path is within destDir (prevent path traversal)
+		if !strings.HasPrefix(filepath.Clean(targetPath), filepath.Clean(destDir)) {
+			e.log.Warn("Skipping potentially malicious path in archive", "path", header.Name)
+			continue
+		}
+
+		switch header.Typeflag {
+		case tar.TypeDir:
+			if err := os.MkdirAll(targetPath, 0755); err != nil {
+				return fmt.Errorf("failed to create directory %s: %w", targetPath, err)
+			}
+		case tar.TypeReg:
+			// Ensure parent directory exists
+			if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
+				return fmt.Errorf("failed to create parent directory: %w", err)
+			}
+
+			// Create the file
+			outFile, err := os.OpenFile(targetPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.FileMode(header.Mode))
+			if err != nil {
+				return fmt.Errorf("failed to create file %s: %w", targetPath, err)
+			}
+
+			// Copy file contents
+			if _, err := io.Copy(outFile, tarReader); err != nil {
+				outFile.Close()
+				return fmt.Errorf("failed to write file %s: %w", targetPath, err)
+			}
+			outFile.Close()
+		case tar.TypeSymlink:
+			// Handle symlinks (common in some archives)
+			if err := os.Symlink(header.Linkname, targetPath); err != nil {
+				// Ignore symlink errors (may already exist or not supported)
+				e.log.Debug("Could not create symlink", "path", targetPath, "target", header.Linkname)
+			}
+		}
+	}
+
+	// Final progress update
+	e.reportProgress(totalSize, totalSize, "Extraction complete")
+	return nil
+}
+
+// progressReader wraps an io.Reader to report read progress
+type progressReader struct {
+	reader      io.Reader
+	totalSize   int64
+	bytesRead   int64
+	callback    ProgressCallback
+	desc        string
+	lastReport  time.Time
+	reportEvery time.Duration
+}
+
+func (pr *progressReader) Read(p []byte) (n int, err error) {
+	n, err = pr.reader.Read(p)
+	pr.bytesRead += int64(n)
+
+	// Throttle progress reporting to every 100ms
+	if pr.reportEvery == 0 {
+		pr.reportEvery = 100 * time.Millisecond
+	}
+	if time.Since(pr.lastReport) > pr.reportEvery {
+		if pr.callback != nil {
+			pr.callback(pr.bytesRead, pr.totalSize, pr.desc)
+		}
+		pr.lastReport = time.Now()
+	}
+
+	return n, err
+}
+
+// extractArchiveShell extracts using shell tar command (faster but no progress)
+func (e *Engine) extractArchiveShell(ctx context.Context, archivePath, destDir string) error {
 	cmd := exec.CommandContext(ctx, "tar", "-xzf", archivePath, "-C", destDir)
 
 	// Stream stderr to avoid memory issues - tar can produce lots of output for large archives
@@ -1761,6 +1937,8 @@ type OriginalSettings struct {
 }
 
 // boostPostgreSQLSettings boosts multiple PostgreSQL settings for large restores
+// NOTE: max_locks_per_transaction requires a PostgreSQL RESTART to take effect!
+// maintenance_work_mem can be changed with pg_reload_conf().
 func (e *Engine) boostPostgreSQLSettings(ctx context.Context, lockBoostValue int) (*OriginalSettings, error) {
 	connStr := e.buildConnString()
 	db, err := sql.Open("pgx", connStr)
@@ -1780,30 +1958,113 @@ func (e *Engine) boostPostgreSQLSettings(ctx context.Context, lockBoostValue int
 	// Get current maintenance_work_mem
 	db.QueryRowContext(ctx, "SHOW maintenance_work_mem").Scan(&original.MaintenanceWorkMem)
 
-	// Boost max_locks_per_transaction (if not already high enough)
+	// CRITICAL: max_locks_per_transaction requires a PostgreSQL RESTART!
+	// pg_reload_conf() is NOT sufficient for this parameter.
+	needsRestart := false
 	if original.MaxLocks < lockBoostValue {
 		_, err = db.ExecContext(ctx, fmt.Sprintf("ALTER SYSTEM SET max_locks_per_transaction = %d", lockBoostValue))
 		if err != nil {
-			e.log.Warn("Could not boost max_locks_per_transaction", "error", err)
+			e.log.Warn("Could not set max_locks_per_transaction", "error", err)
+		} else {
+			needsRestart = true
+			e.log.Warn("max_locks_per_transaction requires PostgreSQL restart to take effect",
+				"current", original.MaxLocks,
+				"target", lockBoostValue)
 		}
 	}
 
 	// Boost maintenance_work_mem to 2GB for faster index creation
+	// (this one CAN be applied via pg_reload_conf)
 	_, err = db.ExecContext(ctx, "ALTER SYSTEM SET maintenance_work_mem = '2GB'")
 	if err != nil {
 		e.log.Warn("Could not boost maintenance_work_mem", "error", err)
 	}
 
-	// Reload config to apply changes (no restart needed for these settings)
+	// Reload config to apply maintenance_work_mem
 	_, err = db.ExecContext(ctx, "SELECT pg_reload_conf()")
 	if err != nil {
 		return original, fmt.Errorf("failed to reload config: %w", err)
 	}
 
+	// If max_locks_per_transaction needs a restart, try to do it
+	if needsRestart {
+		if restarted := e.tryRestartPostgreSQL(ctx); restarted {
+			e.log.Info("PostgreSQL restarted successfully - max_locks_per_transaction now active")
+			// 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
+		}
+	}
+
 	return original, nil
 }
 
+// tryRestartPostgreSQL attempts to restart PostgreSQL using various methods
+// Returns true if restart was successful
+func (e *Engine) tryRestartPostgreSQL(ctx context.Context) bool {
+	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 {
+		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 {
+			return true
+		}
+	}
+
+	// Method 3: service command (older systems)
+	cmd = exec.CommandContext(ctx, "sudo", "service", "postgresql", "restart")
+	if err := cmd.Run(); err == nil {
+		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 {
+		return true
+	}
+
+	// Method 5: Try common PGDATA paths
+	pgdataPaths := []string{
+		"/var/lib/pgsql/data",
+		"/var/lib/pgsql/17/data",
+		"/var/lib/pgsql/16/data",
+		"/var/lib/pgsql/15/data",
+		"/var/lib/postgresql/17/main",
+		"/var/lib/postgresql/16/main",
+		"/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 {
+			return true
+		}
+	}
+
+	return false
+}
+
 // resetPostgreSQLSettings restores original PostgreSQL settings
+// NOTE: max_locks_per_transaction changes are written but require restart to take effect.
+// We don't restart here since we're done with the restore.
 func (e *Engine) resetPostgreSQLSettings(ctx context.Context, original *OriginalSettings) error {
 	connStr := e.buildConnString()
 	db, err := sql.Open("pgx", connStr)
@@ -1812,25 +2073,28 @@ func (e *Engine) resetPostgreSQLSettings(ctx context.Context, original *Original
 	}
 	defer db.Close()
 
-	// Reset max_locks_per_transaction
+	// Reset max_locks_per_transaction (will take effect on next restart)
 	if original.MaxLocks == 64 { // Default
 		db.ExecContext(ctx, "ALTER SYSTEM RESET max_locks_per_transaction")
 	} else if original.MaxLocks > 0 {
 		db.ExecContext(ctx, fmt.Sprintf("ALTER SYSTEM SET max_locks_per_transaction = %d", original.MaxLocks))
 	}
 
-	// Reset maintenance_work_mem
+	// Reset maintenance_work_mem (takes effect immediately with reload)
 	if original.MaintenanceWorkMem == "64MB" { // Default
 		db.ExecContext(ctx, "ALTER SYSTEM RESET maintenance_work_mem")
 	} else if original.MaintenanceWorkMem != "" {
 		db.ExecContext(ctx, fmt.Sprintf("ALTER SYSTEM SET maintenance_work_mem = '%s'", original.MaintenanceWorkMem))
 	}
 
-	// Reload config
+	// Reload config (only maintenance_work_mem will take effect immediately)
 	_, err = db.ExecContext(ctx, "SELECT pg_reload_conf()")
 	if err != nil {
 		return fmt.Errorf("failed to reload config: %w", err)
 	}
 
+	e.log.Info("PostgreSQL settings reset queued",
+		"note", "max_locks_per_transaction will revert on next PostgreSQL restart")
+
 	return nil
 }

internal/restore/preflight.go

@@ -201,10 +201,19 @@ func (e *Engine) checkPostgreSQL(ctx context.Context, result *PreflightResult) {
 		result.PostgreSQL.IsSuperuser = isSuperuser
 	}
 
-	// Add info/warnings
+	// CRITICAL: max_locks_per_transaction requires PostgreSQL RESTART to change!
+	// Warn users loudly about this - it's the #1 cause of "out of shared memory" errors
 	if result.PostgreSQL.MaxLocksPerTransaction < 256 {
-		e.log.Info("PostgreSQL max_locks_per_transaction is low - will auto-boost",
+		e.log.Warn("PostgreSQL max_locks_per_transaction is LOW",
-			"current", result.PostgreSQL.MaxLocksPerTransaction)
+			"current", result.PostgreSQL.MaxLocksPerTransaction,
+			"recommended", "256+",
+			"note", "REQUIRES PostgreSQL restart to change!")
+
+		result.Warnings = append(result.Warnings,
+			fmt.Sprintf("max_locks_per_transaction=%d is low (recommend 256+). "+
+				"This setting requires PostgreSQL RESTART to change. "+
+				"BLOB-heavy databases may fail with 'out of shared memory' error.",
+				result.PostgreSQL.MaxLocksPerTransaction))
 	}
 
 	// Parse shared_buffers and warn if very low

internal/restore/safety.go

@@ -255,7 +255,9 @@ func (s *Safety) CheckDiskSpaceAt(archivePath string, checkDir string, multiplie
 	// Get available disk space
 	availableSpace, err := getDiskSpace(checkDir)
 	if err != nil {
-		s.log.Warn("Cannot check disk space", "error", err)
+		if s.log != nil {
+			s.log.Warn("Cannot check disk space", "error", err)
+		}
 		return nil // Don't fail if we can't check
 	}
 
@@ -278,10 +280,12 @@ func (s *Safety) CheckDiskSpaceAt(archivePath string, checkDir string, multiplie
 			checkDir)
 	}
 
-	s.log.Info("Disk space check passed",
+	if s.log != nil {
-		"location", checkDir,
+		s.log.Info("Disk space check passed",
-		"required", FormatBytes(requiredSpace),
+			"location", checkDir,
-		"available", FormatBytes(availableSpace))
+			"required", FormatBytes(requiredSpace),
+			"available", FormatBytes(availableSpace))
+	}
 
 	return nil
 }

internal/tui/backup_exec.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"strings"
+	"sync"
 	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
@@ -33,6 +34,56 @@ type BackupExecutionModel struct {
 	startTime    time.Time
 	details      []string
 	spinnerFrame int
+
+	// Database count progress (for cluster backup)
+	dbTotal int
+	dbDone  int
+	dbName  string // Current database being backed up
+}
+
+// sharedBackupProgressState holds progress state that can be safely accessed from callbacks
+type sharedBackupProgressState struct {
+	mu        sync.Mutex
+	dbTotal   int
+	dbDone    int
+	dbName    string
+	hasUpdate bool
+}
+
+// Package-level shared progress state for backup operations
+var (
+	currentBackupProgressMu    sync.Mutex
+	currentBackupProgressState *sharedBackupProgressState
+)
+
+func setCurrentBackupProgress(state *sharedBackupProgressState) {
+	currentBackupProgressMu.Lock()
+	defer currentBackupProgressMu.Unlock()
+	currentBackupProgressState = state
+}
+
+func clearCurrentBackupProgress() {
+	currentBackupProgressMu.Lock()
+	defer currentBackupProgressMu.Unlock()
+	currentBackupProgressState = nil
+}
+
+func getCurrentBackupProgress() (dbTotal, dbDone int, dbName string, hasUpdate bool) {
+	currentBackupProgressMu.Lock()
+	defer currentBackupProgressMu.Unlock()
+
+	if currentBackupProgressState == nil {
+		return 0, 0, "", false
+	}
+
+	currentBackupProgressState.mu.Lock()
+	defer currentBackupProgressState.mu.Unlock()
+
+	hasUpdate = currentBackupProgressState.hasUpdate
+	currentBackupProgressState.hasUpdate = false
+
+	return currentBackupProgressState.dbTotal, currentBackupProgressState.dbDone,
+		currentBackupProgressState.dbName, hasUpdate
 }
 
 func NewBackupExecution(cfg *config.Config, log logger.Logger, parent tea.Model, ctx context.Context, backupType, dbName string, ratio int) BackupExecutionModel {
@@ -55,7 +106,6 @@ func NewBackupExecution(cfg *config.Config, log logger.Logger, parent tea.Model,
 }
 
 func (m BackupExecutionModel) Init() tea.Cmd {
-	// TUI handles all display through View() - no progress callbacks needed
 	return tea.Batch(
 		executeBackupWithTUIProgress(m.ctx, m.config, m.logger, m.backupType, m.databaseName, m.ratio),
 		backupTickCmd(),
@@ -91,6 +141,11 @@ func executeBackupWithTUIProgress(parentCtx context.Context, cfg *config.Config,
 
 		start := time.Now()
 
+		// Setup shared progress state for TUI polling
+		progressState := &sharedBackupProgressState{}
+		setCurrentBackupProgress(progressState)
+		defer clearCurrentBackupProgress()
+
 		dbClient, err := database.New(cfg, log)
 		if err != nil {
 			return backupCompleteMsg{
@@ -110,6 +165,16 @@ func executeBackupWithTUIProgress(parentCtx context.Context, cfg *config.Config,
 		// Pass nil as indicator - TUI itself handles all display, no stdout printing
 		engine := backup.NewSilent(cfg, log, dbClient, nil)
 
+		// Set database progress callback for cluster backups
+		engine.SetDatabaseProgressCallback(func(done, total int, currentDB string) {
+			progressState.mu.Lock()
+			progressState.dbDone = done
+			progressState.dbTotal = total
+			progressState.dbName = currentDB
+			progressState.hasUpdate = true
+			progressState.mu.Unlock()
+		})
+
 		var backupErr error
 		switch backupType {
 		case "single":
@@ -157,10 +222,21 @@ func (m BackupExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			// Increment spinner frame for smooth animation
 			m.spinnerFrame = (m.spinnerFrame + 1) % len(spinnerFrames)
 
-			// Update status based on elapsed time to show progress
+			// Poll for database progress updates from callbacks
+			dbTotal, dbDone, dbName, hasUpdate := getCurrentBackupProgress()
+			if hasUpdate {
+				m.dbTotal = dbTotal
+				m.dbDone = dbDone
+				m.dbName = dbName
+			}
+
+			// Update status based on progress and elapsed time
 			elapsedSec := int(time.Since(m.startTime).Seconds())
 
-			if elapsedSec < 2 {
+			if m.dbTotal > 0 && m.dbDone > 0 {
+				// We have real progress from cluster backup
+				m.status = fmt.Sprintf("Backing up database: %s", m.dbName)
+			} else if elapsedSec < 2 {
 				m.status = "Initializing backup..."
 			} else if elapsedSec < 5 {
 				if m.backupType == "cluster" {
@@ -234,6 +310,34 @@ func (m BackupExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	return m, nil
 }
 
+// renderDatabaseProgressBar renders a progress bar for database count progress
+func renderBackupDatabaseProgressBar(done, total int, dbName string, width int) string {
+	if total == 0 {
+		return ""
+	}
+
+	// Calculate progress percentage
+	percent := float64(done) / float64(total)
+	if percent > 1.0 {
+		percent = 1.0
+	}
+
+	// Calculate filled width
+	barWidth := width - 20 // Leave room for label and percentage
+	if barWidth < 10 {
+		barWidth = 10
+	}
+	filled := int(float64(barWidth) * percent)
+	if filled > barWidth {
+		filled = barWidth
+	}
+
+	// Build progress bar
+	bar := strings.Repeat("█", filled) + strings.Repeat("░", barWidth-filled)
+
+	return fmt.Sprintf("  Database: [%s] %d/%d", bar, done, total)
+}
+
 func (m BackupExecutionModel) View() string {
 	var s strings.Builder
 	s.Grow(512) // Pre-allocate estimated capacity for better performance
@@ -255,12 +359,24 @@ func (m BackupExecutionModel) View() string {
 	s.WriteString(fmt.Sprintf("  %-10s %s\n", "Duration:", time.Since(m.startTime).Round(time.Second)))
 	s.WriteString("\n")
 
-	// Status with spinner
+	// Status display
 	if !m.done {
-		if m.cancelling {
+		// Show database progress bar if we have progress data (cluster backup)
-			s.WriteString(fmt.Sprintf("  %s %s\n", spinnerFrames[m.spinnerFrame], m.status))
+		if m.dbTotal > 0 && m.dbDone > 0 {
+			// Show progress bar instead of spinner when we have real progress
+			progressBar := renderBackupDatabaseProgressBar(m.dbDone, m.dbTotal, m.dbName, 50)
+			s.WriteString(progressBar + "\n")
+			s.WriteString(fmt.Sprintf("  %s\n", m.status))
 		} else {
-			s.WriteString(fmt.Sprintf("  %s %s\n", spinnerFrames[m.spinnerFrame], m.status))
+			// Show spinner during initial phases
+			if m.cancelling {
+				s.WriteString(fmt.Sprintf("  %s %s\n", spinnerFrames[m.spinnerFrame], m.status))
+			} else {
+				s.WriteString(fmt.Sprintf("  %s %s\n", spinnerFrames[m.spinnerFrame], m.status))
+			}
+		}
+
+		if !m.cancelling {
 			s.WriteString("\n  [KEY]  Press Ctrl+C or ESC to cancel\n")
 		}
 	} else {

internal/tui/detailed_progress.go

@@ -0,0 +1,406 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+)
+
+// DetailedProgress provides schollz-like progress information for TUI rendering
+// This is a data structure that can be queried by Bubble Tea's View() method
+type DetailedProgress struct {
+	mu sync.RWMutex
+
+	// Core progress
+	Total   int64 // Total bytes or items
+	Current int64 // Current bytes or items done
+
+	// Display info
+	Description string // What operation is happening
+	Unit        string // "bytes", "files", "databases", etc.
+
+	// Timing for ETA/speed calculation
+	StartTime   time.Time
+	LastUpdate  time.Time
+	SpeedWindow []speedSample // Rolling window for speed calculation
+
+	// State
+	IsIndeterminate bool // True if total is unknown (spinner mode)
+	IsComplete      bool
+	IsFailed        bool
+	ErrorMessage    string
+}
+
+type speedSample struct {
+	timestamp time.Time
+	bytes     int64
+}
+
+// NewDetailedProgress creates a progress tracker with known total
+func NewDetailedProgress(total int64, description string) *DetailedProgress {
+	return &DetailedProgress{
+		Total:           total,
+		Description:     description,
+		Unit:            "bytes",
+		StartTime:       time.Now(),
+		LastUpdate:      time.Now(),
+		SpeedWindow:     make([]speedSample, 0, 20),
+		IsIndeterminate: total <= 0,
+	}
+}
+
+// NewDetailedProgressItems creates a progress tracker for item counts
+func NewDetailedProgressItems(total int, description string) *DetailedProgress {
+	return &DetailedProgress{
+		Total:           int64(total),
+		Description:     description,
+		Unit:            "items",
+		StartTime:       time.Now(),
+		LastUpdate:      time.Now(),
+		SpeedWindow:     make([]speedSample, 0, 20),
+		IsIndeterminate: total <= 0,
+	}
+}
+
+// NewDetailedProgressSpinner creates an indeterminate progress tracker
+func NewDetailedProgressSpinner(description string) *DetailedProgress {
+	return &DetailedProgress{
+		Total:           -1,
+		Description:     description,
+		Unit:            "",
+		StartTime:       time.Now(),
+		LastUpdate:      time.Now(),
+		SpeedWindow:     make([]speedSample, 0, 20),
+		IsIndeterminate: true,
+	}
+}
+
+// Add adds to the current progress
+func (dp *DetailedProgress) Add(n int64) {
+	dp.mu.Lock()
+	defer dp.mu.Unlock()
+
+	dp.Current += n
+	dp.LastUpdate = time.Now()
+
+	// Add speed sample
+	dp.SpeedWindow = append(dp.SpeedWindow, speedSample{
+		timestamp: dp.LastUpdate,
+		bytes:     dp.Current,
+	})
+
+	// Keep only last 20 samples for speed calculation
+	if len(dp.SpeedWindow) > 20 {
+		dp.SpeedWindow = dp.SpeedWindow[len(dp.SpeedWindow)-20:]
+	}
+}
+
+// Set sets the current progress to a specific value
+func (dp *DetailedProgress) Set(n int64) {
+	dp.mu.Lock()
+	defer dp.mu.Unlock()
+
+	dp.Current = n
+	dp.LastUpdate = time.Now()
+
+	// Add speed sample
+	dp.SpeedWindow = append(dp.SpeedWindow, speedSample{
+		timestamp: dp.LastUpdate,
+		bytes:     dp.Current,
+	})
+
+	if len(dp.SpeedWindow) > 20 {
+		dp.SpeedWindow = dp.SpeedWindow[len(dp.SpeedWindow)-20:]
+	}
+}
+
+// SetTotal updates the total (useful when total becomes known during operation)
+func (dp *DetailedProgress) SetTotal(total int64) {
+	dp.mu.Lock()
+	defer dp.mu.Unlock()
+
+	dp.Total = total
+	dp.IsIndeterminate = total <= 0
+}
+
+// SetDescription updates the description
+func (dp *DetailedProgress) SetDescription(desc string) {
+	dp.mu.Lock()
+	defer dp.mu.Unlock()
+	dp.Description = desc
+}
+
+// Complete marks the progress as complete
+func (dp *DetailedProgress) Complete() {
+	dp.mu.Lock()
+	defer dp.mu.Unlock()
+
+	dp.IsComplete = true
+	dp.Current = dp.Total
+}
+
+// Fail marks the progress as failed
+func (dp *DetailedProgress) Fail(errMsg string) {
+	dp.mu.Lock()
+	defer dp.mu.Unlock()
+
+	dp.IsFailed = true
+	dp.ErrorMessage = errMsg
+}
+
+// GetPercent returns the progress percentage (0-100)
+func (dp *DetailedProgress) GetPercent() int {
+	dp.mu.RLock()
+	defer dp.mu.RUnlock()
+
+	if dp.IsIndeterminate || dp.Total <= 0 {
+		return 0
+	}
+	percent := int((dp.Current * 100) / dp.Total)
+	if percent > 100 {
+		return 100
+	}
+	return percent
+}
+
+// GetSpeed returns the current transfer speed in bytes/second
+func (dp *DetailedProgress) GetSpeed() float64 {
+	dp.mu.RLock()
+	defer dp.mu.RUnlock()
+
+	if len(dp.SpeedWindow) < 2 {
+		return 0
+	}
+
+	// Use first and last samples in window for smoothed speed
+	first := dp.SpeedWindow[0]
+	last := dp.SpeedWindow[len(dp.SpeedWindow)-1]
+
+	elapsed := last.timestamp.Sub(first.timestamp).Seconds()
+	if elapsed <= 0 {
+		return 0
+	}
+
+	bytesTransferred := last.bytes - first.bytes
+	return float64(bytesTransferred) / elapsed
+}
+
+// GetETA returns the estimated time remaining
+func (dp *DetailedProgress) GetETA() time.Duration {
+	dp.mu.RLock()
+	defer dp.mu.RUnlock()
+
+	if dp.IsIndeterminate || dp.Total <= 0 || dp.Current >= dp.Total {
+		return 0
+	}
+
+	speed := dp.getSpeedLocked()
+	if speed <= 0 {
+		return 0
+	}
+
+	remaining := dp.Total - dp.Current
+	seconds := float64(remaining) / speed
+	return time.Duration(seconds) * time.Second
+}
+
+func (dp *DetailedProgress) getSpeedLocked() float64 {
+	if len(dp.SpeedWindow) < 2 {
+		return 0
+	}
+
+	first := dp.SpeedWindow[0]
+	last := dp.SpeedWindow[len(dp.SpeedWindow)-1]
+
+	elapsed := last.timestamp.Sub(first.timestamp).Seconds()
+	if elapsed <= 0 {
+		return 0
+	}
+
+	bytesTransferred := last.bytes - first.bytes
+	return float64(bytesTransferred) / elapsed
+}
+
+// GetElapsed returns the elapsed time since start
+func (dp *DetailedProgress) GetElapsed() time.Duration {
+	dp.mu.RLock()
+	defer dp.mu.RUnlock()
+	return time.Since(dp.StartTime)
+}
+
+// GetState returns a snapshot of the current state for rendering
+func (dp *DetailedProgress) GetState() DetailedProgressState {
+	dp.mu.RLock()
+	defer dp.mu.RUnlock()
+
+	return DetailedProgressState{
+		Description:     dp.Description,
+		Current:         dp.Current,
+		Total:           dp.Total,
+		Percent:         dp.getPercentLocked(),
+		Speed:           dp.getSpeedLocked(),
+		ETA:             dp.getETALocked(),
+		Elapsed:         time.Since(dp.StartTime),
+		Unit:            dp.Unit,
+		IsIndeterminate: dp.IsIndeterminate,
+		IsComplete:      dp.IsComplete,
+		IsFailed:        dp.IsFailed,
+		ErrorMessage:    dp.ErrorMessage,
+	}
+}
+
+func (dp *DetailedProgress) getPercentLocked() int {
+	if dp.IsIndeterminate || dp.Total <= 0 {
+		return 0
+	}
+	percent := int((dp.Current * 100) / dp.Total)
+	if percent > 100 {
+		return 100
+	}
+	return percent
+}
+
+func (dp *DetailedProgress) getETALocked() time.Duration {
+	if dp.IsIndeterminate || dp.Total <= 0 || dp.Current >= dp.Total {
+		return 0
+	}
+
+	speed := dp.getSpeedLocked()
+	if speed <= 0 {
+		return 0
+	}
+
+	remaining := dp.Total - dp.Current
+	seconds := float64(remaining) / speed
+	return time.Duration(seconds) * time.Second
+}
+
+// DetailedProgressState is an immutable snapshot for rendering
+type DetailedProgressState struct {
+	Description     string
+	Current         int64
+	Total           int64
+	Percent         int
+	Speed           float64 // bytes/sec
+	ETA             time.Duration
+	Elapsed         time.Duration
+	Unit            string
+	IsIndeterminate bool
+	IsComplete      bool
+	IsFailed        bool
+	ErrorMessage    string
+}
+
+// RenderProgressBar renders a TUI-friendly progress bar string
+// Returns something like: "Extracting archive  [████████░░░░░░░░░░░░]  45%  12.5 MB/s  ETA: 2m 30s"
+func (s DetailedProgressState) RenderProgressBar(width int) string {
+	if s.IsIndeterminate {
+		return s.renderIndeterminate()
+	}
+
+	// Progress bar
+	barWidth := 30
+	if width < 80 {
+		barWidth = 20
+	}
+	filled := (s.Percent * barWidth) / 100
+	if filled > barWidth {
+		filled = barWidth
+	}
+
+	bar := strings.Repeat("█", filled) + strings.Repeat("░", barWidth-filled)
+
+	// Format bytes
+	currentStr := FormatBytes(s.Current)
+	totalStr := FormatBytes(s.Total)
+
+	// Format speed
+	speedStr := ""
+	if s.Speed > 0 {
+		speedStr = fmt.Sprintf("%s/s", FormatBytes(int64(s.Speed)))
+	}
+
+	// Format ETA
+	etaStr := ""
+	if s.ETA > 0 && !s.IsComplete {
+		etaStr = fmt.Sprintf("ETA: %s", FormatDurationShort(s.ETA))
+	}
+
+	// Build the line
+	parts := []string{
+		fmt.Sprintf("[%s]", bar),
+		fmt.Sprintf("%3d%%", s.Percent),
+	}
+
+	if s.Unit == "bytes" && s.Total > 0 {
+		parts = append(parts, fmt.Sprintf("%s/%s", currentStr, totalStr))
+	} else if s.Total > 0 {
+		parts = append(parts, fmt.Sprintf("%d/%d", s.Current, s.Total))
+	}
+
+	if speedStr != "" {
+		parts = append(parts, speedStr)
+	}
+	if etaStr != "" {
+		parts = append(parts, etaStr)
+	}
+
+	return strings.Join(parts, "  ")
+}
+
+func (s DetailedProgressState) renderIndeterminate() string {
+	elapsed := FormatDurationShort(s.Elapsed)
+	return fmt.Sprintf("[spinner]  %s  Elapsed: %s", s.Description, elapsed)
+}
+
+// RenderCompact renders a compact single-line progress string
+func (s DetailedProgressState) RenderCompact() string {
+	if s.IsComplete {
+		return fmt.Sprintf("[OK] %s completed in %s", s.Description, FormatDurationShort(s.Elapsed))
+	}
+	if s.IsFailed {
+		return fmt.Sprintf("[FAIL] %s: %s", s.Description, s.ErrorMessage)
+	}
+	if s.IsIndeterminate {
+		return fmt.Sprintf("[...] %s (%s)", s.Description, FormatDurationShort(s.Elapsed))
+	}
+
+	return fmt.Sprintf("[%3d%%] %s - %s/%s", s.Percent, s.Description,
+		FormatBytes(s.Current), FormatBytes(s.Total))
+}
+
+// FormatBytes formats bytes in human-readable format
+func FormatBytes(b int64) string {
+	const unit = 1024
+	if b < unit {
+		return fmt.Sprintf("%d B", b)
+	}
+	div, exp := int64(unit), 0
+	for n := b / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %cB", float64(b)/float64(div), "KMGTPE"[exp])
+}
+
+// FormatDurationShort formats duration in short form
+func FormatDurationShort(d time.Duration) string {
+	if d < time.Second {
+		return "<1s"
+	}
+	if d < time.Minute {
+		return fmt.Sprintf("%ds", int(d.Seconds()))
+	}
+	if d < time.Hour {
+		m := int(d.Minutes())
+		s := int(d.Seconds()) % 60
+		if s > 0 {
+			return fmt.Sprintf("%dm %ds", m, s)
+		}
+		return fmt.Sprintf("%dm", m)
+	}
+	h := int(d.Hours())
+	m := int(d.Minutes()) % 60
+	return fmt.Sprintf("%dh %dm", h, m)
+}

internal/tui/restore_exec.go

@@ -6,6 +6,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
+	"sync"
 	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
@@ -45,6 +46,17 @@ type RestoreExecutionModel struct {
 	spinnerFrame  int
 	spinnerFrames []string
 
+	// Detailed byte progress for schollz-style display
+	bytesTotal  int64
+	bytesDone   int64
+	description string
+	showBytes   bool    // True when we have real byte progress to show
+	speed       float64 // Rolling window speed in bytes/sec
+
+	// Database count progress (for cluster restore)
+	dbTotal int
+	dbDone  int
+
 	// Results
 	done       bool
 	cancelling bool // True when user has requested cancellation
@@ -97,10 +109,13 @@ func restoreTickCmd() tea.Cmd {
 }
 
 type restoreProgressMsg struct {
-	status   string
+	status      string
-	phase    string
+	phase       string
-	progress int
+	progress    int
-	detail   string
+	detail      string
+	bytesTotal  int64
+	bytesDone   int64
+	description string
 }
 
 type restoreCompleteMsg struct {
@@ -109,6 +124,102 @@ type restoreCompleteMsg struct {
 	elapsed time.Duration
 }
 
+// sharedProgressState holds progress state that can be safely accessed from callbacks
+type sharedProgressState struct {
+	mu          sync.Mutex
+	bytesTotal  int64
+	bytesDone   int64
+	description string
+	hasUpdate   bool
+
+	// Database count progress (for cluster restore)
+	dbTotal int
+	dbDone  int
+
+	// Rolling window for speed calculation
+	speedSamples []restoreSpeedSample
+}
+
+type restoreSpeedSample struct {
+	timestamp time.Time
+	bytes     int64
+}
+
+// Package-level shared progress state for restore operations
+var (
+	currentRestoreProgressMu    sync.Mutex
+	currentRestoreProgressState *sharedProgressState
+)
+
+func setCurrentRestoreProgress(state *sharedProgressState) {
+	currentRestoreProgressMu.Lock()
+	defer currentRestoreProgressMu.Unlock()
+	currentRestoreProgressState = state
+}
+
+func clearCurrentRestoreProgress() {
+	currentRestoreProgressMu.Lock()
+	defer currentRestoreProgressMu.Unlock()
+	currentRestoreProgressState = nil
+}
+
+func getCurrentRestoreProgress() (bytesTotal, bytesDone int64, description string, hasUpdate bool, dbTotal, dbDone int, speed float64) {
+	currentRestoreProgressMu.Lock()
+	defer currentRestoreProgressMu.Unlock()
+
+	if currentRestoreProgressState == nil {
+		return 0, 0, "", false, 0, 0, 0
+	}
+
+	currentRestoreProgressState.mu.Lock()
+	defer currentRestoreProgressState.mu.Unlock()
+
+	// Calculate rolling window speed
+	speed = calculateRollingSpeed(currentRestoreProgressState.speedSamples)
+
+	return currentRestoreProgressState.bytesTotal, currentRestoreProgressState.bytesDone,
+		currentRestoreProgressState.description, currentRestoreProgressState.hasUpdate,
+		currentRestoreProgressState.dbTotal, currentRestoreProgressState.dbDone, speed
+}
+
+// calculateRollingSpeed calculates speed from recent samples (last 5 seconds)
+func calculateRollingSpeed(samples []restoreSpeedSample) float64 {
+	if len(samples) < 2 {
+		return 0
+	}
+
+	// Use samples from last 5 seconds for smoothed speed
+	now := time.Now()
+	cutoff := now.Add(-5 * time.Second)
+
+	var firstInWindow, lastInWindow *restoreSpeedSample
+	for i := range samples {
+		if samples[i].timestamp.After(cutoff) {
+			if firstInWindow == nil {
+				firstInWindow = &samples[i]
+			}
+			lastInWindow = &samples[i]
+		}
+	}
+
+	// Fall back to first and last if window is empty
+	if firstInWindow == nil || lastInWindow == nil || firstInWindow == lastInWindow {
+		firstInWindow = &samples[0]
+		lastInWindow = &samples[len(samples)-1]
+	}
+
+	elapsed := lastInWindow.timestamp.Sub(firstInWindow.timestamp).Seconds()
+	if elapsed <= 0 {
+		return 0
+	}
+
+	bytesTransferred := lastInWindow.bytes - firstInWindow.bytes
+	return float64(bytesTransferred) / elapsed
+}
+
+// restoreProgressChannel allows sending progress updates from the restore goroutine
+type restoreProgressChannel chan restoreProgressMsg
+
 func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config, log logger.Logger, archive ArchiveInfo, targetDB string, cleanFirst, createIfMissing bool, restoreType string, cleanClusterFirst bool, existingDBs []string, saveDebugLog bool) tea.Cmd {
 	return func() tea.Msg {
 		// NO TIMEOUT for restore operations - a restore takes as long as it takes
@@ -156,6 +267,48 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 		// STEP 2: Create restore engine with silent progress (no stdout interference with TUI)
 		engine := restore.NewSilent(cfg, log, dbClient)
 
+		// Set up progress callback for detailed progress reporting
+		// We use a shared pointer that can be queried by the TUI ticker
+		progressState := &sharedProgressState{
+			speedSamples: make([]restoreSpeedSample, 0, 100),
+		}
+		engine.SetProgressCallback(func(current, total int64, description string) {
+			progressState.mu.Lock()
+			defer progressState.mu.Unlock()
+			progressState.bytesDone = current
+			progressState.bytesTotal = total
+			progressState.description = description
+			progressState.hasUpdate = true
+
+			// Add speed sample for rolling window calculation
+			progressState.speedSamples = append(progressState.speedSamples, restoreSpeedSample{
+				timestamp: time.Now(),
+				bytes:     current,
+			})
+			// Keep only last 100 samples
+			if len(progressState.speedSamples) > 100 {
+				progressState.speedSamples = progressState.speedSamples[len(progressState.speedSamples)-100:]
+			}
+		})
+
+		// Set up database progress callback for cluster restore
+		engine.SetDatabaseProgressCallback(func(done, total int, dbName string) {
+			progressState.mu.Lock()
+			defer progressState.mu.Unlock()
+			progressState.dbDone = done
+			progressState.dbTotal = total
+			progressState.description = fmt.Sprintf("Restoring %s", dbName)
+			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)
+		defer clearCurrentRestoreProgress()
+
 		// Enable debug logging if requested
 		if saveDebugLog {
 			// Generate debug log path using configured WorkDir
@@ -165,9 +318,6 @@ func executeRestoreWithTUIProgress(parentCtx context.Context, cfg *config.Config
 			log.Info("Debug logging enabled", "path", debugLogPath)
 		}
 
-		// Set up progress callback (but it won't work in goroutine - progress is already sent via logs)
-		// The TUI will just use spinner animation to show activity
-
 		// STEP 3: Execute restore based on type
 		var restoreErr error
 		if restoreType == "restore-cluster" {
@@ -206,39 +356,62 @@ func (m RestoreExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.spinnerFrame = (m.spinnerFrame + 1) % len(m.spinnerFrames)
 			m.elapsed = time.Since(m.startTime)
 
-			// Update status based on elapsed time to show progress
+			// Poll shared progress state for real-time updates
-			// This provides visual feedback even though we don't have real-time progress
+			bytesTotal, bytesDone, description, hasUpdate, dbTotal, dbDone, speed := getCurrentRestoreProgress()
-			elapsedSec := int(m.elapsed.Seconds())
+			if hasUpdate && bytesTotal > 0 {
+				m.bytesTotal = bytesTotal
+				m.bytesDone = bytesDone
+				m.description = description
+				m.showBytes = true
+				m.speed = speed
 
-			if elapsedSec < 2 {
+				// Update status to reflect actual progress
-				m.status = "Initializing restore..."
+				m.status = description
-				m.phase = "Starting"
+				m.phase = "Extracting"
-			} else if elapsedSec < 5 {
+				m.progress = int((bytesDone * 100) / bytesTotal)
-				if m.cleanClusterFirst && len(m.existingDBs) > 0 {
+			} else if hasUpdate && dbTotal > 0 {
-					m.status = fmt.Sprintf("Cleaning %d existing database(s)...", len(m.existingDBs))
+				// Database count progress for cluster restore
-					m.phase = "Cleanup"
+				m.dbTotal = dbTotal
-				} else if m.restoreType == "restore-cluster" {
+				m.dbDone = dbDone
-					m.status = "Extracting cluster archive..."
+				m.showBytes = false
-					m.phase = "Extraction"
+				m.status = fmt.Sprintf("Restoring database %d of %d...", dbDone+1, dbTotal)
-				} else {
+				m.phase = "Restore"
-					m.status = "Preparing restore..."
+				m.progress = int((dbDone * 100) / dbTotal)
-					m.phase = "Preparation"
-				}
-			} else if elapsedSec < 10 {
-				if m.restoreType == "restore-cluster" {
-					m.status = "Restoring global objects..."
-					m.phase = "Globals"
-				} else {
-					m.status = fmt.Sprintf("Restoring database '%s'...", m.targetDB)
-					m.phase = "Restore"
-				}
 			} else {
-				if m.restoreType == "restore-cluster" {
+				// Fallback: Update status based on elapsed time to show progress
-					m.status = "Restoring cluster databases..."
+				// This provides visual feedback even though we don't have real-time progress
-					m.phase = "Restore"
+				elapsedSec := int(m.elapsed.Seconds())
+
+				if elapsedSec < 2 {
+					m.status = "Initializing restore..."
+					m.phase = "Starting"
+				} else if elapsedSec < 5 {
+					if m.cleanClusterFirst && len(m.existingDBs) > 0 {
+						m.status = fmt.Sprintf("Cleaning %d existing database(s)...", len(m.existingDBs))
+						m.phase = "Cleanup"
+					} else if m.restoreType == "restore-cluster" {
+						m.status = "Extracting cluster archive..."
+						m.phase = "Extraction"
+					} else {
+						m.status = "Preparing restore..."
+						m.phase = "Preparation"
+					}
+				} else if elapsedSec < 10 {
+					if m.restoreType == "restore-cluster" {
+						m.status = "Restoring global objects..."
+						m.phase = "Globals"
+					} else {
+						m.status = fmt.Sprintf("Restoring database '%s'...", m.targetDB)
+						m.phase = "Restore"
+					}
 				} else {
-					m.status = fmt.Sprintf("Restoring database '%s'...", m.targetDB)
+					if m.restoreType == "restore-cluster" {
-					m.phase = "Restore"
+						m.status = "Restoring cluster databases..."
+						m.phase = "Restore"
+					} else {
+						m.status = fmt.Sprintf("Restoring database '%s'...", m.targetDB)
+						m.phase = "Restore"
+					}
 				}
 			}
 
@@ -250,6 +423,15 @@ func (m RestoreExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.status = msg.status
 		m.phase = msg.phase
 		m.progress = msg.progress
+
+		// Update byte-level progress if available
+		if msg.bytesTotal > 0 {
+			m.bytesTotal = msg.bytesTotal
+			m.bytesDone = msg.bytesDone
+			m.description = msg.description
+			m.showBytes = true
+		}
+
 		if msg.detail != "" {
 			m.details = append(m.details, msg.detail)
 			// Keep only last 5 details
@@ -356,18 +538,38 @@ func (m RestoreExecutionModel) View() string {
 		// Show progress
 		s.WriteString(fmt.Sprintf("Phase: %s\n", m.phase))
 
-		// Show status with rotating spinner (unified indicator for all operations)
+		// Show detailed progress bar when we have byte-level information
-		spinner := m.spinnerFrames[m.spinnerFrame]
+		// In this case, hide the spinner for cleaner display
-		s.WriteString(fmt.Sprintf("Status: %s %s\n", spinner, m.status))
+		if m.showBytes && m.bytesTotal > 0 {
-		s.WriteString("\n")
+			// Status line without spinner (progress bar provides activity indication)
-
+			s.WriteString(fmt.Sprintf("Status: %s\n", m.status))
-		// Only show progress bar for single database restore
-		// Cluster restore uses spinner only (consistent with CLI behavior)
-		if m.restoreType == "restore-single" {
-			progressBar := renderProgressBar(m.progress)
-			s.WriteString(progressBar)
-			s.WriteString(fmt.Sprintf("  %d%%\n", m.progress))
 			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
+			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))
+			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 for single database restore
+				progressBar := renderProgressBar(m.progress)
+				s.WriteString(progressBar)
+				s.WriteString(fmt.Sprintf("  %d%%\n", m.progress))
+				s.WriteString("\n")
+			}
 		}
 
 		// Elapsed time
@@ -390,6 +592,92 @@ func renderProgressBar(percent int) string {
 	return successStyle.Render(bar) + infoStyle.Render(empty)
 }
 
+// renderDetailedProgressBar renders a schollz-style progress bar with bytes, speed, and ETA
+// Uses elapsed time for speed calculation (fallback)
+func renderDetailedProgressBar(done, total int64, elapsed time.Duration) string {
+	speed := 0.0
+	if elapsed.Seconds() > 0 {
+		speed = float64(done) / elapsed.Seconds()
+	}
+	return renderDetailedProgressBarWithSpeed(done, total, speed)
+}
+
+// renderDetailedProgressBarWithSpeed renders a schollz-style progress bar with pre-calculated rolling speed
+func renderDetailedProgressBarWithSpeed(done, total int64, speed float64) string {
+	var s strings.Builder
+
+	// Calculate percentage
+	percent := 0
+	if total > 0 {
+		percent = int((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("]"))
+
+	// Percentage
+	s.WriteString(fmt.Sprintf("  %3d%%", percent))
+
+	// Bytes progress
+	s.WriteString(fmt.Sprintf("  %s / %s", FormatBytes(done), FormatBytes(total)))
+
+	// Speed display (using rolling window speed)
+	if speed > 0 {
+		s.WriteString(fmt.Sprintf("  %s/s", FormatBytes(int64(speed))))
+
+		// ETA calculation based on rolling speed
+		if done < total {
+			remaining := total - done
+			etaSeconds := float64(remaining) / speed
+			eta := time.Duration(etaSeconds) * time.Second
+			s.WriteString(fmt.Sprintf("  ETA: %s", FormatDurationShort(eta)))
+		}
+	}
+
+	return s.String()
+}
+
+// renderDatabaseProgressBar renders a progress bar for database count (cluster restore)
+func renderDatabaseProgressBar(done, total int) 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))
+
+	return s.String()
+}
+
 // formatDuration formats duration in human readable format
 func formatDuration(d time.Duration) string {
 	if d < time.Minute {