diff --git a/docs/ADDING_AUDIO.md b/docs/ADDING_AUDIO.md
new file mode 100644
index 000000000..5e467ecb8
--- /dev/null
+++ b/docs/ADDING_AUDIO.md
@@ -0,0 +1,196 @@
+# Adding Audio to OLManager
+
+This guide explains how to add new sound effects or music to Open League Manager.
+
+## Audio System Architecture
+
+OLManager uses the **Web Audio API** (not HTMLAudioElement) for all audio playback. This provides:
+
+- **Zero-latency playback** — audio buffers are decoded once and reused
+- **Hardware acceleration** — especially important on Android/mobile
+- **Real-time volume control** — master volume applied via a single `GainNode`
+- **No memory leaks** — each sound spawns a lightweight `AudioBufferSourceNode`, not a full DOM element
+
+## File Locations
+
+| Location | Purpose |
+|----------|---------|
+| `public/sounds/` | Raw audio files (OGG, WAV, MP3) served as static assets |
+| `src/lib/audioManager.ts` | Core audio engine — decoding, playback, volume |
+| `src/components/GlobalClickSound.tsx` | Global click sound on all buttons |
+| `src/components/GlobalNotificationSound.tsx` | Notification sound for new inbox messages |
+| `src/App.tsx` | Pre-loads critical sounds on app startup |
+
+## Supported Formats
+
+| Format | Recommended | Notes |
+|--------|-------------|-------|
+| **OGG** | ✅ Yes | Best compression, fully open, patent-free |
+| **WAV** | ✅ Yes | Uncompressed, instant decode, larger files |
+| **MP3** | ⚠️ Okay | Patent-encumbered, slightly slower decode |
+
+> **License requirement**: All audio assets must be compatible with GPL-3.0. Preferred sources: CC0, CC-BY, CC-BY-SA, or public domain. See [Audio Licensing](#audio-licensing) below.
+
+## How to Add a New Sound Effect
+
+### 1. Add the audio file
+
+Copy your audio file into `public/sounds/`:
+
+```bash
+cp my-sound.ogg public/sounds/my-sound.ogg
+```
+
+### 2. Pre-load it
+
+In `src/App.tsx`, add a `preloadAudio()` call so the sound is decoded before it's needed:
+
+```tsx
+import { preloadAudio } from "./lib/audioManager";
+
+useEffect(() => {
+  preloadAudio("/sounds/click.ogg");
+  preloadAudio("/sounds/notification.ogg");
+  preloadAudio("/sounds/my-sound.ogg");  // ← add this
+}, []);
+```
+
+> Pre-loading is **optional but strongly recommended**. Without it, the first playback may be silent while the browser decodes the file.
+
+### 3. Play the sound from your component
+
+```tsx
+import { playAudio } from "../lib/audioManager";
+
+function MyComponent() {
+  const handleAction = () => {
+    playAudio("/sounds/my-sound.ogg", { volume: 0.5 });
+    // ... rest of your logic
+  };
+
+  return <button onClick={handleAction}>Do Thing</button>;
+}
+```
+
+### PlayOptions
+
+```ts
+playAudio("/sounds/file.ogg", {
+  volume: 0.5,   // 0–1, multiplied by the user's master volume
+  loop: false,   // set true for background music
+  isMusic: false // set true to respect the "Music" toggle in settings
+});
+```
+
+### Return value
+
+`playAudio()` returns a `ManagedAudioNode | null`:
+
+```ts
+const handle = playAudio("/sounds/loop.ogg", { loop: true });
+
+// Later, stop it:
+handle?.stop();
+```
+
+## How to Add Background Music
+
+Music uses the same API but with `loop: true` and `isMusic: true`:
+
+```tsx
+import { playAudio, stopAudio } from "../lib/audioManager";
+
+const musicRef = useRef<ManagedAudioNode | null>(null);
+
+useEffect(() => {
+  musicRef.current = playAudio("/sounds/menu-music.ogg", {
+    loop: true,
+    isMusic: true,
+    volume: 0.3,
+  });
+
+  return () => {
+    stopAudio(musicRef.current);
+  };
+}, []);
+```
+
+Music with `isMusic: true` automatically respects the user's **Music** toggle in Settings.
+
+## Global Sound Effects (Built-in)
+
+Two global sound components are already wired into `App.tsx`:
+
+| Component | Trigger | Sound file |
+|-----------|---------|------------|
+| `GlobalClickSound` | Any `<button>` click | `public/sounds/click.ogg` |
+| `GlobalNotificationSound` | New inbox message | `public/sounds/notification.ogg` |
+
+To disable sound on a specific button, add `data-no-sound`:
+
+```tsx
+<button data-no-sound>This button is silent</button>
+```
+
+## Audio Settings
+
+The following settings are persisted in `AppSettings` (`src/store/settingsStore.ts`):
+
+| Setting | Type | Default | Description |
+|---------|------|---------|-------------|
+| `master_volume` | `number` (0–1) | `0.5` | Global volume multiplier |
+| `sound_effects_enabled` | `boolean` | `true` | Master switch for SFX |
+| `music_enabled` | `boolean` | `true` | Master switch for music |
+
+When `master_volume` changes, `updateMasterVolume()` in `audioManager.ts` updates the Web Audio `GainNode` in real time.
+
+## Audio Licensing
+
+**All audio assets must be GPL-3.0 compatible.**
+
+### Recommended licenses
+
+| License | Compatible? | Attribution required? |
+|---------|-------------|----------------------|
+| **CC0** | ✅ Yes | No |
+| **CC-BY 4.0** | ✅ Yes | Yes (in `AUDIO_PROVENANCE.md` or similar) |
+| **CC-BY-SA 4.0** | ✅ Yes | Yes + ShareAlike |
+| **Public Domain** | ✅ Yes | No |
+| **CC-BY-NC** | ❌ No | — |
+| **Proprietary / All Rights Reserved** | ❌ No | — |
+
+### Recommended sources
+
+- **Kenney.nl** — `public/sounds/click.ogg` and `notification.ogg` come from here (CC0)
+- **OpenGameArt.org** — Filter by CC0 / CC-BY / CC-BY-SA / OGA-BY
+- **Freesound.org** — Filter by CC0 or CC-BY
+- **Incompetech** (Kevin MacLeod) — CC-BY music
+
+### Attribution
+
+If you add audio that requires attribution, add an entry to `docs/AUDIO_PROVENANCE.md` (create the file if it doesn't exist):
+
+```markdown
+## CC-BY 3.0
+
+- `"Battle Theme"` by Kevin MacLeod (incompetech.com)
+  - Licensed under CC BY 3.0
+  - File: `public/sounds/battle-theme.ogg`
+```
+
+## Performance Tips
+
+1. **Keep files small** — OGG at 44.1kHz mono is usually < 10KB for a 0.2s click sound
+2. **Always pre-load** — Call `preloadAudio()` in `App.tsx` for any sound used in the first 5 seconds
+3. **Don't over-use `new Audio()`** — The Web Audio API already handles this via `AudioBufferSourceNode`; you never need to create `new Audio()` manually
+4. **Test on Android** — Web Audio API behaves slightly differently on mobile WebViews; verify with `npm run tauri android dev` if possible
+
+## Troubleshooting
+
+| Symptom | Likely cause | Fix |
+|---------|-------------|-----|
+| Sound doesn't play at all | Buffer not pre-loaded | Add `preloadAudio()` in `App.tsx` |
+| Sound plays once then never again | Using a single `HTMLAudioElement` | Use `playAudio()` which creates fresh `AudioBufferSourceNode`s |
+| Volume slider has no effect | Not calling `updateMasterVolume()` | Call it when `master_volume` changes |
+| Sound only plays after first click | AudioContext suspended | `resumeContextIfNeeded()` is called automatically inside `playAudio()` |
+| No sound on Android | Autoplay policy | First user interaction (click/tap) will unlock the context automatically |
diff --git a/public/sounds/click.ogg b/public/sounds/click.ogg
new file mode 100644
index 000000000..799e3277c
Binary files /dev/null and b/public/sounds/click.ogg differ
diff --git a/public/sounds/notification.ogg b/public/sounds/notification.ogg
new file mode 100644
index 000000000..bbb8b2edc
Binary files /dev/null and b/public/sounds/notification.ogg differ
diff --git a/src/App.tsx b/src/App.tsx
index ed97148ba..a1345d12e 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,10 +1,13 @@
 import { useEffect, lazy, Suspense } from "react";
 import { BrowserRouter, Routes, Route } from "react-router-dom";
 import { useSettingsStore } from "./store/settingsStore";
+import { preloadAudio } from "./lib/audioManager";
 import { useUpdater } from "./hooks/useUpdater";
 import UpdateModal from "./components/updater/UpdateModal";
 import i18n from "./i18n";
 import "./App.css";
+import GlobalNotificationSound from "./components/GlobalNotificationSound";
+import GlobalClickSound from "./components/GlobalClickSound";
 
 const MainMenu = lazy(() => import("./pages/MainMenu"));
 const TeamSelection = lazy(() => import("./pages/TeamSelection"));
@@ -47,6 +50,12 @@ function App() {
     if (!loaded) loadSettings();
   }, [loaded, loadSettings]);
 
+  // Pre-load critical UI sounds so playback is instant (no load latency)
+  useEffect(() => {
+    preloadAudio("/sounds/click.ogg");
+    preloadAudio("/sounds/notification.ogg");
+  }, []);
+
   useEffect(() => {
     const size = SCALE_MAP[settings.ui_scale] || "16px";
     document.documentElement.style.fontSize = size;
@@ -121,6 +130,8 @@ function App() {
 
   return (
     <BrowserRouter>
+      <GlobalNotificationSound />
+      <GlobalClickSound />
       <Suspense fallback={<LazyFallback />}>
         <Routes>
           <Route path="/" element={<MainMenu />} />
diff --git a/src/components/GlobalClickSound.tsx b/src/components/GlobalClickSound.tsx
new file mode 100644
index 000000000..a821df33e
--- /dev/null
+++ b/src/components/GlobalClickSound.tsx
@@ -0,0 +1,56 @@
+import { useEffect, useRef } from "react";
+import { playAudio, preloadAudio } from "../lib/audioManager";
+
+const CLICK_SOUND_PATH = "/sounds/click.ogg";
+
+/**
+ * Global click sound effect for all interactive buttons.
+ *
+ * Attaches a document-level click listener in capture phase and plays a
+ * subtle sound whenever a `<button>` or `[role="button"]` element is
+ * clicked.
+ */
+export default function GlobalClickSound(): null {
+  const lastPlayRef = useRef<number>(0);
+
+  useEffect(() => {
+    preloadAudio(CLICK_SOUND_PATH);
+  }, []);
+
+  useEffect(() => {
+    function isInteractiveButton(target: EventTarget | null): boolean {
+      if (!(target instanceof Element)) return false;
+
+      if (target.closest("[data-no-sound]")) return false;
+
+      if (target instanceof HTMLInputElement && target.type === "range") {
+        return false;
+      }
+      if (target.closest('input[type="range"]')) return false;
+
+      const button = target.closest("button, [role='button']");
+      if (!button) return false;
+
+      if (button instanceof HTMLButtonElement && button.disabled) {
+        return false;
+      }
+
+      return true;
+    }
+
+    const handleClick = (event: MouseEvent) => {
+      if (!isInteractiveButton(event.target)) return;
+
+      const now = Date.now();
+      if (now - lastPlayRef.current < 30) return;
+      lastPlayRef.current = now;
+
+      playAudio(CLICK_SOUND_PATH, { volume: 0.25 });
+    };
+
+    document.addEventListener("click", handleClick, true);
+    return () => document.removeEventListener("click", handleClick, true);
+  }, []);
+
+  return null;
+}
diff --git a/src/components/GlobalNotificationSound.tsx b/src/components/GlobalNotificationSound.tsx
new file mode 100644
index 000000000..f20b822ab
--- /dev/null
+++ b/src/components/GlobalNotificationSound.tsx
@@ -0,0 +1,37 @@
+import { useEffect, useRef } from "react";
+import { useGameStore } from "../store/gameStore";
+import { playAudio, preloadAudio } from "../lib/audioManager";
+
+const NOTIFICATION_SOUND_PATH = "/sounds/notification.ogg";
+
+/**
+ * Global sound manager for inbox notifications.
+ * Plays a sound whenever a new message arrives, regardless of which page
+ * the user is currently viewing (Dashboard, Match, Settings, etc.).
+ */
+export default function GlobalNotificationSound(): null {
+  const gameState = useGameStore((s) => s.gameState);
+  const previousMessageCountRef = useRef<number>(0);
+
+  useEffect(() => {
+    preloadAudio(NOTIFICATION_SOUND_PATH);
+  }, []);
+
+  useEffect(() => {
+    if (!gameState) {
+      previousMessageCountRef.current = 0;
+      return;
+    }
+
+    const currentCount = gameState.messages.length;
+    const previousCount = previousMessageCountRef.current;
+
+    if (previousCount > 0 && currentCount > previousCount) {
+      playAudio(NOTIFICATION_SOUND_PATH, { volume: 0.5 });
+    }
+
+    previousMessageCountRef.current = currentCount;
+  }, [gameState?.messages.length]);
+
+  return null;
+}
diff --git a/src/lib/audioManager.ts b/src/lib/audioManager.ts
new file mode 100644
index 000000000..04f909bba
--- /dev/null
+++ b/src/lib/audioManager.ts
@@ -0,0 +1,214 @@
+/**
+ * Centralized audio manager for OLManager using the Web Audio API.
+ *
+ * This provides zero-latency, hardware-accelerated audio playback that
+ * is far more reliable on mobile / Android than HTMLAudioElement.
+ *
+ * Architecture:
+ * - One shared AudioContext (lazy-created on first user interaction).
+ * - One master GainNode for global volume.
+ * - AudioBuffers are decoded once and reused forever.
+ * - Each play() spawns a fresh AudioBufferSourceNode (required by the spec).
+ */
+import { useSettingsStore } from "../store/settingsStore";
+
+/** Decoded audio data, keyed by file path. */
+const AUDIO_BUFFERS = new Map<string, AudioBuffer>();
+
+/** In-flight fetch promises so we don't double-request the same file. */
+const FETCH_PROMISES = new Map<string, Promise<void>>();
+
+/** Master gain that every sound routes through. */
+let masterGain: GainNode | null = null;
+
+/** Shared AudioContext. Lazy-created because browsers require a user
+ *  gesture before the context can leave the "suspended" state. */
+let audioCtx: AudioContext | null = null;
+
+function getAudioContext(): AudioContext {
+  if (audioCtx) return audioCtx;
+
+  const AC = (window as any).AudioContext || (window as any).webkitAudioContext;
+  const ctx = new AC();
+  audioCtx = ctx;
+
+  const gain = ctx.createGain();
+  gain.connect(ctx.destination);
+
+  // Start with the saved master volume
+  const settings = useSettingsStore.getState().settings;
+  gain.gain.value = settings.master_volume;
+
+  masterGain = gain;
+  return ctx;
+}
+
+function getMasterGain(): GainNode {
+  getAudioContext();
+  return masterGain!;
+}
+
+function getPrefersReducedMotion(): boolean {
+  if (typeof window === "undefined") return false;
+  return window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+
+/**
+ * Ensure the AudioContext is running. Browsers suspend it until the
+ * first user interaction, so we call this before every play().
+ */
+async function resumeContextIfNeeded(): Promise<void> {
+  const ctx = getAudioContext();
+  if (ctx.state === "suspended") {
+    try {
+      await ctx.resume();
+    } catch {
+      // Ignore – playback will simply be silent until the user interacts.
+    }
+  }
+}
+
+export interface PlayOptions {
+  /** Volume of this specific sound, 0–1. Final volume = master * local. */
+  volume?: number;
+  /** Force loop (useful for music). Default false. */
+  loop?: boolean;
+  /** If true, the sound is treated as music and obeys `music_enabled`. */
+  isMusic?: boolean;
+}
+
+export interface ManagedAudioNode {
+  /** Stop the sound immediately. */
+  stop(): void;
+  /** Underlying Web Audio source node (advanced use). */
+  source: AudioBufferSourceNode;
+}
+
+/**
+ * Pre-load an audio file via fetch + decode so it's ready for instant
+ * playback. Safe to call multiple times for the same src.
+ */
+export function preloadAudio(src: string): Promise<void> {
+  // Already decoded?
+  if (AUDIO_BUFFERS.has(src)) return Promise.resolve();
+
+  // Already fetching?
+  const existing = FETCH_PROMISES.get(src);
+  if (existing) return existing;
+
+  const promise = (async () => {
+    try {
+      const response = await fetch(src);
+      if (!response.ok) {
+        console.warn("[AudioManager] Failed to fetch:", src, response.status);
+        return;
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      const ctx = getAudioContext();
+      const audioBuffer = await ctx.decodeAudioData(arrayBuffer);
+      AUDIO_BUFFERS.set(src, audioBuffer);
+    } catch (err) {
+      console.warn("[AudioManager] Preload failed:", src, err);
+    } finally {
+      FETCH_PROMISES.delete(src);
+    }
+  })();
+
+  FETCH_PROMISES.set(src, promise);
+  return promise;
+}
+
+/**
+ * Play a one-shot sound effect or start music.
+ *
+ * @returns A lightweight handle with a `stop()` method, or `null` if
+ *          playback was blocked by settings / accessibility.
+ */
+export function playAudio(
+  src: string,
+  options: PlayOptions = {},
+): ManagedAudioNode | null {
+  const { volume = 1, loop = false, isMusic = false } = options;
+
+  const settings = useSettingsStore.getState().settings;
+
+  // Respect user toggles
+  if (isMusic && !settings.music_enabled) return null;
+  if (!isMusic && !settings.sound_effects_enabled) return null;
+
+  // Respect accessibility
+  if (getPrefersReducedMotion()) return null;
+
+  const buffer = AUDIO_BUFFERS.get(src);
+  if (!buffer) {
+    // Buffer not ready yet – silently skip. The caller should have
+    // pre-loaded it; we don't block here.
+    console.warn("[AudioManager] Buffer not ready, skipping:", src);
+    return null;
+  }
+
+  resumeContextIfNeeded();
+
+  const ctx = getAudioContext();
+  const master = getMasterGain();
+
+  // Per-sound gain so we can control individual volume
+  const soundGain = ctx.createGain();
+  soundGain.gain.value = Math.max(0, Math.min(1, volume));
+
+  const source = ctx.createBufferSource();
+  source.buffer = buffer;
+  source.loop = loop;
+
+  // Chain: source → soundGain → masterGain → destination
+  source.connect(soundGain);
+  soundGain.connect(master);
+
+  source.start(0);
+
+  const handle: ManagedAudioNode = {
+    stop() {
+      try {
+        source.stop();
+      } catch {
+        // Already stopped – ignore.
+      }
+      try {
+        source.disconnect();
+        soundGain.disconnect();
+      } catch {
+        // Ignore double-disconnect.
+      }
+    },
+    source,
+  };
+
+  // Clean up nodes automatically when the sound finishes
+  source.onended = () => {
+    try {
+      source.disconnect();
+      soundGain.disconnect();
+    } catch {
+      // ignore
+    }
+  };
+
+  return handle;
+}
+
+/**
+ * Stop a previously returned audio handle.
+ */
+export function stopAudio(audio: ManagedAudioNode | null): void {
+  if (!audio) return;
+  audio.stop();
+}
+
+/**
+ * Update the master volume in real time.
+ */
+export function updateMasterVolume(): void {
+  if (!masterGain) return;
+  const settings = useSettingsStore.getState().settings;
+  masterGain.gain.value = settings.master_volume;
+}
diff --git a/src/pages/Settings.tsx b/src/pages/Settings.tsx
index 17dd418e6..fe8dd4a87 100644
--- a/src/pages/Settings.tsx
+++ b/src/pages/Settings.tsx
@@ -3,6 +3,7 @@ import { useNavigate, useLocation } from "react-router-dom";
 import { invoke } from "@tauri-apps/api/core";
 import { useTranslation } from "react-i18next";
 import { useSettingsStore, AppSettings } from "../store/settingsStore";
+import { updateMasterVolume } from "../lib/audioManager";
 import { useTheme } from "../context/ThemeContext";
 import { ThemeToggle, Select } from "../components/ui";
 import { SUPPORTED_LANGUAGES } from "../i18n";
@@ -21,6 +22,9 @@ import {
   Type,
   Maximize,
   Minimize,
+  Volume2,
+  VolumeX,
+  Volume1,
   RefreshCw,
   CheckCircle2,
 } from "lucide-react";
@@ -121,6 +125,11 @@ export default function Settings() {
     if (partial.language) {
       i18n.changeLanguage(partial.language);
     }
+
+    // Sync master volume with Web Audio API in real time
+    if (partial.master_volume !== undefined) {
+      updateMasterVolume();
+    }
   };
 
   const handleClearSaves = async () => {
@@ -385,6 +394,70 @@ export default function Settings() {
           </SettingRow>
         </Section>
 
+        {/* ─── Audio ─── */}
+        <Section
+          title={t("settings.audio", "Audio")}
+          icon={<Volume2 className="w-5 h-5" />}
+        >
+          <SettingRow
+            label={t("settings.masterVolume", "Master Volume")}
+            description={t(
+              "settings.masterVolumeDesc",
+              "Global volume for all sounds and music",
+            )}
+          >
+            <div className="flex items-center gap-3 w-48">
+              {settings.master_volume === 0 ? (
+                <VolumeX className="w-4 h-4 text-gray-400" />
+              ) : settings.master_volume < 0.5 ? (
+                <Volume1 className="w-4 h-4 text-gray-400" />
+              ) : (
+                <Volume2 className="w-4 h-4 text-gray-400" />
+              )}
+              <input
+                type="range"
+                min={0}
+                max={1}
+                step={0.05}
+                value={settings.master_volume}
+                onChange={(e) =>
+                  handleUpdate({ master_volume: parseFloat(e.target.value) })
+                }
+                className="flex-1 h-1.5 bg-gray-200 dark:bg-navy-600 rounded-full appearance-none cursor-pointer accent-primary-500"
+              />
+              <span className="text-xs font-heading font-bold uppercase tracking-wider text-gray-500 dark:text-gray-400 w-8 text-right">
+                {Math.round(settings.master_volume * 100)}%
+              </span>
+            </div>
+          </SettingRow>
+
+          <SettingRow
+            label={t("settings.soundEffects", "Sound Effects")}
+            description={t(
+              "settings.soundEffectsDesc",
+              "Notification sounds, UI clicks, and other game sounds",
+            )}
+          >
+            <Toggle
+              checked={settings.sound_effects_enabled}
+              onChange={(v) => handleUpdate({ sound_effects_enabled: v })}
+            />
+          </SettingRow>
+
+          <SettingRow
+            label={t("settings.music", "Music")}
+            description={t(
+              "settings.musicDesc",
+              "Background music during menus and gameplay",
+            )}
+          >
+            <Toggle
+              checked={settings.music_enabled}
+              onChange={(v) => handleUpdate({ music_enabled: v })}
+            />
+          </SettingRow>
+        </Section>
+
         {/* ─── Saves & Data ─── */}
         <Section
           title={t("settings.savesData")}
diff --git a/src/store/settingsStore.test.ts b/src/store/settingsStore.test.ts
index 5814f145b..882a3a161 100644
--- a/src/store/settingsStore.test.ts
+++ b/src/store/settingsStore.test.ts
@@ -18,6 +18,9 @@ const DEFAULT_SETTINGS = {
   confirm_advance: false,
   ui_scale: "normal",
   high_contrast: false,
+  master_volume: 0.5,
+  sound_effects_enabled: true,
+  music_enabled: true,
   debug_tools_enabled: false,
   lol_hybrid_open_trade_confidence_high: 0.6,
   lol_hybrid_disengage_confidence_low: 0.32,
diff --git a/src/store/settingsStore.ts b/src/store/settingsStore.ts
index e5e3f78d3..ca20aef9b 100644
--- a/src/store/settingsStore.ts
+++ b/src/store/settingsStore.ts
@@ -13,6 +13,9 @@ export interface AppSettings {
   confirm_advance: boolean;
   ui_scale: "xsmall" | "small" | "normal" | "large" | "xlarge";
   high_contrast: boolean;
+  master_volume: number;
+  sound_effects_enabled: boolean;
+  music_enabled: boolean;
   debug_tools_enabled: boolean;
   lol_hybrid_open_trade_confidence_high: number;
   lol_hybrid_disengage_confidence_low: number;
@@ -30,6 +33,9 @@ const DEFAULT_SETTINGS: AppSettings = {
   confirm_advance: false,
   ui_scale: "normal",
   high_contrast: false,
+  master_volume: 0.5,
+  sound_effects_enabled: true,
+  music_enabled: true,
   debug_tools_enabled: false,
   lol_hybrid_open_trade_confidence_high: 0.6,
   lol_hybrid_disengage_confidence_low: 0.32,