markupr 2.1.8 → 2.5.0

package/dist/main/index.mjs

@@ -1,12 +1,13 @@
 import { app, globalShortcut, dialog, shell, Notification, systemPreferences, ipcMain, safeStorage, nativeImage, Tray, Menu, clipboard, BrowserWindow, screen, desktopCapturer } from "electron";
 import * as fs from "fs/promises";
-import { mkdir, writeFile, unlink, readFile, stat } from "fs/promises";
+import { mkdir, writeFile, unlink, chmod, readFile, stat } from "fs/promises";
 import * as path from "path";
-import path__default, { join, dirname, basename, extname } from "path";
+import path__default, { join, dirname, basename, resolve, extname } from "path";
 import { fileURLToPath } from "url";
 import Store from "electron-store";
 import { randomUUID } from "crypto";
 import { EventEmitter } from "events";
+import * as fsSync from "fs";
 import { existsSync, statSync, createWriteStream, unlinkSync, mkdirSync, renameSync } from "fs";
 import * as keytar from "keytar";
 import { execFile as execFile$1 } from "child_process";
@@ -529,6 +530,143 @@ function getHotkeyManager(config) {
   return hotkeyManagerInstance;
 }
 const hotkeyManager = getHotkeyManager();
+function isMacOS() {
+  const nodeProcess = globalThis.process;
+  if (nodeProcess?.platform) {
+    return nodeProcess.platform === "darwin";
+  }
+  if (typeof navigator !== "undefined" && navigator.platform) {
+    return navigator.platform.toUpperCase().includes("MAC");
+  }
+  return false;
+}
+const HOTKEYS = [
+  {
+    id: "toggleRecording",
+    label: "Toggle Recording",
+    description: "Start or stop recording",
+    macAccelerator: "Command+Shift+F",
+    winLinuxAccelerator: "Ctrl+Shift+F"
+  },
+  {
+    id: "manualScreenshot",
+    label: "Manual Screenshot",
+    description: "Capture screenshot immediately",
+    macAccelerator: "Command+Shift+S",
+    winLinuxAccelerator: "Ctrl+Shift+S"
+  },
+  {
+    id: "pauseResume",
+    label: "Pause/Resume",
+    description: "Pause or resume recording",
+    macAccelerator: "Command+Shift+P",
+    winLinuxAccelerator: "Ctrl+Shift+P"
+  },
+  {
+    id: "openSettings",
+    label: "Open Settings",
+    description: "Open settings panel",
+    macAccelerator: "Command+,",
+    winLinuxAccelerator: "Ctrl+,"
+  },
+  {
+    id: "showHelp",
+    label: "Show Help",
+    description: "Show keyboard shortcuts",
+    macAccelerator: "Command+?",
+    winLinuxAccelerator: "Ctrl+Shift+/"
+  },
+  {
+    id: "quit",
+    label: "Quit",
+    description: "Quit markupr",
+    macAccelerator: "Command+Q",
+    winLinuxAccelerator: "Alt+F4"
+  }
+];
+const MAC_SYMBOLS = {
+  command: "Cmd",
+  cmd: "Cmd",
+  control: "Ctrl",
+  ctrl: "Ctrl",
+  option: "Option",
+  alt: "Option",
+  shift: "Shift",
+  enter: "Enter",
+  return: "Return",
+  delete: "Delete",
+  backspace: "Delete",
+  escape: "Esc",
+  esc: "Esc",
+  tab: "Tab",
+  space: "Space",
+  up: "Up",
+  down: "Down",
+  left: "Left",
+  right: "Right",
+  pageup: "Page Up",
+  pagedown: "Page Down",
+  home: "Home",
+  end: "End",
+  fn: "Fn"
+};
+const WIN_LINUX_NAMES = {
+  command: "Ctrl",
+  cmd: "Ctrl",
+  control: "Ctrl",
+  ctrl: "Ctrl",
+  option: "Alt",
+  alt: "Alt",
+  shift: "Shift",
+  enter: "Enter",
+  return: "Enter",
+  delete: "Del",
+  backspace: "Backspace",
+  escape: "Esc",
+  esc: "Esc",
+  tab: "Tab",
+  space: "Space",
+  up: "Up",
+  down: "Down",
+  left: "Left",
+  right: "Right",
+  pageup: "Page Up",
+  pagedown: "Page Down",
+  home: "Home",
+  end: "End",
+  fn: "Fn"
+};
+function getHotkeyById(id) {
+  return HOTKEYS.find((h) => h.id === id);
+}
+function getAccelerator(hotkeyId) {
+  const hotkey = getHotkeyById(hotkeyId);
+  if (!hotkey) return "";
+  return isMacOS() ? hotkey.macAccelerator : hotkey.winLinuxAccelerator;
+}
+function parseAccelerator(accelerator) {
+  return accelerator.split("+").map((k) => k.trim());
+}
+function getDisplayKeys(accelerator) {
+  const keys = parseAccelerator(accelerator);
+  const platform = isMacOS();
+  return keys.map((key) => {
+    const lowerKey = key.toLowerCase();
+    if (platform) {
+      return MAC_SYMBOLS[lowerKey] || key.toUpperCase();
+    } else {
+      return WIN_LINUX_NAMES[lowerKey] || key.toUpperCase();
+    }
+  });
+}
+function formatAcceleratorForDisplay(accelerator) {
+  const keys = getDisplayKeys(accelerator);
+  return keys.join("+");
+}
+function formatHotkeyForDisplay(hotkeyId) {
+  const accelerator = getAccelerator(hotkeyId);
+  return formatAcceleratorForDisplay(accelerator);
+}
 const MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024;
 const MAX_LOG_LINES = 1e4;
 const LOG_ROTATION_CHECK_INTERVAL_MS = 6e4;
@@ -539,6 +677,9 @@ class ErrorHandler {
   flushTimer = null;
   rotationTimer = null;
   isInitialized = false;
+  lastNotificationAt = 0;
+  NOTIFICATION_RATE_LIMIT_MS = 3e3;
+  // Min 3s between notifications
   constructor() {
     this.logPath = path.join(app.getPath("logs"), "markupr.log");
   }
@@ -554,7 +695,12 @@ class ErrorHandler {
         () => this.checkLogRotation(),
         LOG_ROTATION_CHECK_INTERVAL_MS
       );
-      this.flushTimer = setInterval(() => this.flushLogs(), 5e3);
+      this.flushTimer = setInterval(() => {
+        try {
+          this.flushLogs();
+        } catch {
+        }
+      }, 5e3);
       this.isInitialized = true;
       this.log("info", "ErrorHandler initialized", { component: "ErrorHandler" });
     } catch (error) {
@@ -574,18 +720,25 @@ class ErrorHandler {
    * Handle permission errors and guide user to system settings
    */
   async handlePermissionError(type) {
+    const settingsName = process.platform === "darwin" ? "System Settings" : process.platform === "win32" ? "Windows Settings" : "system settings";
     const messages = {
       microphone: {
         title: "Microphone Access Required",
         message: "markupr needs microphone access to capture your voice feedback.",
-        detail: 'Click "Open Settings" to grant microphone permission in System Settings.\n\nAfter enabling, you may need to restart the app.',
-        pane: "Privacy_Microphone"
+        detail: `Click "Open Settings" to grant microphone permission in ${settingsName}.
+
+After enabling, you may need to restart the app.`,
+        pane: "Privacy_Microphone",
+        winSettings: "ms-settings:privacy-microphone"
       },
       screen: {
         title: "Screen Recording Required",
         message: "markupr needs screen recording permission to capture screenshots.",
-        detail: 'Click "Open Settings" to grant screen recording permission in System Settings.\n\nYou will need to restart the app after enabling.',
-        pane: "Privacy_ScreenCapture"
+        detail: `Click "Open Settings" to grant screen recording permission in ${settingsName}.
+
+You will need to restart the app after enabling.`,
+        pane: "Privacy_ScreenCapture",
+        winSettings: "ms-settings:privacy-screencapture"
       }
     };
     const config = messages[type];
@@ -610,7 +763,8 @@ class ErrorHandler {
         );
         this.log("info", `Opened system preferences for ${type}`);
       } else if (process.platform === "win32") {
-        await shell.openExternal("ms-settings:privacy-microphone");
+        await shell.openExternal(config.winSettings);
+        this.log("info", `Opened Windows settings for ${type}`);
       }
       return true;
     }
@@ -829,6 +983,11 @@ Please restart the app to continue.`,
    * Show a non-blocking notification to the user
    */
   notifyUser(title, message) {
+    const now = Date.now();
+    if (now - this.lastNotificationAt < this.NOTIFICATION_RATE_LIMIT_MS) {
+      return;
+    }
+    this.lastNotificationAt = now;
     this.emitToRenderer(IPC_CHANNELS.NOTIFICATION, { title, message });
     if (Notification.isSupported()) {
       new Notification({
@@ -1090,6 +1249,12 @@ class AudioCaptureServiceImpl extends EventEmitter {
   recoveryChunks = [];
   recoveryInterval = null;
   // Full-session audio capture (used for post-session transcription + retry workflows)
+  // Memory cap prevents unbounded growth during long sessions. At 16kHz mono
+  // with 4 bytes/sample, a 30-minute session produces ~115MB of PCM data plus
+  // encoded chunks in parallel. The cap ensures total audio memory stays under
+  // control, especially on machines with limited RAM.
+  static MAX_SESSION_AUDIO_BYTES = 200 * 1024 * 1024;
+  // 200MB
   sessionAudioChunks = [];
   sessionAudioBytes = 0;
   sessionAudioDurationMs = 0;
@@ -1098,6 +1263,7 @@ class AudioCaptureServiceImpl extends EventEmitter {
   encodedAudioBytes = 0;
   encodedAudioDurationMs = 0;
   encodedAudioMimeType = null;
+  sessionAudioCapWarningLogged = false;
   constructor(config = {}) {
     super();
     this.config = { ...DEFAULT_CONFIG$1, ...config };
@@ -1172,7 +1338,7 @@ class AudioCaptureServiceImpl extends EventEmitter {
    * This requests device list from renderer via IPC
    */
   async getDevices() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (!this.mainWindow) {
         reject(new Error("Main window not set"));
         return;
@@ -1183,7 +1349,7 @@ class AudioCaptureServiceImpl extends EventEmitter {
       const handler = (_event, devices) => {
         clearTimeout(timeout);
         ipcMain.removeListener(AUDIO_IPC_CHANNELS.DEVICES_RESPONSE, handler);
-        resolve(devices);
+        resolve2(devices);
       };
       ipcMain.on(AUDIO_IPC_CHANNELS.DEVICES_RESPONSE, handler);
       this.mainWindow.webContents.send(AUDIO_IPC_CHANNELS.REQUEST_DEVICES);
@@ -1232,7 +1398,7 @@ class AudioCaptureServiceImpl extends EventEmitter {
       });
       throw windowError;
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timeout = setTimeout(() => {
         reject(new Error("Audio capture start timeout"));
       }, 1e4);
@@ -1256,9 +1422,10 @@ class AudioCaptureServiceImpl extends EventEmitter {
         this.encodedAudioBytes = 0;
         this.encodedAudioDurationMs = 0;
         this.encodedAudioMimeType = null;
+        this.sessionAudioCapWarningLogged = false;
         this.startRecoveryBuffer();
         console.log("[AudioCapture] Capture started");
-        resolve();
+        resolve2();
       };
       const errorHandler2 = (_event, error) => {
         clearTimeout(timeout);
@@ -1462,8 +1629,8 @@ class AudioCaptureServiceImpl extends EventEmitter {
     if (this.stopPromise) {
       return this.stopPromise;
     }
-    this.stopPromise = new Promise((resolve) => {
-      this.resolveStopPromise = resolve;
+    this.stopPromise = new Promise((resolve2) => {
+      this.resolveStopPromise = resolve2;
     });
     return this.stopPromise;
   }
@@ -1500,6 +1667,7 @@ class AudioCaptureServiceImpl extends EventEmitter {
       this.sessionAudioBytes += buffer.byteLength;
       this.sessionAudioDurationMs += Math.max(0, data.duration || this.config.chunkDurationMs);
       this.sessionAudioMimeType = "audio/wav";
+      this.enforceSessionAudioCap();
       this.emit("audioChunk", chunk);
       return;
     }
@@ -1512,6 +1680,7 @@ class AudioCaptureServiceImpl extends EventEmitter {
     this.encodedAudioDurationMs += Math.max(0, data.duration || this.config.chunkDurationMs);
     this.encodedAudioMimeType = data.mimeType || this.encodedAudioMimeType || "audio/webm";
     this.recoveryChunks.push(encodedBuffer);
+    this.enforceSessionAudioCap();
     const level = Number.isFinite(data.audioLevel) ? Math.max(0, Math.min(1, Number(data.audioLevel))) : Math.max(0, Math.min(1, encodedBuffer.byteLength / 6e3));
     this.currentAudioLevel = level;
     this.emit("audioLevel", level);
@@ -1557,6 +1726,38 @@ class AudioCaptureServiceImpl extends EventEmitter {
     }
   }
   // ==========================================================================
+  // Memory Management
+  // ==========================================================================
+  /**
+   * Enforce the session audio memory cap across both PCM and encoded buffers.
+   * Drops oldest chunks from whichever buffer is larger until total is under
+   * 80% of the cap, preserving the most recent audio for transcription quality.
+   */
+  enforceSessionAudioCap() {
+    const totalBytes = this.sessionAudioBytes + this.encodedAudioBytes;
+    if (totalBytes <= AudioCaptureServiceImpl.MAX_SESSION_AUDIO_BYTES) {
+      return;
+    }
+    if (!this.sessionAudioCapWarningLogged) {
+      console.warn(
+        `[AudioCapture] Session audio memory cap reached (${Math.round(totalBytes / 1024 / 1024)}MB). Dropping oldest chunks to stay under ${Math.round(AudioCaptureServiceImpl.MAX_SESSION_AUDIO_BYTES / 1024 / 1024)}MB.`
+      );
+      this.sessionAudioCapWarningLogged = true;
+    }
+    const targetBytes = Math.floor(AudioCaptureServiceImpl.MAX_SESSION_AUDIO_BYTES * 0.8);
+    while (this.sessionAudioBytes + this.encodedAudioBytes > targetBytes && (this.sessionAudioChunks.length > 1 || this.encodedAudioChunks.length > 1)) {
+      if (this.sessionAudioBytes >= this.encodedAudioBytes && this.sessionAudioChunks.length > 1) {
+        const removed = this.sessionAudioChunks.shift();
+        this.sessionAudioBytes -= removed.byteLength;
+      } else if (this.encodedAudioChunks.length > 1) {
+        const removed = this.encodedAudioChunks.shift();
+        this.encodedAudioBytes -= removed.byteLength;
+      } else {
+        break;
+      }
+    }
+  }
+  // ==========================================================================
   // Recovery Buffer Management
   // ==========================================================================
   /**
@@ -1977,7 +2178,7 @@ class SettingsManager {
   }
   setFallbackApiKey(service, key) {
     if (!this.canUseEncryptedFallback()) {
-      throw new Error("safeStorage encryption is unavailable");
+      throw new Error("Secure storage is unavailable. API keys cannot be saved until the app is fully initialized. Try restarting markupr.");
     }
     const encrypted = safeStorage.encryptString(key).toString("base64");
     this.secureStore.set(service, encrypted);
@@ -2012,6 +2213,8 @@ class SettingsManager {
   setInsecureApiKey(service, key) {
     const storeKey = this.getInsecureStoreKey(service);
     this.secureStore.set(storeKey, key);
+    chmod(this.secureStore.path, 384).catch(() => {
+    });
     const legacyMap = this.store.get(
       LEGACY_INSECURE_SECRET_STORE_KEY
     ) || {};
@@ -2102,7 +2305,7 @@ class SettingsManager {
           console.log(`[SettingsManager] Stored API key for ${service} via plaintext fallback`);
         } catch (insecureError) {
           throw new Error(
-            `Unable to store API key for ${service}: ${insecureError instanceof Error ? insecureError.message : String(insecureError)}`
+            `Unable to store API key for ${service}. All storage methods failed. Try restarting markupr or check filesystem permissions. (${insecureError instanceof Error ? insecureError.message : String(insecureError)})`
           );
         }
       }
@@ -2220,13 +2423,18 @@ class SettingsManager {
   // IPC Handlers
   // --------------------------------------------------------------------------
   /**
-   * Register IPC handlers for renderer communication
+   * Register IPC handlers for renderer communication.
+   *
+   * @deprecated Use registerSettingsHandlers() from src/main/ipc/settingsHandlers.ts instead.
+   * This method is retained for interface compatibility but should not be called directly.
+   * The handlers in settingsHandlers.ts include input validation and service name whitelisting.
    */
   registerIpcHandlers() {
     if (this.ipcRegistered) {
       console.warn("[SettingsManager] IPC handlers already registered");
       return;
     }
+    const ALLOWED_API_SERVICES = /* @__PURE__ */ new Set(["openai", "anthropic"]);
     ipcMain.handle(IPC_CHANNELS.SETTINGS_GET, (_, key) => {
       return this.get(key);
     });
@@ -2238,17 +2446,21 @@ class SettingsManager {
       return this.get(key);
     });
     ipcMain.handle(IPC_CHANNELS.SETTINGS_GET_API_KEY, async (_, service) => {
+      if (!ALLOWED_API_SERVICES.has(service)) return null;
       return this.getApiKey(service);
     });
     ipcMain.handle(IPC_CHANNELS.SETTINGS_SET_API_KEY, async (_, service, key) => {
+      if (!ALLOWED_API_SERVICES.has(service)) return false;
       await this.setApiKey(service, key);
       return true;
     });
     ipcMain.handle(IPC_CHANNELS.SETTINGS_DELETE_API_KEY, async (_, service) => {
+      if (!ALLOWED_API_SERVICES.has(service)) return false;
       await this.deleteApiKey(service);
       return true;
     });
     ipcMain.handle(IPC_CHANNELS.SETTINGS_HAS_API_KEY, async (_, service) => {
+      if (!ALLOWED_API_SERVICES.has(service)) return false;
       return this.hasApiKey(service);
     });
     this.ipcRegistered = true;
@@ -2327,9 +2539,10 @@ class WhisperService extends EventEmitter {
    */
   getModelsDirectory() {
     try {
-      return join(app.getPath("userData"), "whisper-models");
+      const { app: app2 } = require2("electron");
+      return join(app2.getPath("userData"), "whisper-models");
     } catch {
-      const homeDir = process.env.HOME || process.env.USERPROFILE || "/tmp";
+      const homeDir = process.env.HOME || process.env.USERPROFILE || os.homedir();
       return join(homeDir, ".markupr", "whisper-models");
     }
   }
@@ -2494,12 +2707,28 @@ class WhisperService extends EventEmitter {
     if (!this.whisperModule) {
       throw new Error("Whisper module not loaded");
     }
-    const result = await this.whisperModule.whisper(samples, {
-      modelPath: this.config.modelPath,
-      language: this.config.language,
-      threads: this.config.threads,
-      translate: this.config.translateToEnglish
+    const CHUNK_TIMEOUT_MS = 6e4;
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(
+        () => reject(new Error("Whisper transcription timed out after 60s")),
+        CHUNK_TIMEOUT_MS
+      );
     });
+    let result;
+    try {
+      result = await Promise.race([
+        this.whisperModule.whisper(samples, {
+          modelPath: this.config.modelPath,
+          language: this.config.language,
+          threads: this.config.threads,
+          translate: this.config.translateToEnglish
+        }),
+        timeoutPromise
+      ]);
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
     if (!result || result.length === 0) {
       return [];
     }
@@ -2547,7 +2776,7 @@ class WhisperService extends EventEmitter {
       const percent = Math.round((i + 1) / totalChunks * 100);
       onProgress?.(percent);
       if (i < totalChunks - 1) {
-        await new Promise((resolve) => setTimeout(resolve, 0));
+        await new Promise((resolve2) => setTimeout(resolve2, 0));
       }
     }
     this.log(`Transcription complete: ${results.length} segment(s)`);
@@ -2694,8 +2923,9 @@ class WhisperService extends EventEmitter {
   async convertWithFfmpeg(audioPath) {
     const ffmpegAvailable = await this.isFfmpegAvailable();
     if (!ffmpegAvailable) {
+      const installHint = process.platform === "darwin" ? "brew install ffmpeg" : process.platform === "win32" ? "winget install ffmpeg or download from https://ffmpeg.org" : "apt install ffmpeg (Debian/Ubuntu) or dnf install ffmpeg (Fedora)";
       throw new Error(
-        "ffmpeg is not available on this system. ffmpeg is required to transcribe non-WAV audio files (webm, ogg, m4a). Install ffmpeg via: brew install ffmpeg (macOS) or apt install ffmpeg (Linux)."
+        `ffmpeg is not available on this system. ffmpeg is required to transcribe non-WAV audio files (webm, ogg, m4a). Install ffmpeg via: ${installHint}.`
       );
     }
     const tempFileName = `markupr-transcode-${randomUUID()}.wav`;
@@ -2715,7 +2945,11 @@ class WhisperService extends EventEmitter {
         "pcm_f32le",
         "-y",
         tempPath
-      ]);
+      ], {
+        env: { PATH: process.env.PATH, HOME: process.env.HOME, LANG: process.env.LANG, TMPDIR: process.env.TMPDIR }
+      });
+      await chmod(tempPath, 384).catch(() => {
+      });
       this.log("ffmpeg conversion complete, parsing WAV...");
       return await this.parseWavFile(tempPath);
     } catch (error) {
@@ -2927,7 +3161,7 @@ async function recoverWithOpenAI(audioAsset, sessionStartSec, apiKey, maxAttempt
       );
       if (attempt < maxAttempts) {
         const delayMs = 500 * attempt;
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        await new Promise((resolve2) => setTimeout(resolve2, delayMs));
       }
     }
   }
@@ -2945,7 +3179,7 @@ async function recoverWithWhisper(audioSamples, sessionStartSec, maxAttempts) {
         const chunkSegments = await whisperService.transcribeSamples(chunk, chunkStartSec);
         recoveredSegments.push(...chunkSegments);
         if (offset + chunkSamples < audioSamples.length) {
-          await new Promise((resolve) => setTimeout(resolve, 0));
+          await new Promise((resolve2) => setTimeout(resolve2, 0));
         }
       }
       const recoveredEvents = recoveredSegments.map((segment) => ({
@@ -2969,7 +3203,7 @@ async function recoverWithWhisper(audioSamples, sessionStartSec, maxAttempts) {
       );
       if (attempt < maxAttempts) {
         const delayMs = 400 * attempt;
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        await new Promise((resolve2) => setTimeout(resolve2, delayMs));
       }
     }
   }
@@ -3091,6 +3325,7 @@ class SessionController {
   // Watchdog state
   stateEnteredAt = Date.now();
   recordingWarningShown = false;
+  recoveryInProgress = false;
   // Post-processing result (available after processing completes)
   postProcessResult = null;
   // Current processing progress (for status reporting)
@@ -3164,13 +3399,13 @@ class SessionController {
    */
   async withTimeoutSync(fn, timeoutMs, operationName = "operation") {
     return this.withTimeout(
-      new Promise((resolve) => {
+      new Promise((resolve2) => {
         try {
           fn();
-          resolve();
+          resolve2();
         } catch (error) {
           console.warn(`[SessionController] ${operationName} threw:`, error);
-          resolve();
+          resolve2();
         }
       }),
       timeoutMs,
@@ -3184,7 +3419,6 @@ class SessionController {
    */
   async initialize() {
     console.log("[SessionController] Initializing...");
-    this.startWatchdog();
     console.log("[SessionController] Initialization complete");
   }
   /**
@@ -3223,6 +3457,12 @@ class SessionController {
       return false;
     }
     const oldState = this.state;
+    if (oldState === "idle" && newState !== "idle") {
+      this.startWatchdog();
+    }
+    if (newState === "idle") {
+      this.stopWatchdog();
+    }
     this.state = newState;
     this.stateEnteredAt = Date.now();
     this.recordingWarningShown = false;
@@ -3248,7 +3488,7 @@ class SessionController {
    */
   async start(sourceId, sourceName) {
     if (this.state !== "idle") {
-      throw new Error(`Cannot start session from state: ${this.state}`);
+      throw new Error(`Cannot start a new session while in "${this.state}" state. Wait for the current session to finish or cancel it first.`);
     }
     console.log(`[SessionController] Starting session for source: ${sourceId}`);
     if (!this.transition("starting")) {
@@ -3358,8 +3598,10 @@ class SessionController {
     if (!this.transition("processing")) {
       console.error("[SessionController] Failed to transition to processing state");
       this.transitionForced("complete");
+      if (this.session) this.session.state = "complete";
+    } else {
+      this.session.state = "processing";
     }
-    this.session.state = "processing";
     await this.withTimeout(
       this.recoverTranscriptFromCapturedAudio(),
       Math.floor(STATE_TIMEOUTS.processing * 0.8),
@@ -3407,8 +3649,7 @@ class SessionController {
     this.postProcessResult = null;
     this.currentProcessingProgress = null;
     this.resetSessionRuntimeState();
-    this.state = "idle";
-    this.emitStateChange();
+    this.transitionForced("idle");
   }
   // ===========================================================================
   // Status & Data Access
@@ -3523,7 +3764,7 @@ class SessionController {
    */
   addFeedbackItem(item) {
     if (!this.session) {
-      throw new Error("No active session");
+      throw new Error("No active session. Start a recording before adding feedback items.");
     }
     const feedbackItem = {
       id: randomUUID(),
@@ -3740,16 +3981,20 @@ class SessionController {
    */
   persistSession() {
     if (this.session) {
-      const persisted = {
-        id: this.session.id,
-        startTime: this.session.startTime,
-        endTime: this.session.endTime,
-        state: this.session.state,
-        sourceId: this.session.sourceId,
-        feedbackItemCount: this.session.feedbackItems.length,
-        metadata: this.session.metadata
-      };
-      store$1.set("currentSession", persisted);
+      try {
+        const persisted = {
+          id: this.session.id,
+          startTime: this.session.startTime,
+          endTime: this.session.endTime,
+          state: this.session.state,
+          sourceId: this.session.sourceId,
+          feedbackItemCount: this.session.feedbackItems.length,
+          metadata: this.session.metadata
+        };
+        store$1.set("currentSession", persisted);
+      } catch (err) {
+        console.error("[SessionController] Failed to persist session:", err);
+      }
     }
   }
   // ===========================================================================
@@ -3827,12 +4072,15 @@ class SessionController {
    * Called by watchdog when a state exceeds its timeout.
    */
   forceRecovery() {
+    if (this.recoveryInProgress) return;
+    this.recoveryInProgress = true;
     console.log(`[SessionController] Force recovery from state: ${this.state}`);
     switch (this.state) {
       case "starting":
         this.handleTimeoutError("Service initialization timed out");
         this.cleanupServicesForced();
         this.transitionForced("idle");
+        this.recoveryInProgress = false;
         break;
       case "recording":
         this.stop().catch((error) => {
@@ -3840,6 +4088,8 @@ class SessionController {
           this.handleTimeoutError("Recording auto-stop failed");
           this.cleanupServicesForced();
           this.transitionForced("error");
+        }).finally(() => {
+          this.recoveryInProgress = false;
         });
         break;
       case "stopping":
@@ -3847,6 +4097,7 @@ class SessionController {
         this.cleanupServicesForced();
         this.transitionForced("processing");
         this.stateEnteredAt = Date.now();
+        this.recoveryInProgress = false;
         break;
       case "processing":
         console.warn("[SessionController] Processing timeout, completing with partial data");
@@ -3858,19 +4109,23 @@ class SessionController {
         }
         this.transitionForced("complete");
         this.stateEnteredAt = Date.now();
+        this.recoveryInProgress = false;
         break;
       case "complete":
         console.log("[SessionController] Complete timeout, resetting to idle");
         this.session = null;
         this.transitionForced("idle");
+        this.recoveryInProgress = false;
         break;
       case "error":
         console.log("[SessionController] Error timeout, resetting to idle");
         this.session = null;
         this.transitionForced("idle");
+        this.recoveryInProgress = false;
         break;
       case "idle":
         console.warn("[SessionController] Unexpected watchdog trigger in idle state");
+        this.recoveryInProgress = false;
         break;
     }
   }
@@ -3880,6 +4135,9 @@ class SessionController {
    */
   transitionForced(newState) {
     const oldState = this.state;
+    if (newState === "idle") {
+      this.stopWatchdog();
+    }
     this.state = newState;
     this.stateEnteredAt = Date.now();
     if (this.session) {
@@ -4079,13 +4337,16 @@ class SessionController {
   }
 }
 const sessionController = new SessionController();
-const STATE_TOOLTIPS = {
-  idle: "markupr - Ready (Cmd+Shift+F)",
-  recording: "markupr - Recording... (Cmd+Shift+F to stop)",
-  processing: "markupr - Processing...",
-  complete: "markupr - Feedback captured!",
-  error: "markupr - Error (click for details)"
-};
+function buildStateTooltips() {
+  const toggleKey = formatHotkeyForDisplay("toggleRecording");
+  return {
+    idle: `markupr - Ready (${toggleKey})`,
+    recording: `markupr - Recording... (${toggleKey} to stop)`,
+    processing: "markupr - Processing...",
+    complete: "markupr - Feedback captured!",
+    error: "markupr - Error (click for details)"
+  };
+}
 const DONATE_URL = "https://ko-fi.com/eddiesanjuan";
 class TrayManagerImpl {
   tray = null;
@@ -4213,7 +4474,7 @@ class TrayManagerImpl {
     }
     const icon = this.loadIcon("idle");
     this.tray = new Tray(icon);
-    this.tray.setToolTip(STATE_TOOLTIPS.idle);
+    this.tray.setToolTip(buildStateTooltips().idle);
     this.updateContextMenu();
     if (process.platform === "darwin") {
       this.tray.on("mouse-up", (event) => {
@@ -4298,7 +4559,7 @@ class TrayManagerImpl {
     }
     const icon = this.loadIcon(state);
     this.tray.setImage(icon);
-    this.tray.setToolTip(STATE_TOOLTIPS[state]);
+    this.tray.setToolTip(buildStateTooltips()[state]);
     if (state === "processing") {
       this.startProcessingAnimation();
     } else if (state === "recording" && process.platform !== "darwin") {
@@ -5012,6 +5273,7 @@ ${REPORT_SUPPORT_LINE}
     const screenshotCount = this.countScreenshots(items);
     const topThemes = this.extractTopThemes(items);
     const highImpactCount = (severityCounts.Critical || 0) + (severityCounts.High || 0);
+    const platform = session.metadata?.os || process?.platform || "Unknown";
     let content = `# ${projectName} Feedback Report
 > Generated by markupr on ${timestamp}
 > Duration: ${duration} | Items: ${items.length} | Screenshots: ${screenshotCount}
@@ -5019,7 +5281,8 @@ ${REPORT_SUPPORT_LINE}
 ## Session Overview
 - **Session ID:** \`${session.id}\`
 - **Source:** ${session.metadata?.sourceName || "Unknown"} (${session.metadata?.sourceType || "screen"})
-- **Environment:** ${session.metadata?.os || "Unknown"}
+- **Platform:** ${platform}
+- **Segments:** ${items.length}
 - **High-impact items:** ${highImpactCount}
 
 ---
@@ -5138,15 +5401,13 @@ ${REPORT_SUPPORT_LINE}
    */
   generateFromPostProcess(result, sessionDir) {
     const { transcriptSegments, extractedFrames } = result;
-    const now = /* @__PURE__ */ new Date();
-    const sessionTimestamp = now.toLocaleString("en-US", {
-      year: "numeric",
-      month: "short",
-      day: "numeric",
-      hour: "2-digit",
-      minute: "2-digit"
-    });
+    const sessionTimestamp = this.formatDateDeterministic(/* @__PURE__ */ new Date());
+    const sessionDuration = transcriptSegments.length > 0 ? this.formatDuration(
+      (transcriptSegments[transcriptSegments.length - 1].endTime - transcriptSegments[0].startTime) * 1e3
+    ) : "0:00";
     let md = `# markupr Session — ${sessionTimestamp}
+`;
+    md += `> Segments: ${transcriptSegments.length} | Frames: ${extractedFrames.length} | Duration: ${sessionDuration}
 
 `;
     if (transcriptSegments.length === 0) {
@@ -5247,8 +5508,14 @@ ${REPORT_SUPPORT_LINE}
   /**
    * Generate a clipboard-friendly summary (<1500 chars).
    * Includes priority items and a reference to the full report.
+   *
+   * @param session - Session data
+   * @param projectName - Optional project name for the header
+   * @param reportPath - Optional absolute or relative path to the full report file.
+   *                     When provided, the summary links to this path instead of the
+   *                     generic ./feedback-report.md placeholder.
    */
-  generateClipboardSummary(session, projectName) {
+  generateClipboardSummary(session, projectName, reportPath) {
     const name = projectName || session.metadata?.sourceName || "Project";
     const items = session.feedbackItems;
     let summary = `# Feedback: ${name} - ${items.length} items
@@ -5272,7 +5539,7 @@ ${REPORT_SUPPORT_LINE}
 `;
     }
     summary += `
-**Full report:** ./feedback-report.md`;
+**Full report:** ${reportPath || "./feedback-report.md"}`;
     if (summary.length > 1500) {
       summary = summary.slice(0, 1497) + "...";
     }
@@ -5303,19 +5570,18 @@ ${REPORT_SUPPORT_LINE}
     return text.slice(0, maxLength - 3) + "...";
   }
   /**
-   * Wrap transcription for markdown blockquote (handle multi-line)
+   * Wrap transcription for markdown blockquote (handle multi-line).
+   * Splits on sentence-ending punctuation followed by whitespace so that
+   * all multi-sentence inputs (including 2-sentence ones) get proper
+   * blockquote continuation lines.
    */
   wrapTranscription(transcription) {
-    const sentences = transcription.match(/[^.!?]+[.!?]+/g);
-    if (!sentences) return transcription;
-    const lastMatch = sentences[sentences.length - 1];
-    const lastMatchEnd = transcription.lastIndexOf(lastMatch) + lastMatch.length;
-    const remainder = transcription.slice(lastMatchEnd).trim();
-    if (remainder) {
-      sentences.push(remainder);
+    if (!transcription.includes(".") && !transcription.includes("!") && !transcription.includes("?")) {
+      return transcription;
     }
-    if (sentences.length <= 2) return transcription;
-    return sentences.map((s) => s.trim()).join("\n> ");
+    const sentences = transcription.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter(Boolean);
+    if (sentences.length <= 1) return transcription;
+    return sentences.join("\n> ");
   }
   /**
    * Format duration from milliseconds to M:SS
@@ -5327,16 +5593,27 @@ ${REPORT_SUPPORT_LINE}
     return `${mins}:${secs.toString().padStart(2, "0")}`;
   }
   /**
-   * Format timestamp to locale string
+   * Format timestamp to a deterministic human-readable string.
+   * Uses explicit formatting instead of toLocaleString to produce
+   * consistent output across platforms and Node.js versions.
    */
   formatTimestamp(ms) {
-    return new Date(ms).toLocaleString("en-US", {
-      year: "numeric",
-      month: "short",
-      day: "numeric",
-      hour: "2-digit",
-      minute: "2-digit"
-    });
+    return this.formatDateDeterministic(new Date(ms));
+  }
+  /**
+   * Produce a deterministic date string: "Feb 14, 2026 at 10:30 AM".
+   * Avoids toLocaleString which can vary across OS versions.
+   */
+  formatDateDeterministic(date) {
+    const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+    const month = months[date.getMonth()];
+    const day = date.getDate();
+    const year = date.getFullYear();
+    const rawHours = date.getHours();
+    const ampm = rawHours >= 12 ? "PM" : "AM";
+    const hours = rawHours % 12 || 12;
+    const minutes = date.getMinutes().toString().padStart(2, "0");
+    return `${month} ${day}, ${year} at ${hours}:${minutes} ${ampm}`;
   }
   /**
    * Format item timestamp as MM:SS from session start
@@ -6153,6 +6430,7 @@ Your job is to transform this raw narration into a structured, actionable feedba
 6. **Categorize.** Use exactly one of: Bug, UX Issue, Performance, Suggestion, Question, Positive Note.
 7. **Write a summary.** 2-3 sentences capturing the most important findings.
 8. **Be concise.** Developers will paste this into AI coding tools. Every word must earn its place.
+9. **Handle sparse input.** If the transcript is very short or absent, focus on describing what you see in screenshots. If neither transcript nor screenshots are available, return a minimal result with an empty items array.
 
 ## Output Format
 
@@ -6261,7 +6539,12 @@ class ClaudeAnalyzer {
    */
   async analyze(session, imageOptions) {
     try {
+      const transcriptText = buildTranscriptText(session);
       const optimizedImages = optimizeForAPI(session.screenshotBuffer, imageOptions);
+      if (transcriptText === "[No transcript available]" && optimizedImages.length === 0) {
+        console.log("[ClaudeAnalyzer] Skipping API call: no transcript and no screenshots");
+        return null;
+      }
       const userContent = buildUserContent(session, optimizedImages);
       let timeoutHandle;
       const timeoutPromise = new Promise((_, reject) => {
@@ -6429,7 +6712,7 @@ class StructuredMarkdownBuilder {
   buildSingleItem(item, index, session, options) {
     const timestamp = this.estimateItemTimestamp(item, session);
     const lines = [];
-    lines.push(`### ${index + 1}. ${item.title}`);
+    lines.push(`### ${this.formatItemId(index)}: ${item.title}`);
     lines.push(`> "${item.quote}"`);
     lines.push("");
     for (const ssIndex of item.screenshotIndices) {
@@ -6509,13 +6792,16 @@ class StructuredMarkdownBuilder {
     const duration = session.endTime ? this.formatDuration(session.endTime - session.startTime) : "In Progress";
     const screenshotCount = session.screenshotBuffer.length;
     const modelLabel = options.modelId ?? "Claude";
+    const platform = process?.platform ?? "Unknown";
     const lines = [
       "## Session Info",
       "",
       `- **Session ID:** \`${session.id}\``,
       `- **Source:** ${session.metadata.sourceName ?? "Unknown"} (${session.metadata.windowTitle ? "window" : "screen"})`,
+      `- **Platform:** ${platform}`,
       `- **Duration:** ${duration}`,
-      `- **Screenshots:** ${screenshotCount}`
+      `- **Screenshots:** ${screenshotCount}`,
+      `- **Segments:** ${session.transcriptBuffer.length}`
     ];
     if (options.hasRecording) {
       const filename = options.recordingFilename ?? "session-recording.webm";
@@ -6568,7 +6854,8 @@ class StructuredMarkdownBuilder {
       (seg) => seg.text.includes(quotePrefix)
     );
     if (matchingSegment) {
-      const relativeMs = matchingSegment.timestamp * 1e3 - session.startTime;
+      const tsMs = Math.round(matchingSegment.timestamp * 1e3);
+      const relativeMs = tsMs - session.startTime;
       return this.formatTimestamp(relativeMs);
     }
     if (item.screenshotIndices.length > 0) {
@@ -6868,7 +7155,7 @@ class ModelDownloadManager extends EventEmitter {
       throw new Error(`Download already in progress for ${model}`);
     }
     this.log(`Starting download: ${model} (${info.sizeMB}MB)`);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let downloadedBytes = 0;
       let lastProgressTime = Date.now();
       let lastDownloadedBytes = 0;
@@ -6979,7 +7266,7 @@ class ModelDownloadManager extends EventEmitter {
             this.completeCallbacks.forEach((cb) => cb(result));
             this.emit("complete", result);
             this.log(`Download complete: ${model}`);
-            resolve(result);
+            resolve2(result);
           } else {
             const error = new Error("Downloaded file size mismatch - download may be corrupted");
             this.handleDownloadError(error, model, targetPath);
@@ -7489,7 +7776,7 @@ class CrashRecoveryManager {
       error: error.message,
       stack: error.stack
     });
-    this.logCrash(error, { type });
+    this.logCrashSync(error, { type });
     if (this.currentSession) {
       this.currentSession.lastSaveTime = Date.now();
       store.set("activeSession", this.currentSession);
@@ -7571,17 +7858,21 @@ class CrashRecoveryManager {
     this.stopAutoSave();
     this.saveInterval = setInterval(() => {
       if (this.currentSession) {
-        this.currentSession.lastSaveTime = Date.now();
-        this.currentSession.metadata.sessionDurationMs = Date.now() - this.currentSession.startTime;
-        store.set("activeSession", this.currentSession);
-        errorHandler.log("debug", "Auto-saved session state", {
-          component: "CrashRecovery",
-          operation: "autoSave",
-          data: {
-            sessionId: this.currentSession.id,
-            feedbackCount: this.currentSession.feedbackItems.length
-          }
-        });
+        try {
+          this.currentSession.lastSaveTime = Date.now();
+          this.currentSession.metadata.sessionDurationMs = Date.now() - this.currentSession.startTime;
+          store.set("activeSession", this.currentSession);
+          errorHandler.log("debug", "Auto-saved session state", {
+            component: "CrashRecovery",
+            operation: "autoSave",
+            data: {
+              sessionId: this.currentSession.id,
+              feedbackCount: this.currentSession.feedbackItems.length
+            }
+          });
+        } catch (err) {
+          console.error("[CrashRecovery] Auto-save failed:", err);
+        }
       }
     }, intervalMs);
   }
@@ -7664,6 +7955,53 @@ class CrashRecoveryManager {
     store.set("crashLogs", logs);
     await this.writeCrashLogToFile(crashLog);
   }
+  /**
+   * Synchronous crash logging for use in uncaughtException handlers.
+   * Uses writeFileSync to ensure data is written before process exits.
+   */
+  logCrashSync(error, context) {
+    const crashLog = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      error: {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      },
+      appVersion: app.getVersion(),
+      platform: process.platform,
+      arch: process.arch,
+      sessionId: this.currentSession?.id,
+      context
+    };
+    try {
+      const settings = this.getSettings();
+      const logs = store.get("crashLogs") || [];
+      logs.push(crashLog);
+      while (logs.length > settings.maxCrashLogs) {
+        logs.shift();
+      }
+      store.set("crashLogs", logs);
+    } catch {
+    }
+    try {
+      const logDir = path.dirname(this.crashLogPath);
+      if (!fsSync.existsSync(logDir)) {
+        fsSync.mkdirSync(logDir, { recursive: true });
+      }
+      let logs = [];
+      try {
+        const existing = fsSync.readFileSync(this.crashLogPath, "utf-8");
+        logs = JSON.parse(existing);
+      } catch {
+      }
+      logs.push(crashLog);
+      while (logs.length > 50) {
+        logs.shift();
+      }
+      fsSync.writeFileSync(this.crashLogPath, JSON.stringify(logs, null, 2));
+    } catch {
+    }
+  }
   /**
    * Write crash log to JSON file
    */
@@ -7819,6 +8157,7 @@ const PAUSE_THRESHOLD_SECONDS = 1.5;
 const PERIODIC_INTERVAL_SECONDS = 15;
 const MAX_PERIODIC_INTERVAL_SECONDS = 20;
 const MAX_KEY_MOMENTS = 20;
+const FRAME_EDGE_MARGIN_SECONDS$1 = 0.35;
 class TranscriptAnalyzer {
   /**
    * Analyze transcript segments and return key moments where frames
@@ -7834,8 +8173,11 @@ class TranscriptAnalyzer {
     }
     const moments = [];
     const firstSegment = segments[0];
+    const lastSegment = segments[segments.length - 1];
+    const sessionDuration = lastSegment.endTime - firstSegment.startTime;
+    const startOffset = sessionDuration > FRAME_EDGE_MARGIN_SECONDS$1 ? FRAME_EDGE_MARGIN_SECONDS$1 : 0;
     moments.push({
-      timestamp: firstSegment.startTime,
+      timestamp: firstSegment.startTime + startOffset,
       reason: "Session start",
       confidence: 1
     });
@@ -7852,8 +8194,7 @@ class TranscriptAnalyzer {
         });
       }
     }
-    const lastSegment = segments[segments.length - 1];
-    if (lastSegment.endTime !== firstSegment.startTime) {
+    if (lastSegment.endTime > firstSegment.startTime + startOffset) {
       moments.push({
         timestamp: lastSegment.endTime,
         reason: "Session end",
@@ -7861,16 +8202,13 @@ class TranscriptAnalyzer {
       });
     }
     if (moments.length < 3 && aiHints.length === 0) {
-      const sessionStart = firstSegment.startTime;
-      const sessionEnd = lastSegment.endTime;
-      const sessionDuration = sessionEnd - sessionStart;
       if (sessionDuration > PERIODIC_INTERVAL_SECONDS) {
         const rawCount = Math.floor(sessionDuration / PERIODIC_INTERVAL_SECONDS);
         const interval = Math.min(
           sessionDuration / rawCount,
           MAX_PERIODIC_INTERVAL_SECONDS
         );
-        for (let t = sessionStart + interval; t < sessionEnd; t += interval) {
+        for (let t = firstSegment.startTime + interval; t < lastSegment.endTime; t += interval) {
           moments.push({
             timestamp: t,
             reason: "Periodic capture",
@@ -7957,6 +8295,14 @@ const FFMPEG_FAST_FRAME_TIMEOUT_MS = 1e4;
 const FFMPEG_CHECK_TIMEOUT_MS = 5e3;
 const FRAME_EDGE_MARGIN_SECONDS = 0.35;
 const TIMESTAMP_DEDUPE_WINDOW_SECONDS = 0.15;
+const SAFE_CHILD_ENV = {
+  PATH: process.env.PATH,
+  HOME: process.env.HOME || process.env.USERPROFILE,
+  USERPROFILE: process.env.USERPROFILE,
+  LANG: process.env.LANG,
+  TMPDIR: process.env.TMPDIR || process.env.TEMP,
+  TEMP: process.env.TEMP
+};
 class FrameExtractor {
   ffmpegPath = "ffmpeg";
   ffprobePath = "ffprobe";
@@ -7972,7 +8318,8 @@ class FrameExtractor {
     }
     try {
       await execFile(this.ffmpegPath, ["-version"], {
-        timeout: FFMPEG_CHECK_TIMEOUT_MS
+        timeout: FFMPEG_CHECK_TIMEOUT_MS,
+        env: SAFE_CHILD_ENV
       });
       this.ffmpegAvailable = true;
       this.log("ffmpeg is available");
@@ -8017,7 +8364,7 @@ class FrameExtractor {
         await this.extractSingleFrame(request.videoPath, timestamp, outputPath);
         const stats = await stat(outputPath).catch(() => null);
         if (!stats || stats.size <= 0) {
-          throw new Error("ffmpeg did not produce a frame file");
+          throw new Error(`ffmpeg did not produce a frame file at timestamp ${timestamp.toFixed(1)}s. The video may be shorter than expected or the codec may not support seeking.`);
         }
         frames.push({
           path: outputPath,
@@ -8070,7 +8417,8 @@ class FrameExtractor {
       outputPath
     ];
     await execFile(this.ffmpegPath, args, {
-      timeout: FFMPEG_ACCURATE_FRAME_TIMEOUT_MS
+      timeout: FFMPEG_ACCURATE_FRAME_TIMEOUT_MS,
+      env: SAFE_CHILD_ENV
     });
   }
   async extractSingleFrameFast(videoPath, timestamp, outputPath) {
@@ -8090,7 +8438,8 @@ class FrameExtractor {
       outputPath
     ];
     await execFile(this.ffmpegPath, args, {
-      timeout: FFMPEG_FAST_FRAME_TIMEOUT_MS
+      timeout: FFMPEG_FAST_FRAME_TIMEOUT_MS,
+      env: SAFE_CHILD_ENV
     });
   }
   /**
@@ -8129,7 +8478,7 @@ class FrameExtractor {
           "default=noprint_wrappers=1:nokey=1",
           videoPath
         ],
-        { timeout: FFMPEG_CHECK_TIMEOUT_MS }
+        { timeout: FFMPEG_CHECK_TIMEOUT_MS, env: SAFE_CHILD_ENV }
       );
       const parsed = Number.parseFloat(String(stdout).trim());
       if (Number.isFinite(parsed) && parsed > 0) {
@@ -9326,7 +9675,7 @@ class PopoverManager {
         preload: preloadPath,
         nodeIntegration: false,
         contextIsolation: true,
-        sandbox: false
+        sandbox: true
       }
     });
     this.window.on("blur", () => {
@@ -9345,7 +9694,7 @@ class PopoverManager {
    * Show the popover anchored to the tray icon
    */
   show() {
-    if (!this.window || !this.tray) return;
+    if (!this.window || this.window.isDestroyed() || !this.tray) return;
     const position = this.calculatePosition();
     this.window.setPosition(position.x, position.y, false);
     this.window.show();
@@ -9356,7 +9705,7 @@ class PopoverManager {
    * Hide the popover
    */
   hide() {
-    if (!this.window) return;
+    if (!this.window || this.window.isDestroyed()) return;
     this.window.hide();
     console.log("[PopoverManager] Popover hidden");
   }
@@ -9364,7 +9713,7 @@ class PopoverManager {
    * Toggle popover visibility
    */
   toggle() {
-    if (!this.window) return;
+    if (!this.window || this.window.isDestroyed()) return;
     if (this.window.isVisible()) {
       this.hide();
     } else {
@@ -9376,7 +9725,7 @@ class PopoverManager {
    * Handles multi-monitor setups and taskbar positions
    */
   calculatePosition() {
-    if (!this.tray || !this.window) {
+    if (!this.tray || !this.window || this.window.isDestroyed()) {
       return { x: 0, y: 0 };
     }
     const trayBounds = this.tray.getBounds();
@@ -9417,14 +9766,14 @@ class PopoverManager {
    * Check if popover is visible
    */
   isVisible() {
-    return this.window?.isVisible() ?? false;
+    return this.window && !this.window.isDestroyed() ? this.window.isVisible() : false;
   }
   /**
    * Resize the popover for different states
    * Re-anchors to tray if visible
    */
   resize(width, height) {
-    if (!this.window) return;
+    if (!this.window || this.window.isDestroyed()) return;
     this.window.setSize(width, height, true);
     if (this.window.isVisible()) {
       const position = this.calculatePosition();
@@ -9466,7 +9815,7 @@ class PopoverManager {
     console.log("[PopoverManager] Destroyed");
   }
   applyStateAppearance(state) {
-    if (!this.window || process.platform !== "darwin") {
+    if (!this.window || this.window.isDestroyed() || process.platform !== "darwin") {
       return;
     }
     const isHudState = state === "recording" || state === "processing";
@@ -10041,13 +10390,14 @@ class PermissionManager {
   // ==========================================================================
   /**
    * Show a helpful dialog when permission is denied
-   * Offers to open System Preferences directly
+   * Offers to open system settings directly
    */
   async showPermissionDeniedDialog(type) {
     const config = PERMISSION_DESCRIPTIONS[type];
+    const settingsLabel = process.platform === "darwin" ? "Open System Settings" : process.platform === "win32" ? "Open Windows Settings" : "Open Settings";
     const options = {
       type: "warning",
-      buttons: ["Open System Settings", "Later"],
+      buttons: [settingsLabel, "Later"],
       defaultId: 0,
       cancelId: 1,
       title: `${config.title} Required`,
@@ -10055,7 +10405,7 @@ class PermissionManager {
       detail: `${config.description}
 
 To enable this permission:
-1. Click "Open System Settings"
+1. Click "${settingsLabel}"
 2. Find markupr in the list
 3. Toggle it ON
 4. You may need to restart markupr`
@@ -10123,11 +10473,12 @@ Would you like to set up permissions now?`
    * Get user-friendly description of permission state
    */
   getPermissionStateDescription(type, state) {
+    const settingsName = process.platform === "darwin" ? "System Settings" : process.platform === "win32" ? "Windows Settings" : "system settings";
     switch (state) {
       case "granted":
         return "Enabled";
       case "denied":
-        return "Denied - click to enable in System Settings";
+        return `Denied - click to enable in ${settingsName}`;
       case "not-determined":
         return "Not set - click to enable";
       case "restricted":
@@ -10140,43 +10491,88 @@ Would you like to set up permissions now?`
 const permissionManager = new PermissionManager();
 function registerSessionHandlers(ctx, actions) {
   ipcMain.handle(IPC_CHANNELS.SESSION_START, async (_, sourceId, sourceName) => {
-    console.log("[Main] Starting session");
-    return actions.startSession(sourceId, sourceName);
+    try {
+      console.log("[Main] Starting session");
+      return await actions.startSession(sourceId, sourceName);
+    } catch (error) {
+      console.error("[IPC] SESSION_START failed:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to start session" };
+    }
   });
   ipcMain.handle(IPC_CHANNELS.SESSION_STOP, async () => {
-    console.log("[Main] Stopping session");
-    return actions.stopSession();
+    try {
+      console.log("[Main] Stopping session");
+      return await actions.stopSession();
+    } catch (error) {
+      console.error("[IPC] SESSION_STOP failed:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to stop session" };
+    }
   });
   ipcMain.handle(IPC_CHANNELS.SESSION_PAUSE, async () => {
-    console.log("[Main] Pausing session");
-    return actions.pauseSession();
+    try {
+      console.log("[Main] Pausing session");
+      return await actions.pauseSession();
+    } catch (error) {
+      console.error("[IPC] SESSION_PAUSE failed:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to pause session" };
+    }
   });
   ipcMain.handle(IPC_CHANNELS.SESSION_RESUME, async () => {
-    console.log("[Main] Resuming session");
-    return actions.resumeSession();
+    try {
+      console.log("[Main] Resuming session");
+      return await actions.resumeSession();
+    } catch (error) {
+      console.error("[IPC] SESSION_RESUME failed:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to resume session" };
+    }
   });
   ipcMain.handle(IPC_CHANNELS.SESSION_CANCEL, async () => {
-    console.log("[Main] Cancelling session");
-    return actions.cancelSession();
+    try {
+      console.log("[Main] Cancelling session");
+      return await actions.cancelSession();
+    } catch (error) {
+      console.error("[IPC] SESSION_CANCEL failed:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to cancel session" };
+    }
   });
   ipcMain.handle(IPC_CHANNELS.SESSION_GET_STATUS, () => {
-    return sessionController.getStatus();
+    try {
+      return sessionController.getStatus();
+    } catch (error) {
+      console.error("[IPC] SESSION_GET_STATUS failed:", error);
+      return { state: "idle", duration: 0, feedbackCount: 0, screenshotCount: 0, isPaused: false };
+    }
   });
   ipcMain.handle(IPC_CHANNELS.SESSION_GET_CURRENT, () => {
-    const session = sessionController.getSession();
-    return session ? actions.serializeSession(session) : null;
+    try {
+      const session = sessionController.getSession();
+      return session ? actions.serializeSession(session) : null;
+    } catch (error) {
+      console.error("[IPC] SESSION_GET_CURRENT failed:", error);
+      return null;
+    }
   });
   ipcMain.handle(IPC_CHANNELS.START_SESSION, async (_, sourceId) => {
-    return actions.startSession(sourceId);
+    try {
+      return await actions.startSession(sourceId);
+    } catch (error) {
+      console.error("[IPC] START_SESSION failed:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to start session" };
+    }
   });
   ipcMain.handle(IPC_CHANNELS.STOP_SESSION, async () => {
-    return actions.stopSession();
+    try {
+      return await actions.stopSession();
+    } catch (error) {
+      console.error("[IPC] STOP_SESSION failed:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to stop session" };
+    }
   });
 }
 const activeScreenRecordings = /* @__PURE__ */ new Map();
 const finalizedScreenRecordings = /* @__PURE__ */ new Map();
 function sleep$1(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function extensionFromMimeType(mimeType) {
   const normalized = (mimeType || "").toLowerCase();
@@ -10314,7 +10710,8 @@ function registerCaptureHandlers(ctx) {
       } else {
         return { success: false, error: "Unsupported recording chunk format." };
       }
-      recording.writeChain = recording.writeChain.then(() => fs.appendFile(recording.tempPath, buffer)).then(() => {
+      recording.writeChain = recording.writeChain.catch(() => {
+      }).then(() => fs.appendFile(recording.tempPath, buffer)).then(() => {
         recording.bytesWritten += buffer.byteLength;
         recording.lastChunkAt = Date.now();
       });
@@ -10502,62 +10899,82 @@ function registerSettingsHandlers(ctx, actions) {
     await fs.writeFile(result.filePath, payload, "utf-8");
   });
   ipcMain.handle(IPC_CHANNELS.SETTINGS_IMPORT, async () => {
-    const settingsManager2 = getSettingsManager2();
-    if (!settingsManager2) {
-      return null;
-    }
-    const mainWindow2 = getMainWindow();
-    const options = {
-      title: "Import markupr Settings",
-      properties: ["openFile"],
-      filters: [{ name: "JSON", extensions: ["json"] }]
-    };
-    const result = mainWindow2 ? await dialog.showOpenDialog(mainWindow2, options) : await dialog.showOpenDialog(options);
-    if (result.canceled || result.filePaths.length === 0) {
-      return null;
-    }
-    const raw = await fs.readFile(result.filePaths[0], "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error("Invalid settings file format.");
-    }
-    const entries = Object.entries(parsed);
-    const allowedKeys = new Set(Object.keys(DEFAULT_SETTINGS$2));
-    const sanitized = {};
-    for (const [key, value] of entries) {
-      if (!allowedKeys.has(key)) {
-        continue;
+    try {
+      const settingsManager2 = getSettingsManager2();
+      if (!settingsManager2) {
+        return null;
+      }
+      const mainWindow2 = getMainWindow();
+      const options = {
+        title: "Import markupr Settings",
+        properties: ["openFile"],
+        filters: [{ name: "JSON", extensions: ["json"] }]
+      };
+      const result = mainWindow2 ? await dialog.showOpenDialog(mainWindow2, options) : await dialog.showOpenDialog(options);
+      if (result.canceled || result.filePaths.length === 0) {
+        return null;
+      }
+      const raw = await fs.readFile(result.filePaths[0], "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        console.warn("[Main] Invalid settings file format");
+        return null;
+      }
+      const entries = Object.entries(parsed);
+      const allowedKeys = new Set(Object.keys(DEFAULT_SETTINGS$2));
+      const sanitized = {};
+      for (const [key, value] of entries) {
+        if (!allowedKeys.has(key)) {
+          continue;
+        }
+        if (key === "__proto__" || key === "constructor") {
+          continue;
+        }
+        sanitized[key] = value;
       }
-      sanitized[key] = value;
+      return settingsManager2.update(sanitized);
+    } catch (error) {
+      console.error("[Main] Failed to import settings:", error);
+      return null;
     }
-    return settingsManager2.update(sanitized);
   });
   ipcMain.handle(IPC_CHANNELS.GET_SETTINGS, () => {
     return getSettingsManager2()?.getAll() ?? { ...DEFAULT_SETTINGS$2 };
   });
   ipcMain.handle(IPC_CHANNELS.SET_SETTINGS, (_, newSettings) => {
-    const settings = getSettingsManager2()?.update(newSettings) ?? {
+    if (!newSettings || typeof newSettings !== "object" || Array.isArray(newSettings)) {
+      return getSettingsManager2()?.getAll() ?? { ...DEFAULT_SETTINGS$2 };
+    }
+    const typedSettings = newSettings;
+    const settings = getSettingsManager2()?.update(typedSettings) ?? {
       ...DEFAULT_SETTINGS$2,
-      ...newSettings
+      ...typedSettings
     };
-    if (newSettings.hotkeys) {
-      const results = hotkeyManager.updateConfig(newSettings.hotkeys);
+    if (typedSettings.hotkeys) {
+      const results = hotkeyManager.updateConfig(typedSettings.hotkeys);
       console.log("[Main] Hotkeys updated:", results);
     }
-    if (newSettings.hasCompletedOnboarding) {
+    if (typedSettings.hasCompletedOnboarding) {
       setHasCompletedOnboarding(true);
     }
     return settings;
   });
+  const ALLOWED_API_SERVICES = /* @__PURE__ */ new Set(["openai", "anthropic"]);
   ipcMain.handle(
     IPC_CHANNELS.SETTINGS_GET_API_KEY,
     async (_, service) => {
+      if (!ALLOWED_API_SERVICES.has(service)) {
+        return null;
+      }
       return getSettingsManager2()?.getApiKey(service) ?? null;
     }
   );
   ipcMain.handle(
     IPC_CHANNELS.SETTINGS_SET_API_KEY,
     async (_, service, key) => {
+      if (!ALLOWED_API_SERVICES.has(service)) {
+        return false;
+      }
       const settingsManager2 = getSettingsManager2();
       if (!settingsManager2) {
         return false;
@@ -10570,7 +10987,7 @@ function registerSettingsHandlers(ctx, actions) {
             return true;
           }
           if (attempt < 2) {
-            await new Promise((resolve) => setTimeout(resolve, 120 * (attempt + 1)));
+            await new Promise((resolve2) => setTimeout(resolve2, 120 * (attempt + 1)));
           }
         }
         if (key.trim().length > 0) {
@@ -10589,6 +11006,9 @@ function registerSettingsHandlers(ctx, actions) {
   ipcMain.handle(
     IPC_CHANNELS.SETTINGS_DELETE_API_KEY,
     async (_, service) => {
+      if (!ALLOWED_API_SERVICES.has(service)) {
+        return false;
+      }
       const settingsManager2 = getSettingsManager2();
       if (!settingsManager2) {
         return false;
@@ -10600,6 +11020,9 @@ function registerSettingsHandlers(ctx, actions) {
   ipcMain.handle(
     IPC_CHANNELS.SETTINGS_HAS_API_KEY,
     async (_, service) => {
+      if (!ALLOWED_API_SERVICES.has(service)) {
+        return false;
+      }
       return getSettingsManager2()?.hasApiKey(service) ?? false;
     }
   );
@@ -10686,7 +11109,8 @@ function registerSettingsHandlers(ctx, actions) {
     return { success: true };
   });
   ipcMain.handle(IPC_CHANNELS.CRASH_RECOVERY_GET_LOGS, (_, limit) => {
-    return crashRecovery.getCrashLogs(limit);
+    const sanitizedLimit = typeof limit === "number" && limit > 0 && limit <= 100 ? Math.floor(limit) : void 0;
+    return crashRecovery.getCrashLogs(sanitizedLimit);
   });
   ipcMain.handle(IPC_CHANNELS.CRASH_RECOVERY_CLEAR_LOGS, () => {
     crashRecovery.clearCrashLogs();
@@ -10695,7 +11119,24 @@ function registerSettingsHandlers(ctx, actions) {
   ipcMain.handle(
     IPC_CHANNELS.CRASH_RECOVERY_UPDATE_SETTINGS,
     (_, settings) => {
-      crashRecovery.updateSettings(settings);
+      if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+        return { success: false };
+      }
+      const input = settings;
+      const validated = {};
+      if (typeof input.enableAutoSave === "boolean") {
+        validated.enableAutoSave = input.enableAutoSave;
+      }
+      if (typeof input.autoSaveIntervalMs === "number" && input.autoSaveIntervalMs >= 1e3 && input.autoSaveIntervalMs <= 3e4) {
+        validated.autoSaveIntervalMs = input.autoSaveIntervalMs;
+      }
+      if (typeof input.enableCrashReporting === "boolean") {
+        validated.enableCrashReporting = input.enableCrashReporting;
+      }
+      if (typeof input.maxCrashLogs === "number" && input.maxCrashLogs >= 0 && input.maxCrashLogs <= 100) {
+        validated.maxCrashLogs = input.maxCrashLogs;
+      }
+      crashRecovery.updateSettings(validated);
       return { success: true };
     }
   );
@@ -10761,7 +11202,7 @@ async function exportSessionFolders(sessionIds) {
   const sessions = await listSessionHistoryItems();
   const selected = sessions.filter((session) => sessionIds.includes(session.id));
   if (!selected.length) {
-    throw new Error("No sessions found to export.");
+    throw new Error("No matching sessions found. Make sure the selected sessions still exist in your session history.");
   }
   const exportRoot = join(fileManager.getOutputDirectory(), "exports");
   const bundleDir = join(exportRoot, `bundle-${Date.now()}`);
@@ -10817,12 +11258,20 @@ function registerOutputHandlers(ctx) {
   });
   ipcMain.handle(IPC_CHANNELS.OUTPUT_OPEN_FOLDER, async (_, sessionDir) => {
     try {
-      const dir = sessionDir || fileManager.getOutputDirectory();
-      await shell.openPath(dir);
+      if (sessionDir !== void 0 && typeof sessionDir !== "string") {
+        return { success: false, error: "Invalid directory path" };
+      }
+      const baseDir = fileManager.getOutputDirectory();
+      const dir = sessionDir || baseDir;
+      const resolved = resolve(dir);
+      if (sessionDir && !resolved.startsWith(resolve(baseDir))) {
+        return { success: false, error: "Invalid directory path" };
+      }
+      await shell.openPath(resolved);
       return { success: true };
     } catch (error) {
       console.error("[Main] Failed to open folder:", error);
-      return { success: false, error: error.message };
+      return { success: false, error: "Failed to open folder" };
     }
   });
   ipcMain.handle(IPC_CHANNELS.OUTPUT_LIST_SESSIONS, async () => {
@@ -10843,27 +11292,46 @@ function registerOutputHandlers(ctx) {
   });
   ipcMain.handle(IPC_CHANNELS.OUTPUT_DELETE_SESSION, async (_, sessionId) => {
     try {
+      if (typeof sessionId !== "string" || sessionId.length === 0) {
+        return { success: false, error: "Invalid session ID" };
+      }
       const session = await getSessionHistoryItem(sessionId);
       if (!session) {
         return { success: false, error: "Session not found" };
       }
+      const baseDir = fileManager.getOutputDirectory();
+      if (!resolve(session.folder).startsWith(resolve(baseDir))) {
+        return { success: false, error: "Invalid session path" };
+      }
       await fs.rm(session.folder, { recursive: true, force: true });
       return { success: true };
     } catch (error) {
       console.error("[Main] Failed to delete session:", error);
-      return { success: false, error: error.message };
+      return { success: false, error: "Failed to delete session" };
     }
   });
   ipcMain.handle(IPC_CHANNELS.OUTPUT_DELETE_SESSIONS, async (_, sessionIds) => {
+    if (!Array.isArray(sessionIds)) {
+      return { success: false, deleted: [], failed: [] };
+    }
     const deleted = [];
     const failed = [];
+    const baseDir = fileManager.getOutputDirectory();
     for (const sessionId of sessionIds) {
       try {
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          failed.push(String(sessionId));
+          continue;
+        }
         const session = await getSessionHistoryItem(sessionId);
         if (!session) {
           failed.push(sessionId);
           continue;
         }
+        if (!resolve(session.folder).startsWith(resolve(baseDir))) {
+          failed.push(sessionId);
+          continue;
+        }
         await fs.rm(session.folder, { recursive: true, force: true });
         deleted.push(sessionId);
       } catch {
@@ -10876,16 +11344,21 @@ function registerOutputHandlers(ctx) {
       failed
     };
   });
+  const ALLOWED_EXPORT_FORMATS = /* @__PURE__ */ new Set(["markdown", "json", "pdf"]);
   ipcMain.handle(
     IPC_CHANNELS.OUTPUT_EXPORT_SESSION,
     async (_, sessionId, format = "markdown") => {
       try {
-        console.log(`[Main] Exporting session ${sessionId} as ${format}`);
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          return { success: false, error: "Invalid session ID" };
+        }
+        const safeFormat = typeof format === "string" && ALLOWED_EXPORT_FORMATS.has(format) ? format : "markdown";
+        console.log(`[Main] Exporting session ${sessionId} as ${safeFormat}`);
         const exportPath = await exportSessionFolders([sessionId]);
         return { success: true, path: exportPath };
       } catch (error) {
         console.error("[Main] Failed to export session:", error);
-        return { success: false, error: error.message };
+        return { success: false, error: "Failed to export session" };
       }
     }
   );
@@ -10893,12 +11366,16 @@ function registerOutputHandlers(ctx) {
     IPC_CHANNELS.OUTPUT_EXPORT_SESSIONS,
     async (_, sessionIds, format = "markdown") => {
       try {
-        console.log(`[Main] Exporting ${sessionIds.length} sessions as ${format}`);
+        if (!Array.isArray(sessionIds) || sessionIds.some((id) => typeof id !== "string")) {
+          return { success: false, error: "Invalid session IDs" };
+        }
+        const safeFormat = typeof format === "string" && ALLOWED_EXPORT_FORMATS.has(format) ? format : "markdown";
+        console.log(`[Main] Exporting ${sessionIds.length} sessions as ${safeFormat}`);
         const exportPath = await exportSessionFolders(sessionIds);
         return { success: true, path: exportPath };
       } catch (error) {
         console.error("[Main] Failed to export sessions:", error);
-        return { success: false, error: error.message };
+        return { success: false, error: "Failed to export sessions" };
       }
     }
   );
@@ -11075,20 +11552,26 @@ function registerWindowHandlers(ctx) {
     return { success: true };
   });
   ipcMain.handle(IPC_CHANNELS.POPOVER_RESIZE, (_, width, height) => {
+    if (typeof width !== "number" || typeof height !== "number" || width < 100 || width > 2e3 || height < 50 || height > 2e3 || !Number.isFinite(width) || !Number.isFinite(height)) {
+      return { success: false, error: "Invalid dimensions" };
+    }
     const popover2 = getPopover();
     if (popover2) {
-      popover2.resize(width, height);
+      popover2.resize(Math.round(width), Math.round(height));
       return { success: true };
     }
     return { success: false, error: "Popover not initialized" };
   });
   ipcMain.handle(IPC_CHANNELS.POPOVER_RESIZE_TO_STATE, (_, state) => {
+    if (typeof state !== "string" || !Object.prototype.hasOwnProperty.call(POPOVER_SIZES, state)) {
+      return { success: false, error: "Invalid popover state" };
+    }
     const popover2 = getPopover();
-    if (popover2 && state in POPOVER_SIZES) {
+    if (popover2) {
       popover2.resizeToState(state);
       return { success: true };
     }
-    return { success: false, error: "Popover not initialized or invalid state" };
+    return { success: false, error: "Popover not initialized" };
   });
   ipcMain.handle(IPC_CHANNELS.POPOVER_SHOW, () => {
     getPopover()?.show();
@@ -11105,20 +11588,28 @@ function registerWindowHandlers(ctx) {
   ipcMain.handle(
     IPC_CHANNELS.TASKBAR_SET_PROGRESS,
     (_, progress) => {
-      getWindowsTaskbar()?.setProgress(progress);
+      if (typeof progress !== "number" || !Number.isFinite(progress)) {
+        return { success: false, error: "Invalid progress value" };
+      }
+      getWindowsTaskbar()?.setProgress(Math.max(0, Math.min(1, progress)));
       return { success: true };
     }
   );
   ipcMain.handle(
     IPC_CHANNELS.TASKBAR_FLASH_FRAME,
     (_, count) => {
-      getWindowsTaskbar()?.flashFrame(count);
+      const sanitizedCount = typeof count === "number" && Number.isFinite(count) && count > 0 ? Math.min(Math.floor(count), 10) : void 0;
+      getWindowsTaskbar()?.flashFrame(sanitizedCount);
       return { success: true };
     }
   );
   ipcMain.handle(
     IPC_CHANNELS.TASKBAR_SET_OVERLAY,
     (_, state) => {
+      const allowedStates = /* @__PURE__ */ new Set(["recording", "processing", "none"]);
+      if (typeof state !== "string" || !allowedStates.has(state)) {
+        return { success: false, error: "Invalid overlay state" };
+      }
       getWindowsTaskbar()?.setOverlayIcon(state);
       return { success: true };
     }
@@ -11209,7 +11700,11 @@ function registerWindowHandlers(ctx) {
       isDownloaded: modelDownloadManager.isModelDownloaded(info.name)
     }));
   });
+  const ALLOWED_WHISPER_MODELS = /* @__PURE__ */ new Set(["tiny", "base", "small", "medium", "large"]);
   ipcMain.handle(IPC_CHANNELS.WHISPER_DOWNLOAD_MODEL, async (_, model) => {
+    if (typeof model !== "string" || !ALLOWED_WHISPER_MODELS.has(model)) {
+      return { success: false, error: "Invalid model name" };
+    }
     try {
       const unsubProgress = modelDownloadManager.onProgress((progress) => {
         getMainWindow()?.webContents.send(IPC_CHANNELS.WHISPER_DOWNLOAD_PROGRESS, {
@@ -11250,6 +11745,9 @@ function registerWindowHandlers(ctx) {
     }
   });
   ipcMain.handle(IPC_CHANNELS.WHISPER_CANCEL_DOWNLOAD, (_, model) => {
+    if (typeof model !== "string" || !ALLOWED_WHISPER_MODELS.has(model)) {
+      return { success: false, error: "Invalid model name" };
+    }
     modelDownloadManager.cancelDownload(model);
     return { success: true };
   });
@@ -11496,7 +11994,12 @@ let windowsTaskbar = null;
 const DEV_RENDERER_URL = "http://localhost:5173";
 const DEV_RENDERER_LOAD_RETRIES = 10;
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function safeSendToRenderer(channel, ...args) {
+  if (mainWindow && !mainWindow.isDestroyed()) {
+    mainWindow.webContents.send(channel, ...args);
+  }
 }
 function attachRendererDiagnostics(window, label) {
   window.on("unresponsive", () => {
@@ -11543,10 +12046,10 @@ function wireAudioTelemetry() {
   teardownAudioTelemetry.forEach((teardown) => teardown());
   teardownAudioTelemetry = [];
   const sendAudioLevel = (level) => {
-    mainWindow?.webContents.send(IPC_CHANNELS.AUDIO_LEVEL, level);
+    safeSendToRenderer(IPC_CHANNELS.AUDIO_LEVEL, level);
   };
   const sendVoiceActivity = (active) => {
-    mainWindow?.webContents.send(IPC_CHANNELS.AUDIO_VOICE_ACTIVITY, active);
+    safeSendToRenderer(IPC_CHANNELS.AUDIO_VOICE_ACTIVITY, active);
   };
   teardownAudioTelemetry.push(
     audioCapture.onAudioLevel(sendAudioLevel),
@@ -11605,8 +12108,7 @@ function createWindow() {
       preload: preloadPath,
       nodeIntegration: false,
       contextIsolation: true,
-      sandbox: false
-      // Required for preload to work with contextBridge
+      sandbox: true
     }
   });
   attachRendererDiagnostics(mainWindow, "Main");
@@ -11629,7 +12131,16 @@ function createWindow() {
     mainWindow = null;
   });
   mainWindow.webContents.setWindowOpenHandler(({ url }) => {
-    shell.openExternal(url);
+    try {
+      const parsed = new URL(url);
+      if (parsed.protocol === "https:" || parsed.protocol === "http:") {
+        shell.openExternal(url);
+      } else {
+        console.warn(`[Main] Blocked external URL with protocol: ${parsed.protocol}`);
+      }
+    } catch {
+      console.warn(`[Main] Blocked invalid external URL`);
+    }
     return { action: "deny" };
   });
   sessionController.setMainWindow(mainWindow);
@@ -11668,7 +12179,7 @@ function handleSessionStateChange(state, session) {
   console.log(`[Main] Session state changed: ${state}`);
   trayManager.setState(mapToTrayState(state));
   if (state === "recording" && sessionController.isSessionPaused()) {
-    trayManager.setTooltip("markupr - Paused (Cmd+Shift+P to resume)");
+    trayManager.setTooltip(`markupr - Paused (${formatHotkeyForDisplay("pauseResume")} to resume)`);
   }
   const keepVisibleOnBlur = state === "starting" || state === "recording" || state === "stopping" || state === "processing";
   popover?.setKeepVisibleOnBlur(keepVisibleOnBlur);
@@ -11680,14 +12191,14 @@ function handleSessionStateChange(state, session) {
     popover.show();
   }
   windowsTaskbar?.updateSessionState(state);
-  mainWindow?.webContents.send(IPC_CHANNELS.SESSION_STATE_CHANGED, {
+  safeSendToRenderer(IPC_CHANNELS.SESSION_STATE_CHANGED, {
     state,
     session: session ? serializeSession(session) : null
   });
-  mainWindow?.webContents.send(IPC_CHANNELS.SESSION_STATUS, sessionController.getStatus());
+  safeSendToRenderer(IPC_CHANNELS.SESSION_STATUS, sessionController.getStatus());
 }
 function handleFeedbackItem(item) {
-  mainWindow?.webContents.send(IPC_CHANNELS.SESSION_FEEDBACK_ITEM, {
+  safeSendToRenderer(IPC_CHANNELS.SESSION_FEEDBACK_ITEM, {
     id: item.id,
     timestamp: item.timestamp,
     text: item.text,
@@ -11713,7 +12224,7 @@ function handleSessionError(error) {
   console.error("[Main] Session error:", error);
   trayManager.setState("error");
   trayManager.setTooltip(`markupr - Error: ${error.message}`);
-  mainWindow?.webContents.send(IPC_CHANNELS.SESSION_ERROR, {
+  safeSendToRenderer(IPC_CHANNELS.SESSION_ERROR, {
     message: error.message
   });
   showErrorNotification("Recording Error", error.message);
@@ -11822,15 +12333,22 @@ function handleHotkeyAction(action) {
       console.warn(`[Main] Unknown hotkey action: ${action}`);
   }
 }
+let toggleRecordingInFlight = false;
 async function handleToggleRecording() {
-  const currentState = sessionController.getState();
-  if (currentState === "recording") {
-    await stopSession();
-  } else if (currentState === "idle") {
-    const result = await startSession();
-    if (!result.success && result.error) {
-      showErrorNotification("Unable to Start Recording", result.error);
+  if (toggleRecordingInFlight) return;
+  toggleRecordingInFlight = true;
+  try {
+    const currentState = sessionController.getState();
+    if (currentState === "recording") {
+      await stopSession();
+    } else if (currentState === "idle") {
+      const result = await startSession();
+      if (!result.success && result.error) {
+        showErrorNotification("Unable to Start Recording", result.error);
+      }
     }
+  } finally {
+    toggleRecordingInFlight = false;
   }
 }
 async function handlePauseResume() {
@@ -11860,7 +12378,7 @@ function pauseSession() {
   if (!paused) {
     return { success: false, error: "Session is already paused." };
   }
-  trayManager.setTooltip("markupr - Paused (Cmd+Shift+P to resume)");
+  trayManager.setTooltip(`markupr - Paused (${formatHotkeyForDisplay("pauseResume")} to resume)`);
   return { success: true };
 }
 function resumeSession() {
@@ -11871,7 +12389,7 @@ function resumeSession() {
   if (!resumed) {
     return { success: false, error: "Session is not paused." };
   }
-  trayManager.setTooltip("markupr - Recording... (Cmd+Shift+F to stop)");
+  trayManager.setTooltip(`markupr - Recording... (${formatHotkeyForDisplay("toggleRecording")} to stop)`);
   return { success: true };
 }
 async function resolveDefaultCaptureSource() {
@@ -11880,7 +12398,8 @@ async function resolveDefaultCaptureSource() {
     thumbnailSize: { width: 1, height: 1 }
   });
   if (!sources.length) {
-    throw new Error("No screen capture source is available.");
+    const settingsHint = process.platform === "darwin" ? "System Settings > Privacy & Security > Screen Recording" : process.platform === "win32" ? "Windows Settings > Privacy > Screen capture" : "your system settings";
+    throw new Error(`No screen capture source is available. Check that markupr has screen recording permission in ${settingsHint}.`);
   }
   const primaryDisplayId = String(screen.getPrimaryDisplay().id);
   const preferredSource = sources.find((source) => source.display_id === primaryDisplayId);
@@ -11999,9 +12518,10 @@ async function startSession(sourceId, sourceName) {
       checkPermission("screen")
     ]);
     if (!microphoneGranted || !screenGranted) {
+      const settingsName = process.platform === "darwin" ? "macOS System Settings" : process.platform === "win32" ? "Windows Settings > Privacy" : "your system settings";
       return {
         success: false,
-        error: "Microphone and screen recording permissions are required. Enable both in macOS System Settings, then retry."
+        error: `Microphone and screen recording permissions are required. Enable both in ${settingsName}, then retry.`
       };
     }
     let resolvedSourceId = sourceId;
@@ -12064,7 +12584,7 @@ async function stopSession() {
   };
   const emitProcessingProgress = (percent, step) => {
     const boundedPercent = Math.max(0, Math.min(100, Math.round(percent)));
-    mainWindow?.webContents.send(IPC_CHANNELS.PROCESSING_PROGRESS, {
+    safeSendToRenderer(IPC_CHANNELS.PROCESSING_PROGRESS, {
       percent: boundedPercent,
       step
     });
@@ -12225,7 +12745,7 @@ async function stopSession() {
         console.log(
           `[Main:stopSession] Step 5/6 complete: post-processing took ${Date.now() - postProcessStartedAt}ms, ${postProcessResult?.transcriptSegments.length ?? 0} segments, ${postProcessResult?.extractedFrames.length ?? 0} frames extracted`
         );
-        mainWindow?.webContents.send(IPC_CHANNELS.PROCESSING_COMPLETE, postProcessResult);
+        safeSendToRenderer(IPC_CHANNELS.PROCESSING_COMPLETE, postProcessResult);
       } catch (postProcessError) {
         console.warn("[Main:stopSession] Step 5/6 FAILED: Post-processing pipeline error, continuing with basic output:", postProcessError);
       } finally {
@@ -12287,8 +12807,8 @@ async function stopSession() {
     console.log(
       `[Main:stopSession] All steps complete in ${totalDurationMs}ms (AI: ${aiDurationMs}ms, save: ${saveDurationMs}ms, postProcess: ${postProcessDurationMs}ms). Report: ${saveResult.markdownPath}`
     );
-    mainWindow?.webContents.send(IPC_CHANNELS.SESSION_COMPLETE, serializeSession(session));
-    mainWindow?.webContents.send(IPC_CHANNELS.OUTPUT_READY, {
+    safeSendToRenderer(IPC_CHANNELS.SESSION_COMPLETE, serializeSession(session));
+    safeSendToRenderer(IPC_CHANNELS.OUTPUT_READY, {
       markdown: markdownForPayload,
       sessionId: session.id,
       path: saveResult.markdownPath,
@@ -12573,6 +13093,9 @@ app.on("will-quit", async () => {
     });
   }
   getFinalizedScreenRecordings().clear();
+  await audioCapture.clearRecoveryBuffers().catch((err) => {
+    console.warn("[Main] Failed to clear audio recovery buffers:", err);
+  });
   teardownAudioTelemetry.forEach((teardown) => teardown());
   teardownAudioTelemetry = [];
   teardownSettingsListeners.forEach((teardown) => teardown());