diff --git a/AUDIT_LOG.md b/AUDIT_LOG.md
index 8570c12..f4510f4 100644
--- a/AUDIT_LOG.md
+++ b/AUDIT_LOG.md
@@ -2,6 +2,74 @@
 
 This log tracks all significant changes, updates, and versions in the PaperCache project.
 
+## 2026-07-01 (Web Speech API Transcription Priority & UI Responsiveness Fix)
+**Change:** fix(memo): prioritize Web Speech API live transcription over Whisper API fallback to avoid 401 Unauthorized errors with OpenRouter API keys, and stop click propagation in MemoVoicePanel to prevent focus trapping and editor squishing.
+
+**Details/Why:**
+When the user recorded a voice note, `MemoVoicePanel` previously always attempted to call Whisper (`openaiTranscribe`) first whenever an API key was configured. If the configured API key was for OpenRouter (`sk-or-v1-...`), the request failed with `401 Unauthorized: Incorrect API key provided`, overwriting the natural Web Speech API transcription with a large error message and skipping AI command restructuring (`openAIChat`). Furthermore, clicking inside the voice memo results panel caused the main app container to steal focus back to CodeMirror, while unbounded panel height squished the editor, making it feel frozen and blocking note deletion or editing. Updated `MemoVoicePanel` to use the Web Speech API transcription directly without invoking Whisper (unless Web Speech API captured nothing), added event propagation stopping to keep focus stable, and capped panel max-height to ensure the editor remains fully accessible.
+
+**Files changed:** `src/components/MemoVoicePanel.tsx`, `src/App.css`, `AUDIT_LOG.md`, `CHANGELOG.md`.
+
+---
+
+## 2026-07-01 (IPC Parameter Key Mapping Fix for `read_asset`)
+**Change:** fix(api): map `assetPath` argument to `{ path: assetPath }` in `tauriApi.readAsset`
+
+**Details/Why:**
+The Tauri Rust backend command `pub async fn read_asset(path: String)` expects an argument object keyed by `path`. The frontend wrapper in `src/api.ts` was passing `{ assetPath }`, resulting in a Tauri IPC error (`invalid args 'path' for command 'read_asset': command read_asset missing required key path`) whenever the app attempted to load saved voice recordings or image assets. Updated `src/api.ts` to pass `{ path: assetPath }`.
+
+**Files changed:** `src/api.ts`, `AUDIT_LOG.md`, `CHANGELOG.md`.
+
+---
+
+## 2026-07-01 (Voice Memo Overlay Visibility, Race Conditions & CSP Fixes)
+**Change:** fix(memo): show overlay window before recording/processing, fix early release race condition before getUserMedia resolves, update CSP `media-src` to permit local audio playback, and ensure processing/error states stay visible
+
+**Details/Why:**
+1. **Overlay Window Visibility (`MemoVoicePanel.tsx`)**: When recording started via global shortcut while the main app was hidden, the floating `voice-indicator` window received the recording event but remained hidden (`visible: false` in `tauri.conf.json`). Added `getCurrentWindow().show()` when starting recording or entering processing/done states when `isOverlay` is true so the user always sees the live indicator and playback pill.
+2. **Push-to-Talk Race Condition**: If the user released `Cmd+Shift+M` before `getUserMedia` finished initializing, `trigger-voice-memo-release` ignored the release because `panelStateRef.current` was still `'idle'`. Removed early returns from release handlers and added delay scheduling so quick taps reliably capture audio and stop recording cleanly.
+3. **Audio Playback CSP (`tauri.conf.json`)**: Updated Content Security Policy to include `media-src 'self' data: blob: file: https:;` and expanded `img-src`/`connect-src` so recorded audio pills can load and play without browser CSP blocks.
+
+**Files changed:** `src/components/MemoVoicePanel.tsx`, `src-tauri/tauri.conf.json`, `AUDIT_LOG.md`, `CHANGELOG.md`.
+
+---
+
+## 2026-07-01 (Voice Memo macOS Audio Permission, IPC Listener Stability & Default State Fix)
+**Change:** fix(memo): add `NSMicrophoneUsageDescription` in `Info.plist`, eliminate IPC listener re-registration race conditions using stable refs, ensure `memoEnabled` defaults to true, and require window focus before intercepting shortcuts
+
+**Details/Why:**
+1. **macOS Microphone Permission (`Info.plist`)**: Created `src-tauri/Info.plist` containing `NSMicrophoneUsageDescription` and configured `"infoPlist": "Info.plist"` in `tauri.conf.json`. Without this explicit plist description, macOS CoreAudio / TCC blocks WKWebView `getUserMedia` requests.
+2. **IPC Event Listener Stability & Race Conditions**: Replaced stateful `panelState` dependencies in `MemoVoicePanel.tsx` with stable `panelStateRef` and `isRecordingRequestedRef`. This prevents event listeners from unregistering and dropping `trigger-voice-memo-release` events over IPC when transitioning from idle to recording. Added explicit error rendering card when microphone access fails instead of silently returning to idle.
+3. **Default State & Window Focus Routing**: Updated `useSettingsStore` and added an auto-upgrade in `App.tsx` so voice memos are enabled by default (`memoEnabled: true`). Updated `shortcuts.rs` so that if `main_win` is unfocused or hidden while the user holds `Cmd+Shift+M`, recording routes to the bottom-left floating overlay window.
+
+**Files changed:** `src-tauri/Info.plist` [NEW], `src-tauri/tauri.conf.json`, `src-tauri/src/commands/shortcuts.rs`, `src/store/useSettingsStore.ts`, `src/App.tsx`, `src/components/MemoVoicePanel.tsx`, `AUDIT_LOG.md`.
+
+---
+
+## 2026-07-01 (Voice Memo Push-to-Talk Press/Release Fix & Stop Button Removal)
+**Change:** fix(memo): resolve global shortcut push-to-talk press vs release events (`Cmd+Shift+M`), remove unnecessary stop button, prevent empty audio blobs on quick release, and add explicit error reporting for AI transcription
+
+**Details/Why:**
+1. **Push-to-Talk Press & Release Handling**: Updated global shortcut registration (`shortcuts.rs`) to emit distinct `trigger-voice-memo-press` on key press and `trigger-voice-memo-release` on key release. Updated `MemoVoicePanel.tsx` to ignore keyboard auto-repeats while recording and stop recording upon key release.
+2. **Stop Button Removal**: Removed the `■ Stop` button from the recording pillbox since push-to-talk recording automatically stops when releasing `Cmd+Shift+M`.
+3. **Audio Integrity & Error Reporting**: Added `stopRecordingSafe` to ensure at least 400ms of audio is captured on rapid key release, preventing 0-byte unplayable audio blobs. Updated `openai_transcribe` base URL logic and added explicit frontend error display if transcription or AI interpretation fails.
+
+**Files changed:** `src-tauri/src/commands/shortcuts.rs`, `src/components/MemoVoicePanel.tsx`, `AUDIT_LOG.md`.
+
+---
+
+## 2026-07-01 (Voice Memo Plugin & Floating Indicator Overlay)
+**Change:** feat(memo): implement voice memo plugin support with hold-to-record global shortcut (`Cmd+Shift+M`), custom waveform pillbox player, floating background overlay indicator, and AI restructuring
+
+**Details/Why:**
+1. **Hold-to-Record & Global Shortcut**: Registered `Cmd+Shift+M` global shortcut. Added floating overlay window (`voice-indicator`) that appears in the bottom-left corner when PaperCache is hidden or unfocused, displaying real-time recording waveform and status.
+2. **Custom Audio Pillbox & Waveform Player**: Replaced standard mic icon and default `<audio>` element with a custom sleek pillbox featuring a play/pause button (`AudioWaveformPill`) and dynamic CSS waveform animation (`.memo-waveform-visual`, `.memo-wave-bar`).
+3. **Transcription & AI Processing**: Captured speech is transcribed and rendered in gray slanted italic text (`.memo-gray-slanted`), then processed via user's configured AI model with PaperCache slash command context to produce structured action items inserted directly into the active note.
+
+**Files changed:** `src-tauri/Cargo.toml`, `src-tauri/tauri.conf.json`, `src-tauri/src/commands/ai.rs`, `src-tauri/src/commands/fs.rs`, `src-tauri/src/commands/shortcuts.rs`, `src-tauri/src/lib.rs`, `src/App.css`, `src/App.tsx`, `src/main.tsx`, `src/components/MemoVoicePanel.tsx` [NEW], `src/components/Editor.tsx`, `src/hooks/useGlobalHotkey.ts`, `src/Settings.tsx`, `src/store/useSettingsStore.ts`, `src/api.ts`, `src/types.d.ts`, `src/setupTests.ts`, `CHANGELOG.md`, `AUDIT_LOG.md`.
+
+---
+
 ## 2026-07-01 (v0.5.9 Release: Image Support & UI Consistency)
 **Change:** feat(release): bump version to 0.5.9; implement image paste support and markdown image widget; align background blur and font typography across modals and timers; extract audio recording features to external project
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 09f19f1..72ee0c7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- **Voice Memo Plugin & Floating Overlay**: Press and hold `Command+Shift+M` from anywhere to record voice notes. When PaperCache is hidden or unfocused, a floating bottom-left waveform pillbox indicator displays your live recording status.
+- **Custom Waveform Player & AI Restructuring**: Voice notes feature sleek audio playback pillboxes with animated waveforms, live gray slanted transcriptions, and automatic restructuring into structured action items using your configured AI model and PaperCache slash commands.
+
+
+### Fixed
+- **Voice Memo Transcription Priority & Responsiveness**: Fixed an issue where recording a voice note with an OpenRouter API key configured resulted in `401 Unauthorized` errors because the app always attempted Whisper API transcription before AI restructuring. Voice memos now prioritize the natural Web Speech API transcription directly and send it to your configured AI model (`openAIChat`) to format PaperCache slash commands.
+- **Voice Panel Focus Trapping & Editor Layout**: Fixed an issue where clicking inside the voice memo result box caused the app container to force focus away, while large result blocks squished the note editor. Added click propagation stopping and maximum panel height limits so you can easily type under voice notes, delete notes, and interact with the editor normally.
+- **Asset Reading (`read_asset`) IPC Mapping**: Fixed an issue where reading saved voice note audio files or pasted images threw `invalid args 'path' for command 'read_asset'` due to a parameter key mismatch between the frontend and Tauri backend.
+- **Floating Overlay Visibility (`Command+Shift+M`)**: Fixed an issue where recording via global shortcut while the main app was hidden recorded audio in the background but failed to reveal the floating bottom-left waveform player and transcript result. The overlay indicator window now automatically shows and focuses when recording or processing voice notes.
+- **Push-to-Talk Race Condition & Audio Playback**: Fixed an issue where releasing `Command+Shift+M` immediately before microphone access resolved would ignore the release event. Also updated Content Security Policy (`media-src`) to allow recorded audio waveform pills to play smoothly.
+- **macOS Microphone Permission (`Info.plist`)**: Added `NSMicrophoneUsageDescription` in the macOS app bundle `Info.plist` so macOS CoreAudio properly grants microphone access instead of silently blocking audio recording.
+- **Push-to-Talk Press & Release Recording**: Fixed an issue where holding `Command+Shift+M` immediately stopped recording due to keyboard auto-repeat events. Replaced unnecessary Stop button with seamless press-to-record and release-to-stop behavior.
+- **Audio & Transcription Error Display**: Resolved 0-byte audio creation on rapid shortcut release and ensured explicit error messages appear in the transcript block if API keys or endpoints fail. Also ensured the voice memo plugin is enabled by default for all users.
 
 ## [v0.5.9] - 2026-07-01
 
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index 0560bed..2a50bd4 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -2429,6 +2429,16 @@ version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
+[[package]]
+name = "mime_guess"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
 [[package]]
 name = "minisign-verify"
 version = "0.2.5"
@@ -3434,6 +3444,7 @@ dependencies = [
  "js-sys",
  "log",
  "mime",
+ "mime_guess",
  "native-tls",
  "once_cell",
  "percent-encoding",
@@ -5171,6 +5182,12 @@ dependencies = [
  "unic-common",
 ]
 
+[[package]]
+name = "unicase"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 75c33c9..c8731b2 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -18,7 +18,7 @@ tauri-plugin-updater = "2.0.0"
 tauri-plugin-global-shortcut = "2.0.0"
 tauri-plugin-dialog = "2.0.0"
 
-reqwest = { version = "0.11", features = ["json", "stream"] }
+reqwest = { version = "0.11", features = ["json", "stream", "multipart"] }
 tokio = { version = "1", features = ["full"] }
 keyring = { version = "3", features = ["apple-native", "windows-native", "linux-native"] }
 serde = { version = "1", features = ["derive"] }
diff --git a/src-tauri/Info.plist b/src-tauri/Info.plist
new file mode 100644
index 0000000..aa21e30
--- /dev/null
+++ b/src-tauri/Info.plist
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSMicrophoneUsageDescription</key>
+	<string>PaperCache requires microphone access to record voice notes and memos.</string>
+</dict>
+</plist>
diff --git a/src-tauri/src/commands/ai.rs b/src-tauri/src/commands/ai.rs
index 93240fe..605784d 100644
--- a/src-tauri/src/commands/ai.rs
+++ b/src-tauri/src/commands/ai.rs
@@ -1,4 +1,5 @@
 use keyring::Entry;
+use reqwest::multipart::{Form, Part};
 use reqwest::Client;
 use serde_json::json;
 
@@ -68,3 +69,94 @@ pub async fn openai_chat(
         .await
         .map_err(|e| format!("Failed to parse API response: {}", e))
 }
+
+#[tauri::command]
+pub async fn openai_transcribe(
+    file_path: String,
+    base_url: String,
+) -> Result<String, String> {
+    if file_path.trim().is_empty() {
+        return Err("Invalid file path provided".into());
+    }
+
+    let entry = Entry::new(SERVICE_NAME, "openai_api_key")
+        .map_err(|e| format!("Failed to access keyring: {}", e))?;
+    let api_key = entry
+        .get_password()
+        .map_err(|_| "API key not found. Please set it in settings.".to_string())?;
+
+    let resolved_path = if std::path::Path::new(&file_path).exists() {
+        std::path::PathBuf::from(&file_path)
+    } else {
+        let clean = file_path.trim_start_matches('/');
+        crate::commands::fs::get_papercache_dir()
+            .map_err(|e| format!("Failed to get app directory: {}", e))?
+            .join(clean)
+    };
+
+    let file_bytes = tokio::fs::read(&resolved_path)
+        .await
+        .map_err(|e| format!("Failed to read audio file ({}): {}", resolved_path.display(), e))?;
+
+    let file_name = std::path::Path::new(&file_path)
+        .file_name()
+        .and_then(|n| n.to_str())
+        .unwrap_or("audio.webm")
+        .to_string();
+
+    let client = Client::new();
+
+    let mut base = if base_url.is_empty()
+        || base_url.contains("openrouter.ai")
+        || base_url.contains("googleapis.com")
+        || base_url.contains("anthropic.com")
+    {
+        DEFAULT_BASE_URL.to_string()
+    } else {
+        base_url.trim_end_matches('/').to_string()
+    };
+    if !base.ends_with("/audio/transcriptions") {
+        base.push_str("/audio/transcriptions");
+    }
+
+    let part = Part::bytes(file_bytes)
+        .file_name(file_name)
+        .mime_str("application/octet-stream")
+        .map_err(|e| format!("Failed to create multipart part: {}", e))?;
+
+    let form = Form::new()
+        .part("file", part)
+        .text("model", "whisper-1");
+
+    let response = client
+        .post(&base)
+        .header("Authorization", format!("Bearer {}", api_key))
+        .multipart(form)
+        .send()
+        .await
+        .map_err(|e| format!("Network request failed: {}", e))?;
+
+    if !response.status().is_success() {
+        let status = response.status();
+        let error_text = response
+            .text()
+            .await
+            .unwrap_or_else(|_| "Unknown error".to_string());
+        return Err(format!(
+            "Transcription API request failed with status {}: {}",
+            status, error_text
+        ));
+    }
+
+    let res_json: serde_json::Value = response
+        .json()
+        .await
+        .map_err(|e| format!("Failed to parse transcription API response: {}", e))?;
+
+    if let Some(text) = res_json.get("text").and_then(|t| t.as_str()) {
+        Ok(text.to_string())
+    } else {
+        Err("No transcript returned from API".to_string())
+    }
+}
+
diff --git a/src-tauri/src/commands/fs.rs b/src-tauri/src/commands/fs.rs
index c44f859..eb27ec5 100644
--- a/src-tauri/src/commands/fs.rs
+++ b/src-tauri/src/commands/fs.rs
@@ -534,9 +534,10 @@ pub async fn save_asset(data_base64: String, ext: String, folder: String) -> Res
     let prefix = folder_name.trim_start_matches('.');
 
     // Generate unique filename with random suffix to avoid collisions
-    use rand::Rng;
-    let mut rng = rand::thread_rng();
-    let random_suffix: u32 = rng.gen();
+    let random_suffix: u32 = {
+        use rand::Rng;
+        rand::thread_rng().gen()
+    };
     let filename = format!("{}_{}_{:08x}.{}", prefix, timestamp, random_suffix, clean_ext);
     let file_path = asset_dir.join(&filename);
 
diff --git a/src-tauri/src/commands/shortcuts.rs b/src-tauri/src/commands/shortcuts.rs
index 27aa51e..adaa3fb 100644
--- a/src-tauri/src/commands/shortcuts.rs
+++ b/src-tauri/src/commands/shortcuts.rs
@@ -15,7 +15,43 @@ impl Default for GlobalShortcutState {
     }
 }
 
-fn handle_shortcut_trigger(app: &AppHandle, action: &str) {
+fn handle_shortcut_trigger(app: &AppHandle, action: &str, state: ShortcutState) {
+    if action == "voice-memo" {
+        let event_name = if state == ShortcutState::Pressed {
+            "trigger-voice-memo-press"
+        } else {
+            "trigger-voice-memo-release"
+        };
+        let mut handled = false;
+        if let Some(main_win) = app.get_webview_window("main") {
+            if main_win.is_visible().unwrap_or(false) && main_win.is_focused().unwrap_or(false) {
+                let _ = main_win.emit(event_name, ());
+                handled = true;
+            }
+        }
+        if !handled {
+            if let Some(ind_win) = app.get_webview_window("voice-indicator") {
+                if state == ShortcutState::Pressed {
+                    if let Ok(Some(monitor)) = ind_win.current_monitor() {
+                        let size = monitor.size();
+                        let scale = monitor.scale_factor();
+                        let logical_height = size.height as f64 / scale;
+                        let x = 20.0;
+                        let y = logical_height - 350.0;
+                        let _ = ind_win.set_position(tauri::Position::Logical(tauri::LogicalPosition { x, y }));
+                    }
+                    let _ = ind_win.show();
+                }
+                let _ = ind_win.emit(event_name, ());
+            }
+        }
+        return;
+    }
+
+    if state != ShortcutState::Pressed {
+        return;
+    }
+
     if action == "new-note" {
         if let Some(window) = app.get_webview_window("main") {
             if !window.is_visible().unwrap_or(false) {
@@ -54,9 +90,7 @@ pub fn update_global_shortcut(
         let action_clone = action.clone();
         app.global_shortcut()
             .on_shortcut(shortcut, move |app, _shortcut, event| {
-                if event.state() == ShortcutState::Pressed {
-                    handle_shortcut_trigger(app, &action_clone);
-                }
+                handle_shortcut_trigger(app, &action_clone, event.state());
             })
             .map_err(|e| format!("Failed to register shortcut: {}", e))?;
     }
@@ -87,9 +121,7 @@ pub fn resume_shortcuts(app: AppHandle) -> Result<(), String> {
             let _ = app
                 .global_shortcut()
                 .on_shortcut(shortcut, move |app, _, event| {
-                    if event.state() == ShortcutState::Pressed {
-                        handle_shortcut_trigger(app, &action_clone);
-                    }
+                    handle_shortcut_trigger(app, &action_clone, event.state());
                 });
         }
     }
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 02fab47..6097517 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -178,6 +178,7 @@ pub fn run() {
             commands::keychain::safe_storage_encrypt,
             commands::keychain::safe_storage_decrypt,
             commands::ai::openai_chat,
+            commands::ai::openai_transcribe,
             commands::shortcuts::update_global_shortcut,
             commands::shortcuts::pause_shortcuts,
             commands::shortcuts::resume_shortcuts,
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index bb85fdf..a22e3ac 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -14,16 +14,29 @@
     "macOSPrivateApi": true,
     "windows": [
       {
+        "label": "main",
         "title": "PaperCache",
         "width": 800,
         "height": 600,
         "decorations": false,
         "transparent": true,
         "shadow": true
+      },
+      {
+        "label": "voice-indicator",
+        "title": "Voice Memo",
+        "width": 420,
+        "height": 340,
+        "decorations": false,
+        "transparent": true,
+        "alwaysOnTop": true,
+        "visible": false,
+        "skipTaskbar": true,
+        "shadow": false
       }
     ],
     "security": {
-      "csp": "default-src 'none'; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; connect-src 'self' https:; font-src 'self' data: https:; object-src 'none'; base-uri 'none';"
+      "csp": "default-src 'none'; script-src 'self' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob: file: https:; media-src 'self' data: blob: file: https:; connect-src 'self' https: wss: data: blob: file:; font-src 'self' data: https:; object-src 'none'; base-uri 'none';"
     }
   },
   "bundle": {
@@ -37,7 +50,10 @@
       "icons/icon.icns",
       "icons/icon.ico"
     ],
-    "resources": ["../notes/*"]
+    "resources": ["../notes/*"],
+    "macOS": {
+      "infoPlist": "Info.plist"
+    }
   },
   "plugins": {
     "updater": {
diff --git a/src/App.css b/src/App.css
index 102e53f..24b1d8b 100644
--- a/src/App.css
+++ b/src/App.css
@@ -1192,3 +1192,426 @@ body {
   background: #10b981;
   width: 100% !important;
 }
+
+/* ═══════════════════════════════════════════════════════
+   Memo Voice Panel
+   ═══════════════════════════════════════════════════════ */
+
+.memo-panel {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+  padding: 6px 14px 6px;
+  border-bottom: 1px solid rgba(128, 128, 128, 0.12);
+  background: rgba(128, 128, 128, 0.04);
+  flex-shrink: 0;
+  max-height: 40vh;
+  overflow-y: auto;
+}
+
+/* ── Controls row ── */
+.memo-controls {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  min-height: 30px;
+}
+
+/* Record button */
+.memo-record-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 14px 4px 10px;
+  background: rgba(255, 80, 100, 0.08);
+  border: 1px solid rgba(255, 80, 100, 0.25);
+  border-radius: 20px;
+  color: inherit;
+  font-family: inherit;
+  font-size: 12px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 0.15s, border-color 0.15s, transform 0.1s;
+  letter-spacing: 0.02em;
+}
+.memo-record-btn:hover {
+  background: rgba(255, 80, 100, 0.15);
+  border-color: rgba(255, 80, 100, 0.45);
+  transform: translateY(-1px);
+}
+.memo-record-btn:active {
+  transform: translateY(0);
+}
+
+.memo-mic-icon {
+  font-size: 13px;
+  line-height: 1;
+}
+
+/* Pulse dot (red animated dot during recording) */
+.memo-pulse-dot {
+  width: 9px;
+  height: 9px;
+  border-radius: 50%;
+  background: #ff4d6d;
+  box-shadow: 0 0 0 0 rgba(255, 77, 109, 0.6);
+  animation: memo-pulse 1.4s cubic-bezier(0.4, 0, 0.6, 1) infinite;
+  flex-shrink: 0;
+}
+
+@keyframes memo-pulse {
+  0%   { box-shadow: 0 0 0 0 rgba(255, 77, 109, 0.7); }
+  60%  { box-shadow: 0 0 0 7px rgba(255, 77, 109, 0); }
+  100% { box-shadow: 0 0 0 0 rgba(255, 77, 109, 0); }
+}
+
+/* Elapsed timer */
+.memo-elapsed {
+  font-size: 12px;
+  font-family: 'JetBrains Mono', monospace;
+  opacity: 0.75;
+  letter-spacing: 0.05em;
+  min-width: 36px;
+}
+
+.memo-recording-label {
+  font-size: 11px;
+  opacity: 0.5;
+  letter-spacing: 0.04em;
+  flex: 1;
+}
+
+/* Stop button */
+.memo-stop-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  padding: 3px 12px;
+  background: rgba(128, 128, 128, 0.1);
+  border: 1px solid rgba(128, 128, 128, 0.2);
+  border-radius: 14px;
+  color: inherit;
+  font-family: inherit;
+  font-size: 11px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 0.15s;
+  margin-left: auto;
+}
+.memo-stop-btn:hover {
+  background: rgba(128, 128, 128, 0.2);
+}
+
+/* Processing spinner */
+.memo-processing {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 12px;
+  opacity: 0.6;
+}
+
+.memo-spinner {
+  display: inline-block;
+  width: 12px;
+  height: 12px;
+  border: 2px solid rgba(128, 128, 128, 0.25);
+  border-top-color: currentColor;
+  border-radius: 50%;
+  animation: memo-spin 0.7s linear infinite;
+}
+
+@keyframes memo-spin {
+  to { transform: rotate(360deg); }
+}
+
+.memo-done-label {
+  font-size: 11px;
+  opacity: 0.65;
+  letter-spacing: 0.02em;
+}
+
+/* ── Ghost transcript (collapsible via grid trick) ── */
+.memo-ghost-wrap {
+  display: grid;
+  grid-template-rows: 0fr;
+  transition: grid-template-rows 0.35s ease;
+  overflow: hidden;
+}
+.memo-ghost-wrap.memo-ghost-visible {
+  grid-template-rows: 1fr;
+}
+
+.memo-ghost-inner {
+  min-height: 0;
+  padding: 0;
+  transition: padding 0.35s ease;
+}
+.memo-ghost-visible .memo-ghost-inner {
+  padding: 5px 0 2px;
+}
+
+.memo-ghost-text {
+  display: block;
+  font-size: 11px;
+  color: rgba(128, 128, 128, 0.65);
+  font-style: italic;
+  line-height: 1.5;
+  letter-spacing: 0.01em;
+  word-break: break-word;
+}
+
+/* ── Result area ── */
+.memo-result {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding-top: 8px;
+}
+
+.memo-audio-pill {
+  display: flex;
+  align-items: center;
+}
+.memo-audio-native {
+  width: 100%;
+  height: 28px;
+  border-radius: 20px;
+  outline: none;
+  accent-color: var(--text-color, #333);
+  opacity: 0.85;
+}
+
+/* Interpreted block */
+.memo-interpreted-block {
+  background: rgba(128, 128, 128, 0.06);
+  border: 1px solid rgba(128, 128, 128, 0.18);
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+.memo-interpreted-header {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 6px 10px;
+  border-bottom: 1px solid rgba(128, 128, 128, 0.12);
+  background: rgba(128, 128, 128, 0.04);
+}
+
+.memo-interpreted-icon {
+  font-size: 12px;
+  line-height: 1;
+}
+
+.memo-interpreted-label {
+  font-size: 11px;
+  font-weight: 600;
+  opacity: 0.75;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  flex: 1;
+}
+
+.memo-interpreted-actions {
+  display: flex;
+  gap: 6px;
+}
+
+.memo-interpreted-pre {
+  margin: 0;
+  padding: 8px 10px;
+  font-family: 'JetBrains Mono', monospace;
+  font-size: 11.5px;
+  white-space: pre-wrap;
+  word-break: break-word;
+  line-height: 1.6;
+  color: inherit;
+  opacity: 0.9;
+  max-height: 200px;
+  overflow-y: auto;
+}
+
+.memo-insert-row {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  padding: 6px 10px 8px;
+  border-top: 1px solid rgba(128, 128, 128, 0.1);
+}
+
+/* Action buttons */
+.memo-action-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  padding: 4px 12px;
+  border-radius: 6px;
+  font-family: inherit;
+  font-size: 11px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 0.15s, opacity 0.15s, transform 0.1s;
+  border: 1px solid transparent;
+  letter-spacing: 0.02em;
+}
+.memo-action-btn:active { transform: translateY(1px); }
+
+.memo-action-btn--primary {
+  background: rgba(59, 130, 246, 0.15);
+  border-color: rgba(59, 130, 246, 0.35);
+  color: #3b82f6;
+}
+.memo-action-btn--primary:hover { background: rgba(59, 130, 246, 0.25); }
+
+.memo-action-btn--secondary {
+  background: rgba(128, 128, 128, 0.1);
+  border-color: rgba(128, 128, 128, 0.2);
+  color: inherit;
+  opacity: 0.7;
+}
+.memo-action-btn--secondary:hover { opacity: 1; background: rgba(128, 128, 128, 0.18); }
+
+.memo-action-btn--ghost {
+  background: transparent;
+  border-color: rgba(128, 128, 128, 0.15);
+  color: inherit;
+  opacity: 0.55;
+}
+.memo-action-btn--ghost:hover { opacity: 0.85; background: rgba(128, 128, 128, 0.08); }
+
+/* ── Overlay Root & Panel ── */
+.memo-overlay-root {
+  width: 100vw;
+  height: 100vh;
+  display: flex;
+  align-items: flex-end;
+  justify-content: flex-start;
+  padding: 16px;
+  box-sizing: border-box;
+  background: transparent;
+}
+
+.memo-panel--overlay {
+  background: rgba(20, 20, 25, 0.94);
+  backdrop-filter: blur(16px);
+  border: 1px solid rgba(255, 255, 255, 0.15);
+  border-radius: 14px;
+  padding: 12px 14px;
+  box-shadow: 0 16px 36px rgba(0, 0, 0, 0.5);
+  min-width: 340px;
+  max-width: 400px;
+  max-height: 80vh;
+  overflow-y: auto;
+}
+
+/* ── Pillbox ── */
+.memo-pillbox {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 12px;
+  border-radius: 20px;
+  background: rgba(30, 30, 35, 0.9);
+  border: 1px solid rgba(255, 255, 255, 0.12);
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.25);
+}
+
+.memo-pillbox--recording {
+  border-color: rgba(255, 77, 109, 0.35);
+}
+
+/* ── Audio Waveform Pillbox ── */
+.memo-audio-pillbox {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 6px 12px;
+  background: rgba(128, 128, 128, 0.1);
+  border: 1px solid rgba(128, 128, 128, 0.2);
+  border-radius: 24px;
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.memo-play-pause-btn {
+  background: rgba(59, 130, 246, 0.2);
+  border: 1px solid rgba(59, 130, 246, 0.4);
+  color: #3b82f6;
+  width: 28px;
+  height: 28px;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  font-size: 11px;
+  transition: transform 0.15s, background 0.15s;
+}
+.memo-play-pause-btn:hover {
+  background: rgba(59, 130, 246, 0.35);
+  transform: scale(1.05);
+}
+
+.memo-waveform-visual {
+  display: flex;
+  align-items: center;
+  gap: 3px;
+  flex: 1;
+  height: 22px;
+}
+
+.memo-wave-bar {
+  flex: 1;
+  background: rgba(156, 163, 175, 0.4);
+  border-radius: 2px;
+  height: 4px;
+  transition: height 0.2s ease, background 0.2s ease;
+}
+
+.memo-waveform--playing .memo-wave-bar {
+  background: #3b82f6;
+  animation: memoWaveAnim 1.2s ease-in-out infinite alternate;
+}
+
+.memo-waveform--playing .memo-wave-bar--1 { animation-delay: 0.1s; height: 14px; }
+.memo-waveform--playing .memo-wave-bar--2 { animation-delay: 0.3s; height: 8px; }
+.memo-waveform--playing .memo-wave-bar--3 { animation-delay: 0.5s; height: 18px; }
+.memo-waveform--playing .memo-wave-bar--4 { animation-delay: 0.2s; height: 12px; }
+.memo-waveform--playing .memo-wave-bar--5 { animation-delay: 0.4s; height: 6px; }
+
+@keyframes memoWaveAnim {
+  0% { transform: scaleY(0.4); }
+  100% { transform: scaleY(1.3); }
+}
+
+/* ── Direct Transcript (Gray Slanted) ── */
+.memo-raw-transcript {
+  padding: 6px 10px;
+  margin: 4px 0;
+  border-left: 2px solid rgba(156, 163, 175, 0.35);
+  background: rgba(128, 128, 128, 0.04);
+  border-radius: 0 6px 6px 0;
+}
+
+.memo-gray-slanted {
+  color: #9ca3af;
+  font-style: italic;
+  font-size: 13px;
+  line-height: 1.5;
+  display: block;
+}
+
+/* ── AI Shimmer state ── */
+.memo-ai-shimmer {
+  padding: 12px 14px;
+  font-size: 12px;
+  font-style: italic;
+  color: #60a5fa;
+  animation: memoPulseShimmer 1.5s ease-in-out infinite;
+}
+
+@keyframes memoPulseShimmer {
+  0%, 100% { opacity: 0.6; }
+  50% { opacity: 1; }
+}
diff --git a/src/App.tsx b/src/App.tsx
index 79e70b3..f3a7656 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -11,6 +11,7 @@ import { useAppStore } from './store/useAppStore'
 import { useSettingsStore } from './store/useSettingsStore'
 import { useTimerStore } from './store/useTimerStore'
 import { listen } from '@tauri-apps/api/event'
+import { getCurrentWindow } from '@tauri-apps/api/window'
 
 import { useNoteStorage } from './hooks/useNoteStorage'
 import { useVariables } from './hooks/useVariables'
@@ -21,6 +22,7 @@ import { NoteSearch } from './components/NoteSearch'
 import { MainActionMenu } from './components/MainActionMenu'
 import { NoteTitleBar } from './components/NoteTitleBar'
 import { Editor, type EditorRef } from './components/Editor'
+import { MemoVoicePanel } from './components/MemoVoicePanel'
 import Settings from './Settings'
 
 const TOAST_TIMEOUT_MS = 5000
@@ -28,6 +30,15 @@ const MODAL_Z_INDEX = 9999
 const KEYBINDS_Z_INDEX = 10000
 const TOAST_Z_INDEX = 99999
 
+export function VoiceIndicatorWindow() {
+  const dummyEditorRef = useRef<EditorRef | null>(null)
+  return (
+    <div className="memo-overlay-root">
+      <MemoVoicePanel editorRef={dummyEditorRef} isOverlay={true} />
+    </div>
+  )
+}
+
 function App() {
   const notes = useAppStore((state) => state.notes)
   const setNotes = useAppStore((state) => state.setNotes)
@@ -49,6 +60,7 @@ function App() {
 
   const { themePreset, fontFamily, showRulings, bgType, bgColor, bgImage, textColor, numColor } =
     useSettingsStore()
+  const memoEnabled = useSettingsStore((state) => state.memoEnabled)
 
   const editorRef = useRef<EditorRef>(null)
 
@@ -58,6 +70,10 @@ function App() {
   useGlobalHotkey()
 
   useEffect(() => {
+    if (localStorage.getItem('papercache-memo-v1-enabled') !== 'true') {
+      useSettingsStore.getState().setSettings({ memoEnabled: true })
+      localStorage.setItem('papercache-memo-v1-enabled', 'true')
+    }
     window.electronAPI.checkForUpdates()
     window.electronAPI.restoreWindowState()
     window.electronAPI.isHyprland().then((isHyp) => {
@@ -155,6 +171,43 @@ function App() {
     checkVersion()
   }, [notes, setCurrentNoteIndex])
 
+  useEffect(() => {
+    let unlisten: (() => void) | undefined
+    listen<{ text: string }>('insert-voice-note', async (event) => {
+      const text = event.payload.text
+      try {
+        await getCurrentWindow().show()
+        await getCurrentWindow().setFocus()
+      } catch {
+        /* ignore */
+      }
+      if (editorRef.current?.view) {
+        const view = editorRef.current.view
+        const { from } = view.state.selection.main
+        const insertText = '\n' + text + '\n'
+        view.dispatch({ changes: { from, to: from, insert: insertText } })
+        view.focus()
+      } else {
+        const { notes, currentNoteIndex, setNotes } = useAppStore.getState()
+        const note = notes[currentNoteIndex]
+        if (note) {
+          setNotes(
+            notes.map((n, idx) =>
+              idx === currentNoteIndex ? { ...n, content: n.content + '\n' + text + '\n' } : n
+            )
+          )
+        }
+      }
+    })
+      .then((fn) => {
+        unlisten = fn
+      })
+      .catch(() => {})
+    return () => {
+      if (unlisten) unlisten()
+    }
+  }, [])
+
   const containerStyle: React.CSSProperties = {
     fontFamily: fontFamily,
     '--font-family': fontFamily,
@@ -183,6 +236,7 @@ function App() {
     >
       <NoteTitleBar />
 
+      {memoEnabled && <MemoVoicePanel editorRef={editorRef} />}
       {showRemindersView && (
         <RemindersPage
           notes={notes}
diff --git a/src/Settings.tsx b/src/Settings.tsx
index a50f60a..915bf12 100644
--- a/src/Settings.tsx
+++ b/src/Settings.tsx
@@ -10,6 +10,7 @@ export default function Settings({ onClose }: { onClose?: () => void }) {
   const [apiKey, setApiKey] = useState('')
   const [isApiKeySet, setIsApiKeySet] = useState(false)
   const [updateChecking, setUpdateChecking] = useState(false)
+  const [memoEnabled, setMemoEnabled] = useState(useSettingsStore.getState().memoEnabled)
 
   useEffect(() => {
     window.electronAPI.getApiKeyStatus().then((status) => {
@@ -138,6 +139,7 @@ export default function Settings({ onClose }: { onClose?: () => void }) {
       symColor,
       aiColor,
       mathColor,
+      memoEnabled,
     })
 
     // Startup
@@ -436,6 +438,49 @@ export default function Settings({ onClose }: { onClose?: () => void }) {
           </div>
         </section>
 
+        <section>
+          <h3>Plugins</h3>
+          <div
+            className="setting-group"
+            style={{ flexDirection: 'column', alignItems: 'flex-start', gap: '6px' }}
+          >
+            <div style={{ display: 'flex', alignItems: 'center', gap: '12px', width: '100%' }}>
+              <label style={{ flex: 1, display: 'flex', flexDirection: 'column', gap: '2px' }}>
+                <span
+                  style={{ display: 'flex', alignItems: 'center', gap: '6px', fontWeight: 600 }}
+                >
+                  <span>🎙</span> Memo — Voice Notes
+                </span>
+                <span style={{ fontSize: '11px', color: 'rgba(128,128,128,0.8)', fontWeight: 400 }}>
+                  Record voice, get a live transcript, and auto-convert speech into PaperCache
+                  commands
+                </span>
+              </label>
+              <input
+                id="settings-memo-toggle"
+                type="checkbox"
+                checked={memoEnabled}
+                onChange={(e) => setMemoEnabled(e.target.checked)}
+                style={{ width: 'auto', marginRight: 0, cursor: 'pointer' }}
+                aria-label="Enable Memo voice notes plugin"
+              />
+            </div>
+            {memoEnabled && (
+              <p
+                style={{
+                  fontSize: '11px',
+                  color: 'rgba(128,128,128,0.7)',
+                  margin: 0,
+                  padding: '4px 0 0',
+                }}
+              >
+                ⚠️ Requires an API key — Whisper is used for transcription and your configured model
+                interprets the result.
+              </p>
+            )}
+          </div>
+        </section>
+
         <section>
           <h3>About</h3>
           <div style={{ textAlign: 'center', padding: '10px 0' }}>
diff --git a/src/api.ts b/src/api.ts
index 9d0de17..67272b4 100644
--- a/src/api.ts
+++ b/src/api.ts
@@ -68,4 +68,5 @@ export const tauriApi: ElectronAPI = {
   onUpdateStatus: (callback) => onEvent('update-status', callback),
   saveAsset: (dataBase64, ext, folder) => invoke('save_asset', { dataBase64, ext, folder }),
   readAsset: (assetPath) => invoke('read_asset', { path: assetPath }),
+  openaiTranscribe: (filePath, baseUrl) => invoke('openai_transcribe', { filePath, baseUrl }),
 }
diff --git a/src/components/Editor.tsx b/src/components/Editor.tsx
index dbf62db..5d60d9e 100644
--- a/src/components/Editor.tsx
+++ b/src/components/Editor.tsx
@@ -115,6 +115,7 @@ export const Editor = forwardRef<EditorRef>((_props, ref) => {
           highlightActiveLine: false,
           highlightActiveLineGutter: false,
           highlightSpecialChars: false,
+          lintKeymap: false,
         }}
       />
     </div>
diff --git a/src/components/MemoVoicePanel.tsx b/src/components/MemoVoicePanel.tsx
new file mode 100644
index 0000000..3304c84
--- /dev/null
+++ b/src/components/MemoVoicePanel.tsx
@@ -0,0 +1,620 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { listen, emit } from '@tauri-apps/api/event'
+import { getCurrentWindow } from '@tauri-apps/api/window'
+import { SETTINGS_KEYS } from '../lib/settingsKeys'
+import { type EditorRef } from './Editor'
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+interface SpeechRecognitionEvent {
+  results: { [index: number]: { [index: number]: { transcript: string } } }
+}
+interface SpeechRecognitionInstance {
+  continuous: boolean
+  interimResults: boolean
+  lang: string
+  onresult: ((event: SpeechRecognitionEvent) => void) | null
+  onerror: (() => void) | null
+  start: () => void
+  stop: () => void
+}
+declare global {
+  interface Window {
+    webkitSpeechRecognition?: { new (): SpeechRecognitionInstance }
+    SpeechRecognition?: { new (): SpeechRecognitionInstance }
+  }
+}
+
+type PanelState = 'idle' | 'recording' | 'processing' | 'done'
+
+interface DonePayload {
+  audioPath: string
+  rawTranscript: string
+  interpreted: string
+  isInterpreting?: boolean
+}
+
+// ─── System prompt for interpretation ─────────────────────────────────────────
+
+const INTERPRET_SYSTEM_PROMPT = `You are a command interpreter for PaperCache, a Markdown note-taking app with a custom slash-command DSL.
+Convert the user's voice input into well-structured PaperCache Markdown. Output ONLY the converted content — no explanations, no surrounding quotes, no code fences.
+
+Available commands and syntax:
+- /check <item>              → interactive checkbox (use for todo items, shopping lists, etc.)
+- /checked <item>            → pre-checked checkbox
+- /task <desc> @<time>       → task with optional due date (time formats: 1d2h, tmrw, YYYY-MM-DD HH:MM)
+- /var name = value          → define a local variable
+- /globvar name = value      → define a global variable (available across all notes)
+- /file <note name>          → link to another note
+- /ai <prompt>               → inline AI query
+- # / ## / ###               → headings (h1 / h2 / h3)
+- - or *                     → bullet list items
+- **bold**, *italic*         → text formatting
+- \`code\`                    → inline code
+
+Rules:
+- For shopping lists or checklists: use /check for each item.
+- For to-dos or action items: prefer /task.
+- For structured information: use appropriate headings and bullets.
+- For numeric data or formulas: write them as math expressions followed by =
+- Preserve the user's intent closely; restructure only enough to be useful.
+- Output clean, minimal Markdown — do not pad with extra blank lines.`
+
+// ─── Helper: read audio blob → base64 ─────────────────────────────────────────
+
+function blobToBase64(blob: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader()
+    reader.onloadend = () => resolve(reader.result as string)
+    reader.onerror = reject
+    reader.readAsDataURL(blob)
+  })
+}
+
+// ─── Audio Pillbox with Waveform Visualizer ───────────────────────────────────
+
+function AudioWaveformPill({ audioSrc }: { audioSrc: string }) {
+  const [isPlaying, setIsPlaying] = useState(false)
+  const audioRef = useRef<HTMLAudioElement | null>(null)
+
+  const togglePlay = () => {
+    if (!audioRef.current) return
+    if (isPlaying) {
+      audioRef.current.pause()
+    } else {
+      audioRef.current.play()
+    }
+  }
+
+  return (
+    <div className="memo-audio-pillbox" aria-label="Audio playback pillbox">
+      <button
+        className="memo-play-pause-btn"
+        onClick={togglePlay}
+        aria-label={isPlaying ? 'Pause' : 'Play'}
+      >
+        {isPlaying ? '⏸' : '▶'}
+      </button>
+      <div className={`memo-waveform-visual ${isPlaying ? 'memo-waveform--playing' : ''}`}>
+        {[...Array(18)].map((_, i) => (
+          <span key={i} className={`memo-wave-bar memo-wave-bar--${(i % 5) + 1}`} />
+        ))}
+      </div>
+      <audio
+        ref={audioRef}
+        src={audioSrc}
+        onPlay={() => setIsPlaying(true)}
+        onPause={() => setIsPlaying(false)}
+        onEnded={() => setIsPlaying(false)}
+      />
+    </div>
+  )
+}
+
+// ─── Component ────────────────────────────────────────────────────────────────
+
+export function MemoVoicePanel({
+  editorRef,
+  isOverlay = false,
+}: {
+  editorRef: React.RefObject<EditorRef | null>
+  isOverlay?: boolean
+}) {
+  const [panelState, setPanelState] = useState<PanelState>('idle')
+  const [liveTranscript, setLiveTranscript] = useState('')
+  const [elapsed, setElapsed] = useState(0)
+  const [donePayload, setDonePayload] = useState<DonePayload | null>(null)
+  const [audioSrc, setAudioSrc] = useState<string | null>(null)
+  const [copyFeedback, setCopyFeedback] = useState(false)
+
+  const mediaRecorderRef = useRef<MediaRecorder | null>(null)
+  const chunksRef = useRef<Blob[]>([])
+  const streamRef = useRef<MediaStream | null>(null)
+  const speechRef = useRef<SpeechRecognitionInstance | null>(null)
+  const liveTranscriptRef = useRef('')
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const holdStartRef = useRef<number>(0)
+
+  const panelStateRef = useRef<PanelState>(panelState)
+  const isRecordingRequestedRef = useRef<boolean>(false)
+
+  useEffect(() => {
+    panelStateRef.current = panelState
+  }, [panelState])
+
+  // Clean up on unmount
+  useEffect(() => {
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current)
+      streamRef.current?.getTracks().forEach((t) => t.stop())
+      speechRef.current?.stop()
+    }
+  }, [])
+
+  // Tick the elapsed timer using chained setTimeout (project rule: no setInterval).
+  const tickTimer = useCallback(() => {
+    timerRef.current = setTimeout(() => {
+      setElapsed((prev) => prev + 1)
+      if (mediaRecorderRef.current?.state === 'recording') {
+        timerRef.current = setTimeout(function tick() {
+          setElapsed((prev) => prev + 1)
+          if (mediaRecorderRef.current?.state === 'recording') {
+            timerRef.current = setTimeout(tick, 1000)
+          }
+        }, 1000)
+      }
+    }, 1000)
+  }, [])
+
+  const startRecording = useCallback(async () => {
+    if (panelStateRef.current !== 'idle') return
+    isRecordingRequestedRef.current = true
+    liveTranscriptRef.current = ''
+    chunksRef.current = []
+    setLiveTranscript('')
+    setElapsed(0)
+    setDonePayload(null)
+    setAudioSrc(null)
+
+    if (isOverlay) {
+      try {
+        await getCurrentWindow().show()
+        await getCurrentWindow().setFocus()
+      } catch {
+        /* ignore */
+      }
+    }
+
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true })
+      streamRef.current = stream
+      setPanelState('recording')
+
+      // Start Web Speech API for live transcription
+      const SpeechRec = window.SpeechRecognition || window.webkitSpeechRecognition
+      if (SpeechRec) {
+        try {
+          const rec = new SpeechRec()
+          rec.continuous = true
+          rec.interimResults = true
+          rec.lang = 'en-US'
+          rec.onresult = (event: SpeechRecognitionEvent) => {
+            let transcript = ''
+            for (let i = 0; i < Object.keys(event.results).length; i++) {
+              const res = event.results[i]
+              if (res?.[0]?.transcript) {
+                transcript += res[0].transcript + ' '
+              }
+            }
+            liveTranscriptRef.current = transcript.trim()
+            setLiveTranscript(transcript.trim())
+          }
+          rec.onerror = null
+          rec.start()
+          speechRef.current = rec
+        } catch {
+          // ignore speech recognition init failures
+        }
+      }
+
+      // Start MediaRecorder for the audio file
+      const mimeType = MediaRecorder.isTypeSupported('audio/webm;codecs=opus')
+        ? 'audio/webm;codecs=opus'
+        : MediaRecorder.isTypeSupported('audio/mp4')
+          ? 'audio/mp4'
+          : ''
+      const recorder = mimeType
+        ? new MediaRecorder(stream, { mimeType })
+        : new MediaRecorder(stream)
+      mediaRecorderRef.current = recorder
+
+      recorder.ondataavailable = (e) => {
+        if (e.data && e.data.size > 0) chunksRef.current.push(e.data)
+      }
+
+      recorder.onstop = async () => {
+        if (timerRef.current) clearTimeout(timerRef.current)
+        streamRef.current?.getTracks().forEach((t) => t.stop())
+        streamRef.current = null
+        try {
+          speechRef.current?.stop()
+        } catch {
+          /* ignore */
+        }
+        setPanelState('processing')
+        if (isOverlay) {
+          try {
+            await getCurrentWindow().show()
+          } catch {
+            /* ignore */
+          }
+        }
+
+        const finalMime = recorder.mimeType || 'audio/webm'
+        const ext = finalMime.includes('mp4') || finalMime.includes('m4a') ? 'm4a' : 'webm'
+        const blob = new Blob(chunksRef.current, { type: finalMime })
+
+        try {
+          const base64 = await blobToBase64(blob)
+          const savedPath = await window.electronAPI.saveAsset(base64, ext, '.audio')
+
+          const audioDataUrl = await window.electronAPI.readAsset(savedPath)
+          setAudioSrc(audioDataUrl)
+
+          // Step 1 — Use Web Speech API live transcription directly
+          let rawTranscript = liveTranscriptRef.current.trim()
+          const hasApiKey = await window.electronAPI.getApiKeyStatus()
+
+          // Only attempt backend Whisper transcription if Web Speech API captured nothing
+          if (!rawTranscript && hasApiKey) {
+            try {
+              const baseUrl =
+                localStorage.getItem(SETTINGS_KEYS.API_BASE_URL) || 'https://api.openai.com/v1'
+              const whisperText = await window.electronAPI.openaiTranscribe(savedPath, baseUrl)
+              if (whisperText?.trim()) rawTranscript = whisperText.trim()
+            } catch (err: unknown) {
+              // Ignore Whisper failures if endpoint is incompatible (e.g. OpenRouter key)
+              // eslint-disable-next-line no-console
+              console.warn('[MemoVoicePanel] Whisper transcribe fallback failed:', err)
+            }
+          }
+
+          // Show direct transcript instantly while AI formats reply
+          setDonePayload({
+            audioPath: savedPath,
+            rawTranscript: rawTranscript || 'Voice note recorded (no speech detected)',
+            interpreted: 'Formatting with AI...',
+            isInterpreting: true,
+          })
+          setPanelState('done')
+
+          // Step 2 — interpret transcript with the configured model
+          let interpreted = rawTranscript || 'Voice note recorded (no speech detected)'
+          if (hasApiKey && rawTranscript && !rawTranscript.startsWith('[')) {
+            try {
+              const model =
+                localStorage.getItem(SETTINGS_KEYS.API_MODEL) ||
+                'nvidia/nemotron-3-super-120b-a12b:free'
+              const baseUrl =
+                localStorage.getItem(SETTINGS_KEYS.API_BASE_URL) || 'https://openrouter.ai/api/v1'
+
+              const result = await window.electronAPI.openAIChat({
+                model,
+                baseUrl,
+                messages: [
+                  { role: 'system', content: INTERPRET_SYSTEM_PROMPT },
+                  {
+                    role: 'user',
+                    content: `Convert this voice note to PaperCache markdown:\n\n"${rawTranscript}"`,
+                  },
+                ],
+              })
+              const content = result?.choices?.[0]?.message?.content
+              if (content?.trim()) interpreted = content.trim()
+            } catch (err: unknown) {
+              // eslint-disable-next-line no-console
+              console.error('[MemoVoicePanel] AI interpretation failed:', err)
+              const aiErr =
+                typeof err === 'string' ? err : (err as Error)?.message || 'AI request failed'
+              interpreted = `${rawTranscript}\n\n[AI Formatting Error: ${aiErr}]`
+            }
+          }
+
+          setDonePayload({
+            audioPath: savedPath,
+            rawTranscript: rawTranscript || 'Voice note recorded',
+            interpreted,
+            isInterpreting: false,
+          })
+        } catch (err) {
+          // eslint-disable-next-line no-console
+          console.error('[MemoVoicePanel] Failed to process recording:', err)
+          const errMsg =
+            typeof err === 'string' ? err : (err as Error)?.message || 'Processing error'
+          setDonePayload({
+            audioPath: '',
+            rawTranscript: `[Error processing voice note: ${errMsg}]`,
+            interpreted: `[Error processing voice note: ${errMsg}]`,
+            isInterpreting: false,
+          })
+          setPanelState('done')
+        }
+      }
+
+      recorder.start()
+      tickTimer()
+
+      if (!isRecordingRequestedRef.current) {
+        const elapsedMs = Date.now() - holdStartRef.current
+        const delay = Math.max(0, 400 - elapsedMs)
+        setTimeout(() => {
+          if (mediaRecorderRef.current?.state === 'recording') {
+            mediaRecorderRef.current.stop()
+          }
+        }, delay)
+      }
+    } catch (err: unknown) {
+      // eslint-disable-next-line no-console
+      console.error('[MemoVoicePanel] Microphone access failed:', err)
+      isRecordingRequestedRef.current = false
+      const errMsg =
+        typeof err === 'string' ? err : (err as Error)?.message || 'Microphone access denied'
+      setDonePayload({
+        audioPath: '',
+        rawTranscript: `[Microphone Access Failed: ${errMsg}. Please grant microphone permission in System Settings → Privacy & Security → Microphone.]`,
+        interpreted: `[Microphone Access Failed: ${errMsg}. Please grant microphone permission in System Settings → Privacy & Security → Microphone.]`,
+        isInterpreting: false,
+      })
+      setPanelState('done')
+      if (isOverlay) {
+        try {
+          await getCurrentWindow().show()
+        } catch {
+          /* ignore */
+        }
+      }
+    }
+  }, [isOverlay, tickTimer])
+
+  const stopRecording = useCallback(() => {
+    if (mediaRecorderRef.current?.state === 'recording') {
+      mediaRecorderRef.current.stop()
+    }
+    try {
+      speechRef.current?.stop()
+    } catch {
+      /* ignore */
+    }
+  }, [])
+
+  const stopRecordingSafe = useCallback(() => {
+    isRecordingRequestedRef.current = false
+    if (panelStateRef.current === 'recording') {
+      const elapsedMs = Date.now() - holdStartRef.current
+      if (elapsedMs < 400) {
+        setTimeout(() => {
+          stopRecording()
+        }, 400 - elapsedMs)
+      } else {
+        stopRecording()
+      }
+    }
+  }, [stopRecording])
+
+  // Cmd+Shift+M capture handler for hold-to-record
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if ((e.metaKey || e.ctrlKey) && e.shiftKey && e.key.toLowerCase() === 'm') {
+        e.preventDefault()
+        e.stopPropagation()
+        if (!e.repeat && panelStateRef.current === 'idle') {
+          holdStartRef.current = Date.now()
+          startRecording()
+        }
+      }
+    }
+
+    const handleKeyUp = (e: KeyboardEvent) => {
+      if (
+        e.key.toLowerCase() === 'm' ||
+        e.key === 'Shift' ||
+        e.key === 'Meta' ||
+        e.key === 'Control'
+      ) {
+        stopRecordingSafe()
+      }
+    }
+
+    window.addEventListener('keydown', handleKeyDown, { capture: true })
+    window.addEventListener('keyup', handleKeyUp, { capture: true })
+    return () => {
+      window.removeEventListener('keydown', handleKeyDown, { capture: true })
+      window.removeEventListener('keyup', handleKeyUp, { capture: true })
+    }
+  }, [startRecording, stopRecordingSafe])
+
+  // Listen for global shortcut trigger from Rust
+  useEffect(() => {
+    let unlistenPress: (() => void) | undefined
+    let unlistenRelease: (() => void) | undefined
+    let unlistenLegacy: (() => void) | undefined
+
+    listen('trigger-voice-memo-press', () => {
+      if (panelStateRef.current === 'idle') {
+        holdStartRef.current = Date.now()
+        startRecording()
+      }
+    })
+      .then((fn) => {
+        unlistenPress = fn
+      })
+      .catch(() => {})
+
+    listen('trigger-voice-memo-release', () => {
+      stopRecordingSafe()
+    })
+      .then((fn) => {
+        unlistenRelease = fn
+      })
+      .catch(() => {})
+
+    listen('trigger-voice-memo', () => {
+      if (panelStateRef.current === 'idle') {
+        holdStartRef.current = Date.now()
+        startRecording()
+      } else {
+        stopRecordingSafe()
+      }
+    })
+      .then((fn) => {
+        unlistenLegacy = fn
+      })
+      .catch(() => {})
+
+    return () => {
+      if (unlistenPress) unlistenPress()
+      if (unlistenRelease) unlistenRelease()
+      if (unlistenLegacy) unlistenLegacy()
+    }
+  }, [startRecording, stopRecordingSafe])
+
+  const insertIntoNote = useCallback(async () => {
+    if (!donePayload) return
+    if (isOverlay) {
+      await emit('insert-voice-note', { text: donePayload.interpreted })
+      try {
+        await getCurrentWindow().hide()
+      } catch {
+        /* ignore */
+      }
+    } else if (editorRef.current?.view) {
+      const view = editorRef.current.view
+      const { from } = view.state.selection.main
+      const insertText = '\n' + donePayload.interpreted + '\n'
+      view.dispatch({ changes: { from, to: from, insert: insertText } })
+      view.focus()
+    } else {
+      await emit('insert-voice-note', { text: donePayload.interpreted })
+    }
+    setDonePayload(null)
+    setAudioSrc(null)
+    setPanelState('idle')
+  }, [donePayload, editorRef, isOverlay])
+
+  const discard = useCallback(async () => {
+    if (isOverlay) {
+      try {
+        await getCurrentWindow().hide()
+      } catch {
+        /* ignore */
+      }
+    }
+    setDonePayload(null)
+    setAudioSrc(null)
+    setPanelState('idle')
+  }, [isOverlay])
+
+  const copyInterpreted = useCallback(() => {
+    if (!donePayload) return
+    navigator.clipboard.writeText(donePayload.interpreted).then(() => {
+      setCopyFeedback(true)
+      setTimeout(() => setCopyFeedback(false), 1500)
+    })
+  }, [donePayload])
+
+  const formatTime = (secs: number) => {
+    const m = Math.floor(secs / 60)
+    const s = secs % 60
+    return `${m}:${s < 10 ? '0' : ''}${s}`
+  }
+
+  // ── Render ─────────────────────────────────────────────────────────────────
+
+  if (panelState === 'idle') return null
+
+  return (
+    <div
+      className={`memo-panel ${isOverlay ? 'memo-panel--overlay' : ''}`}
+      aria-label="Memo voice notes panel"
+      onClick={(e) => e.stopPropagation()}
+      onMouseDown={(e) => e.stopPropagation()}
+    >
+      {panelState === 'recording' && (
+        <div className="memo-pillbox memo-pillbox--recording">
+          <span className="memo-pulse-dot" aria-hidden="true" />
+          <span className="memo-elapsed">{formatTime(elapsed)}</span>
+          <span className="memo-recording-label">
+            {liveTranscript ? `“${liveTranscript}”` : 'Recording…'}
+          </span>
+        </div>
+      )}
+
+      {panelState === 'processing' && (
+        <div className="memo-pillbox memo-pillbox--processing">
+          <span className="memo-spinner" aria-hidden="true" />
+          <span className="memo-processing-text">Transcribing audio…</span>
+        </div>
+      )}
+
+      {panelState === 'done' && donePayload && (
+        <div className="memo-result" aria-label="Voice note result">
+          {audioSrc && <AudioWaveformPill audioSrc={audioSrc} />}
+
+          {donePayload.rawTranscript && (
+            <div className="memo-raw-transcript" aria-label="Direct transcription">
+              <em className="memo-gray-slanted">"{donePayload.rawTranscript}"</em>
+            </div>
+          )}
+
+          <div className="memo-interpreted-block">
+            <div className="memo-interpreted-header">
+              <span className="memo-interpreted-icon" aria-hidden="true">
+                {donePayload.isInterpreting ? '⏳' : '✨'}
+              </span>
+              <span className="memo-interpreted-label">
+                {donePayload.isInterpreting ? 'Formatting with AI…' : 'AI Reply'}
+              </span>
+              {!donePayload.isInterpreting && (
+                <div className="memo-interpreted-actions">
+                  <button
+                    id="memo-copy-btn"
+                    className="memo-action-btn memo-action-btn--secondary"
+                    onClick={copyInterpreted}
+                    aria-label="Copy interpreted text"
+                    title="Copy to clipboard"
+                  >
+                    {copyFeedback ? '✓ Copied' : '⎘ Copy'}
+                  </button>
+                </div>
+              )}
+            </div>
+            {donePayload.isInterpreting ? (
+              <div className="memo-ai-shimmer">Structuring your notes with PaperCache DSL...</div>
+            ) : (
+              <pre className="memo-interpreted-pre">{donePayload.interpreted}</pre>
+            )}
+            <div className="memo-insert-row">
+              <button
+                id="memo-discard-btn"
+                className="memo-action-btn memo-action-btn--ghost"
+                onClick={discard}
+                aria-label="Discard voice note result"
+              >
+                Discard
+              </button>
+              <button
+                id="memo-insert-btn"
+                className="memo-action-btn memo-action-btn--primary"
+                onClick={insertIntoNote}
+                disabled={donePayload.isInterpreting}
+                aria-label="Insert interpreted text into note"
+              >
+                Insert into Note ↓
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/src/hooks/useGlobalHotkey.ts b/src/hooks/useGlobalHotkey.ts
index 1b0dee7..91764c3 100644
--- a/src/hooks/useGlobalHotkey.ts
+++ b/src/hooks/useGlobalHotkey.ts
@@ -236,6 +236,13 @@ Type \`/\` in the editor for inline suggestions:
     if (window.electronAPI.updateGlobalShortcut) {
       window.electronAPI.updateGlobalShortcut('toggle', '', toggleShortcut)
     }
+    const voiceMemoShortcut = getShortcut(
+      SETTINGS_KEYS.SHORTCUT_VOICE_MEMO,
+      `${defaultMod}+Shift+M`
+    )
+    if (window.electronAPI.updateGlobalShortcut) {
+      window.electronAPI.updateGlobalShortcut('voice-memo', '', voiceMemoShortcut)
+    }
 
     // Listen for global new note shortcut
     let disposeNewNote: (() => void) | undefined
diff --git a/src/main.tsx b/src/main.tsx
index d004dcb..d0cafa8 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -1,15 +1,16 @@
 import { StrictMode, useEffect, useState } from 'react'
 import { createRoot } from 'react-dom/client'
 import './index.css'
-import App from './App.tsx'
+import App, { VoiceIndicatorWindow } from './App.tsx'
 import Settings from './Settings.tsx'
 import { ErrorBoundary } from './components/ErrorBoundary.tsx'
+import { getCurrentWindow } from '@tauri-apps/api/window'
 
 import { tauriApi } from './api'
 window.electronAPI = tauriApi
 
 // eslint-disable-next-line react-refresh/only-export-components
-function Root() {
+function MainRoot() {
   const [hash, setHash] = useState(window.location.hash)
   const [migrated, setMigrated] = useState(false)
 
@@ -69,4 +70,18 @@ function Root() {
   )
 }
 
+// eslint-disable-next-line react-refresh/only-export-components
+function Root() {
+  if (getCurrentWindow().label === 'voice-indicator') {
+    return (
+      <StrictMode>
+        <ErrorBoundary>
+          <VoiceIndicatorWindow />
+        </ErrorBoundary>
+      </StrictMode>
+    )
+  }
+  return <MainRoot />
+}
+
 createRoot(document.getElementById('root')!).render(<Root />)
diff --git a/src/setupTests.ts b/src/setupTests.ts
index daa8793..e9f236e 100644
--- a/src/setupTests.ts
+++ b/src/setupTests.ts
@@ -87,7 +87,8 @@ if (typeof window !== 'undefined') {
     onUpdateStatus: vi.fn().mockReturnValue(() => {}),
     saveAsset: vi.fn().mockResolvedValue('/.images/test.png'),
     readAsset: vi.fn().mockResolvedValue('data:image/png;base64,'),
-  } as ElectronAPI
+    openaiTranscribe: vi.fn().mockResolvedValue('test transcript'),
+  } as unknown as ElectronAPI
 }
 
 afterEach(() => {
diff --git a/src/store/useSettingsStore.ts b/src/store/useSettingsStore.ts
index b4e1dd2..1e2f42a 100644
--- a/src/store/useSettingsStore.ts
+++ b/src/store/useSettingsStore.ts
@@ -13,6 +13,7 @@ export interface SettingsState {
   symColor: string
   aiColor: string
   mathColor: string
+  memoEnabled: boolean
 
   setSettings: (
     settings:
@@ -35,6 +36,7 @@ export const useSettingsStore = create<SettingsState>()(
       symColor: '#ff0000',
       aiColor: '#8b5cf6',
       mathColor: '#10b981',
+      memoEnabled: true,
 
       setSettings: (settings) =>
         set((state) => ({
diff --git a/src/types.d.ts b/src/types.d.ts
index 68af16a..a7f983d 100644
--- a/src/types.d.ts
+++ b/src/types.d.ts
@@ -57,6 +57,7 @@ export interface ElectronAPI {
   onUpdateStatus: (callback: (payload: UpdateStatusPayload) => void) => () => void
   saveAsset: (dataBase64: string, ext: string, folder: string) => Promise<string>
   readAsset: (assetPath: string) => Promise<string>
+  openaiTranscribe: (filePath: string, baseUrl: string) => Promise<string>
 }
 
 declare global {