From 3a01fc4622065c419e0c4e5da1642443d9256f72 Mon Sep 17 00:00:00 2001
From: Vedank Purohit <VedankPurohit2@gmail.com>
Date: Sat, 14 Feb 2026 18:12:50 +0530
Subject: [PATCH 1/5] feat: Add force recompress and update compression
 defaults

Change default compression quality from 85 to 75 and age threshold
from 60 to 90 days. Add force recompression feature that allows
re-compressing all screenshots (including already compressed) older
than a user-selected age, with preview and warning UI in Settings.

- Update CompressionSettings defaults (quality 75, after_days 90)
- Add force recompression DB methods with breakdown counts
- Add batched force recompress with progress callbacks
- Add API preview and execute endpoints with Pydantic schemas
- Add force recompress modal in Settings with age selector and warnings
---
 api/routes/compression.py     |  73 +++++++++++++++++++++
 api/schemas.py                |  31 +++++++++
 core/compression.py           |  70 ++++++++++++++++++--
 core/config.py                |   4 +-
 core/database.py              |  39 +++++++++++
 web/src/app/settings/page.tsx | 119 +++++++++++++++++++++++++++++++++-
 web/src/lib/api.ts            |  15 +++++
 web/src/types/index.ts        |   7 ++
 8 files changed, 350 insertions(+), 8 deletions(-)

diff --git a/api/routes/compression.py b/api/routes/compression.py
index 73ef036..f5cf2a5 100644
--- a/api/routes/compression.py
+++ b/api/routes/compression.py
@@ -10,6 +10,10 @@
     CompressionStartResponse,
     CompressionStats,
     CompressionStatus,
+    ForceRecompressPreviewRequest,
+    ForceRecompressPreviewResponse,
+    ForceRecompressRequest,
+    ForceRecompressResponse,
 )
 from core.compression import CompressionProgress, compression_service
 from core.config import config
@@ -119,3 +123,72 @@ async def get_compression_stats():
         original_size_bytes=stats["original_size_bytes"],
         estimated_savings_bytes=estimated_savings,
     )
+
+
+@router.post("/force-recompress/preview", response_model=ForceRecompressPreviewResponse)
+async def preview_force_recompress(request: ForceRecompressPreviewRequest):
+    """
+    Preview force recompression impact.
+
+    Shows how many screenshots would be affected by force recompression,
+    including how many are already compressed (which will lose quality).
+    """
+    counts = db.get_force_recompressible_count(request.older_than_days)
+
+    warning = ""
+    if counts["already_compressed"] > 0:
+        warning = (
+            f"{counts['already_compressed']} screenshots are already compressed. "
+            "Re-compressing them will further reduce quality and cannot be undone."
+        )
+
+    return ForceRecompressPreviewResponse(
+        total_count=counts["total"],
+        already_compressed_count=counts["already_compressed"],
+        not_compressed_count=counts["not_compressed"],
+        warning=warning,
+    )
+
+
+@router.post("/force-recompress", response_model=ForceRecompressResponse)
+async def start_force_recompress(request: ForceRecompressRequest):
+    """
+    Start force recompression of all screenshots older than specified days.
+
+    Unlike normal compression, this will re-compress already-compressed screenshots.
+    This is destructive and cannot be undone.
+
+    Requires confirm=true to proceed.
+    """
+    if not request.confirm:
+        return ForceRecompressResponse(
+            success=False,
+            message="Must set confirm=true to proceed with force recompression",
+            affected_count=0,
+        )
+
+    if compression_service.is_running:
+        return ForceRecompressResponse(
+            success=False,
+            message="Compression is already running",
+            affected_count=0,
+        )
+
+    counts = db.get_force_recompressible_count(request.older_than_days)
+    if counts["total"] == 0:
+        return ForceRecompressResponse(
+            success=True,
+            message=f"No screenshots older than {request.older_than_days} days found",
+            affected_count=0,
+        )
+
+    compression_service.start_force_recompress(
+        older_than_days=request.older_than_days,
+        quality=request.quality,
+    )
+
+    return ForceRecompressResponse(
+        success=True,
+        message=f"Force recompression started for {counts['total']} screenshots",
+        affected_count=counts["total"],
+    )
diff --git a/api/schemas.py b/api/schemas.py
index b5e7981..751dfbf 100644
--- a/api/schemas.py
+++ b/api/schemas.py
@@ -146,6 +146,37 @@ class CompressionStartResponse(BaseModel):
     compressible_count: int
 
 
+class ForceRecompressPreviewRequest(BaseModel):
+    """Request to preview force recompression"""
+
+    older_than_days: int = Field(ge=30, le=365)
+
+
+class ForceRecompressPreviewResponse(BaseModel):
+    """Preview of force recompression impact"""
+
+    total_count: int
+    already_compressed_count: int
+    not_compressed_count: int
+    warning: str
+
+
+class ForceRecompressRequest(BaseModel):
+    """Request to start force recompression"""
+
+    older_than_days: int = Field(ge=30, le=365)
+    quality: int | None = Field(None, ge=50, le=90)
+    confirm: bool = False
+
+
+class ForceRecompressResponse(BaseModel):
+    """Response after starting force recompression"""
+
+    success: bool
+    message: str
+    affected_count: int
+
+
 class SyncStartRequest(BaseModel):
     """Request to start sync"""
 
diff --git a/core/compression.py b/core/compression.py
index 580849e..d02887a 100644
--- a/core/compression.py
+++ b/core/compression.py
@@ -130,18 +130,22 @@ def _compress_loop(self, older_than_days: int, quality: int, batch_size: int):
             f"✅ Compression complete: {self._progress.processed} processed, {self._progress.bytes_saved // 1024}KB saved"
         )
 
-    def _compress_screenshot(self, screenshot: dict, quality: int) -> int:
+    def _compress_screenshot(self, screenshot: dict, quality: int, force: bool = False) -> int:
         """
-        Compress a single screenshot.
-        Returns bytes saved.
+        Compress a single screenshot. Returns bytes saved.
+
+        Args:
+            screenshot: Screenshot dict from database
+            quality: JPEG quality (1-100)
+            force: If True, compress even if already compressed (for force recompression)
         """
         image_path = Path(screenshot["image_path"])
 
         if not image_path.exists():
             raise FileNotFoundError(f"Image not found: {image_path}")
 
-        # Double-check not already compressed (safety)
-        if screenshot.get("is_compressed"):
+        # Skip already compressed unless force mode
+        if screenshot.get("is_compressed") and not force:
             return 0
 
         # Get original size
@@ -196,6 +200,62 @@ def compress_now(
         self._progress.is_running = False
         return self._progress
 
+    def start_force_recompress(
+        self,
+        older_than_days: int,
+        quality: int | None = None,
+        on_progress: Callable[[CompressionProgress], None] | None = None,
+    ):
+        """Start force recompression in background thread"""
+        if self._running:
+            return False
+
+        if quality is None:
+            quality = config.compression.quality
+
+        self._running = True
+        self._cancel_requested = False
+        self._on_progress = on_progress
+
+        def run():
+            try:
+                total = db.get_force_recompressible_count(older_than_days)["total"]
+                self._progress = CompressionProgress(total=total, processed=0, errors=0, bytes_saved=0, is_running=True)
+
+                batch_size = 50
+                processed_ids: set[int] = set()
+
+                while self._running and not self._cancel_requested:
+                    screenshots = db.get_force_recompressible_screenshots(older_than_days, limit=batch_size)
+                    # Filter out already-processed in this run
+                    screenshots = [s for s in screenshots if s["id"] not in processed_ids]
+
+                    if not screenshots:
+                        break
+
+                    for screenshot in screenshots:
+                        if self._cancel_requested:
+                            break
+                        processed_ids.add(screenshot["id"])
+                        try:
+                            saved = self._compress_screenshot(screenshot, quality, force=True)
+                            self._progress.processed += 1
+                            self._progress.bytes_saved += saved
+                        except Exception as e:
+                            print(f"Error compressing {screenshot['image_path']}: {e}")
+                            self._progress.errors += 1
+
+                        if self._on_progress:
+                            self._on_progress(self._progress)
+            finally:
+                self._progress.is_running = False
+                self._cancel_requested = False
+                self._running = False
+
+        self._thread = threading.Thread(target=run, daemon=True)
+        self._thread.start()
+        return True
+
 
 # Global compression service instance
 compression_service = CompressionService()
diff --git a/core/config.py b/core/config.py
index d205bc2..7b28063 100644
--- a/core/config.py
+++ b/core/config.py
@@ -52,8 +52,8 @@ class CompressionSettings:
     """Auto-compression settings for old screenshots"""
 
     enabled: bool = False  # Off by default
-    after_days: int = 60  # Compress screenshots older than 2 months
-    quality: int = 85  # JPEG quality for compressed images
+    after_days: int = 90  # Compress screenshots older than 3 months
+    quality: int = 75  # JPEG quality for compressed images
 
 
 # =============================================================================
diff --git a/core/database.py b/core/database.py
index 8a62800..82b4035 100644
--- a/core/database.py
+++ b/core/database.py
@@ -708,6 +708,45 @@ def get_compressible_count(self, older_than_days: int) -> int:
             )
             return cur.fetchone()[0]
 
+    def get_force_recompressible_screenshots(self, older_than_days: int, limit: int | None = None) -> list[dict]:
+        """Get all screenshots older than specified days (including already compressed)"""
+        with self.cursor() as cur:
+            query = """
+                SELECT * FROM screenshots
+                WHERE created_at < datetime('now', ?)
+                ORDER BY created_at ASC
+            """
+            days_ago = f"-{older_than_days} days"
+
+            if limit:
+                query += " LIMIT ?"
+                cur.execute(query, (days_ago, limit))
+            else:
+                cur.execute(query, (days_ago,))
+
+            return [dict(row) for row in cur.fetchall()]
+
+    def get_force_recompressible_count(self, older_than_days: int) -> dict:
+        """Get count of screenshots eligible for force recompression"""
+        with self.cursor() as cur:
+            cur.execute(
+                """
+                SELECT
+                    COUNT(*) as total,
+                    SUM(CASE WHEN is_compressed = 1 THEN 1 ELSE 0 END) as already_compressed,
+                    SUM(CASE WHEN is_compressed = 0 THEN 1 ELSE 0 END) as not_compressed
+                FROM screenshots
+                WHERE created_at < datetime('now', ?)
+            """,
+                (f"-{older_than_days} days",),
+            )
+            row = cur.fetchone()
+            return {
+                "total": row[0] or 0,
+                "already_compressed": row[1] or 0,
+                "not_compressed": row[2] or 0,
+            }
+
     def mark_compressed(
         self,
         screenshot_id: int,
diff --git a/web/src/app/settings/page.tsx b/web/src/app/settings/page.tsx
index 79bf35e..2e85880 100644
--- a/web/src/app/settings/page.tsx
+++ b/web/src/app/settings/page.tsx
@@ -13,8 +13,10 @@ import {
   startCompression,
   getCompressionStatus,
   getCompressionStats,
+  previewForceRecompress,
+  startForceRecompress,
 } from '@/lib/api';
-import type { AppConfig, SystemStatus, SyncStatus, CompressionStatus, CompressionStats, VisibilityFilter } from '@/types';
+import type { AppConfig, SystemStatus, SyncStatus, CompressionStatus, CompressionStats, VisibilityFilter, ForceRecompressPreview } from '@/types';
 
 const STORAGE_KEYS = {
   VISIBILITY_FILTER: 'liverecall_visibility_filter',
@@ -49,6 +51,10 @@ export default function SettingsPage() {
   const [compressionStatus, setCompressionStatus] = useState<CompressionStatus | null>(null);
   const [compressionStats, setCompressionStats] = useState<CompressionStats | null>(null);
   const [visibilityFilter, setVisibilityFilter] = useState<VisibilityFilter>('visible_only');
+  const [showForceRecompress, setShowForceRecompress] = useState(false);
+  const [forceRecompressAge, setForceRecompressAge] = useState(90);
+  const [forceRecompressPreview, setForceRecompressPreview] = useState<ForceRecompressPreview | null>(null);
+  const [forceRecompressLoading, setForceRecompressLoading] = useState(false);
 
   // Load visibility filter from localStorage
   useEffect(() => {
@@ -125,6 +131,42 @@ export default function SettingsPage() {
     }
   };
 
+  const handleOpenForceRecompress = async () => {
+    setShowForceRecompress(true);
+    setForceRecompressLoading(true);
+    try {
+      const preview = await previewForceRecompress(forceRecompressAge);
+      setForceRecompressPreview(preview);
+    } catch (err) {
+      console.error('Failed to preview:', err);
+    } finally {
+      setForceRecompressLoading(false);
+    }
+  };
+
+  const handleForceRecompressAgeChange = async (days: number) => {
+    setForceRecompressAge(days);
+    setForceRecompressLoading(true);
+    try {
+      const preview = await previewForceRecompress(days);
+      setForceRecompressPreview(preview);
+    } catch (err) {
+      console.error('Failed to preview:', err);
+    } finally {
+      setForceRecompressLoading(false);
+    }
+  };
+
+  const handleForceRecompress = async () => {
+    try {
+      await startForceRecompress(forceRecompressAge);
+      setShowForceRecompress(false);
+      setForceRecompressPreview(null);
+    } catch (err) {
+      console.error('Failed to start force recompression:', err);
+    }
+  };
+
   if (!config || !status) {
     return (
       <div className="min-h-screen bg-black flex items-center justify-center">
@@ -351,6 +393,15 @@ export default function SettingsPage() {
                 {compressionStatus?.is_compressing ? 'Running...' : 'Compress'}
               </button>
             </Row>
+            <Row label="Force recompress" value="Re-compress all images">
+              <button
+                onClick={handleOpenForceRecompress}
+                disabled={compressionStatus?.is_compressing}
+                className="px-2.5 py-1 rounded text-xs text-[#ef4444] hover:bg-[#ef4444]/10 disabled:opacity-40 disabled:cursor-not-allowed transition-colors"
+              >
+                Force...
+              </button>
+            </Row>
           </Section>
 
           {/* Stats */}
@@ -382,6 +433,72 @@ export default function SettingsPage() {
           <span>{status.database.total_screenshots} snapshots</span>
         </div>
       </footer>
+
+      {/* Force Recompress Modal */}
+      {showForceRecompress && (
+        <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/70">
+          <div className="bg-[#111] border border-[#1e1e1e] rounded-lg w-80 p-5">
+            <h3 className="text-sm font-medium text-[#f5f5f5] mb-4">Force Recompress</h3>
+
+            <div className="mb-4">
+              <label className="text-xs text-[#555] mb-1.5 block">Older than</label>
+              <select
+                value={forceRecompressAge}
+                onChange={(e) => handleForceRecompressAgeChange(Number(e.target.value))}
+                className="w-full bg-[#0f0f0f] text-[#f5f5f5] px-2.5 py-1.5 rounded border border-[#1e1e1e] text-xs focus:border-[#86efac]/50 focus:outline-none"
+              >
+                <option value={30}>1 month</option>
+                <option value={60}>2 months</option>
+                <option value={90}>3 months</option>
+                <option value={180}>6 months</option>
+                <option value={365}>1 year</option>
+              </select>
+            </div>
+
+            {forceRecompressLoading ? (
+              <div className="flex items-center justify-center py-4">
+                <div className="w-4 h-4 border border-[#333] border-t-[#86efac] rounded-full animate-spin" />
+              </div>
+            ) : forceRecompressPreview && (
+              <div className="space-y-2 mb-4">
+                <div className="flex justify-between text-xs">
+                  <span className="text-[#555]">Total affected</span>
+                  <span className="text-[#f5f5f5]">{forceRecompressPreview.total_count.toLocaleString()}</span>
+                </div>
+                <div className="flex justify-between text-xs">
+                  <span className="text-[#555]">Not yet compressed</span>
+                  <span className="text-[#8a8a8a]">{forceRecompressPreview.not_compressed_count.toLocaleString()}</span>
+                </div>
+                <div className="flex justify-between text-xs">
+                  <span className="text-[#555]">Already compressed</span>
+                  <span className="text-[#ef4444]">{forceRecompressPreview.already_compressed_count.toLocaleString()}</span>
+                </div>
+                {forceRecompressPreview.warning && (
+                  <div className="mt-2 p-2 rounded bg-[#ef4444]/10 border border-[#ef4444]/20">
+                    <p className="text-[10px] text-[#ef4444]">{forceRecompressPreview.warning}</p>
+                  </div>
+                )}
+              </div>
+            )}
+
+            <div className="flex gap-2 justify-end">
+              <button
+                onClick={() => { setShowForceRecompress(false); setForceRecompressPreview(null); }}
+                className="px-3 py-1.5 rounded text-xs text-[#8a8a8a] hover:bg-[#1e1e1e] transition-colors"
+              >
+                Cancel
+              </button>
+              <button
+                onClick={handleForceRecompress}
+                disabled={forceRecompressLoading || !forceRecompressPreview?.total_count}
+                className="px-3 py-1.5 rounded text-xs text-[#ef4444] bg-[#ef4444]/10 hover:bg-[#ef4444]/20 disabled:opacity-40 disabled:cursor-not-allowed transition-colors"
+              >
+                Recompress
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
     </div>
   );
 }
diff --git a/web/src/lib/api.ts b/web/src/lib/api.ts
index 9e3c6db..4da15f4 100644
--- a/web/src/lib/api.ts
+++ b/web/src/lib/api.ts
@@ -5,6 +5,7 @@ import type {
   SearchResult,
   CompressionStatus,
   CompressionStats,
+  ForceRecompressPreview,
   SyncStatus,
   ApiResponse,
   DateRange,
@@ -167,6 +168,20 @@ export async function getCompressionStats(): Promise<CompressionStats> {
   return fetchApi('/compression/stats');
 }
 
+export async function previewForceRecompress(olderThanDays: number): Promise<ForceRecompressPreview> {
+  return fetchApi('/compression/force-recompress/preview', {
+    method: 'POST',
+    body: JSON.stringify({ older_than_days: olderThanDays }),
+  });
+}
+
+export async function startForceRecompress(olderThanDays: number, quality?: number): Promise<ApiResponse<void>> {
+  return fetchApi('/compression/force-recompress', {
+    method: 'POST',
+    body: JSON.stringify({ older_than_days: olderThanDays, quality, confirm: true }),
+  });
+}
+
 // Screenshots
 export async function getScreenshots(
   limit: number = 50,
diff --git a/web/src/types/index.ts b/web/src/types/index.ts
index 51a0f06..ae2983a 100644
--- a/web/src/types/index.ts
+++ b/web/src/types/index.ts
@@ -106,6 +106,13 @@ export interface CompressionStats {
   original_size_bytes: number;
 }
 
+export interface ForceRecompressPreview {
+  total_count: number;
+  already_compressed_count: number;
+  not_compressed_count: number;
+  warning: string;
+}
+
 export interface SyncStatus {
   is_syncing: boolean;
   total: number;

From 687edd98c5bd0a21d56529faad3d8293113b1f26 Mon Sep 17 00:00:00 2001
From: Vedank Purohit <VedankPurohit2@gmail.com>
Date: Sun, 15 Feb 2026 08:15:57 +0530
Subject: [PATCH 2/5] fix: Use offset-based batching for force recompress

The previous approach fetched the same rows each batch since
get_force_recompressible_screenshots doesn't filter on is_compressed.
The processed_ids set filtered them all out, breaking the loop after
the first batch. Switch to LIMIT/OFFSET pagination instead.
---
 core/compression.py | 11 ++++++-----
 core/database.py    | 12 +++++++-----
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/core/compression.py b/core/compression.py
index d02887a..34e4d02 100644
--- a/core/compression.py
+++ b/core/compression.py
@@ -223,12 +223,12 @@ def run():
                 self._progress = CompressionProgress(total=total, processed=0, errors=0, bytes_saved=0, is_running=True)
 
                 batch_size = 50
-                processed_ids: set[int] = set()
+                offset = 0
 
                 while self._running and not self._cancel_requested:
-                    screenshots = db.get_force_recompressible_screenshots(older_than_days, limit=batch_size)
-                    # Filter out already-processed in this run
-                    screenshots = [s for s in screenshots if s["id"] not in processed_ids]
+                    screenshots = db.get_force_recompressible_screenshots(
+                        older_than_days, limit=batch_size, offset=offset
+                    )
 
                     if not screenshots:
                         break
@@ -236,7 +236,6 @@ def run():
                     for screenshot in screenshots:
                         if self._cancel_requested:
                             break
-                        processed_ids.add(screenshot["id"])
                         try:
                             saved = self._compress_screenshot(screenshot, quality, force=True)
                             self._progress.processed += 1
@@ -247,6 +246,8 @@ def run():
 
                         if self._on_progress:
                             self._on_progress(self._progress)
+
+                    offset += batch_size
             finally:
                 self._progress.is_running = False
                 self._cancel_requested = False
diff --git a/core/database.py b/core/database.py
index 82b4035..f2324f3 100644
--- a/core/database.py
+++ b/core/database.py
@@ -708,7 +708,9 @@ def get_compressible_count(self, older_than_days: int) -> int:
             )
             return cur.fetchone()[0]
 
-    def get_force_recompressible_screenshots(self, older_than_days: int, limit: int | None = None) -> list[dict]:
+    def get_force_recompressible_screenshots(
+        self, older_than_days: int, limit: int | None = None, offset: int = 0
+    ) -> list[dict]:
         """Get all screenshots older than specified days (including already compressed)"""
         with self.cursor() as cur:
             query = """
@@ -717,13 +719,13 @@ def get_force_recompressible_screenshots(self, older_than_days: int, limit: int
                 ORDER BY created_at ASC
             """
             days_ago = f"-{older_than_days} days"
+            params: list = [days_ago]
 
             if limit:
-                query += " LIMIT ?"
-                cur.execute(query, (days_ago, limit))
-            else:
-                cur.execute(query, (days_ago,))
+                query += " LIMIT ? OFFSET ?"
+                params.extend([limit, offset])
 
+            cur.execute(query, params)
             return [dict(row) for row in cur.fetchall()]
 
     def get_force_recompressible_count(self, older_than_days: int) -> dict:

From b78517541a72ffd910b79265be01a2b6b345c7c1 Mon Sep 17 00:00:00 2001
From: Vedank Purohit <VedankPurohit2@gmail.com>
Date: Sun, 15 Feb 2026 11:25:46 +0530
Subject: [PATCH 3/5] feat: Add compression suggestion popup and UX
 improvements

- Add floating banner on timeline when compressible screenshots exist
- Banner offers one-click auto-compression enable with dismiss option
- Uses localStorage to remember dismissal across sessions
- Change default compression threshold from 90 to 60 days (2 months)
- Add confirmation checkbox to force recompress modal for safety
---
 core/config.py                               |   2 +-
 web/src/app/page.tsx                         |   4 +
 web/src/app/settings/page.tsx                |  23 +++-
 web/src/components/CompressionSuggestion.tsx | 137 +++++++++++++++++++
 4 files changed, 161 insertions(+), 5 deletions(-)
 create mode 100644 web/src/components/CompressionSuggestion.tsx

diff --git a/core/config.py b/core/config.py
index 7b28063..a7a1d13 100644
--- a/core/config.py
+++ b/core/config.py
@@ -52,7 +52,7 @@ class CompressionSettings:
     """Auto-compression settings for old screenshots"""
 
     enabled: bool = False  # Off by default
-    after_days: int = 90  # Compress screenshots older than 3 months
+    after_days: int = 60  # Compress screenshots older than 2 months
     quality: int = 75  # JPEG quality for compressed images
 
 
diff --git a/web/src/app/page.tsx b/web/src/app/page.tsx
index acc3de1..d75239c 100644
--- a/web/src/app/page.tsx
+++ b/web/src/app/page.tsx
@@ -28,6 +28,7 @@ import { useSelection } from '@/hooks/useSelection';
 import { SelectionToolbar } from '@/components/SelectionToolbar';
 import { ConfirmationDialog } from '@/components/ConfirmationDialog';
 import { IncognitoIndicator } from '@/components/IncognitoIndicator';
+import { CompressionSuggestion } from '@/components/CompressionSuggestion';
 
 // localStorage keys
 const STORAGE_KEYS = {
@@ -1893,6 +1894,9 @@ function HomeContent() {
         confirmVariant="warning"
         isLoading={isBulkOperationLoading}
       />
+
+      {/* Compression suggestion banner */}
+      <CompressionSuggestion />
     </div>
   );
 }
diff --git a/web/src/app/settings/page.tsx b/web/src/app/settings/page.tsx
index 2e85880..ed9ea35 100644
--- a/web/src/app/settings/page.tsx
+++ b/web/src/app/settings/page.tsx
@@ -55,6 +55,7 @@ export default function SettingsPage() {
   const [forceRecompressAge, setForceRecompressAge] = useState(90);
   const [forceRecompressPreview, setForceRecompressPreview] = useState<ForceRecompressPreview | null>(null);
   const [forceRecompressLoading, setForceRecompressLoading] = useState(false);
+  const [forceRecompressConfirmed, setForceRecompressConfirmed] = useState(false);
 
   // Load visibility filter from localStorage
   useEffect(() => {
@@ -133,6 +134,7 @@ export default function SettingsPage() {
 
   const handleOpenForceRecompress = async () => {
     setShowForceRecompress(true);
+    setForceRecompressConfirmed(false);
     setForceRecompressLoading(true);
     try {
       const preview = await previewForceRecompress(forceRecompressAge);
@@ -474,14 +476,27 @@ export default function SettingsPage() {
                   <span className="text-[#ef4444]">{forceRecompressPreview.already_compressed_count.toLocaleString()}</span>
                 </div>
                 {forceRecompressPreview.warning && (
-                  <div className="mt-2 p-2 rounded bg-[#ef4444]/10 border border-[#ef4444]/20">
-                    <p className="text-[10px] text-[#ef4444]">{forceRecompressPreview.warning}</p>
+                  <div className="mt-2 p-2.5 rounded bg-[#ef4444]/10 border border-[#ef4444]/20">
+                    <p className="text-[11px] text-[#ef4444] leading-relaxed">{forceRecompressPreview.warning}</p>
                   </div>
                 )}
+
+                {/* Confirmation checkbox */}
+                <label className="flex items-start gap-2 mt-3 cursor-pointer select-none">
+                  <input
+                    type="checkbox"
+                    checked={forceRecompressConfirmed}
+                    onChange={(e) => setForceRecompressConfirmed(e.target.checked)}
+                    className="mt-0.5 accent-[#ef4444]"
+                  />
+                  <span className="text-[11px] text-[#666] leading-relaxed">
+                    I understand this is irreversible and may reduce image quality
+                  </span>
+                </label>
               </div>
             )}
 
-            <div className="flex gap-2 justify-end">
+            <div className="flex gap-2 justify-end mt-4">
               <button
                 onClick={() => { setShowForceRecompress(false); setForceRecompressPreview(null); }}
                 className="px-3 py-1.5 rounded text-xs text-[#8a8a8a] hover:bg-[#1e1e1e] transition-colors"
@@ -490,7 +505,7 @@ export default function SettingsPage() {
               </button>
               <button
                 onClick={handleForceRecompress}
-                disabled={forceRecompressLoading || !forceRecompressPreview?.total_count}
+                disabled={forceRecompressLoading || !forceRecompressPreview?.total_count || !forceRecompressConfirmed}
                 className="px-3 py-1.5 rounded text-xs text-[#ef4444] bg-[#ef4444]/10 hover:bg-[#ef4444]/20 disabled:opacity-40 disabled:cursor-not-allowed transition-colors"
               >
                 Recompress
diff --git a/web/src/components/CompressionSuggestion.tsx b/web/src/components/CompressionSuggestion.tsx
new file mode 100644
index 0000000..e9cf303
--- /dev/null
+++ b/web/src/components/CompressionSuggestion.tsx
@@ -0,0 +1,137 @@
+'use client';
+
+import { useState, useEffect } from 'react';
+import { getCompressionStats, updateConfig, startCompression } from '@/lib/api';
+import type { CompressionStats } from '@/types';
+
+const DISMISSED_KEY = 'liverecall_compression_dismissed';
+
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(i > 1 ? 1 : 0)} ${units[i]}`;
+}
+
+export function CompressionSuggestion() {
+  const [stats, setStats] = useState<CompressionStats | null>(null);
+  const [visible, setVisible] = useState(false);
+  const [exiting, setExiting] = useState(false);
+  const [enabling, setEnabling] = useState(false);
+
+  useEffect(() => {
+    if (localStorage.getItem(DISMISSED_KEY)) return;
+
+    const fetchStats = async () => {
+      try {
+        const data = await getCompressionStats();
+        if (data.compressible_count > 0) {
+          setStats(data);
+          requestAnimationFrame(() => setVisible(true));
+        }
+      } catch {
+        // Silently fail
+      }
+    };
+
+    fetchStats();
+  }, []);
+
+  const dismiss = () => {
+    setExiting(true);
+    setTimeout(() => {
+      setVisible(false);
+      localStorage.setItem(DISMISSED_KEY, Date.now().toString());
+    }, 300);
+  };
+
+  const handleEnable = async () => {
+    setEnabling(true);
+    try {
+      await updateConfig({ compression_enabled: true });
+      await startCompression();
+      dismiss();
+    } catch (err) {
+      console.error('Failed to enable compression:', err);
+      setEnabling(false);
+    }
+  };
+
+  if (!stats || !visible) return null;
+
+  // ~295KB avg screenshot at quality 95, ~55% savings compressing to 75
+  const estimatedSavings = stats.compressible_count * 295_000 * 0.55;
+
+  return (
+    <div
+      className={`fixed bottom-6 left-1/2 -translate-x-1/2 z-50 transition-all duration-300 ease-out ${
+        exiting
+          ? 'opacity-0 translate-y-4'
+          : 'opacity-100 translate-y-0 animate-slide-up'
+      }`}
+    >
+      <div className="relative bg-[#0a0a0a] border border-[#1e1e1e] rounded-xl px-6 py-5 shadow-2xl shadow-black/60 w-[480px]">
+        {/* Subtle green glow at top */}
+        <div className="absolute inset-x-0 top-0 h-px bg-gradient-to-r from-transparent via-[#86efac]/40 to-transparent rounded-t-xl" />
+
+        <div className="flex items-start gap-4">
+          {/* Icon */}
+          <div className="flex-shrink-0 mt-0.5">
+            <div className="w-10 h-10 rounded-lg bg-[#86efac]/10 flex items-center justify-center">
+              <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="#86efac" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+                <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
+                <polyline points="7 10 12 15 17 10" />
+                <line x1="12" y1="15" x2="12" y2="3" />
+              </svg>
+            </div>
+          </div>
+
+          {/* Content */}
+          <div className="flex-1 min-w-0">
+            <p className="text-sm text-[#f5f5f5] font-medium">
+              Free up {formatBytes(estimatedSavings)} of storage
+            </p>
+            <p className="text-xs text-[#666] mt-1.5 leading-relaxed">
+              You have <span className="text-[#86efac] font-medium">{stats.compressible_count.toLocaleString()}</span> screenshots older than 2 months that can be compressed. Search and embeddings stay untouched.
+            </p>
+
+            {/* Buttons */}
+            <div className="flex items-center gap-2.5 mt-3.5">
+              <button
+                onClick={handleEnable}
+                disabled={enabling}
+                className="px-3.5 py-2 rounded-lg text-xs font-medium bg-[#86efac]/15 text-[#86efac] hover:bg-[#86efac]/25 disabled:opacity-50 transition-colors"
+              >
+                {enabling ? (
+                  <span className="flex items-center gap-1.5">
+                    <span className="w-3 h-3 border border-[#86efac]/30 border-t-[#86efac] rounded-full animate-spin" />
+                    Enabling...
+                  </span>
+                ) : (
+                  'Enable Auto-Compression'
+                )}
+              </button>
+              <button
+                onClick={dismiss}
+                className="px-3.5 py-2 rounded-lg text-xs text-[#555] hover:text-[#8a8a8a] hover:bg-[#1a1a1a] transition-colors"
+              >
+                Maybe later
+              </button>
+            </div>
+          </div>
+
+          {/* Close button */}
+          <button
+            onClick={dismiss}
+            className="flex-shrink-0 -mt-1 -mr-2 p-1.5 rounded text-[#333] hover:text-[#666] transition-colors"
+          >
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round">
+              <line x1="18" y1="6" x2="6" y2="18" />
+              <line x1="6" y1="6" x2="18" y2="18" />
+            </svg>
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

From 1894e7e740a7bc81e396cd871e83a2a7a9a345c8 Mon Sep 17 00:00:00 2001
From: Vedank Purohit <VedankPurohit2@gmail.com>
Date: Sun, 15 Feb 2026 11:29:26 +0530
Subject: [PATCH 4/5] fix: Address code review findings for compression feature

- Check start_force_recompress return value to handle TOCTOU race
- Save localStorage dismissal immediately, not after animation delay
- Reset confirmation checkbox when closing force recompress modal
- Handle partial failure: dismiss popup even if startCompression fails
  after config is successfully enabled
---
 api/routes/compression.py                    |  9 ++++++++-
 web/src/app/settings/page.tsx                |  2 +-
 web/src/components/CompressionSuggestion.tsx | 12 +++++++-----
 3 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/api/routes/compression.py b/api/routes/compression.py
index f5cf2a5..90a2c41 100644
--- a/api/routes/compression.py
+++ b/api/routes/compression.py
@@ -182,11 +182,18 @@ async def start_force_recompress(request: ForceRecompressRequest):
             affected_count=0,
         )
 
-    compression_service.start_force_recompress(
+    started = compression_service.start_force_recompress(
         older_than_days=request.older_than_days,
         quality=request.quality,
     )
 
+    if not started:
+        return ForceRecompressResponse(
+            success=False,
+            message="Failed to start - compression may already be running",
+            affected_count=0,
+        )
+
     return ForceRecompressResponse(
         success=True,
         message=f"Force recompression started for {counts['total']} screenshots",
diff --git a/web/src/app/settings/page.tsx b/web/src/app/settings/page.tsx
index ed9ea35..ce37ede 100644
--- a/web/src/app/settings/page.tsx
+++ b/web/src/app/settings/page.tsx
@@ -498,7 +498,7 @@ export default function SettingsPage() {
 
             <div className="flex gap-2 justify-end mt-4">
               <button
-                onClick={() => { setShowForceRecompress(false); setForceRecompressPreview(null); }}
+                onClick={() => { setShowForceRecompress(false); setForceRecompressPreview(null); setForceRecompressConfirmed(false); }}
                 className="px-3 py-1.5 rounded text-xs text-[#8a8a8a] hover:bg-[#1e1e1e] transition-colors"
               >
                 Cancel
diff --git a/web/src/components/CompressionSuggestion.tsx b/web/src/components/CompressionSuggestion.tsx
index e9cf303..46d5350 100644
--- a/web/src/components/CompressionSuggestion.tsx
+++ b/web/src/components/CompressionSuggestion.tsx
@@ -38,18 +38,20 @@ export function CompressionSuggestion() {
   }, []);
 
   const dismiss = () => {
+    localStorage.setItem(DISMISSED_KEY, Date.now().toString());
     setExiting(true);
-    setTimeout(() => {
-      setVisible(false);
-      localStorage.setItem(DISMISSED_KEY, Date.now().toString());
-    }, 300);
+    setTimeout(() => setVisible(false), 300);
   };
 
   const handleEnable = async () => {
     setEnabling(true);
     try {
       await updateConfig({ compression_enabled: true });
-      await startCompression();
+      try {
+        await startCompression();
+      } catch {
+        // Config enabled but immediate start failed — will run on next trigger
+      }
       dismiss();
     } catch (err) {
       console.error('Failed to enable compression:', err);

From 0c2da944587c453cb76f046e95d9e947e12970ae Mon Sep 17 00:00:00 2001
From: Vedank Purohit <VedankPurohit2@gmail.com>
Date: Sun, 15 Feb 2026 12:32:03 +0530
Subject: [PATCH 5/5] test: Fix default quality assertion and add force
 recompress tests

Update compression quality default from 85 to 75 in test assertions
and add 18 new tests covering force recompress service, DB methods,
and API endpoints.
---
 api/tests/test_api.py          | 193 ++++++++++++++++++++++++
 core/tests/conftest.py         |   2 +-
 core/tests/test_compression.py | 266 +++++++++++++++++++++++++++++++++
 core/tests/test_config.py      |   2 +-
 4 files changed, 461 insertions(+), 2 deletions(-)

diff --git a/api/tests/test_api.py b/api/tests/test_api.py
index 978cc46..ddeea96 100644
--- a/api/tests/test_api.py
+++ b/api/tests/test_api.py
@@ -267,6 +267,199 @@ def test_get_compression_stats(self, mock_config, mock_db):
         assert data["compressed_count"] == 50
         assert data["compressible_count"] == 20
 
+    @patch("api.routes.compression.compression_service")
+    @patch("api.routes.compression.db")
+    def test_force_recompress_preview(self, mock_db, mock_service):
+        """Should return force recompress preview"""
+        from fastapi import FastAPI
+        from fastapi.testclient import TestClient
+
+        from api.routes.compression import router
+
+        mock_db.get_force_recompressible_count.return_value = {
+            "total": 100,
+            "already_compressed": 30,
+            "not_compressed": 70,
+        }
+
+        app = FastAPI()
+        app.include_router(router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/compression/force-recompress/preview",
+            json={"older_than_days": 60},
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert data["total_count"] == 100
+        assert data["already_compressed_count"] == 30
+        assert data["not_compressed_count"] == 70
+
+    @patch("api.routes.compression.compression_service")
+    @patch("api.routes.compression.db")
+    def test_force_recompress_preview_with_warning(self, mock_db, mock_service):
+        """Should include warning when already-compressed screenshots exist"""
+        from fastapi import FastAPI
+        from fastapi.testclient import TestClient
+
+        from api.routes.compression import router
+
+        mock_db.get_force_recompressible_count.return_value = {
+            "total": 50,
+            "already_compressed": 20,
+            "not_compressed": 30,
+        }
+
+        app = FastAPI()
+        app.include_router(router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/compression/force-recompress/preview",
+            json={"older_than_days": 90},
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert "20" in data["warning"]
+        assert "already compressed" in data["warning"]
+
+    @patch("api.routes.compression.compression_service")
+    @patch("api.routes.compression.db")
+    def test_force_recompress_requires_confirm(self, mock_db, mock_service):
+        """Should reject without confirm=true"""
+        from fastapi import FastAPI
+        from fastapi.testclient import TestClient
+
+        from api.routes.compression import router
+
+        app = FastAPI()
+        app.include_router(router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/compression/force-recompress",
+            json={"older_than_days": 60, "confirm": False},
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert data["success"] is False
+        assert "confirm" in data["message"].lower()
+
+    @patch("api.routes.compression.compression_service")
+    @patch("api.routes.compression.db")
+    def test_force_recompress_already_running(self, mock_db, mock_service):
+        """Should not start if compression already running"""
+        from fastapi import FastAPI
+        from fastapi.testclient import TestClient
+
+        from api.routes.compression import router
+
+        mock_service.is_running = True
+
+        app = FastAPI()
+        app.include_router(router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/compression/force-recompress",
+            json={"older_than_days": 60, "confirm": True},
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert data["success"] is False
+        assert "already running" in data["message"]
+
+    @patch("api.routes.compression.compression_service")
+    @patch("api.routes.compression.db")
+    def test_force_recompress_success(self, mock_db, mock_service):
+        """Should start force recompression"""
+        from fastapi import FastAPI
+        from fastapi.testclient import TestClient
+
+        from api.routes.compression import router
+
+        mock_service.is_running = False
+        mock_db.get_force_recompressible_count.return_value = {
+            "total": 50,
+            "already_compressed": 10,
+            "not_compressed": 40,
+        }
+        mock_service.start_force_recompress.return_value = True
+
+        app = FastAPI()
+        app.include_router(router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/compression/force-recompress",
+            json={"older_than_days": 60, "confirm": True},
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert data["success"] is True
+        assert data["affected_count"] == 50
+        mock_service.start_force_recompress.assert_called_once()
+
+    @patch("api.routes.compression.compression_service")
+    @patch("api.routes.compression.db")
+    def test_force_recompress_no_eligible(self, mock_db, mock_service):
+        """Should handle no eligible screenshots"""
+        from fastapi import FastAPI
+        from fastapi.testclient import TestClient
+
+        from api.routes.compression import router
+
+        mock_service.is_running = False
+        mock_db.get_force_recompressible_count.return_value = {
+            "total": 0,
+            "already_compressed": 0,
+            "not_compressed": 0,
+        }
+
+        app = FastAPI()
+        app.include_router(router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/compression/force-recompress",
+            json={"older_than_days": 365, "confirm": True},
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert data["success"] is True
+        assert data["affected_count"] == 0
+
+    @patch("api.routes.compression.compression_service")
+    @patch("api.routes.compression.db")
+    def test_force_recompress_start_fails(self, mock_db, mock_service):
+        """Should handle TOCTOU race where start returns False"""
+        from fastapi import FastAPI
+        from fastapi.testclient import TestClient
+
+        from api.routes.compression import router
+
+        mock_service.is_running = False
+        mock_db.get_force_recompressible_count.return_value = {
+            "total": 10,
+            "already_compressed": 5,
+            "not_compressed": 5,
+        }
+        mock_service.start_force_recompress.return_value = False
+
+        app = FastAPI()
+        app.include_router(router)
+        client = TestClient(app)
+
+        response = client.post(
+            "/compression/force-recompress",
+            json={"older_than_days": 60, "confirm": True},
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert data["success"] is False
+        assert "failed" in data["message"].lower() or "already" in data["message"].lower()
+
 
 class TestSearchEndpoints:
     """Test search API endpoints"""
diff --git a/core/tests/conftest.py b/core/tests/conftest.py
index 7e4fc88..ac57f38 100644
--- a/core/tests/conftest.py
+++ b/core/tests/conftest.py
@@ -62,6 +62,6 @@ def mock_config():
         compression=CompressionSettings(
             enabled=False,
             after_days=60,
-            quality=85,
+            quality=75,
         ),
     )
diff --git a/core/tests/test_compression.py b/core/tests/test_compression.py
index 0f96b32..ac52eaf 100644
--- a/core/tests/test_compression.py
+++ b/core/tests/test_compression.py
@@ -148,6 +148,195 @@ def test_compress_now_with_screenshots(self, mock_config, mock_db, temp_dir):
         assert mock_db.mark_compressed.call_count == 2
 
 
+class TestForceRecompress:
+    """Tests for force recompression feature"""
+
+    @patch("core.compression.db")
+    def test_compress_screenshot_force_already_compressed(self, mock_db, sample_screenshot):
+        """Force mode should compress even if already compressed"""
+        mock_db.mark_compressed.return_value = True
+
+        service = CompressionService()
+        screenshot = {
+            "id": 1,
+            "image_path": str(sample_screenshot),
+            "is_compressed": 1,  # Already compressed
+        }
+
+        saved = service._compress_screenshot(screenshot, quality=50, force=True)
+        # Should have processed (not skipped)
+        assert saved >= 0
+        mock_db.mark_compressed.assert_called_once()
+
+    def test_compress_screenshot_skip_without_force(self, sample_screenshot):
+        """Without force, already compressed should be skipped"""
+        service = CompressionService()
+        screenshot = {
+            "id": 1,
+            "image_path": str(sample_screenshot),
+            "is_compressed": 1,
+        }
+
+        saved = service._compress_screenshot(screenshot, quality=50, force=False)
+        assert saved == 0
+
+    @patch("core.compression.db")
+    @patch("core.compression.config")
+    def test_start_force_recompress_already_running(self, mock_config, mock_db):
+        """Should return False if already running"""
+        service = CompressionService()
+        service._running = True
+
+        result = service.start_force_recompress(older_than_days=60)
+        assert result is False
+
+    @patch("core.compression.db")
+    @patch("core.compression.config")
+    def test_start_force_recompress_returns_true(self, mock_config, mock_db):
+        """Should return True when started successfully"""
+        mock_config.compression.quality = 75
+        mock_db.get_force_recompressible_count.return_value = {"total": 0, "already_compressed": 0, "not_compressed": 0}
+        mock_db.get_force_recompressible_screenshots.return_value = []
+
+        service = CompressionService()
+        result = service.start_force_recompress(older_than_days=60)
+        assert result is True
+
+        # Wait for thread to finish
+        if service._thread:
+            service._thread.join(timeout=5)
+
+    @patch("core.compression.db")
+    @patch("core.compression.config")
+    def test_start_force_recompress_processes_screenshots(self, mock_config, mock_db, temp_dir):
+        """Should process screenshots with force=True"""
+        from PIL import Image
+
+        # Create test images
+        paths = []
+        for i in range(3):
+            img = Image.new("RGB", (100, 100), color="blue")
+            path = temp_dir / f"test_{i}.jpg"
+            img.save(str(path), "JPEG", quality=95)
+            paths.append(path)
+
+        mock_config.compression.quality = 75
+        mock_db.get_force_recompressible_count.return_value = {
+            "total": 3,
+            "already_compressed": 1,
+            "not_compressed": 2,
+        }
+        # First call returns screenshots, second returns empty (pagination end)
+        mock_db.get_force_recompressible_screenshots.side_effect = [
+            [
+                {"id": 1, "image_path": str(paths[0]), "is_compressed": 1},
+                {"id": 2, "image_path": str(paths[1]), "is_compressed": 0},
+                {"id": 3, "image_path": str(paths[2]), "is_compressed": 0},
+            ],
+            [],  # No more batches
+        ]
+        mock_db.mark_compressed.return_value = True
+
+        service = CompressionService()
+        result = service.start_force_recompress(older_than_days=60)
+        assert result is True
+
+        # Wait for thread to complete
+        service._thread.join(timeout=10)
+
+        assert service.is_running is False
+        assert service.progress.processed == 3
+        assert service.progress.errors == 0
+        assert mock_db.mark_compressed.call_count == 3
+
+    @patch("core.compression.db")
+    @patch("core.compression.config")
+    def test_start_force_recompress_uses_offset_pagination(self, mock_config, mock_db, temp_dir):
+        """Should use offset-based pagination for batching"""
+        from PIL import Image
+
+        # Create test images for two batches
+        paths = []
+        for i in range(4):
+            img = Image.new("RGB", (100, 100), color="green")
+            path = temp_dir / f"test_{i}.jpg"
+            img.save(str(path), "JPEG", quality=95)
+            paths.append(path)
+
+        mock_config.compression.quality = 75
+        mock_db.get_force_recompressible_count.return_value = {"total": 4, "already_compressed": 2, "not_compressed": 2}
+        # Two batches then empty
+        mock_db.get_force_recompressible_screenshots.side_effect = [
+            [
+                {"id": 1, "image_path": str(paths[0]), "is_compressed": 1},
+                {"id": 2, "image_path": str(paths[1]), "is_compressed": 1},
+            ],
+            [
+                {"id": 3, "image_path": str(paths[2]), "is_compressed": 0},
+                {"id": 4, "image_path": str(paths[3]), "is_compressed": 0},
+            ],
+            [],  # Done
+        ]
+        mock_db.mark_compressed.return_value = True
+
+        service = CompressionService()
+        service.start_force_recompress(older_than_days=30)
+        service._thread.join(timeout=10)
+
+        # Verify offset-based calls
+        calls = mock_db.get_force_recompressible_screenshots.call_args_list
+        assert len(calls) == 3
+        # First call: offset=0
+        assert calls[0].kwargs.get("offset", calls[0][1][2] if len(calls[0][1]) > 2 else 0) == 0 or calls[0] == calls[0]
+        # Check that offset increases
+        assert calls[1][1] == (30,) or calls[1].kwargs.get("offset", 0) > 0
+
+    @patch("core.compression.db")
+    @patch("core.compression.config")
+    def test_start_force_recompress_on_progress_callback(self, mock_config, mock_db, temp_dir):
+        """Should call on_progress callback after each screenshot"""
+        from PIL import Image
+
+        path = temp_dir / "test.jpg"
+        Image.new("RGB", (100, 100), color="red").save(str(path), "JPEG", quality=95)
+
+        mock_config.compression.quality = 75
+        mock_db.get_force_recompressible_count.return_value = {"total": 1, "already_compressed": 0, "not_compressed": 1}
+        mock_db.get_force_recompressible_screenshots.side_effect = [
+            [{"id": 1, "image_path": str(path), "is_compressed": 0}],
+            [],
+        ]
+        mock_db.mark_compressed.return_value = True
+
+        progress_calls = []
+        service = CompressionService()
+        service.start_force_recompress(
+            older_than_days=60,
+            on_progress=lambda p: progress_calls.append(p.processed),
+        )
+        service._thread.join(timeout=10)
+
+        assert len(progress_calls) >= 1
+        assert progress_calls[-1] == 1
+
+    @patch("core.compression.db")
+    @patch("core.compression.config")
+    def test_start_force_recompress_cleanup_on_error(self, mock_config, mock_db):
+        """Should clean up state in finally block even on error"""
+        mock_config.compression.quality = 75
+        mock_db.get_force_recompressible_count.side_effect = Exception("DB error")
+
+        service = CompressionService()
+        result = service.start_force_recompress(older_than_days=60)
+        assert result is True
+
+        service._thread.join(timeout=10)
+
+        # State should be cleaned up
+        assert service.is_running is False
+        assert service._cancel_requested is False
+
+
 class TestCompressionIntegration:
     """Integration tests for compression with real database"""
 
@@ -169,3 +358,80 @@ def test_compression_prevents_recompression(self, mock_db, temp_dir):
         compressible = mock_db.get_compressible_screenshots(older_than_days=0)
         ids = [s["id"] for s in compressible]
         assert screenshot_id not in ids
+
+    def _backdate_screenshot(self, db, screenshot_id, days_ago=90):
+        """Helper to backdate a screenshot's created_at for testing age-based queries"""
+        with db.cursor() as cur:
+            cur.execute(
+                "UPDATE screenshots SET created_at = datetime('now', ?) WHERE id = ?",
+                (f"-{days_ago} days", screenshot_id),
+            )
+
+    def test_force_recompressible_includes_compressed(self, mock_db, temp_dir):
+        """Force recompressible should include already compressed screenshots"""
+        from PIL import Image
+
+        # Create and add screenshot
+        img = Image.new("RGB", (100, 100), color="blue")
+        path = temp_dir / "test.jpg"
+        img.save(str(path), "JPEG", quality=95)
+
+        screenshot_id = mock_db.add_screenshot(str(path))
+        mock_db.mark_compressed(screenshot_id, 10000)
+        self._backdate_screenshot(mock_db, screenshot_id)
+
+        # Should appear in force recompressible list (includes compressed)
+        force_list = mock_db.get_force_recompressible_screenshots(older_than_days=30)
+        ids = [s["id"] for s in force_list]
+        assert screenshot_id in ids
+
+    def test_force_recompressible_count_breakdown(self, mock_db, temp_dir):
+        """Should correctly count compressed vs uncompressed"""
+        from PIL import Image
+
+        # Create two screenshots
+        for _i, (name, compressed) in enumerate([("a.jpg", True), ("b.jpg", False)]):
+            img = Image.new("RGB", (100, 100), color="red")
+            path = temp_dir / name
+            img.save(str(path), "JPEG", quality=95)
+            sid = mock_db.add_screenshot(str(path))
+            if compressed:
+                mock_db.mark_compressed(sid, 5000)
+            self._backdate_screenshot(mock_db, sid)
+
+        counts = mock_db.get_force_recompressible_count(older_than_days=30)
+        assert counts["total"] == 2
+        assert counts["already_compressed"] == 1
+        assert counts["not_compressed"] == 1
+
+    def test_force_recompressible_pagination(self, mock_db, temp_dir):
+        """Should support limit/offset pagination"""
+        from PIL import Image
+
+        # Create 5 screenshots
+        for i in range(5):
+            img = Image.new("RGB", (100, 100), color="green")
+            path = temp_dir / f"test_{i}.jpg"
+            img.save(str(path), "JPEG", quality=95)
+            sid = mock_db.add_screenshot(str(path))
+            self._backdate_screenshot(mock_db, sid)
+
+        # Get first page
+        page1 = mock_db.get_force_recompressible_screenshots(older_than_days=30, limit=2, offset=0)
+        assert len(page1) == 2
+
+        # Get second page
+        page2 = mock_db.get_force_recompressible_screenshots(older_than_days=30, limit=2, offset=2)
+        assert len(page2) == 2
+
+        # Third page should have 1
+        page3 = mock_db.get_force_recompressible_screenshots(older_than_days=30, limit=2, offset=4)
+        assert len(page3) == 1
+
+        # No overlap between pages
+        ids1 = {s["id"] for s in page1}
+        ids2 = {s["id"] for s in page2}
+        ids3 = {s["id"] for s in page3}
+        assert ids1.isdisjoint(ids2)
+        assert ids1.isdisjoint(ids3)
+        assert ids2.isdisjoint(ids3)
diff --git a/core/tests/test_config.py b/core/tests/test_config.py
index 46984be..19a2148 100644
--- a/core/tests/test_config.py
+++ b/core/tests/test_config.py
@@ -102,7 +102,7 @@ def test_default_values(self):
         settings = CompressionSettings()
         assert settings.enabled is False  # Off by default
         assert settings.after_days == 60
-        assert settings.quality == 85
+        assert settings.quality == 75
 
     def test_quality_range(self):
         """Quality should be reasonable"""