aris-mac-cleaner 3.5.0 → 4.0.0

package/bin/cli.js

@@ -114,11 +114,85 @@ try {
   };
 }
 
+// Inquirer for arrow key navigation
+let inquirer;
+let useInquirer = true;
+
+try {
+  inquirer = require('inquirer');
+} catch (e) {
+  useInquirer = false;
+}
+
+// ============================================================================
+// INQUIRER HELPER FUNCTIONS
+// ============================================================================
+
+async function selectOption(message, choices, fallbackPromptFn) {
+  if (useInquirer && inquirer) {
+    try {
+      const { selection } = await inquirer.prompt([{
+        type: 'list',
+        name: 'selection',
+        message: message,
+        choices: choices,
+        loop: false,
+        pageSize: 20
+      }]);
+      return selection;
+    } catch (e) {
+      if (fallbackPromptFn) return fallbackPromptFn();
+      return null;
+    }
+  }
+  if (fallbackPromptFn) return fallbackPromptFn();
+  return null;
+}
+
+async function selectMultiple(message, choices, fallbackPromptFn) {
+  if (useInquirer && inquirer) {
+    try {
+      const { selections } = await inquirer.prompt([{
+        type: 'checkbox',
+        name: 'selections',
+        message: message,
+        choices: choices,
+        pageSize: 20
+      }]);
+      return selections;
+    } catch (e) {
+      if (fallbackPromptFn) return fallbackPromptFn();
+      return [];
+    }
+  }
+  if (fallbackPromptFn) return fallbackPromptFn();
+  return [];
+}
+
+async function confirmAction(message, defaultValue = false, fallbackPromptFn) {
+  if (useInquirer && inquirer) {
+    try {
+      const { confirmed } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: message,
+        default: defaultValue
+      }]);
+      return confirmed;
+    } catch (e) {
+      if (fallbackPromptFn) return fallbackPromptFn();
+      return defaultValue;
+    }
+  }
+  if (fallbackPromptFn) return fallbackPromptFn();
+  return defaultValue;
+}
+
 // ============================================================================
 // CONSTANTS
 // ============================================================================
 
-const VERSION = '3.5.0';
+const VERSION = '4.0.0';
 const PACKAGE_NAME = 'aris-mac-cleaner';
 const HOME = os.homedir();
 const CONFIG_DIR = path.join(HOME, '.aris-mac-cleaner');
@@ -158,22 +232,49 @@ if (fs.existsSync(LANGUAGE_FILE)) {
 const MSG = LANG_CODE === 'pt' ? {
   WELCOME: 'Bem-vindo ao Aris Mac Cleaner',
   MENU_TITLE: 'MENU PRINCIPAL',
-  OPT_QUICK: 'Limpeza Rapida',
-  OPT_LARGE: 'Ficheiros Grandes',
-  OPT_DUPLICATES: 'Duplicados',
-  OPT_APPS: 'Desinstalar Apps',
-  OPT_STARTUP: 'Apps de Arranque',
-  OPT_BROWSERS: 'Limpar Browsers',
-  OPT_PROCESSES: 'Processos Pesados',
-  OPT_STATS: 'Estatisticas',
-  OPT_SETTINGS: 'Configuracoes',
-  OPT_DISK: 'Analisador Disco',
-  OPT_PRIVACY: 'Limpeza Privacidade',
-  OPT_MEMORY: 'Otimizar Memoria',
+  // Section headers
+  SECTION_CLEANING: 'LIMPEZAS',
+  SECTION_ANALYSIS: 'ANALISES',
+  SECTION_SETTINGS: 'DEFINICOES',
+  // Menu options
+  OPT_QUICK: 'Quick Clean',
+  OPT_DEEP: 'Deep Clean',
+  OPT_LARGE: 'Large Files',
+  OPT_DUPLICATES: 'Duplicates',
+  OPT_APPS: 'App Uninstaller',
+  OPT_STARTUP: 'Startup Manager',
+  OPT_BROWSERS: 'Browser Cleaner',
+  OPT_PROCESSES: 'Process Manager',
+  OPT_STATS: 'Statistics',
+  OPT_SETTINGS: 'Settings',
+  OPT_DISK: 'Disk Analyzer',
+  OPT_PRIVACY: 'Privacy Sweep',
+  OPT_MEMORY: 'Memory Optimizer',
   OPT_BENCHMARK: 'Benchmark',
-  OPT_SCHEDULER: 'Agendar Limpeza',
-  OPT_EXPORT: 'Exportar Relatorio',
-  OPT_EXIT: 'Sair',
+  OPT_THERMAL: 'Thermal Monitor',
+  OPT_SCHEDULER: 'Scheduler',
+  OPT_EXPORT: 'Export Report',
+  OPT_EXIT: 'Exit',
+  // Deep Clean
+  DEEP_CLEAN: 'Deep Clean',
+  DEEP_CLEAN_DESC: 'Limpeza agressiva completa do sistema',
+  DEEP_CLEAN_WARNING: 'AVISO: Esta operacao vai limpar TUDO. Podes perder dados de cache importantes.',
+  DEEP_CLEAN_CONFIRM: 'Tens a certeza que queres continuar?',
+  DEEP_CLEAN_TIME: 'Tempo estimado: 2-5 minutos',
+  // Deep Clean categories
+  CAT_SYSTEM_CACHES: 'Caches do Sistema',
+  CAT_APP_CACHES: 'Caches de Aplicacoes',
+  CAT_XCODE: 'Xcode',
+  CAT_DEV_CACHES: 'Caches de Dev',
+  CAT_DOCKER: 'Docker',
+  CAT_IOS_BACKUPS: 'Backups iOS',
+  CAT_OLD_DOWNLOADS: 'Downloads Antigos',
+  CAT_MAIL: 'Mail Attachments',
+  CAT_TRASH: 'Lixo',
+  CAT_FONTS: 'Caches de Fontes',
+  CAT_ADOBE: 'Adobe Caches',
+  CAT_MUSIC: 'Music/Spotify Caches',
+  CAT_LOGS: 'Logs Antigos',
   CHOOSE: 'Escolha',
   INVALID: 'Opcao invalida',
   PRESS_ENTER: 'Pressiona ENTER para continuar',
@@ -272,26 +373,89 @@ const MSG = LANG_CODE === 'pt' ? {
   DISK_ANALYSIS: 'ANALISE DE DISCO',
   SCHEDULED_DAILY: 'Agendado diariamente',
   SCHEDULED_WEEKLY: 'Agendado semanalmente',
-  CLEANUP_COMPLETE: 'Limpeza completa!'
+  CLEANUP_COMPLETE: 'Limpeza completa!',
+  THERMAL_STATUS: 'ESTADO TERMAL',
+  THERMAL_COOL: 'FRIO',
+  THERMAL_GOOD: 'BOM',
+  THERMAL_WARM: 'MORNO',
+  THERMAL_HOT: 'QUENTE',
+  THERMAL_CRITICAL: 'CRITICO',
+  THERMAL_TIP_COOL: 'Sistema a funcionar eficientemente',
+  THERMAL_TIP_GOOD: 'Operacao normal',
+  THERMAL_TIP_WARM: 'Sistema a trabalhar forte',
+  THERMAL_TIP_HOT: 'Fecha apps pesadas ou aguarda arrefecimento',
+  THERMAL_TIP_CRITICAL: 'CPU throttling ativo! Fecha apps imediatamente',
+  THERMAL_LEVEL: 'Nivel',
+  THERMAL_TIP: 'Dica',
+  THERMAL_DETAILED: 'Queres info detalhada de energia? (precisa sudo)',
+  THERMAL_STATS_APP: 'Para monitoramento continuo, instala Stats:',
+  THERMAL_POWER: 'Potencia',
+  THERMAL_CPU_POWER: 'CPU',
+  THERMAL_GPU_POWER: 'GPU',
+  THERMAL_ANE_POWER: 'ANE',
+  THERMAL_FREQ: 'Frequencia',
+  THERMAL_LOW: 'Baixo',
+  THERMAL_MEDIUM: 'Medio',
+  THERMAL_HIGH: 'Alto',
+  THERMAL_VERY_HIGH: 'Muito Alto',
+  // Confirmation mode
+  CONFIRM_MODE: 'Modo de confirmacao:',
+  CONFIRM_AUTO: 'Auto - apagar tudo',
+  CONFIRM_MANUAL: 'Manual - confirmar cada item',
+  CONFIRM_DRYRUN: 'Dry-run - apenas pre-visualizar',
+  CONFIRM_CHOOSE: 'Escolhe [a/m/d]:',
+  CONFIRM_ITEM: 'Apagar:',
+  CONFIRM_YES_NO_ALL: '[s/n/a] (Sim / Nao / Aceitar restantes):',
+  SUMMARY_DELETED: 'Apagados',
+  SUMMARY_SKIPPED: 'Ignorados',
+  SUMMARY_FREED: 'Libertado',
+  SUMMARY_WOULD_FREE: 'Seria libertado'
 } : {
   WELCOME: 'Welcome to Aris Mac Cleaner',
   MENU_TITLE: 'MAIN MENU',
+  // Section headers
+  SECTION_CLEANING: 'CLEANING',
+  SECTION_ANALYSIS: 'ANALYSIS',
+  SECTION_SETTINGS: 'SETTINGS',
+  // Menu options
   OPT_QUICK: 'Quick Clean',
+  OPT_DEEP: 'Deep Clean',
   OPT_LARGE: 'Large Files',
   OPT_DUPLICATES: 'Duplicates',
-  OPT_APPS: 'Uninstall Apps',
-  OPT_STARTUP: 'Startup Apps',
-  OPT_BROWSERS: 'Clean Browsers',
-  OPT_PROCESSES: 'Heavy Processes',
+  OPT_APPS: 'App Uninstaller',
+  OPT_STARTUP: 'Startup Manager',
+  OPT_BROWSERS: 'Browser Cleaner',
+  OPT_PROCESSES: 'Process Manager',
   OPT_STATS: 'Statistics',
   OPT_SETTINGS: 'Settings',
   OPT_DISK: 'Disk Analyzer',
   OPT_PRIVACY: 'Privacy Sweep',
   OPT_MEMORY: 'Memory Optimizer',
   OPT_BENCHMARK: 'Benchmark',
-  OPT_SCHEDULER: 'Schedule Cleanup',
+  OPT_THERMAL: 'Thermal Monitor',
+  OPT_SCHEDULER: 'Scheduler',
   OPT_EXPORT: 'Export Report',
   OPT_EXIT: 'Exit',
+  // Deep Clean
+  DEEP_CLEAN: 'Deep Clean',
+  DEEP_CLEAN_DESC: 'Aggressive full system cleanup',
+  DEEP_CLEAN_WARNING: 'WARNING: This will clean EVERYTHING. You may lose important cache data.',
+  DEEP_CLEAN_CONFIRM: 'Are you sure you want to continue?',
+  DEEP_CLEAN_TIME: 'Estimated time: 2-5 minutes',
+  // Deep Clean categories
+  CAT_SYSTEM_CACHES: 'System Caches',
+  CAT_APP_CACHES: 'Application Caches',
+  CAT_XCODE: 'Xcode',
+  CAT_DEV_CACHES: 'Dev Caches',
+  CAT_DOCKER: 'Docker',
+  CAT_IOS_BACKUPS: 'iOS Backups',
+  CAT_OLD_DOWNLOADS: 'Old Downloads',
+  CAT_MAIL: 'Mail Attachments',
+  CAT_TRASH: 'Trash',
+  CAT_FONTS: 'Font Caches',
+  CAT_ADOBE: 'Adobe Caches',
+  CAT_MUSIC: 'Music/Spotify Caches',
+  CAT_LOGS: 'Old Logs',
   CHOOSE: 'Choose',
   INVALID: 'Invalid option',
   PRESS_ENTER: 'Press ENTER to continue',
@@ -390,7 +554,43 @@ const MSG = LANG_CODE === 'pt' ? {
   DISK_ANALYSIS: 'DISK ANALYSIS',
   SCHEDULED_DAILY: 'Scheduled daily',
   SCHEDULED_WEEKLY: 'Scheduled weekly',
-  CLEANUP_COMPLETE: 'Cleanup complete!'
+  CLEANUP_COMPLETE: 'Cleanup complete!',
+  THERMAL_STATUS: 'THERMAL STATUS',
+  THERMAL_COOL: 'COOL',
+  THERMAL_GOOD: 'GOOD',
+  THERMAL_WARM: 'WARM',
+  THERMAL_HOT: 'HOT',
+  THERMAL_CRITICAL: 'CRITICAL',
+  THERMAL_TIP_COOL: 'System running efficiently',
+  THERMAL_TIP_GOOD: 'Normal operation',
+  THERMAL_TIP_WARM: 'System working hard',
+  THERMAL_TIP_HOT: 'Close heavy apps or wait for cooldown',
+  THERMAL_TIP_CRITICAL: 'CPU throttling active! Close apps immediately',
+  THERMAL_LEVEL: 'Level',
+  THERMAL_TIP: 'Tip',
+  THERMAL_DETAILED: 'Want detailed power info? (requires sudo)',
+  THERMAL_STATS_APP: 'For continuous monitoring, install Stats:',
+  THERMAL_POWER: 'Power',
+  THERMAL_CPU_POWER: 'CPU',
+  THERMAL_GPU_POWER: 'GPU',
+  THERMAL_ANE_POWER: 'ANE',
+  THERMAL_FREQ: 'Frequency',
+  THERMAL_LOW: 'Low',
+  THERMAL_MEDIUM: 'Medium',
+  THERMAL_HIGH: 'High',
+  THERMAL_VERY_HIGH: 'Very High',
+  // Confirmation mode
+  CONFIRM_MODE: 'Confirmation mode:',
+  CONFIRM_AUTO: 'Auto - delete all',
+  CONFIRM_MANUAL: 'Manual - confirm each item',
+  CONFIRM_DRYRUN: 'Dry-run - just preview',
+  CONFIRM_CHOOSE: 'Choose [a/m/d]:',
+  CONFIRM_ITEM: 'Delete:',
+  CONFIRM_YES_NO_ALL: '[y/n/a] (Yes / No / Accept all remaining):',
+  SUMMARY_DELETED: 'Deleted',
+  SUMMARY_SKIPPED: 'Skipped',
+  SUMMARY_FREED: 'Freed',
+  SUMMARY_WOULD_FREE: 'Would free'
 };
 
 // ============================================================================
@@ -404,7 +604,7 @@ const ASCII_LOGO = `
  / ___ \\|  _ < | | ___) |
 /_/   \\_\\_| \\_\\___|____/
 
- MAC CLEANER v${VERSION} PREMIUM
+ MAC CLEANER v${VERSION}
 `;
 
 const ASCII_LOGO_FRAMES = [
@@ -510,6 +710,83 @@ async function pressEnter() {
   await prompt(`  ${chalk.dim(MSG.PRESS_ENTER + '...')} `);
 }
 
+// ============================================================================
+// CONFIRMATION MODE SYSTEM
+// ============================================================================
+
+async function askConfirmationMode() {
+  const choices = [
+    { name: chalk.green(MSG.CONFIRM_AUTO), value: 'auto' },
+    { name: chalk.yellow(MSG.CONFIRM_MANUAL), value: 'manual' },
+    { name: chalk.blue(MSG.CONFIRM_DRYRUN), value: 'dryrun' }
+  ];
+
+  const fallback = async () => {
+    console.log();
+    console.log(chalk.cyan('  +-------------------------------------+'));
+    console.log(chalk.cyan('  |  ') + chalk.white(MSG.CONFIRM_MODE.padEnd(35)) + chalk.cyan('|'));
+    console.log(chalk.cyan('  |                                     |'));
+    console.log(chalk.cyan('  |  ') + chalk.green('[a]') + chalk.white(' ' + MSG.CONFIRM_AUTO.padEnd(30)) + chalk.cyan('|'));
+    console.log(chalk.cyan('  |  ') + chalk.yellow('[m]') + chalk.white(' ' + MSG.CONFIRM_MANUAL.padEnd(30)) + chalk.cyan('|'));
+    console.log(chalk.cyan('  |  ') + chalk.blue('[d]') + chalk.white(' ' + MSG.CONFIRM_DRYRUN.padEnd(30)) + chalk.cyan('|'));
+    console.log(chalk.cyan('  |                                     |'));
+    console.log(chalk.cyan('  +-------------------------------------+'));
+    console.log();
+    const c = await prompt(`  ${chalk.white(MSG.CONFIRM_CHOOSE)} `);
+    switch (c.toLowerCase()) {
+      case 'm': return 'manual';
+      case 'd': return 'dryrun';
+      default: return 'auto';
+    }
+  };
+
+  console.log();
+  return await selectOption(MSG.CONFIRM_MODE, choices, fallback);
+}
+
+async function confirmItem(itemPath, itemSize) {
+  const displayPath = itemPath.replace(HOME, '~');
+  const shortPath = displayPath.length > 45 ? '...' + displayPath.slice(-42) : displayPath;
+  const itemDisplay = `${shortPath} ${chalk.dim('(' + formatSize(itemSize) + ')')}`;
+
+  const choices = [
+    { name: LANG_CODE === 'pt' ? 'Sim' : 'Yes', value: 'yes' },
+    { name: LANG_CODE === 'pt' ? 'Nao' : 'No', value: 'no' },
+    { name: LANG_CODE === 'pt' ? 'Aceitar restantes' : 'Accept all remaining', value: 'all' }
+  ];
+
+  const fallback = async () => {
+    console.log();
+    console.log(`  ${chalk.yellow(MSG.CONFIRM_ITEM)} ${chalk.white(shortPath)} ${chalk.dim('(' + formatSize(itemSize) + ')')}`);
+    const answer = await prompt(`  ${chalk.dim(MSG.CONFIRM_YES_NO_ALL)} `);
+    const yesKeys = LANG_CODE === 'pt' ? ['s', 'sim'] : ['y', 'yes'];
+    if (['a'].includes(answer.toLowerCase())) return 'all';
+    if (yesKeys.includes(answer.toLowerCase())) return 'yes';
+    return 'no';
+  };
+
+  console.log();
+  return await selectOption(`${MSG.CONFIRM_ITEM} ${itemDisplay}`, choices, fallback);
+}
+
+function showCleanupSummary(deleted, skipped, freedSize, mode) {
+  console.log();
+  console.log(chalk.white('  ' + '='.repeat(50)));
+  console.log();
+
+  if (mode === 'dryrun') {
+    console.log(`  ${chalk.blue(figures.info)} ${chalk.white(MSG.DRY_RUN_MODE)}`);
+    console.log();
+    console.log(`  ${figures.bullet} ${MSG.SUMMARY_WOULD_FREE}: ${chalk.green(formatSize(freedSize))}`);
+  } else {
+    console.log(`  ${figures.tick} ${MSG.SUMMARY_DELETED}: ${chalk.green(deleted)}`);
+    console.log(`  ${figures.cross} ${MSG.SUMMARY_SKIPPED}: ${chalk.yellow(skipped)}`);
+    console.log(`  ${figures.arrowRight} ${MSG.SUMMARY_FREED}: ${chalk.green(formatSize(freedSize))}`);
+  }
+
+  console.log();
+}
+
 // ============================================================================
 // PREMIUM HEADER WITH GRADIENT
 // ============================================================================
@@ -523,7 +800,7 @@ function header() {
 
   const titleBox = `
 ${chalk.cyan('+')}${chalk.cyan('-'.repeat(68))}${chalk.cyan('+')}
-${chalk.cyan('|')}${chalk.white('                    ARIS MAC CLEANER v' + VERSION + ' PREMIUM                 ')}${chalk.cyan('|')}
+${chalk.cyan('|')}${chalk.white('                      ARIS MAC CLEANER v' + VERSION + '                       ')}${chalk.cyan('|')}
 ${chalk.cyan('|')}${chalk.gray('                  ' + date + ' ' + figures.bullet + ' ' + time + '                   ')}${chalk.cyan('|')}
 ${chalk.cyan('+')}${chalk.cyan('-'.repeat(68))}${chalk.cyan('+')}
 `;
@@ -1071,28 +1348,113 @@ async function privacySweep() {
   }
 
   console.log();
-  console.log(chalk.dim(`  ${MSG.SELECT_DELETE} [a=${MSG.ALL}/n=${MSG.CANCEL}]:`));
-  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
 
-  if (choice.toLowerCase() === 'n' || choice === '') {
+  // Build checkbox choices for inquirer
+  const itemChoices = items.map((item, i) => ({
+    name: `${item.name.padEnd(30)} ${chalk.dim(formatSize(item.size))}`,
+    value: item.fullPath,
+    short: item.name
+  }));
+
+  // Fallback for text-based selection
+  const fallbackSelect = async () => {
+    console.log(chalk.dim(`  ${MSG.SELECT_DELETE} [a=${MSG.ALL}/numbers/n=${MSG.CANCEL}]:`));
+    const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+    if (choice.toLowerCase() === 'n' || choice === '') return [];
+
+    if (choice.toLowerCase() === 'a') {
+      return items.map(item => item.fullPath);
+    }
+
+    const selected = [];
+    const parts = choice.split(',');
+    parts.forEach(part => {
+      const idx = parseInt(part.trim()) - 1;
+      if (idx >= 0 && idx < items.length) selected.push(items[idx].fullPath);
+    });
+    return selected;
+  };
+
+  const selectedPaths = await selectMultiple(
+    `${MSG.SELECT_DELETE} ${chalk.dim('(space to select, enter to confirm)')}`,
+    itemChoices,
+    fallbackSelect
+  );
+
+  if (selectedPaths.length === 0) {
+    await pressEnter();
+    return;
+  }
+
+  // Mark selected items
+  items.forEach(item => {
+    item.selected = selectedPaths.includes(item.fullPath);
+  });
+
+  const selectedItems = items.filter(i => i.selected);
+  if (selectedItems.length === 0) {
     await pressEnter();
     return;
   }
 
+  // Ask confirmation mode
+  const confirmMode = await askConfirmationMode();
+  const isDryRun = confirmMode === 'dryrun' || DRY_RUN;
+  let autoMode = confirmMode === 'auto';
+
   let cleaned = 0;
+  let deletedCount = 0;
+  let skippedCount = 0;
 
-  if (choice.toLowerCase() === 'a') {
+  if (autoMode && !isDryRun) {
     const spinner = ora(MSG.CLEANING).start();
 
     for (const item of items) {
+      if (!item.selected) continue;
       if (deleteItem(item.fullPath)) {
         cleaned += item.size;
+        deletedCount++;
       }
     }
 
     spinner.succeed(chalk.green(`${MSG.PRIVACY_CLEANED}: ${formatSize(cleaned)}`));
+  } else {
+    for (const item of items) {
+      if (!item.selected) continue;
+
+      let shouldDelete = autoMode;
+
+      if (!autoMode && confirmMode === 'manual') {
+        const answer = await confirmItem(item.fullPath, item.size);
+        if (answer === 'all') {
+          autoMode = true;
+          shouldDelete = true;
+        } else if (answer === 'yes') {
+          shouldDelete = true;
+        } else {
+          shouldDelete = false;
+        }
+      }
+
+      if (isDryRun) {
+        console.log(`  ${chalk.blue(figures.info)} [DRY-RUN] ${item.name} ${chalk.dim('(' + formatSize(item.size) + ')')}`);
+        cleaned += item.size;
+        deletedCount++;
+      } else if (shouldDelete) {
+        if (deleteItem(item.fullPath)) {
+          console.log(`  ${chalk.green(figures.tick)} ${item.name}`);
+          cleaned += item.size;
+          deletedCount++;
+        }
+      } else {
+        skippedCount++;
+        console.log(`  ${chalk.yellow(figures.cross)} ${MSG.SUMMARY_SKIPPED}: ${item.name}`);
+      }
+    }
   }
 
+  showCleanupSummary(deletedCount, skippedCount, cleaned, confirmMode);
   await pressEnter();
 }
 
@@ -1114,9 +1476,14 @@ async function memoryOptimizer() {
   console.log(chalk.dim('  You may need to enter your password.'));
   console.log();
 
-  const confirm = await prompt(`  ${chalk.white('Continue? [y/n]:')} `);
+  const fallbackConfirm = async () => {
+    const answer = await prompt(`  ${chalk.white('Continue? [y/n]:')} `);
+    return answer.toLowerCase() === 'y';
+  };
+
+  const confirmed = await confirmAction('Continue with memory optimization?', false, fallbackConfirm);
 
-  if (confirm.toLowerCase() !== 'y') {
+  if (!confirmed) {
     await pressEnter();
     return;
   }
@@ -1238,6 +1605,227 @@ async function benchmarkMode() {
   await pressEnter();
 }
 
+// ============================================================================
+// THERMAL MONITOR
+// ============================================================================
+
+function getThermalStatus() {
+  const output = exec('pmset -g therm 2>/dev/null');
+
+  // Parse thermal status from pmset output
+  let status = 'cool';
+  let level = 10;
+  let emoji = '\u2744\uFE0F';  // snowflake
+  let color = chalk.cyan;
+  let tip = MSG.THERMAL_TIP_COOL;
+
+  const lowerOutput = output.toLowerCase();
+
+  if (lowerOutput.includes('trapping') || lowerOutput.includes('sleeping')) {
+    status = 'critical';
+    level = 90;
+    emoji = '\uD83D\uDEA8';  // rotating light
+    color = chalk.red;
+    tip = MSG.THERMAL_TIP_CRITICAL;
+  } else if (lowerOutput.includes('heavy')) {
+    status = 'hot';
+    level = 70;
+    emoji = '\uD83D\uDD25';  // fire
+    color = chalk.red;
+    tip = MSG.THERMAL_TIP_HOT;
+  } else if (lowerOutput.includes('moderate')) {
+    status = 'warm';
+    level = 50;
+    emoji = '\uD83C\uDF24\uFE0F';  // sun behind small cloud
+    color = chalk.yellow;
+    tip = MSG.THERMAL_TIP_WARM;
+  } else if (lowerOutput.includes('nominal')) {
+    status = 'good';
+    level = 30;
+    emoji = '\u2705';  // check mark
+    color = chalk.green;
+    tip = MSG.THERMAL_TIP_GOOD;
+  }
+  // Default is cool (no thermal warnings)
+
+  const statusText = {
+    cool: MSG.THERMAL_COOL,
+    good: MSG.THERMAL_GOOD,
+    warm: MSG.THERMAL_WARM,
+    hot: MSG.THERMAL_HOT,
+    critical: MSG.THERMAL_CRITICAL
+  }[status];
+
+  return { status, level, emoji, color, statusText, tip, rawOutput: output };
+}
+
+function drawThermalBox(thermal) {
+  const boxWidth = 43;
+  const barWidth = 20;
+
+  // Draw progress bar
+  const filledBars = Math.round((thermal.level / 100) * barWidth);
+  const emptyBars = barWidth - filledBars;
+  const progressBar = '\u2588'.repeat(filledBars) + '\u2591'.repeat(emptyBars);
+
+  // Color the progress bar based on level
+  let barColor = chalk.cyan;
+  if (thermal.level >= 80) barColor = chalk.red;
+  else if (thermal.level >= 60) barColor = chalk.red;
+  else if (thermal.level >= 40) barColor = chalk.yellow;
+  else if (thermal.level >= 20) barColor = chalk.green;
+
+  const lines = [
+    chalk.cyan('\u256D' + '\u2500'.repeat(boxWidth) + '\u256E'),
+    chalk.cyan('\u2502') + '  \uD83C\uDF21\uFE0F  ' + chalk.white.bold(MSG.THERMAL_STATUS) + ' '.repeat(boxWidth - 21) + chalk.cyan('\u2502'),
+    chalk.cyan('\u251C' + '\u2500'.repeat(boxWidth) + '\u2524'),
+    chalk.cyan('\u2502') + '  Status:    ' + thermal.emoji + ' ' + thermal.color(thermal.statusText) + ' '.repeat(boxWidth - 17 - thermal.statusText.length) + chalk.cyan('\u2502'),
+    chalk.cyan('\u2502') + '  ' + MSG.THERMAL_LEVEL + ':     ' + barColor(progressBar) + ' ' + thermal.level + '%' + ' '.repeat(boxWidth - 12 - barWidth - String(thermal.level).length - MSG.THERMAL_LEVEL.length) + chalk.cyan('\u2502'),
+    chalk.cyan('\u2502') + ' '.repeat(boxWidth) + chalk.cyan('\u2502'),
+    chalk.cyan('\u2502') + '  \uD83D\uDCA1 ' + MSG.THERMAL_TIP + ': ' + chalk.dim(thermal.tip.slice(0, boxWidth - 12)) + ' '.repeat(Math.max(0, boxWidth - 10 - MSG.THERMAL_TIP.length - thermal.tip.slice(0, boxWidth - 12).length)) + chalk.cyan('\u2502')
+  ];
+
+  // Handle long tips with word wrap
+  if (thermal.tip.length > boxWidth - 12) {
+    const secondLine = thermal.tip.slice(boxWidth - 12);
+    lines.push(chalk.cyan('\u2502') + '     ' + chalk.dim(secondLine) + ' '.repeat(Math.max(0, boxWidth - 5 - secondLine.length)) + chalk.cyan('\u2502'));
+  }
+
+  lines.push(chalk.cyan('\u2570' + '\u2500'.repeat(boxWidth) + '\u256F'));
+
+  return lines.join('\n');
+}
+
+function parsePowerMetrics(output) {
+  const result = {
+    cpuPower: null,
+    gpuPower: null,
+    anePower: null,
+    cpuFreq: null
+  };
+
+  // Parse CPU Power
+  const cpuMatch = output.match(/CPU Power:\s*([\d.]+)\s*mW/i);
+  if (cpuMatch) {
+    result.cpuPower = parseFloat(cpuMatch[1]) / 1000; // Convert to Watts
+  }
+
+  // Parse GPU Power
+  const gpuMatch = output.match(/GPU Power:\s*([\d.]+)\s*mW/i);
+  if (gpuMatch) {
+    result.gpuPower = parseFloat(gpuMatch[1]) / 1000;
+  }
+
+  // Parse ANE Power
+  const aneMatch = output.match(/ANE Power:\s*([\d.]+)\s*mW/i);
+  if (aneMatch) {
+    result.anePower = parseFloat(aneMatch[1]) / 1000;
+  }
+
+  // Parse CPU frequency
+  const freqMatch = output.match(/CPU Average frequency as fraction of nominal:\s*([\d.]+)%/i);
+  if (freqMatch) {
+    result.cpuFreq = parseFloat(freqMatch[1]);
+  }
+
+  return result;
+}
+
+function getPowerLabel(watts) {
+  if (watts === null) return { label: 'N/A', color: chalk.gray };
+  if (watts < 2) return { label: MSG.THERMAL_LOW, color: chalk.green };
+  if (watts < 5) return { label: MSG.THERMAL_MEDIUM, color: chalk.yellow };
+  if (watts < 10) return { label: MSG.THERMAL_HIGH, color: chalk.red };
+  return { label: MSG.THERMAL_VERY_HIGH, color: chalk.red };
+}
+
+async function thermalMonitor() {
+  header();
+  sectionHeader(MSG.OPT_THERMAL);
+
+  const spinner = ora(MSG.SCANNING).start();
+
+  // Get thermal status
+  const thermal = getThermalStatus();
+
+  spinner.stop();
+
+  // Display thermal status box
+  console.log(drawThermalBox(thermal));
+  console.log();
+
+  // Show raw output if verbose
+  if (thermal.rawOutput) {
+    console.log(chalk.dim('  Raw pmset output:'));
+    thermal.rawOutput.split('\n').forEach(line => {
+      if (line.trim()) {
+        console.log(chalk.dim('    ' + line));
+      }
+    });
+    console.log();
+  }
+
+  // Ask about detailed power info
+  console.log(chalk.yellow(`  ${figures.info} ${MSG.THERMAL_DETAILED}`));
+
+  const fallbackThermal = async () => {
+    const answer = await prompt(`  ${chalk.white('[y/n]:')} `);
+    return answer.toLowerCase() === 'y';
+  };
+
+  const wantDetails = await confirmAction('View detailed power metrics?', false, fallbackThermal);
+
+  if (wantDetails) {
+    console.log();
+    const detailSpinner = ora('Reading power metrics...').start();
+
+    try {
+      const powerOutput = execSync('sudo powermetrics --samplers cpu_power -i1 -n1 2>/dev/null', {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      detailSpinner.stop();
+
+      const power = parsePowerMetrics(powerOutput);
+
+      console.log();
+      console.log(chalk.white('  ' + MSG.THERMAL_POWER + ' Consumption:'));
+      console.log();
+
+      if (power.cpuPower !== null) {
+        const cpuLabel = getPowerLabel(power.cpuPower);
+        console.log(`    ${figures.bullet} ${MSG.THERMAL_CPU_POWER}: ${chalk.cyan(power.cpuPower.toFixed(2) + ' W')} ${cpuLabel.color('(' + cpuLabel.label + ')')}`);
+      }
+
+      if (power.gpuPower !== null) {
+        const gpuLabel = getPowerLabel(power.gpuPower);
+        console.log(`    ${figures.bullet} ${MSG.THERMAL_GPU_POWER}: ${chalk.cyan(power.gpuPower.toFixed(2) + ' W')} ${gpuLabel.color('(' + gpuLabel.label + ')')}`);
+      }
+
+      if (power.anePower !== null) {
+        const aneLabel = getPowerLabel(power.anePower);
+        console.log(`    ${figures.bullet} ${MSG.THERMAL_ANE_POWER}: ${chalk.cyan(power.anePower.toFixed(2) + ' W')} ${aneLabel.color('(' + aneLabel.label + ')')}`);
+      }
+
+      if (power.cpuFreq !== null) {
+        console.log();
+        console.log(`    ${figures.bullet} ${MSG.THERMAL_FREQ}: ${chalk.cyan(power.cpuFreq.toFixed(1) + '%')} of nominal`);
+      }
+
+    } catch (e) {
+      detailSpinner.fail(chalk.red('Failed to read power metrics (sudo may have been denied)'));
+    }
+  }
+
+  console.log();
+  console.log(chalk.cyan('  ' + figures.star + ' ' + MSG.THERMAL_STATS_APP));
+  console.log(chalk.white('    brew install --cask stats'));
+  console.log();
+
+  await pressEnter();
+}
+
 // ============================================================================
 // SCHEDULER (LAUNCHD)
 // ============================================================================
@@ -1252,26 +1840,53 @@ async function scheduler() {
   console.log(chalk.white('  Cleanup Scheduler'));
   console.log();
 
+  let schedulerChoices;
   if (isScheduled) {
     console.log(chalk.green(`  ${figures.tick} Scheduled cleanup is ACTIVE`));
     console.log();
-    console.log(`  ${chalk.cyan('[1]')} Remove schedule`);
-    console.log(`  ${chalk.cyan('[2]')} View current schedule`);
+    schedulerChoices = [
+      { name: 'Remove schedule', value: 'remove' },
+      { name: 'View current schedule', value: 'view' },
+      { name: chalk.yellow(MSG.BACK), value: 'back' }
+    ];
   } else {
     console.log(chalk.yellow(`  ${figures.info} No scheduled cleanup configured`));
     console.log();
-    console.log(`  ${chalk.cyan('[1]')} Schedule daily cleanup (midnight)`);
-    console.log(`  ${chalk.cyan('[2]')} Schedule weekly cleanup (Sunday midnight)`);
+    schedulerChoices = [
+      { name: 'Schedule daily cleanup (midnight)', value: 'daily' },
+      { name: 'Schedule weekly cleanup (Sunday midnight)', value: 'weekly' },
+      { name: chalk.yellow(MSG.BACK), value: 'back' }
+    ];
   }
 
-  console.log();
-  console.log(`  ${chalk.cyan('[0]')} ${MSG.BACK}`);
-  console.log();
+  const fallbackScheduler = async () => {
+    if (isScheduled) {
+      console.log(`  ${chalk.cyan('[1]')} Remove schedule`);
+      console.log(`  ${chalk.cyan('[2]')} View current schedule`);
+    } else {
+      console.log(`  ${chalk.cyan('[1]')} Schedule daily cleanup (midnight)`);
+      console.log(`  ${chalk.cyan('[2]')} Schedule weekly cleanup (Sunday midnight)`);
+    }
+    console.log();
+    console.log(`  ${chalk.cyan('[0]')} ${MSG.BACK}`);
+    console.log();
+    const c = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+    if (c === '0') return 'back';
+    if (isScheduled) {
+      return c === '1' ? 'remove' : c === '2' ? 'view' : 'back';
+    } else {
+      return c === '1' ? 'daily' : c === '2' ? 'weekly' : 'back';
+    }
+  };
 
-  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+  const choice = await selectOption(MSG.OPT_SCHEDULER, schedulerChoices, fallbackScheduler);
+
+  if (choice === 'back' || !choice) {
+    return;
+  }
 
   if (isScheduled) {
-    if (choice === '1') {
+    if (choice === 'remove') {
       // Remove schedule
       try {
         exec(`launchctl unload "${plistPath}" 2>/dev/null`);
@@ -1280,15 +1895,15 @@ async function scheduler() {
       } catch (e) {
         console.log(chalk.red(`  ${figures.cross} Failed to remove schedule`));
       }
-    } else if (choice === '2') {
+    } else if (choice === 'view') {
       // View schedule
       const content = fs.readFileSync(plistPath, 'utf8');
       console.log();
       console.log(chalk.dim(content));
     }
   } else {
-    if (choice === '1' || choice === '2') {
-      const isDaily = choice === '1';
+    if (choice === 'daily' || choice === 'weekly') {
+      const isDaily = choice === 'daily';
 
       const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -1514,8 +2129,13 @@ async function exportHtmlReport() {
   console.log(chalk.dim(`  ${reportPath}`));
   console.log();
 
-  const open = await prompt(`  Open in browser? [y/n]: `);
-  if (open.toLowerCase() === 'y') {
+  const fallbackOpen = async () => {
+    const answer = await prompt(`  Open in browser? [y/n]: `);
+    return answer.toLowerCase() === 'y';
+  };
+
+  const shouldOpen = await confirmAction('Open report in browser?', false, fallbackOpen);
+  if (shouldOpen) {
     exec(`open "${reportPath}"`);
   }
 
@@ -1727,118 +2347,711 @@ async function quickClean() {
   console.log(`  ${figures.arrowRight} ${chalk.white(MSG.TOTAL + ':')} ${chalk.green(formatSize(totalSize))}`);
   console.log();
 
-  // Selection
-  sectionHeader(MSG.SELECT_DELETE);
-  console.log(chalk.dim(`  a = ${MSG.ALL} | n = ${MSG.CANCEL} | 1,3,5 | 1-5 | 1-5,8,10`));
-  console.log();
+  // Selection - build checkbox choices
+  const itemChoices = items.map((item, i) => ({
+    name: `${item.name.padEnd(35)} ${chalk.dim(String(item.size).padStart(6) + ' MB')}`,
+    value: item.path,
+    checked: true,
+    short: item.name
+  }));
+
+  // Fallback for text-based selection
+  const fallbackQuickSelect = async () => {
+    sectionHeader(MSG.SELECT_DELETE);
+    console.log(chalk.dim(`  a = ${MSG.ALL} | n = ${MSG.CANCEL} | 1,3,5 | 1-5 | 1-5,8,10`));
+    console.log();
 
-  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+    const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
 
-  if (choice.toLowerCase() === 'n' || choice === '') {
-    console.log(`  ${chalk.yellow(MSG.CANCEL)}`);
-    await pressEnter();
-    return;
-  }
+    if (choice.toLowerCase() === 'n' || choice === '') {
+      return [];
+    }
 
-  // Process selection
-  if (choice.toLowerCase() !== 'a') {
-    items.forEach(item => item.selected = false);
+    if (choice.toLowerCase() === 'a') {
+      return items.map(item => item.path);
+    }
 
+    const selected = [];
     const parts = choice.split(',');
     parts.forEach(part => {
       part = part.trim();
       if (part.includes('-')) {
         const [start, end] = part.split('-').map(n => parseInt(n));
         for (let j = start; j <= end; j++) {
-          if (j > 0 && j <= items.length) items[j - 1].selected = true;
+          if (j > 0 && j <= items.length) selected.push(items[j - 1].path);
         }
       } else {
         const idx = parseInt(part) - 1;
-        if (idx >= 0 && idx < items.length) items[idx].selected = true;
+        if (idx >= 0 && idx < items.length) selected.push(items[idx].path);
       }
     });
+    return selected;
+  };
+
+  const selectedPaths = await selectMultiple(
+    `${MSG.SELECT_DELETE} ${chalk.dim('(space to toggle, enter to confirm)')}`,
+    itemChoices,
+    fallbackQuickSelect
+  );
+
+  if (selectedPaths.length === 0) {
+    console.log(`  ${chalk.yellow(MSG.CANCEL)}`);
+    await pressEnter();
+    return;
   }
 
+  // Mark selected items
+  items.forEach(item => {
+    item.selected = selectedPaths.includes(item.path);
+  });
+
   // Create backup
   const selectedItems = items.filter(i => i.selected);
-  if (selectedItems.length > 0 && !DRY_RUN) {
+  if (selectedItems.length === 0) {
+    console.log(`  ${chalk.yellow(MSG.CANCEL)}`);
+    await pressEnter();
+    return;
+  }
+
+  // Ask confirmation mode
+  const confirmMode = await askConfirmationMode();
+
+  if (confirmMode !== 'dryrun' && !DRY_RUN) {
     const backupFile = createBackup(selectedItems);
     console.log(chalk.dim(`  ${figures.info} ${MSG.BACKUP_CREATED}: ${path.basename(backupFile)}`));
     console.log();
   }
 
-  // Clean with progress bar
+  // Clean with confirmation mode support
   console.log();
   sectionHeader(MSG.CLEANING);
 
-  const progressBar = createProgressBar(selectedItems.length);
-  progressBar.start(selectedItems.length, 0);
-
   let cleanedSize = 0;
+  let deletedCount = 0;
+  let skippedCount = 0;
+  let autoMode = confirmMode === 'auto';
+  const isDryRun = confirmMode === 'dryrun' || DRY_RUN;
   const claudeVersionsPathLocal = path.join(HOME, '.local/share/claude/versions');
 
-  for (let i = 0; i < items.length; i++) {
-    const item = items[i];
-    if (!item.selected) continue;
+  if (autoMode && !isDryRun) {
+    const progressBar = createProgressBar(selectedItems.length);
+    progressBar.start(selectedItems.length, 0);
 
-    if (item.path === 'CLAUDE_VERSIONS') {
-      if (!DRY_RUN) {
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      if (!item.selected) continue;
+
+      if (item.path === 'CLAUDE_VERSIONS') {
         const versions = fs.readdirSync(claudeVersionsPathLocal).sort().reverse();
         versions.slice(1).forEach(v => {
           try {
             deleteItem(path.join(claudeVersionsPathLocal, v));
           } catch (e) {}
         });
-      }
-      cleanedSize += item.size;
-    } else if (item.path === 'OLD_DOWNLOADS') {
-      if (!DRY_RUN) {
+        cleanedSize += item.size;
+        deletedCount++;
+      } else if (item.path === 'OLD_DOWNLOADS') {
         exec('find ~/Downloads -name "*.dmg" -mtime +7 -delete 2>/dev/null');
         exec('find ~/Downloads -name "*.zip" -mtime +30 -delete 2>/dev/null');
-      }
-      cleanedSize += item.size;
-    } else if (fs.existsSync(item.path)) {
-      if (deleteItem(item.path)) {
         cleanedSize += item.size;
+        deletedCount++;
+      } else if (fs.existsSync(item.path)) {
+        if (deleteItem(item.path)) {
+          cleanedSize += item.size;
+          deletedCount++;
+        }
       }
+
+      progressBar.increment();
     }
 
-    progressBar.increment();
-  }
+    progressBar.stop();
+  } else {
+    // Manual or dry-run mode
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      if (!item.selected) continue;
+
+      let shouldDelete = autoMode;
+
+      if (!autoMode && confirmMode === 'manual') {
+        const displayPath = item.path === 'CLAUDE_VERSIONS' ? claudeVersionsPathLocal :
+                           item.path === 'OLD_DOWNLOADS' ? '~/Downloads (old files)' : item.path;
+        const answer = await confirmItem(displayPath, item.size);
+
+        if (answer === 'all') {
+          autoMode = true;
+          shouldDelete = true;
+        } else if (answer === 'yes') {
+          shouldDelete = true;
+        } else {
+          shouldDelete = false;
+        }
+      }
 
-  progressBar.stop();
+      if (isDryRun) {
+        console.log(`  ${chalk.blue(figures.info)} [DRY-RUN] ${item.name} ${chalk.dim('(' + formatSize(item.size) + ')')}`);
+        cleanedSize += item.size;
+        deletedCount++;
+      } else if (shouldDelete) {
+        if (item.path === 'CLAUDE_VERSIONS') {
+          const versions = fs.readdirSync(claudeVersionsPathLocal).sort().reverse();
+          versions.slice(1).forEach(v => {
+            try {
+              deleteItem(path.join(claudeVersionsPathLocal, v));
+            } catch (e) {}
+          });
+          cleanedSize += item.size;
+          deletedCount++;
+          console.log(`  ${chalk.green(figures.tick)} ${item.name}`);
+        } else if (item.path === 'OLD_DOWNLOADS') {
+          exec('find ~/Downloads -name "*.dmg" -mtime +7 -delete 2>/dev/null');
+          exec('find ~/Downloads -name "*.zip" -mtime +30 -delete 2>/dev/null');
+          cleanedSize += item.size;
+          deletedCount++;
+          console.log(`  ${chalk.green(figures.tick)} ${item.name}`);
+        } else if (fs.existsSync(item.path)) {
+          if (deleteItem(item.path)) {
+            cleanedSize += item.size;
+            deletedCount++;
+            console.log(`  ${chalk.green(figures.tick)} ${item.name}`);
+          }
+        }
+      } else {
+        skippedCount++;
+        console.log(`  ${chalk.yellow(figures.cross)} ${MSG.SUMMARY_SKIPPED}: ${item.name}`);
+      }
+    }
+  }
 
   // npm cache
-  if (!DRY_RUN) {
+  if (!isDryRun) {
     try {
       execSync('npm cache clean --force 2>/dev/null', { stdio: 'ignore' });
     } catch (e) {}
   }
 
-  console.log();
-
-  // Show cleaned items
-  selectedItems.forEach(item => {
-    console.log(`  ${chalk.green(figures.tick)} ${item.name}`);
-  });
+  // Show summary
+  if (autoMode && !isDryRun) {
+    console.log();
+    selectedItems.forEach(item => {
+      console.log(`  ${chalk.green(figures.tick)} ${item.name}`);
+    });
+  }
 
-  console.log();
+  showCleanupSummary(deletedCount, skippedCount, cleanedSize, confirmMode);
   getSystemStats();
   showFinalReport(cleanedSize);
   await pressEnter();
 }
 
 // ============================================================================
-// FIND LARGE FILES
+// DEEP CLEAN (AGGRESSIVE)
 // ============================================================================
 
-async function findLargeFiles() {
+async function deepClean() {
   header();
-  sectionHeader(`${MSG.LARGE_FILES} (>100MB)`);
+  sectionHeader(`${MSG.DEEP_CLEAN} ${chalk.red('\uD83D\uDD25')}`);
 
-  const spinner = ora(MSG.SCANNING).start();
+  // Warning message
+  console.log(chalk.red.bold(`  ${figures.warning} ${MSG.DEEP_CLEAN_WARNING}`));
+  console.log();
+  console.log(chalk.yellow(`  ${MSG.DEEP_CLEAN_TIME}`));
+  console.log();
 
-  const files = [];
+  const fallbackDeepConfirm = async () => {
+    const answer = await prompt(`  ${chalk.white(MSG.DEEP_CLEAN_CONFIRM + ' [y/n]:')} `);
+    return answer.toLowerCase() === 'y';
+  };
+
+  const confirmDeep = await confirmAction(MSG.DEEP_CLEAN_CONFIRM, false, fallbackDeepConfirm);
+  if (!confirmDeep) {
+    console.log(`  ${chalk.yellow(MSG.CANCEL)}`);
+    await pressEnter();
+    return;
+  }
+
+  // Ask confirmation mode
+  const confirmMode = await askConfirmationMode();
+  const isDryRun = confirmMode === 'dryrun' || DRY_RUN;
+  let autoMode = confirmMode === 'auto';
+
+  console.log();
+  const startTime = Date.now();
+
+  let totalCleaned = 0;
+  let deletedCount = 0;
+  let skippedCount = 0;
+  const results = [];
+
+  // Helper function to process item with confirmation
+  async function processItemWithConfirm(itemPath, itemSize, categoryName) {
+    if (isDryRun) {
+      console.log(`  ${chalk.blue(figures.info)} [DRY-RUN] ${itemPath.replace(HOME, '~')} ${chalk.dim('(' + formatSize(itemSize) + ')')}`);
+      return { cleaned: itemSize, deleted: true };
+    }
+
+    if (autoMode) {
+      if (deleteItem(itemPath)) {
+        return { cleaned: itemSize, deleted: true };
+      }
+      return { cleaned: 0, deleted: false };
+    }
+
+    // Manual mode
+    const answer = await confirmItem(itemPath, itemSize);
+    if (answer === 'all') {
+      autoMode = true;
+      if (deleteItem(itemPath)) {
+        console.log(`  ${chalk.green(figures.tick)} ${categoryName}: ${itemPath.replace(HOME, '~')}`);
+        return { cleaned: itemSize, deleted: true };
+      }
+    } else if (answer === 'yes') {
+      if (deleteItem(itemPath)) {
+        console.log(`  ${chalk.green(figures.tick)} ${categoryName}: ${itemPath.replace(HOME, '~')}`);
+        return { cleaned: itemSize, deleted: true };
+      }
+    } else {
+      console.log(`  ${chalk.yellow(figures.cross)} ${MSG.SUMMARY_SKIPPED}: ${itemPath.replace(HOME, '~')}`);
+      return { cleaned: 0, deleted: false, skipped: true };
+    }
+    return { cleaned: 0, deleted: false };
+  }
+
+  // Helper to clean a category
+  async function cleanCategory(categoryName, paths, description) {
+    let categorySize = 0;
+    let catDeleted = 0;
+    let catSkipped = 0;
+
+    if (autoMode && !isDryRun) {
+      const spinner = ora(`${description}...`).start();
+
+      for (const p of paths) {
+        const fullPath = p.replace(/^~/, HOME);
+        if (isExcluded(fullPath)) continue;
+
+        const size = getSize(p);
+        if (size > 0) {
+          if (deleteItem(fullPath)) {
+            categorySize += size;
+            catDeleted++;
+          }
+        }
+      }
+
+      if (categorySize > 0) {
+        spinner.succeed(`${description}: ${chalk.green(formatSize(categorySize))}`);
+      } else {
+        spinner.succeed(`${description}: ${chalk.dim('0 MB')}`);
+      }
+    } else {
+      console.log(chalk.white(`  ${description}:`));
+
+      for (const p of paths) {
+        const fullPath = p.replace(/^~/, HOME);
+        if (isExcluded(fullPath)) continue;
+
+        const size = getSize(p);
+        if (size > 0) {
+          const result = await processItemWithConfirm(fullPath, size, categoryName);
+          categorySize += result.cleaned;
+          if (result.deleted) catDeleted++;
+          if (result.skipped) catSkipped++;
+        }
+      }
+    }
+
+    if (categorySize > 0) {
+      results.push({ category: categoryName, size: categorySize });
+      totalCleaned += categorySize;
+    }
+    deletedCount += catDeleted;
+    skippedCount += catSkipped;
+
+    return categorySize;
+  }
+
+  // 1. System Caches
+  await cleanCategory(MSG.CAT_SYSTEM_CACHES, [
+    '~/Library/Caches/com.apple.Safari',
+    '~/Library/Caches/com.apple.dt.Xcode',
+    '~/Library/Logs',
+    '/Library/Logs',
+    '/private/var/log'
+  ], MSG.CAT_SYSTEM_CACHES);
+
+  // 2. ALL Application Caches
+  let appCacheSize = 0;
+  const cachesDir = path.join(HOME, 'Library/Caches');
+  if (fs.existsSync(cachesDir)) {
+    if (autoMode && !isDryRun) {
+      const spinner2 = ora(`${MSG.CAT_APP_CACHES}...`).start();
+      try {
+        const cacheItems = fs.readdirSync(cachesDir);
+        for (const item of cacheItems) {
+          const itemPath = path.join(cachesDir, item);
+          if (isExcluded(itemPath)) continue;
+          const size = getSize(itemPath);
+          if (size > 0 && deleteItem(itemPath)) {
+            appCacheSize += size;
+            deletedCount++;
+          }
+        }
+      } catch (e) {}
+      if (appCacheSize > 0) {
+        spinner2.succeed(`${MSG.CAT_APP_CACHES}: ${chalk.green(formatSize(appCacheSize))}`);
+      } else {
+        spinner2.succeed(`${MSG.CAT_APP_CACHES}: ${chalk.dim('0 MB')}`);
+      }
+    } else {
+      console.log(chalk.white(`  ${MSG.CAT_APP_CACHES}:`));
+      try {
+        const cacheItems = fs.readdirSync(cachesDir);
+        for (const item of cacheItems) {
+          const itemPath = path.join(cachesDir, item);
+          if (isExcluded(itemPath)) continue;
+          const size = getSize(itemPath);
+          if (size > 0) {
+            const result = await processItemWithConfirm(itemPath, size, MSG.CAT_APP_CACHES);
+            appCacheSize += result.cleaned;
+            if (result.deleted) deletedCount++;
+            if (result.skipped) skippedCount++;
+          }
+        }
+      } catch (e) {}
+    }
+  }
+  if (appCacheSize > 0) {
+    results.push({ category: MSG.CAT_APP_CACHES, size: appCacheSize });
+    totalCleaned += appCacheSize;
+  }
+
+  // 3. Xcode
+  await cleanCategory(MSG.CAT_XCODE, [
+    '~/Library/Developer/Xcode/DerivedData',
+    '~/Library/Developer/Xcode/Archives',
+    '~/Library/Developer/Xcode/iOS DeviceSupport',
+    '~/Library/Developer/Xcode/watchOS DeviceSupport',
+    '~/Library/Developer/Xcode/tvOS DeviceSupport',
+    '~/Library/Developer/CoreSimulator/Caches',
+    '~/Library/Developer/CoreSimulator/Devices'
+  ], MSG.CAT_XCODE);
+
+  // 4. Dev Caches
+  await cleanCategory(MSG.CAT_DEV_CACHES, [
+    '~/.npm',
+    '~/.yarn/cache',
+    '~/.cache/yarn',
+    '~/Library/Caches/pip',
+    '~/.pip/cache',
+    '~/Library/Caches/Homebrew',
+    '~/Library/Caches/CocoaPods',
+    '~/.cocoapods/repos',
+    '~/.gradle/caches',
+    '~/.gradle/wrapper',
+    '~/Library/Caches/typescript',
+    '~/Library/Caches/node-gyp',
+    '~/.cache/pip',
+    '~/Library/Caches/pnpm',
+    '~/.pnpm-store',
+    '~/.cargo/registry/cache',
+    '~/.rustup/tmp',
+    '~/go/pkg/mod/cache'
+  ], MSG.CAT_DEV_CACHES);
+
+  // 5. Docker
+  let dockerSize = 0;
+  if (exec('which docker')) {
+    if (isDryRun) {
+      console.log(chalk.blue(`  ${figures.info} [DRY-RUN] docker system prune -af --volumes`));
+      dockerSize = 500;
+      deletedCount++;
+    } else if (autoMode) {
+      const spinner5 = ora(`${MSG.CAT_DOCKER}...`).start();
+      try {
+        exec('docker system prune -af --volumes 2>/dev/null');
+        dockerSize = 500;
+        deletedCount++;
+      } catch (e) {}
+      spinner5.succeed(`${MSG.CAT_DOCKER}: ${dockerSize > 0 ? chalk.green(formatSize(dockerSize)) : chalk.dim('0 MB')}`);
+    } else {
+      const answer = await confirmItem('Docker (images, containers, volumes)', 500);
+      if (answer === 'all') {
+        autoMode = true;
+        exec('docker system prune -af --volumes 2>/dev/null');
+        dockerSize = 500;
+        deletedCount++;
+        console.log(`  ${chalk.green(figures.tick)} ${MSG.CAT_DOCKER}`);
+      } else if (answer === 'yes') {
+        exec('docker system prune -af --volumes 2>/dev/null');
+        dockerSize = 500;
+        deletedCount++;
+        console.log(`  ${chalk.green(figures.tick)} ${MSG.CAT_DOCKER}`);
+      } else {
+        skippedCount++;
+        console.log(`  ${chalk.yellow(figures.cross)} ${MSG.SUMMARY_SKIPPED}: ${MSG.CAT_DOCKER}`);
+      }
+    }
+  }
+  if (dockerSize > 0) {
+    results.push({ category: MSG.CAT_DOCKER, size: dockerSize });
+    totalCleaned += dockerSize;
+  }
+
+  // 6. iOS Backups older than 30 days
+  let iosBackupSize = 0;
+  const backupsDir = path.join(HOME, 'Library/Application Support/MobileSync/Backup');
+  if (fs.existsSync(backupsDir)) {
+    if (autoMode && !isDryRun) {
+      const spinner6 = ora(`${MSG.CAT_IOS_BACKUPS}...`).start();
+      try {
+        const backups = fs.readdirSync(backupsDir);
+        const thirtyDaysAgo = Date.now() - (30 * 24 * 60 * 60 * 1000);
+        for (const backup of backups) {
+          const backupPath = path.join(backupsDir, backup);
+          const stats = fs.statSync(backupPath);
+          if (stats.mtime.getTime() < thirtyDaysAgo) {
+            const size = getSize(backupPath);
+            if (size > 0 && deleteItem(backupPath)) {
+              iosBackupSize += size;
+              deletedCount++;
+            }
+          }
+        }
+      } catch (e) {}
+      if (iosBackupSize > 0) {
+        spinner6.succeed(`${MSG.CAT_IOS_BACKUPS}: ${chalk.green(formatSize(iosBackupSize))}`);
+      } else {
+        spinner6.succeed(`${MSG.CAT_IOS_BACKUPS}: ${chalk.dim('0 MB')}`);
+      }
+    } else {
+      console.log(chalk.white(`  ${MSG.CAT_IOS_BACKUPS}:`));
+      try {
+        const backups = fs.readdirSync(backupsDir);
+        const thirtyDaysAgo = Date.now() - (30 * 24 * 60 * 60 * 1000);
+        for (const backup of backups) {
+          const backupPath = path.join(backupsDir, backup);
+          const stats = fs.statSync(backupPath);
+          if (stats.mtime.getTime() < thirtyDaysAgo) {
+            const size = getSize(backupPath);
+            if (size > 0) {
+              const result = await processItemWithConfirm(backupPath, size, MSG.CAT_IOS_BACKUPS);
+              iosBackupSize += result.cleaned;
+              if (result.deleted) deletedCount++;
+              if (result.skipped) skippedCount++;
+            }
+          }
+        }
+      } catch (e) {}
+    }
+  }
+  if (iosBackupSize > 0) {
+    results.push({ category: MSG.CAT_IOS_BACKUPS, size: iosBackupSize });
+    totalCleaned += iosBackupSize;
+  }
+
+  // 7. Downloads older than 30 days
+  let oldDownloadsSize = 0;
+  const downloadsDir = path.join(HOME, 'Downloads');
+  if (fs.existsSync(downloadsDir)) {
+    if (autoMode && !isDryRun) {
+      const spinner7 = ora(`${MSG.CAT_OLD_DOWNLOADS}...`).start();
+      try {
+        const items = fs.readdirSync(downloadsDir);
+        const thirtyDaysAgo = Date.now() - (30 * 24 * 60 * 60 * 1000);
+        for (const item of items) {
+          const itemPath = path.join(downloadsDir, item);
+          try {
+            const stats = fs.statSync(itemPath);
+            if (stats.mtime.getTime() < thirtyDaysAgo) {
+              const size = getSize(itemPath);
+              if (size > 0 && deleteItem(itemPath)) {
+                oldDownloadsSize += size;
+                deletedCount++;
+              }
+            }
+          } catch (e) {}
+        }
+      } catch (e) {}
+      if (oldDownloadsSize > 0) {
+        spinner7.succeed(`${MSG.CAT_OLD_DOWNLOADS}: ${chalk.green(formatSize(oldDownloadsSize))}`);
+      } else {
+        spinner7.succeed(`${MSG.CAT_OLD_DOWNLOADS}: ${chalk.dim('0 MB')}`);
+      }
+    } else {
+      console.log(chalk.white(`  ${MSG.CAT_OLD_DOWNLOADS}:`));
+      try {
+        const items = fs.readdirSync(downloadsDir);
+        const thirtyDaysAgo = Date.now() - (30 * 24 * 60 * 60 * 1000);
+        for (const item of items) {
+          const itemPath = path.join(downloadsDir, item);
+          try {
+            const stats = fs.statSync(itemPath);
+            if (stats.mtime.getTime() < thirtyDaysAgo) {
+              const size = getSize(itemPath);
+              if (size > 0) {
+                const result = await processItemWithConfirm(itemPath, size, MSG.CAT_OLD_DOWNLOADS);
+                oldDownloadsSize += result.cleaned;
+                if (result.deleted) deletedCount++;
+                if (result.skipped) skippedCount++;
+              }
+            }
+          } catch (e) {}
+        }
+      } catch (e) {}
+    }
+  }
+  if (oldDownloadsSize > 0) {
+    results.push({ category: MSG.CAT_OLD_DOWNLOADS, size: oldDownloadsSize });
+    totalCleaned += oldDownloadsSize;
+  }
+
+  // 8. Mail Attachments
+  await cleanCategory(MSG.CAT_MAIL, [
+    '~/Library/Mail Downloads',
+    '~/Library/Containers/com.apple.mail/Data/Library/Mail Downloads'
+  ], MSG.CAT_MAIL);
+
+  // 9. Trash from all volumes
+  let trashSize = 0;
+  const userTrash = path.join(HOME, '.Trash');
+  trashSize = getSize(userTrash);
+  if (trashSize > 0) {
+    if (isDryRun) {
+      console.log(`  ${chalk.blue(figures.info)} [DRY-RUN] ${MSG.CAT_TRASH} ${chalk.dim('(' + formatSize(trashSize) + ')')}`);
+      deletedCount++;
+    } else if (autoMode) {
+      const spinner9 = ora(`${MSG.CAT_TRASH}...`).start();
+      exec('rm -rf ~/.Trash/* 2>/dev/null');
+      exec('rm -rf /Volumes/*/.Trashes/* 2>/dev/null');
+      spinner9.succeed(`${MSG.CAT_TRASH}: ${chalk.green(formatSize(trashSize))}`);
+      deletedCount++;
+    } else {
+      const answer = await confirmItem(userTrash, trashSize);
+      if (answer === 'all') {
+        autoMode = true;
+        exec('rm -rf ~/.Trash/* 2>/dev/null');
+        exec('rm -rf /Volumes/*/.Trashes/* 2>/dev/null');
+        console.log(`  ${chalk.green(figures.tick)} ${MSG.CAT_TRASH}`);
+        deletedCount++;
+      } else if (answer === 'yes') {
+        exec('rm -rf ~/.Trash/* 2>/dev/null');
+        exec('rm -rf /Volumes/*/.Trashes/* 2>/dev/null');
+        console.log(`  ${chalk.green(figures.tick)} ${MSG.CAT_TRASH}`);
+        deletedCount++;
+      } else {
+        trashSize = 0;
+        skippedCount++;
+        console.log(`  ${chalk.yellow(figures.cross)} ${MSG.SUMMARY_SKIPPED}: ${MSG.CAT_TRASH}`);
+      }
+    }
+  }
+  if (trashSize > 0) {
+    results.push({ category: MSG.CAT_TRASH, size: trashSize });
+    totalCleaned += trashSize;
+  }
+
+  // 10. Font Caches
+  await cleanCategory(MSG.CAT_FONTS, [
+    '~/Library/Caches/com.apple.FontRegistry',
+    '/Library/Caches/com.apple.ATS'
+  ], MSG.CAT_FONTS);
+
+  // 11. Adobe Caches
+  await cleanCategory(MSG.CAT_ADOBE, [
+    '~/Library/Caches/Adobe',
+    '~/Library/Application Support/Adobe/Common/Media Cache',
+    '~/Library/Application Support/Adobe/Common/Media Cache Files'
+  ], MSG.CAT_ADOBE);
+
+  // 12. Spotify/Music Caches
+  await cleanCategory(MSG.CAT_MUSIC, [
+    '~/Library/Caches/com.spotify.client',
+    '~/Library/Application Support/Spotify/PersistentCache',
+    '~/Library/Caches/com.apple.Music'
+  ], MSG.CAT_MUSIC);
+
+  // 13. Old Log Files
+  let oldLogsSize = 0;
+  oldLogsSize = parseInt(exec('find ~/Library/Logs -type f -mtime +7 -exec du -sm {} \\; 2>/dev/null | awk \'{sum+=$1} END {print sum}\'')) || 0;
+  if (oldLogsSize > 0) {
+    if (isDryRun) {
+      console.log(`  ${chalk.blue(figures.info)} [DRY-RUN] ${MSG.CAT_LOGS} ${chalk.dim('(' + formatSize(oldLogsSize) + ')')}`);
+      deletedCount++;
+    } else if (autoMode) {
+      const spinner13 = ora(`${MSG.CAT_LOGS}...`).start();
+      exec('find ~/Library/Logs -type f -mtime +7 -delete 2>/dev/null');
+      exec('find /Library/Logs -type f -mtime +7 -delete 2>/dev/null');
+      spinner13.succeed(`${MSG.CAT_LOGS}: ${chalk.green(formatSize(oldLogsSize))}`);
+      deletedCount++;
+    } else {
+      const answer = await confirmItem('~/Library/Logs (old files)', oldLogsSize);
+      if (answer === 'all') {
+        autoMode = true;
+        exec('find ~/Library/Logs -type f -mtime +7 -delete 2>/dev/null');
+        exec('find /Library/Logs -type f -mtime +7 -delete 2>/dev/null');
+        console.log(`  ${chalk.green(figures.tick)} ${MSG.CAT_LOGS}`);
+        deletedCount++;
+      } else if (answer === 'yes') {
+        exec('find ~/Library/Logs -type f -mtime +7 -delete 2>/dev/null');
+        exec('find /Library/Logs -type f -mtime +7 -delete 2>/dev/null');
+        console.log(`  ${chalk.green(figures.tick)} ${MSG.CAT_LOGS}`);
+        deletedCount++;
+      } else {
+        oldLogsSize = 0;
+        skippedCount++;
+        console.log(`  ${chalk.yellow(figures.cross)} ${MSG.SUMMARY_SKIPPED}: ${MSG.CAT_LOGS}`);
+      }
+    }
+  }
+  if (oldLogsSize > 0) {
+    results.push({ category: MSG.CAT_LOGS, size: oldLogsSize });
+    totalCleaned += oldLogsSize;
+  }
+
+  // Clean npm cache
+  if (!isDryRun) {
+    try {
+      execSync('npm cache clean --force 2>/dev/null', { stdio: 'ignore' });
+    } catch (e) {}
+  }
+
+  const endTime = Date.now();
+  const duration = Math.round((endTime - startTime) / 1000);
+
+  // Final Report
+  showCleanupSummary(deletedCount, skippedCount, totalCleaned, confirmMode);
+
+  if (results.length > 0) {
+    console.log(chalk.white('  Breakdown:'));
+    results.sort((a, b) => b.size - a.size);
+    results.forEach(r => {
+      console.log(`    ${figures.bullet} ${r.category.padEnd(25)} ${chalk.green(formatSize(r.size))}`);
+    });
+    console.log();
+  }
+
+  console.log(`  ${chalk.white(MSG.TOTAL + ':')} ${chalk.green.bold(formatSize(totalCleaned))}`);
+  console.log(`  ${chalk.dim('Duration: ' + duration + 's')}`);
+  console.log();
+
+  getSystemStats();
+  showFinalReport(totalCleaned);
+  await pressEnter();
+}
+
+// ============================================================================
+// FIND LARGE FILES
+// ============================================================================
+
+async function findLargeFiles() {
+  header();
+  sectionHeader(`${MSG.LARGE_FILES} (>100MB)`);
+
+  const spinner = ora(MSG.SCANNING).start();
+
+  const files = [];
 
   const output = exec(`find ~ -type f -size +100M 2>/dev/null | head -50 | xargs -I {} du -m {} 2>/dev/null | sort -rn | head -30`);
 
@@ -1870,60 +3083,118 @@ async function findLargeFiles() {
 
   const totalLarge = files.reduce((sum, f) => sum + f.size, 0);
 
-  files.forEach((file, i) => {
+  // Build checkbox choices for inquirer
+  const fileChoices = files.map((file, i) => {
     let displayFile = file.path.replace(HOME, '~');
-    if (displayFile.length > 50) {
-      displayFile = '...' + displayFile.slice(-47);
+    if (displayFile.length > 45) {
+      displayFile = '...' + displayFile.slice(-42);
     }
-    console.log(`  ${chalk.cyan('[' + String(i + 1).padStart(2) + ']')} ${chalk.dim(String(file.size).padStart(6) + ' MB')}  ${displayFile}`);
+    return {
+      name: `${chalk.dim(String(file.size).padStart(6) + ' MB')}  ${displayFile}`,
+      value: file.path,
+      short: path.basename(file.path)
+    };
   });
 
-  console.log();
+  // Fallback for text-based selection
+  const fallbackSelect = async () => {
+    files.forEach((file, i) => {
+      let displayFile = file.path.replace(HOME, '~');
+      if (displayFile.length > 50) {
+        displayFile = '...' + displayFile.slice(-47);
+      }
+      console.log(`  ${chalk.cyan('[' + String(i + 1).padStart(2) + ']')} ${chalk.dim(String(file.size).padStart(6) + ' MB')}  ${displayFile}`);
+    });
+    console.log();
+    console.log(`  ${figures.arrowRight} ${chalk.white(MSG.TOTAL + ':')} ${chalk.green(formatSize(totalLarge))} ${chalk.dim('(' + files.length + ' files)')}`);
+    console.log();
+    console.log(chalk.dim(`  ${MSG.SELECT_DELETE} [numbers/a/n]:`));
+    const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+    if (choice.toLowerCase() === 'n' || choice === '') return [];
+
+    const selected = new Array(files.length).fill(false);
+    if (choice.toLowerCase() === 'a') {
+      selected.fill(true);
+    } else {
+      choice.split(',').forEach(part => {
+        part = part.trim();
+        if (part.includes('-')) {
+          const [start, end] = part.split('-').map(n => parseInt(n));
+          for (let j = start; j <= end; j++) {
+            if (j > 0 && j <= files.length) selected[j - 1] = true;
+          }
+        } else {
+          const idx = parseInt(part) - 1;
+          if (idx >= 0 && idx < files.length) selected[idx] = true;
+        }
+      });
+    }
+    return files.filter((f, i) => selected[i]).map(f => f.path);
+  };
+
   console.log(`  ${figures.arrowRight} ${chalk.white(MSG.TOTAL + ':')} ${chalk.green(formatSize(totalLarge))} ${chalk.dim('(' + files.length + ' files)')}`);
   console.log();
 
-  console.log(chalk.dim(`  ${MSG.SELECT_DELETE} [numbers/a/n]:`));
-  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+  const selectedPaths = await selectMultiple(
+    `${MSG.SELECT_DELETE} ${chalk.dim('(space to select, enter to confirm)')}`,
+    fileChoices,
+    fallbackSelect
+  );
 
-  if (choice.toLowerCase() === 'n' || choice === '') {
+  if (selectedPaths.length === 0) {
     await pressEnter();
     return;
   }
 
-  const selected = new Array(files.length).fill(false);
-
-  if (choice.toLowerCase() === 'a') {
-    selected.fill(true);
-  } else {
-    const parts = choice.split(',');
-    parts.forEach(part => {
-      part = part.trim();
-      if (part.includes('-')) {
-        const [start, end] = part.split('-').map(n => parseInt(n));
-        for (let j = start; j <= end; j++) {
-          if (j > 0 && j <= files.length) selected[j - 1] = true;
-        }
-      } else {
-        const idx = parseInt(part) - 1;
-        if (idx >= 0 && idx < files.length) selected[idx] = true;
-      }
-    });
+  const selectedFiles = files.filter(f => selectedPaths.includes(f.path));
+  if (selectedFiles.length === 0) {
+    await pressEnter();
+    return;
   }
 
+  // Ask confirmation mode
+  const confirmMode = await askConfirmationMode();
+  const isDryRun = confirmMode === 'dryrun' || DRY_RUN;
+  let autoMode = confirmMode === 'auto';
+
   let deletedSize = 0;
+  let deletedCount = 0;
+  let skippedCount = 0;
   console.log();
 
-  for (let i = 0; i < files.length; i++) {
-    if (!selected[i]) continue;
+  for (const file of selectedFiles) {
+    let shouldDelete = autoMode;
+
+    if (!autoMode && confirmMode === 'manual') {
+      const answer = await confirmItem(file.path, file.size);
+      if (answer === 'all') {
+        autoMode = true;
+        shouldDelete = true;
+      } else if (answer === 'yes') {
+        shouldDelete = true;
+      } else {
+        shouldDelete = false;
+      }
+    }
 
-    if (deleteItem(files[i].path)) {
-      console.log(`  ${chalk.green(figures.tick)} Deleted: ${path.basename(files[i].path)}`);
-      deletedSize += files[i].size;
+    if (isDryRun) {
+      console.log(`  ${chalk.blue(figures.info)} [DRY-RUN] ${path.basename(file.path)} ${chalk.dim('(' + formatSize(file.size) + ')')}`);
+      deletedSize += file.size;
+      deletedCount++;
+    } else if (shouldDelete) {
+      if (deleteItem(file.path)) {
+        console.log(`  ${chalk.green(figures.tick)} ${MSG.SUMMARY_DELETED}: ${path.basename(file.path)}`);
+        deletedSize += file.size;
+        deletedCount++;
+      }
+    } else {
+      skippedCount++;
+      console.log(`  ${chalk.yellow(figures.cross)} ${MSG.SUMMARY_SKIPPED}: ${path.basename(file.path)}`);
     }
   }
 
-  console.log();
-  console.log(`  ${chalk.green(MSG.FREED + ': ' + formatSize(deletedSize))}`);
+  showCleanupSummary(deletedCount, skippedCount, deletedSize, confirmMode);
 
   playNotificationSound();
   await pressEnter();
@@ -1975,47 +3246,103 @@ async function findDuplicates() {
 
   spinner.stop();
 
-  // Display duplicate groups
-  header();
-  sectionHeader(MSG.DUPLICATES);
-
-  let groupNum = 0;
+  // Collect duplicate groups
+  const duplicateGroups = [];
   let totalDupSize = 0;
-  const allDups = [];
 
   for (const [hash, fileList] of hashGroups) {
     if (fileList.length < 2) continue;
 
-    groupNum++;
     const fileSize = Math.round(getSize(fileList[0]));
     const dupSpace = (fileList.length - 1) * fileSize;
     totalDupSize += dupSpace;
 
-    console.log(`  ${chalk.white(MSG.GROUP + ' ' + groupNum)} ${chalk.dim('(' + fileSize + ' MB ' + MSG.EACH + ')')}`);
+    duplicateGroups.push({ hash, files: fileList, fileSize });
+    if (duplicateGroups.length >= 10) break;
+  }
 
-    fileList.forEach((file, idx) => {
+  if (duplicateGroups.length === 0) {
+    header();
+    sectionHeader(MSG.DUPLICATES);
+    console.log(`  ${chalk.green(figures.tick)} ${MSG.NO_ITEMS}`);
+    await pressEnter();
+    return;
+  }
+
+  // Process each duplicate group
+  let totalDeletedSize = 0;
+  let totalDeletedCount = 0;
+  const isDryRun = DRY_RUN;
+
+  for (let groupIdx = 0; groupIdx < duplicateGroups.length; groupIdx++) {
+    const group = duplicateGroups[groupIdx];
+    header();
+    sectionHeader(`${MSG.DUPLICATES} - ${MSG.GROUP} ${groupIdx + 1}/${duplicateGroups.length}`);
+
+    console.log(`  ${chalk.dim(group.fileSize + ' MB ' + MSG.EACH + ' - ' + group.files.length + ' files')}`);
+    console.log();
+
+    // Build checkbox choices - select files to KEEP (unselected will be deleted)
+    const fileChoices = group.files.map((file, i) => {
       let display = file.replace(HOME, '~');
       if (display.length > 50) display = '...' + display.slice(-47);
-      console.log(`    ${chalk.cyan('[' + (idx + 1) + ']')} ${display}`);
-      allDups.push(file);
+      return {
+        name: display,
+        value: file,
+        checked: i === 0 // First file is selected (kept) by default
+      };
     });
-    console.log();
 
-    if (groupNum >= 10) break;
-  }
+    const fallbackKeep = async () => {
+      group.files.forEach((file, idx) => {
+        let display = file.replace(HOME, '~');
+        if (display.length > 50) display = '...' + display.slice(-47);
+        console.log(`    ${chalk.cyan('[' + (idx + 1) + ']')} ${display}`);
+      });
+      console.log();
+      console.log(chalk.dim(`  ${MSG.SELECT_KEEP} [numbers, default: 1]:`));
+      const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+      if (!choice || choice === '1') return [group.files[0]];
+      const indices = choice.split(',').map(n => parseInt(n.trim()) - 1).filter(n => n >= 0 && n < group.files.length);
+      return indices.length > 0 ? indices.map(i => group.files[i]) : [group.files[0]];
+    };
+
+    const keepFiles = await selectMultiple(
+      `${MSG.SELECT_KEEP} ${chalk.dim('(space to select files to KEEP)')}`,
+      fileChoices,
+      fallbackKeep
+    );
+
+    // Files not in keepFiles will be deleted
+    const filesToDelete = group.files.filter(f => !keepFiles.includes(f));
+
+    if (filesToDelete.length === 0) {
+      console.log(`  ${chalk.yellow(figures.info)} ${LANG_CODE === 'pt' ? 'Nenhum ficheiro a apagar' : 'No files to delete'}`);
+      continue;
+    }
 
-  if (groupNum === 0) {
-    console.log(`  ${chalk.green(figures.tick)} ${MSG.NO_ITEMS}`);
-    await pressEnter();
-    return;
+    console.log();
+    for (const file of filesToDelete) {
+      if (isDryRun) {
+        console.log(`  ${chalk.blue(figures.info)} [DRY-RUN] ${path.basename(file)}`);
+        totalDeletedSize += group.fileSize;
+        totalDeletedCount++;
+      } else {
+        if (deleteItem(file)) {
+          console.log(`  ${chalk.green(figures.tick)} ${MSG.SUMMARY_DELETED}: ${path.basename(file)}`);
+          totalDeletedSize += group.fileSize;
+          totalDeletedCount++;
+        }
+      }
+    }
   }
 
-  console.log(`  ${figures.arrowRight} ${chalk.white(MSG.TOTAL + ':')} ${chalk.green(formatSize(totalDupSize))} ${MSG.IN_DUPLICATES}`);
-  console.log();
-  console.log(chalk.dim(`  ${MSG.SELECT_KEEP}`));
-  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+  // Show summary
+  header();
+  sectionHeader(MSG.DUPLICATES);
+  showCleanupSummary(totalDeletedCount, 0, totalDeletedSize, isDryRun ? 'dryrun' : 'auto');
 
-  console.log(`  ${chalk.yellow(MSG.FEATURE_PROGRESS)}`);
+  playNotificationSound();
   await pressEnter();
 }
 
@@ -2084,56 +3411,125 @@ async function uninstallApps() {
     return;
   }
 
-  apps.forEach((app, i) => {
-    console.log(`  ${chalk.cyan('[' + String(i + 1).padStart(2) + ']')} ${app.name.padEnd(25)} ${chalk.dim('(' + String(app.appSize).padStart(3) + ' MB ' + MSG.APP_SIZE + ' + ' + String(app.dataSize).padStart(3) + ' MB ' + MSG.DATA_SIZE + ')')}`);
-  });
+  // Build checkbox choices for inquirer
+  const appChoices = apps.map((app, i) => ({
+    name: `${app.name.padEnd(25)} ${chalk.dim('(' + String(app.appSize).padStart(3) + ' MB ' + MSG.APP_SIZE + ' + ' + String(app.dataSize).padStart(3) + ' MB ' + MSG.DATA_SIZE + ')')}`,
+    value: app.path,
+    short: app.name
+  }));
+
+  // Fallback for text-based selection
+  const fallbackAppSelect = async () => {
+    apps.forEach((app, i) => {
+      console.log(`  ${chalk.cyan('[' + String(i + 1).padStart(2) + ']')} ${app.name.padEnd(25)} ${chalk.dim('(' + String(app.appSize).padStart(3) + ' MB ' + MSG.APP_SIZE + ' + ' + String(app.dataSize).padStart(3) + ' MB ' + MSG.DATA_SIZE + ')')}`);
+    });
 
-  console.log();
-  console.log(chalk.dim(`  ${MSG.SELECT_DELETE} [numbers/n]:`));
-  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+    console.log();
+    console.log(chalk.dim(`  ${MSG.SELECT_DELETE} [numbers/n]:`));
+    const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
 
-  if (choice.toLowerCase() === 'n' || choice === '') {
+    if (choice.toLowerCase() === 'n' || choice === '') {
+      return [];
+    }
+
+    const selected = [];
+    const parts = choice.split(',');
+    for (const part of parts) {
+      const idx = parseInt(part.trim()) - 1;
+      if (idx >= 0 && idx < apps.length) {
+        selected.push(apps[idx].path);
+      }
+    }
+    return selected;
+  };
+
+  const selectedPaths = await selectMultiple(
+    `${MSG.SELECT_DELETE} ${chalk.dim('(space to select, enter to confirm)')}`,
+    appChoices,
+    fallbackAppSelect
+  );
+
+  if (selectedPaths.length === 0) {
     await pressEnter();
     return;
   }
 
-  const parts = choice.split(',');
-  for (const part of parts) {
-    const idx = parseInt(part.trim()) - 1;
-    if (idx < 0 || idx >= apps.length) continue;
-
-    const app = apps[idx];
-    console.log(`  ${chalk.yellow(MSG.DELETING + ' ' + app.name + '...')}`);
+  // Collect selected apps
+  const selectedApps = apps.filter(app => selectedPaths.includes(app.path));
 
-    // Remove app data
-    if (app.bundleId && !DRY_RUN) {
-      const dataPaths = [
-        path.join(HOME, 'Library/Application Support', app.name),
-        path.join(HOME, 'Library/Application Support', app.bundleId),
-        path.join(HOME, 'Library/Preferences', `${app.bundleId}.plist`),
-        path.join(HOME, 'Library/Caches', app.bundleId),
-        path.join(HOME, 'Library/Caches', app.name),
-        path.join(HOME, 'Library/Containers', app.bundleId),
-        path.join(HOME, 'Library/Saved Application State', `${app.bundleId}.savedState`),
-        path.join(HOME, 'Library/Logs', app.name)
-      ];
+  if (selectedApps.length === 0) {
+    await pressEnter();
+    return;
+  }
 
-      dataPaths.forEach(dp => {
-        try {
-          if (fs.existsSync(dp)) deleteItem(dp);
-        } catch (e) {}
-      });
+  // Ask confirmation mode
+  const confirmMode = await askConfirmationMode();
+  const isDryRun = confirmMode === 'dryrun' || DRY_RUN;
+  let autoMode = confirmMode === 'auto';
+
+  let deletedCount = 0;
+  let skippedCount = 0;
+  let freedSize = 0;
+
+  for (const app of selectedApps) {
+    const totalSize = app.appSize + app.dataSize;
+    let shouldDelete = autoMode;
+
+    if (!autoMode && confirmMode === 'manual') {
+      const answer = await confirmItem(app.path, totalSize);
+      if (answer === 'all') {
+        autoMode = true;
+        shouldDelete = true;
+      } else if (answer === 'yes') {
+        shouldDelete = true;
+      } else {
+        shouldDelete = false;
+      }
     }
 
-    // Remove app
-    if (deleteItem(app.path)) {
-      console.log(`  ${chalk.green(figures.tick)} ${app.name} ${MSG.REMOVED}`);
+    if (isDryRun) {
+      console.log(`  ${chalk.blue(figures.info)} [DRY-RUN] ${app.name} ${chalk.dim('(' + formatSize(totalSize) + ')')}`);
+      freedSize += totalSize;
+      deletedCount++;
+    } else if (shouldDelete) {
+      console.log(`  ${chalk.yellow(MSG.DELETING + ' ' + app.name + '...')}`);
+
+      // Remove app data
+      if (app.bundleId) {
+        const dataPaths = [
+          path.join(HOME, 'Library/Application Support', app.name),
+          path.join(HOME, 'Library/Application Support', app.bundleId),
+          path.join(HOME, 'Library/Preferences', `${app.bundleId}.plist`),
+          path.join(HOME, 'Library/Caches', app.bundleId),
+          path.join(HOME, 'Library/Caches', app.name),
+          path.join(HOME, 'Library/Containers', app.bundleId),
+          path.join(HOME, 'Library/Saved Application State', `${app.bundleId}.savedState`),
+          path.join(HOME, 'Library/Logs', app.name)
+        ];
+
+        dataPaths.forEach(dp => {
+          try {
+            if (fs.existsSync(dp)) deleteItem(dp);
+          } catch (e) {}
+        });
+      }
+
+      // Remove app
+      if (deleteItem(app.path)) {
+        console.log(`  ${chalk.green(figures.tick)} ${app.name} ${MSG.REMOVED}`);
+        freedSize += totalSize;
+        deletedCount++;
+      } else {
+        console.log(`  ${chalk.red(MSG.NEED_SUDO)}`);
+        console.log(`  ${chalk.dim('sudo rm -rf "' + app.path + '"')}`);
+      }
     } else {
-      console.log(`  ${chalk.red(MSG.NEED_SUDO)}`);
-      console.log(`  ${chalk.dim('sudo rm -rf "' + app.path + '"')}`);
+      skippedCount++;
+      console.log(`  ${chalk.yellow(figures.cross)} ${MSG.SUMMARY_SKIPPED}: ${app.name}`);
     }
   }
 
+  showCleanupSummary(deletedCount, skippedCount, freedSize, confirmMode);
   await pressEnter();
 }
 
@@ -2183,10 +3579,22 @@ async function manageStartup() {
   }
 
   console.log();
-  console.log(chalk.dim("  Enter number to toggle, 'd' to disable all, or 'n' to go back"));
-  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
 
-  if (choice.toLowerCase() === 'd') {
+  const startupChoices = [
+    { name: 'Disable all login items', value: 'disable_all' },
+    { name: chalk.yellow(MSG.BACK), value: 'back' }
+  ];
+
+  const fallbackStartup = async () => {
+    console.log(chalk.dim("  Enter 'd' to disable all, or 'n' to go back"));
+    const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+    if (choice.toLowerCase() === 'd') return 'disable_all';
+    return 'back';
+  };
+
+  const choice = await selectOption(MSG.STARTUP_ITEMS, startupChoices, fallbackStartup);
+
+  if (choice === 'disable_all') {
     exec(`osascript -e 'tell application "System Events" to delete every login item' 2>/dev/null`);
     console.log(`  ${chalk.green(figures.tick)} All login items disabled`);
   }
@@ -2229,10 +3637,6 @@ async function cleanBrowsers() {
     addBrowserItem(`${ffProfile}/cache2`, 'Firefox Cache');
   }
 
-  items.forEach((item, i) => {
-    console.log(`  ${chalk.cyan('[' + String(i + 1).padStart(2) + ']')} ${item.name.padEnd(30)} ${chalk.dim(String(item.size).padStart(6) + ' MB')}`);
-  });
-
   if (items.length === 0) {
     console.log(`  ${chalk.green(figures.tick)} ${MSG.NO_ITEMS}`);
     await pressEnter();
@@ -2243,37 +3647,105 @@ async function cleanBrowsers() {
   console.log(`  ${figures.arrowRight} ${chalk.white(MSG.TOTAL + ':')} ${chalk.green(formatSize(totalBrowser))}`);
   console.log();
 
-  console.log(chalk.dim(`  ${MSG.SELECT_DELETE} [numbers/a/n]:`));
-  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+  // Build checkbox choices for inquirer
+  const browserChoices = items.map((item, i) => ({
+    name: `${item.name.padEnd(30)} ${chalk.dim(String(item.size).padStart(6) + ' MB')}`,
+    value: item.path,
+    short: item.name
+  }));
+
+  // Fallback for text-based selection
+  const fallbackBrowserSelect = async () => {
+    items.forEach((item, i) => {
+      console.log(`  ${chalk.cyan('[' + String(i + 1).padStart(2) + ']')} ${item.name.padEnd(30)} ${chalk.dim(String(item.size).padStart(6) + ' MB')}`);
+    });
+    console.log();
+    console.log(chalk.dim(`  ${MSG.SELECT_DELETE} [numbers/a/n]:`));
+    const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+    if (choice.toLowerCase() === 'n' || choice === '') {
+      return [];
+    }
 
-  if (choice.toLowerCase() === 'n' || choice === '') {
-    await pressEnter();
-    return;
-  }
+    if (choice.toLowerCase() === 'a') {
+      return items.map(item => item.path);
+    }
 
-  if (choice.toLowerCase() === 'a') {
-    items.forEach(item => item.selected = true);
-  } else {
+    const selected = [];
     const parts = choice.split(',');
     parts.forEach(part => {
       const idx = parseInt(part.trim()) - 1;
-      if (idx >= 0 && idx < items.length) items[idx].selected = true;
+      if (idx >= 0 && idx < items.length) selected.push(items[idx].path);
     });
+    return selected;
+  };
+
+  const selectedPaths = await selectMultiple(
+    `${MSG.SELECT_DELETE} ${chalk.dim('(space to select, enter to confirm)')}`,
+    browserChoices,
+    fallbackBrowserSelect
+  );
+
+  if (selectedPaths.length === 0) {
+    await pressEnter();
+    return;
+  }
+
+  // Mark selected items
+  items.forEach(item => {
+    item.selected = selectedPaths.includes(item.path);
+  });
+
+  const selectedItems = items.filter(i => i.selected);
+  if (selectedItems.length === 0) {
+    await pressEnter();
+    return;
   }
 
+  // Ask confirmation mode
+  const confirmMode = await askConfirmationMode();
+  const isDryRun = confirmMode === 'dryrun' || DRY_RUN;
+  let autoMode = confirmMode === 'auto';
+
   let cleaned = 0;
+  let deletedCount = 0;
+  let skippedCount = 0;
   console.log();
 
   for (const item of items) {
     if (!item.selected) continue;
-    if (deleteItem(item.path)) {
-      console.log(`  ${chalk.green(figures.tick)} ${item.name}`);
+
+    let shouldDelete = autoMode;
+
+    if (!autoMode && confirmMode === 'manual') {
+      const answer = await confirmItem(item.path, item.size);
+      if (answer === 'all') {
+        autoMode = true;
+        shouldDelete = true;
+      } else if (answer === 'yes') {
+        shouldDelete = true;
+      } else {
+        shouldDelete = false;
+      }
+    }
+
+    if (isDryRun) {
+      console.log(`  ${chalk.blue(figures.info)} [DRY-RUN] ${item.name} ${chalk.dim('(' + formatSize(item.size) + ')')}`);
       cleaned += item.size;
+      deletedCount++;
+    } else if (shouldDelete) {
+      if (deleteItem(item.path)) {
+        console.log(`  ${chalk.green(figures.tick)} ${item.name}`);
+        cleaned += item.size;
+        deletedCount++;
+      }
+    } else {
+      skippedCount++;
+      console.log(`  ${chalk.yellow(figures.cross)} ${MSG.SUMMARY_SKIPPED}: ${item.name}`);
     }
   }
 
-  console.log();
-  console.log(`  ${chalk.green(MSG.FREED + ': ' + formatSize(cleaned))}`);
+  showCleanupSummary(deletedCount, skippedCount, cleaned, confirmMode);
 
   playNotificationSound();
   await pressEnter();
@@ -2324,17 +3796,39 @@ async function killProcesses() {
   }
 
   console.log();
-  console.log(chalk.dim(`  ${MSG.KILL} process [number/n]:`));
-  const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
 
-  if (choice.toLowerCase() === 'n' || choice === '') {
+  // Build list choices for inquirer
+  const processChoices = procs.map((proc, i) => ({
+    name: `${proc.name.padEnd(30)} ${chalk.red(proc.memMB + ' MB RAM')}`,
+    value: proc.pid,
+    short: proc.name
+  }));
+  processChoices.push({ name: chalk.yellow(MSG.BACK), value: 'back' });
+
+  const fallbackProcess = async () => {
+    console.log(chalk.dim(`  ${MSG.KILL} process [number/n]:`));
+    const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+
+    if (choice.toLowerCase() === 'n' || choice === '') {
+      return 'back';
+    }
+
+    const idx = parseInt(choice) - 1;
+    if (idx >= 0 && idx < procs.length) {
+      return procs[idx].pid;
+    }
+    return 'back';
+  };
+
+  const selectedPid = await selectOption(`${MSG.KILL} process`, processChoices, fallbackProcess);
+
+  if (selectedPid === 'back' || !selectedPid) {
     await pressEnter();
     return;
   }
 
-  const idx = parseInt(choice) - 1;
-  if (idx >= 0 && idx < procs.length) {
-    const proc = procs[idx];
+  const proc = procs.find(p => p.pid === selectedPid);
+  if (proc) {
 
     if (DRY_RUN) {
       console.log(chalk.yellow(`  ${figures.info} [DRY-RUN] Would kill: ${proc.name} (PID: ${proc.pid})`));
@@ -2362,21 +3856,40 @@ async function showSettings() {
 
     const currentLang = LANG_CODE === 'en' ? 'EN' : 'PT';
 
-    console.log(`  ${chalk.cyan('[1]')} ${MSG.EXCLUSIONS}`);
-    console.log(`  ${chalk.cyan('[2]')} ${MSG.CUSTOM_PATHS}`);
-    console.log(`  ${chalk.cyan('[3]')} ${MSG.CHANGE_LANG} (current: ${currentLang})`);
-    console.log(`  ${chalk.cyan('[4]')} ${MSG.RESET_DEFAULTS}`);
-    console.log(`  ${chalk.cyan('[5]')} ${DRY_RUN ? chalk.green(figures.tick) : figures.radioOff} Dry-Run Mode`);
-    console.log(`  ${chalk.cyan('[6]')} ${SECURE_DELETE ? chalk.green(figures.tick) : figures.radioOff} Secure Delete Mode`);
-    console.log(`  ${chalk.cyan('[7]')} View Backups`);
-    console.log();
-    console.log(`  ${chalk.cyan('[0]')} ${MSG.BACK}`);
-    console.log();
+    const settingsChoices = [
+      { name: MSG.EXCLUSIONS, value: 'exclusions' },
+      { name: MSG.CUSTOM_PATHS, value: 'paths' },
+      { name: `${MSG.CHANGE_LANG} ${chalk.dim('(' + currentLang + ')')}`, value: 'lang' },
+      { name: MSG.RESET_DEFAULTS, value: 'reset' },
+      new inquirer.Separator(' '),
+      { name: `${DRY_RUN ? chalk.green(figures.tick) : figures.radioOff} Dry-Run Mode`, value: 'dryrun' },
+      { name: `${SECURE_DELETE ? chalk.green(figures.tick) : figures.radioOff} Secure Delete Mode`, value: 'secure' },
+      new inquirer.Separator(' '),
+      { name: 'View Backups', value: 'backups' },
+      new inquirer.Separator(' '),
+      { name: chalk.yellow(MSG.BACK), value: 'back' }
+    ];
+
+    const fallbackSettings = async () => {
+      console.log(`  ${chalk.cyan('[1]')} ${MSG.EXCLUSIONS}`);
+      console.log(`  ${chalk.cyan('[2]')} ${MSG.CUSTOM_PATHS}`);
+      console.log(`  ${chalk.cyan('[3]')} ${MSG.CHANGE_LANG} (current: ${currentLang})`);
+      console.log(`  ${chalk.cyan('[4]')} ${MSG.RESET_DEFAULTS}`);
+      console.log(`  ${chalk.cyan('[5]')} ${DRY_RUN ? chalk.green(figures.tick) : figures.radioOff} Dry-Run Mode`);
+      console.log(`  ${chalk.cyan('[6]')} ${SECURE_DELETE ? chalk.green(figures.tick) : figures.radioOff} Secure Delete Mode`);
+      console.log(`  ${chalk.cyan('[7]')} View Backups`);
+      console.log();
+      console.log(`  ${chalk.cyan('[0]')} ${MSG.BACK}`);
+      console.log();
+      const c = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+      const map = { '1': 'exclusions', '2': 'paths', '3': 'lang', '4': 'reset', '5': 'dryrun', '6': 'secure', '7': 'backups', '0': 'back' };
+      return map[c] || null;
+    };
 
-    const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+    const choice = await selectOption(MSG.OPT_SETTINGS, settingsChoices, fallbackSettings);
 
     switch (choice) {
-      case '1':
+      case 'exclusions':
         // Manage exclusions
         header();
         sectionHeader(MSG.EXCLUSIONS);
@@ -2403,7 +3916,7 @@ async function showSettings() {
         await pressEnter();
         break;
 
-      case '2':
+      case 'paths':
         // Custom paths
         header();
         sectionHeader(MSG.CUSTOM_PATHS);
@@ -2430,7 +3943,7 @@ async function showSettings() {
         await pressEnter();
         break;
 
-      case '3':
+      case 'lang':
         // Change language
         const newLang = LANG_CODE === 'pt' ? 'en' : 'pt';
         fs.writeFileSync(LANGUAGE_FILE, newLang);
@@ -2441,7 +3954,7 @@ async function showSettings() {
         process.exit(0);
         break;
 
-      case '4':
+      case 'reset':
         // Reset defaults
         [EXCLUSIONS_FILE, CUSTOM_PATHS_FILE, LANGUAGE_FILE].forEach(f => {
           if (fs.existsSync(f)) fs.unlinkSync(f);
@@ -2453,19 +3966,19 @@ async function showSettings() {
         process.exit(0);
         break;
 
-      case '5':
+      case 'dryrun':
         DRY_RUN = !DRY_RUN;
         console.log(`  ${chalk.green(figures.tick)} Dry-Run Mode: ${DRY_RUN ? 'ON' : 'OFF'}`);
         await pressEnter();
         break;
 
-      case '6':
+      case 'secure':
         SECURE_DELETE = !SECURE_DELETE;
         console.log(`  ${chalk.green(figures.tick)} Secure Delete Mode: ${SECURE_DELETE ? 'ON' : 'OFF'}`);
         await pressEnter();
         break;
 
-      case '7':
+      case 'backups':
         // View backups
         header();
         sectionHeader('Backups');
@@ -2481,7 +3994,7 @@ async function showSettings() {
         await pressEnter();
         break;
 
-      case '0':
+      case 'back':
         return;
 
       default:
@@ -2501,53 +4014,99 @@ async function mainMenu() {
     // Show update notification
     await showUpdateNotification();
 
-    // Main options
-    console.log(chalk.white('  CLEANING'));
-    console.log(`  ${chalk.cyan('[1]')}  ${MSG.OPT_QUICK}`);
-    console.log(`  ${chalk.cyan('[2]')}  ${MSG.OPT_LARGE}`);
-    console.log(`  ${chalk.cyan('[3]')}  ${MSG.OPT_DUPLICATES}`);
-    console.log(`  ${chalk.cyan('[4]')}  ${MSG.OPT_APPS}`);
-    console.log(`  ${chalk.cyan('[5]')}  ${MSG.OPT_BROWSERS}`);
-    console.log(`  ${chalk.cyan('[6]')}  ${MSG.OPT_PRIVACY}`);
-    console.log();
-
-    console.log(chalk.white('  SYSTEM'));
-    console.log(`  ${chalk.cyan('[7]')}  ${MSG.OPT_STARTUP}`);
-    console.log(`  ${chalk.cyan('[8]')}  ${MSG.OPT_PROCESSES}`);
-    console.log(`  ${chalk.cyan('[9]')}  ${MSG.OPT_MEMORY}`);
-    console.log(`  ${chalk.cyan('[10]')} ${MSG.OPT_DISK}`);
-    console.log();
-
-    console.log(chalk.white('  TOOLS'));
-    console.log(`  ${chalk.cyan('[11]')} ${MSG.OPT_BENCHMARK}`);
-    console.log(`  ${chalk.cyan('[12]')} ${MSG.OPT_SCHEDULER}`);
-    console.log(`  ${chalk.cyan('[13]')} ${MSG.OPT_EXPORT}`);
-    console.log(`  ${chalk.cyan('[14]')} ${MSG.OPT_STATS}`);
-    console.log(`  ${chalk.cyan('[15]')} ${MSG.OPT_SETTINGS}`);
-    console.log();
-
-    console.log(`  ${chalk.cyan('[0]')}  ${MSG.OPT_EXIT}`);
-    console.log();
+    // Build menu choices with separators for sections
+    const menuChoices = [
+      new inquirer.Separator(chalk.yellow(`\u2500\u2500 \uD83E\uDDF9 ${MSG.SECTION_CLEANING} \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`)),
+      { name: MSG.OPT_QUICK, value: 'quick' },
+      { name: `${MSG.OPT_DEEP} ${chalk.red('\uD83D\uDD25')}`, value: 'deep' },
+      { name: MSG.OPT_LARGE, value: 'large' },
+      { name: MSG.OPT_DUPLICATES, value: 'duplicates' },
+      { name: MSG.OPT_APPS, value: 'apps' },
+      { name: MSG.OPT_BROWSERS, value: 'browsers' },
+      { name: MSG.OPT_PRIVACY, value: 'privacy' },
+      { name: MSG.OPT_MEMORY, value: 'memory' },
+      new inquirer.Separator(chalk.yellow(`\u2500\u2500 \uD83D\uDCCA ${MSG.SECTION_ANALYSIS} \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`)),
+      { name: MSG.OPT_STATS, value: 'stats' },
+      { name: MSG.OPT_THERMAL, value: 'thermal' },
+      { name: MSG.OPT_DISK, value: 'disk' },
+      { name: MSG.OPT_BENCHMARK, value: 'benchmark' },
+      { name: MSG.OPT_PROCESSES, value: 'processes' },
+      new inquirer.Separator(chalk.yellow(`\u2500\u2500 \u2699\uFE0F  ${MSG.SECTION_SETTINGS} \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`)),
+      { name: MSG.OPT_STARTUP, value: 'startup' },
+      { name: MSG.OPT_SCHEDULER, value: 'scheduler' },
+      { name: MSG.OPT_SETTINGS, value: 'settings' },
+      { name: MSG.OPT_EXPORT, value: 'export' },
+      new inquirer.Separator(' '),
+      { name: chalk.red(MSG.OPT_EXIT), value: 'exit' }
+    ];
+
+    // Fallback for when inquirer is not available
+    const fallbackMenu = async () => {
+      // Box drawing characters
+      const boxChars = {
+        topLeft: '\u256D', topRight: '\u256E', bottomLeft: '\u2570', bottomRight: '\u256F',
+        horizontal: '\u2500', vertical: '\u2502', horizontalDouble: '\u2550', cross: '\u2560', crossRight: '\u2563'
+      };
+      console.log(chalk.cyan(`${boxChars.topLeft}${''.padEnd(38, boxChars.horizontal)}${boxChars.topRight}`));
+      console.log(chalk.cyan(boxChars.vertical) + chalk.white.bold('  \uD83E\uDDF9 ARIS MAC CLEANER v' + VERSION) + ' '.repeat(11) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.cross) + chalk.cyan(''.padEnd(38, boxChars.horizontalDouble)) + chalk.cyan(boxChars.crossRight));
+      console.log(chalk.cyan(boxChars.vertical) + ' '.repeat(38) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + chalk.yellow('  \u2500\u2500 \uD83E\uDDF9 ' + MSG.SECTION_CLEANING + ' ') + '\u2500'.repeat(38 - 10 - MSG.SECTION_CLEANING.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[1]')} ${MSG.OPT_QUICK}` + ' '.repeat(38 - 7 - MSG.OPT_QUICK.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[2]')} ${MSG.OPT_DEEP} ${chalk.red('\uD83D\uDD25')}` + ' '.repeat(38 - 11 - MSG.OPT_DEEP.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[3]')} ${MSG.OPT_LARGE}` + ' '.repeat(38 - 7 - MSG.OPT_LARGE.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[4]')} ${MSG.OPT_DUPLICATES}` + ' '.repeat(38 - 7 - MSG.OPT_DUPLICATES.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[5]')} ${MSG.OPT_APPS}` + ' '.repeat(38 - 7 - MSG.OPT_APPS.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[6]')} ${MSG.OPT_BROWSERS}` + ' '.repeat(38 - 7 - MSG.OPT_BROWSERS.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[7]')} ${MSG.OPT_PRIVACY}` + ' '.repeat(38 - 7 - MSG.OPT_PRIVACY.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[8]')} ${MSG.OPT_MEMORY}` + ' '.repeat(38 - 7 - MSG.OPT_MEMORY.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + ' '.repeat(38) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + chalk.yellow('  \u2500\u2500 \uD83D\uDCCA ' + MSG.SECTION_ANALYSIS + ' ') + '\u2500'.repeat(38 - 10 - MSG.SECTION_ANALYSIS.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[9]')} ${MSG.OPT_STATS}` + ' '.repeat(38 - 7 - MSG.OPT_STATS.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[10]')} ${MSG.OPT_THERMAL}` + ' '.repeat(38 - 8 - MSG.OPT_THERMAL.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[11]')} ${MSG.OPT_DISK}` + ' '.repeat(38 - 8 - MSG.OPT_DISK.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[12]')} ${MSG.OPT_BENCHMARK}` + ' '.repeat(38 - 8 - MSG.OPT_BENCHMARK.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[13]')} ${MSG.OPT_PROCESSES}` + ' '.repeat(38 - 8 - MSG.OPT_PROCESSES.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + ' '.repeat(38) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + chalk.yellow('  \u2500\u2500 \u2699\uFE0F  ' + MSG.SECTION_SETTINGS + ' ') + '\u2500'.repeat(38 - 11 - MSG.SECTION_SETTINGS.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[14]')} ${MSG.OPT_STARTUP}` + ' '.repeat(38 - 8 - MSG.OPT_STARTUP.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[15]')} ${MSG.OPT_SCHEDULER}` + ' '.repeat(38 - 8 - MSG.OPT_SCHEDULER.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[16]')} ${MSG.OPT_SETTINGS}` + ' '.repeat(38 - 8 - MSG.OPT_SETTINGS.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[17]')} ${MSG.OPT_EXPORT}` + ' '.repeat(38 - 8 - MSG.OPT_EXPORT.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + ' '.repeat(38) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(boxChars.vertical) + `  ${chalk.cyan('[0]')} ${MSG.OPT_EXIT}` + ' '.repeat(38 - 7 - MSG.OPT_EXIT.length) + chalk.cyan(boxChars.vertical));
+      console.log(chalk.cyan(`${boxChars.bottomLeft}${''.padEnd(38, boxChars.horizontal)}${boxChars.bottomRight}`));
+      console.log();
+      const c = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+      const map = { '1': 'quick', '2': 'deep', '3': 'large', '4': 'duplicates', '5': 'apps', '6': 'browsers', '7': 'privacy', '8': 'memory', '9': 'stats', '10': 'thermal', '11': 'disk', '12': 'benchmark', '13': 'processes', '14': 'startup', '15': 'scheduler', '16': 'settings', '17': 'export', '0': 'exit' };
+      return map[c] || null;
+    };
 
-    const choice = await prompt(`  ${chalk.white(MSG.CHOOSE + ':')} `);
+    const choice = await selectOption(
+      chalk.cyan('\uD83E\uDDF9 ARIS MAC CLEANER v' + VERSION),
+      menuChoices,
+      fallbackMenu
+    );
 
     switch (choice) {
-      case '1': await quickClean(); break;
-      case '2': await findLargeFiles(); break;
-      case '3': await findDuplicates(); break;
-      case '4': await uninstallApps(); break;
-      case '5': await cleanBrowsers(); break;
-      case '6': await privacySweep(); break;
-      case '7': await manageStartup(); break;
-      case '8': await killProcesses(); break;
-      case '9': await memoryOptimizer(); break;
-      case '10': await diskAnalyzer(); break;
-      case '11': await benchmarkMode(); break;
-      case '12': await scheduler(); break;
-      case '13': await exportHtmlReport(); break;
-      case '14': await showStatistics(); break;
-      case '15': await showSettings(); break;
-      case '0':
+      case 'quick': await quickClean(); break;
+      case 'deep': await deepClean(); break;
+      case 'large': await findLargeFiles(); break;
+      case 'duplicates': await findDuplicates(); break;
+      case 'apps': await uninstallApps(); break;
+      case 'browsers': await cleanBrowsers(); break;
+      case 'privacy': await privacySweep(); break;
+      case 'memory': await memoryOptimizer(); break;
+      case 'stats': await showStatistics(); break;
+      case 'thermal': await thermalMonitor(); break;
+      case 'disk': await diskAnalyzer(); break;
+      case 'benchmark': await benchmarkMode(); break;
+      case 'processes': await killProcesses(); break;
+      case 'startup': await manageStartup(); break;
+      case 'scheduler': await scheduler(); break;
+      case 'settings': await showSettings(); break;
+      case 'export': await exportHtmlReport(); break;
+      case 'exit':
         clearScreen();
         console.log();
         console.log(gradient.pastel.multiline(`
@@ -2559,8 +4118,10 @@ async function mainMenu() {
         process.exit(0);
         break;
       default:
-        console.log(`  ${chalk.red(MSG.INVALID)}`);
-        await new Promise(r => setTimeout(r, 1000));
+        if (choice === null) {
+          console.log(`  ${chalk.red(MSG.INVALID)}`);
+          await new Promise(r => setTimeout(r, 1000));
+        }
     }
   }
 }
@@ -2618,6 +4179,7 @@ Premium Features:
   - Benchmark mode
   - Privacy sweep
   - Memory optimizer
+  - Thermal monitor with power metrics
   - Scheduled cleanups (launchd)
   - Sound notifications
   - Dry-run and secure delete modes