diff --git a/src/browser/App.tsx b/src/browser/App.tsx
index 79d09597c9..655854cba0 100644
--- a/src/browser/App.tsx
+++ b/src/browser/App.tsx
@@ -39,7 +39,7 @@ import { CommandPalette } from "./components/CommandPalette/CommandPalette";
 import { buildCoreSources, type BuildSourcesParams } from "./utils/commands/sources";
 
 import { THINKING_LEVELS, type ThinkingLevel } from "@/common/types/thinking";
-import { CUSTOM_EVENTS } from "@/common/constants/events";
+import { CUSTOM_EVENTS, type CustomEventType } from "@/common/constants/events";
 import { isWorkspaceForkSwitchEvent } from "./utils/workspaceEvents";
 import {
   getAgentIdKey,
@@ -94,6 +94,8 @@ import { getErrorMessage } from "@/common/utils/errors";
 import assert from "@/common/utils/assert";
 import { createProjectRefs } from "@/common/utils/multiProject";
 import { MULTI_PROJECT_SIDEBAR_SECTION_ID } from "@/common/constants/multiProject";
+import type { EventSoundSettings } from "@/common/config/schemas/appConfigOnDisk";
+import { playEventSound } from "@/browser/utils/audio/eventSounds";
 import { WORKSPACE_DEFAULTS } from "@/constants/workspaceDefaults";
 import { LandingPage } from "@/browser/features/LandingPage/LandingPage";
 import { LoadingScreen } from "@/browser/components/LoadingScreen/LoadingScreen";
@@ -238,6 +240,55 @@ function AppInner() {
     workspaceMetadataRef.current = workspaceMetadata;
   }, [workspaceMetadata]);
 
+  const eventSoundSettingsRef = useRef<EventSoundSettings | undefined>(undefined);
+  const eventSoundSettingsLoadVersionRef = useRef(0);
+  useEffect(() => {
+    const handleEventSoundSettingsChanged = (
+      event: CustomEventType<typeof CUSTOM_EVENTS.EVENT_SOUND_SETTINGS_CHANGED>
+    ) => {
+      eventSoundSettingsLoadVersionRef.current += 1;
+      eventSoundSettingsRef.current = event.detail.eventSoundSettings;
+    };
+
+    window.addEventListener(
+      CUSTOM_EVENTS.EVENT_SOUND_SETTINGS_CHANGED,
+      handleEventSoundSettingsChanged as EventListener
+    );
+
+    if (!api) {
+      eventSoundSettingsRef.current = undefined;
+      return () => {
+        window.removeEventListener(
+          CUSTOM_EVENTS.EVENT_SOUND_SETTINGS_CHANGED,
+          handleEventSoundSettingsChanged as EventListener
+        );
+      };
+    }
+
+    let isCancelled = false;
+    const loadVersion = eventSoundSettingsLoadVersionRef.current;
+    void api.config
+      .getConfig()
+      .then((config) => {
+        if (!isCancelled && loadVersion === eventSoundSettingsLoadVersionRef.current) {
+          eventSoundSettingsRef.current = config.eventSoundSettings;
+        }
+      })
+      .catch((error) => {
+        if (!isCancelled) {
+          console.debug("Failed to load event sound settings", { error: String(error) });
+        }
+      });
+
+    return () => {
+      isCancelled = true;
+      window.removeEventListener(
+        CUSTOM_EVENTS.EVENT_SOUND_SETTINGS_CHANGED,
+        handleEventSoundSettingsChanged as EventListener
+      );
+    };
+  }, [api]);
+
   const handleOpenMuxChat = useCallback(() => {
     // User requested an F1 shortcut to jump straight into Chat with Mux.
     const metadata = workspaceMetadataRef.current.get(MUX_HELP_CHAT_WORKSPACE_ID);
@@ -1002,6 +1053,9 @@ function AppInner() {
         return;
       }
 
+      // Play event sound (independent of notification settings).
+      playEventSound(eventSoundSettingsRef.current, "agent_review_ready", api);
+
       // Skip notification if the selected workspace is focused (Slack-like behavior).
       // Notification suppression intentionally follows selection state, not chat-route visibility.
       const isWorkspaceFocused =
@@ -1038,7 +1092,7 @@ function AppInner() {
     return () => {
       unsubscribe?.();
     };
-  }, [setSelectedWorkspace, workspaceStore]);
+  }, [api, setSelectedWorkspace, workspaceStore]);
 
   // Show auth modal if authentication is required
   if (status === "auth_required") {
diff --git a/src/browser/components/AppLoader/AppLoader.auth.test.tsx b/src/browser/components/AppLoader/AppLoader.auth.test.tsx
index b7a831ffcb..c55c80d3cd 100644
--- a/src/browser/components/AppLoader/AppLoader.auth.test.tsx
+++ b/src/browser/components/AppLoader/AppLoader.auth.test.tsx
@@ -11,6 +11,8 @@ let cleanupDom: (() => void) | null = null;
 let apiStatus: "auth_required" | "connecting" | "error" = "auth_required";
 let apiError: string | null = "Authentication required";
 
+const AUTH_TOKEN_STORAGE_KEY = "mux:auth-token";
+
 // AppLoader imports App, which pulls in Lottie-based components. In happy-dom,
 // lottie-web's canvas bootstrap can throw during module evaluation.
 void mock.module("lottie-react", () => ({
@@ -67,14 +69,32 @@ void mock.module("@/browser/components/StartupConnectionError/StartupConnectionE
 void mock.module("@/browser/components/AuthTokenModal/AuthTokenModal", () => ({
   // Note: Module mocks leak between bun test files.
   // Export all commonly-used symbols to avoid cross-test import errors.
+  // Keep token helpers behaviorally close to production so leaked mocks do not
+  // break tests that expect auth-token persistence.
   AuthTokenModal: (props: { error?: string | null }) => (
     <div data-testid="AuthTokenModalMock">{props.error ?? "no-error"}</div>
   ),
-  getStoredAuthToken: () => null,
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  setStoredAuthToken: () => {},
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  clearStoredAuthToken: () => {},
+  getStoredAuthToken: () => {
+    try {
+      return localStorage.getItem(AUTH_TOKEN_STORAGE_KEY);
+    } catch {
+      return null;
+    }
+  },
+  setStoredAuthToken: (token: string) => {
+    try {
+      localStorage.setItem(AUTH_TOKEN_STORAGE_KEY, token);
+    } catch {
+      // no-op in tests without storage
+    }
+  },
+  clearStoredAuthToken: () => {
+    try {
+      localStorage.removeItem(AUTH_TOKEN_STORAGE_KEY);
+    } catch {
+      // no-op in tests without storage
+    }
+  },
 }));
 
 import { AppLoader } from "../AppLoader/AppLoader";
diff --git a/src/browser/contexts/API.test.tsx b/src/browser/contexts/API.test.tsx
index 5cda98f289..6fbaf9126c 100644
--- a/src/browser/contexts/API.test.tsx
+++ b/src/browser/contexts/API.test.tsx
@@ -65,13 +65,44 @@ let fetchImpl: (input: RequestInfo | URL, init?: RequestInit) => Promise<Respons
 
 // Mock orpc client
 let pingImpl: () => Promise<string> = () => Promise.resolve("pong");
+const AUTH_TOKEN_STORAGE_KEY = "mux:auth-token";
 let storedAuthToken: string | null = null;
-const getStoredAuthTokenMock = mock(() => storedAuthToken);
+
+function readStoredAuthTokenFromLocalStorage(): string | null {
+  try {
+    return localStorage.getItem(AUTH_TOKEN_STORAGE_KEY);
+  } catch {
+    return storedAuthToken;
+  }
+}
+
+function writeStoredAuthTokenToLocalStorage(token: string): void {
+  try {
+    localStorage.setItem(AUTH_TOKEN_STORAGE_KEY, token);
+  } catch {
+    // no-op in tests without storage
+  }
+}
+
+function clearStoredAuthTokenFromLocalStorage(): void {
+  try {
+    localStorage.removeItem(AUTH_TOKEN_STORAGE_KEY);
+  } catch {
+    // no-op in tests without storage
+  }
+}
+
+const getStoredAuthTokenMock = mock(() => {
+  storedAuthToken = readStoredAuthTokenFromLocalStorage();
+  return storedAuthToken;
+});
 const setStoredAuthTokenMock = mock((token: string) => {
   storedAuthToken = token;
+  writeStoredAuthTokenToLocalStorage(token);
 });
 const clearStoredAuthTokenMock = mock(() => {
   storedAuthToken = null;
+  clearStoredAuthTokenFromLocalStorage();
 });
 
 void mock.module("@/common/orpc/client", () => ({
@@ -93,6 +124,8 @@ void mock.module("@orpc/client/message-port", () => ({
 void mock.module("@/browser/components/AuthTokenModal/AuthTokenModal", () => ({
   // Note: Module mocks leak between bun test files.
   // Export all commonly-used symbols to avoid cross-test import errors.
+  // Keep token helpers behaviorally close to production so leaked mocks do not
+  // break tests that expect auth-token persistence.
   AuthTokenModal: () => null,
   getStoredAuthToken: getStoredAuthTokenMock,
   setStoredAuthToken: setStoredAuthTokenMock,
diff --git a/src/browser/features/Settings/Sections/SoundsSection.tsx b/src/browser/features/Settings/Sections/SoundsSection.tsx
new file mode 100644
index 0000000000..66ef7ccb04
--- /dev/null
+++ b/src/browser/features/Settings/Sections/SoundsSection.tsx
@@ -0,0 +1,380 @@
+import { useEffect, useRef, useState } from "react";
+
+import { Button } from "@/browser/components/Button/Button";
+import { Switch } from "@/browser/components/Switch/Switch";
+import { useAPI } from "@/browser/contexts/API";
+import { isDesktopMode } from "@/browser/hooks/useDesktopTitlebar";
+import { CUSTOM_EVENTS, createCustomEvent } from "@/common/constants/events";
+import {
+  ALLOWED_AUDIO_EXTENSIONS,
+  EVENT_SOUND_KEYS,
+  EVENT_SOUND_LABELS,
+  MAX_AUDIO_FILE_SIZE_BYTES,
+  type EventSoundKey,
+} from "@/common/config/eventSoundTypes";
+import type { EventSoundConfig, EventSoundSettings } from "@/common/config/schemas/appConfigOnDisk";
+
+const AUDIO_UPLOAD_ACCEPT = [
+  "audio/*",
+  ...ALLOWED_AUDIO_EXTENSIONS.map((extension) => `.${extension}`),
+].join(",");
+
+function readFileAsBase64(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      if (typeof reader.result !== "string") {
+        reject(new Error("Failed to read selected file."));
+        return;
+      }
+
+      const separatorIndex = reader.result.indexOf(",");
+      if (separatorIndex < 0) {
+        reject(new Error("Failed to parse selected file."));
+        return;
+      }
+
+      resolve(reader.result.slice(separatorIndex + 1));
+    };
+    reader.onerror = () => {
+      reject(new Error("Failed to read selected file."));
+    };
+    reader.readAsDataURL(file);
+  });
+}
+
+function getEventSoundConfig(settings: EventSoundSettings, key: EventSoundKey): EventSoundConfig {
+  const config = settings?.[key];
+  return {
+    enabled: config?.enabled === true,
+    source: config?.source ?? null,
+  };
+}
+
+function updateEventSoundConfig(
+  settings: EventSoundSettings,
+  key: EventSoundKey,
+  config: EventSoundConfig
+): EventSoundSettings {
+  return {
+    ...(settings ?? {}),
+    [key]: config,
+  };
+}
+
+function collectManagedAssetIds(settings: EventSoundSettings): Set<string> {
+  const managedAssetIds = new Set<string>();
+
+  for (const config of Object.values(settings ?? {})) {
+    if (config?.source?.kind === "managed") {
+      managedAssetIds.add(config.source.assetId);
+    }
+  }
+
+  return managedAssetIds;
+}
+
+function getUnreferencedManagedAssetIds(
+  previousSettings: EventSoundSettings,
+  nextSettings: EventSoundSettings
+): string[] {
+  const previousAssetIds = collectManagedAssetIds(previousSettings);
+  const nextAssetIds = collectManagedAssetIds(nextSettings);
+
+  return [...previousAssetIds].filter((assetId) => !nextAssetIds.has(assetId));
+}
+
+export function SoundsSection() {
+  const { api } = useAPI();
+  const [eventSoundSettings, setEventSoundSettings] = useState<EventSoundSettings>(undefined);
+
+  const loadNonceRef = useRef(0);
+  const saveChainRef = useRef<Promise<void>>(Promise.resolve());
+  const pendingSettingsRef = useRef<{
+    hasPending: boolean;
+    settings: EventSoundSettings;
+    staleManagedAssetIds: Set<string>;
+  }>({
+    hasPending: false,
+    settings: undefined,
+    staleManagedAssetIds: new Set<string>(),
+  });
+
+  // Browser mode uses one hidden file input for all rows, so we track which event key opened it.
+  const uploadInputRef = useRef<HTMLInputElement>(null);
+  const uploadTargetKeyRef = useRef<EventSoundKey | null>(null);
+
+  useEffect(() => {
+    if (!api?.config?.getConfig) {
+      return;
+    }
+
+    const loadNonce = ++loadNonceRef.current;
+
+    void api.config
+      .getConfig()
+      .then((config) => {
+        if (loadNonce !== loadNonceRef.current) {
+          return;
+        }
+
+        setEventSoundSettings(config.eventSoundSettings);
+      })
+      .catch(() => {
+        // Best-effort only.
+      });
+  }, [api]);
+
+  const queueSettingsSave = (nextSettings: EventSoundSettings, staleManagedAssetIds: string[]) => {
+    if (!api?.config?.updateEventSoundSettings) {
+      return;
+    }
+
+    pendingSettingsRef.current.hasPending = true;
+    pendingSettingsRef.current.settings = nextSettings;
+
+    for (const staleAssetId of staleManagedAssetIds) {
+      pendingSettingsRef.current.staleManagedAssetIds.add(staleAssetId);
+    }
+
+    // If a pending save now references an asset again, do not delete it.
+    for (const referencedAssetId of collectManagedAssetIds(nextSettings)) {
+      pendingSettingsRef.current.staleManagedAssetIds.delete(referencedAssetId);
+    }
+
+    // Serialize writes so rapid toggles/file selections cannot persist out-of-order settings.
+    saveChainRef.current = saveChainRef.current
+      .catch(() => {
+        // Best-effort only.
+      })
+      .then(async () => {
+        for (;;) {
+          if (!pendingSettingsRef.current.hasPending) {
+            return;
+          }
+
+          const pendingSettings = pendingSettingsRef.current.settings;
+          const staleAssetIds = [...pendingSettingsRef.current.staleManagedAssetIds];
+          pendingSettingsRef.current.hasPending = false;
+          pendingSettingsRef.current.staleManagedAssetIds.clear();
+
+          try {
+            await api.config.updateEventSoundSettings({ eventSoundSettings: pendingSettings });
+
+            const deleteAsset = api.eventSounds?.deleteAsset;
+            if (deleteAsset) {
+              const deletePromises = staleAssetIds.map((assetId) => deleteAsset({ assetId }));
+              await Promise.allSettled(deletePromises);
+            }
+          } catch {
+            for (const staleAssetId of staleAssetIds) {
+              pendingSettingsRef.current.staleManagedAssetIds.add(staleAssetId);
+            }
+            // Best-effort only.
+          }
+        }
+      });
+  };
+
+  const applySettingsUpdate = (updater: (prev: EventSoundSettings) => EventSoundSettings) => {
+    // If the user changed a value while initial load is in flight, keep local edits authoritative.
+    loadNonceRef.current++;
+
+    setEventSoundSettings((prev) => {
+      const next = updater(prev);
+      const staleManagedAssetIds = getUnreferencedManagedAssetIds(prev, next);
+      queueSettingsSave(next, staleManagedAssetIds);
+      window.dispatchEvent(
+        createCustomEvent(CUSTOM_EVENTS.EVENT_SOUND_SETTINGS_CHANGED, {
+          eventSoundSettings: next,
+        })
+      );
+      return next;
+    });
+  };
+
+  const handleEnabledChange = (key: EventSoundKey, enabled: boolean) => {
+    applySettingsUpdate((prev) => {
+      const current = getEventSoundConfig(prev, key);
+      return updateEventSoundConfig(prev, key, {
+        ...current,
+        enabled,
+      });
+    });
+  };
+
+  const handleBrowse = async (key: EventSoundKey) => {
+    if (!api?.projects?.pickAudioFile || !api?.eventSounds?.importFromLocalPath) {
+      return;
+    }
+
+    try {
+      const result = await api.projects.pickAudioFile({});
+      if (result.filePath == null) {
+        return;
+      }
+
+      const importedAsset = await api.eventSounds.importFromLocalPath({
+        localPath: result.filePath,
+      });
+
+      applySettingsUpdate((prev) => {
+        const current = getEventSoundConfig(prev, key);
+        return updateEventSoundConfig(prev, key, {
+          ...current,
+          source: {
+            kind: "managed",
+            assetId: importedAsset.assetId,
+            label: importedAsset.originalName,
+          },
+        });
+      });
+    } catch {
+      // Best-effort only.
+    }
+  };
+
+  const handleUpload = async (key: EventSoundKey, file: File) => {
+    if (!api?.eventSounds?.uploadAsset) {
+      return;
+    }
+
+    if (file.size > MAX_AUDIO_FILE_SIZE_BYTES) {
+      return;
+    }
+
+    try {
+      const base64 = await readFileAsBase64(file);
+      const uploadedAsset = await api.eventSounds.uploadAsset({
+        base64,
+        originalName: file.name,
+        mimeType: file.type,
+      });
+
+      applySettingsUpdate((prev) => {
+        const current = getEventSoundConfig(prev, key);
+        return updateEventSoundConfig(prev, key, {
+          ...current,
+          source: {
+            kind: "managed",
+            assetId: uploadedAsset.assetId,
+            label: uploadedAsset.originalName,
+          },
+        });
+      });
+    } catch {
+      // Best-effort only.
+    }
+  };
+
+  const openUploadPicker = (key: EventSoundKey) => {
+    uploadTargetKeyRef.current = key;
+    uploadInputRef.current?.click();
+  };
+
+  const handleClearFile = (key: EventSoundKey) => {
+    applySettingsUpdate((prev) => {
+      const current = getEventSoundConfig(prev, key);
+      return updateEventSoundConfig(prev, key, {
+        ...current,
+        source: null,
+      });
+    });
+  };
+
+  const canPersist = Boolean(api?.config?.updateEventSoundSettings);
+  const canUseDesktopBrowse =
+    isDesktopMode() &&
+    Boolean(api?.projects?.pickAudioFile) &&
+    Boolean(api?.eventSounds?.importFromLocalPath);
+
+  return (
+    <div className="space-y-4">
+      <div>
+        <h3 className="text-foreground text-sm font-medium">Event sounds</h3>
+        <p className="text-muted mt-1 text-xs">
+          Configure optional audio alerts for key events in Mux.
+        </p>
+      </div>
+
+      <input
+        ref={uploadInputRef}
+        type="file"
+        accept={AUDIO_UPLOAD_ACCEPT}
+        className="hidden"
+        onChange={(event) => {
+          const key = uploadTargetKeyRef.current;
+          const file = event.target.files?.[0];
+          event.target.value = "";
+
+          if (!key || !file) {
+            return;
+          }
+
+          void handleUpload(key, file);
+        }}
+      />
+
+      <div className="border-border-light divide-border-light divide-y rounded-md border">
+        {EVENT_SOUND_KEYS.map((key) => {
+          const soundConfig = getEventSoundConfig(eventSoundSettings, key);
+          const fileLabel =
+            soundConfig.source?.label ?? soundConfig.source?.assetId ?? "No sound selected";
+
+          return (
+            <div key={key} className="space-y-3 px-3 py-3">
+              <div className="flex items-center justify-between gap-4">
+                <div className="min-w-0 flex-1">
+                  <div className="text-foreground text-sm">{EVENT_SOUND_LABELS[key]}</div>
+                  <div className="text-muted mt-0.5 truncate text-xs" title={fileLabel}>
+                    {fileLabel}
+                  </div>
+                </div>
+                <Switch
+                  checked={soundConfig.enabled}
+                  onCheckedChange={(checked) => handleEnabledChange(key, checked)}
+                  disabled={!canPersist}
+                  aria-label={`Toggle sound for ${EVENT_SOUND_LABELS[key]}`}
+                />
+              </div>
+
+              <div className="flex items-center justify-end gap-2">
+                {canUseDesktopBrowse ? (
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    onClick={() => {
+                      void handleBrowse(key);
+                    }}
+                    disabled={!canPersist || !canUseDesktopBrowse}
+                  >
+                    Browse
+                  </Button>
+                ) : (
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    onClick={() => openUploadPicker(key)}
+                    disabled={!canPersist || !api?.eventSounds?.uploadAsset}
+                  >
+                    Upload
+                  </Button>
+                )}
+                {soundConfig.source ? (
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    onClick={() => handleClearFile(key)}
+                    disabled={!canPersist}
+                  >
+                    Clear
+                  </Button>
+                ) : null}
+              </div>
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}
diff --git a/src/browser/features/Settings/SettingsPage.tsx b/src/browser/features/Settings/SettingsPage.tsx
index 370f5fe18b..6a0dfed8ce 100644
--- a/src/browser/features/Settings/SettingsPage.tsx
+++ b/src/browser/features/Settings/SettingsPage.tsx
@@ -16,6 +16,7 @@ import {
   ShieldCheck,
   Server,
   Lock,
+  Volume2,
 } from "lucide-react";
 import { useSettings } from "@/browser/contexts/SettingsContext";
 import { useOnboardingPause } from "@/browser/features/SplashScreens/SplashScreenProvider";
@@ -37,6 +38,7 @@ import { ExperimentsSection } from "./Sections/ExperimentsSection";
 import { ServerAccessSection } from "./Sections/ServerAccessSection";
 import { KeybindsSection } from "./Sections/KeybindsSection";
 import { SecuritySection } from "./Sections/SecuritySection";
+import { SoundsSection } from "./Sections/SoundsSection";
 import type { SettingsSection } from "./types";
 
 const BASE_SECTIONS: SettingsSection[] = [
@@ -100,6 +102,12 @@ const BASE_SECTIONS: SettingsSection[] = [
     icon: <Container className="h-4 w-4" />,
     component: RuntimesSection,
   },
+  {
+    id: "sounds",
+    label: "Sounds",
+    icon: <Volume2 className="h-4 w-4" />,
+    component: SoundsSection,
+  },
   {
     id: "experiments",
     label: "Experiments",
diff --git a/src/browser/utils/audio/eventSounds.test.ts b/src/browser/utils/audio/eventSounds.test.ts
new file mode 100644
index 0000000000..6e9cfad1e3
--- /dev/null
+++ b/src/browser/utils/audio/eventSounds.test.ts
@@ -0,0 +1,136 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { GlobalWindow } from "happy-dom";
+
+import type { EventSoundSettings } from "@/common/config/schemas/appConfigOnDisk";
+
+import { playEventSound } from "./eventSounds";
+
+const AUTH_TOKEN_STORAGE_KEY = "mux:auth-token";
+
+let originalWindow: (Window & typeof globalThis) | undefined;
+let originalDocument: Document | undefined;
+let originalAudio: typeof Audio | undefined;
+let originalLocalStorage: Storage | undefined;
+let lastAudioSource: string | null = null;
+
+class MockAudio {
+  constructor(src?: string) {
+    lastAudioSource = src ?? null;
+  }
+
+  play(): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
+describe("eventSounds", () => {
+  beforeEach(() => {
+    originalWindow = globalThis.window;
+    originalDocument = globalThis.document;
+    originalAudio = globalThis.Audio;
+    originalLocalStorage = globalThis.localStorage;
+
+    globalThis.window = new GlobalWindow() as unknown as Window & typeof globalThis;
+    Object.defineProperty(globalThis.window, "api", {
+      value: undefined,
+      writable: true,
+      configurable: true,
+    });
+    globalThis.document = globalThis.window.document;
+    globalThis.Audio = MockAudio as unknown as typeof Audio;
+    globalThis.localStorage = globalThis.window.localStorage;
+
+    lastAudioSource = null;
+  });
+
+  afterEach(() => {
+    globalThis.window = originalWindow!;
+    globalThis.document = originalDocument!;
+    globalThis.Audio = originalAudio!;
+    globalThis.localStorage = originalLocalStorage!;
+  });
+
+  test("preserves app proxy base path and forwards URL token for playback", () => {
+    window.location.href = "https://coder.example.com/@u/ws/apps/mux/settings?token=url-token";
+
+    const settings: EventSoundSettings = {
+      agent_review_ready: {
+        enabled: true,
+        source: {
+          kind: "managed",
+          assetId: "11111111-1111-1111-1111-111111111111.wav",
+        },
+      },
+    };
+
+    playEventSound(settings, "agent_review_ready");
+
+    expect(lastAudioSource).toBe(
+      "https://coder.example.com/@u/ws/apps/mux/assets/event-sounds/11111111-1111-1111-1111-111111111111.wav?token=url-token"
+    );
+  });
+
+  test("uses stored auth token when URL token is absent", () => {
+    window.location.href = "https://coder.example.com/@u/ws/apps/mux/settings";
+    window.localStorage.setItem(AUTH_TOKEN_STORAGE_KEY, "stored-token");
+
+    const settings: EventSoundSettings = {
+      agent_review_ready: {
+        enabled: true,
+        source: {
+          kind: "managed",
+          assetId: "22222222-2222-2222-2222-222222222222.wav",
+        },
+      },
+    };
+
+    playEventSound(settings, "agent_review_ready");
+
+    expect(lastAudioSource).toBe(
+      "https://coder.example.com/@u/ws/apps/mux/assets/event-sounds/22222222-2222-2222-2222-222222222222.wav?token=stored-token"
+    );
+  });
+
+  test("uses API server status in desktop mode to build playback URL", async () => {
+    window.location.href = "file:///app/index.html";
+    Object.defineProperty(window, "api", {
+      value: {},
+      writable: true,
+      configurable: true,
+    });
+
+    const settings: EventSoundSettings = {
+      agent_review_ready: {
+        enabled: true,
+        source: {
+          kind: "managed",
+          assetId: "33333333-3333-3333-3333-333333333333.wav",
+        },
+      },
+    };
+
+    playEventSound(settings, "agent_review_ready", {
+      server: {
+        getApiServerStatus: () =>
+          Promise.resolve({
+            running: true,
+            baseUrl: "http://127.0.0.1:55525",
+            bindHost: "127.0.0.1",
+            port: 55525,
+            networkBaseUrls: [],
+            token: "desktop-token",
+            configuredBindHost: null,
+            configuredPort: null,
+            configuredServeWebUi: false,
+          }),
+      },
+    } as unknown as Parameters<typeof playEventSound>[2]);
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(lastAudioSource).toBe(
+      "http://127.0.0.1:55525/assets/event-sounds/33333333-3333-3333-3333-333333333333.wav?token=desktop-token"
+    );
+  });
+});
diff --git a/src/browser/utils/audio/eventSounds.ts b/src/browser/utils/audio/eventSounds.ts
new file mode 100644
index 0000000000..8c0634435e
--- /dev/null
+++ b/src/browser/utils/audio/eventSounds.ts
@@ -0,0 +1,90 @@
+import type { APIClient } from "@/browser/contexts/API";
+import { getStoredAuthToken } from "@/browser/components/AuthTokenModal/AuthTokenModal";
+import { getBrowserBackendBaseUrl } from "@/browser/utils/backendBaseUrl";
+import type { EventSoundSettings } from "@/common/config/schemas/appConfigOnDisk";
+import type { EventSoundKey } from "@/common/config/eventSoundTypes";
+
+function getServerAuthToken(): string | null {
+  const urlToken = new URLSearchParams(window.location.search).get("token")?.trim();
+  return urlToken?.length ? urlToken : getStoredAuthToken();
+}
+
+function toManagedPlaybackPath(baseUrl: string, assetId: string, authToken: string | null): string {
+  const playbackUrl = new URL(`assets/event-sounds/${encodeURIComponent(assetId)}`, `${baseUrl}/`);
+
+  // <audio> cannot attach Authorization headers, so pass the server token as
+  // a query param when token-auth is in use.
+  if (authToken) {
+    playbackUrl.searchParams.set("token", authToken);
+  }
+
+  return playbackUrl.toString();
+}
+
+function toBrowserManagedPlaybackPath(assetId: string): string {
+  // Browser mode can run behind a path-based app proxy (for example Coder),
+  // so resolve against the backend base URL instead of assuming "/".
+  return toManagedPlaybackPath(getBrowserBackendBaseUrl(), assetId, getServerAuthToken());
+}
+
+async function toDesktopManagedPlaybackPath(
+  assetId: string,
+  apiClient: APIClient | null | undefined
+): Promise<string | null> {
+  if (!apiClient?.server?.getApiServerStatus) {
+    return null;
+  }
+
+  try {
+    const apiServerStatus = await apiClient.server.getApiServerStatus();
+    if (!apiServerStatus.running || !apiServerStatus.baseUrl) {
+      return null;
+    }
+
+    return toManagedPlaybackPath(apiServerStatus.baseUrl, assetId, apiServerStatus.token);
+  } catch {
+    return null;
+  }
+}
+
+function playAudioFromPath(path: string, eventKey: EventSoundKey): void {
+  const audio = new Audio(path);
+  void audio.play().catch((error) => {
+    console.debug("Event sound playback failed", {
+      eventKey,
+      error: String(error),
+    });
+  });
+}
+
+/**
+ * Attempt to play the configured sound for the given event key.
+ * Fails silently with debug logging if no sound is configured or playback fails.
+ */
+export function playEventSound(
+  eventSoundSettings: EventSoundSettings | undefined,
+  eventKey: EventSoundKey,
+  apiClient?: APIClient | null
+): void {
+  if (!eventSoundSettings) {
+    return;
+  }
+
+  const config = eventSoundSettings[eventKey];
+  if (!config?.enabled || config.source?.kind !== "managed") {
+    return;
+  }
+
+  if (!window.api) {
+    playAudioFromPath(toBrowserManagedPlaybackPath(config.source.assetId), eventKey);
+    return;
+  }
+
+  void toDesktopManagedPlaybackPath(config.source.assetId, apiClient).then((playbackPath) => {
+    if (!playbackPath) {
+      return;
+    }
+
+    playAudioFromPath(playbackPath, eventKey);
+  });
+}
diff --git a/src/common/config/eventSoundTypes.ts b/src/common/config/eventSoundTypes.ts
new file mode 100644
index 0000000000..0aee00664c
--- /dev/null
+++ b/src/common/config/eventSoundTypes.ts
@@ -0,0 +1,35 @@
+// Event keys for the sound system — expand this union as new events are added.
+export const EVENT_SOUND_KEYS = ["agent_review_ready"] as const;
+export type EventSoundKey = (typeof EVENT_SOUND_KEYS)[number];
+
+// Human-readable labels for settings UI.
+export const EVENT_SOUND_LABELS: Record<EventSoundKey, string> = {
+  agent_review_ready: "Agent finished (waiting for review)",
+};
+
+export const ALLOWED_AUDIO_MIME_TYPES = [
+  "audio/mpeg",
+  "audio/mp3",
+  "audio/wav",
+  "audio/x-wav",
+  "audio/wave",
+  "audio/ogg",
+  "audio/mp4",
+  "audio/x-m4a",
+  "audio/aac",
+  "audio/flac",
+  "audio/x-flac",
+  "audio/webm",
+] as const;
+
+export const ALLOWED_AUDIO_EXTENSIONS = [
+  "mp3",
+  "wav",
+  "ogg",
+  "m4a",
+  "aac",
+  "flac",
+  "webm",
+] as const;
+
+export const MAX_AUDIO_FILE_SIZE_BYTES = 5 * 1024 * 1024;
diff --git a/src/common/config/schemas/appConfigOnDisk.test.ts b/src/common/config/schemas/appConfigOnDisk.test.ts
index 707585efd6..e3812144ed 100644
--- a/src/common/config/schemas/appConfigOnDisk.test.ts
+++ b/src/common/config/schemas/appConfigOnDisk.test.ts
@@ -62,6 +62,142 @@ describe("AppConfigOnDiskSchema", () => {
     ).toBe(true);
   });
 
+  it("accepts missing eventSoundSettings", () => {
+    const result = AppConfigOnDiskSchema.safeParse({});
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.eventSoundSettings).toBeUndefined();
+    }
+  });
+
+  it("parses valid eventSoundSettings and applies entry defaults", () => {
+    const result = AppConfigOnDiskSchema.safeParse({
+      eventSoundSettings: {
+        agent_review_ready: {
+          enabled: true,
+        },
+      },
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.eventSoundSettings).toEqual({
+        agent_review_ready: {
+          enabled: true,
+          source: null,
+        },
+      });
+    }
+  });
+
+  it("accepts managed event sound source labels", () => {
+    const result = AppConfigOnDiskSchema.safeParse({
+      eventSoundSettings: {
+        agent_review_ready: {
+          source: {
+            kind: "managed",
+            assetId: "11111111-1111-1111-1111-111111111111.wav",
+            label: "review-ready.wav",
+          },
+        },
+      },
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.eventSoundSettings).toEqual({
+        agent_review_ready: {
+          enabled: false,
+          source: {
+            kind: "managed",
+            assetId: "11111111-1111-1111-1111-111111111111.wav",
+            label: "review-ready.wav",
+          },
+        },
+      });
+    }
+  });
+
+  it("accepts managed event sound source without labels", () => {
+    const result = AppConfigOnDiskSchema.safeParse({
+      eventSoundSettings: {
+        agent_review_ready: {
+          source: {
+            kind: "managed",
+            assetId: "11111111-1111-1111-1111-111111111111.wav",
+          },
+        },
+      },
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.eventSoundSettings).toEqual({
+        agent_review_ready: {
+          enabled: false,
+          source: {
+            kind: "managed",
+            assetId: "11111111-1111-1111-1111-111111111111.wav",
+          },
+        },
+      });
+    }
+  });
+
+  it("preserves unknown eventSoundSettings keys", () => {
+    const result = AppConfigOnDiskSchema.safeParse({
+      eventSoundSettings: {
+        future_event: {
+          source: {
+            kind: "managed",
+            assetId: "11111111-1111-1111-1111-111111111111.wav",
+          },
+        },
+      },
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.eventSoundSettings).toEqual({
+        future_event: {
+          enabled: false,
+          source: {
+            kind: "managed",
+            assetId: "11111111-1111-1111-1111-111111111111.wav",
+          },
+        },
+      });
+    }
+  });
+
+  it("rejects legacy eventSoundSettings filePath entries", () => {
+    expect(
+      AppConfigOnDiskSchema.safeParse({
+        eventSoundSettings: {
+          agent_review_ready: {
+            filePath: "/tmp/legacy.wav",
+          },
+        },
+      }).success
+    ).toBe(false);
+  });
+
+  it("rejects unknown event sound source kinds", () => {
+    expect(
+      AppConfigOnDiskSchema.safeParse({
+        eventSoundSettings: {
+          agent_review_ready: {
+            source: {
+              kind: "external",
+              assetId: "anything",
+            },
+          },
+        },
+      }).success
+    ).toBe(false);
+  });
+
   it("preserves unknown fields via passthrough", () => {
     const valid = { futureField: "something" };
 
diff --git a/src/common/config/schemas/appConfigOnDisk.ts b/src/common/config/schemas/appConfigOnDisk.ts
index ed65a8208a..b1deedd05a 100644
--- a/src/common/config/schemas/appConfigOnDisk.ts
+++ b/src/common/config/schemas/appConfigOnDisk.ts
@@ -30,6 +30,23 @@ export const FeatureFlagOverrideSchema = z.enum(["default", "on", "off"]);
 
 export const UpdateChannelSchema = z.enum(["stable", "nightly"]);
 
+export const EventSoundSourceSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("managed"),
+    assetId: z.string().min(1),
+    label: z.string().optional(),
+  }),
+]);
+
+export const EventSoundConfigSchema = z
+  .object({
+    enabled: z.boolean().default(false),
+    source: EventSoundSourceSchema.nullable().default(null),
+  })
+  .strict();
+
+export const EventSoundSettingsSchema = z.record(z.string(), EventSoundConfigSchema).optional();
+
 export const AppConfigOnDiskSchema = z
   .object({
     projects: z.array(z.tuple([z.string(), ProjectConfigSchema])).optional(),
@@ -63,6 +80,7 @@ export const AppConfigOnDiskSchema = z
     updateChannel: UpdateChannelSchema.optional(),
     runtimeEnablement: RuntimeEnablementOverridesSchema.optional(),
     defaultRuntime: RuntimeEnablementIdSchema.optional(),
+    eventSoundSettings: EventSoundSettingsSchema,
     onePasswordAccountName: z.string().optional(),
   })
   .passthrough();
@@ -74,4 +92,8 @@ export type SubagentAiDefaults = z.infer<typeof SubagentAiDefaultsSchema>;
 export type FeatureFlagOverride = z.infer<typeof FeatureFlagOverrideSchema>;
 export type UpdateChannel = z.infer<typeof UpdateChannelSchema>;
 
+export type EventSoundConfig = z.infer<typeof EventSoundConfigSchema>;
+export type EventSoundSource = z.infer<typeof EventSoundSourceSchema>;
+export type EventSoundSettings = z.infer<typeof EventSoundSettingsSchema>;
+
 export type AppConfigOnDisk = z.infer<typeof AppConfigOnDiskSchema>;
diff --git a/src/common/constants/events.ts b/src/common/constants/events.ts
index b3a45790cb..ec6f4ae6c9 100644
--- a/src/common/constants/events.ts
+++ b/src/common/constants/events.ts
@@ -7,6 +7,7 @@
 
 import type { ThinkingLevel } from "@/common/types/thinking";
 import type { ReviewNoteDataForDisplay } from "@/common/types/message";
+import type { EventSoundSettings } from "@/common/config/schemas/appConfigOnDisk";
 import type { FilePart } from "@/common/orpc/schemas";
 
 export const CUSTOM_EVENTS = {
@@ -116,6 +117,11 @@ export const CUSTOM_EVENTS = {
    * Detail: { enabled: boolean }
    */
   LLM_DEBUG_LOGS_CHANGED: "mux:llmDebugLogsChanged",
+  /**
+   * Event emitted when event sound settings are edited in Settings.
+   * Detail: { eventSoundSettings: EventSoundSettings }
+   */
+  EVENT_SOUND_SETTINGS_CHANGED: "mux:eventSoundSettingsChanged",
 } as const;
 
 /**
@@ -175,6 +181,9 @@ export interface CustomEventPayloads {
   [CUSTOM_EVENTS.LLM_DEBUG_LOGS_CHANGED]: {
     enabled: boolean;
   };
+  [CUSTOM_EVENTS.EVENT_SOUND_SETTINGS_CHANGED]: {
+    eventSoundSettings: EventSoundSettings;
+  };
 }
 
 /**
diff --git a/src/common/orpc/schemas.ts b/src/common/orpc/schemas.ts
index 2c85108975..e4c9419bca 100644
--- a/src/common/orpc/schemas.ts
+++ b/src/common/orpc/schemas.ts
@@ -213,6 +213,7 @@ export {
   CoderWorkspaceStatusSchema,
   config,
   browserSession,
+  eventSounds,
   devtools,
   uiLayouts,
   debug,
diff --git a/src/common/orpc/schemas/api.ts b/src/common/orpc/schemas/api.ts
index 467ec62ff2..1df543c15d 100644
--- a/src/common/orpc/schemas/api.ts
+++ b/src/common/orpc/schemas/api.ts
@@ -73,6 +73,7 @@ import {
 import { PolicyGetResponseSchema } from "./policy";
 import {
   AgentAiDefaultsSchema,
+  EventSoundSettingsSchema,
   SubagentAiDefaultsSchema,
   UpdateChannelSchema,
 } from "../../config/schemas/appConfigOnDisk";
@@ -556,6 +557,10 @@ export const projects = {
     input: z.void(),
     output: z.string().nullable(),
   },
+  pickAudioFile: {
+    input: z.object({}),
+    output: z.object({ filePath: z.string().nullable() }),
+  },
   remove: {
     input: z.object({ projectPath: z.string(), force: z.boolean().nullish() }).passthrough(),
     output: ResultSchema(z.void(), ProjectRemoveErrorSchema),
@@ -1697,6 +1702,7 @@ export const config = {
       muxGovernorUrl: z.string().nullable(),
       muxGovernorEnrolled: z.boolean(),
       llmDebugLogs: z.boolean(),
+      eventSoundSettings: EventSoundSettingsSchema,
       onePasswordAccountName: z.string().nullish(),
     }),
   },
@@ -1775,12 +1781,61 @@ export const config = {
       .strict(),
     output: z.void(),
   },
+  updateEventSoundSettings: {
+    input: z
+      .object({
+        eventSoundSettings: EventSoundSettingsSchema,
+      })
+      .strict(),
+    output: z.void(),
+  },
   unenrollMuxGovernor: {
     input: z.void(),
     output: z.void(),
   },
 };
 
+const EventSoundAssetSchema = z.object({
+  assetId: z.string(),
+  originalName: z.string(),
+  mimeType: z.string(),
+  playbackPath: z.string(),
+  createdAt: z.string(),
+});
+
+export const eventSounds = {
+  uploadAsset: {
+    input: z
+      .object({
+        base64: z.string(),
+        originalName: z.string(),
+        mimeType: z.string(),
+      })
+      .strict(),
+    output: EventSoundAssetSchema,
+  },
+  importFromLocalPath: {
+    input: z
+      .object({
+        localPath: z.string(),
+      })
+      .strict(),
+    output: EventSoundAssetSchema,
+  },
+  deleteAsset: {
+    input: z
+      .object({
+        assetId: z.string(),
+      })
+      .strict(),
+    output: z.void(),
+  },
+  listAssets: {
+    input: z.void(),
+    output: z.array(EventSoundAssetSchema),
+  },
+};
+
 const DevToolsInputTokenBreakdownSchema = z.object({
   total: z.number(),
   noCache: z.number().optional(),
diff --git a/src/common/types/project.ts b/src/common/types/project.ts
index 81d608c9ea..a32b1d6beb 100644
--- a/src/common/types/project.ts
+++ b/src/common/types/project.ts
@@ -3,7 +3,11 @@
  * Kept lightweight for preload script usage.
  */
 
-import type { FeatureFlagOverride, UpdateChannel } from "@/common/config/schemas/appConfigOnDisk";
+import type {
+  EventSoundSettings,
+  FeatureFlagOverride,
+  UpdateChannel,
+} from "@/common/config/schemas/appConfigOnDisk";
 import type { z } from "zod";
 import type {
   ProjectConfigSchema,
@@ -138,6 +142,9 @@ export interface ProjectsConfig {
    */
   runtimeEnablement?: Partial<Record<RuntimeEnablementId, false>>;
 
+  /** Event sound settings keyed by sound event name. */
+  eventSoundSettings?: EventSoundSettings;
+
   /** Optional 1Password account name used for desktop SDK account selection. */
   onePasswordAccountName?: string;
 }
diff --git a/src/desktop/main.ts b/src/desktop/main.ts
index 4b85644aca..070ff6772a 100644
--- a/src/desktop/main.ts
+++ b/src/desktop/main.ts
@@ -813,6 +813,23 @@ async function loadServices(): Promise<void> {
     return res.canceled || res.filePaths.length === 0 ? null : res.filePaths[0];
   });
 
+  services.setProjectAudioFilePicker(async () => {
+    const win = BrowserWindow.getFocusedWindow();
+    if (!win) return null;
+
+    const res = await dialog.showOpenDialog(win, {
+      properties: ["openFile"],
+      filters: [
+        {
+          name: "Audio Files",
+          extensions: ["mp3", "wav", "ogg", "m4a", "aac", "flac", "webm"],
+        },
+      ],
+    });
+
+    return res.canceled || res.filePaths.length === 0 ? null : res.filePaths[0];
+  });
+
   services.setTerminalWindowManager(terminalWindowManager);
 
   loadTokenizerModules().catch((error) => {
diff --git a/src/node/config.test.ts b/src/node/config.test.ts
index 3a74224cd9..f21889ff8c 100644
--- a/src/node/config.test.ts
+++ b/src/node/config.test.ts
@@ -3,6 +3,7 @@ import * as os from "os";
 import * as path from "path";
 import { Config } from "./config";
 import { MULTI_PROJECT_CONFIG_KEY } from "@/common/constants/multiProject";
+import type { EventSoundSettings } from "@/common/config/schemas/appConfigOnDisk";
 import { type ExternalSecretResolver, secretsToRecord } from "@/common/types/secrets";
 
 describe("Config", () => {
@@ -182,6 +183,80 @@ describe("Config", () => {
     });
   });
 
+  describe("event sound settings", () => {
+    it("loads eventSoundSettings and applies schema defaults", () => {
+      const configFile = path.join(tempDir, "config.json");
+      fs.writeFileSync(
+        configFile,
+        JSON.stringify({
+          projects: [],
+          eventSoundSettings: {
+            agent_review_ready: {
+              enabled: true,
+              source: {
+                kind: "managed",
+                assetId: "11111111-1111-1111-1111-111111111111.wav",
+              },
+            },
+            future_event: {
+              source: {
+                kind: "managed",
+                assetId: "22222222-2222-2222-2222-222222222222.wav",
+              },
+            },
+          },
+        })
+      );
+
+      const loaded = config.loadConfigOrDefault();
+      expect(loaded.eventSoundSettings).toEqual({
+        agent_review_ready: {
+          enabled: true,
+          source: {
+            kind: "managed",
+            assetId: "11111111-1111-1111-1111-111111111111.wav",
+          },
+        },
+        future_event: {
+          enabled: false,
+          source: {
+            kind: "managed",
+            assetId: "22222222-2222-2222-2222-222222222222.wav",
+          },
+        },
+      });
+    });
+
+    it("round-trips eventSoundSettings through editConfig", async () => {
+      const eventSoundSettings: EventSoundSettings = {
+        agent_review_ready: {
+          enabled: true,
+          source: {
+            kind: "managed",
+            assetId: "11111111-1111-1111-1111-111111111111.wav",
+          },
+        },
+        future_event: {
+          enabled: false,
+          source: null,
+        },
+      };
+
+      await config.editConfig((cfg) => {
+        cfg.eventSoundSettings = eventSoundSettings;
+        return cfg;
+      });
+
+      const reloaded = config.loadConfigOrDefault();
+      expect(reloaded.eventSoundSettings).toEqual(eventSoundSettings);
+
+      const raw = JSON.parse(fs.readFileSync(path.join(tempDir, "config.json"), "utf-8")) as {
+        eventSoundSettings?: unknown;
+      };
+      expect(raw.eventSoundSettings).toEqual(eventSoundSettings);
+    });
+  });
+
   describe("model preferences", () => {
     it("should preserve explicit gateway-scoped defaultModel and hiddenModels", async () => {
       await config.editConfig((cfg) => {
diff --git a/src/node/config.ts b/src/node/config.ts
index f2b4b6ebea..298b4d17a1 100644
--- a/src/node/config.ts
+++ b/src/node/config.ts
@@ -19,10 +19,11 @@ import type {
   FeatureFlagOverride,
   UpdateChannel,
 } from "@/common/types/project";
-import type {
-  AppConfigOnDisk,
-  BaseProviderConfig as ProviderConfig,
-  ProvidersConfig as CanonicalProvidersConfig,
+import {
+  EventSoundSettingsSchema,
+  type AppConfigOnDisk,
+  type BaseProviderConfig as ProviderConfig,
+  type ProvidersConfig as CanonicalProvidersConfig,
 } from "@/common/config/schemas";
 import {
   DEFAULT_TASK_SETTINGS,
@@ -142,6 +143,11 @@ function areStringArraysEqual(a: string[], b: string[]): boolean {
   return true;
 }
 
+function parseEventSoundSettings(value: unknown): AppConfigOnDisk["eventSoundSettings"] {
+  const result = EventSoundSettingsSchema.safeParse(value);
+  return result.success ? result.data : undefined;
+}
+
 function normalizeOptionalModelString(value: unknown): string | undefined {
   if (typeof value !== "string") {
     return undefined;
@@ -584,6 +590,8 @@ export class Config {
           ? undefined
           : layoutPresetsRaw;
 
+        const eventSoundSettings = parseEventSoundSettings(parsed.eventSoundSettings);
+
         return {
           projects: projectsMap,
           apiServerBindHost: parseOptionalNonEmptyString(parsed.apiServerBindHost),
@@ -616,6 +624,7 @@ export class Config {
           updateChannel,
           defaultRuntime,
           runtimeEnablement,
+          eventSoundSettings,
           onePasswordAccountName: parseOptionalNonEmptyString(parsed.onePasswordAccountName),
         };
       }
@@ -790,6 +799,11 @@ export class Config {
         data.defaultRuntime = defaultRuntime;
       }
 
+      const eventSoundSettings = parseEventSoundSettings(config.eventSoundSettings);
+      if (eventSoundSettings !== undefined) {
+        data.eventSoundSettings = eventSoundSettings;
+      }
+
       const onePasswordAccountName = parseOptionalNonEmptyString(config.onePasswordAccountName);
       if (onePasswordAccountName) {
         data.onePasswordAccountName = onePasswordAccountName;
diff --git a/src/node/orpc/context.ts b/src/node/orpc/context.ts
index c0b6a95039..3eb8843bcd 100644
--- a/src/node/orpc/context.ts
+++ b/src/node/orpc/context.ts
@@ -37,6 +37,7 @@ import type { AnalyticsService } from "@/node/services/analytics/analyticsServic
 import type { DesktopBridgeServer } from "@/node/services/desktop/DesktopBridgeServer";
 import type { DesktopSessionManager } from "@/node/services/desktop/DesktopSessionManager";
 import type { DesktopTokenManager } from "@/node/services/desktop/DesktopTokenManager";
+import type { EventSoundAssetService } from "@/node/services/eventSoundAssetService";
 
 export interface ORPCContext {
   config: Config;
@@ -77,5 +78,6 @@ export interface ORPCContext {
   desktopSessionManager: DesktopSessionManager;
   desktopTokenManager: DesktopTokenManager;
   desktopBridgeServer: DesktopBridgeServer;
+  eventSoundAssetService: EventSoundAssetService;
   headers?: IncomingHttpHeaders;
 }
diff --git a/src/node/orpc/router.ts b/src/node/orpc/router.ts
index 2e006f1f54..b5708d8ec3 100644
--- a/src/node/orpc/router.ts
+++ b/src/node/orpc/router.ts
@@ -596,6 +596,7 @@ export const router = (authToken?: string) => {
             muxGovernorUrl,
             muxGovernorEnrolled,
             llmDebugLogs: config.llmDebugLogs === true,
+            eventSoundSettings: config.eventSoundSettings,
             onePasswordAccountName: config.onePasswordAccountName ?? null,
           };
         }),
@@ -964,6 +965,23 @@ export const router = (authToken?: string) => {
             return config;
           });
         }),
+      updateEventSoundSettings: t
+        .input(schemas.config.updateEventSoundSettings.input)
+        .output(schemas.config.updateEventSoundSettings.output)
+        .handler(async ({ context, input }) => {
+          await context.config.editConfig((config) => {
+            const nextSettings = input.eventSoundSettings;
+            if (!nextSettings || Object.keys(nextSettings).length === 0) {
+              const { eventSoundSettings: _eventSoundSettings, ...rest } = config;
+              return rest;
+            }
+
+            return {
+              ...config,
+              eventSoundSettings: nextSettings,
+            };
+          });
+        }),
       unenrollMuxGovernor: t
         .input(schemas.config.unenrollMuxGovernor.input)
         .output(schemas.config.unenrollMuxGovernor.output)
@@ -976,6 +994,32 @@ export const router = (authToken?: string) => {
           await context.policyService.refreshNow();
         }),
     },
+    eventSounds: {
+      uploadAsset: t
+        .input(schemas.eventSounds.uploadAsset.input)
+        .output(schemas.eventSounds.uploadAsset.output)
+        .handler(async ({ context, input }) => {
+          return context.eventSoundAssetService.uploadFromData(input);
+        }),
+      importFromLocalPath: t
+        .input(schemas.eventSounds.importFromLocalPath.input)
+        .output(schemas.eventSounds.importFromLocalPath.output)
+        .handler(async ({ context, input }) => {
+          return context.eventSoundAssetService.importFromLocalPath(input.localPath);
+        }),
+      deleteAsset: t
+        .input(schemas.eventSounds.deleteAsset.input)
+        .output(schemas.eventSounds.deleteAsset.output)
+        .handler(async ({ context, input }) => {
+          await context.eventSoundAssetService.deleteAsset(input.assetId);
+        }),
+      listAssets: t
+        .input(schemas.eventSounds.listAssets.input)
+        .output(schemas.eventSounds.listAssets.output)
+        .handler(async ({ context }) => {
+          return context.eventSoundAssetService.listAssets();
+        }),
+    },
     devtools: {
       getRuns: t
         .input(schemas.devtools.getRuns.input)
@@ -2382,6 +2426,13 @@ export const router = (authToken?: string) => {
         .handler(async ({ context }) => {
           return context.projectService.pickDirectory();
         }),
+      pickAudioFile: t
+        .input(schemas.projects.pickAudioFile.input)
+        .output(schemas.projects.pickAudioFile.output)
+        .handler(async ({ context }) => {
+          const filePath = await context.projectService.pickAudioFile();
+          return { filePath };
+        }),
       getFileCompletions: t
         .input(schemas.projects.getFileCompletions.input)
         .output(schemas.projects.getFileCompletions.output)
diff --git a/src/node/orpc/server.test.ts b/src/node/orpc/server.test.ts
index 66c8accfff..fb756070a4 100644
--- a/src/node/orpc/server.test.ts
+++ b/src/node/orpc/server.test.ts
@@ -328,6 +328,67 @@ describe("createOrpcServer", () => {
     }
   });
 
+  test("serves managed event sound assets by validated asset id", async () => {
+    const servedAssetId = "11111111-1111-1111-1111-111111111111.wav";
+    const missingAssetId = "22222222-2222-2222-2222-222222222222.wav";
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "mux-event-sound-route-"));
+    const assetPath = path.join(tempDir, servedAssetId);
+    const assetBody = "event-sound-payload";
+
+    await fs.writeFile(assetPath, assetBody, "utf-8");
+
+    const stubContext: Partial<ORPCContext> = {
+      eventSoundAssetService: {
+        getAssetFilePath: (assetId: string) => {
+          if (assetId === servedAssetId) {
+            return Promise.resolve(assetPath);
+          }
+
+          if (assetId === missingAssetId) {
+            return Promise.resolve(null);
+          }
+
+          return Promise.resolve(null);
+        },
+      } as unknown as ORPCContext["eventSoundAssetService"],
+    };
+
+    let server: Awaited<ReturnType<typeof createOrpcServer>> | null = null;
+
+    try {
+      server = await createOrpcServer({
+        host: "127.0.0.1",
+        port: 0,
+        context: stubContext as ORPCContext,
+        authToken: "test-token",
+      });
+
+      const unauthenticatedResponse = await fetch(
+        `${server.baseUrl}/assets/event-sounds/${servedAssetId}`
+      );
+      expect(unauthenticatedResponse.status).toBe(401);
+
+      const invalidIdResponse = await fetch(
+        `${server.baseUrl}/assets/event-sounds/not-a-valid-id?token=test-token`
+      );
+      expect(invalidIdResponse.status).toBe(400);
+
+      const missingAssetResponse = await fetch(
+        `${server.baseUrl}/assets/event-sounds/${missingAssetId}?token=test-token`
+      );
+      expect(missingAssetResponse.status).toBe(404);
+
+      const servedAssetResponse = await fetch(
+        `${server.baseUrl}/assets/event-sounds/${servedAssetId}?token=test-token`
+      );
+      expect(servedAssetResponse.status).toBe(200);
+      expect(await servedAssetResponse.text()).toBe(assetBody);
+    } finally {
+      await server?.close();
+      await fs.rm(tempDir, { recursive: true, force: true });
+    }
+  });
+
   test("reports whether GitHub device-flow login is enabled", async () => {
     async function runCase(enabled: boolean): Promise<void> {
       const stubContext: Partial<ORPCContext> = {
diff --git a/src/node/orpc/server.ts b/src/node/orpc/server.ts
index e7bc8e1e4f..b508a404ca 100644
--- a/src/node/orpc/server.ts
+++ b/src/node/orpc/server.ts
@@ -34,6 +34,8 @@ type AliveWebSocket = WebSocket & { isAlive?: boolean };
 
 const WS_HEARTBEAT_INTERVAL_MS = 30_000;
 
+const EVENT_SOUND_ASSET_ID_PATTERN = /^[0-9a-f-]{36}\.[a-z0-9]+$/i;
+
 // --- Types ---
 
 export interface OrpcServerOptions {
@@ -703,6 +705,16 @@ export async function createOrpcServer({
       return true;
     }
 
+    // Media elements (like <audio>) cannot attach Authorization headers,
+    // so accept token query params for authenticated event-sound asset playback only.
+    if (req.path.startsWith("/assets/event-sounds/")) {
+      const queryTokenValue = req.query.token;
+      const queryToken = Array.isArray(queryTokenValue) ? queryTokenValue[0] : queryTokenValue;
+      if (typeof queryToken === "string" && safeEq(queryToken.trim(), expectedToken)) {
+        return true;
+      }
+    }
+
     const sessionTokens = extractCookieValues(req.headers.cookie, SERVER_AUTH_SESSION_COOKIE_NAME);
     if (sessionTokens.length === 0) {
       return false;
@@ -1238,6 +1250,27 @@ export async function createOrpcServer({
     res.send(html);
   });
 
+  app.get("/assets/event-sounds/:assetId", async (req, res) => {
+    if (!(await isHttpRequestAuthenticated(req))) {
+      res.status(401).json({ error: "Invalid or missing auth token/session" });
+      return;
+    }
+
+    const assetId = req.params.assetId;
+    if (!assetId || !EVENT_SOUND_ASSET_ID_PATTERN.test(assetId)) {
+      res.status(400).json({ error: "Invalid asset id" });
+      return;
+    }
+
+    const filePath = await context.eventSoundAssetService.getAssetFilePath(assetId);
+    if (!filePath) {
+      res.status(404).json({ error: "Asset not found" });
+      return;
+    }
+
+    res.sendFile(filePath);
+  });
+
   const orpcRouter = existingRouter ?? router(authToken);
 
   // OpenAPI generator for spec endpoint
diff --git a/src/node/services/eventSoundAssetService.test.ts b/src/node/services/eventSoundAssetService.test.ts
new file mode 100644
index 0000000000..34b02fa8be
--- /dev/null
+++ b/src/node/services/eventSoundAssetService.test.ts
@@ -0,0 +1,252 @@
+import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test";
+import * as fsPromises from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { MAX_AUDIO_FILE_SIZE_BYTES } from "@/common/config/eventSoundTypes";
+
+import { EventSoundAssetService } from "./eventSoundAssetService";
+
+const KNOWN_MISSING_ASSET_ID = "00000000-0000-0000-0000-000000000000.wav";
+
+async function sleep(ms: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function expectRejects(promise: Promise<unknown>, message: string): Promise<void> {
+  let caught: unknown;
+
+  try {
+    await promise;
+  } catch (error) {
+    caught = error;
+  }
+
+  expect(caught).toBeDefined();
+  expect(caught).toBeInstanceOf(Error);
+  expect((caught as Error).message).toContain(message);
+}
+
+describe("EventSoundAssetService", () => {
+  let tempMuxHome: string;
+  let service: EventSoundAssetService;
+
+  beforeEach(async () => {
+    tempMuxHome = await fsPromises.mkdtemp(path.join(os.tmpdir(), "mux-event-sound-assets-"));
+    service = new EventSoundAssetService(tempMuxHome);
+  });
+
+  afterEach(async () => {
+    await fsPromises.rm(tempMuxHome, { recursive: true, force: true });
+  });
+
+  it("imports an audio file from local path", async () => {
+    const sourcePath = path.join(tempMuxHome, "source.wav");
+    const sourceBytes = Buffer.from([0, 1, 2, 3, 4, 5]);
+    await fsPromises.writeFile(sourcePath, sourceBytes);
+
+    const imported = await service.importFromLocalPath(sourcePath);
+
+    expect(imported.assetId).toMatch(/^[0-9a-f-]{36}\.wav$/i);
+    expect(imported.originalName).toBe("source.wav");
+    expect(imported.mimeType).toBe("audio/wav");
+    expect(imported.playbackPath).toBe(`/assets/event-sounds/${imported.assetId}`);
+
+    const storedPath = await service.getAssetFilePath(imported.assetId);
+    expect(storedPath).not.toBeNull();
+
+    const storedBytes = await fsPromises.readFile(storedPath!);
+    expect(Buffer.compare(storedBytes, sourceBytes)).toBe(0);
+  });
+
+  it("rejects local imports larger than the max size", async () => {
+    const sourcePath = path.join(tempMuxHome, "oversize.wav");
+    await fsPromises.writeFile(sourcePath, Buffer.alloc(MAX_AUDIO_FILE_SIZE_BYTES + 1, 1));
+
+    await expectRejects(
+      service.importFromLocalPath(sourcePath),
+      "Audio file exceeds maximum allowed size"
+    );
+  });
+
+  it("checks file size metadata before reading oversized local imports", async () => {
+    const sourcePath = path.join(tempMuxHome, "oversize-by-metadata.wav");
+    await fsPromises.writeFile(sourcePath, "");
+    await fsPromises.truncate(sourcePath, MAX_AUDIO_FILE_SIZE_BYTES + 1);
+
+    const readFileSpy = spyOn(fsPromises, "readFile");
+    try {
+      await expectRejects(
+        service.importFromLocalPath(sourcePath),
+        "Audio file exceeds maximum allowed size"
+      );
+      expect(readFileSpy).not.toHaveBeenCalled();
+    } finally {
+      readFileSpy.mockRestore();
+    }
+  });
+
+  it("rejects local imports with unsupported extensions", async () => {
+    const sourcePath = path.join(tempMuxHome, "not-audio.txt");
+    await fsPromises.writeFile(sourcePath, "not audio");
+
+    await expectRejects(
+      service.importFromLocalPath(sourcePath),
+      "Unsupported audio file extension"
+    );
+  });
+
+  it("uploads an audio asset from base64 data", async () => {
+    const sourceBytes = Buffer.from("mux-event-sound");
+
+    const uploaded = await service.uploadFromData({
+      base64: sourceBytes.toString("base64"),
+      originalName: "upload.mp3",
+      mimeType: "audio/mpeg",
+    });
+
+    expect(uploaded.assetId).toMatch(/^[0-9a-f-]{36}\.mp3$/i);
+    expect(uploaded.mimeType).toBe("audio/mpeg");
+
+    const storedPath = await service.getAssetFilePath(uploaded.assetId);
+    expect(storedPath).not.toBeNull();
+
+    const storedBytes = await fsPromises.readFile(storedPath!);
+    expect(Buffer.compare(storedBytes, sourceBytes)).toBe(0);
+  });
+  it("accepts uploads with empty MIME type when the extension is allowed", async () => {
+    const sourceBytes = Buffer.from("mux-event-sound-empty-mime");
+
+    const uploaded = await service.uploadFromData({
+      base64: sourceBytes.toString("base64"),
+      originalName: "upload.wav",
+      mimeType: "",
+    });
+
+    expect(uploaded.assetId).toMatch(/^[0-9a-f-]{36}\.wav$/i);
+    expect(uploaded.mimeType).toBe("audio/wav");
+
+    const storedPath = await service.getAssetFilePath(uploaded.assetId);
+    expect(storedPath).not.toBeNull();
+
+    const storedBytes = await fsPromises.readFile(storedPath!);
+    expect(Buffer.compare(storedBytes, sourceBytes)).toBe(0);
+  });
+
+  it("rejects uploaded payloads larger than the max size", async () => {
+    const oversizedPayload = Buffer.alloc(MAX_AUDIO_FILE_SIZE_BYTES + 1, 2).toString("base64");
+
+    await expectRejects(
+      service.uploadFromData({
+        base64: oversizedPayload,
+        originalName: "oversize.wav",
+        mimeType: "audio/wav",
+      }),
+      "Audio file exceeds maximum allowed size"
+    );
+  });
+
+  it("deletes stored assets from disk and index", async () => {
+    const uploaded = await service.uploadFromData({
+      base64: Buffer.from("to-delete").toString("base64"),
+      originalName: "delete.wav",
+      mimeType: "audio/wav",
+    });
+
+    const filePath = await service.getAssetFilePath(uploaded.assetId);
+    expect(filePath).not.toBeNull();
+
+    await service.deleteAsset(uploaded.assetId);
+
+    expect(await service.getAssetFilePath(uploaded.assetId)).toBeNull();
+    expect(await service.listAssets()).toEqual([]);
+  });
+
+  it("removes tampered index entries without deleting files outside the asset directory", async () => {
+    const tamperedAssetId = "11111111-1111-1111-1111-111111111111.wav";
+    const outsidePath = path.join(tempMuxHome, "outside.txt");
+    await fsPromises.writeFile(outsidePath, "must-survive");
+
+    const assetsDirPath = path.join(tempMuxHome, "assets", "event-sounds");
+    const indexPath = path.join(assetsDirPath, "index.json");
+    await fsPromises.mkdir(assetsDirPath, { recursive: true });
+
+    await fsPromises.writeFile(
+      indexPath,
+      JSON.stringify(
+        {
+          version: 1,
+          assets: {
+            [tamperedAssetId]: {
+              assetId: tamperedAssetId,
+              fileName: "../../outside.txt",
+              originalName: "tampered.wav",
+              mimeType: "audio/wav",
+              sizeBytes: 1,
+              createdAt: new Date().toISOString(),
+            },
+          },
+        },
+        null,
+        2
+      ),
+      "utf-8"
+    );
+
+    await service.deleteAsset(tamperedAssetId);
+
+    expect(await fsPromises.readFile(outsidePath, "utf-8")).toBe("must-survive");
+    expect(await service.listAssets()).toEqual([]);
+  });
+
+  it("treats deleteAsset for unknown ids as a no-op", async () => {
+    await service.deleteAsset(KNOWN_MISSING_ASSET_ID);
+  });
+
+  it("lists assets in newest-first order", async () => {
+    const first = await service.uploadFromData({
+      base64: Buffer.from("first").toString("base64"),
+      originalName: "first.wav",
+      mimeType: "audio/wav",
+    });
+
+    await sleep(2);
+
+    const second = await service.uploadFromData({
+      base64: Buffer.from("second").toString("base64"),
+      originalName: "second.wav",
+      mimeType: "audio/wav",
+    });
+
+    const listed = await service.listAssets();
+    expect(listed).toHaveLength(2);
+    expect(listed[0]?.assetId).toBe(second.assetId);
+    expect(listed[1]?.assetId).toBe(first.assetId);
+  });
+
+  it("returns file paths for known assets and null for unknown assets", async () => {
+    const uploaded = await service.uploadFromData({
+      base64: Buffer.from("path-check").toString("base64"),
+      originalName: "path-check.wav",
+      mimeType: "audio/wav",
+    });
+
+    expect(await service.getAssetFilePath(uploaded.assetId)).not.toBeNull();
+    expect(await service.getAssetFilePath(KNOWN_MISSING_ASSET_ID)).toBeNull();
+  });
+
+  it("persists the asset index across service re-instantiation", async () => {
+    const uploaded = await service.uploadFromData({
+      base64: Buffer.from("persisted").toString("base64"),
+      originalName: "persisted.wav",
+      mimeType: "audio/wav",
+    });
+
+    const reloadedService = new EventSoundAssetService(tempMuxHome);
+    const listed = await reloadedService.listAssets();
+
+    expect(listed).toHaveLength(1);
+    expect(listed[0]?.assetId).toBe(uploaded.assetId);
+    expect(await reloadedService.getAssetFilePath(uploaded.assetId)).not.toBeNull();
+  });
+});
diff --git a/src/node/services/eventSoundAssetService.ts b/src/node/services/eventSoundAssetService.ts
new file mode 100644
index 0000000000..8f275e7789
--- /dev/null
+++ b/src/node/services/eventSoundAssetService.ts
@@ -0,0 +1,434 @@
+import * as crypto from "node:crypto";
+import * as fsPromises from "node:fs/promises";
+import * as path from "node:path";
+
+import writeFileAtomic from "write-file-atomic";
+
+import {
+  ALLOWED_AUDIO_EXTENSIONS,
+  ALLOWED_AUDIO_MIME_TYPES,
+  MAX_AUDIO_FILE_SIZE_BYTES,
+} from "@/common/config/eventSoundTypes";
+import { log } from "@/node/services/log";
+
+type AllowedAudioExtension = (typeof ALLOWED_AUDIO_EXTENSIONS)[number];
+type AllowedAudioMimeType = (typeof ALLOWED_AUDIO_MIME_TYPES)[number];
+
+const EVENT_SOUND_ASSET_INDEX_VERSION = 1 as const;
+const EVENT_SOUND_ASSET_ROUTE_PREFIX = "/assets/event-sounds";
+
+const EXTENSION_TO_MIME: Record<AllowedAudioExtension, AllowedAudioMimeType> = {
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  flac: "audio/flac",
+  webm: "audio/webm",
+};
+
+const MIME_TO_EXTENSION: Record<AllowedAudioMimeType, AllowedAudioExtension> = {
+  "audio/mpeg": "mp3",
+  "audio/mp3": "mp3",
+  "audio/wav": "wav",
+  "audio/x-wav": "wav",
+  "audio/wave": "wav",
+  "audio/ogg": "ogg",
+  "audio/mp4": "m4a",
+  "audio/x-m4a": "m4a",
+  "audio/aac": "aac",
+  "audio/flac": "flac",
+  "audio/x-flac": "flac",
+  "audio/webm": "webm",
+};
+
+const EVENT_SOUND_ASSET_ID_PATTERN = /^[0-9a-f-]{36}\.[a-z0-9]+$/i;
+
+export interface EventSoundAssetIndexEntry {
+  assetId: string;
+  fileName: string;
+  originalName: string;
+  mimeType: AllowedAudioMimeType;
+  sizeBytes: number;
+  createdAt: string;
+}
+
+interface EventSoundAssetIndexFile {
+  version: typeof EVENT_SOUND_ASSET_INDEX_VERSION;
+  assets: Record<string, EventSoundAssetIndexEntry>;
+}
+
+export interface UploadEventSoundAssetInput {
+  base64: string;
+  originalName: string;
+  mimeType: string;
+}
+
+export interface EventSoundAsset {
+  assetId: string;
+  originalName: string;
+  mimeType: string;
+  playbackPath: string;
+  createdAt: string;
+}
+
+export class EventSoundAssetService {
+  private readonly assetsDirPath: string;
+  private readonly indexFilePath: string;
+  private mutationQueue: Promise<void> = Promise.resolve();
+
+  constructor(muxHome: string) {
+    this.assetsDirPath = path.join(muxHome, "assets", "event-sounds");
+    this.indexFilePath = path.join(this.assetsDirPath, "index.json");
+  }
+
+  private async withSerializedMutation<T>(fn: () => Promise<T>): Promise<T> {
+    let result!: T;
+    const run = async () => {
+      result = await fn();
+    };
+
+    const next = this.mutationQueue.catch(() => undefined).then(run);
+    this.mutationQueue = next;
+    await next;
+    return result;
+  }
+
+  private async ensureStorageDir(): Promise<void> {
+    await fsPromises.mkdir(this.assetsDirPath, { recursive: true });
+  }
+
+  private normalizeMimeType(mimeType: string): AllowedAudioMimeType | null {
+    const normalized = mimeType.trim().toLowerCase();
+    return (ALLOWED_AUDIO_MIME_TYPES as readonly string[]).includes(normalized)
+      ? (normalized as AllowedAudioMimeType)
+      : null;
+  }
+
+  private normalizeExtension(value: string): AllowedAudioExtension | null {
+    const normalized = value.trim().toLowerCase().replace(/^\./, "");
+    return (ALLOWED_AUDIO_EXTENSIONS as readonly string[]).includes(normalized)
+      ? (normalized as AllowedAudioExtension)
+      : null;
+  }
+
+  private getExtensionFromOriginalName(originalName: string): AllowedAudioExtension | null {
+    return this.normalizeExtension(path.extname(originalName));
+  }
+
+  private validateSize(sizeBytes: number): void {
+    if (sizeBytes > MAX_AUDIO_FILE_SIZE_BYTES) {
+      throw new Error(
+        `Audio file exceeds maximum allowed size of ${MAX_AUDIO_FILE_SIZE_BYTES} bytes`
+      );
+    }
+  }
+
+  private decodeBase64Payload(base64: string): Buffer {
+    const normalized = base64.trim().replace(/\s+/g, "");
+    if (!normalized || normalized.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(normalized)) {
+      throw new Error("Invalid base64 payload");
+    }
+
+    const bytes = Buffer.from(normalized, "base64");
+    if (bytes.length === 0) {
+      throw new Error("Invalid base64 payload");
+    }
+
+    const normalizedNoPadding = normalized.replace(/=+$/, "");
+    const reencodedNoPadding = bytes.toString("base64").replace(/=+$/, "");
+    if (normalizedNoPadding !== reencodedNoPadding) {
+      throw new Error("Invalid base64 payload");
+    }
+
+    return bytes;
+  }
+
+  private async readIndex(): Promise<Record<string, EventSoundAssetIndexEntry>> {
+    try {
+      const raw = await fsPromises.readFile(this.indexFilePath, "utf-8");
+      const parsed = JSON.parse(raw) as unknown;
+
+      if (!parsed || typeof parsed !== "object") {
+        return {};
+      }
+
+      const index = parsed as { version?: unknown; assets?: unknown };
+      if (index.version !== EVENT_SOUND_ASSET_INDEX_VERSION) {
+        return {};
+      }
+
+      if (!index.assets || typeof index.assets !== "object") {
+        return {};
+      }
+
+      const assets: Record<string, EventSoundAssetIndexEntry> = {};
+      for (const [assetId, entry] of Object.entries(index.assets as Record<string, unknown>)) {
+        if (!EVENT_SOUND_ASSET_ID_PATTERN.test(assetId)) {
+          continue;
+        }
+
+        if (!entry || typeof entry !== "object") {
+          continue;
+        }
+
+        const record = entry as Partial<EventSoundAssetIndexEntry>;
+        if (
+          typeof record.fileName !== "string" ||
+          typeof record.originalName !== "string" ||
+          typeof record.mimeType !== "string" ||
+          typeof record.sizeBytes !== "number" ||
+          typeof record.createdAt !== "string"
+        ) {
+          continue;
+        }
+
+        const normalizedMimeType = this.normalizeMimeType(record.mimeType);
+        if (!normalizedMimeType) {
+          continue;
+        }
+
+        assets[assetId] = {
+          assetId,
+          fileName: record.fileName,
+          originalName: record.originalName,
+          mimeType: normalizedMimeType,
+          sizeBytes: record.sizeBytes,
+          createdAt: record.createdAt,
+        };
+      }
+
+      return assets;
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        return {};
+      }
+
+      log.warn("Failed to read event sound asset index; returning empty index", { error });
+      return {};
+    }
+  }
+
+  private async writeIndex(index: Record<string, EventSoundAssetIndexEntry>): Promise<void> {
+    await this.ensureStorageDir();
+
+    const payload: EventSoundAssetIndexFile = {
+      version: EVENT_SOUND_ASSET_INDEX_VERSION,
+      assets: index,
+    };
+
+    await writeFileAtomic(this.indexFilePath, `${JSON.stringify(payload, null, 2)}\n`, "utf-8");
+  }
+
+  private async writeAssetFile(filePath: string, bytes: Buffer): Promise<void> {
+    await this.ensureStorageDir();
+
+    const tempPath = path.join(
+      this.assetsDirPath,
+      `.${path.basename(filePath)}.${crypto.randomUUID()}.tmp`
+    );
+
+    await fsPromises.writeFile(tempPath, bytes);
+
+    try {
+      await fsPromises.rename(tempPath, filePath);
+    } catch (error) {
+      await fsPromises.rm(tempPath, { force: true }).catch(() => undefined);
+      throw error;
+    }
+  }
+
+  private buildAssetId(
+    extension: AllowedAudioExtension,
+    index: Record<string, EventSoundAssetIndexEntry>
+  ): string {
+    for (;;) {
+      const assetId = `${crypto.randomUUID()}.${extension}`;
+      if (!(assetId in index)) {
+        return assetId;
+      }
+    }
+  }
+
+  private toAsset(entry: EventSoundAssetIndexEntry): EventSoundAsset {
+    return {
+      assetId: entry.assetId,
+      originalName: entry.originalName,
+      mimeType: entry.mimeType,
+      createdAt: entry.createdAt,
+      playbackPath: this.getAssetPlaybackPath(entry.assetId),
+    };
+  }
+
+  private assertAssetIdFormat(assetId: string): void {
+    if (!EVENT_SOUND_ASSET_ID_PATTERN.test(assetId)) {
+      throw new Error("Invalid asset id");
+    }
+  }
+
+  private resolveIndexedAssetFilePath(fileName: string): string | null {
+    if (!EVENT_SOUND_ASSET_ID_PATTERN.test(fileName)) {
+      return null;
+    }
+
+    const filePath = path.resolve(this.assetsDirPath, fileName);
+    const relative = path.relative(this.assetsDirPath, filePath);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+      return null;
+    }
+
+    return filePath;
+  }
+
+  private async storeAsset(params: {
+    bytes: Buffer;
+    originalName: string;
+    mimeType: AllowedAudioMimeType;
+    extension: AllowedAudioExtension;
+  }): Promise<EventSoundAsset> {
+    const assets = await this.readIndex();
+    const assetId = this.buildAssetId(params.extension, assets);
+    const fileName = assetId;
+    const filePath = path.join(this.assetsDirPath, fileName);
+
+    await this.writeAssetFile(filePath, params.bytes);
+
+    const entry: EventSoundAssetIndexEntry = {
+      assetId,
+      fileName,
+      originalName: params.originalName,
+      mimeType: params.mimeType,
+      sizeBytes: params.bytes.byteLength,
+      createdAt: new Date().toISOString(),
+    };
+
+    assets[assetId] = entry;
+
+    try {
+      await this.writeIndex(assets);
+    } catch (error) {
+      await fsPromises.rm(filePath, { force: true }).catch(() => undefined);
+      throw error;
+    }
+
+    return this.toAsset(entry);
+  }
+
+  async importFromLocalPath(localPath: string): Promise<EventSoundAsset> {
+    return this.withSerializedMutation(async () => {
+      const extension = this.normalizeExtension(path.extname(localPath));
+      if (!extension) {
+        throw new Error("Unsupported audio file extension");
+      }
+
+      const stat = await fsPromises.stat(localPath);
+      this.validateSize(stat.size);
+
+      const bytes = await fsPromises.readFile(localPath);
+      // Re-validate after reading in case the file grew between stat + read.
+      this.validateSize(bytes.byteLength);
+
+      return this.storeAsset({
+        bytes,
+        originalName: path.basename(localPath),
+        mimeType: EXTENSION_TO_MIME[extension],
+        extension,
+      });
+    });
+  }
+
+  async uploadFromData(input: UploadEventSoundAssetInput): Promise<EventSoundAsset> {
+    return this.withSerializedMutation(async () => {
+      const extensionFromName = this.getExtensionFromOriginalName(input.originalName);
+      const mimeTypeFromInput = this.normalizeMimeType(input.mimeType);
+      const extension =
+        extensionFromName ?? (mimeTypeFromInput ? MIME_TO_EXTENSION[mimeTypeFromInput] : null);
+      if (!extension) {
+        if (input.mimeType.trim().length > 0) {
+          throw new Error("Unsupported audio MIME type");
+        }
+        throw new Error("Unsupported audio file extension");
+      }
+
+      const mimeType = mimeTypeFromInput ?? EXTENSION_TO_MIME[extension];
+
+      const bytes = this.decodeBase64Payload(input.base64);
+      this.validateSize(bytes.byteLength);
+
+      const originalName = input.originalName.trim() || `event-sound.${extension}`;
+
+      return this.storeAsset({
+        bytes,
+        originalName,
+        mimeType,
+        extension,
+      });
+    });
+  }
+
+  async deleteAsset(assetId: string): Promise<void> {
+    await this.withSerializedMutation(async () => {
+      this.assertAssetIdFormat(assetId);
+
+      const assets = await this.readIndex();
+      const entry = assets[assetId];
+      if (!entry) {
+        return;
+      }
+
+      const filePath = this.resolveIndexedAssetFilePath(entry.fileName);
+      if (filePath) {
+        await fsPromises.rm(filePath, { force: true });
+      } else {
+        log.warn("Skipping event sound asset file deletion for invalid indexed filename", {
+          assetId,
+          fileName: entry.fileName,
+        });
+      }
+
+      delete assets[assetId];
+      await this.writeIndex(assets);
+    });
+  }
+
+  async listAssets(): Promise<EventSoundAsset[]> {
+    const assets = await this.readIndex();
+
+    return Object.values(assets)
+      .sort((left, right) => {
+        if (left.createdAt === right.createdAt) {
+          return left.assetId.localeCompare(right.assetId);
+        }
+
+        return right.createdAt.localeCompare(left.createdAt);
+      })
+      .map((entry) => this.toAsset(entry));
+  }
+
+  async getAssetFilePath(assetId: string): Promise<string | null> {
+    this.assertAssetIdFormat(assetId);
+
+    const assets = await this.readIndex();
+    const entry = assets[assetId];
+    if (!entry) {
+      return null;
+    }
+
+    const filePath = this.resolveIndexedAssetFilePath(entry.fileName);
+    if (!filePath) {
+      return null;
+    }
+
+    try {
+      await fsPromises.access(filePath);
+      return filePath;
+    } catch {
+      return null;
+    }
+  }
+
+  getAssetPlaybackPath(assetId: string): string {
+    this.assertAssetIdFormat(assetId);
+    return `${EVENT_SOUND_ASSET_ROUTE_PREFIX}/${encodeURIComponent(assetId)}`;
+  }
+}
diff --git a/src/node/services/projectService.ts b/src/node/services/projectService.ts
index ba7269df00..68b11bc4ed 100644
--- a/src/node/services/projectService.ts
+++ b/src/node/services/projectService.ts
@@ -319,6 +319,7 @@ interface FileCompletionsCacheEntry {
 export class ProjectService {
   private readonly fileCompletionsCache = new Map<string, FileCompletionsCacheEntry>();
   private directoryPicker?: () => Promise<string | null>;
+  private audioFilePicker?: () => Promise<string | null>;
   private readonly sshPromptService: SshPromptService | undefined;
   private workspaceService?: WorkspaceRemover;
 
@@ -342,6 +343,15 @@ export class ProjectService {
     return this.directoryPicker();
   }
 
+  setAudioFilePicker(picker: () => Promise<string | null>) {
+    this.audioFilePicker = picker;
+  }
+
+  async pickAudioFile(): Promise<string | null> {
+    if (!this.audioFilePicker) return null;
+    return this.audioFilePicker();
+  }
+
   async create(
     projectPath: string
   ): Promise<Result<{ projectConfig: ProjectConfig; normalizedPath: string }>> {
diff --git a/src/node/services/serviceContainer.ts b/src/node/services/serviceContainer.ts
index 8beb426f4f..f53db877fb 100644
--- a/src/node/services/serviceContainer.ts
+++ b/src/node/services/serviceContainer.ts
@@ -49,6 +49,7 @@ import { McpOauthService } from "@/node/services/mcpOauthService";
 import { IdleCompactionService } from "@/node/services/idleCompactionService";
 import { getSigningService, type SigningService } from "@/node/services/signingService";
 import { coderService, type CoderService } from "@/node/services/coderService";
+import { EventSoundAssetService } from "@/node/services/eventSoundAssetService";
 import { SshPromptService } from "@/node/services/sshPromptService";
 import { WorkspaceLifecycleHooks } from "@/node/services/workspaceLifecycleHooks";
 import {
@@ -133,6 +134,7 @@ export class ServiceContainer {
   public readonly desktopSessionManager: DesktopSessionManager;
   public readonly desktopTokenManager: DesktopTokenManager;
   public readonly desktopBridgeServer: DesktopBridgeServer;
+  public readonly eventSoundAssetService: EventSoundAssetService;
   public readonly sshPromptService = new SshPromptService();
   private readonly ptyService: PTYService;
   public readonly idleCompactionService: IdleCompactionService;
@@ -156,6 +158,8 @@ export class ServiceContainer {
       streamPortRegistry: this.streamPortRegistry,
     });
 
+    this.eventSoundAssetService = new EventSoundAssetService(config.rootDir);
+
     // Desktop passes WorkspaceMcpOverridesService explicitly so AIService uses
     // the persistent config rather than creating a default with an ephemeral one.
     this.workspaceMcpOverridesService = new WorkspaceMcpOverridesService(config);
@@ -575,6 +579,7 @@ export class ServiceContainer {
       coderService: this.coderService,
       serverAuthService: this.serverAuthService,
       sshPromptService: this.sshPromptService,
+      eventSoundAssetService: this.eventSoundAssetService,
       analyticsService: this.analyticsService,
       desktopSessionManager: this.desktopSessionManager,
       desktopTokenManager: this.desktopTokenManager,
@@ -601,6 +606,10 @@ export class ServiceContainer {
     this.projectService.setDirectoryPicker(picker);
   }
 
+  setProjectAudioFilePicker(picker: () => Promise<string | null>): void {
+    this.projectService.setAudioFilePicker(picker);
+  }
+
   setTerminalWindowManager(manager: TerminalWindowManager): void {
     this.terminalService.setTerminalWindowManager(manager);
   }
diff --git a/vite.config.ts b/vite.config.ts
index 98d10c7463..5a2a582d88 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -181,6 +181,12 @@ export default defineConfig(({ mode }) => {
           // point back to the public dev-server origin (not 127.0.0.1:3000).
           changeOrigin: false,
         },
+        "/assets/event-sounds": {
+          target: backendProxyTarget,
+          // Dev-server mode serves the UI from Vite, but managed event-sound assets
+          // are served by the backend Express route.
+          changeOrigin: false,
+        },
         "/health": {
           target: backendProxyTarget,
           changeOrigin: true,