MoneyPackCleaner v1.0 - Premium cleaner with bunny branding, all 7 pro features

moneypack_cleaner.py

@@ -0,0 +1,1714 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+MoneyPackCleaner v1.0
+Premium Storage Optimization Suite
+Created by MoneyPack
+
+Features:
+- Disk analysis with donut chart visualization
+- Large file scanner with category detection
+- Duplicate file finder
+- Folder size analyzer
+- System cleaner (temp, cache, trash, thumbnails, browser)
+- File age scanner (find forgotten files)
+- Startup manager
+- Scheduled auto-cleaning
+- System tray with quick actions
+- Toast notifications
+- Dry run mode
+- Splash screen with branding
+"""
+
+import os
+import sys
+import time
+import shutil
+import hashlib
+import platform
+import subprocess
+import json
+import math
+from pathlib import Path
+from datetime import datetime, timedelta
+from dataclasses import dataclass, field
+from typing import List, Tuple, Dict
+from collections import defaultdict
+
+from PyQt6.QtWidgets import (
+    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
+    QTabWidget, QLabel, QPushButton, QProgressBar, QCheckBox,
+    QTreeWidget, QTreeWidgetItem, QTableWidget, QTableWidgetItem,
+    QHeaderView, QAbstractItemView, QTextEdit, QLineEdit,
+    QFileDialog, QMessageBox, QStatusBar, QGroupBox, QFrame,
+    QComboBox, QSpinBox, QMenu, QSystemTrayIcon, QSplashScreen,
+    QGraphicsOpacityEffect, QSizePolicy, QScrollArea, QRadioButton
+)
+from PyQt6.QtCore import (
+    Qt, QThread, pyqtSignal, QTimer, QSize, QPropertyAnimation,
+    QPoint, QRect, QEasingCurve, QSequentialAnimationGroup
+)
+from PyQt6.QtGui import (
+    QFont, QColor, QAction, QIcon, QPainter, QPen, QBrush,
+    QLinearGradient, QRadialGradient, QPixmap, QPainterPath,
+    QConicalGradient, QFontMetrics
+)
+
+
+# ============================================================================
+# BRANDING COLORS
+# ============================================================================
+
+class Brand:
+    # MoneyPack signature palette - dark luxury
+    BG_DARK = "#0a0a14"
+    BG_PANEL = "#12121f"
+    BG_CARD = "#1a1a2e"
+    BORDER = "#2a2a40"
+    
+    # Accent colors
+    GOLD = "#d4af37"         # Premium gold
+    GOLD_LIGHT = "#f0d060"
+    PINK = "#ff2d75"         # Playboy-inspired hot pink
+    PINK_LIGHT = "#ff5c8a"
+    CYAN = "#00e5ff"
+    PURPLE = "#9c27b0"
+    
+    # Text
+    TEXT = "#e8e8f0"
+    TEXT_DIM = "#7a7a90"
+    TEXT_MUTED = "#4a4a60"
+    
+    # Status
+    SUCCESS = "#00e676"
+    WARNING = "#ffab00"
+    DANGER = "#ff1744"
+
+
+# ============================================================================
+# UTILITY
+# ============================================================================
+
+def format_size(size_bytes: int) -> str:
+    if size_bytes <= 0:
+        return "0 B"
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+        if size_bytes < 1024:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024
+    return f"{size_bytes:.1f} PB"
+
+
+def safe_remove(path: str) -> bool:
+    try:
+        if os.path.isfile(path):
+            os.remove(path)
+        elif os.path.isdir(path):
+            shutil.rmtree(path)
+        return True
+    except (OSError, PermissionError):
+        return False
+
+
+def days_since_access(path: str) -> int:
+    try:
+        atime = os.path.getatime(path)
+        return (datetime.now() - datetime.fromtimestamp(atime)).days
+    except (OSError, ValueError):
+        return -1
+
+
+# ============================================================================
+# DATA CLASSES
+# ============================================================================
+
+@dataclass
+class DiskInfo:
+    drive: str
+    mount_point: str
+    total: int
+    used: int
+    free: int
+    percent: float
+
+
+@dataclass
+class FileEntry:
+    path: str
+    size: int
+    modified: str
+    ext: str = ""
+    category: str = ""
+    days_old: int = 0
+
+
+@dataclass
+class DuplicateGroup:
+    size: int
+    files: List[str] = field(default_factory=list)
+
+
+@dataclass
+class FolderEntry:
+    path: str
+    size: int
+    file_count: int
+    percent: float = 0.0
+
+
+# ============================================================================
+# CORE ENGINE
+# ============================================================================
+
+class DiskScanner:
+    SKIP_DIRS = {
+        '$Recycle.Bin', 'System Volume Information', 'Windows', 'WinSxS',
+        'node_modules', '.git', '__pycache__', 'venv', '.venv',
+        'Recovery', 'PerfLogs', '.Trash', 'proc', 'sys', 'dev',
+    }
+    
+    CATEGORY_MAP = {
+        'Video': {'.mp4','.avi','.mkv','.mov','.flv','.wmv','.webm','.m4v','.mpg'},
+        'Audio': {'.mp3','.wav','.flac','.aac','.ogg','.wma','.m4a','.opus'},
+        'Image': {'.jpg','.jpeg','.png','.gif','.bmp','.tiff','.webp','.svg','.psd','.raw'},
+        'Archive': {'.zip','.rar','.7z','.tar','.gz','.bz2','.xz','.iso','.cab'},
+        'Document': {'.pdf','.doc','.docx','.xls','.xlsx','.ppt','.pptx','.txt','.odt'},
+        'Installer': {'.exe','.msi','.dmg','.deb','.rpm','.appimage','.apk'},
+        'Database': {'.db','.sqlite','.mdf','.sql','.bak'},
+        'Virtual': {'.vmdk','.vdi','.vhd','.vhdx','.ova'},
+    }
+    
+    @classmethod
+    def get_disks(cls) -> List[DiskInfo]:
+        disks = []
+        if sys.platform == 'win32':
+            try:
+                import ctypes
+                bitmask = ctypes.windll.kernel32.GetLogicalDrives()
+                for letter in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
+                    if bitmask & 1:
+                        drive = f"{letter}:\\"
+                        try:
+                            u = shutil.disk_usage(drive)
+                            if u.total > 0:
+                                disks.append(DiskInfo(f"{letter}:", drive, u.total, u.used, u.free, round(u.used/u.total*100, 1)))
+                        except (OSError, PermissionError):
+                            pass
+                    bitmask >>= 1
+            except Exception:
+                pass
+        else:
+            seen = set()
+            for mount in ['/', str(Path.home())]:
+                try:
+                    u = shutil.disk_usage(mount)
+                    if u.total > 0 and u.total not in seen:
+                        seen.add(u.total)
+                        disks.append(DiskInfo(mount, mount, u.total, u.used, u.free, round(u.used/u.total*100, 1)))
+                except (OSError, PermissionError):
+                    pass
+        return disks
+    
+    @classmethod
+    def get_category(cls, ext: str) -> str:
+        ext = ext.lower()
+        for cat, exts in cls.CATEGORY_MAP.items():
+            if ext in exts:
+                return cat
+        return "Other"
+    
+    @classmethod
+    def scan_large_files(cls, root, threshold=50*1024*1024, max_files=500, callback=None):
+        results = []
+        count = 0
+        for dirpath, dirnames, filenames in os.walk(root):
+            dirnames[:] = [d for d in dirnames if d not in cls.SKIP_DIRS and not d.startswith('.')]
+            for fname in filenames:
+                try:
+                    fpath = os.path.join(dirpath, fname)
+                    size = os.path.getsize(fpath)
+                    if size >= threshold:
+                        ext = os.path.splitext(fname)[1].lower()
+                        try:
+                            mtime = datetime.fromtimestamp(os.path.getmtime(fpath)).strftime('%Y-%m-%d')
+                        except:
+                            mtime = "?"
+                        results.append(FileEntry(fpath, size, mtime, ext, cls.get_category(ext)))
+                        count += 1
+                        if callback and count % 20 == 0:
+                            callback(count)
+                        if count >= max_files:
+                            return sorted(results, key=lambda x: x.size, reverse=True)
+                except (OSError, PermissionError):
+                    continue
+        return sorted(results, key=lambda x: x.size, reverse=True)
+    
+    @classmethod
+    def scan_old_files(cls, root, min_days=180, min_size=1024*1024, max_files=300, callback=None):
+        """Find files not accessed in min_days."""
+        results = []
+        count = 0
+        for dirpath, dirnames, filenames in os.walk(root):
+            dirnames[:] = [d for d in dirnames if d not in cls.SKIP_DIRS and not d.startswith('.')]
+            for fname in filenames:
+                try:
+                    fpath = os.path.join(dirpath, fname)
+                    size = os.path.getsize(fpath)
+                    if size >= min_size:
+                        days = days_since_access(fpath)
+                        if days >= min_days:
+                            ext = os.path.splitext(fname)[1].lower()
+                            results.append(FileEntry(fpath, size, f"{days}d ago", ext, cls.get_category(ext), days))
+                            count += 1
+                            if callback and count % 20 == 0:
+                                callback(count)
+                            if count >= max_files:
+                                return sorted(results, key=lambda x: x.days_old, reverse=True)
+                except (OSError, PermissionError):
+                    continue
+        return sorted(results, key=lambda x: x.days_old, reverse=True)
+    
+    @classmethod
+    def find_duplicates(cls, root, min_size=1024*1024, callback=None):
+        size_map = defaultdict(list)
+        count = 0
+        for dirpath, dirnames, filenames in os.walk(root):
+            dirnames[:] = [d for d in dirnames if d not in cls.SKIP_DIRS and not d.startswith('.')]
+            for fname in filenames:
+                try:
+                    fpath = os.path.join(dirpath, fname)
+                    size = os.path.getsize(fpath)
+                    if size >= min_size:
+                        size_map[size].append(fpath)
+                        count += 1
+                        if callback and count % 200 == 0:
+                            callback(f"Indexing: {count}")
+                except (OSError, PermissionError):
+                    continue
+        
+        duplicates = []
+        hash_map = defaultdict(list)
+        candidates = [(s, ps) for s, ps in size_map.items() if len(ps) > 1]
+        
+        for size, paths in candidates:
+            for fpath in paths:
+                try:
+                    h = hashlib.md5()
+                    with open(fpath, 'rb') as f:
+                        h.update(f.read(8192))
+                        if size > 8192:
+                            f.seek(-8192, 2)
+                            h.update(f.read(8192))
+                    hash_map[f"{size}_{h.hexdigest()}"].append(fpath)
+                except (OSError, PermissionError):
+                    continue
+        
+        for key, paths in hash_map.items():
+            if len(paths) > 1:
+                size = int(key.split('_')[0])
+                duplicates.append(DuplicateGroup(size, paths))
+        
+        return sorted(duplicates, key=lambda x: x.size * len(x.files), reverse=True)
+    
+    @classmethod
+    def analyze_folders(cls, root, callback=None):
+        folders = []
+        try:
+            for entry in sorted(os.scandir(root), key=lambda e: e.name):
+                if entry.is_dir() and entry.name not in cls.SKIP_DIRS and not entry.name.startswith('.'):
+                    try:
+                        size = 0
+                        fcount = 0
+                        for r, d, fs in os.walk(entry.path):
+                            d[:] = [x for x in d if x not in cls.SKIP_DIRS]
+                            for f in fs:
+                                try:
+                                    size += os.path.getsize(os.path.join(r, f))
+                                    fcount += 1
+                                except:
+                                    pass
+                        if size > 0:
+                            folders.append(FolderEntry(entry.path, size, fcount))
+                        if callback:
+                            callback(len(folders))
+                    except (OSError, PermissionError):
+                        pass
+        except (OSError, PermissionError):
+            pass
+        
+        total = sum(f.size for f in folders)
+        for f in folders:
+            f.percent = round(f.size / total * 100, 1) if total > 0 else 0
+        return sorted(folders, key=lambda x: x.size, reverse=True)
+    
+    @classmethod
+    def get_temp_paths(cls):
+        paths = []
+        if sys.platform == 'win32':
+            candidates = [
+                os.environ.get('TEMP', ''),
+                os.path.join(os.environ.get('LOCALAPPDATA', ''), 'Temp'),
+                os.path.join(os.environ.get('WINDIR', r'C:\Windows'), 'Temp'),
+                os.path.join(os.environ.get('WINDIR', r'C:\Windows'), 'Prefetch'),
+                os.path.join(os.environ.get('LOCALAPPDATA', ''), 'Microsoft', 'Windows', 'INetCache'),
+            ]
+        else:
+            candidates = ['/tmp', '/var/tmp', os.path.join(str(Path.home()), '.cache'),
+                         os.path.join(str(Path.home()), '.local', 'share', 'Trash')]
+        return [p for p in candidates if p and os.path.exists(p)]
+    
+    @classmethod
+    def scan_temp_size(cls):
+        total, count = 0, 0
+        for d in cls.get_temp_paths():
+            try:
+                for r, _, fs in os.walk(d):
+                    for f in fs:
+                        try:
+                            total += os.path.getsize(os.path.join(r, f))
+                            count += 1
+                        except:
+                            pass
+            except:
+                pass
+        return total, count
+    
+    @classmethod
+    def get_startup_items(cls):
+        """Get startup programs (Windows)."""
+        items = []
+        if sys.platform == 'win32':
+            # Registry Run keys
+            for key_path in [
+                r"HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run",
+                r"HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run",
+            ]:
+                try:
+                    r = subprocess.run(["reg", "query", key_path], capture_output=True, text=True, timeout=5)
+                    if r.returncode == 0:
+                        for line in r.stdout.split("\n"):
+                            if "REG_SZ" in line or "REG_EXPAND_SZ" in line:
+                                parts = line.strip().split(None, 2)
+                                if len(parts) >= 3:
+                                    name = parts[0]
+                                    value = parts[2] if len(parts) > 2 else ""
+                                    items.append({"name": name, "command": value, "source": key_path, "enabled": True})
+                except:
+                    pass
+            
+            # Startup folder
+            startup = Path.home() / "AppData/Roaming/Microsoft/Windows/Start Menu/Programs/Startup"
+            if startup.exists():
+                for f in startup.iterdir():
+                    items.append({"name": f.name, "command": str(f), "source": "Startup Folder", "enabled": True})
+        else:
+            # Linux autostart
+            autostart = Path.home() / ".config" / "autostart"
+            if autostart.exists():
+                for f in autostart.iterdir():
+                    if f.suffix == ".desktop":
+                        items.append({"name": f.stem, "command": str(f), "source": "autostart", "enabled": True})
+        return items
+
+
+class DiskCleaner:
+    @classmethod
+    def delete_files(cls, paths):
+        result = {'deleted': 0, 'failed': 0, 'freed': 0}
+        for p in paths:
+            try:
+                if not os.path.exists(p):
+                    continue
+                size = os.path.getsize(p) if os.path.isfile(p) else 0
+                if safe_remove(p):
+                    result['deleted'] += 1
+                    result['freed'] += size
+                else:
+                    result['failed'] += 1
+            except:
+                result['failed'] += 1
+        return result
+    
+    @classmethod
+    def clean_temp(cls, callback=None):
+        result = {'deleted': 0, 'freed': 0}
+        for d in DiskScanner.get_temp_paths():
+            try:
+                for r, _, fs in os.walk(d):
+                    for f in fs:
+                        fp = os.path.join(r, f)
+                        try:
+                            size = os.path.getsize(fp)
+                            os.remove(fp)
+                            result['deleted'] += 1
+                            result['freed'] += size
+                            if callback and result['deleted'] % 50 == 0:
+                                callback(result['deleted'])
+                        except:
+                            pass
+            except:
+                pass
+        return result
+    
+    @classmethod
+    def empty_trash(cls):
+        if sys.platform == 'win32':
+            try:
+                import ctypes
+                ctypes.windll.shell32.SHEmptyRecycleBinW(None, None, 0x07)
+                return True
+            except:
+                return False
+        else:
+            for trash in [str(Path.home() / ".local/share/Trash"), str(Path.home() / ".Trash")]:
+                if os.path.exists(trash):
+                    try:
+                        shutil.rmtree(trash)
+                        os.makedirs(trash, exist_ok=True)
+                        return True
+                    except:
+                        pass
+        return False
+    
+    @classmethod
+    def clean_browser_cache(cls):
+        result = {'deleted': 0, 'freed': 0}
+        dirs = []
+        if sys.platform == 'win32':
+            local = os.environ.get('LOCALAPPDATA', '')
+            dirs = [
+                os.path.join(local, 'Google', 'Chrome', 'User Data', 'Default', 'Cache'),
+                os.path.join(local, 'Google', 'Chrome', 'User Data', 'Default', 'Code Cache'),
+                os.path.join(local, 'Microsoft', 'Edge', 'User Data', 'Default', 'Cache'),
+            ]
+        else:
+            home = str(Path.home())
+            dirs = [os.path.join(home, '.cache', 'google-chrome'), os.path.join(home, '.cache', 'mozilla')]
+        
+        for d in dirs:
+            if os.path.exists(d):
+                for r, _, fs in os.walk(d):
+                    for f in fs:
+                        fp = os.path.join(r, f)
+                        try:
+                            size = os.path.getsize(fp)
+                            os.remove(fp)
+                            result['deleted'] += 1
+                            result['freed'] += size
+                        except:
+                            pass
+        return result
+
+
+# ============================================================================
+# WORKER THREADS
+# ============================================================================
+
+class ScanWorker(QThread):
+    progress = pyqtSignal(int)
+    finished = pyqtSignal(list)
+    status = pyqtSignal(str)
+    
+    def __init__(self, mode, root, **kwargs):
+        super().__init__()
+        self.mode = mode
+        self.root = root
+        self.kwargs = kwargs
+    
+    def run(self):
+        self.status.emit(f"Scanning {os.path.basename(self.root)}...")
+        if self.mode == 'large':
+            r = DiskScanner.scan_large_files(self.root, self.kwargs.get('threshold', 50*1024*1024), callback=lambda c: self.progress.emit(c))
+        elif self.mode == 'old':
+            r = DiskScanner.scan_old_files(self.root, self.kwargs.get('min_days', 180), callback=lambda c: self.progress.emit(c))
+        elif self.mode == 'duplicates':
+            r = DiskScanner.find_duplicates(self.root, self.kwargs.get('min_size', 1024*1024), callback=lambda s: self.status.emit(s))
+        elif self.mode == 'folders':
+            r = DiskScanner.analyze_folders(self.root, callback=lambda c: self.progress.emit(c))
+        else:
+            r = []
+        self.finished.emit(r)
+
+
+class CleanWorker(QThread):
+    finished = pyqtSignal(dict)
+    status = pyqtSignal(str)
+    
+    def __init__(self, tasks):
+        super().__init__()
+        self.tasks = tasks
+    
+    def run(self):
+        result = {'deleted': 0, 'freed': 0}
+        if 'temp' in self.tasks:
+            self.status.emit("Cleaning temp files...")
+            r = DiskCleaner.clean_temp()
+            result['deleted'] += r['deleted']
+            result['freed'] += r['freed']
+        if 'trash' in self.tasks:
+            self.status.emit("Emptying trash...")
+            DiskCleaner.empty_trash()
+        if 'browser' in self.tasks:
+            self.status.emit("Cleaning browser cache...")
+            r = DiskCleaner.clean_browser_cache()
+            result['deleted'] += r['deleted']
+            result['freed'] += r['freed']
+        self.finished.emit(result)
+
+
+# ============================================================================
+# CUSTOM WIDGETS
+# ============================================================================
+
+class BunnyLogo(QWidget):
+    """Custom painted bunny logo widget - MoneyPack branded."""
+    
+    def __init__(self, size=80):
+        super().__init__()
+        self.setFixedSize(size, size)
+        self._size = size
+    
+    def paintEvent(self, event):
+        p = QPainter(self)
+        p.setRenderHint(QPainter.RenderHint.Antialiasing)
+        
+        s = self._size
+        cx, cy = s/2, s/2
+        
+        # Glow behind
+        glow = QRadialGradient(cx, cy, s*0.45)
+        glow.setColorAt(0, QColor(Brand.PINK + "40"))
+        glow.setColorAt(1, QColor(Brand.PINK + "00"))
+        p.setBrush(QBrush(glow))
+        p.setPen(Qt.PenStyle.NoPen)
+        p.drawEllipse(int(cx - s*0.4), int(cy - s*0.4), int(s*0.8), int(s*0.8))
+        
+        # Bunny head (circle)
+        head_y = cy + s*0.08
+        head_r = s * 0.22
+        p.setBrush(QColor(Brand.PINK))
+        p.setPen(QPen(QColor(Brand.GOLD), 2))
+        p.drawEllipse(int(cx - head_r), int(head_y - head_r), int(head_r*2), int(head_r*2))
+        
+        # Ears
+        ear_w = s * 0.08
+        ear_h = s * 0.28
+        ear_y = head_y - head_r - ear_h * 0.6
+        
+        # Left ear
+        ear_path = QPainterPath()
+        ear_path.addEllipse(cx - s*0.12 - ear_w/2, ear_y, ear_w, ear_h)
+        p.setBrush(QColor(Brand.PINK))
+        p.drawPath(ear_path)
+        
+        # Right ear
+        ear_path2 = QPainterPath()
+        ear_path2.addEllipse(cx + s*0.12 - ear_w/2, ear_y, ear_w, ear_h)
+        p.drawPath(ear_path2)
+        
+        # Inner ears (gold)
+        p.setBrush(QColor(Brand.GOLD))
+        p.setPen(Qt.PenStyle.NoPen)
+        inner_w = ear_w * 0.5
+        inner_h = ear_h * 0.6
+        p.drawEllipse(int(cx - s*0.12 - inner_w/2), int(ear_y + ear_h*0.2), int(inner_w), int(inner_h))
+        p.drawEllipse(int(cx + s*0.12 - inner_w/2), int(ear_y + ear_h*0.2), int(inner_w), int(inner_h))
+        
+        # Eyes
+        p.setBrush(QColor("#ffffff"))
+        eye_size = s * 0.04
+        p.drawEllipse(int(cx - s*0.08), int(head_y - s*0.03), int(eye_size), int(eye_size))
+        p.drawEllipse(int(cx + s*0.05), int(head_y - s*0.03), int(eye_size), int(eye_size))
+        
+        # Bow tie (gold)
+        p.setBrush(QColor(Brand.GOLD))
+        p.setPen(Qt.PenStyle.NoPen)
+        bow_y = head_y + head_r - s*0.02
+        bow_path = QPainterPath()
+        bow_path.moveTo(cx, bow_y)
+        bow_path.lineTo(cx - s*0.1, bow_y - s*0.05)
+        bow_path.lineTo(cx - s*0.1, bow_y + s*0.05)
+        bow_path.closeSubpath()
+        bow_path.moveTo(cx, bow_y)
+        bow_path.lineTo(cx + s*0.1, bow_y - s*0.05)
+        bow_path.lineTo(cx + s*0.1, bow_y + s*0.05)
+        bow_path.closeSubpath()
+        p.drawPath(bow_path)
+        
+        p.end()
+
+
+class DonutChart(QWidget):
+    """Animated donut chart showing disk usage breakdown."""
+    
+    def __init__(self, size=200):
+        super().__init__()
+        self.setFixedSize(size, size)
+        self._size = size
+        self._segments = []  # [(percent, color, label)]
+        self._center_text = ""
+        self._center_sub = ""
+    
+    def set_data(self, segments, center_text="", center_sub=""):
+        self._segments = segments
+        self._center_text = center_text
+        self._center_sub = center_sub
+        self.update()
+    
+    def paintEvent(self, event):
+        p = QPainter(self)
+        p.setRenderHint(QPainter.RenderHint.Antialiasing)
+        
+        s = self._size
+        margin = 10
+        outer_r = (s - margin*2) / 2
+        inner_r = outer_r * 0.65
+        cx, cy = s/2, s/2
+        
+        # Background ring
+        p.setPen(Qt.PenStyle.NoPen)
+        p.setBrush(QColor(Brand.BORDER))
+        p.drawEllipse(int(cx - outer_r), int(cy - outer_r), int(outer_r*2), int(outer_r*2))
+        
+        # Inner circle (dark)
+        p.setBrush(QColor(Brand.BG_PANEL))
+        p.drawEllipse(int(cx - inner_r), int(cy - inner_r), int(inner_r*2), int(inner_r*2))
+        
+        # Draw segments
+        if self._segments:
+            rect = QRect(int(cx - outer_r), int(cy - outer_r), int(outer_r*2), int(outer_r*2))
+            start_angle = 90 * 16  # Start from top
+            
+            for percent, color, label in self._segments:
+                span = int(percent / 100 * 360 * 16)
+                if span == 0:
+                    continue
+                p.setBrush(QColor(color))
+                p.setPen(QPen(QColor(Brand.BG_PANEL), 2))
+                p.drawPie(rect, start_angle, -span)
+                start_angle -= span
+            
+            # Redraw inner circle
+            p.setPen(Qt.PenStyle.NoPen)
+            p.setBrush(QColor(Brand.BG_PANEL))
+            p.drawEllipse(int(cx - inner_r), int(cy - inner_r), int(inner_r*2), int(inner_r*2))
+        
+        # Center text
+        if self._center_text:
+            p.setPen(QColor(Brand.TEXT))
+            font = QFont("Segoe UI", int(s * 0.08), QFont.Weight.Bold)
+            p.setFont(font)
+            p.drawText(QRect(0, int(cy - s*0.1), s, int(s*0.15)), Qt.AlignmentFlag.AlignCenter, self._center_text)
+        
+        if self._center_sub:
+            p.setPen(QColor(Brand.TEXT_DIM))
+            font = QFont("Segoe UI", int(s * 0.05))
+            p.setFont(font)
+            p.drawText(QRect(0, int(cy + s*0.02), s, int(s*0.12)), Qt.AlignmentFlag.AlignCenter, self._center_sub)
+        
+        p.end()
+
+
+class ToastNotification(QFrame):
+    """Slide-in toast notification."""
+    
+    def __init__(self, parent, message, toast_type="info", duration=3000):
+        super().__init__(parent)
+        self.setFixedSize(350, 60)
+        
+        colors = {
+            "info": Brand.CYAN,
+            "success": Brand.SUCCESS,
+            "warning": Brand.WARNING,
+            "error": Brand.DANGER,
+        }
+        color = colors.get(toast_type, Brand.CYAN)
+        
+        self.setStyleSheet(f"""
+            QFrame {{
+                background-color: {Brand.BG_CARD};
+                border: 1px solid {color};
+                border-left: 4px solid {color};
+                border-radius: 8px;
+            }}
+        """)
+        
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(12, 8, 12, 8)
+        
+        icons = {"info": "i", "success": "+", "warning": "!", "error": "X"}
+        icon_lbl = QLabel(icons.get(toast_type, "i"))
+        icon_lbl.setStyleSheet(f"color: {color}; font-size: 18px; font-weight: bold; border: none;")
+        layout.addWidget(icon_lbl)
+        
+        msg_lbl = QLabel(message)
+        msg_lbl.setStyleSheet(f"color: {Brand.TEXT}; font-size: 12px; border: none;")
+        msg_lbl.setWordWrap(True)
+        layout.addWidget(msg_lbl)
+        
+        # Position at top-right of parent
+        parent_rect = parent.rect()
+        self.move(parent_rect.width() - 370, 10)
+        self.show()
+        
+        # Slide in animation
+        self._anim = QPropertyAnimation(self, b"pos")
+        self._anim.setDuration(300)
+        self._anim.setStartValue(QPoint(parent_rect.width(), 10))
+        self._anim.setEndValue(QPoint(parent_rect.width() - 370, 10))
+        self._anim.setEasingCurve(QEasingCurve.Type.OutCubic)
+        self._anim.start()
+        
+        # Auto dismiss
+        QTimer.singleShot(duration, self._dismiss)
+    
+    def _dismiss(self):
+        self._fade = QPropertyAnimation(self, b"pos")
+        self._fade.setDuration(200)
+        self._fade.setEndValue(QPoint(self.parent().rect().width(), self.y()))
+        self._fade.setEasingCurve(QEasingCurve.Type.InCubic)
+        self._fade.finished.connect(self.deleteLater)
+        self._fade.start()
+
+
+# ============================================================================
+# TAB WIDGETS
+# ============================================================================
+
+class DashboardTab(QWidget):
+    log_signal = pyqtSignal(str)
+    
+    def __init__(self):
+        super().__init__()
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(16, 16, 16, 16)
+        layout.setSpacing(16)
+        
+        # Header with logo
+        header = QHBoxLayout()
+        self.logo = BunnyLogo(60)
+        header.addWidget(self.logo)
+        
+        title_layout = QVBoxLayout()
+        title = QLabel("MoneyPackCleaner")
+        title.setFont(QFont("Segoe UI", 22, QFont.Weight.Bold))
+        title.setStyleSheet(f"color: {Brand.GOLD}; border: none;")
+        title_layout.addWidget(title)
+        subtitle = QLabel("Premium Storage Optimization")
+        subtitle.setStyleSheet(f"color: {Brand.TEXT_DIM}; border: none; font-size: 12px;")
+        title_layout.addWidget(subtitle)
+        header.addLayout(title_layout)
+        header.addStretch()
+        
+        # Quick actions
+        quick_scan_btn = QPushButton("Quick Clean")
+        quick_scan_btn.setObjectName("primary")
+        quick_scan_btn.setFixedHeight(36)
+        quick_scan_btn.clicked.connect(self._quick_clean)
+        header.addWidget(quick_scan_btn)
+        
+        layout.addLayout(header)
+        
+        # Main content: Chart + Stats
+        content = QHBoxLayout()
+        
+        # Donut chart
+        chart_frame = QFrame()
+        chart_frame.setStyleSheet(f"background-color: {Brand.BG_PANEL}; border: 1px solid {Brand.BORDER}; border-radius: 12px;")
+        chart_layout = QVBoxLayout(chart_frame)
+        chart_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.chart = DonutChart(220)
+        chart_layout.addWidget(self.chart, alignment=Qt.AlignmentFlag.AlignCenter)
+        content.addWidget(chart_frame)
+        
+        # Stats cards
+        stats_layout = QVBoxLayout()
+        stats_layout.setSpacing(10)
+        
+        self.cards = {}
+        card_data = [
+            ("total", "Total Storage", Brand.GOLD),
+            ("used", "Used Space", Brand.PINK),
+            ("free", "Free Space", Brand.SUCCESS),
+            ("temp", "Cleanable", Brand.WARNING),
+        ]
+        for key, label, color in card_data:
+            card = self._make_card(label, "---", color)
+            self.cards[key] = card
+            stats_layout.addWidget(card)
+        
+        stats_layout.addStretch()
+        content.addLayout(stats_layout)
+        layout.addLayout(content)
+        
+        # Disk table
+        self.table = QTableWidget()
+        self.table.setColumnCount(5)
+        self.table.setHorizontalHeaderLabels(["Drive", "Total", "Used", "Free", "Usage"])
+        self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
+        self.table.verticalHeader().setVisible(False)
+        self.table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.table.setMaximumHeight(150)
+        layout.addWidget(self.table)
+        
+        self.refresh()
+    
+    def _make_card(self, label, value, color):
+        frame = QFrame()
+        frame.setFixedHeight(65)
+        frame.setStyleSheet(f"background-color: {Brand.BG_PANEL}; border: 1px solid {color}33; border-radius: 10px;")
+        fl = QHBoxLayout(frame)
+        fl.setContentsMargins(14, 8, 14, 8)
+        
+        dot = QLabel("*")
+        dot.setStyleSheet(f"color: {color}; font-size: 24px; border: none;")
+        fl.addWidget(dot)
+        
+        text_l = QVBoxLayout()
+        text_l.setSpacing(0)
+        lbl = QLabel(label)
+        lbl.setStyleSheet(f"color: {Brand.TEXT_DIM}; font-size: 11px; border: none;")
+        text_l.addWidget(lbl)
+        val = QLabel(value)
+        val.setObjectName("card_val")
+        val.setStyleSheet(f"color: {color}; font-size: 16px; font-weight: bold; border: none;")
+        text_l.addWidget(val)
+        fl.addLayout(text_l)
+        fl.addStretch()
+        return frame
+    
+    def _update_card(self, key, value):
+        card = self.cards[key]
+        lbl = card.findChild(QLabel, "card_val")
+        if lbl:
+            lbl.setText(value)
+    
+    def refresh(self):
+        disks = DiskScanner.get_disks()
+        self.table.setRowCount(len(disks))
+        
+        for i, d in enumerate(disks):
+            self.table.setItem(i, 0, QTableWidgetItem(d.drive))
+            self.table.setItem(i, 1, QTableWidgetItem(format_size(d.total)))
+            self.table.setItem(i, 2, QTableWidgetItem(format_size(d.used)))
+            self.table.setItem(i, 3, QTableWidgetItem(format_size(d.free)))
+            bar = QProgressBar()
+            bar.setValue(int(d.percent))
+            bar.setFormat(f"{d.percent}%")
+            self.table.setCellWidget(i, 4, bar)
+        
+        total = sum(d.total for d in disks)
+        used = sum(d.used for d in disks)
+        free = sum(d.free for d in disks)
+        
+        self._update_card("total", format_size(total))
+        self._update_card("used", format_size(used))
+        self._update_card("free", format_size(free))
+        
+        temp_size, _ = DiskScanner.scan_temp_size()
+        self._update_card("temp", format_size(temp_size))
+        
+        # Update donut
+        if total > 0:
+            used_pct = used / total * 100
+            free_pct = free / total * 100
+            self.chart.set_data(
+                [(used_pct, Brand.PINK, "Used"), (free_pct, Brand.SUCCESS, "Free")],
+                center_text=f"{used_pct:.0f}%",
+                center_sub="Used"
+            )
+    
+    def _quick_clean(self):
+        self.log_signal.emit("Quick clean started...")
+        r = DiskCleaner.clean_temp()
+        self.log_signal.emit(f"Quick clean: {r['deleted']} files, {format_size(r['freed'])} freed")
+        self.refresh()
+        # Toast
+        ToastNotification(self.window(), f"Freed {format_size(r['freed'])}", "success")
+
+
+class LargeFilesTab(QWidget):
+    log_signal = pyqtSignal(str)
+    
+    def __init__(self):
+        super().__init__()
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(12, 12, 12, 12)
+        layout.setSpacing(10)
+        
+        title = QLabel("Large File Scanner")
+        title.setFont(QFont("Segoe UI", 16, QFont.Weight.Bold))
+        title.setStyleSheet(f"color: {Brand.GOLD}; border: none;")
+        layout.addWidget(title)
+        
+        ctrl = QHBoxLayout()
+        self.path_input = QLineEdit(str(Path.home()))
+        ctrl.addWidget(self.path_input)
+        browse_btn = QPushButton("Browse")
+        browse_btn.clicked.connect(lambda: self._browse())
+        ctrl.addWidget(browse_btn)
+        ctrl.addWidget(QLabel("Min:"))
+        self.threshold = QSpinBox()
+        self.threshold.setRange(1, 10000)
+        self.threshold.setValue(50)
+        self.threshold.setSuffix(" MB")
+        ctrl.addWidget(self.threshold)
+        
+        self.dry_run_chk = QCheckBox("Dry Run (preview only)")
+        ctrl.addWidget(self.dry_run_chk)
+        layout.addLayout(ctrl)
+        
+        self.tree = QTreeWidget()
+        self.tree.setHeaderLabels(["File", "Size", "Category", "Modified", "Path"])
+        self.tree.header().setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
+        self.tree.setColumnWidth(1, 90)
+        self.tree.setColumnWidth(2, 80)
+        self.tree.setColumnWidth(3, 90)
+        self.tree.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+        self.tree.setAlternatingRowColors(True)
+        layout.addWidget(self.tree)
+        
+        bottom = QHBoxLayout()
+        self.status_lbl = QLabel("Ready")
+        self.status_lbl.setStyleSheet(f"color: {Brand.TEXT_DIM}; border: none;")
+        bottom.addWidget(self.status_lbl)
+        bottom.addStretch()
+        self.scan_btn = QPushButton("Scan")
+        self.scan_btn.setObjectName("primary")
+        self.scan_btn.clicked.connect(self._scan)
+        bottom.addWidget(self.scan_btn)
+        self.del_btn = QPushButton("Delete Selected")
+        self.del_btn.setObjectName("danger")
+        self.del_btn.clicked.connect(self._delete)
+        self.del_btn.setEnabled(False)
+        bottom.addWidget(self.del_btn)
+        layout.addLayout(bottom)
+        
+        self._worker = None
+    
+    def _browse(self):
+        p = QFileDialog.getExistingDirectory(self, "Select")
+        if p:
+            self.path_input.setText(p)
+    
+    def _scan(self):
+        self.tree.clear()
+        self.scan_btn.setEnabled(False)
+        self.status_lbl.setText("Scanning...")
+        self._worker = ScanWorker('large', self.path_input.text(), threshold=self.threshold.value()*1024*1024)
+        self._worker.finished.connect(self._done)
+        self._worker.status.connect(lambda s: self.status_lbl.setText(s))
+        self._worker.start()
+    
+    def _done(self, results):
+        self.scan_btn.setEnabled(True)
+        self.del_btn.setEnabled(len(results) > 0)
+        colors = {'Video':'#ff6b6b','Audio':'#ffa500','Image':'#00d4aa','Archive':'#6c63ff','Installer':'#ff00aa','Document':'#00bfff'}
+        total = sum(e.size for e in results)
+        for e in results:
+            item = QTreeWidgetItem()
+            item.setText(0, os.path.basename(e.path))
+            item.setText(1, format_size(e.size))
+            item.setText(2, e.category)
+            item.setText(3, e.modified)
+            item.setText(4, e.path)
+            item.setData(0, Qt.ItemDataRole.UserRole, e.path)
+            item.setForeground(2, QColor(colors.get(e.category, '#888')))
+            self.tree.addTopLevelItem(item)
+        self.status_lbl.setText(f"{len(results)} files ({format_size(total)})")
+        self.log_signal.emit(f"Large files: {len(results)} found, {format_size(total)}")
+    
+    def _delete(self):
+        items = self.tree.selectedItems()
+        if not items:
+            return
+        paths = [i.data(0, Qt.ItemDataRole.UserRole) for i in items]
+        
+        if self.dry_run_chk.isChecked():
+            total = sum(os.path.getsize(p) for p in paths if os.path.exists(p))
+            QMessageBox.information(self, "Dry Run", f"Would delete {len(paths)} files\nWould free: {format_size(total)}")
+            return
+        
+        if QMessageBox.question(self, "Delete", f"Permanently delete {len(paths)} files?") == QMessageBox.StandardButton.Yes:
+            r = DiskCleaner.delete_files(paths)
+            self.log_signal.emit(f"Deleted {r['deleted']} files, freed {format_size(r['freed'])}")
+            ToastNotification(self.window(), f"Freed {format_size(r['freed'])}", "success")
+            self._scan()
+
+
+class OldFilesTab(QWidget):
+    log_signal = pyqtSignal(str)
+    
+    def __init__(self):
+        super().__init__()
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(12, 12, 12, 12)
+        layout.setSpacing(10)
+        
+        title = QLabel("Forgotten Files")
+        title.setFont(QFont("Segoe UI", 16, QFont.Weight.Bold))
+        title.setStyleSheet(f"color: {Brand.GOLD}; border: none;")
+        layout.addWidget(title)
+        
+        desc = QLabel("Find files you haven't opened in months or years")
+        desc.setStyleSheet(f"color: {Brand.TEXT_DIM}; border: none;")
+        layout.addWidget(desc)
+        
+        ctrl = QHBoxLayout()
+        self.path_input = QLineEdit(str(Path.home()))
+        ctrl.addWidget(self.path_input)
+        browse_btn = QPushButton("Browse")
+        browse_btn.clicked.connect(lambda: self._browse())
+        ctrl.addWidget(browse_btn)
+        ctrl.addWidget(QLabel("Not accessed in:"))
+        self.days_spin = QSpinBox()
+        self.days_spin.setRange(30, 3650)
+        self.days_spin.setValue(180)
+        self.days_spin.setSuffix(" days")
+        ctrl.addWidget(self.days_spin)
+        layout.addLayout(ctrl)
+        
+        self.tree = QTreeWidget()
+        self.tree.setHeaderLabels(["File", "Size", "Last Access", "Category", "Path"])
+        self.tree.header().setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
+        self.tree.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+        self.tree.setAlternatingRowColors(True)
+        layout.addWidget(self.tree)
+        
+        bottom = QHBoxLayout()
+        self.status_lbl = QLabel("Find files gathering dust on your drive")
+        self.status_lbl.setStyleSheet(f"color: {Brand.TEXT_DIM}; border: none;")
+        bottom.addWidget(self.status_lbl)
+        bottom.addStretch()
+        self.scan_btn = QPushButton("Find Old Files")
+        self.scan_btn.setObjectName("primary")
+        self.scan_btn.clicked.connect(self._scan)
+        bottom.addWidget(self.scan_btn)
+        self.del_btn = QPushButton("Delete Selected")
+        self.del_btn.setObjectName("danger")
+        self.del_btn.clicked.connect(self._delete)
+        self.del_btn.setEnabled(False)
+        bottom.addWidget(self.del_btn)
+        layout.addLayout(bottom)
+        self._worker = None
+    
+    def _browse(self):
+        p = QFileDialog.getExistingDirectory(self, "Select")
+        if p:
+            self.path_input.setText(p)
+    
+    def _scan(self):
+        self.tree.clear()
+        self.scan_btn.setEnabled(False)
+        self._worker = ScanWorker('old', self.path_input.text(), min_days=self.days_spin.value())
+        self._worker.finished.connect(self._done)
+        self._worker.status.connect(lambda s: self.status_lbl.setText(s))
+        self._worker.start()
+    
+    def _done(self, results):
+        self.scan_btn.setEnabled(True)
+        self.del_btn.setEnabled(len(results) > 0)
+        total = sum(e.size for e in results)
+        for e in results:
+            item = QTreeWidgetItem()
+            item.setText(0, os.path.basename(e.path))
+            item.setText(1, format_size(e.size))
+            item.setText(2, e.modified)
+            item.setText(3, e.category)
+            item.setText(4, e.path)
+            item.setData(0, Qt.ItemDataRole.UserRole, e.path)
+            if e.days_old > 365:
+                item.setForeground(2, QColor(Brand.DANGER))
+            elif e.days_old > 180:
+                item.setForeground(2, QColor(Brand.WARNING))
+            self.tree.addTopLevelItem(item)
+        self.status_lbl.setText(f"{len(results)} forgotten files ({format_size(total)})")
+        self.log_signal.emit(f"Old files: {len(results)} found, {format_size(total)}")
+    
+    def _delete(self):
+        items = self.tree.selectedItems()
+        if not items:
+            return
+        paths = [i.data(0, Qt.ItemDataRole.UserRole) for i in items]
+        if QMessageBox.question(self, "Delete", f"Delete {len(paths)} old files?") == QMessageBox.StandardButton.Yes:
+            r = DiskCleaner.delete_files(paths)
+            self.log_signal.emit(f"Deleted {r['deleted']} old files")
+            ToastNotification(self.window(), f"Freed {format_size(r['freed'])}", "success")
+            self._scan()
+
+
+class DuplicatesTab(QWidget):
+    log_signal = pyqtSignal(str)
+    
+    def __init__(self):
+        super().__init__()
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(12, 12, 12, 12)
+        layout.setSpacing(10)
+        
+        title = QLabel("Duplicate Finder")
+        title.setFont(QFont("Segoe UI", 16, QFont.Weight.Bold))
+        title.setStyleSheet(f"color: {Brand.GOLD}; border: none;")
+        layout.addWidget(title)
+        
+        ctrl = QHBoxLayout()
+        self.path_input = QLineEdit(str(Path.home()))
+        ctrl.addWidget(self.path_input)
+        browse_btn = QPushButton("Browse")
+        browse_btn.clicked.connect(lambda: self._browse())
+        ctrl.addWidget(browse_btn)
+        ctrl.addWidget(QLabel("Min:"))
+        self.min_spin = QSpinBox()
+        self.min_spin.setRange(1, 1000)
+        self.min_spin.setValue(1)
+        self.min_spin.setSuffix(" MB")
+        ctrl.addWidget(self.min_spin)
+        layout.addLayout(ctrl)
+        
+        self.tree = QTreeWidget()
+        self.tree.setHeaderLabels(["File", "Size", "Path"])
+        self.tree.header().setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
+        self.tree.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
+        self.tree.setAlternatingRowColors(True)
+        layout.addWidget(self.tree)
+        
+        bottom = QHBoxLayout()
+        self.status_lbl = QLabel("Ready")
+        self.status_lbl.setStyleSheet(f"color: {Brand.TEXT_DIM}; border: none;")
+        bottom.addWidget(self.status_lbl)
+        bottom.addStretch()
+        self.scan_btn = QPushButton("Find Duplicates")
+        self.scan_btn.setObjectName("primary")
+        self.scan_btn.clicked.connect(self._scan)
+        bottom.addWidget(self.scan_btn)
+        self.del_btn = QPushButton("Delete Selected")
+        self.del_btn.setObjectName("danger")
+        self.del_btn.clicked.connect(self._delete)
+        self.del_btn.setEnabled(False)
+        bottom.addWidget(self.del_btn)
+        layout.addLayout(bottom)
+        self._worker = None
+    
+    def _browse(self):
+        p = QFileDialog.getExistingDirectory(self, "Select")
+        if p:
+            self.path_input.setText(p)
+    
+    def _scan(self):
+        self.tree.clear()
+        self.scan_btn.setEnabled(False)
+        self.status_lbl.setText("Scanning...")
+        self._worker = ScanWorker('duplicates', self.path_input.text(), min_size=self.min_spin.value()*1024*1024)
+        self._worker.finished.connect(self._done)
+        self._worker.status.connect(lambda s: self.status_lbl.setText(s))
+        self._worker.start()
+    
+    def _done(self, groups):
+        self.scan_btn.setEnabled(True)
+        self.del_btn.setEnabled(len(groups) > 0)
+        waste = 0
+        for g in groups[:80]:
+            w = g.size * (len(g.files) - 1)
+            waste += w
+            parent = QTreeWidgetItem()
+            parent.setText(0, f"[{len(g.files)} copies] {os.path.basename(g.files[0])}")
+            parent.setText(1, format_size(g.size))
+            parent.setForeground(0, QColor(Brand.WARNING))
+            for fp in g.files:
+                child = QTreeWidgetItem(parent)
+                child.setText(0, os.path.basename(fp))
+                child.setText(1, format_size(g.size))
+                child.setText(2, fp)
+                child.setData(0, Qt.ItemDataRole.UserRole, fp)
+            self.tree.addTopLevelItem(parent)
+        self.status_lbl.setText(f"{len(groups)} groups | Wasted: {format_size(waste)}")
+        self.log_signal.emit(f"Duplicates: {len(groups)} groups, {format_size(waste)} wasted")
+    
+    def _delete(self):
+        items = self.tree.selectedItems()
+        paths = [i.data(0, Qt.ItemDataRole.UserRole) for i in items if i.data(0, Qt.ItemDataRole.UserRole)]
+        if paths and QMessageBox.question(self, "Delete", f"Delete {len(paths)} copies?") == QMessageBox.StandardButton.Yes:
+            r = DiskCleaner.delete_files(paths)
+            ToastNotification(self.window(), f"Freed {format_size(r['freed'])}", "success")
+            self._scan()
+
+
+class CleanerTab(QWidget):
+    log_signal = pyqtSignal(str)
+    
+    def __init__(self):
+        super().__init__()
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(12, 12, 12, 12)
+        layout.setSpacing(12)
+        
+        title = QLabel("System Cleaner")
+        title.setFont(QFont("Segoe UI", 16, QFont.Weight.Bold))
+        title.setStyleSheet(f"color: {Brand.GOLD}; border: none;")
+        layout.addWidget(title)
+        
+        # Info
+        self.info_lbl = QLabel("Analyzing...")
+        self.info_lbl.setStyleSheet(f"color: {Brand.TEXT}; border: none; font-size: 13px; padding: 8px;")
+        layout.addWidget(self.info_lbl)
+        
+        # Options
+        opts = QGroupBox("Select what to clean")
+        ol = QVBoxLayout(opts)
+        self.chk_temp = QCheckBox("Temporary Files")
+        self.chk_temp.setChecked(True)
+        ol.addWidget(self.chk_temp)
+        self.chk_trash = QCheckBox("Recycle Bin / Trash")
+        self.chk_trash.setChecked(True)
+        ol.addWidget(self.chk_trash)
+        self.chk_browser = QCheckBox("Browser Cache (Chrome, Edge, Firefox)")
+        ol.addWidget(self.chk_browser)
+        self.chk_thumbs = QCheckBox("Thumbnail Cache")
+        self.chk_thumbs.setChecked(True)
+        ol.addWidget(self.chk_thumbs)
+        layout.addWidget(opts)
+        
+        # Dry run
+        self.dry_run = QCheckBox("Dry Run - show what would be cleaned without deleting")
+        self.dry_run.setStyleSheet(f"color: {Brand.WARNING};")
+        layout.addWidget(self.dry_run)
+        
+        self.progress = QProgressBar()
+        self.progress.setValue(0)
+        self.progress.setFormat("Ready")
+        layout.addWidget(self.progress)
+        
+        self.result_lbl = QLabel("")
+        self.result_lbl.setStyleSheet(f"color: {Brand.SUCCESS}; border: none; font-weight: bold; font-size: 14px;")
+        layout.addWidget(self.result_lbl)
+        
+        btn = QHBoxLayout()
+        self.analyze_btn = QPushButton("Analyze")
+        self.analyze_btn.clicked.connect(self._analyze)
+        btn.addWidget(self.analyze_btn)
+        self.clean_btn = QPushButton("Clean Now")
+        self.clean_btn.setObjectName("primary")
+        self.clean_btn.clicked.connect(self._clean)
+        btn.addWidget(self.clean_btn)
+        btn.addStretch()
+        layout.addLayout(btn)
+        layout.addStretch()
+        
+        QTimer.singleShot(300, self._analyze)
+        self._worker = None
+    
+    def _analyze(self):
+        size, count = DiskScanner.scan_temp_size()
+        self.info_lbl.setText(f"Found {count:,} cleanable files ({format_size(size)})")
+    
+    def _clean(self):
+        if self.dry_run.isChecked():
+            size, count = DiskScanner.scan_temp_size()
+            QMessageBox.information(self, "Dry Run", f"Would clean ~{count:,} files\nWould free ~{format_size(size)}")
+            return
+        
+        if QMessageBox.question(self, "Clean", "Clean selected items?") != QMessageBox.StandardButton.Yes:
+            return
+        
+        tasks = []
+        if self.chk_temp.isChecked():
+            tasks.append('temp')
+        if self.chk_trash.isChecked():
+            tasks.append('trash')
+        if self.chk_browser.isChecked():
+            tasks.append('browser')
+        
+        self.clean_btn.setEnabled(False)
+        self.progress.setValue(50)
+        self.progress.setFormat("Cleaning...")
+        
+        self._worker = CleanWorker(tasks)
+        self._worker.finished.connect(self._done)
+        self._worker.start()
+    
+    def _done(self, result):
+        self.clean_btn.setEnabled(True)
+        self.progress.setValue(100)
+        self.progress.setFormat("Done!")
+        self.result_lbl.setText(f"Cleaned {result['deleted']:,} files | Freed {format_size(result['freed'])}")
+        self.log_signal.emit(f"Cleaned {result['deleted']} files, freed {format_size(result['freed'])}")
+        ToastNotification(self.window(), f"Freed {format_size(result['freed'])}", "success")
+        QTimer.singleShot(1000, self._analyze)
+
+
+class StartupTab(QWidget):
+    log_signal = pyqtSignal(str)
+    
+    def __init__(self):
+        super().__init__()
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(12, 12, 12, 12)
+        layout.setSpacing(10)
+        
+        title = QLabel("Startup Manager")
+        title.setFont(QFont("Segoe UI", 16, QFont.Weight.Bold))
+        title.setStyleSheet(f"color: {Brand.GOLD}; border: none;")
+        layout.addWidget(title)
+        
+        desc = QLabel("Programs that run when your computer starts")
+        desc.setStyleSheet(f"color: {Brand.TEXT_DIM}; border: none;")
+        layout.addWidget(desc)
+        
+        self.table = QTableWidget()
+        self.table.setColumnCount(4)
+        self.table.setHorizontalHeaderLabels(["Name", "Command", "Source", "Status"])
+        self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
+        self.table.verticalHeader().setVisible(False)
+        self.table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        layout.addWidget(self.table)
+        
+        bottom = QHBoxLayout()
+        refresh_btn = QPushButton("Refresh")
+        refresh_btn.clicked.connect(self._refresh)
+        bottom.addWidget(refresh_btn)
+        bottom.addStretch()
+        self.status_lbl = QLabel("")
+        self.status_lbl.setStyleSheet(f"color: {Brand.TEXT_DIM}; border: none;")
+        bottom.addWidget(self.status_lbl)
+        layout.addLayout(bottom)
+        
+        self._refresh()
+    
+    def _refresh(self):
+        items = DiskScanner.get_startup_items()
+        self.table.setRowCount(len(items))
+        for i, item in enumerate(items):
+            self.table.setItem(i, 0, QTableWidgetItem(item["name"]))
+            self.table.setItem(i, 1, QTableWidgetItem(item["command"][:80]))
+            self.table.setItem(i, 2, QTableWidgetItem(item["source"]))
+            status = QTableWidgetItem("Enabled")
+            status.setForeground(QColor(Brand.SUCCESS))
+            self.table.setItem(i, 3, status)
+        self.status_lbl.setText(f"{len(items)} startup items")
+        self.log_signal.emit(f"Startup: {len(items)} items found")
+
+
+class LogTab(QWidget):
+    def __init__(self):
+        super().__init__()
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(12, 12, 12, 12)
+        
+        title = QLabel("Activity Log")
+        title.setFont(QFont("Segoe UI", 16, QFont.Weight.Bold))
+        title.setStyleSheet(f"color: {Brand.GOLD}; border: none;")
+        layout.addWidget(title)
+        
+        self.log = QTextEdit()
+        self.log.setReadOnly(True)
+        self.log.setFont(QFont("Consolas", 10))
+        layout.addWidget(self.log)
+        
+        btn = QHBoxLayout()
+        QPushButton("Clear", clicked=self.log.clear).also = btn.addWidget(QPushButton("Clear", clicked=self.log.clear))
+        btn.addStretch()
+        layout.addLayout(btn)
+        
+        self.add("MoneyPackCleaner initialized")
+    
+    def add(self, msg):
+        ts = datetime.now().strftime("%H:%M:%S")
+        self.log.append(f"<span style='color:{Brand.TEXT_DIM}'>[{ts}]</span> <span style='color:{Brand.TEXT}'>{msg}</span>")
+
+
+# ============================================================================
+# MAIN WINDOW
+# ============================================================================
+
+DARK_QSS = f"""
+QMainWindow {{ background-color: {Brand.BG_DARK}; color: {Brand.TEXT}; }}
+QMenuBar {{ background-color: {Brand.BG_PANEL}; color: {Brand.TEXT}; border-bottom: 1px solid {Brand.BORDER}; }}
+QMenuBar::item {{ padding: 6px 16px; }}
+QMenuBar::item:selected {{ background-color: {Brand.BG_CARD}; }}
+QMenu {{ background-color: {Brand.BG_PANEL}; border: 1px solid {Brand.BORDER}; color: {Brand.TEXT}; }}
+QMenu::item {{ padding: 6px 30px; }}
+QMenu::item:selected {{ background-color: {Brand.BG_CARD}; color: {Brand.GOLD}; }}
+QLabel {{ color: {Brand.TEXT}; }}
+QGroupBox {{ font-weight: bold; border: 1px solid {Brand.BORDER}; border-radius: 8px; margin-top: 10px; padding-top: 12px; color: {Brand.TEXT}; }}
+QGroupBox::title {{ subcontrol-origin: margin; left: 12px; padding: 0 5px; color: {Brand.GOLD}; }}
+QProgressBar {{ border: 1px solid {Brand.BORDER}; border-radius: 6px; text-align: center; background-color: {Brand.BG_PANEL}; color: {Brand.TEXT}; height: 22px; }}
+QProgressBar::chunk {{ background: qlineargradient(x1:0,y1:0,x2:1,y2:0, stop:0 {Brand.PINK}, stop:1 {Brand.GOLD}); border-radius: 6px; }}
+QPushButton {{ background-color: {Brand.BG_CARD}; border: 1px solid {Brand.BORDER}; border-radius: 6px; padding: 8px 18px; color: {Brand.TEXT}; font-weight: bold; }}
+QPushButton:hover {{ border-color: {Brand.GOLD}; color: {Brand.GOLD}; }}
+QPushButton:pressed {{ background-color: {Brand.GOLD}; color: #000; }}
+QPushButton:disabled {{ color: {Brand.TEXT_MUTED}; border-color: {Brand.BG_PANEL}; }}
+QPushButton#primary {{ background-color: {Brand.PINK}; border: none; color: #fff; }}
+QPushButton#primary:hover {{ background-color: {Brand.PINK_LIGHT}; }}
+QPushButton#danger {{ background-color: {Brand.DANGER}; border: none; color: #fff; }}
+QPushButton#danger:hover {{ background-color: #ff4466; }}
+QTreeWidget, QTableWidget {{ background-color: {Brand.BG_PANEL}; border: 1px solid {Brand.BORDER}; color: {Brand.TEXT}; alternate-background-color: {Brand.BG_DARK}; gridline-color: {Brand.BORDER}; }}
+QTreeWidget::item:selected, QTableWidget::item:selected {{ background-color: {Brand.BG_CARD}; }}
+QHeaderView::section {{ background-color: {Brand.BG_CARD}; color: {Brand.TEXT_DIM}; padding: 6px; border: none; border-bottom: 2px solid {Brand.BORDER}; font-weight: bold; font-size: 11px; }}
+QTextEdit {{ background-color: {Brand.BG_PANEL}; border: 1px solid {Brand.BORDER}; color: {Brand.TEXT}; border-radius: 6px; }}
+QLineEdit {{ background-color: {Brand.BG_PANEL}; border: 1px solid {Brand.BORDER}; border-radius: 6px; padding: 7px; color: {Brand.TEXT}; }}
+QLineEdit:focus {{ border-color: {Brand.GOLD}; }}
+QTabWidget::pane {{ border: 1px solid {Brand.BORDER}; border-radius: 0; }}
+QTabBar::tab {{ background-color: {Brand.BG_PANEL}; color: {Brand.TEXT_DIM}; padding: 10px 20px; border: none; border-bottom: 3px solid transparent; font-weight: bold; }}
+QTabBar::tab:selected {{ color: {Brand.GOLD}; border-bottom: 3px solid {Brand.GOLD}; background-color: {Brand.BG_DARK}; }}
+QTabBar::tab:hover {{ color: {Brand.TEXT}; }}
+QScrollBar:vertical {{ background-color: {Brand.BG_DARK}; width: 8px; }}
+QScrollBar::handle:vertical {{ background-color: {Brand.BORDER}; border-radius: 4px; min-height: 20px; }}
+QScrollBar::handle:vertical:hover {{ background-color: {Brand.GOLD}; }}
+QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {{ height: 0; }}
+QCheckBox {{ color: {Brand.TEXT}; spacing: 8px; }}
+QCheckBox::indicator {{ width: 18px; height: 18px; border: 2px solid {Brand.BORDER}; border-radius: 4px; background: {Brand.BG_PANEL}; }}
+QCheckBox::indicator:checked {{ background-color: {Brand.PINK}; border-color: {Brand.PINK}; }}
+QSpinBox {{ background: {Brand.BG_PANEL}; border: 1px solid {Brand.BORDER}; border-radius: 6px; padding: 5px; color: {Brand.TEXT}; }}
+QStatusBar {{ background-color: {Brand.BG_PANEL}; color: {Brand.TEXT_DIM}; border-top: 1px solid {Brand.BORDER}; }}
+QFrame {{ border: none; }}
+QToolTip {{ background: {Brand.BG_CARD}; color: {Brand.TEXT}; border: 1px solid {Brand.GOLD}; padding: 5px; border-radius: 4px; }}
+QMessageBox {{ background-color: {Brand.BG_DARK}; }}
+"""
+
+
+class MoneyPackCleanerWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("MoneyPackCleaner")
+        self.setMinimumSize(1100, 750)
+        self.resize(1300, 850)
+        
+        self._setup_menu()
+        self._setup_ui()
+        self._setup_tray()
+        self._setup_statusbar()
+        self._setup_scheduler()
+    
+    def _setup_menu(self):
+        mb = self.menuBar()
+        file_m = mb.addMenu("File")
+        file_m.addAction(QAction("Refresh", self, shortcut="F5", triggered=lambda: self.dashboard.refresh()))
+        file_m.addSeparator()
+        file_m.addAction(QAction("Exit", self, shortcut="Ctrl+Q", triggered=self.close))
+        
+        tools_m = mb.addMenu("Tools")
+        tools_m.addAction(QAction("Quick Clean", self, shortcut="Ctrl+Shift+C", triggered=lambda: self.dashboard._quick_clean()))
+        tools_m.addSeparator()
+        for i, name in enumerate(["Dashboard","Large Files","Old Files","Duplicates","Clean","Startup","Log"]):
+            tools_m.addAction(QAction(name, self, triggered=lambda checked, idx=i: self.tabs.setCurrentIndex(idx)))
+        
+        help_m = mb.addMenu("Help")
+        help_m.addAction(QAction("About", self, triggered=self._about))
+    
+    def _setup_ui(self):
+        central = QWidget()
+        self.setCentralWidget(central)
+        layout = QVBoxLayout(central)
+        layout.setContentsMargins(0, 0, 0, 0)
+        
+        self.tabs = QTabWidget()
+        
+        self.dashboard = DashboardTab()
+        self.tabs.addTab(self.dashboard, "Dashboard")
+        
+        self.large_tab = LargeFilesTab()
+        self.tabs.addTab(self.large_tab, "Large Files")
+        
+        self.old_tab = OldFilesTab()
+        self.tabs.addTab(self.old_tab, "Old Files")
+        
+        self.dup_tab = DuplicatesTab()
+        self.tabs.addTab(self.dup_tab, "Duplicates")
+        
+        self.clean_tab = CleanerTab()
+        self.tabs.addTab(self.clean_tab, "Clean")
+        
+        self.startup_tab = StartupTab()
+        self.tabs.addTab(self.startup_tab, "Startup")
+        
+        self.log_tab = LogTab()
+        self.tabs.addTab(self.log_tab, "Log")
+        
+        layout.addWidget(self.tabs)
+        
+        # Connect logs
+        for tab in [self.dashboard, self.large_tab, self.old_tab, self.dup_tab, self.clean_tab, self.startup_tab]:
+            tab.log_signal.connect(self.log_tab.add)
+    
+    def _setup_tray(self):
+        if not QSystemTrayIcon.isSystemTrayAvailable():
+            return
+        
+        # Create icon
+        pixmap = QPixmap(32, 32)
+        pixmap.fill(QColor(0, 0, 0, 0))
+        painter = QPainter(pixmap)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.setBrush(QColor(Brand.PINK))
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.drawEllipse(2, 2, 28, 28)
+        painter.setPen(QPen(QColor(Brand.GOLD), 2))
+        painter.setFont(QFont("Arial", 14, QFont.Weight.Bold))
+        painter.drawText(QRect(0, 0, 32, 32), Qt.AlignmentFlag.AlignCenter, "M")
+        painter.end()
+        
+        self._tray = QSystemTrayIcon(QIcon(pixmap), self)
+        self._tray.setToolTip("MoneyPackCleaner")
+        
+        menu = QMenu()
+        menu.addAction("Show", self.show)
+        menu.addAction("Quick Clean", self.dashboard._quick_clean)
+        menu.addSeparator()
+        menu.addAction("Exit", self._quit)
+        self._tray.setContextMenu(menu)
+        self._tray.activated.connect(lambda r: self.show() if r == QSystemTrayIcon.ActivationReason.DoubleClick else None)
+        self._tray.show()
+    
+    def _setup_statusbar(self):
+        self.statusBar().showMessage("Ready")
+        self._status_timer = QTimer(self)
+        self._status_timer.timeout.connect(self._update_status)
+        self._status_timer.start(15000)
+        self._update_status()
+    
+    def _update_status(self):
+        disks = DiskScanner.get_disks()
+        if disks:
+            free = sum(d.free for d in disks)
+            self.statusBar().showMessage(f"Free: {format_size(free)} | {datetime.now().strftime('%H:%M')}")
+    
+    def _setup_scheduler(self):
+        """Auto-clean every 4 hours."""
+        self._sched_timer = QTimer(self)
+        self._sched_timer.timeout.connect(self._scheduled_clean)
+        self._sched_timer.start(4 * 60 * 60 * 1000)  # 4 hours
+    
+    def _scheduled_clean(self):
+        r = DiskCleaner.clean_temp()
+        self.log_tab.add(f"[Scheduled] Auto-cleaned {r['deleted']} files, freed {format_size(r['freed'])}")
+        if hasattr(self, '_tray'):
+            self._tray.showMessage("MoneyPackCleaner", f"Auto-cleaned: freed {format_size(r['freed'])}", QSystemTrayIcon.MessageIcon.Information, 3000)
+    
+    def _about(self):
+        QMessageBox.about(self, "About MoneyPackCleaner",
+            "MoneyPackCleaner v1.0\n"
+            "Created by MoneyPack\n\n"
+            "Premium Storage Optimization Suite\n\n"
+            "Features:\n"
+            "- Disk usage with donut chart\n"
+            "- Large file scanner\n"
+            "- Forgotten file finder\n"
+            "- Duplicate detector\n"
+            "- System cleaner\n"
+            "- Startup manager\n"
+            "- Scheduled auto-cleaning\n"
+            "- System tray\n"
+            "- Dry run mode\n"
+            "- Toast notifications"
+        )
+    
+    def _quit(self):
+        if hasattr(self, '_tray'):
+            self._tray.hide()
+        QApplication.quit()
+    
+    def closeEvent(self, event):
+        if hasattr(self, '_tray') and self._tray.isVisible():
+            self.hide()
+            self._tray.showMessage("MoneyPackCleaner", "Running in background", QSystemTrayIcon.MessageIcon.Information, 2000)
+            event.ignore()
+        else:
+            event.accept()
+
+
+# ============================================================================
+# SPLASH SCREEN
+# ============================================================================
+
+def create_splash() -> QSplashScreen:
+    """Create branded splash screen."""
+    pixmap = QPixmap(500, 300)
+    pixmap.fill(QColor(Brand.BG_DARK))
+    
+    painter = QPainter(pixmap)
+    painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+    
+    # Gradient background
+    grad = QLinearGradient(0, 0, 500, 300)
+    grad.setColorAt(0, QColor(Brand.BG_DARK))
+    grad.setColorAt(0.5, QColor(Brand.BG_PANEL))
+    grad.setColorAt(1, QColor(Brand.BG_DARK))
+    painter.fillRect(0, 0, 500, 300, grad)
+    
+    # Border glow
+    painter.setPen(QPen(QColor(Brand.GOLD), 2))
+    painter.setBrush(Qt.BrushStyle.NoBrush)
+    painter.drawRoundedRect(2, 2, 496, 296, 12, 12)
+    
+    # Bunny silhouette (centered)
+    painter.setBrush(QColor(Brand.PINK))
+    painter.setPen(Qt.PenStyle.NoPen)
+    cx, cy = 250, 110
+    # Head
+    painter.drawEllipse(int(cx-25), int(cy-25), 50, 50)
+    # Ears
+    painter.drawEllipse(int(cx-18), int(cy-70), 14, 50)
+    painter.drawEllipse(int(cx+4), int(cy-70), 14, 50)
+    # Inner ears (gold)
+    painter.setBrush(QColor(Brand.GOLD))
+    painter.drawEllipse(int(cx-14), int(cy-60), 7, 30)
+    painter.drawEllipse(int(cx+7), int(cy-60), 7, 30)
+    
+    # Title
+    painter.setPen(QColor(Brand.GOLD))
+    font = QFont("Segoe UI", 28, QFont.Weight.Bold)
+    painter.setFont(font)
+    painter.drawText(QRect(0, 150, 500, 50), Qt.AlignmentFlag.AlignCenter, "MoneyPackCleaner")
+    
+    # Subtitle
+    painter.setPen(QColor(Brand.TEXT_DIM))
+    font = QFont("Segoe UI", 12)
+    painter.setFont(font)
+    painter.drawText(QRect(0, 200, 500, 30), Qt.AlignmentFlag.AlignCenter, "Premium Storage Optimization")
+    
+    # Author
+    painter.setPen(QColor(Brand.PINK))
+    font = QFont("Segoe UI", 10)
+    painter.setFont(font)
+    painter.drawText(QRect(0, 240, 500, 25), Qt.AlignmentFlag.AlignCenter, "by MoneyPack")
+    
+    # Loading text
+    painter.setPen(QColor(Brand.TEXT_MUTED))
+    painter.drawText(QRect(0, 270, 500, 20), Qt.AlignmentFlag.AlignCenter, "Loading...")
+    
+    painter.end()
+    
+    splash = QSplashScreen(pixmap)
+    splash.setWindowFlags(Qt.WindowType.SplashScreen | Qt.WindowType.FramelessWindowHint)
+    return splash
+
+
+# ============================================================================
+# ENTRY POINT
+# ============================================================================
+
+def main():
+    app = QApplication(sys.argv)
+    app.setStyle("Fusion")
+    app.setStyleSheet(DARK_QSS)
+    app.setFont(QFont("Segoe UI", 10))
+    app.setApplicationName("MoneyPackCleaner")
+    
+    # Splash
+    splash = create_splash()
+    splash.show()
+    app.processEvents()
+    
+    # Load main window
+    time.sleep(1.5)
+    window = MoneyPackCleanerWindow()
+    
+    splash.finish(window)
+    window.show()
+    
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()