Delete autovol_tray.py

autovol_tray.py

@@ -1,1992 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-AutoVol (Tray) — zero-config, self-healing auto volume learner.
-
-What it tries to do:
-- Watch "how loud the system audio is" (best effort: real loopback audio; fallback: peak meter).
-- Learn when you turn volume down (stores the loudness level at that moment).
-- Next time it detects you're above your learned loudness threshold, it gently ducks volume.
-
-v0.10.10 fixes vs v0.10.9:
-- Fix comtypes access-violation on COM pointer finalizers by ensuring COM interface pointers
-  are dereferenced (and collected) BEFORE CoUninitialize in COM threads.
-- Ensure WinVolSTA COM thread is joined on close, so it can cleanly unwind before interpreter exit.
-
-Run:
-  python autovol_tray.py
-
-Data dir (Windows):
-  %LOCALAPPDATA%\\AutoVol
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-import math
-import time
-import json
-import platform
-import threading
-import argparse
-import queue
-import subprocess
-import traceback
-import logging
-import gc
-from logging.handlers import RotatingFileHandler
-from typing import Deque, Dict, List, Optional, Tuple, Callable, Any
-from collections import deque
-from dataclasses import dataclass
-
-__version__ = "0.10.10"
-_WIN = platform.system().lower().startswith("win")
-
-DEFAULT_SR = 48000
-DEFAULT_FRAME_S = 0.20
-DEFAULT_FRAMES = int(round(DEFAULT_SR * DEFAULT_FRAME_S))
-
-# ------------------ dependency bootstrap ------------------
-
-_NO_AUTOINSTALL = ("--no-autoinstall" in sys.argv)
-
-
-def _pip_install(pkgs: List[str]) -> bool:
-    """Best-effort dependency install.
-
-    If you're NOT in a venv, install into per-user site-packages (avoids admin/permission issues).
-    If you're in a venv, install into the venv as normal.
-    """
-    try:
-        in_venv = (getattr(sys, "base_prefix", sys.prefix) != sys.prefix) or bool(os.environ.get("VIRTUAL_ENV"))
-        cmd = [sys.executable, "-m", "pip", "install", "--upgrade"]
-        if not in_venv:
-            cmd.append("--user")
-        cmd += pkgs
-        p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
-        if p.returncode != 0:
-            logging.info("[deps] pip failed (%s):\n%s", p.returncode, p.stdout[-3000:])
-        return (p.returncode == 0)
-    except Exception:
-        return False
-
-
-def _ensure_deps(auto_install: bool = True) -> None:
-    need: List[str] = []
-
-    try:
-        import numpy  # noqa: F401
-    except Exception:
-        need.append("numpy")
-
-    try:
-        import PIL  # noqa: F401
-    except Exception:
-        need.append("Pillow")
-
-    try:
-        import pystray  # noqa: F401
-    except Exception:
-        need.append("pystray")
-
-    if _WIN:
-        try:
-            import comtypes  # noqa: F401
-        except Exception:
-            need.append("comtypes")
-        try:
-            import pycaw  # noqa: F401
-        except Exception:
-            need.append("pycaw")
-        try:
-            import win32api  # type: ignore  # noqa: F401
-        except Exception:
-            need.append("pywin32")
-
-    try:
-        import sounddevice  # noqa: F401
-    except Exception:
-        need.append("sounddevice")
-
-    # Optional fallback
-    try:
-        import soundcard  # noqa: F401
-    except Exception:
-        if auto_install:
-            need.append("soundcard")
-
-    # Optional VAD (do not force install)
-    try:
-        import webrtcvad  # noqa: F401
-    except Exception:
-        pass
-
-    if need and auto_install:
-        _pip_install(need)
-
-
-# Install before importing heavy deps (best effort).
-try:
-    _ensure_deps(auto_install=(not _NO_AUTOINSTALL))
-except Exception:
-    pass
-
-# Third-party deps
-import numpy as np
-
-try:
-    import sounddevice as sd
-except Exception:
-    sd = None
-
-try:
-    import soundcard as sc
-except Exception:
-    sc = None
-
-try:
-    import webrtcvad  # type: ignore
-    _HAVE_WEBRTCVAD = True
-except Exception:
-    webrtcvad = None
-    _HAVE_WEBRTCVAD = False
-
-import pystray
-from pystray import MenuItem as Item, Menu
-from PIL import Image, ImageDraw
-
-
-# ------------------ logging ------------------
-
-def _default_data_dir() -> str:
-    if _WIN and "LOCALAPPDATA" in os.environ:
-        return os.path.join(os.environ["LOCALAPPDATA"], "AutoVol")
-    return os.path.abspath(".")
-
-
-def setup_logging(data_dir: str) -> str:
-    os.makedirs(data_dir, exist_ok=True)
-    log_path = os.path.join(data_dir, "autovol.log")
-
-    logger = logging.getLogger()
-    logger.setLevel(logging.INFO)
-
-    fmt = logging.Formatter("%(asctime)s %(levelname)s %(threadName)s %(message)s")
-    fh = RotatingFileHandler(log_path, maxBytes=512_000, backupCount=2, encoding="utf-8")
-    fh.setFormatter(fmt)
-    sh = logging.StreamHandler(sys.stdout)
-    sh.setFormatter(fmt)
-
-    logger.handlers = []
-    logger.addHandler(fh)
-    logger.addHandler(sh)
-
-    logging.info("AutoVol starting v%s (win=%s) data_dir=%s", __version__, _WIN, data_dir)
-    logging.info("Args: %s", " ".join(sys.argv))
-    if _NO_AUTOINSTALL:
-        logging.info("Auto-install deps: DISABLED (--no-autoinstall)")
-    return log_path
-
-
-# ------------------ utils ------------------
-
-def clamp(x: float, lo: float, hi: float) -> float:
-    return max(lo, min(hi, x))
-
-
-def db_to_lin(db: float) -> float:
-    return 10.0 ** (db / 20.0)
-
-
-def rms_dbfs(x: np.ndarray, eps: float = 1e-12) -> float:
-    if x is None or getattr(x, "size", 0) == 0:
-        return -100.0
-    if x.ndim == 2 and x.shape[1] > 1:
-        x = x.mean(axis=1)
-    rms = float(np.sqrt(np.mean(np.square(x), dtype=np.float64)))
-    if not np.isfinite(rms) or rms <= eps:
-        return -100.0
-    db = 20.0 * math.log10(max(eps, rms))
-    return float(max(min(db, 0.0), -100.0))
-
-
-def safe_tooltip(s: str, max_len: int = 120) -> str:
-    """
-    Windows NOTIFYICONDATAW tooltip limit is 128 WCHAR incl null.
-    Keep it comfortably below to avoid pystray ValueError.
-    """
-    s = s.replace("\n", " ").strip()
-    if len(s) <= max_len:
-        return s
-    return s[: max_len - 1] + "…"
-
-
-@dataclass
-class Stats:
-    p50: float
-    p70: float
-    p85: float
-    p95: float
-    n: int
-
-
-class PercentileWindow:
-    def __init__(self, frame_s: float, history_s: float):
-        self.frame_s = float(frame_s)
-        self.buf: Deque[Tuple[float, float]] = deque(maxlen=int(history_s / frame_s) + 16)
-        self.lock = threading.Lock()
-
-    def push(self, ts: float, db: float) -> None:
-        with self.lock:
-            self.buf.append((ts, db))
-
-    def stats(self, window_s: float) -> Stats:
-        cutoff = time.time() - float(window_s)
-        with self.lock:
-            vals = [db for (ts, db) in self.buf if ts >= cutoff]
-        if not vals:
-            return Stats(-100.0, -100.0, -100.0, -100.0, 0)
-        vals.sort()
-
-        def pct(p: float) -> float:
-            k = int(round((len(vals) - 1) * clamp(p, 0.0, 1.0)))
-            return float(vals[k])
-
-        return Stats(p50=pct(0.50), p70=pct(0.70), p85=pct(0.85), p95=pct(0.95), n=len(vals))
-
-
-# ------------------ samplers ------------------
-
-class SamplerBase:
-    """
-    Samplers should be "alive" even during silence.
-    Health is: are samples arriving (n>0), not whether audio is loud.
-    """
-    def chosen_name(self) -> Optional[str]:
-        return None
-
-    def start(self) -> None:
-        pass
-
-    def stop(self) -> None:
-        pass
-
-    def get_last_block(self) -> Optional[np.ndarray]:
-        return None
-
-    def samples_recent(self, window_s: float = 1.5) -> bool:
-        try:
-            win = getattr(self, "win", None)
-            if win is None:
-                return False
-            st = win.stats(window_s)
-            return st.n > 0
-        except Exception:
-            return False
-
-
-class LoopbackSampler_SD(SamplerBase):
-    """
-    sounddevice WASAPI loopback.
-
-    Key detail: some PortAudio/WASAPI builds on Windows do NOT support the blocking API
-    (you'll see: "Blocking API not supported yet"). To self-heal across machines, we run
-    the stream in CALLBACK mode and never call stream.read().
-
-    Strategy:
-    - Prefer explicit "(loopback)" INPUT devices when present.
-    - Otherwise, try the default OUTPUT device with WasapiSettings(loopback=True).
-    - Try a small set of sample rates + channel counts (2/1).
-    """
-
-    def __init__(self, sr=DEFAULT_SR, frame_s=DEFAULT_FRAME_S, history_s=150.0):
-        self.sr = int(sr)
-        self.frame_s = float(frame_s)
-        self.frames = int(round(self.frame_s * self.sr))
-        self.win = PercentileWindow(frame_s, history_s)
-
-        self.ok = False
-        self._stop = threading.Event()
-        self._th: Optional[threading.Thread] = None
-        self._last_block: Optional[np.ndarray] = None
-        self._lb_lock = threading.Lock()
-
-        self._chosen: Optional[str] = None
-        self._dev_index: Optional[int] = None
-        self._extra = None
-
-    def chosen_name(self) -> Optional[str]:
-        return self._chosen if self.ok else None
-
-    def get_last_block(self) -> Optional[np.ndarray]:
-        with self._lb_lock:
-            return None if self._last_block is None else self._last_block.copy()
-
-    def _wasapi_idx(self) -> Optional[int]:
-        if sd is None:
-            return None
-        try:
-            hostapis = sd.query_hostapis()
-            for i, h in enumerate(hostapis):
-                if "wasapi" in str(h.get("name", "")).lower():
-                    return i
-        except Exception:
-            return None
-        return None
-
-    def _pick_loopback_input_device(self) -> Optional[int]:
-        """
-        Many systems expose loopback capture as a dedicated *input* device with "(loopback)" in name.
-        If present, prefer it (more reliable than output+loopback settings).
-        """
-        if sd is None or not _WIN:
-            return None
-        wasapi_idx = self._wasapi_idx()
-        if wasapi_idx is None:
-            return None
-        try:
-            devs = sd.query_devices()
-        except Exception:
-            return None
-
-        out_name = ""
-        try:
-            out_idx = int(sd.default.device[1])
-            out_name = str(sd.query_devices(out_idx).get("name", "")).lower()
-        except Exception:
-            out_name = ""
-
-        loopbacks: List[int] = []
-        for i, d in enumerate(devs):
-            try:
-                if int(d.get("hostapi", -1)) != wasapi_idx:
-                    continue
-                if int(d.get("max_input_channels", 0)) <= 0:
-                    continue
-                name = str(d.get("name", "")).lower()
-                if "loopback" in name or "(loopback)" in name:
-                    loopbacks.append(i)
-            except Exception:
-                continue
-        if not loopbacks:
-            return None
-
-        # Prefer loopback device that matches the default output device name (best guess)
-        if out_name:
-            out_stem = out_name.split("(")[0].strip()
-            if out_stem:
-                for i in loopbacks:
-                    try:
-                        name = str(devs[i].get("name", "")).lower()
-                        if out_stem in name:
-                            return i
-                    except Exception:
-                        continue
-        return loopbacks[0]
-
-    def _pick_output_device(self) -> Optional[int]:
-        if sd is None or not _WIN:
-            return None
-        wasapi_idx = self._wasapi_idx()
-        if wasapi_idx is None:
-            return None
-        try:
-            devs = sd.query_devices()
-        except Exception:
-            return None
-
-        outs: List[int] = []
-        for i, d in enumerate(devs):
-            try:
-                if int(d.get("hostapi", -1)) == wasapi_idx and int(d.get("max_output_channels", 0)) > 0:
-                    outs.append(i)
-            except Exception:
-                continue
-        if not outs:
-            return None
-        try:
-            out_def = int(sd.default.device[1])
-            if out_def in outs:
-                return out_def
-        except Exception:
-            pass
-        return outs[0]
-
-    def start(self) -> None:
-        if self._th or sd is None or not _WIN:
-            return
-
-        dev = self._pick_loopback_input_device()
-        using_loopback_input = True
-        if dev is None:
-            dev = self._pick_output_device()
-            using_loopback_input = False
-        if dev is None:
-            logging.info("[SD Loopback] no WASAPI device found.")
-            return
-
-        self._dev_index = dev
-        try:
-            devinfo = sd.query_devices(dev)
-            devname = str(devinfo.get("name", "?"))
-            max_in = int(devinfo.get("max_input_channels", 0) or 0)
-            max_out = int(devinfo.get("max_output_channels", 0) or 0)
-            dev_sr = float(devinfo.get("default_samplerate", self.sr) or self.sr)
-        except Exception:
-            devname, max_in, max_out, dev_sr = f"dev#{dev}", 0, 2, float(self.sr)
-
-        # Extra settings: loopback True (works for output device capture; harmless for dedicated loopback inputs)
-        extra = None
-        try:
-            extra = sd.WasapiSettings(loopback=True)
-        except Exception:
-            extra = None
-        self._extra = extra
-
-        if using_loopback_input:
-            self._chosen = f"sd/wasapi loopback-in: {devname}"
-            ch_max = max(1, max_in)
-        else:
-            self._chosen = f"sd/wasapi loopback: {devname}"
-            ch_max = max(1, max_out)
-
-        sr_candidates: List[int] = []
-        for s in [self.sr, int(dev_sr), 48000, 44100]:
-            if s > 8000 and s not in sr_candidates:
-                sr_candidates.append(int(s))
-
-        # Try stereo then mono, but never exceed what the device advertises.
-        ch_candidates: List[int] = []
-        for c in [2, 1]:
-            if c <= ch_max:
-                ch_candidates.append(c)
-        if not ch_candidates:
-            ch_candidates = [1]
-
-        def cb(indata, frames, time_info, status):  # noqa: ANN001
-            try:
-                block = np.asarray(indata, dtype=np.float32)
-                self.win.push(time.time(), rms_dbfs(block))
-                with self._lb_lock:
-                    self._last_block = block.copy()
-            except Exception:
-                pass
-
-        def run():
-            try:
-                last_err = None
-                stream = None
-
-                for sr_try in sr_candidates:
-                    for ch_try in ch_candidates:
-                        try:
-                            frames = int(round(self.frame_s * sr_try))
-                            stream = sd.InputStream(
-                                samplerate=sr_try,
-                                channels=ch_try,
-                                dtype="float32",
-                                blocksize=frames,
-                                device=self._dev_index,
-                                extra_settings=self._extra if _WIN else None,
-                                callback=cb,  # callback mode: avoids "Blocking API not supported yet"
-                            )
-                            self.sr = int(sr_try)
-                            self.frames = int(frames)
-                            self.ok = True
-                            logging.info("[SD Loopback] opened sr=%s ch=%s (%s)", sr_try, ch_try, self._chosen)
-                            break
-                        except Exception as e:
-                            last_err = e
-                            stream = None
-                    if stream is not None:
-                        break
-
-                if stream is None:
-                    logging.info("[SD Loopback] init error: %r", last_err)
-                    self.ok = False
-                    return
-
-                with stream:
-                    while not self._stop.is_set():
-                        time.sleep(0.25)
-            except Exception as e:
-                logging.info("[SD Loopback] thread error: %r", e)
-                self.ok = False
-
-        self._th = threading.Thread(target=run, name="SDLoopback", daemon=True)
-        self._th.start()
-
-    def stop(self) -> None:
-        self._stop.set()
-        if self._th:
-            self._th.join(timeout=1.5)
-
-
-class StereoMixSampler_SD(SamplerBase):
-    """
-    Capture from an *input* device that looks like "Stereo Mix"/"What U Hear".
-
-    Same deal as LoopbackSampler_SD: use CALLBACK mode so we don't depend on PortAudio's
-    blocking API support ("Blocking API not supported yet").
-    """
-
-    def __init__(self, sr=DEFAULT_SR, frame_s=DEFAULT_FRAME_S, history_s=150.0):
-        self.sr = int(sr)
-        self.frame_s = float(frame_s)
-        self.frames = int(round(self.frame_s * self.sr))
-        self.win = PercentileWindow(frame_s, history_s)
-
-        self.ok = False
-        self._stop = threading.Event()
-        self._th: Optional[threading.Thread] = None
-        self._last_block: Optional[np.ndarray] = None
-        self._lb_lock = threading.Lock()
-
-        self._chosen: Optional[str] = None
-        self._dev_index: Optional[int] = None
-
-    def chosen_name(self) -> Optional[str]:
-        return self._chosen if self.ok else None
-
-    def get_last_block(self) -> Optional[np.ndarray]:
-        with self._lb_lock:
-            return None if self._last_block is None else self._last_block.copy()
-
-    def _pick_device(self) -> Optional[int]:
-        if sd is None:
-            return None
-        try:
-            devs = sd.query_devices()
-        except Exception:
-            return None
-
-        needles = ["stereo mix", "what u hear", "what you hear"]
-        for i, d in enumerate(devs):
-            try:
-                name = str(d.get("name", "")).lower()
-                max_in = int(d.get("max_input_channels", 0))
-                if max_in <= 0:
-                    continue
-                if any(n in name for n in needles):
-                    return i
-            except Exception:
-                continue
-        return None
-
-    def start(self) -> None:
-        if self._th or sd is None:
-            return
-        dev = self._pick_device()
-        if dev is None:
-            return
-        self._dev_index = dev
-
-        try:
-            devinfo = sd.query_devices(dev)
-            devname = str(devinfo.get("name", "?"))
-            max_in = int(devinfo.get("max_input_channels", 1) or 1)
-            dev_sr = float(devinfo.get("default_samplerate", self.sr) or self.sr)
-        except Exception:
-            devname, max_in, dev_sr = f"dev#{dev}", 1, float(self.sr)
-
-        self._chosen = f"sd/input: {devname}"
-
-        sr_candidates: List[int] = []
-        for s in [self.sr, int(dev_sr), 48000, 44100]:
-            if s > 8000 and s not in sr_candidates:
-                sr_candidates.append(int(s))
-
-        ch_candidates = [c for c in [2, 1] if c <= max_in] or [1]
-
-        def cb(indata, frames, time_info, status):  # noqa: ANN001
-            try:
-                block = np.asarray(indata, dtype=np.float32)
-                self.win.push(time.time(), rms_dbfs(block))
-                with self._lb_lock:
-                    self._last_block = block.copy()
-            except Exception:
-                pass
-
-        def run():
-            last_err = None
-            stream = None
-
-            for sr_try in sr_candidates:
-                for ch_try in ch_candidates:
-                    try:
-                        frames = int(round(self.frame_s * sr_try))
-                        stream = sd.InputStream(
-                            samplerate=sr_try,
-                            channels=ch_try,
-                            dtype="float32",
-                            blocksize=frames,
-                            device=self._dev_index,
-                            callback=cb,
-                        )
-                        self.sr = int(sr_try)
-                        self.frames = int(frames)
-                        self.ok = True
-                        logging.info("[StereoMix] opened sr=%s ch=%s (%s)", sr_try, ch_try, self._chosen)
-                        break
-                    except Exception as e:
-                        last_err = e
-                        stream = None
-                if stream is not None:
-                    break
-
-            if stream is None:
-                logging.info("[StereoMix] init error: %r", last_err)
-                self.ok = False
-                return
-
-            try:
-                with stream:
-                    while not self._stop.is_set():
-                        time.sleep(0.25)
-            except Exception as e:
-                logging.info("[StereoMix] thread error: %r", e)
-                self.ok = False
-
-        self._th = threading.Thread(target=run, name="StereoMix", daemon=True)
-        self._th.start()
-
-    def stop(self) -> None:
-        self._stop.set()
-        if self._th:
-            self._th.join(timeout=1.5)
-
-
-class LoopbackSampler_SC(SamplerBase):
-    """python-soundcard loopback (can pick the "wrong" speaker on multi-output systems)."""
-
-    def __init__(self, sr: int = DEFAULT_SR, frame_s: float = DEFAULT_FRAME_S, history_s: float = 150.0, dev_name: Optional[str] = None):
-        self.ok = False
-        self.sr = int(sr)
-        self.frame_s = float(frame_s)
-        self.frames = int(round(self.frame_s * self.sr))
-        self.win = PercentileWindow(self.frame_s, history_s)
-        self.stop_evt = threading.Event()
-        self.th: Optional[threading.Thread] = None
-        self._last_block: Optional[np.ndarray] = None
-        self._lb_lock = threading.Lock()
-        self._chosen_name: Optional[str] = None
-        self._dev_name = dev_name
-
-    def chosen_name(self) -> Optional[str]:
-        return self._chosen_name if self.ok else None
-
-    def get_last_block(self) -> Optional[np.ndarray]:
-        with self._lb_lock:
-            return None if self._last_block is None else self._last_block.copy()
-
-    def _speaker_score(self, name: str) -> int:
-        n = name.lower()
-        score = 0
-        if "realtek" in n:
-            score += 50
-        if "speaker" in n:
-            score += 20
-        if "headphone" in n:
-            score += 10
-        # deprioritize HDMI/display devices
-        bad = ["hdmi", "display", "nvidia", "amd", "intel", "vf", "dp audio"]
-        if any(b in n for b in bad):
-            score -= 40
-        return score
-
-    def _pick_recorder(self):
-        """
-        python-soundcard loopback.
-
-        Prefer OS default speaker first; otherwise heuristic sort.
-        Only require that we can open the recorder (no audio needed yet).
-        """
-        if sc is None:
-            return None
-
-        speakers: List[Any] = []
-        try:
-            speakers = list(sc.all_speakers())
-        except Exception:
-            speakers = []
-
-        # If dev_name supplied, try it first.
-        if self._dev_name:
-            for spk in speakers:
-                try:
-                    if str(getattr(spk, "name", "")) == str(self._dev_name):
-                        try:
-                            mic = sc.get_microphone(id=str(spk.name), include_loopback=True)
-                            self._chosen_name = f"soundcard loopback: {mic.name}"
-                            for ch in (2, 1):
-                                try:
-                                    rec = mic.recorder(samplerate=self.sr, channels=ch)
-                                    return rec
-                                except Exception:
-                                    continue
-                        except Exception:
-                            pass
-                except Exception:
-                    continue
-
-        # Default first
-        default_first: List[Any] = []
-        try:
-            d = sc.default_speaker()
-            default_first = [d]
-            speakers = [s for s in speakers if getattr(s, "name", None) != getattr(d, "name", None)]
-        except Exception:
-            default_first = []
-
-        speakers_sorted = sorted(
-            speakers,
-            key=lambda s: self._speaker_score(getattr(s, "name", "")),
-            reverse=True,
-        )
-
-        candidates = (default_first + speakers_sorted)[:12]
-
-        for spk in candidates:
-            try:
-                mic = sc.get_microphone(id=str(spk.name), include_loopback=True)
-                self._chosen_name = f"soundcard loopback: {mic.name}"
-                for ch in (2, 1):
-                    try:
-                        rec = mic.recorder(samplerate=self.sr, channels=ch)
-                        return rec
-                    except Exception:
-                        continue
-            except Exception:
-                continue
-
-        return None
-
-    def start(self) -> None:
-        if self.th or sc is None:
-            return
-        rec = self._pick_recorder()
-        if rec is None:
-            return
-
-        def run():
-            with rec:
-                while not self.stop_evt.is_set():
-                    try:
-                        block = rec.record(self.frames)
-                        block = np.asarray(block, dtype=np.float32)
-                        self.win.push(time.time(), rms_dbfs(block))
-                        with self._lb_lock:
-                            self._last_block = block.copy()
-                    except Exception:
-                        time.sleep(0.05)
-
-        self.th = threading.Thread(target=run, name="SCLoopback", daemon=True)
-        self.th.start()
-        self.ok = True
-        logging.info("[soundcard loopback] running: %s", self._chosen_name)
-
-    def stop(self) -> None:
-        self.stop_evt.set()
-        if self.th:
-            self.th.join(timeout=1.5)
-
-
-class PycawPeakSampler(SamplerBase):
-    """
-    Reliable-ish fallback: system output peak meter via Pycaw.
-
-    Notes:
-    - This sampler does NOT provide raw audio blocks (so VAD is disabled).
-    - Some systems throw intermittent COM errors on GetPeakValue(). We keep emitting samples
-      (using last known value) and aggressively re-acquire the meter to self-heal.
-    """
-
-    def __init__(self, frame_s=DEFAULT_FRAME_S, history_s=150.0):
-        self.frame_s = float(frame_s)
-        self.win = PercentileWindow(frame_s, history_s)
-        self._stop = threading.Event()
-        self._th: Optional[threading.Thread] = None
-        self._ok = False
-
-        self._mu = threading.Lock()
-        self._succ = 0
-        self._fail = 0
-        self._fail_streak = 0
-        self._last_ok_ts = 0.0
-
-    def chosen_name(self) -> Optional[str]:
-        return "pycaw peak meter" if self._ok else None
-
-    def is_degraded(self) -> bool:
-        with self._mu:
-            if not self._ok:
-                return True
-            now = time.time()
-            if (now - self._last_ok_ts) > 8.0 and self._fail_streak >= 80:
-                return True
-            return False
-
-    def start(self) -> None:
-        if self._th or not _WIN:
-            return
-
-        def run():
-            meter = None
-            last_db = -100.0
-
-            def acquire():
-                nonlocal meter
-                try:
-                    import ctypes
-                    from ctypes import POINTER
-                    from pycaw.pycaw import AudioUtilities, IAudioMeterInformation
-                    from comtypes import CLSCTX_ALL
-
-                    dev = AudioUtilities.GetSpeakers()
-                    iface = dev.Activate(IAudioMeterInformation._iid_, CLSCTX_ALL, None)
-                    meter = ctypes.cast(iface, POINTER(IAudioMeterInformation))
-                    return True
-                except Exception as e:
-                    logging.info("[PycawMeter] acquire failed: %r", e)
-                    meter = None
-                    return False
-
-            CoUninitialize = None
-            try:
-                try:
-                    from comtypes import CoInitializeEx, CoUninitialize as _CoUninitialize, COINIT_MULTITHREADED
-                    CoUninitialize = _CoUninitialize
-                    CoInitializeEx(COINIT_MULTITHREADED)
-                except Exception:
-                    from comtypes import CoInitialize, CoUninitialize as _CoUninitialize
-                    CoUninitialize = _CoUninitialize
-                    CoInitialize()
-
-                try:
-                    ok = acquire()
-                    self._ok = bool(ok)
-                    if self._ok:
-                        logging.info("[PycawMeter] running.")
-
-                    last_log = 0.0
-                    while not self._stop.is_set():
-                        db = last_db
-                        try:
-                            if meter is None:
-                                acquire()
-
-                            if meter is not None:
-                                import ctypes
-                                from ctypes import byref, c_float
-
-                                v = c_float()
-                                meter.GetPeakValue(byref(v))
-                                peak = float(v.value)
-                                if peak <= 0.0 or not math.isfinite(peak):
-                                    db = -100.0
-                                else:
-                                    db = 20.0 * math.log10(max(1e-9, peak))
-                                last_db = db
-
-                                with self._mu:
-                                    self._succ += 1
-                                    self._fail_streak = 0
-                                    self._last_ok_ts = time.time()
-                            else:
-                                raise RuntimeError("meter not acquired")
-                        except Exception:
-                            with self._mu:
-                                self._fail += 1
-                                self._fail_streak += 1
-                                fs = self._fail_streak
-
-                            if fs in (1, 10, 25, 50) or (time.time() - last_log) > 15.0:
-                                last_log = time.time()
-                                logging.info("[PycawMeter] read error (x%s) — continuing.", fs)
-
-                            if fs in (3, 10, 25, 50, 80) or (time.time() - self._last_ok_ts) > 6.0:
-                                acquire()
-
-                        self.win.push(time.time(), db)
-                        time.sleep(self.frame_s)
-                finally:
-                    # IMPORTANT: drop COM interface refs BEFORE CoUninitialize
-                    try:
-                        meter = None
-                        gc.collect()
-                    except Exception:
-                        pass
-                    try:
-                        if CoUninitialize is not None:
-                            CoUninitialize()
-                    except Exception:
-                        pass
-            except Exception as e:
-                logging.info("[PycawMeter] init error: %r", e)
-
-        self._th = threading.Thread(target=run, name="PycawMeter", daemon=True)
-        self._th.start()
-
-    def stop(self) -> None:
-        self._stop.set()
-        if self._th:
-            self._th.join(timeout=2.5)
-
-
-class MeterSampler(SamplerBase):
-    """
-    Last-resort COM meter via CreateObject("MMDeviceEnumerator") and IAudioMeterInformation.
-    """
-
-    def __init__(self, frame_s=DEFAULT_FRAME_S, history_s=150.0):
-        self.frame_s = float(frame_s)
-        self.win = PercentileWindow(frame_s, history_s)
-        self._ok = False
-        self._stop = threading.Event()
-        self._th: Optional[threading.Thread] = None
-
-        self._mu = threading.Lock()
-        self._fail_streak = 0
-        self._last_ok_ts = 0.0
-
-    def chosen_name(self) -> Optional[str]:
-        return "endpoint peak meter" if self._ok else None
-
-    def is_degraded(self) -> bool:
-        with self._mu:
-            if not self._ok:
-                return True
-            if (time.time() - self._last_ok_ts) > 8.0 and self._fail_streak >= 80:
-                return True
-            return False
-
-    def start(self) -> None:
-        if self._th or not _WIN:
-            return
-
-        def run():
-            meter = None
-            last_db = -100.0
-
-            def acquire():
-                nonlocal meter
-                try:
-                    import ctypes
-                    from ctypes import POINTER, byref, c_float, c_int, c_void_p, c_ulong
-                    from comtypes import (
-                        IUnknown, GUID, HRESULT, COMMETHOD,
-                        CLSCTX_ALL,
-                    )
-                    from comtypes.client import CreateObject
-
-                    eRender = 0
-                    eMultimedia = 1
-
-                    class IMMDevice(IUnknown):
-                        _iid_ = GUID('{D666063F-1587-4E43-81F1-B948E807363F}')
-                        _methods_ = [
-                            COMMETHOD([], HRESULT, 'Activate',
-                                      (['in'], GUID, 'iid'),
-                                      (['in'], c_ulong, 'dwClsCtx'),
-                                      (['in'], c_void_p, 'pActivationParams'),
-                                      (['out'], POINTER(c_void_p), 'ppInterface')),
-                        ]
-
-                    class IMMDeviceEnumerator(IUnknown):
-                        _iid_ = GUID('{A95664D2-9614-4F35-A746-DE8DB63617E6}')
-                        _methods_ = [
-                            COMMETHOD([], HRESULT, 'GetDefaultAudioEndpoint',
-                                      (['in'], c_int, 'dataFlow'),
-                                      (['in'], c_int, 'role'),
-                                      (['out'], POINTER(POINTER(IMMDevice)), 'ppDevice')),
-                        ]
-
-                    class IAudioMeterInformation(IUnknown):
-                        _iid_ = GUID('{C02216F6-8C67-4B5B-9D00-D008E73E0064}')
-                        _methods_ = [
-                            COMMETHOD([], HRESULT, 'GetPeakValue',
-                                      (['out'], POINTER(c_float), 'pfPeak')),
-                        ]
-
-                    enum = CreateObject("MMDeviceEnumerator", interface=IMMDeviceEnumerator)
-                    dev = POINTER(IMMDevice)()
-                    hr = enum.GetDefaultAudioEndpoint(eRender, eMultimedia, byref(dev))
-                    if hr:
-                        raise OSError(f"GetDefaultAudioEndpoint failed hr=0x{hr:08X}")
-                    ptr = c_void_p()
-                    hr = dev.Activate(IAudioMeterInformation._iid_, CLSCTX_ALL, None, byref(ptr))
-                    if hr:
-                        raise OSError(f"Activate(IAudioMeterInformation) failed hr=0x{hr:08X}")
-
-                    meter = ctypes.cast(ptr, POINTER(IAudioMeterInformation))
-                    return True
-                except Exception as e:
-                    logging.info("[Meter] acquire failed: %r", e)
-                    meter = None
-                    return False
-
-            CoUninitialize = None
-            try:
-                try:
-                    from comtypes import CoInitializeEx, CoUninitialize as _CoUninitialize, COINIT_MULTITHREADED
-                    CoUninitialize = _CoUninitialize
-                    CoInitializeEx(COINIT_MULTITHREADED)
-                except Exception:
-                    from comtypes import CoInitialize, CoUninitialize as _CoUninitialize
-                    CoUninitialize = _CoUninitialize
-                    CoInitialize()
-
-                try:
-                    ok = acquire()
-                    self._ok = bool(ok)
-                    if self._ok:
-                        logging.info("[Meter] running (COM peak).")
-
-                    last_log = 0.0
-                    while not self._stop.is_set():
-                        db = last_db
-                        try:
-                            if meter is None:
-                                acquire()
-
-                            if meter is not None:
-                                from ctypes import byref, c_float
-                                v = c_float()
-                                meter.GetPeakValue(byref(v))
-                                peak = float(v.value)
-                                if peak <= 0.0 or not math.isfinite(peak):
-                                    db = -100.0
-                                else:
-                                    db = 20.0 * math.log10(max(1e-9, peak))
-                                last_db = db
-
-                                with self._mu:
-                                    self._fail_streak = 0
-                                    self._last_ok_ts = time.time()
-                            else:
-                                raise RuntimeError("meter not acquired")
-                        except Exception:
-                            with self._mu:
-                                self._fail_streak += 1
-                                fs = self._fail_streak
-
-                            if fs in (1, 10, 25, 50) or (time.time() - last_log) > 15.0:
-                                last_log = time.time()
-                                logging.info("[Meter] read error (x%s) — continuing.", fs)
-
-                            if fs in (3, 10, 25, 50, 80):
-                                acquire()
-
-                        self.win.push(time.time(), db)
-                        time.sleep(self.frame_s)
-                finally:
-                    # IMPORTANT: drop COM interface refs BEFORE CoUninitialize
-                    try:
-                        meter = None
-                        gc.collect()
-                    except Exception:
-                        pass
-                    try:
-                        if CoUninitialize is not None:
-                            CoUninitialize()
-                    except Exception:
-                        pass
-            except Exception as e:
-                logging.info("[Meter] init error: %r", e)
-
-        self._th = threading.Thread(target=run, name="MeterCOM", daemon=True)
-        self._th.start()
-
-    def stop(self) -> None:
-        self._stop.set()
-        if self._th:
-            self._th.join(timeout=2.5)
-
-
-# ------------------ volume backends ------------------
-
-class VolBackend:
-    def get(self) -> float:
-        raise NotImplementedError
-
-    def set(self, s: float) -> None:
-        raise NotImplementedError
-
-
-class WinVolSTA(VolBackend):
-    """System master volume via pycaw on a dedicated COM thread."""
-
-    def __init__(self):
-        self._q: queue.Queue = queue.Queue()
-        self._ready = threading.Event()
-        self._stop = threading.Event()
-        self._th = threading.Thread(target=self._run, name="WinVolCOM", daemon=True)
-        self._th.start()
-        if not self._ready.wait(timeout=2.5):
-            raise RuntimeError("WinVolSTA COM init timed out")
-
-    def _run(self):
-        dev = None
-        iface = None
-        ep = None
-        CoUninitialize = None
-        try:
-            from comtypes import CoInitialize, CoUninitialize as _CoUninitialize, CLSCTX_ALL  # type: ignore
-            from ctypes import POINTER, cast
-            from pycaw.pycaw import AudioUtilities, IAudioEndpointVolume  # type: ignore
-
-            CoUninitialize = _CoUninitialize
-
-            CoInitialize()
-            try:
-                dev = AudioUtilities.GetSpeakers()
-                iface = dev.Activate(IAudioEndpointVolume._iid_, CLSCTX_ALL, None)
-                ep = cast(iface, POINTER(IAudioEndpointVolume))
-                self._ready.set()
-
-                while not self._stop.is_set():
-                    try:
-                        op, val, ack = self._q.get(timeout=0.1)
-                    except queue.Empty:
-                        continue
-                    try:
-                        if op == "get":
-                            ack.set_result(float(ep.GetMasterVolumeLevelScalar()))
-                        elif op == "set":
-                            ep.SetMasterVolumeLevelScalar(clamp(float(val), 0.0, 1.0), None)
-                            ack.set_result(True)
-                        elif op == "quit":
-                            ack.set_result(True)
-                            break
-                    except Exception as e:
-                        ack.set_exception(e)
-            finally:
-                # IMPORTANT: drop COM interface refs BEFORE CoUninitialize
-                try:
-                    ep = None
-                    iface = None
-                    dev = None
-                    gc.collect()
-                except Exception:
-                    pass
-                try:
-                    if CoUninitialize is not None:
-                        CoUninitialize()
-                except Exception:
-                    pass
-        except Exception as e:
-            self._ready.set()
-            try:
-                while True:
-                    op, val, ack = self._q.get_nowait()
-                    ack.set_exception(e)
-            except queue.Empty:
-                pass
-
-    class _Ack:
-        def __init__(self):
-            self._ev = threading.Event()
-            self._res = None
-            self._exc: Optional[BaseException] = None
-
-        def set_result(self, r):
-            self._res = r
-            self._ev.set()
-
-        def set_exception(self, e: BaseException):
-            self._exc = e
-            self._ev.set()
-
-        def wait(self, timeout=None):
-            ok = self._ev.wait(timeout)
-            if not ok:
-                raise TimeoutError("WinVolSTA RPC timed out")
-            if self._exc:
-                raise self._exc
-            return self._res
-
-    def _rpc(self, op: str, val=None, timeout=2.0):
-        ack = WinVolSTA._Ack()
-        self._q.put((op, val, ack))
-        return ack.wait(timeout=timeout)
-
-    def get(self) -> float:
-        try:
-            return float(self._rpc("get"))
-        except Exception:
-            return 0.5
-
-    def set(self, s: float) -> None:
-        try:
-            self._rpc("set", s)
-        except Exception:
-            pass
-
-    def close(self):
-        try:
-            self._rpc("quit", timeout=1.5)
-        except Exception:
-            pass
-        self._stop.set()
-        try:
-            if self._th and self._th.is_alive():
-                self._th.join(timeout=2.5)
-        except Exception:
-            pass
-
-
-class DryVol(VolBackend):
-    def __init__(self):
-        self._s = 0.4
-
-    def get(self) -> float:
-        return self._s
-
-    def set(self, s: float) -> None:
-        self._s = clamp(float(s), 0.0, 1.0)
-
-
-def choose_backend(force_dry: bool = False) -> VolBackend:
-    if not _WIN or force_dry:
-        logging.info("[Vol] Using DryVol (no system changes).")
-        return DryVol()
-    try:
-        bk = WinVolSTA()
-        logging.info("[Vol] Using WinVolSTA (COM thread).")
-        return bk
-    except Exception as e:
-        logging.info("[Vol] Falling back to DryVol: %r", e)
-        return DryVol()
-
-
-# ------------------ learner ------------------
-
-class Learner:
-    def __init__(self, path: str, min_events=6, q=0.70):
-        self.path = path
-        self.min_events = int(min_events)
-        self.q = float(q)
-        self.global_downs: Deque[float] = deque(maxlen=600)
-        self.hour_downs: Dict[int, Deque[float]] = {h: deque(maxlen=300) for h in range(24)}
-        self._mu = threading.Lock()
-        self.load()
-
-    def load(self):
-        if not os.path.exists(self.path):
-            return
-        try:
-            with open(self.path, "r", encoding="utf-8") as f:
-                data = json.load(f)
-        except Exception as e:
-            logging.info("[Learner] load error: %r", e)
-            return
-
-        with self._mu:
-            self.global_downs.clear()
-            for h in range(24):
-                self.hour_downs[h].clear()
-
-            g_src = data.get("global_downs", [])
-            if isinstance(g_src, list):
-                for x in g_src[-600:]:
-                    try:
-                        self.global_downs.append(float(x))
-                    except Exception:
-                        pass
-
-            h_src = data.get("hour_downs", {})
-            if isinstance(h_src, dict):
-                for k, arr in h_src.items():
-                    try:
-                        h = int(k)
-                        if 0 <= h <= 23 and isinstance(arr, list):
-                            for x in arr[-300:]:
-                                try:
-                                    self.hour_downs[h].append(float(x))
-                                except Exception:
-                                    pass
-                    except Exception:
-                        continue
-
-    def save(self):
-        try:
-            with self._mu:
-                out = {
-                    "global_downs": list(self.global_downs),
-                    "hour_downs": {str(h): list(self.hour_downs[h]) for h in range(24)},
-                }
-            tmp = self.path + ".tmp"
-            with open(tmp, "w", encoding="utf-8") as f:
-                json.dump(out, f)
-            os.replace(tmp, self.path)
-        except Exception as e:
-            logging.info("[Learner] save error: %r", e)
-
-    @staticmethod
-    def _percentile(vals: List[float], q: float) -> float:
-        if not vals:
-            return -100.0
-        s = sorted(vals)
-        k = int(round((len(s) - 1) * clamp(q, 0.0, 1.0)))
-        return float(s[k])
-
-    def record_down(self, db_at: float, hour: int):
-        with self._mu:
-            self.global_downs.append(float(db_at))
-            if 0 <= hour <= 23:
-                self.hour_downs[hour].append(float(db_at))
-
-    def threshold(self, hour: int) -> Optional[float]:
-        with self._mu:
-            per = self.hour_downs.get(hour, deque())
-            g = self.global_downs
-
-            if len(per) >= self.min_events:
-                q_use = 0.75 if len(per) > 20 else self.q
-                return self._percentile(list(per), q_use)
-
-            if len(g) >= self.min_events:
-                q_use = 0.75 if len(g) > 20 else self.q
-                return self._percentile(list(g), q_use)
-
-        return None
-
-    def counts(self) -> Tuple[int, Dict[int, int]]:
-        with self._mu:
-            return len(self.global_downs), {h: len(self.hour_downs[h]) for h in range(24)}
-
-    def reset(self):
-        with self._mu:
-            self.global_downs.clear()
-            for h in range(24):
-                self.hour_downs[h].clear()
-        self.save()
-
-
-# ------------------ speech gate ------------------
-
-class SpeechGate:
-    def __init__(self, fs_capture: int, frame_ms: int = 20, aggressiveness: int = 2, ema_alpha: float = 0.35):
-        self.fs_cap = int(fs_capture)
-        self.frame_ms = int(frame_ms)
-        self._ema = 0.0
-        self._alpha = float(clamp(ema_alpha, 0.0, 1.0))
-        self._have_vad = _HAVE_WEBRTCVAD
-        if self._have_vad:
-            self.vad = webrtcvad.Vad(int(clamp(aggressiveness, 0, 3)))
-
-    def _to_16k_pcm16(self, x: np.ndarray) -> Tuple[bytes, int]:
-        if x.ndim > 1:
-            x = x.mean(axis=1)
-        fs16 = 16000
-        if self.fs_cap == 48000:
-            x = x[::3]
-        else:
-            idx = np.linspace(0, len(x) - 1, int(len(x) * fs16 / self.fs_cap))
-            x = np.interp(idx, np.arange(len(x)), x).astype(np.float32)
-        x = np.clip(x, -1.0, 1.0)
-        return (x * 32767.0).astype(np.int16).tobytes(), fs16
-
-    def _heuristic_prob(self, block: np.ndarray) -> float:
-        if block.ndim > 1:
-            x = block.mean(axis=1).astype(np.float32, copy=False)
-        else:
-            x = block.astype(np.float32, copy=False)
-
-        e_db = 20.0 * math.log10(max(1e-9, float(np.sqrt(np.mean(x * x)))))
-        if e_db <= -55.0 or len(x) < 512:
-            return 0.0
-
-        zc = float(np.mean((x[1:] * x[:-1]) < 0.0))
-        X = np.fft.rfft(x * np.hanning(len(x)))
-        mag = np.abs(X) + 1e-9
-        freqs = np.fft.rfftfreq(len(x), 1.0 / self.fs_cap)
-        hf = float(mag[freqs >= 2000].sum() / mag.sum())
-        return 1.0 if (0.03 <= zc <= 0.25) and (0.05 <= hf <= 0.60) else 0.0
-
-    def prob(self, block: Optional[np.ndarray]) -> float:
-        if block is None or getattr(block, "size", 0) == 0:
-            self._ema = (1.0 - self._alpha) * self._ema
-            return self._ema
-
-        if self._have_vad:
-            try:
-                pcm16, fs16 = self._to_16k_pcm16(block)
-                frame_len = int((self.frame_ms / 1000.0) * fs16)
-                hits = 0
-                total = 0
-                step = frame_len * 2
-                for i in range(0, len(pcm16), step):
-                    frame = pcm16[i: i + step]
-                    if len(frame) < step:
-                        break
-                    total += 1
-                    if self.vad.is_speech(frame, fs16):
-                        hits += 1
-                raw = (hits / total) if total else 0.0
-            except Exception:
-                raw = 0.0
-        else:
-            raw = self._heuristic_prob(block)
-
-        self._ema = self._alpha * raw + (1.0 - self._alpha) * self._ema
-        return self._ema
-
-
-# ------------------ volume poller ------------------
-
-class VolumePoller:
-    def __init__(self, bk, poll_s=0.05, min_step=0.005):
-        self.bk = bk
-        self.poll_s = float(poll_s)
-        self.min_step = float(min_step)
-        self._stop = threading.Event()
-        self._thr: Optional[threading.Thread] = None
-        self._prev = self.bk.get()
-        self._callbacks: List[Callable[[float, float, float], None]] = []
-
-    def on_change(self, fn: Callable[[float, float, float], None]):
-        self._callbacks.append(fn)
-
-    def start(self):
-        if self._thr:
-            return
-
-        def run():
-            while not self._stop.is_set():
-                time.sleep(self.poll_s)
-                try:
-                    cur = self.bk.get()
-                except Exception:
-                    continue
-                prev = self._prev
-                if abs(cur - prev) >= self.min_step:
-                    ts = time.time()
-                    for fn in self._callbacks:
-                        try:
-                            fn(ts, prev, cur)
-                        except Exception:
-                            pass
-                    self._prev = cur
-
-        self._thr = threading.Thread(target=run, name="VolPoll", daemon=True)
-        self._thr.start()
-
-    def stop(self):
-        self._stop.set()
-        if self._thr:
-            self._thr.join(timeout=1.5)
-
-
-# ------------------ controller ------------------
-
-class AutoVolController:
-    def __init__(self, model_path: str, events_path: str, force_dryvol: bool = False):
-        self.model_path = model_path
-        self.events_path = events_path
-
-        self.FRAME_S = DEFAULT_FRAME_S
-        self.BASELINE_WIN_S = 45.0
-        self.SHORT_WIN_S = 1.0
-
-        self.OVER_MARGIN_DB = 1.2
-        self.ATTACK_DB_MAX = 1.6
-        self.RELEASE_DB_MAX = 0.45
-        self.MIN_VOL = 0.03
-
-        self.SPEECH_UP_DB = 2.0
-        self.NOSPEECH_DOWN_DB = -2.0
-
-        self.IGNORE_OWN_SET_S = 0.8
-        self.USER_DOWN_COOLDOWN_S = 1.2
-        self.SET_COOLDOWN_S = 1.6
-        self.STARTUP_OBS_S = 6.0
-
-        self.NO_SAMPLE_GRACE_S = 8.0
-        self.SWITCH_COOLDOWN_S = 15.0
-
-        self._stop = threading.Event()
-        self._paused = threading.Event()
-        self._observe = threading.Event()  # observe-only mode (no volume changes)
-        self._thread: Optional[threading.Thread] = None
-        self._last_set_ts = 0.0
-        self._last_user_down_ts = 0.0
-        self._startup_ts = time.time()
-
-        self.observe_only = False
-
-        self._last_th: Optional[float] = None
-        self._last_p85 = -100.0
-        self._last_p95 = -100.0
-        self._speech = 0.0
-        self._flash_duck_until = 0.0
-
-        self._signal_state = "INIT"
-        self._last_sample_ts = time.time()
-        self._last_switch_ts = 0.0
-
-        self.bk = choose_backend(force_dry=force_dryvol)
-        self.learner = Learner(path=self.model_path)
-        self._downs_total = self.learner.counts()[0]
-
-        try:
-            self.events = open(self.events_path, "a", encoding="utf-8")
-        except Exception as e:
-            logging.info("[AutoVol] cannot open events file: %r", e)
-            self.events = None
-
-        self.resting = self.bk.get()
-        self.current = self.resting
-
-        self.poll = VolumePoller(self.bk, poll_s=0.05, min_step=0.005)
-        self.poll.on_change(self._on_user_change)
-
-        self.vad = SpeechGate(fs_capture=48000, frame_ms=20, aggressiveness=2, ema_alpha=0.35)
-
-        self._samplers: List[SamplerBase] = [
-            LoopbackSampler_SD(sr=48000, frame_s=self.FRAME_S, history_s=150.0),
-            LoopbackSampler_SC(sr=48000, frame_s=self.FRAME_S, history_s=150.0),
-            PycawPeakSampler(frame_s=self.FRAME_S, history_s=150.0),
-            StereoMixSampler_SD(sr=48000, frame_s=self.FRAME_S, history_s=150.0),
-            MeterSampler(frame_s=self.FRAME_S, history_s=150.0),
-        ]
-
-        self.sampler: Optional[SamplerBase] = None
-        self._sampler_idx = -1
-
-        self._switch_sampler(reason="startup")
-
-        bk_name = "WinVolSTA" if isinstance(self.bk, WinVolSTA) else "DryVol"
-        src = self.sampler.chosen_name() if self.sampler else "none"
-        logging.info("[AutoVol] backend=%s sampler=%s model=%s events=%s", bk_name, src, self.model_path, self.events_path)
-
-    @property
-    def observe_only(self) -> bool:
-        """If True, AutoVol will not change system volume (it still learns + shows stats)."""
-        return bool(self._observe.is_set())
-
-    @observe_only.setter
-    def observe_only(self, v: bool) -> None:
-        if bool(v):
-            self._observe.set()
-        else:
-            self._observe.clear()
-
-    def _write_event(self, obj: Dict[str, Any]) -> None:
-        try:
-            if self.events:
-                self.events.write(json.dumps(obj) + "\n")
-                self.events.flush()
-        except Exception:
-            pass
-
-    def _sampler_stats(self, window_s: float) -> Stats:
-        if self.sampler is not None and hasattr(self.sampler, "win"):
-            try:
-                return getattr(self.sampler, "win").stats(window_s)
-            except Exception:
-                pass
-        return Stats(-100.0, -100.0, -100.0, -100.0, 0)
-
-    def _switch_sampler(self, reason: str) -> None:
-        try:
-            if self.sampler:
-                self.sampler.stop()
-        except Exception:
-            pass
-
-        picked = None
-        for _ in range(len(self._samplers)):
-            self._sampler_idx = (self._sampler_idx + 1) % max(1, len(self._samplers))
-            cand = self._samplers[self._sampler_idx]
-            try:
-                cand.start()
-            except Exception:
-                pass
-
-            t0 = time.time()
-            while time.time() - t0 < 2.8:
-                nm = cand.chosen_name()
-                if nm is not None:
-                    picked = cand
-                    break
-                try:
-                    if isinstance(cand, (LoopbackSampler_SD, StereoMixSampler_SD, LoopbackSampler_SC)):
-                        if cand.samples_recent(1.0):
-                            picked = cand
-                            break
-                except Exception:
-                    pass
-                time.sleep(0.2)
-
-            if picked is cand:
-                break
-
-            try:
-                cand.stop()
-            except Exception:
-                pass
-
-        self.sampler = picked
-        self._last_switch_ts = time.time()
-
-        if self.sampler:
-            logging.info("[Sampler] switched -> %s (%s)", self.sampler.chosen_name(), reason)
-            self._signal_state = f"SWITCH({reason})"
-        else:
-            logging.info("[Sampler] no viable sampler found (%s).", reason)
-            self._signal_state = "NO SAMPLER"
-
-    def _update_signal_health(self) -> None:
-        now = time.time()
-
-        if self.sampler is not None:
-            deg = getattr(self.sampler, "is_degraded", None)
-            if callable(deg):
-                try:
-                    if bool(deg()) and (now - self._last_switch_ts) >= self.SWITCH_COOLDOWN_S:
-                        self._signal_state = "DEGRADED"
-                        self._switch_sampler(reason="degraded")
-                        return
-                except Exception:
-                    pass
-
-        st = self._sampler_stats(1.5)
-        if st.n > 0:
-            self._last_sample_ts = now
-            if (
-                self._signal_state in ("INIT", "NO SAMPLES", "NO SAMPLER")
-                or self._signal_state.startswith("SWITCH")
-                or self._signal_state == "DEGRADED"
-            ):
-                self._signal_state = "LIVE"
-            return
-
-        if (now - self._last_sample_ts) > self.NO_SAMPLE_GRACE_S:
-            self._signal_state = "NO SAMPLES"
-            if (now - self._last_switch_ts) >= self.SWITCH_COOLDOWN_S:
-                self._switch_sampler(reason="no-samples")
-
-    def vol_set(self, new_scalar: float, why: str = "auto") -> None:
-        new_scalar = clamp(new_scalar, self.MIN_VOL, 1.0)
-        self.bk.set(new_scalar)
-        self.current = new_scalar
-        now = time.time()
-        self._last_set_ts = now
-        self._flash_duck_until = now + 2.2
-
-        self._write_event({
-            "ts": round(now, 3),
-            "type": "AUTO_SET",
-            "why": why,
-            "vol": round(new_scalar, 3),
-            "th_db": None if self._last_th is None else round(self._last_th, 2),
-            "p85_db": round(self._last_p85, 2),
-            "p95_db": round(self._last_p95, 2),
-            "signal": self._signal_state,
-            "sampler": self.sampler.chosen_name() if self.sampler else None,
-        })
-
-    def _on_user_change(self, ts: float, old: float, new: float):
-        if ts - self._last_set_ts <= self.IGNORE_OWN_SET_S:
-            return
-
-        self.resting = new
-        self.current = new
-
-        if self._paused.is_set():
-            return
-
-        st = self._sampler_stats(self.SHORT_WIN_S)
-        hour = time.localtime(ts).tm_hour
-        db_at = st.p85
-
-        self._write_event({
-            "ts": round(ts, 3),
-            "type": "USER_SET",
-            "hour": hour,
-            "dir": "DOWN" if new < old else "UP",
-            "p85_db": round(db_at, 2),
-            "old": round(old, 3),
-            "new": round(new, 3),
-            "signal": self._signal_state,
-            "sampler": self.sampler.chosen_name() if self.sampler else None,
-        })
-
-        if (
-            new < old
-            and st.n >= 1
-            and (ts - self._last_user_down_ts) > self.USER_DOWN_COOLDOWN_S
-        ):
-            self.learner.record_down(db_at, hour)
-            self._last_user_down_ts = ts
-            self._downs_total += 1
-            self.learner.save()
-
-    def start(self):
-        self.poll.start()
-        if self._thread:
-            return
-        self._thread = threading.Thread(target=self._run, name="AutoVolLoop", daemon=True)
-        self._thread.start()
-
-    def stop(self):
-        self._stop.set()
-        try:
-            self.poll.stop()
-        except Exception:
-            pass
-        try:
-            if isinstance(self.bk, WinVolSTA):
-                self.bk.close()
-        except Exception:
-            pass
-        try:
-            if self.sampler:
-                self.sampler.stop()
-        except Exception:
-            pass
-        try:
-            self.learner.save()
-            if self.events:
-                self.events.close()
-        except Exception:
-            pass
-        if self._thread:
-            self._thread.join(timeout=1.5)
-
-    def pause(self, do_pause: bool):
-        if do_pause:
-            self._paused.set()
-            if abs(self.current - self.resting) > 1e-3:
-                self.vol_set(self.resting, why="pause->restore")
-        else:
-            self._paused.clear()
-
-    def reset_learning(self):
-        try:
-            self.learner.reset()
-            self._downs_total = 0
-        except Exception:
-            pass
-
-    def open_data_folder(self, data_dir: str):
-        try:
-            if _WIN:
-                os.startfile(data_dir)  # type: ignore[attr-defined]
-            elif sys.platform == "darwin":
-                subprocess.Popen(["open", data_dir])
-            else:
-                subprocess.Popen(["xdg-open", data_dir])
-        except Exception:
-            pass
-
-    def stats_text_short(self) -> str:
-        mode = "P" if self._paused.is_set() else ("O" if self.observe_only or (time.time() - self._startup_ts < self.STARTUP_OBS_S) else "L")
-        th_txt = f"{self._last_th:.0f}" if self._last_th is not None else "—"
-        src = self.sampler.chosen_name() if self.sampler else "none"
-        return f"{self._signal_state} {mode} vol:{self.current:.2f} p85:{self._last_p85:.0f} th:{th_txt} d:{self._downs_total} ({src})"
-
-    def stats_text_long(self) -> str:
-        tag = "vad" if _HAVE_WEBRTCVAD else "lite"
-        th_txt = f"{self._last_th:.1f}dB" if (self._last_th is not None) else "—"
-        mode_txt = "PAUSED" if self._paused.is_set() else ("OBSERVE" if self.observe_only or (time.time() - self._startup_ts < self.STARTUP_OBS_S) else "LIVE")
-        duck_txt = " ↓" if (time.time() < self._flash_duck_until) else ""
-        src = self.sampler.chosen_name() if self.sampler else "none"
-        return f"{self._signal_state} | {mode_txt}{duck_txt} | downs:{self._downs_total} | p85:{self._last_p85:.1f} | p95:{self._last_p95:.1f} | th:{th_txt} | vol:{self.current:.2f} | sp:{self._speech:.2f}({tag}) | src:{src}"
-
-    def _maybe_promote_sampler(self, now: float) -> None:
-        # This method exists in some builds; keep it safe even if called.
-        if self._paused.is_set() or self._observe.is_set():
-            return
-
-    def _run(self):
-        last_save = time.time()
-
-        while not self._stop.is_set():
-            time.sleep(0.25)
-            now = time.time()
-
-            actual = self.bk.get()
-            if abs(actual - self.current) > 0.05:
-                self.resting = actual
-                self.current = actual
-
-            self._update_signal_health()
-            if self._signal_state in ("NO SAMPLER", "NO SAMPLES"):
-                continue
-
-            if self._paused.is_set() or self.observe_only or (now - self._startup_ts < self.STARTUP_OBS_S):
-                continue
-
-            if not self.sampler:
-                continue
-
-            base = self._sampler_stats(self.BASELINE_WIN_S)
-            cur = self._sampler_stats(self.SHORT_WIN_S)
-            self._last_p85 = cur.p85
-            self._last_p95 = cur.p95
-
-            if cur.n < 1:
-                continue
-
-            hour = time.localtime().tm_hour
-            th = self.learner.threshold(hour)
-            if th is None:
-                th = max(base.p70, -45.0) + 6.0
-            self._last_th = th
-
-            over85 = cur.p85 - th
-            if (now - self._last_set_ts) >= self.SET_COOLDOWN_S and over85 > self.OVER_MARGIN_DB:
-                step_db = clamp(over85 * 0.35, 0.25, self.ATTACK_DB_MAX)
-                self.vol_set(self.current * db_to_lin(-step_db), why="steady_over85")
-                continue
-
-            over95 = cur.p95 - th
-            if (now - self._last_set_ts) >= self.SET_COOLDOWN_S and over95 > (self.OVER_MARGIN_DB + 1.8):
-                step_db = clamp(over95 * 0.55, 0.6, 2.8)
-                self.vol_set(self.current * db_to_lin(-step_db), why="spike_over95")
-                continue
-
-            block = None
-            try:
-                block = self.sampler.get_last_block()
-            except Exception:
-                block = None
-
-            if block is not None and getattr(block, "size", 0) > 0:
-                sp_prob = self.vad.prob(block)
-                self._speech = 0.6 * sp_prob + 0.4 * self._speech
-
-                if (now - self._last_set_ts) >= self.SET_COOLDOWN_S:
-                    target = self.resting
-                    if self._speech >= 0.55:
-                        target = min(1.0, self.resting * db_to_lin(self.SPEECH_UP_DB))
-                    else:
-                        target = max(self.MIN_VOL, self.resting * db_to_lin(self.NOSPEECH_DOWN_DB))
-
-                    if abs(target - self.current) > 0.015:
-                        step_up = db_to_lin(self.RELEASE_DB_MAX)
-                        step_dn = db_to_lin(-self.RELEASE_DB_MAX)
-                        if target > self.current:
-                            new = min(target, self.current * step_up)
-                        else:
-                            new = max(target, self.current * step_dn)
-                        self.vol_set(new, why="speech_gate")
-            else:
-                self.vad.prob(None)
-                self._speech = 0.0
-
-            if now - last_save >= 25.0:
-                last_save = now
-                self.learner.save()
-
-
-# ------------------ tray ------------------
-
-def make_icon(color_fg=(255, 255, 255, 255), color_bg=(0, 0, 0, 0)) -> Image.Image:
-    W, H = 64, 64
-    img = Image.new("RGBA", (W, H), color_bg)
-    d = ImageDraw.Draw(img)
-    d.rectangle([12, 24, 24, 40], fill=color_fg)
-    d.polygon([(24, 24), (36, 16), (36, 48), (24, 40)], fill=color_fg)
-    d.arc([38, 18, 58, 46], start=315, end=45, width=3, fill=color_fg)
-    d.arc([42, 14, 62, 50], start=315, end=45, width=2, fill=color_fg)
-    return img
-
-
-def resolve_paths(model_filename: str, events_filename: str) -> Tuple[str, str, str]:
-    data_dir = _default_data_dir()
-    os.makedirs(data_dir, exist_ok=True)
-    model_path = model_filename if os.path.isabs(model_filename) else os.path.join(data_dir, model_filename)
-    events_path = events_filename if os.path.isabs(events_filename) else os.path.join(data_dir, events_filename)
-    return data_dir, model_path, events_path
-
-
-def run_tray():
-    ap = argparse.ArgumentParser(add_help=True)
-    ap.add_argument("--model", default="autovol_learn.json")
-    ap.add_argument("--events", default="autovol_events.jsonl")
-    ap.add_argument("--force-dryvol", action="store_true", help="don't touch system volume (debug)")
-    ap.add_argument("--observe", action="store_true", help="start in observe-only mode (no volume changes)")
-    ap.add_argument("--reset", action="store_true", help="reset learned downs before starting")
-    ap.add_argument("--no-autoinstall", action="store_true", help="disable auto-install of missing deps")
-    args = ap.parse_args()
-
-    data_dir, model_path, events_path = resolve_paths(args.model, args.events)
-    log_path = setup_logging(data_dir)
-    logging.info("Log file: %s", log_path)
-
-    ctl = AutoVolController(model_path=model_path, events_path=events_path, force_dryvol=args.force_dryvol)
-    if args.reset:
-        ctl.reset_learning()
-        logging.info("Learning reset.")
-    ctl.observe_only = bool(args.observe)
-    ctl.start()
-
-    icon_img = make_icon()
-    icon = pystray.Icon("AutoVol", icon=icon_img, title="AutoVol")
-
-    def update_title():
-        icon.title = safe_tooltip("AutoVol — " + ctl.stats_text_short())
-
-    def on_pause(_icon, _item):
-        ctl.pause(not ctl._paused.is_set())
-        update_title()
-
-    def on_toggle_observe(_icon, _item):
-        ctl.observe_only = not ctl.observe_only
-        update_title()
-
-    def on_reset(_icon, _item):
-        ctl.reset_learning()
-        update_title()
-
-    def on_open(_icon, _item):
-        ctl.open_data_folder(data_dir)
-
-    def on_quit(icon_obj, _item):
-        try:
-            ctl.stop()
-        finally:
-            icon_obj.stop()
-
-    menu = Menu(
-        Item(lambda _item: safe_tooltip("Status: " + ctl.stats_text_long(), max_len=120), None, enabled=False),
-        Item(lambda _item: "Observe only (no changes)", on_toggle_observe, checked=lambda _item: ctl.observe_only),
-        Item(lambda _item: "Resume" if ctl._paused.is_set() else "Pause", on_pause),
-        Item("Reset learning", on_reset),
-        Item("Open data folder", on_open),
-        Item("Quit", on_quit),
-    )
-    icon.menu = menu
-
-    def refresher():
-        while not ctl._stop.is_set():
-            update_title()
-            time.sleep(1.8)
-
-    threading.Thread(target=refresher, name="TrayRefresh", daemon=True).start()
-
-    logging.info("[AutoVol] tray up — check system tray.")
-    update_title()
-    icon.run()
-
-
-if __name__ == "__main__":
-    try:
-        run_tray()
-    except KeyboardInterrupt:
-        pass
-    except Exception as e:
-        try:
-            dd = _default_data_dir()
-            os.makedirs(dd, exist_ok=True)
-            with open(os.path.join(dd, "autovol_crash.txt"), "w", encoding="utf-8") as f:
-                f.write(repr(e) + "\n\n")
-                f.write(traceback.format_exc())
-        except Exception:
-            pass
-        raise