# Tray-Icon mit Einstellungs-Dialog — Implementierungsplan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** whisper-local erhält ein Windows-Tray-Icon mit 3 Zustandsfarben (Warten/Aufnahme/Transkription), Rechtsklick-Menü (Einstellungen/Beenden) und einem Einstellungs-Dialog für Hotkey und Mikrofon.

**Architecture:** Neues Package `whisper_local/tray/` mit Factory-Funktion `create_tray()` analog zu `create_listener()` und `create_inserter()`. Auf Linux gibt `create_tray()` ein No-Op-Stub zurück. Tray-Thread und tkinter-Dialog laufen in dedizierten Threads; Kommunikation mit dem asyncio-Loop via `call_soon_threadsafe` / `run_coroutine_threadsafe`.

**Tech Stack:** pystray, Pillow, tkinter, sv-ttk, darkdetect, ctypes (Win32), sounddevice (bereits vorhanden), pynput (bereits vorhanden)

---

## Dateiübersicht

| Aktion | Datei | Verantwortung |
|---|---|---|
| Ändern | `whisper_local/config.py` | `microphone`-Feld + `save_config()` |
| Ändern | `whisper_local/recorder.py` | `device`-Parameter für sounddevice |
| Ändern | `whisper_local/hotkey/__init__.py` | `stop()` im Protocol |
| Ändern | `whisper_local/hotkey/_pynput.py` | `stop()` implementieren |
| Ändern | `whisper_local/hotkey/_evdev.py` | `stop()` Stub für Protocol-Konformität |
| Ändern | `pyproject.toml` | Neue Windows-Abhängigkeiten |
| Erstellen | `whisper_local/tray/__init__.py` | `create_tray()`, `AppState` re-export |
| Erstellen | `whisper_local/tray/_icon.py` | Pillow-Icon-Generierung |
| Erstellen | `whisper_local/tray/_tray.py` | `AppState`, `NoOpTray`, `Win32TrayApp` |
| Erstellen | `whisper_local/tray/_theme.py` | System-Theme-Erkennung |
| Erstellen | `whisper_local/tray/_settings.py` | `SettingsDialog`, Konflikt-Erkennung |
| Ändern | `whisper_local/__main__.py` | Tray in `App` integrieren |
| Ändern | `tests/test_config.py` | Tests für `microphone` + `save_config` |
| Ändern | `tests/test_recorder.py` | Test für `device`-Parameter |
| Ändern | `tests/test_hotkey.py` | Tests für `stop()` |
| Erstellen | `tests/test_tray.py` | Alle Tray-Tests |
| Ändern | `tests/test_main.py` | `create_tray` mocken, Tray-Callbacks testen |

---

## Task 1: Config — `microphone`-Feld + `save_config()`

**Files:**
- Modify: `whisper_local/config.py`
- Modify: `tests/test_config.py`

- [ ] **Schritt 1: Fehlschlagenden Test schreiben**

Ans Ende von `tests/test_config.py` anfügen:

```python
class TestMicrophoneConfig:
    def test_default_microphone_is_empty(self):
        config = Config()
        assert config.microphone == ""

    def test_load_device_from_toml(self, tmp_path):
        config_file = tmp_path / "config.toml"
        config_file.write_text('[audio]\ndevice = "Headset Mic"\n')
        config = load_config(config_file)
        assert config.microphone == "Headset Mic"


class TestSaveConfig:
    def test_save_and_reload(self, tmp_path):
        from whisper_local.config import save_config
        path = tmp_path / "config.toml"
        config = Config(hotkey="KEY_F8", microphone="USB Mic")
        save_config(config, path)
        loaded = load_config(path)
        assert loaded.hotkey == "KEY_F8"
        assert loaded.microphone == "USB Mic"

    def test_save_creates_parent_dirs(self, tmp_path):
        from whisper_local.config import save_config
        path = tmp_path / "subdir" / "config.toml"
        save_config(Config(), path)
        assert path.exists()
```

- [ ] **Schritt 2: Test ausführen — muss scheitern**

```
uv run pytest tests/test_config.py::TestMicrophoneConfig tests/test_config.py::TestSaveConfig -v
```

Erwartet: FAIL — `Config` hat kein `microphone`, `save_config` existiert nicht.

- [ ] **Schritt 3: Implementierung**

`whisper_local/config.py` — `Config`-Dataclass und `load_config` und neue Funktion `save_config`:

```python
@dataclass
class Config:
    hotkey: str = "KEY_F12"
    whisper_model: str = "small"
    language: str = "de"
    compute_type: str = "int8"
    sample_rate: int = 16000
    channels: int = 1
    min_duration: float = 0.5
    microphone: str = ""
```

In `load_config`, nach dem `audio_section`-Block ergänzen:

```python
    if "device" in audio_section:
        config.microphone = audio_section["device"]
```

Neue Funktion am Ende der Datei:

```python
def save_config(config: Config, path: Path = DEFAULT_CONFIG_PATH) -> None:
    """Schreibt Config als TOML-Datei. Erstellt Verzeichnisse bei Bedarf."""
    path.parent.mkdir(parents=True, exist_ok=True)
    content = (
        f'[hotkey]\nkey = "{config.hotkey}"\n\n'
        f'[whisper]\nmodel = "{config.whisper_model}"\n'
        f'language = "{config.language}"\n'
        f'compute_type = "{config.compute_type}"\n\n'
        f'[audio]\nsample_rate = {config.sample_rate}\n'
        f'channels = {config.channels}\n'
        f'min_duration = {config.min_duration}\n'
        f'device = "{config.microphone}"\n'
    )
    path.write_text(content, encoding="utf-8")
```

- [ ] **Schritt 4: Tests ausführen — müssen bestehen**

```
uv run pytest tests/test_config.py -v
```

Erwartet: alle PASS.

- [ ] **Schritt 5: Commit**

```bash
git add whisper_local/config.py tests/test_config.py
git commit -m "feat: add microphone field and save_config to Config"
```

---

## Task 2: Recorder — `device`-Parameter

**Files:**
- Modify: `whisper_local/recorder.py`
- Modify: `tests/test_recorder.py`

- [ ] **Schritt 1: Fehlschlagenden Test schreiben**

Ans Ende von `tests/test_recorder.py` anfügen:

```python
    def test_device_passed_to_inputstream(self):
        recorder = Recorder(sample_rate=16000, channels=1, min_duration=0.0, device="USB Mic")
        with patch("sounddevice.InputStream") as mock_cls:
            mock_cls.return_value = MagicMock()
            recorder.start()
            call_kwargs = mock_cls.call_args.kwargs
            assert call_kwargs["device"] == "USB Mic"
            recorder.stop()

    def test_default_device_is_none(self):
        recorder = Recorder()
        assert recorder.device is None
```

- [ ] **Schritt 2: Test ausführen — muss scheitern**

```
uv run pytest tests/test_recorder.py::TestRecorder::test_device_passed_to_inputstream tests/test_recorder.py::TestRecorder::test_default_device_is_none -v
```

Erwartet: FAIL — `Recorder` kennt kein `device`.

- [ ] **Schritt 3: Implementierung**

`whisper_local/recorder.py`:

```python
class Recorder:
    def __init__(
        self,
        sample_rate: int = 16000,
        channels: int = 1,
        min_duration: float = 0.5,
        device: str | None = None,
    ):
        self.sample_rate = sample_rate
        self.channels = channels
        self.min_duration = min_duration
        self.device = device
        self.is_recording = False
        self._chunks: list[np.ndarray] = []
        self._stream: sd.InputStream | None = None
```

In `start()` den `InputStream`-Aufruf um `device=self.device` ergänzen:

```python
        self._stream = sd.InputStream(
            samplerate=self.sample_rate,
            channels=self.channels,
            dtype=np.float32,
            callback=self._audio_callback,
            device=self.device,
        )
```

- [ ] **Schritt 4: Tests ausführen — müssen bestehen**

```
uv run pytest tests/test_recorder.py -v
```

Erwartet: alle PASS.

- [ ] **Schritt 5: Commit**

```bash
git add whisper_local/recorder.py tests/test_recorder.py
git commit -m "feat: add optional device parameter to Recorder"
```

---

## Task 3: HotkeyListener — `stop()`-Methode

**Files:**
- Modify: `whisper_local/hotkey/__init__.py`
- Modify: `whisper_local/hotkey/_pynput.py`
- Modify: `whisper_local/hotkey/_evdev.py`
- Modify: `tests/test_hotkey.py`

- [ ] **Schritt 1: Fehlschlagenden Test schreiben**

Ans Ende von `tests/test_hotkey.py` anfügen:

```python
class TestPynputHotkeyListenerStop:
    @pytest.mark.asyncio
    async def test_stop_ends_listen(self):
        from whisper_local.hotkey._pynput import PynputHotkeyListener
        from unittest.mock import patch, MagicMock
        listener = PynputHotkeyListener("KEY_F12")

        with patch("whisper_local.hotkey._pynput.Listener") as mock_listener_cls:
            mock_listener_cls.return_value = MagicMock()
            listen_task = asyncio.create_task(listener.listen())
            await asyncio.sleep(0)   # Loop einen Schritt weiter
            listener.stop()
            await asyncio.wait_for(listen_task, timeout=1.0)
```

- [ ] **Schritt 2: Test ausführen — muss scheitern**

```
uv run pytest tests/test_hotkey.py::TestPynputHotkeyListenerStop -v
```

Erwartet: FAIL — `PynputHotkeyListener` hat keine `stop()`-Methode.

- [ ] **Schritt 3: Protocol aktualisieren**

`whisper_local/hotkey/__init__.py`:

```python
@runtime_checkable
class HotkeyListener(Protocol):
    on_press: AsyncCallback | None
    on_release: AsyncCallback | None

    async def listen(self) -> None: ...
    def stop(self) -> None: ...
```

- [ ] **Schritt 4: PynputHotkeyListener aktualisieren**

`whisper_local/hotkey/_pynput.py` — `__init__` und `listen` und neue Methode `stop`:

```python
class PynputHotkeyListener:
    def __init__(self, key_name: str = "KEY_F12"):
        self.key_name = key_name
        self._target_key = _evdev_to_pynput_key(key_name)
        self.on_press: AsyncCallback | None = None
        self.on_release: AsyncCallback | None = None
        self._loop: asyncio.AbstractEventLoop | None = None
        self._pressed = False
        self._stop_event: asyncio.Event | None = None

    def stop(self) -> None:
        """Signalisiert dem listen()-Loop zu beenden."""
        if self._loop is not None and self._stop_event is not None:
            self._loop.call_soon_threadsafe(self._stop_event.set)

    async def listen(self) -> None:
        self._loop = asyncio.get_running_loop()
        self._stop_event = asyncio.Event()

        listener = Listener(on_press=self._on_press, on_release=self._on_release)
        listener.start()
        logger.info("Lausche auf %s via pynput", self.key_name)

        try:
            await self._stop_event.wait()
        finally:
            listener.stop()
```

- [ ] **Schritt 5: EvdevHotkeyListener Stub hinzufügen**

`whisper_local/hotkey/_evdev.py` — `stop()`-Stub für Protocol-Konformität:

```python
    def stop(self) -> None:
        """Stub — evdev-Listener läuft bis zum Prozessende."""
        pass
```

- [ ] **Schritt 6: Tests ausführen — müssen bestehen**

```
uv run pytest tests/test_hotkey.py -v
```

Erwartet: alle PASS.

- [ ] **Schritt 7: Commit**

```bash
git add whisper_local/hotkey/__init__.py whisper_local/hotkey/_pynput.py whisper_local/hotkey/_evdev.py tests/test_hotkey.py
git commit -m "feat: add stop() method to HotkeyListener protocol and PynputHotkeyListener"
```

---

## Task 4: Abhängigkeiten

**Files:**
- Modify: `pyproject.toml`

- [ ] **Schritt 1: `pyproject.toml` aktualisieren**

Im `dependencies`-Array ergänzen (nach `pywin32`-Zeile):

```toml
dependencies = [
    "faster-whisper>=1.1.0",
    "sounddevice>=0.5.0",
    "numpy>=2.0.0",
    "evdev>=1.7.0; sys_platform == 'linux'",
    "pynput>=1.7.0; sys_platform == 'win32'",
    "pywin32>=306; sys_platform == 'win32'",
    "pystray>=0.19.0; sys_platform == 'win32'",
    "Pillow>=10.0.0; sys_platform == 'win32'",
    "sv-ttk>=2.6.0; sys_platform == 'win32'",
    "darkdetect>=0.8.0; sys_platform == 'win32'",
]
```

- [ ] **Schritt 2: Lock-Datei aktualisieren**

```
uv lock
```

Erwartet: `uv.lock` wird aktualisiert, kein Fehler.

- [ ] **Schritt 3: Commit**

```bash
git add pyproject.toml uv.lock
git commit -m "build: add pystray, Pillow, sv-ttk, darkdetect as Windows dependencies"
```

---

## Task 5: `_icon.py` — Icon-Generierung

**Files:**
- Create: `whisper_local/tray/__init__.py` (leer)
- Create: `whisper_local/tray/_icon.py`
- Create: `tests/test_tray.py`

- [ ] **Schritt 1: Leeres Package anlegen**

`whisper_local/tray/__init__.py` mit leerem Inhalt erstellen (wird in Task 10 befüllt).

- [ ] **Schritt 2: Fehlschlagenden Test schreiben**

`tests/test_tray.py` erstellen:

```python
import sys
import pytest


@pytest.mark.skipif(sys.platform != "win32", reason="Tray nur auf Windows")
class TestCreateIcon:
    def test_returns_image_for_each_state(self):
        from PIL import Image
        from whisper_local.tray._tray import AppState
        from whisper_local.tray._icon import create_icon

        for state in AppState:
            img = create_icon(state)
            assert isinstance(img, Image.Image)
            assert img.size == (64, 64)
            assert img.mode == "RGBA"

    def test_different_states_have_different_colors(self):
        from whisper_local.tray._tray import AppState
        from whisper_local.tray._icon import create_icon

        waiting = create_icon(AppState.WAITING)
        recording = create_icon(AppState.RECORDING)
        assert waiting.tobytes() != recording.tobytes()
```

- [ ] **Schritt 3: Test ausführen — muss scheitern**

```
uv run pytest tests/test_tray.py::TestCreateIcon -v
```

Erwartet: FAIL — Module nicht vorhanden.

- [ ] **Schritt 4: `_tray.py` — AppState-Enum anlegen** (wird in Task 6 vervollständigt)

`whisper_local/tray/_tray.py` erstellen — nur den Enum, damit `_icon.py` importieren kann:

```python
"""Tray-App und App-Zustände für whisper-local (Windows)."""

import enum


class AppState(enum.Enum):
    WAITING = "waiting"
    RECORDING = "recording"
    TRANSCRIBING = "transcribing"
```

- [ ] **Schritt 5: `_icon.py` implementieren**

`whisper_local/tray/_icon.py` erstellen:

```python
"""Programmatische Icon-Generierung via Pillow."""

from PIL import Image, ImageDraw

from whisper_local.tray._tray import AppState

_STATE_COLORS: dict[AppState, tuple[int, int, int]] = {
    AppState.WAITING: (150, 150, 150),
    AppState.RECORDING: (220, 50, 50),
    AppState.TRANSCRIBING: (220, 180, 0),
}


def create_icon(state: AppState, size: int = 64) -> Image.Image:
    """Erzeugt ein Mikrofon-Icon in der Farbe des übergebenen Zustands."""
    color = _STATE_COLORS[state]
    img = Image.new("RGBA", (size, size), (0, 0, 0, 0))
    draw = ImageDraw.Draw(img)

    cx = size // 2
    bw = max(4, size // 6)   # Hälfte der Körperbreite
    top = size // 8
    mid = size // 2

    # Mikrofon-Körper (abgerundetes Rechteck)
    draw.rounded_rectangle(
        [cx - bw, top, cx + bw, mid + bw],
        radius=bw,
        fill=color,
    )

    # Bogen (Stativ-Bogen)
    arc_r = size // 4
    arc_top = mid
    lw = max(2, size // 20)
    draw.arc(
        [cx - arc_r, arc_top, cx + arc_r, arc_top + arc_r],
        start=0, end=180, fill=color, width=lw,
    )

    # Stiel
    pole_top = arc_top + arc_r // 2
    pole_bot = size - size // 8
    draw.line([cx, pole_top, cx, pole_bot], fill=color, width=lw)

    # Sockel
    base = size // 5
    draw.line([cx - base, pole_bot, cx + base, pole_bot], fill=color, width=lw)

    return img
```

- [ ] **Schritt 6: Tests ausführen — müssen bestehen**

```
uv run pytest tests/test_tray.py::TestCreateIcon -v
```

Erwartet: alle PASS (oder skip auf Linux).

- [ ] **Schritt 7: Commit**

```bash
git add whisper_local/tray/__init__.py whisper_local/tray/_tray.py whisper_local/tray/_icon.py tests/test_tray.py
git commit -m "feat: add AppState enum and programmatic tray icon generation"
```

---

## Task 6: `_tray.py` — `Win32TrayApp` + `NoOpTray`

**Files:**
- Modify: `whisper_local/tray/_tray.py`
- Modify: `tests/test_tray.py`

- [ ] **Schritt 1: Fehlschlagenden Test schreiben**

In `tests/test_tray.py` ergänzen:

```python
@pytest.mark.skipif(sys.platform != "win32", reason="Tray nur auf Windows")
class TestWin32TrayApp:
    def test_set_state_updates_icon(self):
        from unittest.mock import MagicMock, patch
        from whisper_local.tray._tray import AppState, Win32TrayApp

        app = Win32TrayApp(on_settings=MagicMock(), on_quit=MagicMock())

        mock_icon = MagicMock()
        app._icon = mock_icon

        app.set_state(AppState.RECORDING)

        assert mock_icon.icon is not None

    def test_set_state_before_start_is_safe(self):
        from unittest.mock import MagicMock
        from whisper_local.tray._tray import AppState, Win32TrayApp

        app = Win32TrayApp(on_settings=MagicMock(), on_quit=MagicMock())
        app.set_state(AppState.WAITING)  # kein Fehler, _icon ist None


class TestNoOpTray:
    def test_start_does_nothing(self):
        from whisper_local.tray._tray import AppState, NoOpTray
        tray = NoOpTray()
        tray.start()  # kein Fehler

    def test_set_state_does_nothing(self):
        from whisper_local.tray._tray import AppState, NoOpTray
        tray = NoOpTray()
        tray.set_state(AppState.RECORDING)  # kein Fehler
```

- [ ] **Schritt 2: Test ausführen — muss scheitern**

```
uv run pytest tests/test_tray.py::TestWin32TrayApp tests/test_tray.py::TestNoOpTray -v
```

Erwartet: FAIL — `Win32TrayApp` und `NoOpTray` nicht vorhanden.

- [ ] **Schritt 3: `_tray.py` vervollständigen**

`whisper_local/tray/_tray.py` komplett ersetzen:

```python
"""Tray-App und App-Zustände für whisper-local (Windows)."""

import enum
import sys
import threading
from typing import Callable


class AppState(enum.Enum):
    WAITING = "waiting"
    RECORDING = "recording"
    TRANSCRIBING = "transcribing"


class Win32TrayApp:
    """Tray-Icon via pystray für Windows."""

    def __init__(self, on_settings: Callable[[], None], on_quit: Callable[[], None]):
        self._on_settings = on_settings
        self._on_quit = on_quit
        self._icon = None

    def start(self) -> None:
        """Startet pystray in einem Daemon-Thread."""
        import pystray
        from whisper_local.tray._icon import create_icon

        menu = pystray.Menu(
            pystray.MenuItem("Einstellungen", self._menu_settings),
            pystray.MenuItem("Beenden", self._menu_quit),
        )
        self._icon = pystray.Icon(
            "whisper-local",
            create_icon(AppState.WAITING),
            "whisper-local",
            menu,
        )
        thread = threading.Thread(target=self._icon.run, daemon=True)
        thread.start()

    def set_state(self, state: AppState) -> None:
        """Tauscht das Icon aus (thread-sicher)."""
        if self._icon is not None:
            from whisper_local.tray._icon import create_icon
            self._icon.icon = create_icon(state)

    def _menu_settings(self, icon, item) -> None:
        self._on_settings()

    def _menu_quit(self, icon, item) -> None:
        if self._icon is not None:
            self._icon.stop()
        self._on_quit()


class NoOpTray:
    """Platzhalter-Implementierung für nicht-Windows-Plattformen."""

    def start(self) -> None:
        pass

    def set_state(self, state: AppState) -> None:
        pass
```

- [ ] **Schritt 4: Tests ausführen — müssen bestehen**

```
uv run pytest tests/test_tray.py -v
```

Erwartet: alle PASS (Windows), Skips auf Linux.

- [ ] **Schritt 5: Commit**

```bash
git add whisper_local/tray/_tray.py tests/test_tray.py
git commit -m "feat: add Win32TrayApp and NoOpTray with state management"
```

---

## Task 7: `_theme.py` — System-Theme-Erkennung

**Files:**
- Create: `whisper_local/tray/_theme.py`
- Modify: `tests/test_tray.py`

- [ ] **Schritt 1: Fehlschlagenden Test schreiben**

In `tests/test_tray.py` ergänzen:

```python
@pytest.mark.skipif(sys.platform != "win32", reason="Theme nur auf Windows")
class TestApplySystemTheme:
    def test_applies_light_theme(self):
        import tkinter as tk
        from unittest.mock import patch, MagicMock
        from whisper_local.tray._theme import apply_system_theme

        root = tk.Tk()
        root.withdraw()
        try:
            with patch("darkdetect.theme", return_value="Light"), \
                 patch("sv_ttk.set_theme") as mock_set:
                apply_system_theme(root)
                mock_set.assert_called_once_with("light")
        finally:
            root.destroy()

    def test_applies_dark_theme(self):
        import tkinter as tk
        from unittest.mock import patch
        from whisper_local.tray._theme import apply_system_theme

        root = tk.Tk()
        root.withdraw()
        try:
            with patch("darkdetect.theme", return_value="Dark"), \
                 patch("sv_ttk.set_theme") as mock_set:
                apply_system_theme(root)
                mock_set.assert_called_once_with("dark")
        finally:
            root.destroy()

    def test_falls_back_to_light_when_none(self):
        import tkinter as tk
        from unittest.mock import patch
        from whisper_local.tray._theme import apply_system_theme

        root = tk.Tk()
        root.withdraw()
        try:
            with patch("darkdetect.theme", return_value=None), \
                 patch("sv_ttk.set_theme") as mock_set:
                apply_system_theme(root)
                mock_set.assert_called_once_with("light")
        finally:
            root.destroy()
```

- [ ] **Schritt 2: Test ausführen — muss scheitern**

```
uv run pytest tests/test_tray.py::TestApplySystemTheme -v
```

Erwartet: FAIL — `_theme.py` nicht vorhanden.

- [ ] **Schritt 3: `_theme.py` implementieren**

`whisper_local/tray/_theme.py` erstellen:

```python
"""System-Theme-Erkennung und sv-ttk-Anwendung."""

import tkinter as tk


def apply_system_theme(root: tk.Tk) -> None:
    """Setzt sv-ttk-Theme passend zum Windows-System-Theme (Light/Dark)."""
    import darkdetect
    import sv_ttk

    detected = darkdetect.theme() or "Light"
    sv_ttk.set_theme(detected.lower())
```

- [ ] **Schritt 4: Tests ausführen — müssen bestehen**

```
uv run pytest tests/test_tray.py::TestApplySystemTheme -v
```

Erwartet: alle PASS.

- [ ] **Schritt 5: Commit**

```bash
git add whisper_local/tray/_theme.py tests/test_tray.py
git commit -m "feat: add system theme detection for sv-ttk"
```

---

## Task 8: `_settings.py` — Hilfsfunktionen

**Files:**
- Create: `whisper_local/tray/_settings.py`
- Modify: `tests/test_tray.py`

- [ ] **Schritt 1: Fehlschlagenden Test schreiben**

In `tests/test_tray.py` ergänzen:

```python
@pytest.mark.skipif(sys.platform != "win32", reason="Settings nur auf Windows")
class TestCheckHotkeyConflict:
    def test_returns_false_when_key_is_free(self):
        from unittest.mock import patch, MagicMock
        from whisper_local.tray._settings import check_hotkey_conflict

        mock_user32 = MagicMock()
        mock_user32.RegisterHotKey.return_value = 1  # Erfolg
        with patch("ctypes.windll") as mock_windll:
            mock_windll.user32 = mock_user32
            result = check_hotkey_conflict("KEY_F12")
        assert result is False
        mock_user32.UnregisterHotKey.assert_called_once()

    def test_returns_true_when_key_is_taken(self):
        from unittest.mock import patch, MagicMock
        from whisper_local.tray._settings import check_hotkey_conflict

        mock_user32 = MagicMock()
        mock_user32.RegisterHotKey.return_value = 0  # Belegt
        with patch("ctypes.windll") as mock_windll:
            mock_windll.user32 = mock_user32
            result = check_hotkey_conflict("KEY_F12")
        assert result is True
        mock_user32.UnregisterHotKey.assert_not_called()

    def test_returns_false_for_unknown_key(self):
        from whisper_local.tray._settings import check_hotkey_conflict
        result = check_hotkey_conflict("KEY_NONEXISTENT_999")
        assert result is False


class TestListMicrophones:
    def test_returns_only_input_devices(self):
        from unittest.mock import patch
        from whisper_local.tray._settings import list_microphones

        fake_devices = [
            {"name": "Speakers", "max_input_channels": 0},
            {"name": "Headset Mic", "max_input_channels": 1},
            {"name": "USB Mic", "max_input_channels": 2},
        ]
        with patch("sounddevice.query_devices", return_value=fake_devices):
            result = list_microphones()
        assert result == [("Headset Mic", 1), ("USB Mic", 2)]

    def test_returns_empty_list_when_no_input(self):
        from unittest.mock import patch
        from whisper_local.tray._settings import list_microphones

        with patch("sounddevice.query_devices", return_value=[]):
            result = list_microphones()
        assert result == []


class TestPynputToEvdevKey:
    def test_function_key(self):
        from pynput.keyboard import Key
        from whisper_local.tray._settings import pynput_to_evdev_key
        assert pynput_to_evdev_key(Key.f12) == "KEY_F12"

    def test_space_key(self):
        from pynput.keyboard import Key
        from whisper_local.tray._settings import pynput_to_evdev_key
        assert pynput_to_evdev_key(Key.space) == "KEY_SPACE"

    def test_char_key(self):
        from pynput.keyboard import KeyCode
        from whisper_local.tray._settings import pynput_to_evdev_key
        key = KeyCode.from_char("a")
        assert pynput_to_evdev_key(key) == "KEY_A"

    def test_unknown_returns_empty(self):
        from whisper_local.tray._settings import pynput_to_evdev_key
        assert pynput_to_evdev_key(None) == ""
```

- [ ] **Schritt 2: Test ausführen — muss scheitern**

```
uv run pytest tests/test_tray.py::TestCheckHotkeyConflict tests/test_tray.py::TestListMicrophones tests/test_tray.py::TestPynputToEvdevKey -v
```

Erwartet: FAIL — `_settings.py` nicht vorhanden.

- [ ] **Schritt 3: Hilfsfunktionen implementieren**

`whisper_local/tray/_settings.py` erstellen (nur Hilfsfunktionen, Dialog folgt in Task 9):

```python
"""Einstellungs-Dialog für whisper-local (Windows)."""

from __future__ import annotations

import ctypes
import threading
from typing import Callable

import sounddevice as sd

from whisper_local.config import Config, save_config


def pynput_to_evdev_key(key) -> str:
    """Konvertiert pynput-Key zu evdev-Key-Namen (z.B. Key.f12 → 'KEY_F12')."""
    from pynput.keyboard import Key, KeyCode

    if isinstance(key, Key):
        return f"KEY_{key.name.upper()}"
    if isinstance(key, KeyCode) and key.char:
        return f"KEY_{key.char.upper()}"
    return ""


def check_hotkey_conflict(evdev_name: str) -> bool:
    """Gibt True zurück wenn die Taste per Win32-RegisterHotKey belegt ist."""
    from whisper_local.hotkey._pynput import _evdev_to_pynput_key
    from pynput.keyboard import Key

    try:
        pynput_key = _evdev_to_pynput_key(evdev_name)
    except ValueError:
        return False

    if not isinstance(pynput_key, Key):
        return False

    vk = getattr(pynput_key.value, "vk", None)
    if vk is None:
        return False

    HOTKEY_ID = 0x7FFF
    user32 = ctypes.windll.user32
    if user32.RegisterHotKey(None, HOTKEY_ID, 0, vk):
        user32.UnregisterHotKey(None, HOTKEY_ID)
        return False
    return True


def list_microphones() -> list[tuple[str, int]]:
    """Gibt Liste aller Eingabegeräte als (name, index) zurück."""
    devices = sd.query_devices()
    return [
        (dev["name"], idx)
        for idx, dev in enumerate(devices)
        if dev["max_input_channels"] > 0
    ]
```

- [ ] **Schritt 4: Tests ausführen — müssen bestehen**

```
uv run pytest tests/test_tray.py::TestCheckHotkeyConflict tests/test_tray.py::TestListMicrophones tests/test_tray.py::TestPynputToEvdevKey -v
```

Erwartet: alle PASS.

- [ ] **Schritt 5: Commit**

```bash
git add whisper_local/tray/_settings.py tests/test_tray.py
git commit -m "feat: add hotkey conflict detection and microphone listing helpers"
```

---

## Task 9: `_settings.py` — SettingsDialog

**Files:**
- Modify: `whisper_local/tray/_settings.py`
- Modify: `tests/test_tray.py`

- [ ] **Schritt 1: Fehlschlagenden Test schreiben**

In `tests/test_tray.py` ergänzen:

```python
@pytest.mark.skipif(sys.platform != "win32", reason="Settings nur auf Windows")
class TestSettingsDialog:
    def test_on_save_called_with_new_config(self):
        import tkinter as tk
        from unittest.mock import patch, MagicMock, call
        from whisper_local.config import Config
        from whisper_local.tray._settings import SettingsDialog

        saved = []
        dialog = SettingsDialog(
            config=Config(hotkey="KEY_F12", microphone=""),
            on_save=saved.append,
        )

        # Dialog direkt aufrufen (nicht in Thread), mit gemocktem mainloop
        with patch("tkinter.Tk.mainloop"), \
             patch("whisper_local.tray._settings.apply_system_theme"), \
             patch("whisper_local.tray._settings.list_microphones", return_value=[]), \
             patch("whisper_local.tray._settings.save_config") as mock_save:
            dialog._run()

        # _run() ruft mainloop auf, der sofort zurückkehrt.
        # save() wird nicht automatisch aufgerufen — das ist korrekt.
        # Wir prüfen nur, dass _run() ohne Fehler durchläuft.
        assert mock_save.call_count == 0  # Noch nicht gespeichert ohne Klick

    def test_on_save_callback_called_when_save_invoked(self):
        import tkinter as tk
        from unittest.mock import patch, MagicMock
        from whisper_local.config import Config
        from whisper_local.tray._settings import SettingsDialog

        saved_configs = []
        dialog = SettingsDialog(
            config=Config(hotkey="KEY_F12", microphone=""),
            on_save=saved_configs.append,
        )

        # _run() intern aufrufen und save() direkt triggern
        captured_save_fn = []

        def fake_button(frame, text, command, **kwargs):
            if text == "Speichern":
                captured_save_fn.append(command)
            mock = MagicMock()
            mock.pack = MagicMock()
            return mock

        with patch("tkinter.Tk.mainloop"), \
             patch("whisper_local.tray._settings.apply_system_theme"), \
             patch("whisper_local.tray._settings.list_microphones", return_value=[("USB Mic", 0)]), \
             patch("whisper_local.tray._settings.save_config"), \
             patch("tkinter.ttk.Button", side_effect=fake_button):
            dialog._run()

        if captured_save_fn:
            captured_save_fn[0]()
            assert len(saved_configs) == 1
```

- [ ] **Schritt 2: Test ausführen — muss scheitern**

```
uv run pytest tests/test_tray.py::TestSettingsDialog -v
```

Erwartet: FAIL — `SettingsDialog` nicht vorhanden.

- [ ] **Schritt 3: SettingsDialog implementieren**

`whisper_local/tray/_settings.py` — `SettingsDialog`-Klasse am Ende der Datei ergänzen:

```python
class SettingsDialog:
    """Einstellungs-Dialog (läuft in eigenem Thread)."""

    def __init__(self, config: Config, on_save: Callable[[Config], None]):
        self._config = config
        self._on_save = on_save

    def open(self) -> None:
        """Öffnet den Dialog in einem Daemon-Thread."""
        thread = threading.Thread(target=self._run, daemon=True)
        thread.start()

    def _run(self) -> None:
        import tkinter as tk
        from tkinter import ttk
        from whisper_local.tray._theme import apply_system_theme

        root = tk.Tk()
        root.title("whisper-local – Einstellungen")
        root.resizable(False, False)
        apply_system_theme(root)

        frame = ttk.Frame(root, padding=16)
        frame.pack(fill=tk.BOTH, expand=True)

        # --- Hotkey ---
        ttk.Label(frame, text="Hotkey").grid(row=0, column=0, sticky=tk.W, pady=4)
        hotkey_var = tk.StringVar(value=self._config.hotkey)
        ttk.Label(frame, textvariable=hotkey_var, width=14, relief="sunken").grid(
            row=0, column=1, padx=8
        )

        conflict_var = tk.StringVar()
        ttk.Label(frame, textvariable=conflict_var, foreground="orange").grid(
            row=1, column=0, columnspan=3, sticky=tk.W
        )

        def record_hotkey():
            hotkey_var.set("...")
            conflict_var.set("")

            captured: list[str] = []

            def on_press(key):
                evdev = pynput_to_evdev_key(key)
                if evdev:
                    captured.append(evdev)
                return False  # Listener stoppen

            def listen():
                from pynput.keyboard import Listener
                with Listener(on_press=on_press) as lst:
                    lst.join()
                if captured:
                    evdev = captured[0]
                    root.after(0, lambda: hotkey_var.set(evdev))
                    if check_hotkey_conflict(evdev):
                        root.after(
                            0,
                            lambda: conflict_var.set(
                                "⚠ Taste ist von einer anderen App belegt (Win32-Hotkeys)"
                            ),
                        )

            threading.Thread(target=listen, daemon=True).start()

        ttk.Button(frame, text="Aufzeichnen", command=record_hotkey).grid(
            row=0, column=2, padx=4
        )

        # --- Mikrofon ---
        ttk.Label(frame, text="Mikrofon").grid(row=2, column=0, sticky=tk.W, pady=4)
        mics = list_microphones()
        mic_names = ["Standard"] + [name for name, _ in mics]
        current_mic = self._config.microphone or "Standard"
        mic_var = tk.StringVar(value=current_mic)
        ttk.Combobox(
            frame, textvariable=mic_var, values=mic_names, state="readonly", width=32
        ).grid(row=2, column=1, columnspan=2, sticky=tk.W, padx=4)

        # --- Buttons ---
        btn_frame = ttk.Frame(frame)
        btn_frame.grid(row=3, column=0, columnspan=3, pady=12, sticky=tk.E)

        def save():
            new_config = Config(
                hotkey=hotkey_var.get(),
                whisper_model=self._config.whisper_model,
                language=self._config.language,
                compute_type=self._config.compute_type,
                sample_rate=self._config.sample_rate,
                channels=self._config.channels,
                min_duration=self._config.min_duration,
                microphone="" if mic_var.get() == "Standard" else mic_var.get(),
            )
            save_config(new_config)
            self._on_save(new_config)
            root.destroy()

        ttk.Button(btn_frame, text="Speichern", command=save).pack(side=tk.RIGHT, padx=4)
        ttk.Button(btn_frame, text="Abbrechen", command=root.destroy).pack(side=tk.RIGHT)

        root.mainloop()
```

- [ ] **Schritt 4: Tests ausführen — müssen bestehen**

```
uv run pytest tests/test_tray.py::TestSettingsDialog -v
```

Erwartet: alle PASS.

- [ ] **Schritt 5: Commit**

```bash
git add whisper_local/tray/_settings.py tests/test_tray.py
git commit -m "feat: add SettingsDialog with hotkey recording and microphone selection"
```

---

## Task 10: `tray/__init__.py` — Factory `create_tray()`

**Files:**
- Modify: `whisper_local/tray/__init__.py`
- Modify: `tests/test_tray.py`

- [ ] **Schritt 1: Fehlschlagenden Test schreiben**

In `tests/test_tray.py` ergänzen:

```python
class TestCreateTray:
    @pytest.mark.skipif(sys.platform != "win32", reason="Win32TrayApp nur auf Windows")
    def test_returns_win32_tray_on_windows(self):
        from unittest.mock import MagicMock
        from whisper_local.tray import create_tray
        from whisper_local.tray._tray import Win32TrayApp

        tray = create_tray(on_settings=MagicMock(), on_quit=MagicMock())
        assert isinstance(tray, Win32TrayApp)

    @pytest.mark.skipif(sys.platform == "win32", reason="NoOpTray nur auf nicht-Windows")
    def test_returns_noop_tray_on_non_windows(self):
        from unittest.mock import MagicMock
        from whisper_local.tray import create_tray
        from whisper_local.tray._tray import NoOpTray

        tray = create_tray(on_settings=MagicMock(), on_quit=MagicMock())
        assert isinstance(tray, NoOpTray)

    def test_appstate_exported_from_package(self):
        from whisper_local.tray import AppState
        assert AppState.WAITING is not None
        assert AppState.RECORDING is not None
        assert AppState.TRANSCRIBING is not None
```

- [ ] **Schritt 2: Test ausführen — muss scheitern**

```
uv run pytest tests/test_tray.py::TestCreateTray -v
```

Erwartet: FAIL — `create_tray` nicht in `__init__.py`.

- [ ] **Schritt 3: `__init__.py` implementieren**

`whisper_local/tray/__init__.py`:

```python
"""Tray-Package — plattformspezifische Tray-App."""

import sys
from typing import Callable

from whisper_local.tray._tray import AppState, NoOpTray


def create_tray(
    on_settings: Callable[[], None],
    on_quit: Callable[[], None],
) -> "Win32TrayApp | NoOpTray":
    """Gibt den plattformspezifischen Tray zurück."""
    if sys.platform == "win32":
        from whisper_local.tray._tray import Win32TrayApp
        return Win32TrayApp(on_settings=on_settings, on_quit=on_quit)
    return NoOpTray()


__all__ = ["create_tray", "AppState"]
```

- [ ] **Schritt 4: Tests ausführen — müssen bestehen**

```
uv run pytest tests/test_tray.py -v
```

Erwartet: alle PASS (Windows), Skips wo plattformspezifisch.

- [ ] **Schritt 5: Commit**

```bash
git add whisper_local/tray/__init__.py tests/test_tray.py
git commit -m "feat: add create_tray() factory with platform dispatch"
```

---

## Task 11: `__main__.py` — App-Integration

**Files:**
- Modify: `whisper_local/__main__.py`
- Modify: `tests/test_main.py`

- [ ] **Schritt 1: Bestehende Tests anpassen**

In `tests/test_main.py` alle drei `@patch`-Decorator-Blöcke um `create_tray`-Mock erweitern:

```python
    @patch("whisper_local.__main__.create_tray")
    @patch("whisper_local.__main__.Transcriber")
    @patch("whisper_local.__main__.create_listener")
    @patch("whisper_local.__main__.create_inserter")
    def test_app_init(self, mock_inserter_factory, mock_listener_factory,
                      mock_transcriber_class, mock_tray_factory):
        app = App()
        assert app.recorder is not None
        mock_transcriber_class.assert_called_once()
        mock_listener_factory.assert_called_once()
        mock_inserter_factory.assert_called_once()
        mock_tray_factory.assert_called_once()
```

Gleiche Erweiterung für `test_on_press_starts_recording`, `test_on_release_stops_and_transcribes`, `test_on_release_no_audio_skips`.

Außerdem neue Tests am Ende anfügen:

```python
    @patch("whisper_local.__main__.create_tray")
    @patch("whisper_local.__main__.Transcriber")
    @patch("whisper_local.__main__.create_listener")
    @patch("whisper_local.__main__.create_inserter")
    def test_on_press_sets_recording_state(
        self, mock_inserter_factory, mock_listener_factory,
        mock_transcriber_class, mock_tray_factory
    ):
        from whisper_local.tray import AppState
        mock_tray = MagicMock()
        mock_tray_factory.return_value = mock_tray

        app = App()
        app.recorder = MagicMock()

        import asyncio
        asyncio.run(app.on_press())

        mock_tray.set_state.assert_called_with(AppState.RECORDING)

    @patch("whisper_local.__main__.create_tray")
    @patch("whisper_local.__main__.Transcriber")
    @patch("whisper_local.__main__.create_listener")
    @patch("whisper_local.__main__.create_inserter")
    def test_on_release_sets_waiting_state_after_transcription(
        self, mock_inserter_factory, mock_listener_factory,
        mock_transcriber_class, mock_tray_factory
    ):
        from whisper_local.tray import AppState
        mock_tray = MagicMock()
        mock_tray_factory.return_value = mock_tray

        mock_transcriber = MagicMock()
        mock_transcriber.transcribe.return_value = "Text"
        mock_transcriber_class.return_value = mock_transcriber

        app = App()
        app.recorder = MagicMock()
        app.recorder.stop.return_value = np.zeros(16000, dtype=np.float32)
        app.inserter = MagicMock()
        app.inserter.insert = AsyncMock()

        import asyncio
        asyncio.run(app.on_release())

        calls = [c.args[0] for c in mock_tray.set_state.call_args_list]
        assert AppState.TRANSCRIBING in calls
        assert calls[-1] == AppState.WAITING
```

- [ ] **Schritt 2: Tests ausführen — bestehende müssen scheitern**

```
uv run pytest tests/test_main.py -v
```

Erwartet: FAIL auf alten Tests (fehlender `create_tray`-Mock) + FAIL auf neuen Tests.

- [ ] **Schritt 3: `__main__.py` aktualisieren**

`whisper_local/__main__.py` komplett ersetzen:

```python
"""Entry-Point für whisper-local."""

import asyncio
import logging
import sys

from whisper_local.config import Config, load_config
from whisper_local.hotkey import create_listener
from whisper_local.inserter import create_inserter
from whisper_local.recorder import Recorder
from whisper_local.transcriber import Transcriber
from whisper_local.tray import AppState, create_tray

logger = logging.getLogger(__name__)


class App:
    def __init__(self, config: Config | None = None):
        if config is None:
            config = load_config()

        self._config = config
        self._loop: asyncio.AbstractEventLoop | None = None
        self._hotkey_task: asyncio.Task | None = None

        self.recorder = Recorder(
            sample_rate=config.sample_rate,
            channels=config.channels,
            min_duration=config.min_duration,
            device=config.microphone or None,
        )
        self.transcriber = Transcriber(
            model_name=config.whisper_model,
            compute_type=config.compute_type,
            language=config.language,
        )
        self.inserter = create_inserter()
        self.hotkey = create_listener(key_name=config.hotkey)
        self.hotkey.on_press = self.on_press
        self.hotkey.on_release = self.on_release
        self.tray = create_tray(on_settings=self._open_settings, on_quit=self._quit)

    async def on_press(self) -> None:
        """Callback: Hotkey gedrückt — Aufnahme starten."""
        logger.info("Aufnahme startet...")
        self.tray.set_state(AppState.RECORDING)
        self.recorder.start()

    async def on_release(self) -> None:
        """Callback: Hotkey losgelassen — Aufnahme stoppen, transkribieren, einfügen."""
        audio = self.recorder.stop()
        if audio is None:
            logger.info("Keine Audio-Daten, übersprungen")
            self.tray.set_state(AppState.WAITING)
            return

        logger.info("Transkribiere...")
        self.tray.set_state(AppState.TRANSCRIBING)
        text = self.transcriber.transcribe(audio)
        if text:
            await self.inserter.insert(text)
        self.tray.set_state(AppState.WAITING)

    def _quit(self) -> None:
        """Beendet die Anwendung sauber."""
        if self._loop is not None:
            self._loop.call_soon_threadsafe(self._loop.stop)

    def _open_settings(self) -> None:
        """Öffnet den Einstellungs-Dialog."""
        from whisper_local.tray._settings import SettingsDialog
        SettingsDialog(config=self._config, on_save=self._on_config_reload).open()

    def _on_config_reload(self, new_config: Config) -> None:
        """Übernimmt neue Konfiguration ohne App-Neustart."""
        self._config = new_config
        self.recorder = Recorder(
            sample_rate=new_config.sample_rate,
            channels=new_config.channels,
            min_duration=new_config.min_duration,
            device=new_config.microphone or None,
        )
        if self._loop is not None:
            asyncio.run_coroutine_threadsafe(
                self._restart_hotkey(new_config.hotkey), self._loop
            )

    async def _restart_hotkey(self, key_name: str) -> None:
        """Stoppt den alten Hotkey-Listener und startet einen neuen."""
        self.hotkey.stop()
        await asyncio.sleep(0.1)
        self.hotkey = create_listener(key_name=key_name)
        self.hotkey.on_press = self.on_press
        self.hotkey.on_release = self.on_release
        self._hotkey_task = asyncio.create_task(self.hotkey.listen())

    async def run(self) -> None:
        """Startet den Hauptloop."""
        self._loop = asyncio.get_running_loop()
        logger.info("whisper-local gestartet, warte auf Hotkey...")
        self.tray.start()
        self._hotkey_task = asyncio.create_task(self.hotkey.listen())
        await self._hotkey_task


def main():
    logging.basicConfig(
        level=logging.INFO,
        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
    )
    app = App()
    try:
        asyncio.run(app.run())
    except KeyboardInterrupt:
        logger.info("Beendet")
        sys.exit(0)


if __name__ == "__main__":
    main()
```

- [ ] **Schritt 4: Alle Tests ausführen — müssen bestehen**

```
uv run pytest -v
```

Erwartet: alle PASS.

- [ ] **Schritt 5: Commit**

```bash
git add whisper_local/__main__.py tests/test_main.py
git commit -m "feat: integrate tray icon, settings dialog, and config reload into App"
```