diff --git a/README.md b/README.md
index 5d8fe55..310cc70 100644
--- a/README.md
+++ b/README.md
@@ -18,15 +18,21 @@ A beautiful, native macOS desktop application for transcribing audio and video f
 
 - **Drag & Drop** - Drag single or multiple files to create a batch queue
 - **Batch Processing** - Process unlimited files sequentially with automatic queue management
-- **Multiple Formats** - Supports MP3, WAV, M4A, FLAC, OGG, WMA, AAC, AIFF, MP4, MOV, AVI, MKV, WebM, WMV, FLV, M4V
+- **Queue Persistence + Resume** - Restore unfinished queue items after restarting the app
+- **Duplicate File Protection** - Automatically skips duplicates by file path/fingerprint in batch mode
+- **Retry Failed Items** - One-click retry for failed or cancelled queue items
+- **Live Batch ETA** - See estimated remaining time while batch processing is running
+- **Completion Notifications** - Native notification when a batch finishes
+- **Multiple Formats** - Supports MP3, WAV, M4A, FLAC, OGG, OPUS, OGA, AMR, WMA, AAC, AIFF, MP4, MOV, AVI, MKV, WebM, WMV, FLV, M4V
 - **Multiple Models** - Choose from tiny, base, small, medium, large-v3, or large-v3-turbo Whisper models (including English-only variants)
 - **Output Formats** - Export as VTT subtitles, SRT subtitles, plain text, Word (`.docx`), PDF, or Markdown
+- **Finder Reveal After Save** - Prompt to reveal the saved transcript directly in Finder
 - **Language Support** - Auto-detect or select from 12+ languages
 - **Apple Silicon Optimized** - Native Metal GPU acceleration on M1/M2/M3/M4 Macs
 - **Dark Mode** - Beautiful dark theme that respects your system preference
 - **Auto Updates** - Automatic update notifications when new versions are available
 - **Keyboard Shortcuts** - Full keyboard navigation support
-- **Transcription History** - Keep track of your recent transcriptions
+- **Transcription History + Search** - Keep track of recent transcriptions and search by file name, content, model, or language
 - **Native Performance** - Uses whisper.cpp for fast, efficient transcription
 - **TypeScript** - Fully typed codebase for better maintainability
 - **Feature-Driven Architecture** - Modular codebase organized by feature domains
diff --git a/docs/index.html b/docs/index.html
index 67b93b7..ac94c3b 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -8,9 +8,9 @@
     <meta name="title"
         content="WhisperDesk - Free Local AI Audio Transcription for macOS | Privacy-First Speech-to-Text">
     <meta name="description"
-        content="Free, open-source audio transcription app for macOS. Transcribe audio & video files privately using OpenAI's Whisper AI locally. No cloud uploads, no subscriptions. Supports Apple Silicon & Intel. Export to SRT, VTT, TXT.">
+        content="Free, open-source audio transcription app for macOS. Transcribe audio & video files privately using OpenAI's Whisper AI locally, including OPUS/OGA/AMR voice notes. No cloud uploads, no subscriptions. Supports Apple Silicon & Intel. Export to SRT, VTT, TXT, DOCX, PDF, and Markdown. Smart batch queue with resume, retry, live ETA, duplicate skipping, and searchable history">
     <meta name="keywords"
-        content="whisper, transcription, audio transcription, video transcription, speech to text, voice to text, AI transcription, local transcription, offline transcription, macOS transcription app, free transcription software, open source transcription, whisper.cpp, OpenAI Whisper, Apple Silicon, M1, M2, M3, M4, subtitle generator, SRT generator, VTT generator, podcast transcription, meeting transcription, interview transcription, private transcription, secure transcription">
+        content="whisper, transcription, audio transcription, video transcription, speech to text, voice to text, AI transcription, local transcription, offline transcription, macOS transcription app, free transcription software, open source transcription, whisper.cpp, OpenAI Whisper, Apple Silicon, M1, M2, M3, M4, subtitle generator, SRT generator, VTT generator, podcast transcription, meeting transcription, interview transcription, private transcription, secure transcription, opus transcription, oga transcription, amr transcription, whatsapp voice note transcription">
     <meta name="author" content="PVAS Development">
     <meta name="robots" content="index, follow, max-image-preview:large, max-snippet:-1, max-video-preview:-1">
     <meta name="googlebot" content="index, follow">
@@ -61,13 +61,16 @@
         },
         "license": "https://opensource.org/licenses/MIT",
         "screenshot": "https://whisperdesk.org/screenshot.png",
-        "softwareVersion": "1.1.6",
+        "softwareVersion": "1.9.0",
         "downloadUrl": "https://github.com/PVAS-Development/whisperdesk/releases/latest",
         "featureList": [
             "100% Local Processing",
             "GPU Accelerated (Apple Silicon Metal)",
-            "Multi-format Export (SRT, VTT, JSON, TXT)",
-            "Batch Processing Queue",
+            "Batch Queue with ETA, Retry, and Duplicate Protection",
+            "Queue Persistence and Resume After Restart",
+            "Transcription History Search",
+            "Multi-format Export (VTT, SRT, TXT, DOCX, PDF, Markdown)",
+            "Finder Reveal After Save",
             "No Internet Required",
             "No Subscription Fees",
             "Open Source (MIT License)"
@@ -134,7 +137,7 @@
                 "name": "What formats can WhisperDesk export?",
                 "acceptedAnswer": {
                     "@type": "Answer",
-                    "text": "WhisperDesk supports exporting transcriptions to SRT (subtitles), VTT (web subtitles), JSON, and plain text formats."
+                    "text": "WhisperDesk can export transcripts as VTT, SRT, TXT, Markdown, DOCX, and PDF."
                 }
             },
             {
@@ -144,6 +147,14 @@
                     "@type": "Answer",
                     "text": "Yes, WhisperDesk is optimized for Apple Silicon (M1, M2, M3, M4) Macs with Metal GPU acceleration for blazing fast transcription speeds up to 100x real-time."
                 }
+            },
+            {
+                "@type": "Question",
+                "name": "Can I resume my transcription queue after restarting the app?",
+                "acceptedAnswer": {
+                    "@type": "Answer",
+                    "text": "Yes. WhisperDesk restores unfinished queue items after restart and lets you resume processing with one click."
+                }
             }
         ]
     }
@@ -175,8 +186,8 @@
                 <div class="nav-links">
                     <a href="#features" class="nav-link">Features</a>
                     <a href="#how-it-works" class="nav-link">How it Works</a>
-                    <a href="https://www.paypal.com/donate/?hosted_button_id=HTJXGMEGMWWD6" class="nav-link-icon" target="_blank"
-                        rel="noopener noreferrer" aria-label="Donate to WhisperDesk">
+                    <a href="https://www.paypal.com/donate/?hosted_button_id=HTJXGMEGMWWD6" class="nav-link-icon"
+                        target="_blank" rel="noopener noreferrer" aria-label="Donate to WhisperDesk">
                         <i data-lucide="heart" class="heart-icon"></i>
                     </a>
                     <a href="https://github.com/PVAS-Development/whisperdesk" class="nav-link-icon" target="_blank"
@@ -286,7 +297,8 @@ <h3 class="feature-title">Multi-Format Export</h3>
                         </div>
                         <h3 class="feature-title">Batch Processing</h3>
                         <p class="feature-description">
-                            Drag and drop multiple files or folders. Process unlimited audio files sequentially with automatic queue management.
+                            Drag and drop multiple files or folders. Process unlimited audio files sequentially with
+                            automatic queue management.
                         </p>
                     </article>
                 </div>
@@ -343,8 +355,8 @@ <h2 id="opensource-title" class="opensource-title">Open Source & Community Drive
             <nav class="footer-links" aria-label="Footer navigation">
                 <a href="https://www.paypal.com/donate/?hosted_button_id=HTJXGMEGMWWD6" target="_blank"
                     rel="noopener noreferrer" class="footer-link">Donate</a>
-                <a href="https://www.buymeacoffee.com/pedrovsiqueira" target="_blank"
-                    rel="noopener noreferrer" class="footer-link">Buy me a coffee</a>
+                <a href="https://www.buymeacoffee.com/pedrovsiqueira" target="_blank" rel="noopener noreferrer"
+                    class="footer-link">Buy me a coffee</a>
                 <a href="https://github.com/PVAS-Development/whisperdesk/blob/main/LICENSE" target="_blank"
                     rel="noopener noreferrer" class="footer-link">License</a>
                 <a href="https://github.com/PVAS-Development/whisperdesk/blob/main/CONTRIBUTING.md" target="_blank"
@@ -411,4 +423,4 @@ <h2 id="opensource-title" class="opensource-title">Open Source & Community Drive
     </script>
 </body>
 
-</html>
\ No newline at end of file
+</html>
diff --git a/src/main/index.ts b/src/main/index.ts
index 8a151a1..f8aaa83 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -4,10 +4,14 @@ import path from 'path';
 import { registerIpcHandlers } from './ipc';
 import { initAnalytics, trackEvent, AnalyticsEvents } from './services/analytics';
 import { initAutoUpdater, checkForUpdates } from './services/auto-updater';
+import { safeSend } from './utils/safe-send';
 import packageJson from '../../package.json';
 
 initAnalytics();
 
+const APP_DISPLAY_NAME = 'WhisperDesk';
+const APP_USER_MODEL_ID = 'com.whisperdesk.app';
+
 let mainWindow: BrowserWindow | null = null;
 let ipcHandlersRegistered = false;
 
@@ -16,6 +20,19 @@ const appVersion = packageJson.version;
 
 const UPDATE_CHECK_DELAY_MS = 3000;
 
+app.setName(APP_DISPLAY_NAME);
+
+if (process.platform === 'win32') {
+  app.setAppUserModelId(APP_USER_MODEL_ID);
+}
+
+if (process.platform === 'darwin') {
+  app.setAboutPanelOptions({
+    applicationName: APP_DISPLAY_NAME,
+    applicationVersion: appVersion,
+  });
+}
+
 function createMenu() {
   if (!mainWindow) return;
 
@@ -27,14 +44,14 @@ function createMenu() {
           label: 'Open File...',
           accelerator: 'CmdOrCtrl+O',
           click: () => {
-            mainWindow?.webContents.send('menu:openFile');
+            safeSend(mainWindow, 'menu:openFile');
           },
         },
         {
           label: 'Save Transcription...',
           accelerator: 'CmdOrCtrl+S',
           click: () => {
-            mainWindow?.webContents.send('menu:saveFile');
+            safeSend(mainWindow, 'menu:saveFile');
           },
         },
         { type: 'separator' as const },
@@ -60,7 +77,7 @@ function createMenu() {
           label: 'Copy All Transcription',
           accelerator: 'CmdOrCtrl+C',
           click: () => {
-            mainWindow?.webContents.send('menu:copyTranscription');
+            safeSend(mainWindow, 'menu:copyTranscription');
           },
         },
       ],
@@ -81,7 +98,7 @@ function createMenu() {
           label: 'Toggle History',
           accelerator: 'CmdOrCtrl+H',
           click: () => {
-            mainWindow?.webContents.send('menu:toggleHistory');
+            safeSend(mainWindow, 'menu:toggleHistory');
           },
         },
       ],
@@ -93,14 +110,14 @@ function createMenu() {
           label: 'Start Transcription',
           accelerator: 'CmdOrCtrl+Enter',
           click: () => {
-            mainWindow?.webContents.send('menu:startTranscription');
+            safeSend(mainWindow, 'menu:startTranscription');
           },
         },
         {
           label: 'Cancel Transcription',
           accelerator: 'Escape',
           click: () => {
-            mainWindow?.webContents.send('menu:cancelTranscription');
+            safeSend(mainWindow, 'menu:cancelTranscription');
           },
         },
       ],
@@ -201,6 +218,7 @@ const createWindow = () => {
       sandbox: true,
     },
     titleBarStyle: 'hiddenInset',
+    title: APP_DISPLAY_NAME,
     trafficLightPosition: { x: 20, y: 20 },
   });
 
diff --git a/src/main/ipc/index.ts b/src/main/ipc/index.ts
index 0cae402..aa0ce6d 100644
--- a/src/main/ipc/index.ts
+++ b/src/main/ipc/index.ts
@@ -16,9 +16,14 @@ import {
   generatePdfDocument,
   generateMarkdownDocument,
 } from '../utils/export-helper';
+import { generateFileFingerprint } from '../utils/media-info';
+import { safeSend } from '../utils/safe-send';
 import { trackEvent, AnalyticsEvents } from '../services/analytics';
+import { SUPPORTED_EXTENSIONS } from '../../shared/types';
 import type { TranscriptionOptions, SaveFileOptions } from '../../shared/types';
 
+const OPEN_DIALOG_MEDIA_EXTENSIONS = [...SUPPORTED_EXTENSIONS];
+
 export function registerIpcHandlers(getMainWindow: () => BrowserWindow | null) {
   ipcMain.handle('dialog:openFile', async () => {
     const mainWindow = getMainWindow();
@@ -29,7 +34,7 @@ export function registerIpcHandlers(getMainWindow: () => BrowserWindow | null) {
       filters: [
         {
           name: 'Audio/Video',
-          extensions: ['mp3', 'wav', 'm4a', 'mp4', 'mov', 'mkv', 'flac', 'ogg', 'webm'],
+          extensions: OPEN_DIALOG_MEDIA_EXTENSIONS,
         },
       ],
     });
@@ -48,7 +53,7 @@ export function registerIpcHandlers(getMainWindow: () => BrowserWindow | null) {
       filters: [
         {
           name: 'Audio/Video',
-          extensions: ['mp3', 'wav', 'm4a', 'mp4', 'mov', 'mkv', 'flac', 'ogg', 'webm'],
+          extensions: OPEN_DIALOG_MEDIA_EXTENSIONS,
         },
       ],
     });
@@ -91,11 +96,19 @@ export function registerIpcHandlers(getMainWindow: () => BrowserWindow | null) {
 
   ipcMain.handle('file:getInfo', async (_event, filePath: string) => {
     try {
-      const stats = fs.statSync(filePath);
+      const stats = await fs.promises.stat(filePath);
+      let fingerprint: string | undefined;
+      try {
+        fingerprint = await generateFileFingerprint(filePath, stats.size);
+      } catch {
+        fingerprint = undefined;
+      }
+
       return {
         name: path.basename(filePath),
         path: filePath,
         size: stats.size,
+        fingerprint,
       };
     } catch {
       return null;
@@ -114,7 +127,7 @@ export function registerIpcHandlers(getMainWindow: () => BrowserWindow | null) {
   ipcMain.handle('models:download', async (_event, modelName: string) => {
     try {
       const result = await downloadModel(modelName, (progress) => {
-        getMainWindow()?.webContents.send('models:downloadProgress', progress);
+        safeSend(getMainWindow(), 'models:downloadProgress', progress);
       });
       if (result.success) {
         trackEvent(AnalyticsEvents.MODEL_DOWNLOADED, { model: modelName });
@@ -138,7 +151,7 @@ export function registerIpcHandlers(getMainWindow: () => BrowserWindow | null) {
   ipcMain.handle('transcribe:start', async (_event, options: TranscriptionOptions) => {
     try {
       const promise = transcribe(options, (progress) => {
-        getMainWindow()?.webContents.send('transcribe:progress', progress);
+        safeSend(getMainWindow(), 'transcribe:progress', progress);
       });
 
       currentTranscription = promise;
@@ -227,4 +240,29 @@ export function registerIpcHandlers(getMainWindow: () => BrowserWindow | null) {
     }
     await shell.openExternal(url);
   });
+
+  ipcMain.handle('shell:showItemInFolder', async (_event, filePath: string) => {
+    try {
+      if (typeof filePath !== 'string' || filePath.trim().length === 0) {
+        return { success: false, error: 'Invalid file path' };
+      }
+
+      if (!path.isAbsolute(filePath)) {
+        return { success: false, error: 'Invalid file path' };
+      }
+
+      const resolvedPath = path.resolve(filePath);
+
+      try {
+        await fs.promises.access(resolvedPath, fs.constants.F_OK);
+      } catch {
+        return { success: false, error: 'File not found' };
+      }
+
+      shell.showItemInFolder(resolvedPath);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  });
 }
diff --git a/src/main/services/auto-updater.ts b/src/main/services/auto-updater.ts
index 0f333d7..8145472 100644
--- a/src/main/services/auto-updater.ts
+++ b/src/main/services/auto-updater.ts
@@ -2,6 +2,7 @@ import { autoUpdater } from 'electron-updater';
 import type { BrowserWindow } from 'electron';
 import type { UpdateInfo, UpdateProgress } from '../../shared/types';
 import { trackEvent, AnalyticsEvents } from './analytics';
+import { safeSend } from '../utils/safe-send';
 import log from 'electron-log';
 
 autoUpdater.logger = log;
@@ -24,7 +25,7 @@ export function initAutoUpdater(getMainWindow: () => BrowserWindow | null) {
     updateCheckInProgress = true;
     log.info('Checking for updates...');
     const mainWindow = getMainWindow();
-    mainWindow?.webContents.send('update:status', {
+    safeSend(mainWindow, 'update:status', {
       status: 'checking',
     });
     trackEvent(AnalyticsEvents.UPDATE_CHECKING);
@@ -39,7 +40,7 @@ export function initAutoUpdater(getMainWindow: () => BrowserWindow | null) {
       releaseDate: info.releaseDate,
       releaseNotes: info.releaseNotes as string | undefined,
     };
-    mainWindow?.webContents.send('update:status', {
+    safeSend(mainWindow, 'update:status', {
       status: 'available',
       info: updateInfo,
     });
@@ -50,7 +51,7 @@ export function initAutoUpdater(getMainWindow: () => BrowserWindow | null) {
     updateCheckInProgress = false;
     log.info('No updates available');
     const mainWindow = getMainWindow();
-    mainWindow?.webContents.send('update:status', {
+    safeSend(mainWindow, 'update:status', {
       status: 'not-available',
     });
     trackEvent(AnalyticsEvents.UPDATE_NOT_AVAILABLE);
@@ -60,7 +61,7 @@ export function initAutoUpdater(getMainWindow: () => BrowserWindow | null) {
     updateCheckInProgress = false;
     log.error('Update error:', error);
     const mainWindow = getMainWindow();
-    mainWindow?.webContents.send('update:status', {
+    safeSend(mainWindow, 'update:status', {
       status: 'error',
       error: error.message,
     });
@@ -77,7 +78,7 @@ export function initAutoUpdater(getMainWindow: () => BrowserWindow | null) {
       transferred: progressObj.transferred,
       total: progressObj.total,
     };
-    mainWindow?.webContents.send('update:status', {
+    safeSend(mainWindow, 'update:status', {
       status: 'downloading',
       progress,
     });
@@ -90,7 +91,7 @@ export function initAutoUpdater(getMainWindow: () => BrowserWindow | null) {
       releaseDate: info.releaseDate,
       releaseNotes: info.releaseNotes as string | undefined,
     };
-    mainWindow?.webContents.send('update:status', {
+    safeSend(mainWindow, 'update:status', {
       status: 'downloaded',
       info: updateInfo,
     });
diff --git a/src/main/services/whisper.ts b/src/main/services/whisper.ts
index 29d440f..7acf4da 100644
--- a/src/main/services/whisper.ts
+++ b/src/main/services/whisper.ts
@@ -385,6 +385,7 @@ function convertToWav(inputPath: string, outputPath: string): Promise<string> {
     const args = [
       '-i',
       inputPath,
+      '-vn', // Drop video streams if present
       '-ar',
       '16000', // 16kHz sample rate (required by Whisper)
       '-ac',
@@ -512,8 +513,9 @@ export function transcribe(
         outputBase,
       ];
 
-      // Add language if specified
-      if (language && language !== 'auto') {
+      // whisper.cpp defaults to English when -l is omitted.
+      // Pass 'auto' explicitly to enable language auto-detection.
+      if (language) {
         args.push('-l', language);
       }
 
diff --git a/src/main/utils/media-info.ts b/src/main/utils/media-info.ts
new file mode 100644
index 0000000..9a5d0c0
--- /dev/null
+++ b/src/main/utils/media-info.ts
@@ -0,0 +1,62 @@
+import fs from 'fs';
+import crypto from 'crypto';
+import { sanitizePath } from '../../shared/utils';
+
+const CHUNK_SIZE = 128 * 1024; // 128 KB
+
+async function readChunk(
+  handle: fs.promises.FileHandle,
+  position: number,
+  length: number
+): Promise<Buffer> {
+  const safeLength = Math.max(0, Math.min(length, CHUNK_SIZE));
+  if (safeLength === 0) {
+    return Buffer.alloc(0);
+  }
+
+  const buffer = Buffer.allocUnsafe(safeLength);
+  const { bytesRead } = await handle.read(buffer, 0, safeLength, position);
+  return bytesRead === safeLength ? buffer : buffer.subarray(0, bytesRead);
+}
+
+export async function generateFileFingerprint(filePath: string, fileSize: number): Promise<string> {
+  const hash = crypto.createHash('sha256');
+  hash.update(String(fileSize));
+
+  let fileHandle: fs.promises.FileHandle | null = null;
+  try {
+    fileHandle = await fs.promises.open(filePath, 'r');
+
+    const firstChunkSize = Math.min(fileSize, CHUNK_SIZE);
+    hash.update(await readChunk(fileHandle, 0, firstChunkSize));
+
+    if (fileSize > CHUNK_SIZE * 2) {
+      const middleOffset = Math.max(0, Math.floor(fileSize / 2) - Math.floor(CHUNK_SIZE / 2));
+      hash.update(await readChunk(fileHandle, middleOffset, CHUNK_SIZE));
+    }
+
+    if (fileSize > CHUNK_SIZE) {
+      const lastOffset = Math.max(0, fileSize - CHUNK_SIZE);
+      hash.update(await readChunk(fileHandle, lastOffset, CHUNK_SIZE));
+    }
+  } catch (error) {
+    console.warn('Failed to generate file fingerprint', {
+      file: sanitizePath(filePath),
+      error: error instanceof Error ? error.message : String(error),
+    });
+    throw error;
+  } finally {
+    if (fileHandle !== null) {
+      try {
+        await fileHandle.close();
+      } catch (closeError) {
+        console.warn('Failed to close file after generating fingerprint', {
+          file: sanitizePath(filePath),
+          error: closeError instanceof Error ? closeError.message : String(closeError),
+        });
+      }
+    }
+  }
+
+  return hash.digest('hex');
+}
diff --git a/src/main/utils/safe-send.ts b/src/main/utils/safe-send.ts
new file mode 100644
index 0000000..5a2f27d
--- /dev/null
+++ b/src/main/utils/safe-send.ts
@@ -0,0 +1,33 @@
+import type { BrowserWindow } from 'electron';
+
+function isObjectDestroyedError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+
+  return error.message.toLowerCase().includes('object has been destroyed');
+}
+
+export function safeSend(
+  mainWindow: BrowserWindow | null,
+  channel: string,
+  ...args: unknown[]
+): void {
+  if (!mainWindow || mainWindow.isDestroyed()) {
+    return;
+  }
+
+  const contents = mainWindow.webContents;
+  if (!contents || contents.isDestroyed()) {
+    return;
+  }
+
+  try {
+    contents.send(channel, ...args);
+  } catch (error) {
+    if (isObjectDestroyedError(error)) {
+      return;
+    }
+    throw error;
+  }
+}
diff --git a/src/preload/index.ts b/src/preload/index.ts
index 155c7dc..abbe5e0 100644
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -39,6 +39,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
     ipcRenderer.invoke('analytics:track', eventName, properties),
 
   openExternal: (url: string) => ipcRenderer.invoke('shell:openExternal', url),
+  showItemInFolder: (filePath: string) => ipcRenderer.invoke('shell:showItemInFolder', filePath),
 
   onMenuOpenFile: (callback: () => void) => {
     ipcRenderer.on('menu:openFile', () => callback());
diff --git a/src/renderer/App.css b/src/renderer/App.css
index 223cc8d..a0b7b26 100644
--- a/src/renderer/App.css
+++ b/src/renderer/App.css
@@ -97,6 +97,27 @@
   font-size: 0.9rem;
 }
 
+.queue-resume-banner {
+  padding: 12px;
+  border-radius: var(--radius-sm);
+  border: 1px solid var(--accent);
+  background: color-mix(in srgb, var(--accent) 10%, var(--surface));
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.queue-resume-banner-title {
+  margin: 0;
+  color: var(--text-primary);
+  font-size: 0.9rem;
+}
+
+.queue-resume-banner-actions {
+  display: flex;
+  gap: 8px;
+}
+
 .right-panel {
   padding: 20px;
   display: flex;
diff --git a/src/renderer/components/layout/LeftPanel/LeftPanel.tsx b/src/renderer/components/layout/LeftPanel/LeftPanel.tsx
index 8dbc9b9..af768a2 100644
--- a/src/renderer/components/layout/LeftPanel/LeftPanel.tsx
+++ b/src/renderer/components/layout/LeftPanel/LeftPanel.tsx
@@ -6,7 +6,7 @@ import { useFFmpegStatus } from '../../../hooks';
 import { TranscriptionActions } from './TranscriptionActions';
 import { ErrorMessage } from './ErrorMessage';
 import { DonationSection } from './DonationSection';
-import { SystemWarning } from '../../ui';
+import { Button, SystemWarning } from '../../ui';
 
 function LeftPanel(): React.JSX.Element {
   const {
@@ -15,11 +15,18 @@ function LeftPanel(): React.JSX.Element {
     setSettings,
     setModelDownloaded,
     queue,
+    duplicateFilesSkipped,
+    estimatedTimeRemainingSec,
+    showQueueResumePrompt,
+    restoredQueueItemsCount,
     selectedQueueItemId,
     handleFilesSelect,
     removeFromQueue,
     clearCompletedFromQueue,
+    handleRetryFailed,
     selectQueueItem,
+    dismissQueueResumePrompt,
+    resumePersistedQueue,
   } = useAppTranscription();
 
   const { isFFmpegAvailable, isChecking, recheckStatus } = useFFmpegStatus();
@@ -36,20 +43,38 @@ function LeftPanel(): React.JSX.Element {
       <FileDropZone
         onFilesSelect={handleFilesSelect}
         queueCount={queue.length}
+        duplicateFilesSkipped={duplicateFilesSkipped}
         disabled={isTranscribing}
       />
 
-      {queue.length > 0 && (
-        <FileQueue
-          queue={queue}
-          onRemove={removeFromQueue}
-          onClearCompleted={clearCompletedFromQueue}
-          onSelectItem={selectQueueItem}
-          selectedItemId={selectedQueueItemId}
-          disabled={isTranscribing}
-        />
+      {showQueueResumePrompt && restoredQueueItemsCount > 0 && (
+        <div className="queue-resume-banner" role="status" aria-live="polite">
+          <p className="queue-resume-banner-title">
+            Restored {restoredQueueItemsCount} queued file
+            {restoredQueueItemsCount === 1 ? '' : 's'} from your last session.
+          </p>
+          <div className="queue-resume-banner-actions">
+            <Button onClick={() => void resumePersistedQueue()} disabled={isTranscribing}>
+              Resume Queue
+            </Button>
+            <Button variant="ghost" onClick={dismissQueueResumePrompt} disabled={isTranscribing}>
+              Dismiss
+            </Button>
+          </div>
+        </div>
       )}
 
+      <FileQueue
+        queue={queue}
+        onRemove={removeFromQueue}
+        onClearCompleted={clearCompletedFromQueue}
+        onRetryFailed={handleRetryFailed}
+        onSelectItem={selectQueueItem}
+        selectedItemId={selectedQueueItemId}
+        estimatedTimeRemainingSec={estimatedTimeRemainingSec}
+        disabled={isTranscribing}
+      />
+
       <SettingsPanel
         settings={settings}
         onChange={setSettings}
diff --git a/src/renderer/config/__tests__/constants.test.ts b/src/renderer/config/__tests__/constants.test.ts
index d65b2b6..89be935 100644
--- a/src/renderer/config/__tests__/constants.test.ts
+++ b/src/renderer/config/__tests__/constants.test.ts
@@ -16,6 +16,9 @@ describe('config/constants', () => {
       expect(SUPPORTED_EXTENSIONS).toContain('mp3');
       expect(SUPPORTED_EXTENSIONS).toContain('wav');
       expect(SUPPORTED_EXTENSIONS).toContain('flac');
+      expect(SUPPORTED_EXTENSIONS).toContain('opus');
+      expect(SUPPORTED_EXTENSIONS).toContain('oga');
+      expect(SUPPORTED_EXTENSIONS).toContain('amr');
     });
 
     it('includes video extensions', () => {
diff --git a/src/renderer/contexts/AppContext.tsx b/src/renderer/contexts/AppContext.tsx
index b517d06..e90b84f 100644
--- a/src/renderer/contexts/AppContext.tsx
+++ b/src/renderer/contexts/AppContext.tsx
@@ -55,10 +55,17 @@ export function AppProvider({ children }: AppProviderProps): React.JSX.Element {
   const {
     queue,
     isProcessing,
+    duplicateFilesSkipped,
+    estimatedTimeRemainingSec,
+    showQueueResumePrompt,
+    restoredQueueItemsCount,
     addFiles,
     removeFile,
     clearCompleted,
+    dismissQueueResumePrompt,
+    resumePersistedQueue,
     startProcessing,
+    retryFailed,
     cancelProcessing,
     getCompletedTranscription,
   } = useBatchQueue({
@@ -101,6 +108,10 @@ export function AppProvider({ children }: AppProviderProps): React.JSX.Element {
     await startProcessing();
   }, [startProcessing]);
 
+  const handleRetryFailed = useCallback(async (): Promise<void> => {
+    await retryFailed();
+  }, [retryFailed]);
+
   const handleCancel = useCallback(async (): Promise<void> => {
     await cancelProcessing();
   }, [cancelProcessing]);
@@ -199,6 +210,10 @@ export function AppProvider({ children }: AppProviderProps): React.JSX.Element {
       transcription,
       error,
       modelDownloaded,
+      duplicateFilesSkipped,
+      estimatedTimeRemainingSec,
+      showQueueResumePrompt,
+      restoredQueueItemsCount,
       copySuccess,
       queue,
       selectedQueueItemId,
@@ -210,6 +225,10 @@ export function AppProvider({ children }: AppProviderProps): React.JSX.Element {
       transcription,
       error,
       modelDownloaded,
+      duplicateFilesSkipped,
+      estimatedTimeRemainingSec,
+      showQueueResumePrompt,
+      restoredQueueItemsCount,
       copySuccess,
       queue,
       selectedQueueItemId,
@@ -222,6 +241,7 @@ export function AppProvider({ children }: AppProviderProps): React.JSX.Element {
       setSettings,
       setModelDownloaded,
       handleTranscribe,
+      handleRetryFailed,
       handleCancel,
       handleSave,
       handleCopy: onCopy,
@@ -229,12 +249,15 @@ export function AppProvider({ children }: AppProviderProps): React.JSX.Element {
       removeFromQueue,
       clearCompletedFromQueue,
       selectQueueItem,
+      dismissQueueResumePrompt,
+      resumePersistedQueue,
     }),
     [
       setSelectedFile,
       setSettings,
       setModelDownloaded,
       handleTranscribe,
+      handleRetryFailed,
       handleCancel,
       handleSave,
       onCopy,
@@ -242,6 +265,8 @@ export function AppProvider({ children }: AppProviderProps): React.JSX.Element {
       removeFromQueue,
       clearCompletedFromQueue,
       selectQueueItem,
+      dismissQueueResumePrompt,
+      resumePersistedQueue,
     ]
   );
 
diff --git a/src/renderer/contexts/types.ts b/src/renderer/contexts/types.ts
index ec5c266..3ee9192 100644
--- a/src/renderer/contexts/types.ts
+++ b/src/renderer/contexts/types.ts
@@ -30,6 +30,10 @@ export interface TranscriptionStateContextValue {
   transcription: string;
   error: string | null;
   modelDownloaded: boolean;
+  duplicateFilesSkipped: number;
+  estimatedTimeRemainingSec: number | null;
+  showQueueResumePrompt: boolean;
+  restoredQueueItemsCount: number;
   copySuccess: boolean;
   queue: QueueItem[];
   selectedQueueItemId: string | null;
@@ -40,6 +44,7 @@ export interface TranscriptionActionsContextValue {
   setSettings: (settings: TranscriptionSettings) => void;
   setModelDownloaded: (downloaded: boolean) => void;
   handleTranscribe: () => Promise<void>;
+  handleRetryFailed: () => Promise<void>;
   handleCancel: () => Promise<void>;
   handleSave: (format?: OutputFormat) => Promise<void>;
   handleCopy: () => Promise<void>;
@@ -47,6 +52,8 @@ export interface TranscriptionActionsContextValue {
   removeFromQueue: (id: string) => void;
   clearCompletedFromQueue: () => void;
   selectQueueItem: (id: string) => void;
+  dismissQueueResumePrompt: () => void;
+  resumePersistedQueue: () => Promise<void>;
 }
 
 export interface TranscriptionContextValue
diff --git a/src/renderer/features/history/components/TranscriptionHistory/TranscriptionHistory.css b/src/renderer/features/history/components/TranscriptionHistory/TranscriptionHistory.css
index eb07318..131d359 100644
--- a/src/renderer/features/history/components/TranscriptionHistory/TranscriptionHistory.css
+++ b/src/renderer/features/history/components/TranscriptionHistory/TranscriptionHistory.css
@@ -61,6 +61,43 @@
   gap: 8px;
 }
 
+.history-search {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 10px;
+  margin-bottom: 10px;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  background: var(--surface);
+  color: var(--text-muted);
+}
+
+.history-search-input {
+  flex: 1;
+  border: none;
+  outline: none;
+  background: transparent;
+  color: var(--text-primary);
+  font-size: 0.9rem;
+}
+
+.history-search-input::placeholder {
+  color: var(--text-muted);
+}
+
+.history-search-summary {
+  font-size: 0.8rem;
+  color: var(--text-secondary);
+  margin-bottom: 10px;
+  padding: 0 2px;
+}
+
+.history-empty-search {
+  height: auto;
+  min-height: 160px;
+}
+
 .history-item {
   padding: 12px;
   background: var(--surface);
diff --git a/src/renderer/features/history/components/TranscriptionHistory/TranscriptionHistory.tsx b/src/renderer/features/history/components/TranscriptionHistory/TranscriptionHistory.tsx
index 24ceebe..dae8943 100644
--- a/src/renderer/features/history/components/TranscriptionHistory/TranscriptionHistory.tsx
+++ b/src/renderer/features/history/components/TranscriptionHistory/TranscriptionHistory.tsx
@@ -1,5 +1,12 @@
-import React, { type KeyboardEvent } from 'react';
-import { History, Trash2, X, Inbox, Clock } from 'lucide-react';
+import React, {
+  useMemo,
+  useState,
+  useEffect,
+  useRef,
+  type KeyboardEvent,
+  type ChangeEvent,
+} from 'react';
+import { History, Trash2, X, Inbox, Clock, Search } from 'lucide-react';
 import { Button } from '../../../../components/ui';
 import { formatDate, formatDuration } from '../../../../utils';
 import { getLanguageLabel } from '../../../../config';
@@ -22,12 +29,58 @@ function TranscriptionHistory({
   onSelect,
   onDelete,
 }: TranscriptionHistoryProps): React.JSX.Element {
+  const [searchQuery, setSearchQuery] = useState('');
+  const searchInputRef = useRef<HTMLInputElement>(null);
+
+  const trimmedQuery = searchQuery.trim().toLowerCase();
+  const filteredHistory = useMemo(() => {
+    if (!trimmedQuery) {
+      return history;
+    }
+
+    return history.filter((item) => {
+      const searchable = [
+        item.fileName,
+        item.preview,
+        item.fullText,
+        item.model,
+        getLanguageLabel(item.language),
+        item.format ?? '',
+      ]
+        .join(' ')
+        .toLowerCase();
+
+      return searchable.includes(trimmedQuery);
+    });
+  }, [history, trimmedQuery]);
+
+  useEffect(() => {
+    const handleKeyDown = (event: globalThis.KeyboardEvent): void => {
+      if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === 'f') {
+        event.preventDefault();
+        searchInputRef.current?.focus();
+      }
+    };
+
+    document.addEventListener('keydown', handleKeyDown);
+    return () => document.removeEventListener('keydown', handleKeyDown);
+  }, []);
+
   const handleItemKeyDown = (e: KeyboardEvent<HTMLDivElement>, item: HistoryItem): void => {
     if (e.key === 'Enter') {
       onSelect(item);
     }
   };
 
+  const handleSearchChange = (event: ChangeEvent<HTMLInputElement>): void => {
+    setSearchQuery(event.target.value);
+  };
+
+  const handleSearchClear = (): void => {
+    setSearchQuery('');
+    searchInputRef.current?.focus();
+  };
+
   const handleDelete = (event: React.MouseEvent, itemId: string, fileName: string): void => {
     event.stopPropagation();
     if (window.confirm(`Are you sure you want to delete the transcription for "${fileName}"?`)) {
@@ -74,44 +127,83 @@ function TranscriptionHistory({
             <span className="empty-hint">Your transcription history will appear here</span>
           </div>
         ) : (
-          <div className="history-list">
-            {history.map((item) => (
-              <div
-                key={item.id}
-                className="history-item"
-                onClick={() => onSelect(item)}
-                role="button"
-                tabIndex={0}
-                onKeyDown={(e) => handleItemKeyDown(e, item)}
-              >
-                <div className="history-item-header">
-                  <span className="history-filename">{item.fileName}</span>
-                  <div className="history-item-header-actions">
-                    <span className="history-date">{formatDate(item.date)}</span>
-                    <Button
-                      variant="ghost"
-                      size="sm"
-                      icon={<Trash2 size={14} />}
-                      iconOnly
-                      onClick={(event) => handleDelete(event, item.id, item.fileName)}
-                      title="Delete transcription"
-                      aria-label={`Delete ${item.fileName}`}
-                      className="history-item-delete"
-                    />
+          <>
+            <div className="history-search">
+              <Search size={16} aria-hidden="true" />
+              <input
+                ref={searchInputRef}
+                type="text"
+                className="history-search-input"
+                value={searchQuery}
+                onChange={handleSearchChange}
+                placeholder="Search history (file name, transcript, model, language)"
+                aria-label="Search history"
+              />
+              {searchQuery && (
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  icon={<X size={14} />}
+                  iconOnly
+                  onClick={handleSearchClear}
+                  title="Clear history search"
+                  aria-label="Clear history search"
+                />
+              )}
+            </div>
+
+            {trimmedQuery && (
+              <div className="history-search-summary">
+                {filteredHistory.length} result{filteredHistory.length === 1 ? '' : 's'}
+              </div>
+            )}
+
+            {filteredHistory.length === 0 ? (
+              <div className="history-empty history-empty-search">
+                <span>No matches found</span>
+                <span className="empty-hint">Try different keywords</span>
+              </div>
+            ) : (
+              <div className="history-list">
+                {filteredHistory.map((item) => (
+                  <div
+                    key={item.id}
+                    className="history-item"
+                    onClick={() => onSelect(item)}
+                    role="button"
+                    tabIndex={0}
+                    onKeyDown={(e) => handleItemKeyDown(e, item)}
+                  >
+                    <div className="history-item-header">
+                      <span className="history-filename">{item.fileName}</span>
+                      <div className="history-item-header-actions">
+                        <span className="history-date">{formatDate(item.date)}</span>
+                        <Button
+                          variant="ghost"
+                          size="sm"
+                          icon={<Trash2 size={14} />}
+                          iconOnly
+                          onClick={(event) => handleDelete(event, item.id, item.fileName)}
+                          title="Delete transcription"
+                          aria-label={`Delete ${item.fileName}`}
+                          className="history-item-delete"
+                        />
+                      </div>
+                    </div>
+                    <div className="history-item-meta">
+                      <span className="history-tag">{item.model}</span>
+                      <span className="history-tag">{getLanguageLabel(item.language)}</span>
+                      {item.format && <span className="history-tag">.{item.format}</span>}
+                      <span className="history-duration">
+                        <Clock size={12} aria-hidden="true" /> {formatDuration(item.duration)}
+                      </span>
+                    </div>
+                    <p className="history-preview">{item.preview}</p>
                   </div>
-                </div>
-                <div className="history-item-meta">
-                  <span className="history-tag">{item.model}</span>
-                  <span className="history-tag">{getLanguageLabel(item.language)}</span>
-                  {item.format && <span className="history-tag">.{item.format}</span>}
-                  <span className="history-duration">
-                    <Clock size={12} aria-hidden="true" /> {formatDuration(item.duration)}
-                  </span>
-                </div>
-                <p className="history-preview">{item.preview}</p>
+                ))}
               </div>
-            ))}
-          </div>
+            )}
+          </>
         )}
       </div>
     </div>
diff --git a/src/renderer/features/history/components/TranscriptionHistory/__tests__/TranscriptionHistory.test.tsx b/src/renderer/features/history/components/TranscriptionHistory/__tests__/TranscriptionHistory.test.tsx
index c400432..a2c12cb 100644
--- a/src/renderer/features/history/components/TranscriptionHistory/__tests__/TranscriptionHistory.test.tsx
+++ b/src/renderer/features/history/components/TranscriptionHistory/__tests__/TranscriptionHistory.test.tsx
@@ -50,6 +50,123 @@ describe('TranscriptionHistory component', () => {
     expect(onSelect).toHaveBeenCalledWith(mockHistoryItem);
   });
 
+  it('filters history items by transcript content and file name', () => {
+    const onClear = vi.fn();
+    const onClose = vi.fn();
+    const onSelect = vi.fn();
+    const onDelete = vi.fn();
+    const firstItem = createMockHistoryItem({
+      id: 'history-1',
+      fileName: 'finance-report.mp3',
+      fullText: 'Quarterly earnings increased by twelve percent',
+      preview: 'Quarterly earnings increased...',
+    });
+    const secondItem = createMockHistoryItem({
+      id: 'history-2',
+      fileName: 'meeting-notes.mp3',
+      fullText: 'Team retrospective and sprint planning notes',
+      preview: 'Team retrospective...',
+    });
+
+    render(
+      <TranscriptionHistory
+        history={[firstItem, secondItem]}
+        onClear={onClear}
+        onClose={onClose}
+        onSelect={onSelect}
+        onDelete={onDelete}
+      />
+    );
+
+    const searchInput = screen.getByLabelText('Search history');
+    fireEvent.change(searchInput, { target: { value: 'earnings' } });
+
+    expect(screen.getByText('finance-report.mp3')).toBeInTheDocument();
+    expect(screen.queryByText('meeting-notes.mp3')).not.toBeInTheDocument();
+
+    fireEvent.change(searchInput, { target: { value: 'meeting-notes' } });
+
+    expect(screen.getByText('meeting-notes.mp3')).toBeInTheDocument();
+    expect(screen.queryByText('finance-report.mp3')).not.toBeInTheDocument();
+  });
+
+  it('shows empty search state when there are no matching history items', () => {
+    const onClear = vi.fn();
+    const onClose = vi.fn();
+    const onSelect = vi.fn();
+    const onDelete = vi.fn();
+    const historyItem = createMockHistoryItem({
+      id: 'history-1',
+      fullText: 'The quick brown fox',
+      preview: 'The quick brown fox...',
+    });
+
+    render(
+      <TranscriptionHistory
+        history={[historyItem]}
+        onClear={onClear}
+        onClose={onClose}
+        onSelect={onSelect}
+        onDelete={onDelete}
+      />
+    );
+
+    fireEvent.change(screen.getByLabelText('Search history'), { target: { value: 'not found' } });
+
+    expect(screen.getByText('No matches found')).toBeInTheDocument();
+    expect(screen.getByText('0 results')).toBeInTheDocument();
+  });
+
+  it('clears the search query when clear search button is clicked', () => {
+    const onClear = vi.fn();
+    const onClose = vi.fn();
+    const onSelect = vi.fn();
+    const onDelete = vi.fn();
+    const historyItem = createMockHistoryItem({
+      id: 'history-1',
+      fullText: 'alpha beta gamma',
+      preview: 'alpha beta gamma',
+    });
+
+    render(
+      <TranscriptionHistory
+        history={[historyItem]}
+        onClear={onClear}
+        onClose={onClose}
+        onSelect={onSelect}
+        onDelete={onDelete}
+      />
+    );
+
+    const searchInput = screen.getByLabelText('Search history') as HTMLInputElement;
+    fireEvent.change(searchInput, { target: { value: 'alpha' } });
+    expect(searchInput.value).toBe('alpha');
+
+    fireEvent.click(screen.getByLabelText('Clear history search'));
+    expect(searchInput.value).toBe('');
+  });
+
+  it('focuses search input with keyboard shortcut', () => {
+    const onClear = vi.fn();
+    const onClose = vi.fn();
+    const onSelect = vi.fn();
+    const onDelete = vi.fn();
+    const historyItem = createMockHistoryItem();
+
+    render(
+      <TranscriptionHistory
+        history={[historyItem]}
+        onClear={onClear}
+        onClose={onClose}
+        onSelect={onSelect}
+        onDelete={onDelete}
+      />
+    );
+
+    fireEvent.keyDown(document, { key: 'f', ctrlKey: true });
+    expect(screen.getByLabelText('Search history')).toHaveFocus();
+  });
+
   it('calls onSelect on Enter key press', () => {
     const mockHistoryItem = createMockHistoryItem();
     const onClear = vi.fn();
diff --git a/src/renderer/features/settings/components/SettingsPanel/__tests__/SettingsPanel.test.tsx b/src/renderer/features/settings/components/SettingsPanel/__tests__/SettingsPanel.test.tsx
index 9ec44b1..1b41601 100644
--- a/src/renderer/features/settings/components/SettingsPanel/__tests__/SettingsPanel.test.tsx
+++ b/src/renderer/features/settings/components/SettingsPanel/__tests__/SettingsPanel.test.tsx
@@ -422,6 +422,10 @@ describe('SettingsPanel', () => {
     });
 
     const modelSelect = screen.getByLabelText('Select Whisper model') as HTMLSelectElement;
+    await waitFor(() => {
+      expect(modelSelect).not.toBeDisabled();
+    });
+
     fireEvent.change(modelSelect, { target: { value: 'small' } });
 
     await waitFor(() => {
diff --git a/src/renderer/features/transcription/__tests__/useBatchQueue.test.ts b/src/renderer/features/transcription/__tests__/useBatchQueue.test.ts
index d10c7d6..02a76c2 100644
--- a/src/renderer/features/transcription/__tests__/useBatchQueue.test.ts
+++ b/src/renderer/features/transcription/__tests__/useBatchQueue.test.ts
@@ -1,5 +1,5 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { renderHook, act, waitFor } from '@testing-library/react';
 import { useBatchQueue } from '../hooks/useBatchQueue';
 import { overrideElectronAPI } from '@/test/utils';
 import type {
@@ -8,8 +8,12 @@ import type {
   TranscriptionResult,
   TranscriptionProgress,
 } from '@/types';
+import { logger } from '@/services/logger';
 
 describe('useBatchQueue', () => {
+  const originalNotification = globalThis.Notification;
+  const QUEUE_STORAGE_KEY = 'whisperdesk_queue';
+
   const mockSettings: TranscriptionSettings = {
     model: 'base',
     language: 'en',
@@ -18,14 +22,19 @@ describe('useBatchQueue', () => {
   const mockOnHistoryAdd = vi.fn();
   const mockOnFirstComplete = vi.fn();
 
-  const createMockSelectedFile = (name: string): SelectedFile => ({
+  const createMockSelectedFile = (
+    name: string,
+    overrides: Partial<SelectedFile> = {}
+  ): SelectedFile => ({
     name,
     path: `/path/to/${name}`,
     size: 1024,
+    ...overrides,
   });
 
   beforeEach(() => {
     vi.clearAllMocks();
+    localStorage.clear();
     overrideElectronAPI({
       startTranscription: vi.fn().mockResolvedValue({
         success: true,
@@ -38,6 +47,40 @@ describe('useBatchQueue', () => {
     });
   });
 
+  afterEach(() => {
+    if (originalNotification) {
+      Object.defineProperty(globalThis, 'Notification', {
+        configurable: true,
+        writable: true,
+        value: originalNotification,
+      });
+    } else {
+      Reflect.deleteProperty(globalThis, 'Notification');
+    }
+  });
+
+  const mockNotificationApi = (permission: NotificationPermission = 'granted') => {
+    const notificationSpy = vi.fn();
+    const requestPermissionSpy = vi.fn().mockResolvedValue(permission);
+
+    class MockNotification {
+      static permission: NotificationPermission = permission;
+      static requestPermission = requestPermissionSpy;
+
+      constructor(title: string, options?: NotificationOptions) {
+        notificationSpy({ title, options });
+      }
+    }
+
+    Object.defineProperty(globalThis, 'Notification', {
+      configurable: true,
+      writable: true,
+      value: MockNotification,
+    });
+
+    return { notificationSpy, requestPermissionSpy };
+  };
+
   describe('initialization', () => {
     it('should initialize with empty queue', () => {
       const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
@@ -45,6 +88,69 @@ describe('useBatchQueue', () => {
       expect(result.current.queue).toEqual([]);
       expect(result.current.isProcessing).toBe(false);
       expect(result.current.currentItemId).toBe(null);
+      expect(result.current.estimatedTimeRemainingSec).toBeNull();
+      expect(result.current.showQueueResumePrompt).toBe(false);
+      expect(result.current.restoredQueueItemsCount).toBe(0);
+    });
+
+    it('should restore persisted queue and normalize processing items to pending', () => {
+      localStorage.setItem(
+        QUEUE_STORAGE_KEY,
+        JSON.stringify([
+          {
+            id: 'pending-1',
+            file: { name: 'pending.mp3', path: '/path/to/pending.mp3', size: 1024 },
+            status: 'pending',
+          },
+          {
+            id: 'processing-1',
+            file: { name: 'processing.mp3', path: '/path/to/processing.mp3' },
+            status: 'processing',
+          },
+          {
+            id: 'error-1',
+            file: { name: 'error.mp3', path: '/path/to/error.mp3' },
+            status: 'error',
+            error: 'Failed previously',
+          },
+          {
+            id: 'invalid-1',
+            file: { name: 'invalid.mp3', path: '/path/to/invalid.mp3' },
+            status: 'completed',
+          },
+        ])
+      );
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      expect(result.current.queue).toHaveLength(3);
+      expect(result.current.queue[0]).toMatchObject({
+        id: 'pending-1',
+        status: 'pending',
+        progress: { percent: 0, status: '' },
+      });
+      expect(result.current.queue[1]).toMatchObject({
+        id: 'processing-1',
+        status: 'pending',
+        progress: { percent: 0, status: '' },
+      });
+      expect(result.current.queue[2]).toMatchObject({
+        id: 'error-1',
+        status: 'error',
+        error: 'Failed previously',
+      });
+      expect(result.current.showQueueResumePrompt).toBe(true);
+      expect(result.current.restoredQueueItemsCount).toBe(3);
+    });
+
+    it('should ignore corrupted persisted queue data', () => {
+      localStorage.setItem(QUEUE_STORAGE_KEY, 'not-json');
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      expect(result.current.queue).toEqual([]);
+      expect(result.current.showQueueResumePrompt).toBe(false);
+      expect(result.current.restoredQueueItemsCount).toBe(0);
     });
   });
 
@@ -76,6 +182,98 @@ describe('useBatchQueue', () => {
       const ids = result.current.queue.map((item) => item.id);
       expect(new Set(ids).size).toBe(2);
     });
+
+    it('should skip duplicate file paths and expose skipped count', () => {
+      const warnSpy = vi.spyOn(logger, 'warn');
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      const duplicateFile = createMockSelectedFile('audio1.mp3');
+      const newFile = createMockSelectedFile('audio2.mp3');
+
+      act(() => {
+        result.current.addFiles([duplicateFile]);
+      });
+
+      expect(result.current.queue).toHaveLength(1);
+      expect(result.current.duplicateFilesSkipped).toBe(0);
+
+      act(() => {
+        result.current.addFiles([duplicateFile, newFile, duplicateFile]);
+      });
+
+      expect(result.current.queue).toHaveLength(2);
+      expect(result.current.queue[0]!.file.path).toBe('/path/to/audio1.mp3');
+      expect(result.current.queue[1]!.file.path).toBe('/path/to/audio2.mp3');
+      expect(result.current.duplicateFilesSkipped).toBe(2);
+      expect(warnSpy).toHaveBeenCalledWith('Skipped duplicate files in batch queue', {
+        count: 2,
+        files: ['audio1.mp3', 'audio1.mp3'],
+      });
+    });
+
+    it('should detect duplicates against restored queue before effects run', () => {
+      localStorage.setItem(
+        QUEUE_STORAGE_KEY,
+        JSON.stringify([
+          {
+            id: 'restored-1',
+            file: { name: 'audio1.mp3', path: '/path/to/audio1.mp3', size: 1024 },
+            status: 'pending',
+          },
+        ])
+      );
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      expect(result.current.queue).toHaveLength(1);
+      expect(result.current.duplicateFilesSkipped).toBe(1);
+    });
+
+    it('should skip content duplicates using fingerprint even with different file paths', () => {
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      const fingerprint = 'shared-fingerprint';
+      const originalFile = createMockSelectedFile('audio1.mp3', {
+        path: '/desktop/audio1.mp3',
+        fingerprint,
+      });
+      const copiedFile = createMockSelectedFile('audio1 copy.mp3', {
+        path: '/desktop/audio1 copy.mp3',
+        fingerprint,
+      });
+
+      act(() => {
+        result.current.addFiles([originalFile, copiedFile]);
+      });
+
+      expect(result.current.queue).toHaveLength(1);
+      expect(result.current.queue[0]!.file.path).toBe('/desktop/audio1.mp3');
+      expect(result.current.duplicateFilesSkipped).toBe(1);
+    });
+
+    it('should reset duplicate count when no duplicates are skipped', () => {
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      expect(result.current.duplicateFilesSkipped).toBe(1);
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio2.mp3')]);
+      });
+
+      expect(result.current.duplicateFilesSkipped).toBe(0);
+    });
   });
 
   describe('removeFile', () => {
@@ -98,6 +296,31 @@ describe('useBatchQueue', () => {
       expect(result.current.queue).toHaveLength(1);
       expect(result.current.queue[0]!.file.name).toBe('audio2.mp3');
     });
+
+    it('should clear duplicate skipped badge count when queue becomes empty', async () => {
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      expect(result.current.duplicateFilesSkipped).toBe(1);
+
+      const idToRemove = result.current.queue[0]!.id;
+      act(() => {
+        result.current.removeFile(idToRemove);
+      });
+
+      expect(result.current.queue).toHaveLength(0);
+
+      await waitFor(() => {
+        expect(result.current.duplicateFilesSkipped).toBe(0);
+      });
+    });
   });
 
   describe('clearCompleted', () => {
@@ -139,6 +362,176 @@ describe('useBatchQueue', () => {
 
       expect(result.current.queue).toHaveLength(0);
     });
+
+    it('should not clear items while processing', async () => {
+      const warnSpy = vi.spyOn(logger, 'warn');
+      const pendingPromise = new Promise(() => {});
+
+      overrideElectronAPI({
+        startTranscription: vi.fn().mockReturnValue(pendingPromise),
+        onTranscriptionProgress: vi.fn().mockReturnValue(() => {}),
+      });
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      act(() => {
+        result.current.startProcessing();
+      });
+
+      expect(result.current.isProcessing).toBe(true);
+
+      act(() => {
+        result.current.clearAll();
+      });
+
+      expect(result.current.queue).toHaveLength(1);
+      expect(warnSpy).toHaveBeenCalledWith('Cannot clear queue while processing');
+    });
+  });
+
+  describe('queue persistence and resume', () => {
+    it('should persist resumable queue items to localStorage', () => {
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      const saved = JSON.parse(localStorage.getItem(QUEUE_STORAGE_KEY) || '[]');
+      expect(saved).toHaveLength(1);
+      expect(saved[0]).toMatchObject({
+        file: {
+          name: 'audio1.mp3',
+          path: '/path/to/audio1.mp3',
+        },
+        status: 'pending',
+      });
+    });
+
+    it('should clear persisted queue when all items are completed', async () => {
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      expect(localStorage.getItem(QUEUE_STORAGE_KEY)).not.toBeNull();
+
+      await act(async () => {
+        await result.current.startProcessing();
+      });
+
+      expect(localStorage.getItem(QUEUE_STORAGE_KEY)).toBeNull();
+    });
+
+    it('should dismiss resume prompt without changing restored queue', () => {
+      localStorage.setItem(
+        QUEUE_STORAGE_KEY,
+        JSON.stringify([
+          {
+            id: 'restored-1',
+            file: { name: 'restored.mp3', path: '/path/to/restored.mp3' },
+            status: 'pending',
+          },
+        ])
+      );
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      expect(result.current.showQueueResumePrompt).toBe(true);
+      expect(result.current.queue).toHaveLength(1);
+
+      act(() => {
+        result.current.dismissQueueResumePrompt();
+      });
+
+      expect(result.current.showQueueResumePrompt).toBe(false);
+      expect(result.current.restoredQueueItemsCount).toBe(0);
+      expect(result.current.queue).toHaveLength(1);
+    });
+
+    it('should resume restored queue and hide resume prompt', async () => {
+      localStorage.setItem(
+        QUEUE_STORAGE_KEY,
+        JSON.stringify([
+          {
+            id: 'restored-1',
+            file: { name: 'restored.mp3', path: '/path/to/restored.mp3' },
+            status: 'pending',
+          },
+        ])
+      );
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      expect(result.current.showQueueResumePrompt).toBe(true);
+
+      await act(async () => {
+        await result.current.resumePersistedQueue();
+      });
+
+      expect(result.current.showQueueResumePrompt).toBe(false);
+      expect(result.current.restoredQueueItemsCount).toBe(0);
+      expect(result.current.queue[0]!.status).toBe('completed');
+    });
+
+    it('should not persist queue again on progress-only updates', async () => {
+      let progressCallback: ((progress: TranscriptionProgress) => void) | undefined;
+      let resolveTranscription: ((value: TranscriptionResult) => void) | undefined;
+
+      overrideElectronAPI({
+        startTranscription: vi.fn().mockImplementation(
+          () =>
+            new Promise<TranscriptionResult>((resolve) => {
+              resolveTranscription = resolve;
+            })
+        ),
+        cancelTranscription: vi.fn().mockResolvedValue({ success: true }),
+        onTranscriptionProgress: vi.fn().mockImplementation((callback) => {
+          progressCallback = callback;
+          return () => {};
+        }),
+      });
+
+      const setItemSpy = vi.spyOn(Storage.prototype, 'setItem');
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      act(() => {
+        void result.current.startProcessing();
+      });
+
+      await waitFor(() => {
+        expect(result.current.isProcessing).toBe(true);
+      });
+
+      const writesBeforeProgress = setItemSpy.mock.calls.length;
+
+      act(() => {
+        progressCallback?.({ percent: 15, status: 'Transcribing... 15%' });
+        progressCallback?.({ percent: 32, status: 'Transcribing... 32%' });
+        progressCallback?.({ percent: 58, status: 'Transcribing... 58%' });
+      });
+
+      await waitFor(() => {
+        expect(setItemSpy).toHaveBeenCalledTimes(writesBeforeProgress);
+      });
+
+      act(() => {
+        resolveTranscription?.({ success: true, text: 'Transcribed text' });
+      });
+
+      await waitFor(() => {
+        expect(result.current.isProcessing).toBe(false);
+      });
+    });
   });
 
   describe('startProcessing', () => {
@@ -218,18 +611,12 @@ describe('useBatchQueue', () => {
     });
 
     it('should not start if already processing', async () => {
+      let resolveTranscription: ((value: TranscriptionResult) => void) | undefined;
       const startTranscriptionMock = vi.fn().mockImplementation(
         () =>
-          new Promise((resolve) =>
-            setTimeout(
-              () =>
-                resolve({
-                  success: true,
-                  text: 'text',
-                }),
-              100
-            )
-          )
+          new Promise<TranscriptionResult>((resolve) => {
+            resolveTranscription = resolve;
+          })
       );
 
       overrideElectronAPI({
@@ -240,14 +627,12 @@ describe('useBatchQueue', () => {
       const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
 
       act(() => {
-        result.current.addFiles([
-          createMockSelectedFile('audio1.mp3'),
-          createMockSelectedFile('audio2.mp3'),
-        ]);
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
       });
 
+      let processingPromise: Promise<void>;
       act(() => {
-        result.current.startProcessing();
+        processingPromise = result.current.startProcessing();
       });
 
       expect(result.current.isProcessing).toBe(true);
@@ -257,6 +642,11 @@ describe('useBatchQueue', () => {
       });
 
       expect(startTranscriptionMock).toHaveBeenCalledTimes(1);
+
+      await act(async () => {
+        resolveTranscription?.({ success: true, text: 'text' });
+        await processingPromise;
+      });
     });
 
     it('should handle transcription errors', async () => {
@@ -282,6 +672,31 @@ describe('useBatchQueue', () => {
       expect(result.current.queue[0]!.error).toBe('Transcription failed');
     });
 
+    it('should map FFmpeg no-audio errors to a friendly message', async () => {
+      overrideElectronAPI({
+        startTranscription: vi.fn().mockResolvedValue({
+          success: false,
+          error: 'FFmpeg conversion failed: Output file does not contain any stream',
+        }),
+        onTranscriptionProgress: vi.fn().mockReturnValue(() => {}),
+      });
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('video-only.mov')]);
+      });
+
+      await act(async () => {
+        await result.current.startProcessing();
+      });
+
+      expect(result.current.queue[0]!.status).toBe('error');
+      expect(result.current.queue[0]!.error).toBe(
+        'No audio track found in this file. Please choose a file that contains audio.'
+      );
+    });
+
     it('should handle cancelled result from transcription', async () => {
       overrideElectronAPI({
         startTranscription: vi.fn().mockResolvedValue({
@@ -356,6 +771,109 @@ describe('useBatchQueue', () => {
 
       expect(result.current.isProcessing).toBe(false);
     });
+
+    it('should expose estimated time remaining while processing subsequent items', async () => {
+      let now = 1000;
+      const nowSpy = vi.spyOn(Date, 'now').mockImplementation(() => now);
+
+      let resolveSecond: ((value: TranscriptionResult) => void) | undefined;
+      const startTranscriptionMock = vi
+        .fn()
+        .mockImplementationOnce(async () => {
+          now = 6000;
+          return { success: true, text: 'first' };
+        })
+        .mockImplementationOnce(
+          () =>
+            new Promise<TranscriptionResult>((resolve) => {
+              resolveSecond = resolve;
+            })
+        );
+
+      overrideElectronAPI({
+        startTranscription: startTranscriptionMock,
+        onTranscriptionProgress: vi.fn().mockReturnValue(() => {}),
+      });
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([
+          createMockSelectedFile('audio1.mp3'),
+          createMockSelectedFile('audio2.mp3'),
+        ]);
+      });
+
+      let processingPromise: Promise<void>;
+      act(() => {
+        processingPromise = result.current.startProcessing();
+      });
+
+      await waitFor(() => {
+        expect(result.current.estimatedTimeRemainingSec).toBe(5);
+      });
+
+      await act(async () => {
+        now = 11000;
+        resolveSecond?.({ success: true, text: 'second' });
+        await processingPromise;
+      });
+
+      expect(result.current.estimatedTimeRemainingSec).toBeNull();
+      nowSpy.mockRestore();
+    });
+
+    it('should estimate remaining time from current item progress before first completion', async () => {
+      let now = 1000;
+      const nowSpy = vi.spyOn(Date, 'now').mockImplementation(() => now);
+
+      let progressCb: ((progress: TranscriptionProgress) => void) | undefined;
+      let resolveTranscription: ((value: TranscriptionResult) => void) | undefined;
+
+      overrideElectronAPI({
+        startTranscription: vi.fn().mockImplementation(
+          () =>
+            new Promise<TranscriptionResult>((resolve) => {
+              resolveTranscription = resolve;
+            })
+        ),
+        onTranscriptionProgress: (cb) => {
+          progressCb = cb;
+          return () => {};
+        },
+      });
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([
+          createMockSelectedFile('audio1.mp3'),
+          createMockSelectedFile('audio2.mp3'),
+          createMockSelectedFile('audio3.mp3'),
+        ]);
+      });
+
+      let processingPromise: Promise<void>;
+      act(() => {
+        processingPromise = result.current.startProcessing();
+      });
+
+      act(() => {
+        now = 2000;
+        progressCb?.({ percent: 50, status: 'Halfway' });
+      });
+
+      expect(result.current.estimatedTimeRemainingSec).toBe(5);
+
+      await act(async () => {
+        now = 3000;
+        resolveTranscription?.({ success: true, text: 'done' });
+        await result.current.cancelProcessing();
+        await processingPromise;
+      });
+
+      nowSpy.mockRestore();
+    });
   });
 
   describe('cancelProcessing', () => {
@@ -480,6 +998,76 @@ describe('useBatchQueue', () => {
 
       expect(result.current.queue[0]!.status).toBe('completed');
     });
+
+    it('should retry only failed and cancelled items', async () => {
+      const startTranscriptionMock = vi
+        .fn()
+        .mockResolvedValueOnce({ success: false, error: 'First failed' })
+        .mockResolvedValueOnce({ success: true, cancelled: true })
+        .mockResolvedValueOnce({ success: true, text: 'third-complete' })
+        .mockResolvedValueOnce({ success: true, text: 'retry-first' })
+        .mockResolvedValueOnce({ success: true, text: 'retry-second' });
+
+      overrideElectronAPI({
+        startTranscription: startTranscriptionMock,
+        onTranscriptionProgress: vi.fn().mockReturnValue(() => {}),
+      });
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([
+          createMockSelectedFile('audio1.mp3'),
+          createMockSelectedFile('audio2.mp3'),
+          createMockSelectedFile('audio3.mp3'),
+        ]);
+      });
+
+      await act(async () => {
+        await result.current.startProcessing();
+      });
+
+      expect(result.current.queue[0]!.status).toBe('error');
+      expect(result.current.queue[1]!.status).toBe('cancelled');
+      expect(result.current.queue[2]!.status).toBe('completed');
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio4.mp3')]);
+      });
+
+      expect(result.current.queue[3]!.status).toBe('pending');
+
+      await act(async () => {
+        await result.current.retryFailed();
+      });
+
+      expect(startTranscriptionMock).toHaveBeenCalledTimes(5);
+      expect(result.current.queue[0]!.status).toBe('completed');
+      expect(result.current.queue[1]!.status).toBe('completed');
+      expect(result.current.queue[2]!.status).toBe('completed');
+      expect(result.current.queue[3]!.status).toBe('pending');
+    });
+
+    it('should not retry pending items when using retryFailed', async () => {
+      const startTranscriptionMock = vi.fn().mockResolvedValue({ success: true, text: 'text' });
+      overrideElectronAPI({
+        startTranscription: startTranscriptionMock,
+        onTranscriptionProgress: vi.fn().mockReturnValue(() => {}),
+      });
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      await act(async () => {
+        await result.current.retryFailed();
+      });
+
+      expect(startTranscriptionMock).not.toHaveBeenCalled();
+      expect(result.current.queue[0]!.status).toBe('pending');
+    });
   });
 
   describe('progress and cancellation flow', () => {
@@ -570,4 +1158,172 @@ describe('useBatchQueue', () => {
       expect(result.current.queue[1]!.status).toBe('cancelled');
     });
   });
+
+  describe('completion notifications', () => {
+    it('should notify once when processing completes and permission is granted', async () => {
+      const { notificationSpy } = mockNotificationApi('granted');
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([
+          createMockSelectedFile('audio1.mp3'),
+          createMockSelectedFile('audio2.mp3'),
+        ]);
+      });
+
+      await act(async () => {
+        await result.current.startProcessing();
+      });
+
+      expect(notificationSpy).toHaveBeenCalledTimes(1);
+      expect(notificationSpy).toHaveBeenCalledWith({
+        title: 'Batch transcription complete',
+        options: { body: '2 completed' },
+      });
+    });
+
+    it('should request permission and notify when permission starts as default', async () => {
+      const { notificationSpy, requestPermissionSpy } = mockNotificationApi('default');
+      requestPermissionSpy.mockResolvedValueOnce('granted');
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      await act(async () => {
+        await result.current.startProcessing();
+      });
+
+      await waitFor(() => {
+        expect(requestPermissionSpy).toHaveBeenCalledTimes(1);
+        expect(notificationSpy).toHaveBeenCalledWith({
+          title: 'Transcription complete',
+          options: { body: '1 completed' },
+        });
+      });
+    });
+
+    it('should not notify if permission is denied after requesting', async () => {
+      const { notificationSpy, requestPermissionSpy } = mockNotificationApi('default');
+      requestPermissionSpy.mockResolvedValueOnce('denied');
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      await act(async () => {
+        await result.current.startProcessing();
+      });
+
+      await waitFor(() => {
+        expect(requestPermissionSpy).toHaveBeenCalledTimes(1);
+      });
+      expect(notificationSpy).not.toHaveBeenCalled();
+    });
+
+    it('should not notify when processing was cancelled', async () => {
+      const { notificationSpy } = mockNotificationApi('granted');
+      let resolveTranscription: ((value: TranscriptionResult) => void) | undefined;
+
+      overrideElectronAPI({
+        startTranscription: vi.fn().mockImplementation(
+          () =>
+            new Promise<TranscriptionResult>((resolve) => {
+              resolveTranscription = resolve;
+            })
+        ),
+        cancelTranscription: vi.fn().mockResolvedValue({ success: true }),
+        onTranscriptionProgress: vi.fn().mockReturnValue(() => {}),
+      });
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      let processingPromise: Promise<void>;
+      act(() => {
+        processingPromise = result.current.startProcessing();
+      });
+
+      await act(async () => {
+        await result.current.cancelProcessing();
+      });
+
+      await act(async () => {
+        resolveTranscription?.({ success: true, text: 'Done' });
+        await processingPromise;
+      });
+
+      expect(notificationSpy).not.toHaveBeenCalled();
+    });
+
+    it('should log warning when notification creation throws', async () => {
+      const requestPermissionSpy = vi.fn().mockResolvedValue('granted');
+
+      class MockNotification {
+        static permission: NotificationPermission = 'granted';
+        static requestPermission = requestPermissionSpy;
+
+        constructor() {
+          throw new Error('constructor failed');
+        }
+      }
+
+      Object.defineProperty(globalThis, 'Notification', {
+        configurable: true,
+        writable: true,
+        value: MockNotification,
+      });
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      await act(async () => {
+        await result.current.startProcessing();
+      });
+
+      expect(logger.warn).toHaveBeenCalledWith('Failed to create completion notification', {
+        error: 'constructor failed',
+      });
+    });
+
+    it('should log warning when notification permission lookup throws', async () => {
+      class MockNotification {
+        static get permission(): NotificationPermission {
+          throw new Error('permission failed');
+        }
+
+        static requestPermission = vi.fn().mockResolvedValue('granted');
+
+        constructor() {}
+      }
+
+      Object.defineProperty(globalThis, 'Notification', {
+        configurable: true,
+        writable: true,
+        value: MockNotification,
+      });
+
+      const { result } = renderHook(() => useBatchQueue({ settings: mockSettings }));
+      act(() => {
+        result.current.addFiles([createMockSelectedFile('audio1.mp3')]);
+      });
+
+      await act(async () => {
+        await result.current.startProcessing();
+      });
+
+      expect(logger.warn).toHaveBeenCalledWith('Failed to show completion notification', {
+        error: 'permission failed',
+      });
+    });
+  });
 });
diff --git a/src/renderer/features/transcription/__tests__/useTranscription.test.ts b/src/renderer/features/transcription/__tests__/useTranscription.test.ts
index 82fbbaf..7d4c21c 100644
--- a/src/renderer/features/transcription/__tests__/useTranscription.test.ts
+++ b/src/renderer/features/transcription/__tests__/useTranscription.test.ts
@@ -3,6 +3,7 @@ import { renderHook, act } from '@testing-library/react';
 import { useTranscription } from '@/features/transcription';
 import { overrideElectronAPI } from '@/test/utils';
 import { createMockFile } from '@/test/fixtures';
+import { logger } from '@/services/logger';
 
 describe('useTranscription', () => {
   beforeEach(() => {
@@ -71,8 +72,11 @@ describe('useTranscription', () => {
     const mockSaveFile = vi
       .fn()
       .mockResolvedValue({ success: true, filePath: '/path/to/saved.vtt' });
+    const mockShowItemInFolder = vi.fn().mockResolvedValue({ success: true });
+    const confirmSpy = vi.spyOn(window, 'confirm').mockReturnValue(false);
     overrideElectronAPI({
       saveFile: mockSaveFile,
+      showItemInFolder: mockShowItemInFolder,
     });
 
     const { result } = renderHook(() => useTranscription());
@@ -91,7 +95,97 @@ describe('useTranscription', () => {
       content: 'Test transcription',
       format: 'vtt',
     });
+    expect(mockShowItemInFolder).not.toHaveBeenCalled();
     expect(result.current.error).toBeNull();
+    confirmSpy.mockRestore();
+  });
+
+  it('should reveal saved file in Finder when confirmed', async () => {
+    const mockSaveFile = vi
+      .fn()
+      .mockResolvedValue({ success: true, filePath: '/path/to/saved.vtt' });
+    const mockShowItemInFolder = vi.fn().mockResolvedValue({ success: true });
+    const confirmSpy = vi.spyOn(window, 'confirm').mockReturnValue(true);
+
+    overrideElectronAPI({
+      saveFile: mockSaveFile,
+      showItemInFolder: mockShowItemInFolder,
+    });
+
+    const { result } = renderHook(() => useTranscription());
+
+    act(() => {
+      result.current.setSelectedFile(mockFile);
+      result.current.setTranscription('Test transcription');
+    });
+
+    await act(async () => {
+      await result.current.handleSave('vtt');
+    });
+
+    expect(mockShowItemInFolder).toHaveBeenCalledWith('/path/to/saved.vtt');
+    confirmSpy.mockRestore();
+  });
+
+  it('should log warning when revealing saved file fails', async () => {
+    const mockSaveFile = vi
+      .fn()
+      .mockResolvedValue({ success: true, filePath: '/path/to/saved.vtt' });
+    const mockShowItemInFolder = vi
+      .fn()
+      .mockResolvedValue({ success: false, error: 'No handler registered' });
+    const confirmSpy = vi.spyOn(window, 'confirm').mockReturnValue(true);
+
+    overrideElectronAPI({
+      saveFile: mockSaveFile,
+      showItemInFolder: mockShowItemInFolder,
+    });
+
+    const { result } = renderHook(() => useTranscription());
+
+    act(() => {
+      result.current.setSelectedFile(mockFile);
+      result.current.setTranscription('Test transcription');
+    });
+
+    await act(async () => {
+      await result.current.handleSave('vtt');
+    });
+
+    expect(logger.warn).toHaveBeenCalledWith('Failed to reveal saved file in Finder', {
+      path: 'saved.vtt',
+      error: 'No handler registered',
+    });
+    confirmSpy.mockRestore();
+  });
+
+  it('should skip reveal when confirm throws', async () => {
+    const mockSaveFile = vi
+      .fn()
+      .mockResolvedValue({ success: true, filePath: '/path/to/saved.vtt' });
+    const mockShowItemInFolder = vi.fn().mockResolvedValue({ success: true });
+    const confirmSpy = vi.spyOn(window, 'confirm').mockImplementation(() => {
+      throw new Error('confirm unavailable');
+    });
+
+    overrideElectronAPI({
+      saveFile: mockSaveFile,
+      showItemInFolder: mockShowItemInFolder,
+    });
+
+    const { result } = renderHook(() => useTranscription());
+
+    act(() => {
+      result.current.setSelectedFile(mockFile);
+      result.current.setTranscription('Test transcription');
+    });
+
+    await act(async () => {
+      await result.current.handleSave('vtt');
+    });
+
+    expect(mockShowItemInFolder).not.toHaveBeenCalled();
+    confirmSpy.mockRestore();
   });
 
   it('should handle save file error', async () => {
diff --git a/src/renderer/features/transcription/components/FileDropZone/FileDropZone.css b/src/renderer/features/transcription/components/FileDropZone/FileDropZone.css
index d9e3377..96aeece 100644
--- a/src/renderer/features/transcription/components/FileDropZone/FileDropZone.css
+++ b/src/renderer/features/transcription/components/FileDropZone/FileDropZone.css
@@ -78,3 +78,14 @@
   font-weight: 500;
   color: var(--accent);
 }
+
+.dropzone-duplicate-badge {
+  margin-top: 8px;
+  padding: 4px 10px;
+  background: var(--warning-light);
+  border: 1px solid var(--warning);
+  border-radius: 12px;
+  font-size: 0.7rem;
+  font-weight: 500;
+  color: var(--warning-dark);
+}
diff --git a/src/renderer/features/transcription/components/FileDropZone/FileDropZone.tsx b/src/renderer/features/transcription/components/FileDropZone/FileDropZone.tsx
index 304760d..0c87602 100644
--- a/src/renderer/features/transcription/components/FileDropZone/FileDropZone.tsx
+++ b/src/renderer/features/transcription/components/FileDropZone/FileDropZone.tsx
@@ -8,12 +8,14 @@ import './FileDropZone.css';
 export interface FileDropZoneProps {
   onFilesSelect: (files: SelectedFile[]) => void;
   queueCount?: number;
+  duplicateFilesSkipped?: number;
   disabled: boolean;
 }
 
 function FileDropZone({
   onFilesSelect,
   queueCount = 0,
+  duplicateFilesSkipped = 0,
   disabled,
 }: FileDropZoneProps): React.JSX.Element {
   const handleClick = async (): Promise<void> => {
@@ -78,10 +80,18 @@ function FileDropZone({
         <Files size={40} className="dropzone-icon-svg" />
         <span className="dropzone-text">Drop audio/video files here</span>
         <span className="dropzone-subtext">or click to browse (multiple files)</span>
-        <span className="dropzone-formats">MP3, WAV, M4A, FLAC, OGG, MP4, MOV, AVI, MKV, WEBM</span>
+        <span className="dropzone-formats">
+          MP3, WAV, M4A, FLAC, OGG, OPUS, OGA, AMR, MP4, MOV, AVI, MKV, WEBM
+        </span>
         {queueCount > 0 && (
           <span className="dropzone-queue-badge">{queueCount} files in queue</span>
         )}
+        {duplicateFilesSkipped > 0 && (
+          <span className="dropzone-duplicate-badge" role="status" aria-live="polite">
+            Skipped {duplicateFilesSkipped} duplicate file
+            {duplicateFilesSkipped > 1 ? 's' : ''}
+          </span>
+        )}
       </div>
     </div>
   );
diff --git a/src/renderer/features/transcription/components/FileDropZone/__tests__/FileDropZone.test.tsx b/src/renderer/features/transcription/components/FileDropZone/__tests__/FileDropZone.test.tsx
index 881e7e0..cbc3f3f 100644
--- a/src/renderer/features/transcription/components/FileDropZone/__tests__/FileDropZone.test.tsx
+++ b/src/renderer/features/transcription/components/FileDropZone/__tests__/FileDropZone.test.tsx
@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { render, screen, fireEvent, waitFor, createEvent } from '@testing-library/react';
 import { FileDropZone } from '@/features/transcription';
 import { overrideElectronAPI } from '@/test/utils';
 import { createMockFile } from '@/test/fixtures';
@@ -16,6 +16,7 @@ describe('FileDropZone', () => {
 
     expect(screen.getByText(/Drop audio\/video files here/i)).toBeInTheDocument();
     expect(screen.getByText(/multiple files/i)).toBeInTheDocument();
+    expect(screen.getByText(/OPUS/i)).toBeInTheDocument();
   });
 
   it('should be clickable and open multiple files dialog', async () => {
@@ -75,6 +76,37 @@ describe('FileDropZone', () => {
     });
   });
 
+  it('should accept .opus files on drop', async () => {
+    overrideElectronAPI({
+      getPathForFile: vi.fn().mockReturnValue('/path/to/voice-note.opus'),
+      getFileInfo: vi.fn().mockResolvedValue({
+        name: 'voice-note.opus',
+        path: '/path/to/voice-note.opus',
+        size: 1024,
+      }),
+    });
+
+    render(<FileDropZone onFilesSelect={onFilesSelect} disabled={false} />);
+
+    const dropzone = screen.getByRole('button');
+    const file = createMockFile({ name: 'voice-note.opus' });
+
+    fireEvent.drop(dropzone, {
+      dataTransfer: {
+        files: [file],
+      },
+    });
+
+    await waitFor(() => {
+      expect(onFilesSelect).toHaveBeenCalledWith([
+        expect.objectContaining({
+          name: 'voice-note.opus',
+          path: '/path/to/voice-note.opus',
+        }),
+      ]);
+    });
+  });
+
   it('should filter out invalid files', async () => {
     overrideElectronAPI({
       openMultipleFiles: vi.fn().mockResolvedValue(['/path/to/test.txt']),
@@ -102,12 +134,61 @@ describe('FileDropZone', () => {
     expect(window.electronAPI?.openMultipleFiles).not.toHaveBeenCalled();
   });
 
+  it('should prevent default on drag over', () => {
+    render(<FileDropZone onFilesSelect={onFilesSelect} disabled={false} />);
+
+    const dropzone = screen.getByRole('button');
+    const event = createEvent.dragOver(dropzone);
+    const preventDefaultSpy = vi.spyOn(event, 'preventDefault');
+    fireEvent(dropzone, event);
+
+    expect(preventDefaultSpy).toHaveBeenCalled();
+  });
+
+  it('should open file dialog on Enter key', async () => {
+    overrideElectronAPI({
+      openMultipleFiles: vi.fn().mockResolvedValue(['/path/to/test1.mp3']),
+      getFileInfo: vi.fn().mockResolvedValue({
+        name: 'test1.mp3',
+        path: '/path/to/test1.mp3',
+        size: 1024,
+      }),
+    });
+
+    render(<FileDropZone onFilesSelect={onFilesSelect} disabled={false} />);
+    const dropzone = screen.getByRole('button');
+
+    fireEvent.keyDown(dropzone, { key: 'Enter' });
+
+    await waitFor(() => {
+      expect(window.electronAPI?.openMultipleFiles).toHaveBeenCalled();
+      expect(onFilesSelect).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  it('should ignore non-activation keys', () => {
+    render(<FileDropZone onFilesSelect={onFilesSelect} disabled={false} />);
+    const dropzone = screen.getByRole('button');
+
+    fireEvent.keyDown(dropzone, { key: 'ArrowDown' });
+
+    expect(window.electronAPI?.openMultipleFiles).not.toHaveBeenCalled();
+  });
+
   it('should show queue count badge', () => {
     render(<FileDropZone onFilesSelect={onFilesSelect} disabled={false} queueCount={3} />);
 
     expect(screen.getByText('3 files in queue')).toBeInTheDocument();
   });
 
+  it('should show duplicate files skipped badge', () => {
+    render(
+      <FileDropZone onFilesSelect={onFilesSelect} disabled={false} duplicateFilesSkipped={2} />
+    );
+
+    expect(screen.getByText('Skipped 2 duplicate files')).toBeInTheDocument();
+  });
+
   it('should handle multiple files drop', async () => {
     overrideElectronAPI({
       getPathForFile: vi.fn((file) => `/path/to/${file.name}`),
diff --git a/src/renderer/features/transcription/components/FileQueue/FileQueue.css b/src/renderer/features/transcription/components/FileQueue/FileQueue.css
index 5ac1d73..63c1a48 100644
--- a/src/renderer/features/transcription/components/FileQueue/FileQueue.css
+++ b/src/renderer/features/transcription/components/FileQueue/FileQueue.css
@@ -2,7 +2,7 @@
   background: var(--surface, #1a1a1f);
   border: 1px solid var(--border, rgba(255, 255, 255, 0.1));
   border-radius: var(--radius, 8px);
-  margin-top: 12px;
+  margin-top: 10px;
   display: flex;
   flex-direction: column;
 }
@@ -26,6 +26,12 @@
   gap: 6px;
 }
 
+.file-queue-header-actions {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
 .file-queue-list {
   min-height: 44px;
   max-height: 200px;
@@ -172,6 +178,22 @@
   opacity: 1;
 }
 
+.file-queue-toast {
+  margin: 8px 12px 0;
+  padding: 8px 10px;
+  border-radius: 6px;
+  border: 1px solid var(--warning, #b45309);
+  background: var(--warning-light, rgba(245, 158, 11, 0.12));
+  color: var(--warning, #b45309);
+  font-size: 0.72rem;
+  line-height: 1.3;
+}
+
+.file-queue.file-queue-toast-only {
+  background: transparent;
+  border: none;
+}
+
 .file-queue-summary {
   display: flex;
   gap: 12px;
@@ -192,6 +214,10 @@
   color: var(--danger);
 }
 
+.file-queue-summary span.eta {
+  color: var(--accent);
+}
+
 .file-queue-summary span.hint {
   color: var(--accent);
   font-style: italic;
diff --git a/src/renderer/features/transcription/components/FileQueue/FileQueue.tsx b/src/renderer/features/transcription/components/FileQueue/FileQueue.tsx
index ee78764..a14b2f4 100644
--- a/src/renderer/features/transcription/components/FileQueue/FileQueue.tsx
+++ b/src/renderer/features/transcription/components/FileQueue/FileQueue.tsx
@@ -1,19 +1,24 @@
-import React from 'react';
-import { CheckCircle, Loader, Clock, XCircle, Slash, X, Trash2 } from 'lucide-react';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { CheckCircle, Loader, Clock, XCircle, Slash, X, Trash2, RotateCcw } from 'lucide-react';
 import { Button } from '../../../../components/ui';
 import { formatFileSize } from '../../../../utils';
 import type { QueueItem, QueueItemStatus } from '../../../../types';
+import { toUserFriendlyTranscriptionError } from '../../utils/errorMessages';
 import './FileQueue.css';
 
 export interface FileQueueProps {
   queue: QueueItem[];
   onRemove: (id: string) => void;
   onClearCompleted: () => void;
+  onRetryFailed: () => void;
   onSelectItem?: (id: string) => void;
   selectedItemId?: string | null;
+  estimatedTimeRemainingSec?: number | null;
   disabled?: boolean;
 }
 
+const REMOVE_ERROR_TOAST_DURATION_MS = 5000;
+
 function getStatusIcon(status: QueueItemStatus): React.ReactNode {
   switch (status) {
     case 'completed':
@@ -31,50 +36,127 @@ function getStatusIcon(status: QueueItemStatus): React.ReactNode {
   }
 }
 
+function formatEstimatedTime(seconds: number): string {
+  const totalSeconds = Math.max(0, Math.round(seconds));
+  if (totalSeconds < 60) {
+    return `${totalSeconds}s`;
+  }
+
+  if (totalSeconds < 3600) {
+    const minutes = Math.floor(totalSeconds / 60);
+    const remainingSeconds = totalSeconds % 60;
+    return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+  }
+
+  const hours = Math.floor(totalSeconds / 3600);
+  const remainingMinutes = Math.floor((totalSeconds % 3600) / 60);
+  return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+}
+
 function FileQueue({
   queue,
   onRemove,
   onClearCompleted,
+  onRetryFailed,
   onSelectItem,
   selectedItemId,
+  estimatedTimeRemainingSec = null,
   disabled = false,
 }: FileQueueProps): React.JSX.Element | null {
-  if (queue.length === 0) {
+  const [removeErrorToastMessage, setRemoveErrorToastMessage] = useState<string | null>(null);
+  const removeErrorToastTimeoutRef = useRef<number | null>(null);
+
+  const clearRemoveErrorToastTimer = useCallback(() => {
+    if (removeErrorToastTimeoutRef.current === null) {
+      return;
+    }
+    window.clearTimeout(removeErrorToastTimeoutRef.current);
+    removeErrorToastTimeoutRef.current = null;
+  }, []);
+
+  const showRemoveErrorToast = useCallback(
+    (message: string) => {
+      clearRemoveErrorToastTimer();
+      setRemoveErrorToastMessage(message);
+      removeErrorToastTimeoutRef.current = window.setTimeout(() => {
+        setRemoveErrorToastMessage(null);
+        removeErrorToastTimeoutRef.current = null;
+      }, REMOVE_ERROR_TOAST_DURATION_MS);
+    },
+    [clearRemoveErrorToastTimer]
+  );
+
+  useEffect(() => clearRemoveErrorToastTimer, [clearRemoveErrorToastTimer]);
+
+  if (queue.length === 0 && !removeErrorToastMessage) {
     return null;
   }
 
+  if (queue.length === 0) {
+    return (
+      <div className="file-queue file-queue-toast-only">
+        <div className="file-queue-toast" role="status" aria-live="polite">
+          {removeErrorToastMessage}
+        </div>
+      </div>
+    );
+  }
+
   const completedCount = queue.filter((item) => item.status === 'completed').length;
   const processingCount = queue.filter((item) => item.status === 'processing').length;
   const pendingCount = queue.filter((item) => item.status === 'pending').length;
   const errorCount = queue.filter((item) => item.status === 'error').length;
+  const cancelledCount = queue.filter((item) => item.status === 'cancelled').length;
+  const retryCount = errorCount + cancelledCount;
+  const hasRetryItems = retryCount > 0;
   const hasCompletedItems = completedCount > 0 || queue.some((item) => item.status === 'cancelled');
 
   const handleItemClick = (id: string): void => {
     onSelectItem?.(id);
   };
 
-  const handleRemoveClick = (e: React.MouseEvent, id: string, isProcessing: boolean): void => {
+  const handleRemoveClick = (e: React.MouseEvent, item: QueueItem): void => {
     e.stopPropagation();
-    if (disabled || isProcessing) return;
-    onRemove(id);
+    if (disabled || item.status === 'processing') return;
+
+    if (item.status === 'error' && item.error) {
+      const friendlyError = toUserFriendlyTranscriptionError(item.error);
+      showRemoveErrorToast(`Removed failed item: ${friendlyError}`);
+    }
+
+    onRemove(item.id);
   };
 
   return (
     <div className="file-queue">
       <div className="file-queue-header">
         <span className="file-queue-title">FILES ({queue.length})</span>
-        {hasCompletedItems && (
-          <Button
-            variant="ghost"
-            size="sm"
-            icon={<Trash2 size={14} />}
-            onClick={onClearCompleted}
-            disabled={disabled}
-            title="Clear completed"
-          >
-            Clear
-          </Button>
-        )}
+        <div className="file-queue-header-actions">
+          {hasRetryItems && (
+            <Button
+              variant="ghost"
+              size="sm"
+              icon={<RotateCcw size={14} />}
+              onClick={onRetryFailed}
+              disabled={disabled}
+              title="Retry failed and cancelled items"
+            >
+              Retry Failed
+            </Button>
+          )}
+          {hasCompletedItems && (
+            <Button
+              variant="ghost"
+              size="sm"
+              icon={<Trash2 size={14} />}
+              onClick={onClearCompleted}
+              disabled={disabled}
+              title="Clear completed"
+            >
+              Clear
+            </Button>
+          )}
+        </div>
       </div>
 
       <div className="file-queue-list">
@@ -104,7 +186,12 @@ function FileQueue({
                 </div>
               )}
               {item.status === 'error' && item.error && (
-                <span className="file-queue-item-error">{item.error}</span>
+                <span
+                  className="file-queue-item-error"
+                  title={toUserFriendlyTranscriptionError(item.error)}
+                >
+                  {toUserFriendlyTranscriptionError(item.error)}
+                </span>
               )}
             </div>
             <div className="file-queue-item-meta">
@@ -120,7 +207,7 @@ function FileQueue({
               size="sm"
               icon={<X size={14} />}
               iconOnly
-              onClick={(e) => handleRemoveClick(e, item.id, item.status === 'processing')}
+              onClick={(e) => handleRemoveClick(e, item)}
               disabled={disabled || item.status === 'processing'}
               title="Remove from queue"
               aria-label={`Remove ${item.file.name} from queue`}
@@ -130,9 +217,23 @@ function FileQueue({
         ))}
       </div>
 
+      {removeErrorToastMessage && (
+        <div className="file-queue-toast" role="status" aria-live="polite">
+          {removeErrorToastMessage}
+        </div>
+      )}
+
       <div className="file-queue-summary">
         {completedCount > 0 && <span>{completedCount} completed</span>}
         {processingCount > 0 && <span>{processingCount} processing</span>}
+        {processingCount > 0 && (
+          <span className="eta">
+            ETA{' '}
+            {typeof estimatedTimeRemainingSec === 'number'
+              ? formatEstimatedTime(estimatedTimeRemainingSec)
+              : 'calculating...'}
+          </span>
+        )}
         {pendingCount > 0 && <span>{pendingCount} pending</span>}
         {errorCount > 0 && <span className="error">{errorCount} failed</span>}
         {completedCount > 0 && !processingCount && (
diff --git a/src/renderer/features/transcription/components/FileQueue/__tests__/FileQueue.test.tsx b/src/renderer/features/transcription/components/FileQueue/__tests__/FileQueue.test.tsx
index a051715..49eb0a1 100644
--- a/src/renderer/features/transcription/components/FileQueue/__tests__/FileQueue.test.tsx
+++ b/src/renderer/features/transcription/components/FileQueue/__tests__/FileQueue.test.tsx
@@ -1,5 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
 import { render, screen, fireEvent } from '@testing-library/react';
+import { useState } from 'react';
 import { FileQueue } from '../FileQueue';
 import type { QueueItem } from '@/types';
 
@@ -20,6 +21,7 @@ describe('FileQueue', () => {
     queue: [createMockQueueItem()],
     onRemove: vi.fn(),
     onClearCompleted: vi.fn(),
+    onRetryFailed: vi.fn(),
     onSelectItem: vi.fn(),
     selectedItemId: null,
     disabled: false,
@@ -113,6 +115,39 @@ describe('FileQueue', () => {
       render(<FileQueue {...defaultProps} queue={queue} />);
       expect(screen.getByText('Transcription failed')).toBeInTheDocument();
     });
+
+    it('should display a friendly message for FFmpeg files without audio tracks', () => {
+      const queue = [
+        createMockQueueItem({
+          status: 'error',
+          error: 'FFmpeg conversion failed: Output file does not contain any stream',
+        }),
+      ];
+      render(<FileQueue {...defaultProps} queue={queue} />);
+      expect(
+        screen.getByText(
+          'No audio track found in this file. Please choose a file that contains audio.'
+        )
+      ).toBeInTheDocument();
+    });
+
+    it('should expose full error text on hover tooltip', () => {
+      const queue = [
+        createMockQueueItem({
+          status: 'error',
+          error: 'FFmpeg conversion failed: Output file does not contain any stream',
+        }),
+      ];
+      render(<FileQueue {...defaultProps} queue={queue} />);
+
+      const error = screen.getByText(
+        'No audio track found in this file. Please choose a file that contains audio.'
+      );
+      expect(error).toHaveAttribute(
+        'title',
+        'No audio track found in this file. Please choose a file that contains audio.'
+      );
+    });
   });
 
   describe('interactions', () => {
@@ -133,6 +168,62 @@ describe('FileQueue', () => {
       expect(onRemove).toHaveBeenCalledWith('item-1');
     });
 
+    it('should show a toast with friendly error when removing a failed item', () => {
+      const onRemove = vi.fn();
+      const queue = [
+        createMockQueueItem({
+          status: 'error',
+          error: 'FFmpeg conversion failed: Output file does not contain any stream',
+        }),
+      ];
+      render(<FileQueue {...defaultProps} queue={queue} onRemove={onRemove} />);
+
+      const removeButton = screen.getByLabelText('Remove audio.mp3 from queue');
+      fireEvent.click(removeButton);
+
+      expect(onRemove).toHaveBeenCalledWith('item-1');
+      expect(
+        screen.getByText(
+          'Removed failed item: No audio track found in this file. Please choose a file that contains audio.'
+        )
+      ).toBeInTheDocument();
+    });
+
+    it('should keep toast visible when removing the only failed item', () => {
+      const queue = [
+        createMockQueueItem({
+          status: 'error',
+          error: 'FFmpeg conversion failed: Output file does not contain any stream',
+        }),
+      ];
+
+      const Wrapper = () => {
+        const [items, setItems] = useState(queue);
+
+        return (
+          <FileQueue
+            queue={items}
+            onRemove={(id) => setItems((prev) => prev.filter((item) => item.id !== id))}
+            onClearCompleted={vi.fn()}
+            onRetryFailed={vi.fn()}
+            onSelectItem={vi.fn()}
+            selectedItemId={null}
+          />
+        );
+      };
+
+      render(<Wrapper />);
+
+      fireEvent.click(screen.getByLabelText('Remove audio.mp3 from queue'));
+
+      expect(
+        screen.getByText(
+          'Removed failed item: No audio track found in this file. Please choose a file that contains audio.'
+        )
+      ).toBeInTheDocument();
+      expect(screen.queryByText('FILES (1)')).not.toBeInTheDocument();
+    });
+
     it('should not call onRemove when disabled', () => {
       const onRemove = vi.fn();
       render(<FileQueue {...defaultProps} onRemove={onRemove} disabled={true} />);
@@ -171,6 +262,35 @@ describe('FileQueue', () => {
     });
   });
 
+  describe('retry failed button', () => {
+    it('should show retry button when there are failed items', () => {
+      const queue = [createMockQueueItem({ status: 'error', error: 'Failed' })];
+      render(<FileQueue {...defaultProps} queue={queue} />);
+      expect(screen.getByText('Retry Failed')).toBeInTheDocument();
+    });
+
+    it('should show retry button when there are cancelled items', () => {
+      const queue = [createMockQueueItem({ status: 'cancelled' })];
+      render(<FileQueue {...defaultProps} queue={queue} />);
+      expect(screen.getByText('Retry Failed')).toBeInTheDocument();
+    });
+
+    it('should not show retry button when there are no failed or cancelled items', () => {
+      const queue = [createMockQueueItem({ status: 'pending' })];
+      render(<FileQueue {...defaultProps} queue={queue} />);
+      expect(screen.queryByText('Retry Failed')).not.toBeInTheDocument();
+    });
+
+    it('should call onRetryFailed when clicking retry button', () => {
+      const onRetryFailed = vi.fn();
+      const queue = [createMockQueueItem({ status: 'error', error: 'Failed' })];
+      render(<FileQueue {...defaultProps} queue={queue} onRetryFailed={onRetryFailed} />);
+
+      fireEvent.click(screen.getByText('Retry Failed'));
+      expect(onRetryFailed).toHaveBeenCalled();
+    });
+  });
+
   describe('summary', () => {
     it('should show completed count', () => {
       const queue = [
@@ -197,6 +317,48 @@ describe('FileQueue', () => {
       expect(screen.getByText('1 processing')).toBeInTheDocument();
     });
 
+    it('should show eta in seconds for short remaining time', () => {
+      const queue = [createMockQueueItem({ status: 'processing' })];
+      render(<FileQueue {...defaultProps} queue={queue} estimatedTimeRemainingSec={45} />);
+      expect(screen.getByText('ETA 45s')).toBeInTheDocument();
+    });
+
+    it('should show eta in minutes and seconds', () => {
+      const queue = [createMockQueueItem({ status: 'processing' })];
+      render(<FileQueue {...defaultProps} queue={queue} estimatedTimeRemainingSec={90} />);
+      expect(screen.getByText('ETA 1m 30s')).toBeInTheDocument();
+    });
+
+    it('should show eta in whole minutes when no remaining seconds', () => {
+      const queue = [createMockQueueItem({ status: 'processing' })];
+      render(<FileQueue {...defaultProps} queue={queue} estimatedTimeRemainingSec={120} />);
+      expect(screen.getByText('ETA 2m')).toBeInTheDocument();
+    });
+
+    it('should show eta in hours when needed', () => {
+      const queue = [createMockQueueItem({ status: 'processing' })];
+      render(<FileQueue {...defaultProps} queue={queue} estimatedTimeRemainingSec={7200} />);
+      expect(screen.getByText('ETA 2h')).toBeInTheDocument();
+    });
+
+    it('should show eta in hours and minutes when needed', () => {
+      const queue = [createMockQueueItem({ status: 'processing' })];
+      render(<FileQueue {...defaultProps} queue={queue} estimatedTimeRemainingSec={7260} />);
+      expect(screen.getByText('ETA 2h 1m')).toBeInTheDocument();
+    });
+
+    it('should show eta as calculating while processing if estimate is not ready', () => {
+      const queue = [createMockQueueItem({ status: 'processing' })];
+      render(<FileQueue {...defaultProps} queue={queue} estimatedTimeRemainingSec={null} />);
+      expect(screen.getByText('ETA calculating...')).toBeInTheDocument();
+    });
+
+    it('should not show eta when no items are processing', () => {
+      const queue = [createMockQueueItem({ status: 'pending' })];
+      render(<FileQueue {...defaultProps} queue={queue} estimatedTimeRemainingSec={45} />);
+      expect(screen.queryByText(/ETA/)).not.toBeInTheDocument();
+    });
+
     it('should show failed count', () => {
       const queue = [createMockQueueItem({ status: 'error', error: 'Failed' })];
       render(<FileQueue {...defaultProps} queue={queue} />);
diff --git a/src/renderer/features/transcription/hooks/useBatchQueue.ts b/src/renderer/features/transcription/hooks/useBatchQueue.ts
index 3fabfa1..753c05d 100644
--- a/src/renderer/features/transcription/hooks/useBatchQueue.ts
+++ b/src/renderer/features/transcription/hooks/useBatchQueue.ts
@@ -12,7 +12,9 @@ import {
   onTranscriptionProgress,
 } from '../../../services/electronAPI';
 import { logger } from '../../../services/logger';
+import { STORAGE_KEYS } from '../../../utils/storage';
 import { sanitizePath } from '../../../../shared/utils';
+import { toUserFriendlyTranscriptionError } from '../utils/errorMessages';
 
 interface UseBatchQueueOptions {
   settings: TranscriptionSettings;
@@ -24,13 +26,20 @@ interface UseBatchQueueReturn {
   queue: QueueItem[];
   isProcessing: boolean;
   currentItemId: string | null;
+  duplicateFilesSkipped: number;
+  estimatedTimeRemainingSec: number | null;
+  showQueueResumePrompt: boolean;
+  restoredQueueItemsCount: number;
 
   addFiles: (files: SelectedFile[]) => void;
   removeFile: (id: string) => void;
   clearCompleted: () => void;
   clearAll: () => void;
+  dismissQueueResumePrompt: () => void;
+  resumePersistedQueue: () => Promise<void>;
 
   startProcessing: () => Promise<void>;
+  retryFailed: () => Promise<void>;
   cancelProcessing: () => Promise<void>;
 
   getCompletedTranscription: (id: string) => string | undefined;
@@ -40,16 +49,242 @@ function generateId(): string {
   return crypto.randomUUID();
 }
 
+function getFileIdentityKey(file: SelectedFile): string {
+  if (file.fingerprint) {
+    return `fingerprint:${file.fingerprint}`;
+  }
+  return `path:${file.path}`;
+}
+
+type PersistedQueueStatus = Extract<
+  QueueItemStatus,
+  'pending' | 'processing' | 'error' | 'cancelled'
+>;
+
+interface PersistedQueueItem {
+  id: string;
+  file: SelectedFile;
+  status: PersistedQueueStatus;
+  error?: string;
+}
+
+const QUEUE_STORAGE_KEY = STORAGE_KEYS.QUEUE;
+
+function isPersistedQueueStatus(status: unknown): status is PersistedQueueStatus {
+  return (
+    status === 'pending' || status === 'processing' || status === 'error' || status === 'cancelled'
+  );
+}
+
+function toQueueItem(item: PersistedQueueItem): QueueItem {
+  const status: QueueItemStatus = item.status === 'processing' ? 'pending' : item.status;
+  return {
+    id: item.id,
+    file: item.file,
+    status,
+    progress: { percent: 0, status: '' },
+    error:
+      status === 'error' && item.error ? toUserFriendlyTranscriptionError(item.error) : undefined,
+  };
+}
+
+function loadPersistedQueue(): QueueItem[] {
+  try {
+    const savedQueue = localStorage.getItem(QUEUE_STORAGE_KEY);
+    if (!savedQueue) {
+      return [];
+    }
+
+    const parsedQueue: unknown = JSON.parse(savedQueue);
+    if (!Array.isArray(parsedQueue)) {
+      return [];
+    }
+
+    return parsedQueue.reduce<QueueItem[]>((items, rawItem) => {
+      if (!rawItem || typeof rawItem !== 'object') {
+        return items;
+      }
+
+      const candidate = rawItem as Partial<PersistedQueueItem>;
+      if (typeof candidate.id !== 'string' || !isPersistedQueueStatus(candidate.status)) {
+        return items;
+      }
+
+      const file = candidate.file;
+      if (
+        !file ||
+        typeof file !== 'object' ||
+        typeof file.name !== 'string' ||
+        typeof file.path !== 'string'
+      ) {
+        return items;
+      }
+
+      const normalizedFile: SelectedFile = {
+        name: file.name,
+        path: file.path,
+        size: typeof file.size === 'number' ? file.size : undefined,
+        fingerprint: typeof file.fingerprint === 'string' ? file.fingerprint : undefined,
+      };
+
+      items.push(
+        toQueueItem({
+          id: candidate.id,
+          file: normalizedFile,
+          status: candidate.status,
+          error: typeof candidate.error === 'string' ? candidate.error : undefined,
+        })
+      );
+      return items;
+    }, []);
+  } catch {
+    return [];
+  }
+}
+
+function getResumableQueueItems(queue: QueueItem[]): PersistedQueueItem[] {
+  return queue.reduce<PersistedQueueItem[]>((items, item) => {
+    if (item.status === 'completed') {
+      return items;
+    }
+
+    items.push({
+      id: item.id,
+      file: {
+        name: item.file.name,
+        path: item.file.path,
+        size: item.file.size,
+        fingerprint: item.file.fingerprint,
+      },
+      status: item.status,
+      error: item.status === 'error' ? item.error : undefined,
+    });
+
+    return items;
+  }, []);
+}
+
+function persistQueueSnapshot(resumableItems: PersistedQueueItem[]): void {
+  try {
+    if (resumableItems.length === 0) {
+      localStorage.removeItem(QUEUE_STORAGE_KEY);
+      return;
+    }
+
+    localStorage.setItem(QUEUE_STORAGE_KEY, JSON.stringify(resumableItems));
+  } catch (error) {
+    logger.error('Failed to persist batch queue:', error);
+  }
+}
+
+function showBatchCompletionNotification(items: QueueItem[]): void {
+  if (typeof Notification === 'undefined' || items.length === 0) {
+    return;
+  }
+
+  const completedCount = items.filter((item) => item.status === 'completed').length;
+  const failedCount = items.filter((item) => item.status === 'error').length;
+  const cancelledCount = items.filter((item) => item.status === 'cancelled').length;
+
+  const title = items.length > 1 ? 'Batch transcription complete' : 'Transcription complete';
+  const summaryParts: string[] = [];
+
+  if (completedCount > 0) summaryParts.push(`${completedCount} completed`);
+  if (failedCount > 0) summaryParts.push(`${failedCount} failed`);
+  if (cancelledCount > 0) summaryParts.push(`${cancelledCount} cancelled`);
+
+  const body = summaryParts.length > 0 ? summaryParts.join(' • ') : `${items.length} processed`;
+
+  const notify = (): void => {
+    try {
+      new Notification(title, { body });
+    } catch (error) {
+      logger.warn('Failed to create completion notification', {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  };
+
+  try {
+    if (Notification.permission === 'granted') {
+      notify();
+      return;
+    }
+
+    if (Notification.permission === 'default') {
+      void Notification.requestPermission()
+        .then((permission) => {
+          if (permission === 'granted') {
+            notify();
+          }
+        })
+        .catch(() => {});
+    }
+  } catch (error) {
+    logger.warn('Failed to show completion notification', {
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+}
+
 export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueReturn {
   const { settings, onHistoryAdd, onFirstComplete } = options;
 
-  const [queue, setQueue] = useState<QueueItem[]>([]);
+  const [queue, setQueue] = useState<QueueItem[]>(() => loadPersistedQueue());
   const [isProcessing, setIsProcessing] = useState(false);
   const [currentItemId, setCurrentItemId] = useState<string | null>(null);
+  const [duplicateFilesSkipped, setDuplicateFilesSkipped] = useState(0);
+  const [estimatedTimeRemainingSec, setEstimatedTimeRemainingSec] = useState<number | null>(null);
+  const [showQueueResumePrompt, setShowQueueResumePrompt] = useState(false);
+  const [restoredQueueItemsCount, setRestoredQueueItemsCount] = useState(0);
 
   const isCancelledRef = useRef(false);
   const hasCalledFirstCompleteRef = useRef(false);
   const progressUnsubscribeRef = useRef<(() => void) | null>(null);
+  const queueRef = useRef<QueueItem[]>(queue);
+  const initialQueueLengthRef = useRef(queue.length);
+  const shouldPersistQueueRef = useRef(true);
+  const lastPersistedQueueSnapshotRef = useRef<string | null>(null);
+  const activeRunItemIdsRef = useRef<Set<string>>(new Set());
+  const currentItemStartTimeRef = useRef<number | null>(null);
+  const remainingPendingCountRef = useRef(0);
+
+  useEffect(() => {
+    const restoredCount = initialQueueLengthRef.current;
+    if (restoredCount > 0) {
+      setShowQueueResumePrompt(true);
+      setRestoredQueueItemsCount(restoredCount);
+    }
+  }, []);
+
+  useEffect(() => {
+    // Always keep the latest queue in ref for add/remove calculations.
+    queueRef.current = queue;
+
+    // Persist only for structural/status changes, not progress ticks.
+    if (!shouldPersistQueueRef.current) {
+      return;
+    }
+    shouldPersistQueueRef.current = false;
+
+    const resumableItems = getResumableQueueItems(queue);
+
+    const currentSnapshot = JSON.stringify(resumableItems);
+    if (currentSnapshot === lastPersistedQueueSnapshotRef.current) {
+      return;
+    }
+
+    lastPersistedQueueSnapshotRef.current = currentSnapshot;
+    persistQueueSnapshot(resumableItems);
+  }, [queue]);
+
+  useEffect(() => {
+    if (queue.length === 0) {
+      setShowQueueResumePrompt(false);
+      setRestoredQueueItemsCount(0);
+      setDuplicateFilesSkipped(0);
+    }
+  }, [queue.length]);
 
   useEffect(() => {
     return () => {
@@ -61,27 +296,54 @@ export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueRetur
   }, []);
 
   const addFiles = useCallback((files: SelectedFile[]) => {
-    const newItems: QueueItem[] = files.map((file) => ({
-      id: generateId(),
-      file,
-      status: 'pending' as QueueItemStatus,
-      progress: { percent: 0, status: '' },
-    }));
-
-    setQueue((prev) => [...prev, ...newItems]);
-
-    logger.info('Added files to batch queue', {
-      count: files.length,
-      files: files.map((f) => f.name),
-    });
+    const existingKeys = new Set(queueRef.current.map((item) => getFileIdentityKey(item.file)));
+    const duplicateFiles: SelectedFile[] = [];
+
+    const newItems: QueueItem[] = files.reduce<QueueItem[]>((items, file) => {
+      const identityKey = getFileIdentityKey(file);
+      if (existingKeys.has(identityKey)) {
+        duplicateFiles.push(file);
+        return items;
+      }
+
+      existingKeys.add(identityKey);
+      items.push({
+        id: generateId(),
+        file,
+        status: 'pending' as QueueItemStatus,
+        progress: { percent: 0, status: '' },
+      });
+      return items;
+    }, []);
+
+    if (newItems.length > 0) {
+      shouldPersistQueueRef.current = true;
+      queueRef.current = [...queueRef.current, ...newItems];
+      setQueue((prev) => [...prev, ...newItems]);
+      logger.info('Added files to batch queue', {
+        count: newItems.length,
+        files: newItems.map((item) => item.file.name),
+      });
+    }
+
+    setDuplicateFilesSkipped(duplicateFiles.length);
+
+    if (duplicateFiles.length > 0) {
+      logger.warn('Skipped duplicate files in batch queue', {
+        count: duplicateFiles.length,
+        files: duplicateFiles.map((file) => file.name),
+      });
+    }
   }, []);
 
   const removeFile = useCallback((id: string) => {
+    shouldPersistQueueRef.current = true;
     setQueue((prev) => prev.filter((item) => item.id !== id));
     logger.info('Removed file from batch queue', { id });
   }, []);
 
   const clearCompleted = useCallback(() => {
+    shouldPersistQueueRef.current = true;
     setQueue((prev) =>
       prev.filter((item) => item.status !== 'completed' && item.status !== 'cancelled')
     );
@@ -93,20 +355,30 @@ export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueRetur
       logger.warn('Cannot clear queue while processing');
       return;
     }
+    shouldPersistQueueRef.current = true;
     setQueue([]);
+    setShowQueueResumePrompt(false);
+    setRestoredQueueItemsCount(0);
     logger.info('Cleared all items from batch queue');
   }, [isProcessing]);
 
+  const dismissQueueResumePrompt = useCallback(() => {
+    setShowQueueResumePrompt(false);
+    setRestoredQueueItemsCount(0);
+  }, []);
+
   const processItem = useCallback(
     async (item: QueueItem): Promise<QueueItem> => {
       const startTime = Date.now();
 
+      shouldPersistQueueRef.current = true;
       setQueue((prev) =>
         prev.map((q) =>
           q.id === item.id ? { ...q, status: 'processing' as QueueItemStatus, startTime } : q
         )
       );
       setCurrentItemId(item.id);
+      currentItemStartTimeRef.current = startTime;
 
       if (progressUnsubscribeRef.current) {
         progressUnsubscribeRef.current();
@@ -115,6 +387,32 @@ export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueRetur
 
       progressUnsubscribeRef.current = onTranscriptionProgress((progress) => {
         setQueue((prev) => prev.map((q) => (q.id === item.id ? { ...q, progress } : q)));
+
+        const startTimeMs = currentItemStartTimeRef.current;
+        const progressPercent = Number(progress.percent);
+
+        if (
+          isCancelledRef.current ||
+          startTimeMs === null ||
+          !Number.isFinite(progressPercent) ||
+          progressPercent <= 0 ||
+          progressPercent > 100
+        ) {
+          return;
+        }
+
+        const elapsedMs = Date.now() - startTimeMs;
+        if (elapsedMs <= 0) {
+          return;
+        }
+
+        const projectedItemDurationMs = elapsedMs / (progressPercent / 100);
+        const remainingCurrentMs = Math.max(0, projectedItemDurationMs - elapsedMs);
+        const remainingMs =
+          remainingCurrentMs + projectedItemDurationMs * remainingPendingCountRef.current;
+
+        const estimatedSeconds = Math.max(1, Math.round(remainingMs / 1000));
+        setEstimatedTimeRemainingSec(estimatedSeconds);
       });
 
       logger.info('Processing batch item', {
@@ -137,6 +435,7 @@ export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueRetur
         if (isCancelledRef.current) {
           return {
             ...item,
+            startTime,
             status: 'cancelled',
             endTime,
           };
@@ -147,8 +446,9 @@ export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueRetur
           logger.error('Batch item failed', { id: item.id, error });
           return {
             ...item,
+            startTime,
             status: 'error',
-            error,
+            error: toUserFriendlyTranscriptionError(error),
             endTime,
           };
         }
@@ -156,6 +456,7 @@ export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueRetur
         if (result.cancelled) {
           return {
             ...item,
+            startTime,
             status: 'cancelled',
             endTime,
           };
@@ -164,6 +465,7 @@ export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueRetur
         if (!result.text) {
           return {
             ...item,
+            startTime,
             status: 'error',
             error: 'Transcription produced no output',
             endTime,
@@ -197,6 +499,7 @@ export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueRetur
 
         return {
           ...item,
+          startTime,
           status: 'completed',
           result,
           progress: { percent: 100, status: 'Complete!' },
@@ -207,8 +510,9 @@ export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueRetur
         logger.error('Batch item threw error', { id: item.id, error: err });
         return {
           ...item,
+          startTime,
           status: 'error',
-          error,
+          error: toUserFriendlyTranscriptionError(error),
           endTime: Date.now(),
         };
       } finally {
@@ -221,51 +525,121 @@ export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueRetur
     [settings, onHistoryAdd, onFirstComplete]
   );
 
-  const startProcessing = useCallback(async () => {
-    if (isProcessing) return;
+  const runProcessing = useCallback(
+    async (targetStatuses: QueueItemStatus[], noItemsLogMessage: string) => {
+      if (isProcessing) return;
 
-    const itemsToProcess = queue.filter(
-      (item) => item.status === 'pending' || item.status === 'cancelled' || item.status === 'error'
-    );
+      const itemsToProcess = queue.filter((item) => targetStatuses.includes(item.status));
 
-    if (itemsToProcess.length === 0) {
-      logger.warn('No items to process');
-      return;
-    }
+      if (itemsToProcess.length === 0) {
+        logger.warn(noItemsLogMessage);
+        return;
+      }
 
-    setQueue((prev) =>
-      prev.map((item) =>
-        item.status === 'cancelled' || item.status === 'error'
-          ? { ...item, status: 'pending' as QueueItemStatus, error: undefined, endTime: undefined }
-          : item
-      )
-    );
+      const activeIds = new Set(itemsToProcess.map((item) => item.id));
+      activeRunItemIdsRef.current = activeIds;
+      setEstimatedTimeRemainingSec(null);
+
+      shouldPersistQueueRef.current = true;
+      setQueue((prev) =>
+        prev.map((item) =>
+          activeIds.has(item.id) && (item.status === 'cancelled' || item.status === 'error')
+            ? {
+                ...item,
+                status: 'pending' as QueueItemStatus,
+                error: undefined,
+                endTime: undefined,
+              }
+            : item
+        )
+      );
+
+      setIsProcessing(true);
+      isCancelledRef.current = false;
+      hasCalledFirstCompleteRef.current = false;
+
+      logger.info('Starting batch processing', { count: itemsToProcess.length });
+
+      const processedDurationsMs: number[] = [];
+      const processedItems: QueueItem[] = [];
+
+      for (let index = 0; index < itemsToProcess.length; index++) {
+        const item = itemsToProcess[index];
+        if (!item) continue;
 
-    setIsProcessing(true);
-    isCancelledRef.current = false;
-    hasCalledFirstCompleteRef.current = false;
+        if (isCancelledRef.current) {
+          shouldPersistQueueRef.current = true;
+          setQueue((prev) =>
+            prev.map((q) =>
+              q.status === 'pending' && activeIds.has(q.id)
+                ? { ...q, status: 'cancelled' as QueueItemStatus }
+                : q
+            )
+          );
+          break;
+        }
 
-    logger.info('Starting batch processing', { count: itemsToProcess.length });
+        const resetItem = { ...item, status: 'pending' as QueueItemStatus, error: undefined };
+        remainingPendingCountRef.current = itemsToProcess.length - (index + 1);
+        const processedItem = await processItem(resetItem);
+        currentItemStartTimeRef.current = null;
+        processedItems.push(processedItem);
+        shouldPersistQueueRef.current = true;
+        setQueue((prev) => prev.map((q) => (q.id === processedItem.id ? processedItem : q)));
+
+        if (
+          typeof processedItem.startTime === 'number' &&
+          typeof processedItem.endTime === 'number' &&
+          processedItem.endTime >= processedItem.startTime
+        ) {
+          processedDurationsMs.push(processedItem.endTime - processedItem.startTime);
+        }
 
-    for (const item of itemsToProcess) {
-      if (isCancelledRef.current) {
-        setQueue((prev) =>
-          prev.map((q) =>
-            q.status === 'pending' ? { ...q, status: 'cancelled' as QueueItemStatus } : q
-          )
-        );
-        break;
+        const remainingItemsCount = itemsToProcess.length - (index + 1);
+        if (remainingItemsCount <= 0) {
+          setEstimatedTimeRemainingSec(0);
+        } else if (processedDurationsMs.length > 0) {
+          const averageDurationMs =
+            processedDurationsMs.reduce((total, value) => total + value, 0) /
+            processedDurationsMs.length;
+          const estimatedSeconds = Math.max(
+            1,
+            Math.round((averageDurationMs * remainingItemsCount) / 1000)
+          );
+          setEstimatedTimeRemainingSec(estimatedSeconds);
+        }
       }
 
-      const resetItem = { ...item, status: 'pending' as QueueItemStatus, error: undefined };
-      const processedItem = await processItem(resetItem);
-      setQueue((prev) => prev.map((q) => (q.id === processedItem.id ? processedItem : q)));
-    }
+      const wasCancelled = isCancelledRef.current;
+      setIsProcessing(false);
+      setCurrentItemId(null);
+      activeRunItemIdsRef.current = new Set();
+      currentItemStartTimeRef.current = null;
+      remainingPendingCountRef.current = 0;
+      setEstimatedTimeRemainingSec(null);
 
-    setIsProcessing(false);
-    setCurrentItemId(null);
-    logger.info('Batch processing complete');
-  }, [isProcessing, queue, processItem]);
+      if (!wasCancelled) {
+        showBatchCompletionNotification(processedItems);
+      }
+
+      logger.info('Batch processing complete');
+    },
+    [isProcessing, queue, processItem]
+  );
+
+  const startProcessing = useCallback(async () => {
+    dismissQueueResumePrompt();
+    await runProcessing(['pending', 'cancelled', 'error'], 'No items to process');
+  }, [dismissQueueResumePrompt, runProcessing]);
+
+  const retryFailed = useCallback(async () => {
+    dismissQueueResumePrompt();
+    await runProcessing(['cancelled', 'error'], 'No failed items to retry');
+  }, [dismissQueueResumePrompt, runProcessing]);
+
+  const resumePersistedQueue = useCallback(async () => {
+    await startProcessing();
+  }, [startProcessing]);
 
   const cancelProcessing = useCallback(async () => {
     if (!isProcessing) return;
@@ -275,10 +649,15 @@ export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueRetur
 
     setIsProcessing(false);
     setCurrentItemId(null);
+    currentItemStartTimeRef.current = null;
+    remainingPendingCountRef.current = 0;
+    setEstimatedTimeRemainingSec(null);
 
+    shouldPersistQueueRef.current = true;
     setQueue((prev) =>
       prev.map((q) =>
-        q.status === 'processing' || q.status === 'pending'
+        q.status === 'processing' ||
+        (q.status === 'pending' && activeRunItemIdsRef.current.has(q.id))
           ? { ...q, status: 'cancelled' as QueueItemStatus, endTime: Date.now() }
           : q
       )
@@ -307,13 +686,20 @@ export function useBatchQueue(options: UseBatchQueueOptions): UseBatchQueueRetur
     queue,
     isProcessing,
     currentItemId,
+    duplicateFilesSkipped,
+    estimatedTimeRemainingSec,
+    showQueueResumePrompt,
+    restoredQueueItemsCount,
 
     addFiles,
     removeFile,
     clearCompleted,
     clearAll,
+    dismissQueueResumePrompt,
+    resumePersistedQueue,
 
     startProcessing,
+    retryFailed,
     cancelProcessing,
 
     getCompletedTranscription,
diff --git a/src/renderer/features/transcription/hooks/useTranscription.ts b/src/renderer/features/transcription/hooks/useTranscription.ts
index 6cd88eb..3aa206b 100644
--- a/src/renderer/features/transcription/hooks/useTranscription.ts
+++ b/src/renderer/features/transcription/hooks/useTranscription.ts
@@ -1,9 +1,31 @@
 import { useState, useCallback } from 'react';
 import type { SelectedFile, TranscriptionSettings, OutputFormat } from '../../../types';
-import { saveFile } from '../../../services/electronAPI';
+import { saveFile, showItemInFolder } from '../../../services/electronAPI';
 import { logger } from '../../../services/logger';
 import { sanitizePath } from '../../../../shared/utils';
 
+function shouldRevealInFinderAfterSave(): boolean {
+  if (typeof window === 'undefined' || typeof window.confirm !== 'function') {
+    return false;
+  }
+
+  const confirmFn = window.confirm as unknown as {
+    (message?: string): boolean;
+    mock?: unknown;
+  };
+  const isJSDOM = typeof navigator !== 'undefined' && /jsdom/i.test(navigator.userAgent || '');
+
+  if (isJSDOM && !confirmFn.mock) {
+    return false;
+  }
+
+  try {
+    return confirmFn('File saved successfully. Show in Finder?');
+  } catch {
+    return false;
+  }
+}
+
 export interface UseTranscriptionReturn {
   selectedFile: SelectedFile | null;
   settings: TranscriptionSettings;
@@ -76,6 +98,16 @@ export function useTranscription(): UseTranscriptionReturn {
 
       if (result?.success && result.filePath) {
         logger.info('File saved', { path: sanitizePath(result.filePath), format });
+
+        if (shouldRevealInFinderAfterSave()) {
+          const revealResult = await showItemInFolder(result.filePath);
+          if (!revealResult.success) {
+            logger.warn('Failed to reveal saved file in Finder', {
+              path: sanitizePath(result.filePath),
+              error: revealResult.error || 'Unknown error',
+            });
+          }
+        }
       } else if (result?.error) {
         setError(`Failed to save: ${result.error}`);
         logger.error('Failed to save file', { error: result.error, format });
diff --git a/src/renderer/features/transcription/utils/errorMessages.ts b/src/renderer/features/transcription/utils/errorMessages.ts
new file mode 100644
index 0000000..19c4fa2
--- /dev/null
+++ b/src/renderer/features/transcription/utils/errorMessages.ts
@@ -0,0 +1,21 @@
+export function toUserFriendlyTranscriptionError(errorMessage: string): string {
+  const normalized = errorMessage.toLowerCase();
+
+  if (
+    normalized.includes('output file does not contain any stream') ||
+    (normalized.includes('stream map') && normalized.includes('matches no streams')) ||
+    normalized.includes('no audio stream')
+  ) {
+    return 'No audio track found in this file. Please choose a file that contains audio.';
+  }
+
+  if (normalized.includes('ffmpeg not found')) {
+    return 'FFmpeg is not available. Install FFmpeg and try again.';
+  }
+
+  if (normalized.includes('input file not found')) {
+    return 'Input file not found. Make sure the file still exists and try again.';
+  }
+
+  return errorMessage;
+}
diff --git a/src/renderer/services/__tests__/electronAPI.test.ts b/src/renderer/services/__tests__/electronAPI.test.ts
index c634372..ef4c3cc 100644
--- a/src/renderer/services/__tests__/electronAPI.test.ts
+++ b/src/renderer/services/__tests__/electronAPI.test.ts
@@ -22,6 +22,7 @@ import {
   installUpdate,
   onUpdateStatus,
   openExternal,
+  showItemInFolder,
   onMenuOpenFile,
   onMenuSaveFile,
   onMenuCopyTranscription,
@@ -112,6 +113,8 @@ describe('electronAPI wrapper', () => {
     unsubscribeUpdate();
 
     await expect(openExternal('https://example.com')).resolves.toBeUndefined();
+    const reveal = await showItemInFolder('/tmp/test.txt');
+    expect(reveal.success).toBe(false);
 
     const unsubscribeMenuOpen = onMenuOpenFile(() => {});
     expect(typeof unsubscribeMenuOpen).toBe('function');
@@ -211,6 +214,9 @@ describe('electronAPI wrapper', () => {
     await openExternal('https://example.com');
     expect(api.openExternal).toHaveBeenCalledWith('https://example.com');
 
+    await showItemInFolder('/tmp/test.txt');
+    expect(api.showItemInFolder).toHaveBeenCalledWith('/tmp/test.txt');
+
     onMenuOpenFile(() => {});
     expect(api.onMenuOpenFile).toHaveBeenCalled();
 
@@ -229,4 +235,15 @@ describe('electronAPI wrapper', () => {
     onMenuToggleHistory(() => {});
     expect(api.onMenuToggleHistory).toHaveBeenCalled();
   });
+
+  it('showItemInFolder returns failure when underlying API throws', async () => {
+    const api = createFullElectronAPIMock();
+    api.showItemInFolder = vi.fn().mockRejectedValue(new Error('No handler registered'));
+    window.electronAPI = api;
+
+    const result = await showItemInFolder('/tmp/test.txt');
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('No handler registered');
+  });
 });
diff --git a/src/renderer/services/electronAPI.ts b/src/renderer/services/electronAPI.ts
index ec8d8fb..e9395f3 100644
--- a/src/renderer/services/electronAPI.ts
+++ b/src/renderer/services/electronAPI.ts
@@ -132,6 +132,20 @@ export async function openExternal(url: string): Promise<void> {
   await window.electronAPI?.openExternal(url);
 }
 
+export async function showItemInFolder(
+  filePath: string
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    const result = await window.electronAPI?.showItemInFolder(filePath);
+    return result ?? { success: false, error: 'Electron API not available' };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
 export function onMenuOpenFile(callback: () => void): Unsubscribe {
   return window.electronAPI?.onMenuOpenFile(callback) ?? (() => {});
 }
diff --git a/src/renderer/test/electronAPIMocks.ts b/src/renderer/test/electronAPIMocks.ts
index a9593a3..689e50e 100644
--- a/src/renderer/test/electronAPIMocks.ts
+++ b/src/renderer/test/electronAPIMocks.ts
@@ -34,6 +34,7 @@ export const createDefaultElectronAPIMock = (): ElectronAPI => ({
   }),
   trackEvent: vi.fn().mockResolvedValue(undefined),
   openExternal: vi.fn().mockResolvedValue(undefined),
+  showItemInFolder: vi.fn().mockResolvedValue({ success: true }),
   onMenuOpenFile: vi.fn().mockReturnValue(() => {}),
   onMenuSaveFile: vi.fn().mockReturnValue(() => {}),
   onMenuCopyTranscription: vi.fn().mockReturnValue(() => {}),
@@ -67,6 +68,7 @@ export const createFullElectronAPIMock = (): ElectronAPI => ({
     .mockResolvedValue({ heapUsed: 1, heapTotal: 2, rss: 3, external: 4, isTranscribing: false }),
   trackEvent: vi.fn().mockResolvedValue(undefined),
   openExternal: vi.fn().mockResolvedValue(undefined),
+  showItemInFolder: vi.fn().mockResolvedValue({ success: true }),
   onMenuOpenFile: vi.fn().mockReturnValue(() => {}),
   onMenuSaveFile: vi.fn().mockReturnValue(() => {}),
   onMenuCopyTranscription: vi.fn().mockReturnValue(() => {}),
diff --git a/src/renderer/test/setup.ts b/src/renderer/test/setup.ts
index f21f02a..da91729 100644
--- a/src/renderer/test/setup.ts
+++ b/src/renderer/test/setup.ts
@@ -36,6 +36,7 @@ const mockElectronAPI: ElectronAPI = {
   }),
   trackEvent: vi.fn().mockResolvedValue(undefined),
   openExternal: vi.fn().mockResolvedValue(undefined),
+  showItemInFolder: vi.fn().mockResolvedValue({ success: true }),
   onMenuOpenFile: vi.fn().mockReturnValue(() => {}),
   onMenuSaveFile: vi.fn().mockReturnValue(() => {}),
   onMenuCopyTranscription: vi.fn().mockReturnValue(() => {}),
diff --git a/src/renderer/types/electron.d.ts b/src/renderer/types/electron.d.ts
index 6e02ef7..07d46d6 100644
--- a/src/renderer/types/electron.d.ts
+++ b/src/renderer/types/electron.d.ts
@@ -53,6 +53,7 @@ export interface ElectronAPI {
     properties?: Record<string, string | number | boolean>
   ) => Promise<void>;
   openExternal: (url: string) => Promise<void>;
+  showItemInFolder: (filePath: string) => Promise<{ success: boolean; error?: string }>;
   onMenuOpenFile: (callback: () => void) => Unsubscribe;
   onMenuSaveFile: (callback: () => void) => Unsubscribe;
   onMenuCopyTranscription: (callback: () => void) => Unsubscribe;
diff --git a/src/renderer/utils/__tests__/fileProcessing.test.ts b/src/renderer/utils/__tests__/fileProcessing.test.ts
index c556cff..dced4ce 100644
--- a/src/renderer/utils/__tests__/fileProcessing.test.ts
+++ b/src/renderer/utils/__tests__/fileProcessing.test.ts
@@ -104,6 +104,20 @@ describe('fileProcessing', () => {
       expect(result).toEqual([fileInfo]);
     });
 
+    it('processes .opus files as valid media', async () => {
+      const filePaths = ['/path/to/voice-note.opus'];
+      const fileInfo = { name: 'voice-note.opus', path: '/path/to/voice-note.opus', size: 2048 };
+
+      (electronAPI.openMultipleFilesDialog as Mock).mockResolvedValue(filePaths);
+      (electronAPI.getFileInfo as Mock).mockResolvedValue(fileInfo);
+      (validators.isValidMediaFile as Mock).mockReturnValue(true);
+
+      const result = await selectAndProcessFiles();
+
+      expect(result).toEqual([fileInfo]);
+      expect(validators.isValidMediaFile).toHaveBeenCalledWith('voice-note.opus');
+    });
+
     it('returns empty array when all files are invalid', async () => {
       const filePaths = ['/path/to/doc.pdf', '/path/to/text.txt'];
       const fileInfo1 = { name: 'doc.pdf', path: '/path/to/doc.pdf', size: 500 };
diff --git a/src/renderer/utils/__tests__/validators.test.ts b/src/renderer/utils/__tests__/validators.test.ts
index 64632a4..85081a6 100644
--- a/src/renderer/utils/__tests__/validators.test.ts
+++ b/src/renderer/utils/__tests__/validators.test.ts
@@ -14,6 +14,9 @@ describe('validators', () => {
       expect(isValidMediaFile('song.m4a')).toBe(true);
       expect(isValidMediaFile('music.flac')).toBe(true);
       expect(isValidMediaFile('audio.ogg')).toBe(true);
+      expect(isValidMediaFile('voice.opus')).toBe(true);
+      expect(isValidMediaFile('note.oga')).toBe(true);
+      expect(isValidMediaFile('memo.amr')).toBe(true);
     });
 
     it('should return true for valid video extensions', () => {
diff --git a/src/renderer/utils/storage.ts b/src/renderer/utils/storage.ts
index a820955..f5c65fc 100644
--- a/src/renderer/utils/storage.ts
+++ b/src/renderer/utils/storage.ts
@@ -4,6 +4,7 @@ const STORAGE_KEYS = {
   HISTORY: 'whisperdesk_history',
   THEME: 'whisperdesk_theme',
   LAST_MODEL: 'whisperdesk_lastModel',
+  QUEUE: 'whisperdesk_queue',
 } as const;
 
 export type StorageKey = (typeof STORAGE_KEYS)[keyof typeof STORAGE_KEYS];
diff --git a/src/shared/types.ts b/src/shared/types.ts
index d2b2e15..c52b2b9 100644
--- a/src/shared/types.ts
+++ b/src/shared/types.ts
@@ -2,6 +2,7 @@ export interface SelectedFile {
   name: string;
   path: string;
   size?: number;
+  fingerprint?: string;
 }
 
 export type WhisperModelName =
@@ -178,6 +179,9 @@ export const SUPPORTED_EXTENSIONS = [
   'm4a',
   'flac',
   'ogg',
+  'opus',
+  'oga',
+  'amr',
   'wma',
   'aac',
   'aiff',