diff --git a/.gitignore b/.gitignore
index 3784c0cf8..ac93fba57 100644
--- a/.gitignore
+++ b/.gitignore
@@ -40,6 +40,7 @@ electron/native/gpu-export-probe/build/
 electron/native/nvidia-cuda-compositor/build/
 electron/native/bin/*/whisper-*
 electron/native/bin/*/whisper-runtime.json
+electron/native/bin/*/*.dll
 
 # Local debug helpers
 tmp-*.ps1
diff --git a/electron/electron-env.d.ts b/electron/electron-env.d.ts
index 1a926718f..2d47e3246 100644
--- a/electron/electron-env.d.ts
+++ b/electron/electron-env.d.ts
@@ -67,6 +67,14 @@ interface UpdateStatusSummary {
 
 type RendererRecordingSessionData = import("./ipc/types").RecordingSessionData;
 
+interface FocusModeResult {
+	success: boolean;
+	enabled: boolean;
+	/** Always true for in-app suppression (supported on all platforms). */
+	supported: boolean;
+	error?: string;
+}
+
 interface RendererFfmpegAudioMuxMetrics {
 	tempVideoWriteMs?: number;
 	tempEditedAudioWriteMs?: number;
@@ -930,6 +938,11 @@ interface Window {
 		cancelCountdown: () => Promise<{ success: boolean }>;
 		getActiveCountdown: () => Promise<{ success: boolean; seconds: number | null }>;
 		onCountdownTick: (callback: (seconds: number) => void) => () => void;
+		/** Focus mode — in-app notification suppression */
+		getFocusModeStatus: () => Promise<FocusModeResult>;
+		setFocusMode: (enabled: boolean) => Promise<FocusModeResult>;
+		/** Subscribe to focus-mode state changes broadcast from the main process. Returns an unsubscribe function. */
+		onFocusModeChanged: (callback: (result: FocusModeResult) => void) => () => void;
 	};
 }
 
diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts
index 2a0f998eb..6fe88a8a5 100644
--- a/electron/ipc/handlers.ts
+++ b/electron/ipc/handlers.ts
@@ -3,6 +3,7 @@ import { registerAnnouncementHandlers } from "./register/announcements";
 import { registerAssetHandlers } from "./register/assets";
 import { registerCaptionHandlers } from "./register/captions";
 import { registerExportHandlers } from "./register/export";
+import { registerFocusModeHandlers } from "./register/focusMode";
 import { registerPermissionHandlers } from "./register/permissions";
 import { registerProjectHandlers } from "./register/project";
 import { registerRecordingHandlers } from "./register/recording";
@@ -71,4 +72,5 @@ export function registerIpcHandlers(
 	registerCaptionHandlers();
 	registerProjectHandlers();
 	registerSettingsHandlers();
+	registerFocusModeHandlers();
 }
diff --git a/electron/ipc/register/focusMode.test.ts b/electron/ipc/register/focusMode.test.ts
new file mode 100644
index 000000000..b0e195917
--- /dev/null
+++ b/electron/ipc/register/focusMode.test.ts
@@ -0,0 +1,158 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// ── In-memory settings store mock ─────────────────────────────────────────────
+const settingsStore: Record<string, unknown> = {};
+
+vi.mock("../../appSettingsStore", () => ({
+	readAppSetting: (key: string) => settingsStore[key] ?? null,
+	writeAppSetting: (key: string, value: unknown) => {
+		settingsStore[key] = value;
+	},
+}));
+
+// ── Electron mock ─────────────────────────────────────────────────────────────
+const handlers: Record<string, (event: unknown, ...args: unknown[]) => unknown> = {};
+const sentMessages: Array<{ channel: string; payload: unknown }> = [];
+
+const mockWebContents = {
+	isDestroyed: () => false,
+	send: (channel: string, payload: unknown) => {
+		sentMessages.push({ channel, payload });
+	},
+};
+
+vi.mock("electron", () => ({
+	ipcMain: {
+		handle: (channel: string, handler: (event: unknown, ...args: unknown[]) => unknown) => {
+			handlers[channel] = handler;
+		},
+	},
+	webContents: {
+		getAllWebContents: () => [mockWebContents],
+	},
+}));
+
+// ── Import after mocks are set up ─────────────────────────────────────────────
+import { registerFocusModeHandlers } from "./focusMode";
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function invoke(channel: string, ...args: unknown[]) {
+	const handler = handlers[channel];
+	if (!handler) throw new Error(`No handler registered for channel "${channel}"`);
+	return handler(null, ...args);
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe("focus mode IPC handlers", () => {
+	beforeEach(() => {
+		// Register handlers fresh for each test
+		registerFocusModeHandlers();
+		// Clear sent messages
+		sentMessages.length = 0;
+		// Reset the settings store
+		for (const k of Object.keys(settingsStore)) {
+			delete settingsStore[k];
+		}
+	});
+
+	afterEach(() => {
+		// Clean up registered handlers between tests
+		for (const k of Object.keys(handlers)) {
+			delete handlers[k];
+		}
+	});
+
+	describe("get-focus-mode-status", () => {
+		it("returns enabled:false when no stored value exists", () => {
+			const result = invoke("get-focus-mode-status");
+			expect(result).toEqual({ success: true, enabled: false, supported: true });
+		});
+
+		it("returns enabled:true when the setting is persisted as true", () => {
+			settingsStore["focusModeEnabled"] = true;
+			const result = invoke("get-focus-mode-status");
+			expect(result).toEqual({ success: true, enabled: true, supported: true });
+		});
+
+		it("coerces a non-boolean truthy stored value to false (strict equality check)", () => {
+			// The handler uses `stored === true` — only exact boolean true is accepted.
+			settingsStore["focusModeEnabled"] = 1;
+			const result = invoke("get-focus-mode-status");
+			expect(result).toEqual({ success: true, enabled: false, supported: true });
+		});
+	});
+
+	describe("set-focus-mode", () => {
+		it("enables focus mode and persists the setting", () => {
+			const result = invoke("set-focus-mode", true);
+			expect(result).toEqual({ success: true, enabled: true, supported: true });
+			expect(settingsStore["focusModeEnabled"]).toBe(true);
+		});
+
+		it("disables focus mode and persists the setting", () => {
+			settingsStore["focusModeEnabled"] = true;
+			const result = invoke("set-focus-mode", false);
+			expect(result).toEqual({ success: true, enabled: false, supported: true });
+			expect(settingsStore["focusModeEnabled"]).toBe(false);
+		});
+
+		it("rejects a non-boolean payload (string)", () => {
+			const result = invoke("set-focus-mode", "true") as {
+				success: boolean;
+				error?: string;
+			};
+			expect(result.success).toBe(false);
+			expect(typeof result.error).toBe("string");
+			// Setting should remain unchanged
+			expect(settingsStore["focusModeEnabled"]).toBeUndefined();
+		});
+
+		it("rejects a non-boolean payload (number)", () => {
+			const result = invoke("set-focus-mode", 1) as { success: boolean };
+			expect(result.success).toBe(false);
+		});
+
+		it("rejects null payload", () => {
+			const result = invoke("set-focus-mode", null) as { success: boolean };
+			expect(result.success).toBe(false);
+		});
+
+		it("broadcasts focus-mode-changed to all renderer windows on success", () => {
+			invoke("set-focus-mode", true);
+			expect(sentMessages).toHaveLength(1);
+			expect(sentMessages[0].channel).toBe("focus-mode-changed");
+			expect(sentMessages[0].payload).toEqual({
+				success: true,
+				enabled: true,
+				supported: true,
+			});
+		});
+
+		it("does not broadcast on rejected non-boolean input", () => {
+			invoke("set-focus-mode", "yes");
+			expect(sentMessages).toHaveLength(0);
+		});
+	});
+
+	describe("crash / restart recovery via persisted state", () => {
+		it("restores enabled:true from the settings store on next get after abnormal exit", () => {
+			// Simulate: the setting was persisted during a previous session
+			settingsStore["focusModeEnabled"] = true;
+			// On next app launch the handler reads the store
+			const result = invoke("get-focus-mode-status");
+			expect(result).toEqual({ success: true, enabled: true, supported: true });
+		});
+	});
+
+	describe("supported is always true (in-app suppression)", () => {
+		it("get always returns supported:true", () => {
+			const result = invoke("get-focus-mode-status") as { supported: boolean };
+			expect(result.supported).toBe(true);
+		});
+
+		it("set always returns supported:true on success", () => {
+			const result = invoke("set-focus-mode", false) as { supported: boolean };
+			expect(result.supported).toBe(true);
+		});
+	});
+});
diff --git a/electron/ipc/register/focusMode.ts b/electron/ipc/register/focusMode.ts
new file mode 100644
index 000000000..937c05059
--- /dev/null
+++ b/electron/ipc/register/focusMode.ts
@@ -0,0 +1,86 @@
+import { ipcMain, webContents } from "electron";
+import { readAppSetting, writeAppSetting } from "../../appSettingsStore";
+
+const FOCUS_MODE_SETTING_KEY = "focusModeEnabled";
+
+/** The result shape returned by all focus-mode IPC handlers. */
+interface FocusModeResult {
+	success: boolean;
+	enabled: boolean;
+	/** Always true: in-app suppression is supported on every platform. */
+	supported: boolean;
+	error?: string;
+}
+
+function readFocusModeEnabled(): boolean {
+	const stored = readAppSetting(FOCUS_MODE_SETTING_KEY);
+	return stored === true;
+}
+
+function broadcastFocusModeChanged(result: FocusModeResult) {
+	for (const wc of webContents.getAllWebContents()) {
+		if (!wc.isDestroyed()) {
+			wc.send("focus-mode-changed", result);
+		}
+	}
+}
+
+export function registerFocusModeHandlers() {
+	// ── get-focus-mode-status ─────────────────────────────────────────────────
+	ipcMain.handle("get-focus-mode-status", (): FocusModeResult => {
+		try {
+			return {
+				success: true,
+				enabled: readFocusModeEnabled(),
+				supported: true,
+			};
+		} catch (error) {
+			console.error("[focus-mode] Failed to read focus mode status:", error);
+			return {
+				success: false,
+				enabled: false,
+				supported: true,
+				error: String(error),
+			};
+		}
+	});
+
+	// ── set-focus-mode ────────────────────────────────────────────────────────
+	ipcMain.handle("set-focus-mode", (_event, enabled: unknown): FocusModeResult => {
+		// Validate: reject non-boolean payloads rather than coercing.
+		if (typeof enabled !== "boolean") {
+			const error = `set-focus-mode: expected boolean, received ${typeof enabled}`;
+			console.warn(`[focus-mode] ${error}`);
+			return {
+				success: false,
+				enabled: readFocusModeEnabled(),
+				supported: true,
+				error,
+			};
+		}
+
+		try {
+			writeAppSetting(FOCUS_MODE_SETTING_KEY, enabled);
+
+			const result: FocusModeResult = {
+				success: true,
+				enabled,
+				supported: true,
+			};
+
+			// Broadcast to all renderer windows so multi-window state stays in sync.
+			broadcastFocusModeChanged(result);
+
+			return result;
+		} catch (error) {
+			console.error("[focus-mode] Failed to set focus mode:", error);
+			// Return last-known state so the renderer can revert correctly.
+			return {
+				success: false,
+				enabled: readFocusModeEnabled(),
+				supported: true,
+				error: String(error),
+			};
+		}
+	});
+}
diff --git a/electron/preload.ts b/electron/preload.ts
index 990ee7a8f..8f2ddc3fc 100644
--- a/electron/preload.ts
+++ b/electron/preload.ts
@@ -1019,4 +1019,22 @@ contextBridge.exposeInMainWorld("electronAPI", {
 		ipcRenderer.on("countdown-tick", listener);
 		return () => ipcRenderer.removeListener("countdown-tick", listener);
 	},
+	// Focus mode — in-app notification suppression
+	getFocusModeStatus: () => ipcRenderer.invoke("get-focus-mode-status"),
+	setFocusMode: (enabled: boolean) => ipcRenderer.invoke("set-focus-mode", enabled),
+	onFocusModeChanged: (
+		callback: (result: {
+			success: boolean;
+			enabled: boolean;
+			supported: boolean;
+			error?: string;
+		}) => void,
+	) => {
+		const listener = (
+			_event: Electron.IpcRendererEvent,
+			payload: { success: boolean; enabled: boolean; supported: boolean; error?: string },
+		) => callback(payload);
+		ipcRenderer.on("focus-mode-changed", listener);
+		return () => ipcRenderer.removeListener("focus-mode-changed", listener);
+	},
 });
diff --git a/src/components/announcements/AnnouncementDialog.tsx b/src/components/announcements/AnnouncementDialog.tsx
index a9bc0fcfb..51b4ef61f 100644
--- a/src/components/announcements/AnnouncementDialog.tsx
+++ b/src/components/announcements/AnnouncementDialog.tsx
@@ -1,6 +1,6 @@
 import { ArrowLeft, ArrowRight, ArrowSquareOut, Megaphone } from "@phosphor-icons/react";
 import { useEffect, useRef, useState } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { BUNDLED_ANNOUNCEMENT_FEED } from "@/content/announcements";
 import { useI18n } from "@/contexts/I18nContext";
 import { runAnnouncementAction } from "@/lib/announcementActions";
diff --git a/src/components/announcements/EditorAnnouncementBanner.tsx b/src/components/announcements/EditorAnnouncementBanner.tsx
index 6180c17b9..a714b8198 100644
--- a/src/components/announcements/EditorAnnouncementBanner.tsx
+++ b/src/components/announcements/EditorAnnouncementBanner.tsx
@@ -1,6 +1,6 @@
 import { ArrowRight, ArrowSquareOut, X } from "@phosphor-icons/react";
 import { useEffect, useRef, useState } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { Button } from "@/components/ui/button";
 import { BUNDLED_ANNOUNCEMENT_FEED } from "@/content/announcements";
 import { useI18n } from "@/contexts/I18nContext";
diff --git a/src/components/announcements/LiveAnnouncementNotifications.tsx b/src/components/announcements/LiveAnnouncementNotifications.tsx
index 3d6bce30f..ff91f5d1a 100644
--- a/src/components/announcements/LiveAnnouncementNotifications.tsx
+++ b/src/components/announcements/LiveAnnouncementNotifications.tsx
@@ -1,5 +1,5 @@
 import { useEffect, useRef } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { BUNDLED_ANNOUNCEMENT_FEED } from "@/content/announcements";
 import { useI18n } from "@/contexts/I18nContext";
 import { runAnnouncementAction } from "@/lib/announcementActions";
diff --git a/src/components/launch/LaunchWindow.tsx b/src/components/launch/LaunchWindow.tsx
index 66cbe608b..27690f39b 100644
--- a/src/components/launch/LaunchWindow.tsx
+++ b/src/components/launch/LaunchWindow.tsx
@@ -1,5 +1,7 @@
 import {
 	ArrowClockwiseIcon,
+	BellSimpleIcon,
+	BellSimpleSlashIcon,
 	CaretUpIcon,
 	DotsThreeVerticalIcon,
 	MicrophoneIcon,
@@ -42,6 +44,7 @@ import { ProjectPopover } from "./popovers/ProjectPopover";
 import { SourcePopover } from "./popovers/SourcePopover";
 import { WebcamPopover } from "./popovers/WebcamPopover";
 import { RecordingControls } from "./RecordingControls";
+import { useFocusMode } from "./hooks/useFocusMode";
 
 const SHOW_DEV_UPDATE_PREVIEW = import.meta.env.DEV;
 
@@ -85,6 +88,9 @@ function LaunchWindowContent() {
 	const hudContentRef = useRef<HTMLDivElement>(null);
 	const hudBarRef = useRef<HTMLDivElement>(null);
 
+	const { focusModeEnabled, focusModeSupported, focusModeLoading, toggleFocusMode } =
+		useFocusMode();
+
 	const {
 		selectedSource,
 		hasSelectedSource,
@@ -345,6 +351,38 @@ function LaunchWindowContent() {
 				}
 			/>
 
+			<Button
+				variant="ghost"
+				size="icon"
+				iconSize="lg"
+				id="focus-mode-toggle"
+				title={
+					!focusModeSupported
+						? t("recording.focusModeUnavailable")
+						: focusModeEnabled
+							? t("recording.disableFocusMode")
+							: t("recording.enableFocusMode")
+				}
+				aria-label={
+					!focusModeSupported
+						? t("recording.focusModeUnavailable")
+						: focusModeEnabled
+							? t("recording.disableFocusMode")
+							: t("recording.enableFocusMode")
+				}
+				disabled={!focusModeSupported || focusModeLoading}
+				className={focusModeEnabled && focusModeSupported ? styles.ibActive : ""}
+				onClick={() => {
+					void toggleFocusMode();
+				}}
+			>
+				{focusModeEnabled ? (
+					<BellSimpleSlashIcon size={18} />
+				) : (
+					<BellSimpleIcon size={18} />
+				)}
+			</Button>
+
 			<button
 				type="button"
 				className={`${styles.recBtn} ${styles.electronNoDrag}`}
diff --git a/src/components/launch/hooks/useFocusMode.test.ts b/src/components/launch/hooks/useFocusMode.test.ts
new file mode 100644
index 000000000..b918d91ec
--- /dev/null
+++ b/src/components/launch/hooks/useFocusMode.test.ts
@@ -0,0 +1,174 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// Mock i18n context
+vi.mock("../../../contexts/I18nContext", () => ({
+	useScopedT: () => (key: string) => `translated:${key}`,
+}));
+
+// Mock toast wrapper
+vi.mock("../../../lib/toast", () => ({
+	toast: {
+		error: vi.fn(),
+		errorAlways: vi.fn(),
+	},
+}));
+
+// Mock focusMode ref module
+const setFocusModeEnabledRefMock = vi.fn();
+const setFocusModeInitializedMock = vi.fn();
+vi.mock("../../../lib/focusMode", () => ({
+	setFocusModeEnabledRef: (val: boolean) => setFocusModeEnabledRefMock(val),
+	setFocusModeInitialized: () => setFocusModeInitializedMock(),
+}));
+
+// Custom minimal hook runner to simulate React lifecycle in Node
+let stateMap: Map<number, unknown> = new Map();
+let stateSetters: Map<number, (v: unknown) => void> = new Map();
+let effectCleanups: Array<(() => void) | undefined> = [];
+let stateIndex = 0;
+let effectCallbacks: Array<() => void | (() => void)> = [];
+
+vi.mock("react", async () => {
+	const actual = await vi.importActual<typeof import("react")>("react");
+	return {
+		...actual,
+		useState: (initial: unknown) => {
+			const idx = stateIndex++;
+			if (!stateMap.has(idx)) {
+				stateMap.set(idx, typeof initial === "function" ? initial() : initial);
+			}
+			const setter = (val: unknown) => {
+				const next = typeof val === "function" ? val(stateMap.get(idx)) : val;
+				stateMap.set(idx, next);
+			};
+			stateSetters.set(idx, setter);
+			return [stateMap.get(idx), setter];
+		},
+		useEffect: (effect: () => void | (() => void)) => {
+			effectCallbacks.push(effect);
+		},
+		useCallback: (fn: (...args: unknown[]) => unknown) => fn,
+	};
+});
+
+describe("useFocusMode hook", () => {
+	let mockGetFocusModeStatus: ReturnType<typeof vi.fn>;
+	let mockSetFocusMode: ReturnType<typeof vi.fn>;
+	let mockOnFocusModeChanged: ReturnType<typeof vi.fn>;
+	let listenerCallback: ((result: unknown) => void) | null = null;
+	const unsubscribeMock = vi.fn();
+
+	beforeEach(() => {
+		stateMap.clear();
+		stateSetters.clear();
+		effectCleanups = [];
+		effectCallbacks = [];
+		stateIndex = 0;
+		listenerCallback = null;
+		unsubscribeMock.mockClear();
+		setFocusModeEnabledRefMock.mockClear();
+		setFocusModeInitializedMock.mockClear();
+
+		mockGetFocusModeStatus = vi.fn().mockResolvedValue({
+			success: true,
+			enabled: false,
+			supported: true,
+		});
+
+		mockSetFocusMode = vi.fn().mockResolvedValue({
+			success: true,
+			enabled: true,
+			supported: true,
+		});
+
+		mockOnFocusModeChanged = vi.fn((cb) => {
+			listenerCallback = cb;
+			return unsubscribeMock;
+		});
+
+		(globalThis as unknown as { electronAPI: unknown }).electronAPI = {
+			getFocusModeStatus: mockGetFocusModeStatus,
+			setFocusMode: mockSetFocusMode,
+			onFocusModeChanged: mockOnFocusModeChanged,
+		};
+		(globalThis as unknown as { window: unknown }).window = globalThis;
+	});
+
+	afterEach(() => {
+		Reflect.deleteProperty(globalThis, "electronAPI");
+		Reflect.deleteProperty(globalThis, "window");
+		vi.clearAllMocks();
+	});
+
+	async function runHook() {
+		stateIndex = 0;
+		effectCallbacks = [];
+		const { useFocusMode } = await import("./useFocusMode");
+		// biome-ignore lint/correctness/useHookAtTopLevel: runHook is a test-only hook runner, not a React component
+		const hookResult = useFocusMode();
+
+		// Run mounted effects
+		for (const cb of effectCallbacks) {
+			const cleanup = cb();
+			if (typeof cleanup === "function") {
+				effectCleanups.push(cleanup);
+			}
+		}
+
+		return hookResult;
+	}
+
+	it("queries getFocusModeStatus on mount and syncs state", async () => {
+		mockGetFocusModeStatus.mockResolvedValueOnce({
+			success: true,
+			enabled: true,
+			supported: true,
+		});
+
+		const result = await runHook();
+		expect(mockGetFocusModeStatus).toHaveBeenCalled();
+		// Wait for microtasks to resolve
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(setFocusModeEnabledRefMock).toHaveBeenCalledWith(true);
+		expect(result.focusModeEnabled).toBe(false); // initial return before async resolves
+	});
+
+	it("subscribes to onFocusModeChanged and cleans up on unmount", async () => {
+		await runHook();
+		expect(mockOnFocusModeChanged).toHaveBeenCalled();
+		expect(listenerCallback).toBeDefined();
+
+		// Trigger change event
+		listenerCallback!({ success: true, enabled: true, supported: true });
+		expect(setFocusModeEnabledRefMock).toHaveBeenCalledWith(true);
+
+		// Trigger cleanups
+		for (const cleanup of effectCleanups) {
+			cleanup?.();
+		}
+		expect(unsubscribeMock).toHaveBeenCalled();
+	});
+
+	it("toggles focus mode and calls setFocusMode", async () => {
+		const result = await runHook();
+		await result.toggleFocusMode();
+
+		expect(mockSetFocusMode).toHaveBeenCalledWith(true);
+		expect(setFocusModeEnabledRefMock).toHaveBeenCalledWith(true);
+	});
+
+	it("shows error toast when toggle fails", async () => {
+		const { toast } = await import("../../../lib/toast");
+		mockSetFocusMode.mockResolvedValueOnce({
+			success: false,
+			error: "Custom error message",
+		});
+
+		const result = await runHook();
+		await result.toggleFocusMode();
+
+		expect(toast.errorAlways).toHaveBeenCalledWith("Custom error message");
+	});
+});
diff --git a/src/components/launch/hooks/useFocusMode.ts b/src/components/launch/hooks/useFocusMode.ts
new file mode 100644
index 000000000..a7d4097bd
--- /dev/null
+++ b/src/components/launch/hooks/useFocusMode.ts
@@ -0,0 +1,98 @@
+import { useCallback, useEffect, useState } from "react";
+import { useScopedT } from "../../../contexts/I18nContext";
+import { setFocusModeEnabledRef, setFocusModeInitialized } from "../../../lib/focusMode";
+import { toast } from "../../../lib/toast";
+
+/**
+ * Manages focus-mode state for the HUD.
+ *
+ * - Queries `getFocusModeStatus()` on mount to restore persisted state.
+ * - Subscribes to `onFocusModeChanged` for multi-window synchronisation.
+ * - `toggleFocusMode` sends `setFocusMode` and updates state only after a
+ *   confirmed success; on failure it reverts the icon and surfaces a toast.
+ */
+export function useFocusMode() {
+	const t = useScopedT("launch");
+	const [focusModeEnabled, setFocusModeEnabled] = useState(false);
+	const [focusModeSupported, setFocusModeSupported] = useState(true);
+	const [focusModeLoading, setFocusModeLoading] = useState(false);
+
+	// Keep the module-level ref in sync so the toast wrapper can read it
+	// without needing access to React state.
+	const applyState = useCallback((enabled: boolean, supported: boolean) => {
+		setFocusModeEnabled(enabled);
+		setFocusModeSupported(supported);
+		setFocusModeEnabledRef(enabled);
+	}, []);
+
+	// ── Initial load ──────────────────────────────────────────────────────────
+	useEffect(() => {
+		let cancelled = false;
+
+		const load = async () => {
+			try {
+				const result = await window.electronAPI?.getFocusModeStatus?.();
+				if (!cancelled && result?.success) {
+					applyState(result.enabled, result.supported);
+					// Mark as initialized so toast suppression activates from this point.
+					setFocusModeInitialized();
+				}
+			} catch (error) {
+				console.error("[useFocusMode] Failed to load focus mode status:", error);
+			}
+		};
+
+		void load();
+
+		return () => {
+			cancelled = true;
+		};
+	}, [applyState]);
+
+	// ── Multi-window sync ─────────────────────────────────────────────────────
+	useEffect(() => {
+		const cleanup = window.electronAPI?.onFocusModeChanged?.((result) => {
+			if (result.success) {
+				applyState(result.enabled, result.supported);
+			}
+		});
+
+		return () => {
+			cleanup?.();
+		};
+	}, [applyState]);
+
+	// ── Toggle ────────────────────────────────────────────────────────────────
+	const toggleFocusMode = useCallback(async () => {
+		if (focusModeLoading) return;
+
+		const next = !focusModeEnabled;
+		setFocusModeLoading(true);
+
+		try {
+			const result = await window.electronAPI?.setFocusMode?.(next);
+
+			if (result?.success) {
+				applyState(result.enabled, result.supported);
+			} else {
+				// Revert to the last known-good state; the ref is already correct.
+				// Use errorAlways so this control error is visible even when focus
+				// mode is currently active.
+				const errorMsg = result?.error ?? t("recording.focusModeError");
+				toast.errorAlways(errorMsg);
+			}
+		} catch (error) {
+			console.error("[useFocusMode] Failed to toggle focus mode:", error);
+			toast.errorAlways(t("recording.focusModeError"));
+		} finally {
+			setFocusModeLoading(false);
+		}
+	}, [focusModeEnabled, focusModeLoading, applyState, t]);
+
+	return {
+		focusModeEnabled,
+		focusModeSupported,
+		focusModeLoading,
+		toggleFocusMode,
+	};
+}
diff --git a/src/components/video-editor/AddCustomFontDialog.tsx b/src/components/video-editor/AddCustomFontDialog.tsx
index 2fe3aac6a..8cc980c4e 100644
--- a/src/components/video-editor/AddCustomFontDialog.tsx
+++ b/src/components/video-editor/AddCustomFontDialog.tsx
@@ -1,6 +1,6 @@
 import { Plus } from "@phosphor-icons/react";
 import { useState } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { Button } from "@/components/ui/button";
 import {
 	Dialog,
diff --git a/src/components/video-editor/AnnotationSettingsPanel.tsx b/src/components/video-editor/AnnotationSettingsPanel.tsx
index af5326320..482edd773 100644
--- a/src/components/video-editor/AnnotationSettingsPanel.tsx
+++ b/src/components/video-editor/AnnotationSettingsPanel.tsx
@@ -15,7 +15,7 @@ import {
 } from "@phosphor-icons/react";
 import Block from "@uiw/react-color-block";
 import { useEffect, useMemo, useRef, useState } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { Button } from "@/components/ui/button";
 import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
 import {
diff --git a/src/components/video-editor/EditorWindow.tsx b/src/components/video-editor/EditorWindow.tsx
index f45d9cb6e..6b42f2148 100644
--- a/src/components/video-editor/EditorWindow.tsx
+++ b/src/components/video-editor/EditorWindow.tsx
@@ -1,6 +1,7 @@
 import { useEffect } from "react";
 import { ShortcutsProvider } from "../../contexts/ShortcutsContext";
 import { loadAllCustomFonts } from "../../lib/customFonts";
+import { setFocusModeEnabledRef, setFocusModeInitialized } from "../../lib/focusMode";
 import { AnnouncementDialog } from "../announcements/AnnouncementDialog";
 import { LiveAnnouncementNotifications } from "../announcements/LiveAnnouncementNotifications";
 import { ShortcutsConfigDialog } from "./ShortcutsConfigDialog";
@@ -13,6 +14,30 @@ export default function EditorWindow() {
 		});
 	}, []);
 
+	// Sync focus-mode state into the module-level ref so that the toast wrapper
+	// suppresses notifications in the editor window too, matching the HUD.
+	useEffect(() => {
+		let cancelled = false;
+
+		void window.electronAPI?.getFocusModeStatus?.().then((result) => {
+			if (!cancelled && result?.success) {
+				setFocusModeEnabledRef(result.enabled);
+				setFocusModeInitialized();
+			}
+		});
+
+		const cleanup = window.electronAPI?.onFocusModeChanged?.((result) => {
+			if (result.success) {
+				setFocusModeEnabledRef(result.enabled);
+			}
+		});
+
+		return () => {
+			cancelled = true;
+			cleanup?.();
+		};
+	}, []);
+
 	return (
 		<>
 			<ShortcutsProvider>
diff --git a/src/components/video-editor/SettingsPanel.tsx b/src/components/video-editor/SettingsPanel.tsx
index 8b289e3f5..7bd143a0c 100644
--- a/src/components/video-editor/SettingsPanel.tsx
+++ b/src/components/video-editor/SettingsPanel.tsx
@@ -8,7 +8,7 @@ import {
 } from "@phosphor-icons/react";
 import { AnimatePresence, LayoutGroup, motion } from "motion/react";
 import { useEffect, useMemo, useRef, useState } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import minimalCursorUrl from "@/assets/cursors/custom/minimal-cursor.svg";
 import { Button } from "@/components/ui/button";
 import {
diff --git a/src/components/video-editor/ShortcutsConfigDialog.tsx b/src/components/video-editor/ShortcutsConfigDialog.tsx
index c359c1f11..f68bf4d28 100644
--- a/src/components/video-editor/ShortcutsConfigDialog.tsx
+++ b/src/components/video-editor/ShortcutsConfigDialog.tsx
@@ -1,6 +1,6 @@
 import { Keyboard, ArrowCounterClockwise as RotateCcw } from "@phosphor-icons/react";
 import { useCallback, useEffect, useState } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { Button } from "@/components/ui/button";
 import {
 	Dialog,
diff --git a/src/components/video-editor/TutorialHelp.tsx b/src/components/video-editor/TutorialHelp.tsx
index b38b6f3e8..eb64f4ccc 100644
--- a/src/components/video-editor/TutorialHelp.tsx
+++ b/src/components/video-editor/TutorialHelp.tsx
@@ -22,7 +22,7 @@ import { useScopedT } from "@/contexts/I18nContext";
 import { useShortcuts } from "@/contexts/ShortcutsContext";
 import { formatBinding, SHORTCUT_ACTIONS, SHORTCUT_LABELS } from "@/lib/shortcuts";
 import { formatShortcut } from "@/utils/platformUtils";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 
 export const RECORDLY_ISSUES_URL = "https://github.com/webadderallorg/Recordly/issues";
 const RECORDLY_DISCORD_URL = "https://discord.gg/sdv2FBVNgE";
diff --git a/src/components/video-editor/audio/useSourceAudioFallback.ts b/src/components/video-editor/audio/useSourceAudioFallback.ts
index f081d2ce6..dec2d37ad 100644
--- a/src/components/video-editor/audio/useSourceAudioFallback.ts
+++ b/src/components/video-editor/audio/useSourceAudioFallback.ts
@@ -1,5 +1,5 @@
 import { useEffect, useRef, useState } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { SOURCE_AUDIO_FALLBACK_TOAST_ID } from "@/components/video-editor/audio/audioTypes";
 
 interface UseSourceAudioFallbackParams {
diff --git a/src/components/video-editor/captions/useAutoCaptionController.ts b/src/components/video-editor/captions/useAutoCaptionController.ts
index 8ac1c11cf..e996bd76e 100644
--- a/src/components/video-editor/captions/useAutoCaptionController.ts
+++ b/src/components/video-editor/captions/useAutoCaptionController.ts
@@ -1,5 +1,5 @@
 import { type Dispatch, type SetStateAction, useCallback, useEffect, useRef } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { resolveAutoCaptionSourcePath } from "../autoCaptionSource";
 import { type CaptionEditTarget, updateCaptionCuesForEditedTarget } from "../captionEditing";
 import { resolveVideoUrl } from "../projectPersistence";
diff --git a/src/components/video-editor/export/exportRunnerSupport.ts b/src/components/video-editor/export/exportRunnerSupport.ts
index 11c8cf8e6..76a05edba 100644
--- a/src/components/video-editor/export/exportRunnerSupport.ts
+++ b/src/components/video-editor/export/exportRunnerSupport.ts
@@ -1,6 +1,6 @@
 import type { RefObject } from "react";
 import { useCallback } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import type { SupportedMp4Dimensions } from "@/lib/exporter";
 import type { useVideoEditorAudio } from "../audio/useVideoEditorAudio";
 import type { getSmokeExportConfig } from "../smokeExportConfig";
diff --git a/src/components/video-editor/export/useExportDialogActions.ts b/src/components/video-editor/export/useExportDialogActions.ts
index 0c7bc87f4..fef1a095f 100644
--- a/src/components/video-editor/export/useExportDialogActions.ts
+++ b/src/components/video-editor/export/useExportDialogActions.ts
@@ -1,5 +1,5 @@
 import { type RefObject, useCallback } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import type { ExportSettings } from "@/lib/exporter";
 import { resolveExportStartSettings } from "../exportStartSettings";
 import type { VideoPlaybackRef } from "../VideoPlayback";
diff --git a/src/components/video-editor/export/useExportRunner.ts b/src/components/video-editor/export/useExportRunner.ts
index 37edbdba4..0d07ab3e2 100644
--- a/src/components/video-editor/export/useExportRunner.ts
+++ b/src/components/video-editor/export/useExportRunner.ts
@@ -1,5 +1,5 @@
 import { useCallback, useRef } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { getMp4ExportBitrate } from "@/lib/exporter/exportBitrate";
 import { DEFAULT_MP4_CODEC } from "@/lib/exporter/mp4Support";
 import type { ExportSettings } from "@/lib/exporter/types";
diff --git a/src/components/video-editor/hooks/useClipRegionCommands.ts b/src/components/video-editor/hooks/useClipRegionCommands.ts
index f605789e9..7b9ee9747 100644
--- a/src/components/video-editor/hooks/useClipRegionCommands.ts
+++ b/src/components/video-editor/hooks/useClipRegionCommands.ts
@@ -1,6 +1,6 @@
 import type { Span } from "dnd-timeline";
 import { type Dispatch, type MutableRefObject, type SetStateAction, useCallback } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { changeClipSpan } from "../clipSpanChange";
 import { planClipSpeedChange } from "../clipSpeedChange";
 import { planClipSplit } from "../clipSplit";
diff --git a/src/components/video-editor/hooks/useTimelineEditingController.ts b/src/components/video-editor/hooks/useTimelineEditingController.ts
index 083340f9a..0f563c234 100644
--- a/src/components/video-editor/hooks/useTimelineEditingController.ts
+++ b/src/components/video-editor/hooks/useTimelineEditingController.ts
@@ -1,6 +1,6 @@
 import type { Dispatch, MutableRefObject, RefObject, SetStateAction } from "react";
 import { useCallback } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import type { useI18n } from "@/contexts/I18nContext";
 import type { useShortcuts } from "@/contexts/ShortcutsContext";
 import { useVideoEditorAudio } from "../audio/useVideoEditorAudio";
diff --git a/src/components/video-editor/layout/EditorExportMenu.tsx b/src/components/video-editor/layout/EditorExportMenu.tsx
index 7f557a70a..a13a8d477 100644
--- a/src/components/video-editor/layout/EditorExportMenu.tsx
+++ b/src/components/video-editor/layout/EditorExportMenu.tsx
@@ -1,5 +1,5 @@
 import { DownloadSimple as Download } from "@phosphor-icons/react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { Button } from "@/components/ui/button";
 import {
 	DropdownMenu,
diff --git a/src/components/video-editor/layout/EditorSidebar.tsx b/src/components/video-editor/layout/EditorSidebar.tsx
index d73720b68..cae0a74c5 100644
--- a/src/components/video-editor/layout/EditorSidebar.tsx
+++ b/src/components/video-editor/layout/EditorSidebar.tsx
@@ -10,7 +10,7 @@ import {
 import { motion } from "motion/react";
 import type { ComponentProps, Dispatch, SetStateAction } from "react";
 import { useMemo } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import type { useI18n } from "@/contexts/I18nContext";
 import ExtensionManager from "../ExtensionManager";
 import { SettingsPanel } from "../SettingsPanel";
diff --git a/src/components/video-editor/presets/useEditorPresets.ts b/src/components/video-editor/presets/useEditorPresets.ts
index d092dbe9d..0c10cde33 100644
--- a/src/components/video-editor/presets/useEditorPresets.ts
+++ b/src/components/video-editor/presets/useEditorPresets.ts
@@ -1,5 +1,5 @@
 import { type Dispatch, type SetStateAction, useCallback, useEffect, useMemo } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import {
 	type EditorPreset,
 	type EditorPresetSnapshot,
diff --git a/src/components/video-editor/project/useProjectLifecycle.ts b/src/components/video-editor/project/useProjectLifecycle.ts
index 1f0a0f320..d395963c2 100644
--- a/src/components/video-editor/project/useProjectLifecycle.ts
+++ b/src/components/video-editor/project/useProjectLifecycle.ts
@@ -8,7 +8,7 @@ import {
 	useMemo,
 	useRef,
 } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import type { AspectRatio } from "@/utils/aspectRatioUtils";
 import type { useExportSettings } from "../export/useExportSettings";
 import type { UnsavedChangesDecision } from "../layout/EditorDialogs";
diff --git a/src/components/video-editor/project/useProjectOpenActions.ts b/src/components/video-editor/project/useProjectOpenActions.ts
index 127e5ec54..3f60ae362 100644
--- a/src/components/video-editor/project/useProjectOpenActions.ts
+++ b/src/components/video-editor/project/useProjectOpenActions.ts
@@ -6,7 +6,7 @@ import {
 	useCallback,
 	useEffect,
 } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { fromFileUrl, resolveVideoUrl } from "../projectPersistence";
 import type { useAppearanceState } from "../state/useAppearanceState";
 import type { useProjectState } from "../state/useProjectState";
diff --git a/src/components/video-editor/project/useProjectSaveActions.ts b/src/components/video-editor/project/useProjectSaveActions.ts
index bf1c51b27..47b5e0005 100644
--- a/src/components/video-editor/project/useProjectSaveActions.ts
+++ b/src/components/video-editor/project/useProjectSaveActions.ts
@@ -1,5 +1,5 @@
 import { type RefObject, useCallback, useEffect, useRef } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { createProjectData, type EditorProjectData } from "../projectPersistence";
 import type { useProjectState } from "../state/useProjectState";
 import { cloneStructured, getErrorMessage } from "../videoEditorUtils";
diff --git a/src/components/video-editor/timeline/hooks/utils/timelineNotifications.ts b/src/components/video-editor/timeline/hooks/utils/timelineNotifications.ts
index 7843b1d5b..bbc31834b 100644
--- a/src/components/video-editor/timeline/hooks/utils/timelineNotifications.ts
+++ b/src/components/video-editor/timeline/hooks/utils/timelineNotifications.ts
@@ -1,4 +1,4 @@
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 
 export interface TimelineNotifications {
 	error: (title: string, description?: string) => void;
diff --git a/src/hooks/useScreenRecorder.ts b/src/hooks/useScreenRecorder.ts
index 459652415..aa4dac052 100644
--- a/src/hooks/useScreenRecorder.ts
+++ b/src/hooks/useScreenRecorder.ts
@@ -1,6 +1,6 @@
 import { fixWebmDuration } from "@fix-webm-duration/fix";
 import { useCallback, useEffect, useRef, useState } from "react";
-import { toast } from "sonner";
+import { toast } from "@/lib/toast";
 import { getEffectiveRecordingDurationMs } from "@/lib/mediaTiming";
 import {
 	getVideoExtensionForMimeType,
diff --git a/src/i18n/locales/de/launch.json b/src/i18n/locales/de/launch.json
index bae512379..a18bc2114 100644
--- a/src/i18n/locales/de/launch.json
+++ b/src/i18n/locales/de/launch.json
@@ -43,6 +43,10 @@
 		"stop": "Stopp",
 		"cancel": "Abbrechen",
 		"more": "Mehr",
+		"enableFocusMode": "Fokusmodus aktivieren",
+		"disableFocusMode": "Fokusmodus deaktivieren",
+		"focusModeUnavailable": "Fokusmodus auf dieser Plattform nicht verfügbar",
+		"focusModeError": "Fokusmodus konnte nicht geändert werden",
 		"update": {
 			"update": "Aktualisieren",
 			"updated": "Aktualisiert",
diff --git a/src/i18n/locales/en/launch.json b/src/i18n/locales/en/launch.json
index d4f7aba94..fc03b44f7 100644
--- a/src/i18n/locales/en/launch.json
+++ b/src/i18n/locales/en/launch.json
@@ -43,6 +43,10 @@
 		"stop": "Stop",
 		"cancel": "Cancel",
 		"more": "More",
+		"enableFocusMode": "Enable focus mode",
+		"disableFocusMode": "Disable focus mode",
+		"focusModeUnavailable": "Focus mode unavailable on this platform",
+		"focusModeError": "Failed to change focus mode",
 		"update": {
 			"update": "Update",
 			"updated": "Updated",
diff --git a/src/i18n/locales/es/launch.json b/src/i18n/locales/es/launch.json
index 4edc2d9c6..93beb4ab1 100644
--- a/src/i18n/locales/es/launch.json
+++ b/src/i18n/locales/es/launch.json
@@ -43,6 +43,10 @@
 		"stop": "Detener",
 		"cancel": "Cancelar",
 		"more": "Más",
+		"enableFocusMode": "Activar modo de concentración",
+		"disableFocusMode": "Desactivar modo de concentración",
+		"focusModeUnavailable": "El modo de concentración no está disponible en esta plataforma",
+		"focusModeError": "No se pudo cambiar el modo de concentración",
 		"update": {
 			"update": "Actualizar",
 			"updated": "Actualizado",
diff --git a/src/i18n/locales/fr/launch.json b/src/i18n/locales/fr/launch.json
index 2969355fa..73e76e2c1 100644
--- a/src/i18n/locales/fr/launch.json
+++ b/src/i18n/locales/fr/launch.json
@@ -43,6 +43,10 @@
 		"stop": "Arrêter",
 		"cancel": "Annuler",
 		"more": "Plus",
+		"enableFocusMode": "Activer le mode concentration",
+		"disableFocusMode": "Désactiver le mode concentration",
+		"focusModeUnavailable": "Le mode concentration n'est pas disponible sur cette plateforme",
+		"focusModeError": "Impossible de modifier le mode concentration",
 		"update": {
 			"update": "Mettre à jour",
 			"updated": "Mis à jour",
diff --git a/src/i18n/locales/it/launch.json b/src/i18n/locales/it/launch.json
index 0dbdbea34..7ebe52284 100644
--- a/src/i18n/locales/it/launch.json
+++ b/src/i18n/locales/it/launch.json
@@ -43,6 +43,10 @@
 		"stop": "Stop",
 		"cancel": "Annulla",
 		"more": "Altro",
+		"enableFocusMode": "Attiva modalità Focus",
+		"disableFocusMode": "Disattiva modalità Focus",
+		"focusModeUnavailable": "Modalità Focus non disponibile su questa piattaforma",
+		"focusModeError": "Impossibile modificare la modalità Focus",
 		"update": {
 			"update": "Aggiorna",
 			"updated": "Aggiornato",
diff --git a/src/i18n/locales/ko/launch.json b/src/i18n/locales/ko/launch.json
index 2e4683a56..7bf76eff5 100644
--- a/src/i18n/locales/ko/launch.json
+++ b/src/i18n/locales/ko/launch.json
@@ -43,6 +43,10 @@
 		"stop": "중지",
 		"cancel": "취소",
 		"more": "더 보기",
+		"enableFocusMode": "집중 모드 사용",
+		"disableFocusMode": "집중 모드 사용 안 함",
+		"focusModeUnavailable": "이 플랫폼에서는 집중 모드를 사용할 수 없습니다",
+		"focusModeError": "집중 모드를 변경하지 못했습니다",
 		"update": {
 			"update": "업데이트",
 			"updated": "업데이트 완료",
diff --git a/src/i18n/locales/nl/launch.json b/src/i18n/locales/nl/launch.json
index 774c7335a..b61f860e4 100644
--- a/src/i18n/locales/nl/launch.json
+++ b/src/i18n/locales/nl/launch.json
@@ -43,6 +43,10 @@
 		"stop": "Stoppen",
 		"cancel": "Annuleren",
 		"more": "Meer",
+		"enableFocusMode": "Focusmodus inschakelen",
+		"disableFocusMode": "Focusmodus uitschakelen",
+		"focusModeUnavailable": "Focusmodus is niet beschikbaar op dit platform",
+		"focusModeError": "Focusmodus kon niet worden gewijzigd",
 		"update": {
 			"update": "Bijwerken",
 			"updated": "Bijgewerkt",
diff --git a/src/i18n/locales/pt-BR/launch.json b/src/i18n/locales/pt-BR/launch.json
index cc8c35c7e..bf55fac73 100644
--- a/src/i18n/locales/pt-BR/launch.json
+++ b/src/i18n/locales/pt-BR/launch.json
@@ -43,6 +43,10 @@
 		"stop": "Parar",
 		"cancel": "Cancelar",
 		"more": "Mais",
+		"enableFocusMode": "Ativar modo de foco",
+		"disableFocusMode": "Desativar modo de foco",
+		"focusModeUnavailable": "Modo de foco não disponível nesta plataforma",
+		"focusModeError": "Falha ao alterar o modo de foco",
 		"update": {
 			"update": "Atualizar",
 			"updated": "Atualizado",
diff --git a/src/i18n/locales/ru/launch.json b/src/i18n/locales/ru/launch.json
index 47531cfa1..b1d1493aa 100644
--- a/src/i18n/locales/ru/launch.json
+++ b/src/i18n/locales/ru/launch.json
@@ -43,6 +43,10 @@
 		"stop": "Стоп",
 		"cancel": "Отмена",
 		"more": "Ещё",
+		"enableFocusMode": "Включить режим концентрации",
+		"disableFocusMode": "Выключить режим концентрации",
+		"focusModeUnavailable": "Режим концентрации недоступен на этой платформе",
+		"focusModeError": "Не удалось изменить режим концентрации",
 		"update": {
 			"update": "Обновить",
 			"updated": "Обновлено",
diff --git a/src/i18n/locales/zh-CN/launch.json b/src/i18n/locales/zh-CN/launch.json
index 2b88c6d70..79f57afbb 100644
--- a/src/i18n/locales/zh-CN/launch.json
+++ b/src/i18n/locales/zh-CN/launch.json
@@ -43,6 +43,10 @@
 		"stop": "停止",
 		"cancel": "取消",
 		"more": "更多",
+		"enableFocusMode": "开启专注模式",
+		"disableFocusMode": "关闭专注模式",
+		"focusModeUnavailable": "专注模式在此平台上不可用",
+		"focusModeError": "更改专注模式失败",
 		"update": {
 			"update": "更新",
 			"updated": "已是最新",
diff --git a/src/i18n/locales/zh-TW/launch.json b/src/i18n/locales/zh-TW/launch.json
index 9d44d3218..8b64f8922 100644
--- a/src/i18n/locales/zh-TW/launch.json
+++ b/src/i18n/locales/zh-TW/launch.json
@@ -43,6 +43,10 @@
 		"stop": "停止",
 		"cancel": "取消",
 		"more": "更多",
+		"enableFocusMode": "開啟專注模式",
+		"disableFocusMode": "關閉專注模式",
+		"focusModeUnavailable": "此平台不支援專注模式",
+		"focusModeError": "變更專注模式失敗",
 		"update": {
 			"update": "更新",
 			"updated": "已更新",
diff --git a/src/lib/focusMode.ts b/src/lib/focusMode.ts
new file mode 100644
index 000000000..a3a7bc6cb
--- /dev/null
+++ b/src/lib/focusMode.ts
@@ -0,0 +1,41 @@
+/**
+ * Renderer-side focus-mode state.
+ *
+ * This module holds a single mutable reference to the current focus-mode
+ * enabled flag. It is updated by the `useFocusMode` hook (which syncs from
+ * the main process) and read synchronously by the `toast` wrapper to decide
+ * whether to suppress notifications.
+ *
+ * Keeping state here — rather than only in React — avoids having to thread
+ * the flag through every component that might show a toast.
+ *
+ * `_initialized` starts as `false` so that toasts are never suppressed
+ * during early startup (before the persisted status has been fetched from
+ * the main process). The hook sets it to `true` once the first
+ * `getFocusModeStatus` response is received.
+ */
+
+let _focusModeEnabled = false;
+let _initialized = false;
+
+/** Returns true when focus mode is currently active AND the status has been initialized. */
+export function isFocusModeEnabled(): boolean {
+	return _initialized && _focusModeEnabled;
+}
+
+/**
+ * Called by `useFocusMode` whenever the main-process broadcasts a state change.
+ * Not intended for direct use outside of the hook.
+ */
+export function setFocusModeEnabledRef(enabled: boolean): void {
+	_focusModeEnabled = enabled;
+}
+
+/**
+ * Called by `useFocusMode` once the initial `getFocusModeStatus` response
+ * succeeds. Until this is called, `isFocusModeEnabled()` returns `false`
+ * so that early-startup toasts are never accidentally suppressed.
+ */
+export function setFocusModeInitialized(): void {
+	_initialized = true;
+}
diff --git a/src/lib/toast.test.ts b/src/lib/toast.test.ts
new file mode 100644
index 000000000..2f96fce87
--- /dev/null
+++ b/src/lib/toast.test.ts
@@ -0,0 +1,87 @@
+import { toast as sonnerToast } from "sonner";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { isFocusModeEnabled, setFocusModeEnabledRef, setFocusModeInitialized } from "./focusMode";
+import { toast } from "./toast";
+
+vi.mock("sonner", () => ({
+	toast: Object.assign(vi.fn(), {
+		success: vi.fn(),
+		error: vi.fn(),
+		info: vi.fn(),
+		warning: vi.fn(),
+		loading: vi.fn(),
+		promise: vi.fn(),
+		dismiss: vi.fn(),
+		custom: vi.fn(),
+		message: vi.fn(),
+	}),
+}));
+
+describe("toast wrapper with focus mode", () => {
+	beforeEach(() => {
+		setFocusModeEnabledRef(false);
+		setFocusModeInitialized();
+		vi.clearAllMocks();
+	});
+
+	afterEach(() => {
+		setFocusModeEnabledRef(false);
+	});
+
+	it("passes through toast calls when focus mode is disabled", () => {
+		expect(isFocusModeEnabled()).toBe(false);
+
+		toast("hello");
+		expect(sonnerToast).toHaveBeenCalledWith("hello");
+
+		toast.success("saved");
+		expect(sonnerToast.success).toHaveBeenCalledWith("saved");
+
+		toast.error("failed");
+		expect(sonnerToast.error).toHaveBeenCalledWith("failed");
+
+		toast.info("note");
+		expect(sonnerToast.info).toHaveBeenCalledWith("note");
+
+		toast.warning("alert");
+		expect(sonnerToast.warning).toHaveBeenCalledWith("alert");
+
+		toast.loading("working");
+		expect(sonnerToast.loading).toHaveBeenCalledWith("working");
+	});
+
+	it("suppresses all toast variants and returns dummy id when focus mode is enabled", () => {
+		setFocusModeEnabledRef(true);
+		expect(isFocusModeEnabled()).toBe(true);
+
+		const id = toast("hello");
+		expect(id).toBe("focus-mode-suppressed");
+		expect(sonnerToast).not.toHaveBeenCalled();
+
+		const successId = toast.success("saved");
+		expect(successId).toBe("focus-mode-suppressed");
+		expect(sonnerToast.success).not.toHaveBeenCalled();
+
+		const errorId = toast.error("failed");
+		expect(errorId).toBe("focus-mode-suppressed");
+		expect(sonnerToast.error).not.toHaveBeenCalled();
+
+		const infoId = toast.info("note");
+		expect(infoId).toBe("focus-mode-suppressed");
+		expect(sonnerToast.info).not.toHaveBeenCalled();
+
+		const warningId = toast.warning("alert");
+		expect(warningId).toBe("focus-mode-suppressed");
+		expect(sonnerToast.warning).not.toHaveBeenCalled();
+
+		const loadingId = toast.loading("working");
+		expect(loadingId).toBe("focus-mode-suppressed");
+		expect(sonnerToast.loading).not.toHaveBeenCalled();
+	});
+
+	it("allows dismiss calls even when focus mode is active", () => {
+		setFocusModeEnabledRef(true);
+		toast.dismiss("some-id");
+		expect(sonnerToast.dismiss).toHaveBeenCalledWith("some-id");
+	});
+});
diff --git a/src/lib/toast.ts b/src/lib/toast.ts
new file mode 100644
index 000000000..8959855c4
--- /dev/null
+++ b/src/lib/toast.ts
@@ -0,0 +1,84 @@
+/**
+ * Focus-mode-aware toast wrapper.
+ *
+ * Import `toast` from this module instead of directly from `"sonner"`.
+ * All calls are silently suppressed while focus mode is active so that
+ * Recordly does not interrupt the user's focus session with notifications.
+ *
+ * The API surface mirrors the subset of sonner's `toast` that is used
+ * across this codebase: the base call plus `.success`, `.error`, `.info`,
+ * `.warning`, `.loading`, `.promise`, `.custom`, `.message`, and `.dismiss`.
+ *
+ * `.errorAlways` bypasses suppression for critical control errors (e.g.
+ * focus-mode toggle failures) that must always be visible to the user.
+ */
+
+import { toast as sonnerToast } from "sonner";
+import { isFocusModeEnabled } from "./focusMode";
+
+type SonnerToast = typeof sonnerToast;
+
+function noop(): string {
+	// Return a stable dummy ID so callers that pass the ID to toast.dismiss()
+	// don't break when the toast was suppressed.
+	return "focus-mode-suppressed";
+}
+
+function maybeToast(...args: Parameters<SonnerToast>): ReturnType<SonnerToast> {
+	if (isFocusModeEnabled()) {
+		return noop() as ReturnType<SonnerToast>;
+	}
+	return sonnerToast(...args);
+}
+
+maybeToast.success = ((...args: Parameters<SonnerToast["success"]>) => {
+	if (isFocusModeEnabled()) return noop();
+	return sonnerToast.success(...args);
+}) as SonnerToast["success"];
+
+maybeToast.error = ((...args: Parameters<SonnerToast["error"]>) => {
+	if (isFocusModeEnabled()) return noop();
+	return sonnerToast.error(...args);
+}) as SonnerToast["error"];
+
+maybeToast.info = ((...args: Parameters<SonnerToast["info"]>) => {
+	if (isFocusModeEnabled()) return noop();
+	return sonnerToast.info(...args);
+}) as SonnerToast["info"];
+
+maybeToast.warning = ((...args: Parameters<SonnerToast["warning"]>) => {
+	if (isFocusModeEnabled()) return noop();
+	return sonnerToast.warning(...args);
+}) as SonnerToast["warning"];
+
+maybeToast.loading = ((...args: Parameters<SonnerToast["loading"]>) => {
+	if (isFocusModeEnabled()) return noop();
+	return sonnerToast.loading(...args);
+}) as SonnerToast["loading"];
+
+maybeToast.promise = ((...args: Parameters<SonnerToast["promise"]>) => {
+	if (isFocusModeEnabled()) return noop();
+	return sonnerToast.promise(...args);
+}) as SonnerToast["promise"];
+
+maybeToast.custom = ((...args: Parameters<SonnerToast["custom"]>) => {
+	if (isFocusModeEnabled()) return noop();
+	return sonnerToast.custom(...args);
+}) as SonnerToast["custom"];
+
+maybeToast.message = ((...args: Parameters<SonnerToast["message"]>) => {
+	if (isFocusModeEnabled()) return noop();
+	return sonnerToast.message(...args);
+}) as SonnerToast["message"];
+
+maybeToast.dismiss = sonnerToast.dismiss;
+
+/**
+ * Like `toast.error` but always shows the toast regardless of focus mode.
+ * Use only for critical control errors that the user must see
+ * (e.g. the focus-mode toggle itself failing).
+ */
+maybeToast.errorAlways = sonnerToast.error;
+
+/** Focus-mode-aware drop-in replacement for sonner's `toast`. */
+export const toast = maybeToast;