diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index e9fa4f0..dd12d1c 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -312,7 +312,7 @@ Copyright (C) 2024-2026 Calibre-Web Automated contributors
 - zhiyue (1 commits)
 # Fork Contributors (crocodilestick/calibre-web-automated)
 
-- crocodilestick (921 commits)
+- crocodilestick (922 commits)
 - jmarmstrong1207 (73 commits)
 - demitrix (30 commits)
 - sirwolfgang (29 commits)
diff --git a/cps/cwa_functions.py b/cps/cwa_functions.py
index 1fd0e12..c8f525f 100755
--- a/cps/cwa_functions.py
+++ b/cps/cwa_functions.py
@@ -555,7 +555,7 @@ def set_cwa_settings():
     string_settings = []
     list_settings = []
     integer_settings = ['ingest_timeout_minutes', 'auto_send_delay_minutes']  # Special handling for integer settings
-    json_settings = ['metadata_provider_hierarchy', 'metadata_providers_enabled']  # Special handling for JSON settings
+    json_settings = ['metadata_provider_hierarchy', 'metadata_providers_enabled', 'duplicate_format_priority']  # Special handling for JSON settings
     
     for setting in cwa_default_settings:
         if setting in integer_settings or setting in json_settings:
diff --git a/cps/duplicates.py b/cps/duplicates.py
index 2cb4cf1..fb65de6 100644
--- a/cps/duplicates.py
+++ b/cps/duplicates.py
@@ -11,7 +11,7 @@ from datetime import datetime
 from functools import wraps
 import hashlib
 
-from . import db, calibre_db, logger, ub
+from . import db, calibre_db, logger, ub, csrf
 from .admin import admin_required  
 from .usermanagement import login_required_if_no_ano
 from .render_template import render_title_template
@@ -58,6 +58,129 @@ def generate_group_hash(title, author):
     return hashlib.md5(composite.encode('utf-8')).hexdigest()
 
 
+def validate_resolution_strategy(strategy):
+    """Validate that strategy is one of the allowed values"""
+    valid_strategies = ['newest', 'highest_quality_format', 'most_metadata', 'largest_file_size']
+    return strategy in valid_strategies
+
+
+def select_book_to_keep(books, strategy):
+    """
+    Select which book to keep from a duplicate group based on strategy.
+    
+    Args:
+        books: List of book objects from find_duplicate_books()
+        strategy: One of 'newest', 'highest_quality_format', 'most_metadata', 'largest_file_size'
+    
+    Returns:
+        The book object to keep
+    """
+    if not books:
+        return None
+    
+    if strategy == 'newest':
+        # Keep the most recently added book
+        return max(books, key=lambda b: b.timestamp if b.timestamp else datetime.min)
+    
+    elif strategy == 'highest_quality_format':
+        # Get format priority from settings
+        try:
+            import json
+            cwa_db = CWA_DB()
+            format_priority_json = cwa_db.cwa_settings.get('duplicate_format_priority', '{}')
+            format_priority = json.loads(format_priority_json)
+        except Exception as e:
+            log.warning("[cwa-duplicates] Error loading format priority from settings, using defaults: %s", str(e))
+            # Fallback to default priority
+            format_priority = {
+                'EPUB': 100,
+                'KEPUB': 95,
+                'AZW3': 90,
+                'MOBI': 80,
+                'AZW': 75,
+                'PDF': 60,
+                'TXT': 40,
+                'CBZ': 35,
+                'CBR': 35,
+                'FB2': 30,
+                'DJVU': 25,
+                'HTML': 20,
+                'RTF': 15,
+                'DOC': 10,
+                'DOCX': 10,
+            }
+        
+        def get_best_format_score(book):
+            """Calculate best format score for a book"""
+            if not book.data:
+                return 0
+            scores = [format_priority.get(data.format.upper(), 0) for data in book.data if data.format]
+            return max(scores) if scores else 0
+        
+        # Keep book with highest quality format, fallback to newest if tie
+        return max(books, key=lambda b: (get_best_format_score(b), b.timestamp if b.timestamp else datetime.min))
+    
+    elif strategy == 'most_metadata':
+        # Count metadata completeness
+        def metadata_score(book):
+            score = 0
+            
+            # Tags
+            if hasattr(book, 'tags') and book.tags:
+                score += len(book.tags) * 2
+            
+            # Series
+            if hasattr(book, 'series') and book.series:
+                score += 5
+            
+            # Rating
+            if hasattr(book, 'ratings') and book.ratings:
+                for rating in book.ratings:
+                    if rating.rating and rating.rating > 0:
+                        score += 3
+            
+            # Description/comments
+            if hasattr(book, 'comments') and book.comments:
+                for comment in book.comments:
+                    if comment.text and len(comment.text.strip()) > 50:
+                        score += 10
+            
+            # Publisher
+            if hasattr(book, 'publishers') and book.publishers:
+                score += 2
+            
+            # Published date
+            if hasattr(book, 'pubdate') and book.pubdate:
+                score += 2
+            
+            # Identifiers (ISBN, etc.)
+            if hasattr(book, 'identifiers') and book.identifiers:
+                score += len(book.identifiers) * 3
+            
+            # Number of formats
+            if hasattr(book, 'data') and book.data:
+                score += len(book.data)
+            
+            return score
+        
+        # Keep book with most complete metadata, fallback to newest if tie
+        return max(books, key=lambda b: (metadata_score(b), b.timestamp if b.timestamp else datetime.min))
+    
+    elif strategy == 'largest_file_size':
+        # Sum all format file sizes
+        def total_file_size(book):
+            if not book.data:
+                return 0
+            return sum(data.uncompressed_size for data in book.data if hasattr(data, 'uncompressed_size') and data.uncompressed_size)
+        
+        # Keep book with largest total file size, fallback to newest if tie
+        return max(books, key=lambda b: (total_file_size(b), b.timestamp if b.timestamp else datetime.min))
+    
+    else:
+        # Default fallback: keep newest
+        return max(books, key=lambda b: b.timestamp if b.timestamp else datetime.min)
+
+
 def get_unresolved_duplicate_count(user_id=None):
     """Get count of unresolved duplicate groups for a user
     
@@ -127,11 +250,19 @@ def find_duplicate_books(include_dismissed=False, user_id=None):
         # Get CWA settings for duplicate detection
         cwa_db = CWA_DB()
         settings = cwa_db.cwa_settings
+        
+        # Check if duplicate detection is enabled
+        detection_enabled = settings.get('duplicate_detection_enabled', 1)
+        if not detection_enabled:
+            print("[cwa-duplicates] Duplicate detection is disabled in settings", flush=True)
+            return []
+            
     except Exception as e:
         print(f"[cwa-duplicates] Error loading CWA settings: {str(e)}, falling back to defaults", flush=True)
         log.error("[cwa-duplicates] Error loading CWA settings: %s, falling back to defaults", str(e))
         # Fallback to safe defaults
         settings = {
+            'duplicate_detection_enabled': 1,
             'duplicate_detection_title': 1,
             'duplicate_detection_author': 1,
             'duplicate_detection_language': 1,
@@ -323,14 +454,71 @@ def get_duplicate_status():
         - preview: List of up to 3 sample duplicate groups
     """
     try:
-        # Check if notifications are enabled
+        # Check if duplicate detection is enabled
         cwa_db = CWA_DB()
+        detection_enabled = cwa_db.cwa_settings.get('duplicate_detection_enabled', 1)
+        
+        if not detection_enabled:
+            return jsonify({
+                'success': True,
+                'enabled': False,
+                'count': 0,
+                'preview': []
+            })
+        
+        # Check if notifications are enabled
         notifications_enabled = cwa_db.cwa_settings.get('duplicate_notifications_enabled', 1)
         
-        # Get unresolved duplicate groups
+        # Try to get cached results first
+        cache_data = cwa_db.get_duplicate_cache()
+        
+        if cache_data and not cache_data['scan_pending']:
+            # Cache is valid, use it
+            duplicate_groups = cache_data['duplicate_groups']
+            
+            # Filter out dismissed groups for this user
+            if current_user and current_user.id:
+                try:
+                    dismissed_hashes = set()
+                    dismissed_groups = ub.session.query(ub.DismissedDuplicateGroup.group_hash)\
+                        .filter(ub.DismissedDuplicateGroup.user_id == current_user.id)\
+                        .all()
+                    dismissed_hashes = {row[0] for row in dismissed_groups}
+                    
+                    if dismissed_hashes:
+                        duplicate_groups = [group for group in duplicate_groups 
+                                          if group['group_hash'] not in dismissed_hashes]
+                except Exception as e:
+                    log.error("[cwa-duplicates] Error filtering dismissed groups: %s", str(e))
+            
+            count = len(duplicate_groups)
+            
+            # Get preview of first 3 groups
+            preview = []
+            for group in duplicate_groups[:3]:
+                preview.append({
+                    'title': group['title'],
+                    'author': group['author'],
+                    'count': group['count'],
+                    'hash': group['group_hash']
+                })
+            
+            return jsonify({
+                'success': True,
+                'enabled': bool(notifications_enabled),
+                'count': count,
+                'preview': preview,
+                'cached': True
+            })
+        
+        # Cache is invalid or pending, run fresh scan
         duplicate_groups = find_duplicate_books(include_dismissed=False)
         count = len(duplicate_groups)
         
+        # Update cache with full results (before filtering dismissed)
+        all_groups = find_duplicate_books(include_dismissed=True)
+        cwa_db.update_duplicate_cache(all_groups, len(all_groups))
+        
         # Get preview of first 3 groups
         preview = []
         for group in duplicate_groups[:3]:
@@ -345,7 +533,8 @@ def get_duplicate_status():
             'success': True,
             'enabled': bool(notifications_enabled),
             'count': count,
-            'preview': preview
+            'preview': preview,
+            'cached': False
         })
     except Exception as e:
         log.error("[cwa-duplicates] Error getting duplicate status: %s", str(e))
@@ -456,3 +645,282 @@ def undismiss_duplicate_group(group_hash):
             'success': False,
             'error': str(e)
         }), 500
+
+
+@duplicates.route("/duplicates/invalidate-cache", methods=['POST'])
+@csrf.exempt
+def invalidate_cache():
+    """Internal endpoint to invalidate duplicate cache (called after ingest)"""
+    try:
+        cwa_db = CWA_DB()
+        success = cwa_db.invalidate_duplicate_cache()
+        
+        if success:
+            log.info("[cwa-duplicates] Cache invalidated - will refresh on next status check")
+            return jsonify({'success': True, 'message': 'Cache invalidated'})
+        else:
+            return jsonify({'success': False, 'error': 'Failed to invalidate cache'}), 500
+            
+    except Exception as e:
+        log.error("[cwa-duplicates] Error invalidating cache: %s", str(e))
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@duplicates.route("/duplicates/trigger-scan", methods=['POST'])
+@csrf.exempt
+@login_required_if_no_ano
+@admin_or_edit_required
+def trigger_scan():
+    """Manually trigger a duplicate scan"""
+    try:
+        # Invalidate cache and run fresh scan
+        cwa_db = CWA_DB()
+        cwa_db.invalidate_duplicate_cache()
+        
+        # Run scan
+        duplicate_groups = find_duplicate_books(include_dismissed=False)
+        
+        # Update cache
+        all_groups = find_duplicate_books(include_dismissed=True)
+        cwa_db.update_duplicate_cache(all_groups, len(all_groups))
+        
+        log.info("[cwa-duplicates] Manual scan triggered by user %s, found %s groups", 
+                current_user.name, len(duplicate_groups))
+        
+        return jsonify({
+            'success': True,
+            'message': _('Duplicate scan completed'),
+            'count': len(duplicate_groups)
+        })
+        
+    except Exception as e:
+        log.error("[cwa-duplicates] Error triggering scan: %s", str(e))
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@duplicates.route("/duplicates/preview-resolution", methods=["POST"])
+@login_required_if_no_ano
+@admin_required
+def preview_resolution():
+    """Preview auto-resolution without executing"""
+    print("[cwa-duplicates] Preview resolution endpoint called", flush=True)
+    log.info("[cwa-duplicates] Preview resolution endpoint called")
+    try:
+        from flask import request
+        strategy = request.json.get('strategy', 'newest')
+        print(f"[cwa-duplicates] Preview strategy: {strategy}", flush=True)
+        log.info("[cwa-duplicates] Preview strategy: %s", strategy)
+        
+        if not validate_resolution_strategy(strategy):
+            error_msg = f'Invalid resolution strategy: {strategy}'
+            print(f"[cwa-duplicates] {error_msg}", flush=True)
+            log.error("[cwa-duplicates] %s", error_msg)
+            return jsonify({
+                'success': False,
+                'error': _(error_msg)
+            }), 400
+        
+        print("[cwa-duplicates] Calling auto_resolve_duplicates in dry_run mode...", flush=True)
+        result = auto_resolve_duplicates(
+            strategy=strategy,
+            dry_run=True,
+            user_id=current_user.id,
+            trigger_type='manual'
+        )
+        
+        print(f"[cwa-duplicates] Preview result: {result.get('success', False)}, resolved_count={result.get('resolved_count', 0)}", flush=True)
+        return jsonify(result)
+        
+    except Exception as e:
+        import traceback
+        error_trace = traceback.format_exc()
+        print(f"[cwa-duplicates] Error previewing resolution: {e}\n{error_trace}", flush=True)
+        log.error("[cwa-duplicates] Error previewing resolution: %s\n%s", str(e), error_trace)
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@duplicates.route("/duplicates/execute-resolution", methods=["POST"])
+@login_required_if_no_ano
+@admin_required
+def execute_resolution():
+    """Execute auto-resolution"""
+    try:
+        from flask import request
+        strategy = request.json.get('strategy', 'newest')
+        
+        if not validate_resolution_strategy(strategy):
+            return jsonify({
+                'success': False,
+                'error': _('Invalid resolution strategy')
+            }), 400
+        
+        result = auto_resolve_duplicates(
+            strategy=strategy,
+            dry_run=False,
+            user_id=current_user.id,
+            trigger_type='manual'
+        )
+        
+        # Invalidate cache after resolution
+        if result['success'] and result['deleted_count'] > 0:
+            cwa_db = CWA_DB()
+            cwa_db.invalidate_duplicate_cache()
+        
+        return jsonify(result)
+        
+    except Exception as e:
+        log.error("[cwa-duplicates] Error executing resolution: %s", str(e))
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+def auto_resolve_duplicates(strategy='newest', dry_run=False, user_id=None, trigger_type='manual'):
+    """
+    Automatically resolve duplicate books by keeping one and deleting others.
+    
+    Args:
+        strategy: Resolution strategy ('newest', 'highest_quality_format', 'most_metadata', 'largest_file_size')
+        dry_run: If True, return preview without actually deleting
+        user_id: User ID triggering the resolution (for audit)
+        trigger_type: 'manual', 'scheduled', or 'automatic'
+    
+    Returns:
+        dict with keys:
+            'success': bool
+            'resolved_count': int (number of groups resolved)
+            'deleted_count': int (total books deleted)
+            'kept_count': int (total books kept)
+            'errors': list of error messages
+            'preview': list of dicts (if dry_run=True) with 'group', 'kept_book', 'deleted_books'
+    """
+    from cps.editbooks import delete_book_from_table
+    from cps import config
+    import os
+    import shutil
+    
+    # Validate strategy
+    if not validate_resolution_strategy(strategy):
+        return {'success': False, 'errors': [f'Invalid strategy: {strategy}']}
+    
+    # Get duplicate groups (exclude dismissed)
+    duplicate_groups = find_duplicate_books(include_dismissed=False)
+    
+    if not duplicate_groups:
+        return {
+            'success': True,
+            'resolved_count': 0,
+            'deleted_count': 0,
+            'kept_count': 0,
+            'errors': [],
+            'message': 'No unresolved duplicates found'
+        }
+    
+    result = {
+        'success': True,
+        'resolved_count': 0,
+        'deleted_count': 0,
+        'kept_count': 0,
+        'errors': [],
+        'preview': [] if dry_run else None
+    }
+    
+    cwa_db = CWA_DB()
+    
+    for group in duplicate_groups:
+        try:
+            # Select book to keep
+            book_to_keep = select_book_to_keep(group['books'], strategy)
+            
+            if not book_to_keep:
+                result['errors'].append(f"Could not select book to keep for group: {group['title']}")
+                continue
+            
+            # Get books to delete
+            books_to_delete = [b for b in group['books'] if b.id != book_to_keep.id]
+            
+            if not books_to_delete:
+                continue  # Only one book in group, nothing to resolve
+            
+            if dry_run:
+                # Preview mode: just collect info
+                result['preview'].append({
+                    'group_hash': group['group_hash'],
+                    'title': group['title'],
+                    'author': group['author'],
+                    'kept_book_id': book_to_keep.id,
+                    'kept_book_timestamp': book_to_keep.timestamp.strftime('%Y-%m-%d %H:%M') if book_to_keep.timestamp else 'Unknown',
+                    'kept_book_formats': [d.format for d in book_to_keep.data] if book_to_keep.data else [],
+                    'deleted_book_ids': [b.id for b in books_to_delete],
+                    'deleted_books_info': [{
+                        'id': b.id,
+                        'timestamp': b.timestamp.strftime('%Y-%m-%d %H:%M') if b.timestamp else 'Unknown',
+                        'formats': [d.format for d in b.data] if b.data else []
+                    } for b in books_to_delete]
+                })
+                result['kept_count'] += 1
+                result['deleted_count'] += len(books_to_delete)
+                result['resolved_count'] += 1
+                continue
+            
+            # Actual resolution mode
+            deleted_ids = []
+            backup_dir = f"/config/processed_books/duplicate_resolutions/{datetime.now().strftime('%Y%m%d_%H%M%S')}_group_{group['group_hash'][:8]}"
+            os.makedirs(backup_dir, exist_ok=True)
+            
+            # Backup and delete each duplicate
+            for book in books_to_delete:
+                try:
+                    # Backup book files
+                    book_path = os.path.join(config.config_calibre_dir, book.path)
+                    if os.path.exists(book_path):
+                        backup_path = os.path.join(backup_dir, f"book_{book.id}")
+                        shutil.copytree(book_path, backup_path)
+                        log.info("[cwa-duplicates] Backed up book %s to %s", book.id, backup_path)
+                    
+                    # Delete from Calibre library
+                    delete_book_from_table(book.id, "", True)  # True = delete from disk
+                    deleted_ids.append(book.id)
+                    log.info("[cwa-duplicates] Deleted duplicate book %s: %s", book.id, book.title)
+                    
+                except Exception as e:
+                    log.error("[cwa-duplicates] Error deleting book %s: %s", book.id, e)
+                    result['errors'].append(f"Failed to delete book {book.id}: {str(e)}")
+            
+            if deleted_ids:
+                # Log to audit table
+                cwa_db.log_duplicate_resolution(
+                    group_hash=group['group_hash'],
+                    group_title=group['title'],
+                    group_author=group['author'],
+                    kept_book_id=book_to_keep.id,
+                    deleted_book_ids=deleted_ids,
+                    strategy=strategy,
+                    trigger_type=trigger_type,
+                    user_id=user_id,
+                    notes=f"Resolved {len(deleted_ids)} duplicate(s) using {strategy} strategy"
+                )
+                
+                result['resolved_count'] += 1
+                result['kept_count'] += 1
+                result['deleted_count'] += len(deleted_ids)
+                
+                log.info("[cwa-duplicates] Resolved duplicate group '%s' by %s: kept book %s, deleted %s duplicates", 
+                        group['title'], group['author'], book_to_keep.id, len(deleted_ids))
+        
+        except Exception as e:
+            log.error("[cwa-duplicates] Error resolving duplicate group '%s': %s", group.get('title', 'unknown'), e)
+            result['errors'].append(f"Group '{group.get('title', 'unknown')}': {str(e)}")
+    
+
+    if result['errors']:
+        result['success'] = False
+    
+    return result
diff --git a/cps/editbooks.py b/cps/editbooks.py
index 1f55ecc..55561aa 100644
--- a/cps/editbooks.py
+++ b/cps/editbooks.py
@@ -1171,6 +1171,18 @@ def delete_book_from_table(book_id, book_format, json_response, location=""):
                     if book_format.upper() in ['KEPUB', 'EPUB', 'EPUB3']:
                         kobo_sync_status.remove_synced_book(book.id, True)
                 calibre_db.session.commit()
+                
+                # Invalidate duplicate cache after book deletion
+                try:
+                    import sys
+                    sys.path.insert(1, '/app/calibre-web-automated/scripts/')
+                    from cwa_db import CWA_DB
+                    cwa_db = CWA_DB()
+                    cwa_db.invalidate_duplicate_cache()
+                    cwa_db.close()
+                except Exception as e:
+                    log.error("Failed to invalidate duplicate cache after deletion: %s", str(e))
+                
             except Exception as ex:
                 log.error_or_exception(ex)
                 calibre_db.session.rollback()
diff --git a/cps/static/js/duplicates.js b/cps/static/js/duplicates.js
index ba172b1..340e93d 100644
--- a/cps/static/js/duplicates.js
+++ b/cps/static/js/duplicates.js
@@ -26,10 +26,10 @@ $(document).ready(function() {
     function updateSelectionCount() {
         var count = selectedBooks.length;
         if (count === 0) {
-            $('#selection_count').text('');
+            $('#selection_count').text('0 BOOKS SELECTED');
             $('#delete_selected').addClass('disabled').attr('aria-disabled', true);
         } else {
-            $('#selection_count').text(count + ' book' + (count > 1 ? 's' : '') + ' selected');
+            $('#selection_count').text(count + ' BOOK' + (count > 1 ? 'S' : '') + ' SELECTED');
             $('#delete_selected').removeClass('disabled').attr('aria-disabled', false);
         }
     }
@@ -267,6 +267,157 @@ $(document).ready(function() {
         });
     });
     
+    // Manual scan trigger
+    $('#trigger_scan').on('click', function() {
+        var btn = $(this);
+        btn.prop('disabled', true);
+        btn.html('<span class="glyphicon glyphicon-refresh glyphicon-spin"></span> Scanning...');
+        
+        $.ajax({
+            url: '/duplicates/trigger-scan',
+            type: 'POST',
+            headers: {
+                'X-CSRFToken': csrfToken
+            },
+            dataType: 'json',
+            success: function(response) {
+                if (response.success) {
+                    alert('Scan complete! Found ' + response.count + ' duplicate groups.');
+                    location.reload();
+                } else {
+                    alert('Scan failed: ' + response.error);
+                }
+            },
+            error: function(xhr, status, error) {
+                console.error('[CWA Duplicates] Error triggering scan:', error);
+                alert('Error: Failed to trigger duplicate scan');
+            },
+            complete: function() {
+                btn.prop('disabled', false);
+                btn.html('<span class="glyphicon glyphicon-refresh"></span> Scan for Duplicates Now');
+            }
+        });
+    });
+    
+    // Auto-resolution preview
+    $('#preview_resolution').on('click', function() {
+        var strategy = $('#resolution_strategy').val();
+        var btn = $(this);
+        btn.prop('disabled', true);
+        btn.html('<span class="glyphicon glyphicon-refresh glyphicon-spin"></span> Loading...');
+        
+        $.ajax({
+            url: '/duplicates/preview-resolution',
+            method: 'POST',
+            contentType: 'application/json',
+            headers: {
+                'X-CSRFToken': csrfToken
+            },
+            data: JSON.stringify({ strategy: strategy }),
+            success: function(data) {
+                if (data.success && data.preview) {
+                    showResolutionPreview(data);
+                    $('#execute_resolution').removeClass('disabled').prop('aria-disabled', false);
+                } else {
+                    alert('Error generating preview: ' + (data.errors || []).join(', '));
+                }
+            },
+            error: function() {
+                alert('Failed to generate preview');
+            },
+            complete: function() {
+                btn.prop('disabled', false);
+                btn.html('<span class="glyphicon glyphicon-eye-open"></span> Preview');
+            }
+        });
+    });
+    
+    // Execute resolution
+    $('#execute_resolution').on('click', function() {
+        if ($(this).hasClass('disabled')) return;
+        
+        if (!confirm('Are you sure you want to execute auto-resolution? This will permanently delete duplicate books.')) {
+            return;
+        }
+        
+        var strategy = $('#resolution_strategy').val();
+        var btn = $(this);
+        btn.addClass('disabled').html('<span class="glyphicon glyphicon-refresh glyphicon-spin"></span> Executing...');
+        
+        $.ajax({
+            url: '/duplicates/execute-resolution',
+            method: 'POST',
+            contentType: 'application/json',
+            headers: {
+                'X-CSRFToken': csrfToken
+            },
+            data: JSON.stringify({ strategy: strategy }),
+            success: function(data) {
+                if (data.success) {
+                    alert('Resolution complete!\n\nResolved: ' + data.resolved_count + ' groups\nKept: ' + data.kept_count + ' books\nDeleted: ' + data.deleted_count + ' books');
+                    location.reload();
+                } else {
+                    alert('Errors occurred:\n' + (data.errors || []).join('\n'));
+                    btn.removeClass('disabled').html('<span class="glyphicon glyphicon-flash"></span> Execute Resolution');
+                }
+            },
+            error: function() {
+                alert('Failed to execute resolution');
+                btn.removeClass('disabled').html('<span class="glyphicon glyphicon-flash"></span> Execute Resolution');
+            }
+        });
+    });
+    
+    function showResolutionPreview(data) {
+        var html = '<div style="margin-bottom: 20px; padding: 15px; background: #6d6d6d66; border-left: 4px solid #4caf50; border-radius: 4px; color: white">' +
+            '<h4 style="color: #98f99c; margin-top: 0;">Summary</h4>' +
+            '<p><strong>Groups to resolve:</strong> ' + data.resolved_count + '</p>' +
+            '<p><strong>Books to keep:</strong> ' + data.kept_count + '</p>' +
+            '<p><strong>Books to delete:</strong> ' + data.deleted_count + '</p>' +
+            '</div>';
+        
+        if (data.preview && data.preview.length > 0) {
+            html += '<div style="margin-top: 20px;"><h4>Preview:</h4>';
+            
+            data.preview.forEach(function(group) {
+                html += '<div style="padding: 15px; border: none; border-radius: 6px; background: #6d6d6d66;">' +
+                    '<h5 style="color: white; margin-top: 0;">' + escapeHtml(group.title) + ' <small>by ' + escapeHtml(group.author) + '</small></h5>' +
+                    '<div style="margin-bottom: 15px; padding: 10px; background: #d4edda; border-left: 3px solid #28a745; border-radius: 4px; color: #1c2832">' +
+                    '<strong style="color: #155724;">✓ KEEP:</strong> Book ID ' + group.kept_book_id + ' ' +
+                    '<small style="color: #666;">(Added: ' + group.kept_book_timestamp + ', Formats: ' + group.kept_book_formats.join(', ') + ')</small>' +
+                    '</div>' +
+                    '<div style="padding: 10px; background: #f8d7da; border-left: 3px solid #dc3545; border-radius: 4px;">' +
+                    '<strong style="color: #721c24;">✗ DELETE:</strong>' +
+                    '<ul style="margin: 5px 0 0 20px; padding: 0; color: #1c2832">';
+                
+                group.deleted_books_info.forEach(function(book) {
+                    html += '<li style="margin: 5px 0;">' +
+                        'Book ID ' + book.id + ' ' +
+                        '<small style="color: #666;">(Added: ' + book.timestamp + ', Formats: ' + book.formats.join(', ') + ')</small>' +
+                        '</li>';
+                });
+                
+                html += '</ul></div></div>';
+            });
+            
+            html += '</div>';
+        }
+        
+        $('#resolution_preview_body').html(html);
+        $('#resolution_preview_modal').modal('show');
+    }
+    
+    function escapeHtml(text) {
+        var map = {
+            '&': '&amp;',
+            '<': '&lt;',
+            '>': '&gt;',
+            '"': '&quot;',
+            "'": '&#039;'
+        };
+        return text.replace(/[&<>"']/g, function(m) { return map[m]; });
+    }
+    
     // Initialize
     updateSelectionCount();
     updateBookItemVisuals();
diff --git a/cps/templates/cwa_settings.html b/cps/templates/cwa_settings.html
index 4ebc249..35763b0 100755
--- a/cps/templates/cwa_settings.html
+++ b/cps/templates/cwa_settings.html
@@ -594,6 +594,20 @@
       </tbody></table>
     </div>
 
+    <div class="settings-container">
+      <h4 class="settings-section-header">{{_('CWA Duplicate Detection System')}}</h4>
+
+      <p class="cwa-settings-explanation settings-explanation">
+        {{_('Enable or disable the duplicate detection system. When disabled, duplicate scanning will not run and no notifications will be shown.')}}
+      </p>
+
+      <div class="checkbox-wrapper" style="margin-bottom: 1.5rem;">
+        <input type="checkbox" id="duplicate_detection_enabled" name="duplicate_detection_enabled" value="1" {% if cwa_settings['duplicate_detection_enabled'] %} checked {% endif %}>
+        <label for="duplicate_detection_enabled">{{_('Enable Duplicate Detection')}}</label>
+        <small class="settings-explanation">{{_('When enabled, CWA will scan for duplicate books after each import')}}</small>
+      </div>
+    </div>
+
     <div class="settings-container">
       <h4 class="settings-section-header">{{_('CWA Duplicate Detection Criteria')}}</h4>
 
@@ -646,6 +660,28 @@
       </div>
     </div>
 
+    <div class="settings-container">
+      <h4 class="settings-section-header">{{_('Duplicate Format Priority Ranking')}}</h4>
+
+      <p class="cwa-settings-explanation settings-explanation">
+        {{_('Configure which file formats are preferred when using the "Highest Quality Format" auto-resolution strategy. Drag and drop to reorder formats by priority (higher = better).')}}
+      </p>
+
+      <input type="hidden" id="duplicate_format_priority" name="duplicate_format_priority" value='{{ cwa_settings.get("duplicate_format_priority", "{\"EPUB\":100,\"KEPUB\":95,\"AZW3\":90,\"MOBI\":80,\"AZW\":75,\"PDF\":60,\"TXT\":40,\"CBZ\":35,\"CBR\":35,\"FB2\":30,\"DJVU\":25,\"HTML\":20,\"RTF\":15,\"DOC\":10,\"DOCX\":10}") }}'>
+      
+      <div id="format_priority_container" style="margin-top: 1rem;">
+        <ul id="format_priority_list" style="list-style: none; padding: 0; margin: 0;">
+          <!-- Will be populated by JavaScript -->
+        </ul>
+      </div>
+
+      <div class="cwa-settings-tip">
+        <small class="settings-explanation">
+          <strong>{{_('Tip:')}}</strong> {{_('When resolving duplicates with "Highest Quality Format" strategy, books with higher-ranked formats will be kept. Lower priority formats will be deleted.')}}
+        </small>
+      </div>
+    </div>
+
     <br>
 
 <!--
@@ -946,6 +982,147 @@ document.addEventListener('DOMContentLoaded', function() {
   
   // Initialize the hidden input value
   updateHiddenInput();
+  
+  // Format Priority Ranking System
+  function initializeFormatPriorityList() {
+    const hiddenInput = document.getElementById('duplicate_format_priority');
+    const container = document.getElementById('format_priority_list');
+    
+    if (!hiddenInput || !container) return;
+    
+    try {
+      // Decode HTML entities if present
+      const rawValue = hiddenInput.value || '{}';
+      const decodedValue = rawValue.replace(/&quot;/g, '"').replace(/&#34;/g, '"');
+      const formatPriority = JSON.parse(decodedValue);
+      
+      // Convert to array and sort by priority (highest first)
+      const formatArray = Object.entries(formatPriority).map(([format, priority]) => ({
+        format: format,
+        priority: priority
+      }));
+      formatArray.sort((a, b) => b.priority - a.priority);
+      
+      // Check if we actually have formats to display
+      if (formatArray.length === 0) {
+        console.error('No format priority data found');
+        container.innerHTML = '<li style="color: #e74c3c; padding: 12px;">No format data available. Please save settings to initialize.</li>';
+        return;
+      }
+      
+      // Populate list
+      container.innerHTML = '';
+      formatArray.forEach((item, index) => {
+        const li = document.createElement('li');
+        li.className = 'format-priority-item';
+        li.dataset.format = item.format;
+        li.dataset.priority = item.priority;
+        li.draggable = true;
+        li.innerHTML = `
+          <div style="display: flex; align-items: center; padding: 6px; margin-bottom: 8px; background: #2a3441; border: 1px solid #444; border-radius: 6px; cursor: move; transition: all 0.2s; padding-left: 2rem;">
+            <span style="color: #ffc200; margin-right: 15px; font-size: 18px;">☰</span>
+            <span style="flex: 1; color: white; font-weight: 500;">${item.format}</span>
+            <span style="color: #4CAF50; font-size: 13px; padding: 4px 8px; background: rgba(76, 160, 80, 0.1); border-radius: 4px;">Priority: ${item.priority}</span>
+          </div>
+        `;
+        container.appendChild(li);
+      });
+      
+      setupFormatPriorityDragDrop();
+    } catch (e) {
+      console.error('Error initializing format priority list:', e);
+      console.error('Hidden input value:', hiddenInput ? hiddenInput.value : 'not found');
+      container.innerHTML = '<li style="color: #e74c3c; padding: 12px;">Error loading format priority: ' + e.message + '</li>';
+    }
+  }
+  
+  function setupFormatPriorityDragDrop() {
+    let draggedFormatElement = null;
+    let isDraggingFormat = false;
+    
+    const items = document.querySelectorAll('.format-priority-item');
+    
+    items.forEach(item => {
+      item.addEventListener('mousedown', function(e) {
+        isDraggingFormat = true;
+        draggedFormatElement = this;
+        this.style.opacity = '0.5';
+        document.body.style.userSelect = 'none';
+        e.preventDefault();
+      });
+    });
+    
+    document.addEventListener('mousemove', function(e) {
+      if (!isDraggingFormat || !draggedFormatElement) return;
+      
+      const container = document.getElementById('format_priority_list');
+      const afterElement = getFormatAfterElement(container, e.clientY);
+      
+      if (afterElement == null) {
+        container.appendChild(draggedFormatElement);
+      } else {
+        container.insertBefore(draggedFormatElement, afterElement);
+      }
+    });
+    
+    document.addEventListener('mouseup', function(e) {
+      if (!isDraggingFormat) return;
+      
+      isDraggingFormat = false;
+      if (draggedFormatElement) {
+        draggedFormatElement.style.opacity = '1';
+        draggedFormatElement = null;
+      }
+      document.body.style.userSelect = '';
+      updateFormatPriorityHiddenInput();
+    });
+  }
+  
+  function getFormatAfterElement(container, y) {
+    const draggableElements = [...container.querySelectorAll('.format-priority-item')].filter(el => el.style.opacity !== '0.5');
+    
+    return draggableElements.reduce((closest, child) => {
+      const box = child.getBoundingClientRect();
+      const offset = y - box.top - box.height / 2;
+      
+      if (offset < 0 && offset > closest.offset) {
+        return { offset: offset, element: child };
+      } else {
+        return closest;
+      }
+    }, { offset: Number.NEGATIVE_INFINITY }).element;
+  }
+  
+  function updateFormatPriorityHiddenInput() {
+    const container = document.getElementById('format_priority_list');
+    const hiddenInput = document.getElementById('duplicate_format_priority');
+    const items = container.querySelectorAll('.format-priority-item');
+    
+    // Recalculate priorities based on order (top = highest)
+    const formatPriority = {};
+    const totalItems = items.length;
+    
+    items.forEach((item, index) => {
+      const format = item.dataset.format;
+      // Higher priority for items at the top
+      const priority = 100 - (index * Math.floor(100 / totalItems));
+      formatPriority[format] = priority;
+    });
+    
+    hiddenInput.value = JSON.stringify(formatPriority);
+    
+    // Update priority badges
+    items.forEach((item, index) => {
+      const format = item.dataset.format;
+      const priorityBadge = item.querySelector('span:last-child');
+      if (priorityBadge) {
+        priorityBadge.textContent = `Priority: ${formatPriority[format]}`;
+      }
+    });
+  }
+  
+  // Initialize format priority list on page load
+  initializeFormatPriorityList();
 });
 </script>
 {% endblock %}
diff --git a/cps/templates/duplicates.html b/cps/templates/duplicates.html
index 983fc68..e46ed3c 100644
--- a/cps/templates/duplicates.html
+++ b/cps/templates/duplicates.html
@@ -21,7 +21,7 @@
       border-bottom: 3px solid #e74c3c;
       background: linear-gradient(90deg, rgba(231, 76, 60, 0.2) 0%, rgba(231, 76, 60, 0.04) 100%);
       border-radius: 8px;
-      padding: 15px;
+      padding: 3rem;
       margin: -10px -10px 25px -10px;
   }
   .duplicate-title {
@@ -38,14 +38,14 @@
       font-weight: 500;
   }
   .duplicate-count {
-      color: #e74c3c;
+      color: white;
       font-weight: 700;
-      font-style: italic;
-      background: linear-gradient(135deg, rgba(231, 76, 60, 0.1) 0%, rgba(231, 76, 60, 0.05) 100%);
+      background: linear-gradient(135deg, rgb(231 76 60 / 51%) 0%, rgb(231 76 60 / 42%) 100%);
       padding: 6px 12px;
       border-radius: 6px;
       display: inline-block;
       border: 1px solid rgba(231, 76, 60, 0.2);
+      text-transform: capitalize;
   }
   .books-grid {
       display: flex;
@@ -260,10 +260,35 @@
       cursor: not-allowed;
   }
   .selection-info {
-      margin-left: 15px;
       font-weight: 600;
-      color: #28a745;
+      color: white;
       text-shadow: 0 1px 2px rgba(40, 167, 69, 0.1);
+      background: #cc7b1969;
+      padding: 1rem;
+      max-height: 37px;
+      border-radius: 4px;
+      text-transform: capitalize;
+      line-height: normal;
+      padding-inline: 1.5rem;
+  }
+  div.bulk-actions > div.form-inline {
+      display: flex;
+      flex-direction: row;
+      flex-wrap: wrap;
+      justify-content: flex-start;
+      gap: 1rem;
+  }
+  .glyphicon.glyphicon-refresh {
+      font-size: smaller !important;
+      margin-right: 6px;
+  }
+  .container-fluid img {
+      display: block;
+      width: max(10vw,120px) !important;
+      height: auto;
+      max-width: 26rem;
+      margin: auto;
+      box-shadow: 0 0 12px rgba(0, 0, 0, 0.6);
   }
   @media (max-width: 768px) {
     .books-grid {
@@ -287,6 +312,9 @@
       {% if duplicate_groups %}
         <div class="bulk-actions">
           <div class="form-inline">
+            <button type="button" class="btn btn-sm btn-default" id="trigger_scan">
+              <span class="glyphicon glyphicon-refresh"></span> {{_('Scan for Duplicates Now')}}
+            </button>
             <button type="button" class="btn btn-sm btn-default" id="select_all">{{_('Select Duplicates')}}</button>
             <button type="button" class="btn btn-sm btn-default" id="select_none">{{_('Select None')}}</button>
             <button type="button" class="btn btn-sm btn-danger disabled" id="delete_selected" aria-disabled="true">{{_('Delete Selected')}}</button>
@@ -294,6 +322,41 @@
           </div>
         </div>
 
+        <!-- Auto-Resolution Section -->
+        <div class="settings-container" style="margin-bottom: 30px; padding: 25px; background: #1c28328a; border-radius: 10px; margin-inline: 0rem; max-width: none;">
+          <h4 style="color: white; margin-bottom: 15px; display: flex; align-items: center;">
+            <span class="glyphicon glyphicon-cog" style="margin-right: 10px;"></span>
+            {{_('Auto-Resolve Duplicates')}}
+          </h4>
+          
+          <p style="color: #bbb; margin-bottom: 20px;">
+            {{_('Automatically resolve all duplicate groups by keeping one book and deleting others based on a strategy.')}}
+          </p>
+          
+          <div style="display: flex; align-items: center; gap: 15px; flex-wrap: wrap;">
+            <label for="resolution_strategy" style="color: white; font-weight: 600;">{{_('Strategy:')}}</label>
+            <select id="resolution_strategy" class="form-control" style="background: #1c2832; color: white; border: 1px solid #444;">
+              <option value="newest">{{_('Keep Newest - Delete older copies, keep the most recently added')}}</option>
+              <option value="highest_quality_format">{{_('Keep Highest Quality Format - Prefer EPUB > KEPUB > AZW3 > MOBI > PDF')}}</option>
+              <option value="most_metadata">{{_('Keep Most Metadata - Keep book with most complete information')}}</option>
+              <option value="largest_file_size">{{_('Keep Largest File Size - Keep book with largest total file size')}}</option>
+            </select>
+            
+            <button type="button" class="btn btn-default" id="preview_resolution">
+              <span class="glyphicon glyphicon-eye-open"></span> {{_('Preview')}}
+            </button>
+            
+            <button type="button" class="btn btn-danger disabled" id="execute_resolution" aria-disabled="true">
+              <span class="glyphicon glyphicon-flash"></span> {{_('Execute Resolution')}}
+            </button>
+          </div>
+          
+          <div class="cwa-settings-tip" style="margin-top: 15px; background: rgba(231, 76, 60, 0.15); border-left: 3px solid #e74c3c; padding: 12px; border-radius: 4px;">
+            <strong style="color: #e74c3c;">⚠️ {{_('Warning:')}}</strong>
+            <span style="color: #ddd;">{{_('This will permanently delete books. Original files will be backed up to')}} <code style="background: #2a3441; padding: 2px 6px; border-radius: 3px; color: #f39c12; line-break: anywhere;">/config/processed_books/duplicate_resolutions/</code></span>
+          </div>
+        </div>
+
         <div class="duplicates-container">
           {% for group in duplicate_groups %}
           <div class="duplicate-group" data-group-hash="{{ group.group_hash }}">
@@ -379,6 +442,26 @@
   </div>
 </div>
 
+<!-- Resolution Preview Modal -->
+<div class="modal fade" id="resolution_preview_modal" role="dialog">
+  <div class="modal-dialog modal-lg" style="width: 50%; max-width: 1200px;">
+    <div class="modal-content">
+      <div class="modal-header" style="background: #e59029; color: white;">
+        <button type="button" class="close" data-dismiss="modal" style="color: white;">&times;</button>
+        <h4 class="modal-title">
+          <span class="glyphicon glyphicon-eye-open"></span> {{_('Resolution Preview')}}
+        </h4>
+      </div>
+      <div class="modal-body" id="resolution_preview_body" style="max-height: 600px; overflow-y: auto; padding: 3rem;">
+        <!-- Preview content will be injected here -->
+      </div>
+      <div class="modal-footer">
+        <button type="button" class="btn btn-default" data-dismiss="modal">{{_('Close')}}</button>
+      </div>
+    </div>
+  </div>
+</div>
+
 <!-- Success Modal -->
 <div class="modal fade" id="success_modal" role="dialog" aria-labelledby="successModalLabel">
   <div class="modal-dialog">
diff --git a/root/etc/s6-overlay/s6-rc.d/cwa-init/run b/root/etc/s6-overlay/s6-rc.d/cwa-init/run
index 9221be8..e6164c7 100755
--- a/root/etc/s6-overlay/s6-rc.d/cwa-init/run
+++ b/root/etc/s6-overlay/s6-rc.d/cwa-init/run
@@ -90,6 +90,7 @@ install -d -o abc -g abc /config/processed_books/converted
 install -d -o abc -g abc /config/processed_books/imported
 install -d -o abc -g abc /config/processed_books/failed
 install -d -o abc -g abc /config/processed_books/fixed_originals
+install -d -o abc -g abc /config/processed_books/duplicate_resolutions
 install -d -o abc -g abc /config/log_archive
 install -d -o abc -g abc /config/.cwa_conversion_tmp
 
diff --git a/scripts/cwa_db.py b/scripts/cwa_db.py
index 5d1f52e..1ba3c4c 100644
--- a/scripts/cwa_db.py
+++ b/scripts/cwa_db.py
@@ -250,7 +250,7 @@ class CWA_DB:
         integer_settings = ['ingest_timeout_minutes', 'auto_send_delay_minutes']
         
         # Define which settings should remain as JSON strings (not split by comma)
-        json_settings = ['metadata_provider_hierarchy', 'metadata_providers_enabled']
+        json_settings = ['metadata_provider_hierarchy', 'metadata_providers_enabled', 'duplicate_format_priority']
 
         for header in headers:
             if isinstance(cwa_settings[header], int) and header not in integer_settings:
@@ -2096,6 +2096,126 @@ class CWA_DB:
                 }
             }
 
+    def invalidate_duplicate_cache(self):
+        """Mark duplicate cache as needing refresh"""
+        try:
+            self.cur.execute("""
+                UPDATE cwa_duplicate_cache 
+                SET scan_pending = 1 
+                WHERE id = 1
+            """)
+            self.con.commit()
+            return True
+        except Exception as e:
+            print(f"[cwa-db] Error invalidating duplicate cache: {e}")
+            return False
+
+    def get_duplicate_cache(self):
+        """Get cached duplicate scan results"""
+        import json
+        try:
+            self.cur.execute("""
+                SELECT scan_timestamp, duplicate_groups_json, total_count, scan_pending
+                FROM cwa_duplicate_cache 
+                WHERE id = 1
+            """)
+            row = self.cur.fetchone()
+            if row and row[1]:  # Has cached data
+                return {
+                    'scan_timestamp': row[0],
+                    'duplicate_groups': json.loads(row[1]),
+                    'total_count': row[2],
+                    'scan_pending': bool(row[3])
+                }
+            return None
+        except Exception as e:
+            print(f"[cwa-db] Error getting duplicate cache: {e}")
+            return None
+
+    def update_duplicate_cache(self, duplicate_groups, total_count):
+        """Update duplicate cache with fresh scan results"""
+        import json
+        from datetime import datetime
+        try:
+            # Serialize duplicate groups to JSON (extract only serializable data)
+            serializable_groups = []
+            for group in duplicate_groups:
+                serializable_group = {
+                    'title': group.get('title', ''),
+                    'author': group.get('author', ''),
+                    'count': group.get('count', 0),
+                    'group_hash': group.get('group_hash', ''),
+                    'book_ids': [book.id for book in group.get('books', [])]
+                }
+                serializable_groups.append(serializable_group)
+            
+            groups_json = json.dumps(serializable_groups)
+            
+            self.cur.execute("""
+                UPDATE cwa_duplicate_cache 
+                SET scan_timestamp = ?, 
+                    duplicate_groups_json = ?, 
+                    total_count = ?, 
+                    scan_pending = 0
+                WHERE id = 1
+            """, (datetime.now().isoformat(), groups_json, total_count))
+            self.con.commit()
+            return True
+        except Exception as e:
+            print(f"[cwa-db] Error updating duplicate cache: {e}")
+            return False
+
+    def log_duplicate_resolution(self, group_hash, group_title, group_author, kept_book_id, 
+                                 deleted_book_ids, strategy, trigger_type, user_id=None, notes=None):
+        """Log a duplicate resolution to audit table"""
+        import json
+        try:
+            self.cur.execute("""
+                INSERT INTO cwa_duplicate_resolutions 
+                (group_hash, group_title, group_author, kept_book_id, deleted_book_ids, 
+                 strategy, trigger_type, user_id, notes)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (group_hash, group_title, group_author, kept_book_id, 
+                  json.dumps(deleted_book_ids), strategy, trigger_type, user_id, notes))
+            self.con.commit()
+            return True
+        except Exception as e:
+            print(f"[cwa-db] Error logging duplicate resolution: {e}")
+            return False
+
+    def get_resolution_history(self, limit=100):
+        """Get recent resolution history"""
+        import json
+        try:
+            self.cur.execute("""
+                SELECT id, timestamp, group_hash, group_title, group_author, 
+                       kept_book_id, deleted_book_ids, strategy, trigger_type, user_id, notes
+                FROM cwa_duplicate_resolutions 
+                ORDER BY timestamp DESC 
+                LIMIT ?
+            """, (limit,))
+            
+            results = []
+            for row in self.cur.fetchall():
+                results.append({
+                    'id': row[0],
+                    'timestamp': row[1],
+                    'group_hash': row[2],
+                    'group_title': row[3],
+                    'group_author': row[4],
+                    'kept_book_id': row[5],
+                    'deleted_book_ids': json.loads(row[6]),
+                    'strategy': row[7],
+                    'trigger_type': row[8],
+                    'user_id': row[9],
+                    'notes': row[10]
+                })
+            return results
+        except Exception as e:
+            print(f"[cwa-db] Error getting resolution history: {e}")
+            return []
+
+
 def main():
     db = CWA_DB()
 
diff --git a/scripts/cwa_schema.sql b/scripts/cwa_schema.sql
index e439969..d416b90 100755
--- a/scripts/cwa_schema.sql
+++ b/scripts/cwa_schema.sql
@@ -71,9 +71,11 @@ CREATE TABLE IF NOT EXISTS cwa_settings(
     duplicate_detection_publisher SMALLINT DEFAULT 0 NOT NULL,
     duplicate_detection_format SMALLINT DEFAULT 0 NOT NULL,
     -- Duplicate notification and auto-resolution settings
+    duplicate_detection_enabled SMALLINT DEFAULT 1 NOT NULL,
     duplicate_notifications_enabled SMALLINT DEFAULT 1 NOT NULL,
     duplicate_auto_resolve_enabled SMALLINT DEFAULT 0 NOT NULL,
-    duplicate_auto_resolve_strategy TEXT DEFAULT 'newest' NOT NULL
+    duplicate_auto_resolve_strategy TEXT DEFAULT 'newest' NOT NULL,
+    duplicate_format_priority TEXT DEFAULT '{"EPUB":100,"KEPUB":95,"AZW3":90,"MOBI":80,"AZW":75,"PDF":60,"TXT":40,"CBZ":35,"CBR":35,"FB2":30,"DJVU":25,"HTML":20,"RTF":15,"DOC":10,"DOCX":10}' NOT NULL
 );
 
 -- Persisted scheduled jobs (initial focus: auto-send). Rows remain until dispatched or manually cleared.
@@ -104,3 +106,34 @@ CREATE TABLE IF NOT EXISTS cwa_user_activity (
 CREATE INDEX IF NOT EXISTS idx_activity_user ON cwa_user_activity(user_id);
 CREATE INDEX IF NOT EXISTS idx_activity_event ON cwa_user_activity(event_type);
 CREATE INDEX IF NOT EXISTS idx_activity_time ON cwa_user_activity(timestamp);
+
+-- Duplicate detection cache table
+CREATE TABLE IF NOT EXISTS cwa_duplicate_cache (
+    id INTEGER PRIMARY KEY CHECK (id = 1),  -- Singleton table, only one row
+    scan_timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+    duplicate_groups_json TEXT,  -- JSON serialized duplicate groups
+    total_count INTEGER DEFAULT 0,
+    scan_pending INTEGER DEFAULT 1  -- 1=needs scan, 0=cache valid
+);
+
+-- Insert default row for cache table
+INSERT OR IGNORE INTO cwa_duplicate_cache (id, scan_pending) VALUES (1, 1);
+
+-- Auto-resolution audit log
+CREATE TABLE IF NOT EXISTS cwa_duplicate_resolutions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+    group_hash TEXT NOT NULL,
+    group_title TEXT,
+    group_author TEXT,
+    kept_book_id INTEGER NOT NULL,
+    deleted_book_ids TEXT NOT NULL,  -- JSON array of deleted IDs
+    strategy TEXT NOT NULL,  -- 'newest', 'highest_quality_format', 'most_metadata', 'largest_file_size'
+    trigger_type TEXT NOT NULL,  -- 'manual', 'scheduled', 'automatic'
+    backed_up INTEGER DEFAULT 1,  -- 1=yes, 0=no
+    user_id INTEGER,  -- NULL for automatic, admin user ID for manual
+    notes TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_duplicate_resolutions_timestamp ON cwa_duplicate_resolutions(timestamp);
+CREATE INDEX IF NOT EXISTS idx_duplicate_resolutions_group_hash ON cwa_duplicate_resolutions(group_hash);
diff --git a/scripts/ingest_processor.py b/scripts/ingest_processor.py
index 28c884c..0c10300 100644
--- a/scripts/ingest_processor.py
+++ b/scripts/ingest_processor.py
@@ -760,6 +760,9 @@ class NewBookProcessor:
             # This solves the issue where multiple books don't appear until container restart
             self.refresh_cwa_session()
 
+            # Invalidate duplicate cache since a new book was added
+            self.invalidate_duplicate_cache()
+
             # Generate KOReader sync checksums for the imported book
             if self.last_added_book_id is not None:
                 self.generate_book_checksums(staged_path.stem, book_id=self.last_added_book_id)
@@ -1102,6 +1105,28 @@ class NewBookProcessor:
             print("[ingest-processor] Continuing despite session refresh failure - books may require manual refresh", flush=True)
 
 
+    def invalidate_duplicate_cache(self) -> None:
+        """Invalidate the duplicate detection cache after adding a new book
+
+        This triggers a fresh duplicate scan on the next status check.
+        """
+        try:
+            url = get_internal_api_url("/duplicates/invalidate-cache")
+            resp = requests.post(
+                url,
+                headers=get_internal_api_headers(),
+                timeout=5,
+                verify=False,
+            )
+            if resp.status_code == 200:
+                print("[ingest-processor] Duplicate cache invalidated", flush=True)
+            else:
+                print(f"[ingest-processor] WARN: Duplicate cache invalidation returned {resp.status_code}", flush=True)
+        except Exception as e:
+            # Don't fail the import if cache invalidation fails
+            print(f"[ingest-processor] WARN: Failed to invalidate duplicate cache: {e}", flush=True)
+
+
     def set_library_permissions(self):
         try:
             nsm = os.getenv("NETWORK_SHARE_MODE", "false").strip().lower() in ("1", "true", "yes", "on")