diff --git a/docs/superpowers/plans/2026-06-26-winui-control-panel-cleanup.md b/docs/superpowers/plans/2026-06-26-winui-control-panel-cleanup.md
new file mode 100644
index 0000000..e686702
--- /dev/null
+++ b/docs/superpowers/plans/2026-06-26-winui-control-panel-cleanup.md
@@ -0,0 +1,491 @@
+# WinUI Control-Panel Cleanup Implementation Plan
+
+> **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:** Streamline the WinUI control panel — grouped cards, custom title bar, a gesture-help InfoBar, drop Lock/Click-through/Zoom, and size the window to its content.
+
+**Architecture:** UI-layer only. Core VM loses three observable props (Lock/ClickThrough/Zoom); `MainWindow.xaml` is regrouped into two `Border` cards under section headers with a custom title bar; the capture/shim/overlay pipeline is untouched. Removed config fields and enum members are kept (unused) to avoid config-version churn.
+
+**Tech Stack:** C# .NET 8, WinUI 3 (Windows App SDK 1.8), CommunityToolkit.Mvvm, xUnit.
+
+## Global Constraints
+
+- **Pristine build:** 0 warnings (CI enforces `/warnaserror` + `TreatWarningsAsErrors`). No `#pragma warning disable`.
+- **No new NuGet dependency** — native `Border`/`TextBlock`/`InfoBar` only, not the SettingsControls toolkit.
+- **System theme only** — no brand-accent brushes; bind to `ThemeResource` keys.
+- **Core has no WinUI/Win32 types** — VM changes stay pure .NET.
+- **Keep, do not remove:** `OverlaySettings.{Locked,ClickThrough,Zoom}` fields; `HotkeyAction.{ToggleLock,ToggleClickThrough}` enum members; `OverlayWindow.{SetLocked,SetClickThrough,SetZoom}` methods. Mark deliberate keeps with a `// ponytail:` comment.
+- **Maxine attribution footer stays** (SDK License Supplement §3.1) — pinned, always visible.
+- **WinUI API verification:** before coding the title bar and min-size (Task 4/5), consult Context7 MCP (`resolve-library-id` → `query-docs`) for the current Windows App SDK 1.8 `AppWindowTitleBar` / `OverlappedPresenter` surface, per the global Context7 rule. Code below is the expected shape; confirm signatures before relying on them.
+- **App-project verification is a CI/human gate:** the App can't build on this host (needs the shim DLL + RTX). Tasks 3–5 are verified by the self-hosted RTX CI build (0 warnings) plus a visual human check; only Tasks 1–2 (Core) run locally via `dotnet test`.
+
+---
+
+### Task 1: Remove Lock/ClickThrough/Zoom from the view-model
+
+**Files:**
+- Modify: `src/CameraOnScreen.Core/ViewModels/MainViewModel.cs`
+- Test: `tests/CameraOnScreen.Core.Tests/ViewModels/MainViewModelTests.cs`
+
+**Interfaces:**
+- Consumes: `AppConfig`, `OverlaySettings` (unchanged — fields stay).
+- Produces: `MainViewModel` with no `Locked`/`ClickThrough`/`Zoom` properties; `Mirror` kept. `ToAppConfig` still returns a fully-populated `AppConfig` (removed fields default: `Locked=false`, `ClickThrough=false`, `Zoom=1.0`).
+
+- [ ] **Step 1: Update the VM tests to the new contract**
+
+In `MainViewModelTests.cs`, **replace** the test `LoadFrom_propagates_locked_and_clickthrough` (currently ~lines 149-160) and `LoadFrom_propagates_mirror_and_zoom` (~196-207) with a single mirror-only test, and **edit** `ToAppConfig_captures_geometry_and_effects` (~162-176) and `ToAppConfig_captures_mirror_and_zoom` (~209-218) to drop Lock/Zoom.
+
+Replace the two `LoadFrom_*` tests with:
+
+```csharp
+    [Fact]
+    public void LoadFrom_propagates_mirror()
+    {
+        var vm = Build(GpuTier.Rtx, out _);
+        var config = new AppConfig
+        {
+            Overlay = new OverlaySettings { Mirror = true }
+        };
+        vm.LoadFrom(config);
+        Assert.True(vm.Mirror);
+    }
+```
+
+Replace `ToAppConfig_captures_geometry_and_effects` body's Lock lines — set it to:
+
+```csharp
+    [Fact]
+    public void ToAppConfig_captures_geometry_and_effects()
+    {
+        var vm = Build(GpuTier.Rtx, out _);
+        vm.GreenScreenEnabled = true;
+        var cfg = vm.ToAppConfig(10, 20, 300, 400);
+        Assert.Equal(10, cfg.Overlay.X);
+        Assert.Equal(20, cfg.Overlay.Y);
+        Assert.Equal(300, cfg.Overlay.Width);
+        Assert.Equal(400, cfg.Overlay.Height);
+        Assert.True(cfg.Effects.GreenScreenEnabled);
+        Assert.Null(cfg.CameraId);
+    }
+```
+
+Replace `ToAppConfig_captures_mirror_and_zoom` with mirror-only:
+
+```csharp
+    [Fact]
+    public void ToAppConfig_captures_mirror()
+    {
+        var vm = Build(GpuTier.Rtx, out _);
+        vm.Mirror = true;
+        var cfg = vm.ToAppConfig(10, 20, 300, 400);
+        Assert.True(cfg.Overlay.Mirror);
+    }
+```
+
+- [ ] **Step 2: Run the tests to verify they fail to compile**
+
+Run: `dotnet test tests/CameraOnScreen.Core.Tests/CameraOnScreen.Core.Tests.csproj`
+Expected: BUILD FAILURE — tests still reference `vm.Locked`/`vm.Zoom` nowhere now, but the VM still *defines* them; compile actually still succeeds and tests PASS. (This is a deletion refactor — the suite is the regression guard, not a red-first test.) Proceed to Step 3.
+
+- [ ] **Step 3: Remove the three observable properties**
+
+In `MainViewModel.cs`, delete these three `[ObservableProperty]` lines (~76-79), keeping `mirror`:
+
+```csharp
+    [ObservableProperty] private bool locked;          // DELETE
+    [ObservableProperty] private bool clickThrough;    // DELETE
+    [ObservableProperty] private double zoom = 1.0;    // DELETE
+```
+
+Keep:
+```csharp
+    [ObservableProperty] private bool mirror;
+```
+
+- [ ] **Step 4: Remove the load/save lines**
+
+In `LoadFrom` (~106-109), delete the `Locked`, `ClickThrough`, and `Zoom` lines; keep `Mirror`:
+
+```csharp
+        // DELETE: Locked = config.Overlay.Locked;
+        // DELETE: ClickThrough = config.Overlay.ClickThrough;
+        Mirror = config.Overlay.Mirror;
+        // DELETE: Zoom = config.Overlay.Zoom;
+```
+
+In `ToAppConfig`'s `OverlaySettings` initializer (~121-126), drop `Locked`/`ClickThrough`/`Zoom` so they take their record defaults:
+
+```csharp
+        Overlay = new OverlaySettings
+        {
+            X = x, Y = y, Width = w, Height = h,
+            // ponytail: Locked/ClickThrough/Zoom intentionally omitted — fields kept on the record
+            // (default false/false/1.0) so config stays schema-stable; the overlay is always
+            // interactive and unzoomed now.
+            Mirror = Mirror
+        },
+```
+
+Also update the stale comment above `ToAppConfig` (~116-117) that says "Locked/ClickThrough are the existing observable props" — replace with: `// Mirror is the kept observable prop; Lock/ClickThrough/Zoom were removed (overlay is always interactive).`
+
+- [ ] **Step 5: Run the tests to verify green**
+
+Run: `dotnet test tests/CameraOnScreen.Core.Tests/CameraOnScreen.Core.Tests.csproj`
+Expected: PASS — 58 tests, 0 failures (was 59; net -1 after merging two load tests into one).
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/CameraOnScreen.Core/ViewModels/MainViewModel.cs tests/CameraOnScreen.Core.Tests/ViewModels/MainViewModelTests.cs
+git commit -m "refactor(vm): drop Lock/ClickThrough/Zoom from view-model"
+```
+
+---
+
+### Task 2: Drop the dead default hotkeys
+
+**Files:**
+- Modify: `src/CameraOnScreen.Core/Config/Models.cs:53-59`
+- Test: `tests/CameraOnScreen.Core.Tests/Hotkeys/HotkeyValidatorTests.cs` (no change expected — verify)
+
+**Interfaces:**
+- Consumes: nothing new.
+- Produces: `AppConfig.DefaultHotkeys()` returns 2 bindings (`ToggleOverlayVisible`, `ToggleRunning`). The `HotkeyAction.ToggleLock`/`ToggleClickThrough` enum members remain (still referenced by `HotkeyValidatorTests`).
+
+- [ ] **Step 1: Remove the two dead default bindings**
+
+In `Models.cs`, `DefaultHotkeys()` — delete the `ToggleLock` and `ToggleClickThrough` entries (~55-56), keeping the other two:
+
+```csharp
+    // VK codes: F10=0x79, F11=0x7A. (ToggleLock/ToggleClickThrough default bindings removed —
+    // ponytail: enum members kept for config compatibility, but no UI/behavior toggles them now.)
+    public static IReadOnlyList<HotkeyBinding> DefaultHotkeys() => Array.AsReadOnly(new[]
+    {
+        new HotkeyBinding { Action = HotkeyAction.ToggleOverlayVisible,Modifiers = HotkeyModifiers.Control | HotkeyModifiers.Alt, VirtualKey = 0x79 },
+        new HotkeyBinding { Action = HotkeyAction.ToggleRunning,       Modifiers = HotkeyModifiers.Control | HotkeyModifiers.Alt, VirtualKey = 0x7A },
+    });
+```
+
+- [ ] **Step 2: Run the Core tests**
+
+Run: `dotnet test tests/CameraOnScreen.Core.Tests/CameraOnScreen.Core.Tests.csproj`
+Expected: PASS, 0 failures. `HotkeyValidatorTests.DefaultHotkeys_has_no_conflict` still holds (two bindings, distinct keys); the conflict test still compiles (`ToggleLock` enum member intact).
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/CameraOnScreen.Core/Config/Models.cs
+git commit -m "refactor(config): drop dead Lock/ClickThrough default hotkeys"
+```
+
+---
+
+### Task 3: Strip removed wiring from the window code-behind
+
+**Files:**
+- Modify: `src/CameraOnScreen.App/MainWindow.xaml.cs`
+
+**Interfaces:**
+- Consumes: `MainViewModel` without `Locked`/`ClickThrough`/`Zoom` (Task 1).
+- Produces: a code-behind that references only `Mirror` among the removed props; the overlay is left at its always-interactive defaults (`_locked=false`, `_clickThrough=false`, `_zoom=1.0` — no setter calls).
+
+> Not locally buildable (App needs shim + RTX). Verified at CI build + visual gate.
+
+- [ ] **Step 1: Remove the SetLocked/SetClickThrough/SetZoom ctor calls**
+
+In the ctor (~57-61), delete the `SetLocked`, `SetClickThrough`, and `SetZoom` lines; keep `SetMirror`:
+
+```csharp
+        // Apply the initial state loaded from config to the overlay.
+        _overlay.SetMirror(Vm.Mirror);
+        // ponytail: overlay stays always-interactive (no SetLocked/SetClickThrough) and unzoomed
+        // (no SetZoom) — Lock/ClickThrough/Zoom were removed from the panel.
+```
+
+- [ ] **Step 2: Remove the hotkey switch cases for Lock/ClickThrough**
+
+In `OnHotkeyAction` (~173-181), delete the `ToggleLock` and `ToggleClickThrough` cases (they referenced the removed `Vm.Locked`/`Vm.ClickThrough`), keeping the other two:
+
+```csharp
+            switch (action)
+            {
+                case HotkeyAction.ToggleOverlayVisible: _overlay.ToggleVisible(); break;
+                case HotkeyAction.ToggleRunning:
+                    if (Vm.IsRunning) Vm.StopCommand?.Execute(null); else Vm.StartCommand?.Execute(null);
+                    break;
+                // ToggleLock/ToggleClickThrough: no-ops now (overlay always interactive); enum kept.
+            }
+```
+
+- [ ] **Step 3: Remove the OnVmPropertyChanged branches for Locked/ClickThrough/Zoom**
+
+In `OnVmPropertyChanged` (~287-294), delete the three `else if` branches for `Locked`, `ClickThrough`, and `Zoom`; keep the `Mirror` branch:
+
+```csharp
+        else if (e.PropertyName == nameof(MainViewModel.Mirror))
+            _overlay.SetMirror(Vm.Mirror);
+        // Locked/ClickThrough/Zoom branches removed — those props no longer exist.
+```
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/CameraOnScreen.App/MainWindow.xaml.cs
+git commit -m "refactor(app): remove Lock/ClickThrough/Zoom overlay wiring"
+```
+
+---
+
+### Task 4: Custom title bar + dynamic sizing in code-behind
+
+**Files:**
+- Modify: `src/CameraOnScreen.App/MainWindow.xaml.cs`
+
+**Interfaces:**
+- Consumes: an `x:Name="AppTitleBar"` element added in Task 5's XAML, and `x:Name="RootGrid"` (the window root).
+- Produces: `ExtendsContentIntoTitleBar=true` + `SetTitleBar(AppTitleBar)`; window sized to content on first layout instead of the hardcoded 400×720.
+
+> **Before coding:** Context7 `query-docs` for "Windows App SDK 1.8 ExtendsContentIntoTitleBar SetTitleBar AppWindow Resize OverlappedPresenter minimum size". Confirm `SetTitleBar(UIElement)` and whether `OverlappedPresenter.PreferredMinimumWidth/Height` exist in 1.8. The code below is the expected shape.
+
+- [ ] **Step 1: Replace `RightSizePanel` with size-to-content**
+
+Delete the `PanelWidthDip`/`PanelHeightDip` consts (~15) and rewrite `RightSizePanel` (~119-127) to measure the laid-out content and resize to it. Call it from the existing ctor call site (`RightSizePanel();` ~74) but defer to first layout via `RootGrid.Loaded`:
+
+```csharp
+    // Size the window to its content (DPI-scaled) instead of a magic number, so every control is
+    // visible at open. ScrollViewer is the fallback if the user shrinks the window.
+    private void RightSizePanel()
+    {
+        RootGrid.Loaded += (_, _) =>
+        {
+            RootGrid.Measure(new Windows.Foundation.Size(double.PositiveInfinity, double.PositiveInfinity));
+            var hwnd = WinRT.Interop.WindowNative.GetWindowHandle(this);
+            double scale = GetDpiForWindow(hwnd) / 96.0;
+            var id = Microsoft.UI.Win32Interop.GetWindowIdFromWindow(hwnd);
+            var appWindow = Microsoft.UI.Windowing.AppWindow.GetFromWindowId(id);
+            int w = (int)(RootGrid.DesiredSize.Width * scale);
+            int h = (int)(RootGrid.DesiredSize.Height * scale);
+            appWindow.Resize(new Windows.Graphics.SizeInt32(w, h));
+            // ponytail: best-effort min-size lock if the presenter supports it; else ScrollViewer
+            // covers shrink. Guarded so a missing API in 1.8 doesn't break the build.
+            if (appWindow.Presenter is Microsoft.UI.Windowing.OverlappedPresenter p)
+            {
+                p.PreferredMinimumWidth = w;
+                p.PreferredMinimumHeight = h;
+            }
+        };
+    }
+```
+
+> If Context7 confirms `PreferredMinimumWidth/Height` do **not** exist in 1.8, delete the `if (appWindow.Presenter ...)` block (size-to-content alone satisfies the requirement; ScrollViewer is the shrink fallback). Do not add a WM_GETMINMAXINFO subclass — out of scope.
+
+- [ ] **Step 2: Wire the custom title bar in the ctor**
+
+After `InitializeComponent();` (~73, before `RightSizePanel();`), extend into the title bar and set the drag region:
+
+```csharp
+        InitializeComponent();
+        ExtendsContentIntoTitleBar = true;
+        SetTitleBar(AppTitleBar);
+        RightSizePanel();
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/CameraOnScreen.App/MainWindow.xaml.cs
+git commit -m "feat(app): custom title bar + size-to-content window"
+```
+
+---
+
+### Task 5: Regroup the panel XAML
+
+**Files:**
+- Modify: `src/CameraOnScreen.App/MainWindow.xaml`
+
+**Interfaces:**
+- Consumes: `Vm` without `Zoom` (the Zoom `Slider` is deleted); the static helpers `QualityEnabled`, `ExposureSliderEnabled` (unchanged); `StatusLine`, `MaxineAttribution`, `NotAvailableVisibility`, `EyeContactNotAvailableVisibility` (unchanged).
+- Produces: a window with `x:Name="RootGrid"`, an `x:Name="AppTitleBar"` title bar row, two grouped cards, and a help `InfoBar`.
+
+> Not locally buildable. Verified at CI build + visual gate. Keep every binding path byte-identical to today's (only grouping/containers change) so no code-behind helper goes missing.
+
+- [ ] **Step 1: Rewrite `MainWindow.xaml`**
+
+Replace the whole file with the grouped layout. Title-bar row (row 0), scrollable body (row 1), pinned attribution (row 2):
+
+```xml
+<Window
+    x:Class="CameraOnScreen.App.MainWindow"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:muxc="using:Microsoft.UI.Xaml.Controls"
+    xmlns:local="using:CameraOnScreen.App">
+    <Grid x:Name="RootGrid">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="*"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <!-- Custom title bar (drag region set via SetTitleBar in code-behind). -->
+        <Grid x:Name="AppTitleBar" Grid.Row="0" Height="36" ColumnSpacing="8" Padding="12,0,0,0">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+            <Image Grid.Column="0" Source="ms-appx:///Assets/cos.ico" Width="16" Height="16"
+                   VerticalAlignment="Center"/>
+            <TextBlock Grid.Column="1" Text="Camera on Screen" VerticalAlignment="Center"
+                       Style="{ThemeResource CaptionTextBlockStyle}"/>
+        </Grid>
+
+        <!-- Controls scroll; the license-required footer (row 2) stays pinned outside. -->
+        <ScrollViewer Grid.Row="1" Padding="16">
+            <StackPanel Spacing="16">
+
+                <muxc:InfoBar Severity="Informational" IsOpen="True" IsClosable="False"
+                              Title="Overlay tips"
+                              Message="Scroll over the overlay to resize it · drag the + handle to move it."/>
+
+                <!-- CAMERA -->
+                <StackPanel Spacing="8">
+                    <TextBlock Text="Camera" Style="{ThemeResource BodyStrongTextBlockStyle}"/>
+                    <Border Background="{ThemeResource CardBackgroundFillColorDefaultBrush}"
+                            BorderBrush="{ThemeResource CardStrokeColorDefaultBrush}"
+                            BorderThickness="1" CornerRadius="8" Padding="12">
+                        <StackPanel Spacing="12">
+                            <ComboBox Header="Camera"
+                                      ItemsSource="{x:Bind Vm.Cameras}"
+                                      SelectedItem="{x:Bind Vm.SelectedCamera, Mode=TwoWay}"
+                                      DisplayMemberPath="Name" HorizontalAlignment="Stretch"/>
+                            <StackPanel Orientation="Horizontal" Spacing="8">
+                                <Button Content="Start" Command="{x:Bind Vm.StartCommand}"
+                                        AutomationProperties.Name="Start capture"/>
+                                <Button Content="Stop" Command="{x:Bind Vm.StopCommand}"
+                                        AutomationProperties.Name="Stop capture"/>
+                                <TextBlock Text="{x:Bind StatusLine, Mode=OneWay}"
+                                           VerticalAlignment="Center"
+                                           AutomationProperties.LiveSetting="Polite"/>
+                            </StackPanel>
+                            <ToggleSwitch Header="Mirror (selfie view)"
+                                          IsOn="{x:Bind Vm.Mirror, Mode=TwoWay}"/>
+                            <ToggleSwitch Header="Lock exposure (steady FPS)"
+                                          IsEnabled="{x:Bind Vm.ExposureSupported, Mode=OneWay}"
+                                          IsOn="{x:Bind Vm.ExposureLock, Mode=TwoWay}"/>
+                            <Slider Header="Exposure" Minimum="0" Maximum="1" StepFrequency="0.05"
+                                    IsEnabled="{x:Bind local:MainWindow.ExposureSliderEnabled(Vm.ExposureSupported, Vm.ExposureLock), Mode=OneWay}"
+                                    Value="{x:Bind Vm.ExposureValue, Mode=TwoWay}"/>
+                        </StackPanel>
+                    </Border>
+                </StackPanel>
+
+                <!-- AI EFFECTS -->
+                <StackPanel Spacing="8">
+                    <TextBlock Text="AI Effects" Style="{ThemeResource BodyStrongTextBlockStyle}"/>
+                    <Border Background="{ThemeResource CardBackgroundFillColorDefaultBrush}"
+                            BorderBrush="{ThemeResource CardStrokeColorDefaultBrush}"
+                            BorderThickness="1" CornerRadius="8" Padding="12">
+                        <StackPanel Spacing="12">
+                            <ToggleSwitch Header="AI Green Screen" IsEnabled="{x:Bind Vm.EffectsAvailable, Mode=OneWay}"
+                                          IsOn="{x:Bind Vm.GreenScreenEnabled, Mode=TwoWay}"/>
+                            <Slider Header="Green-screen Expand" Minimum="0" Maximum="1" StepFrequency="0.05"
+                                    IsEnabled="{x:Bind Vm.GreenScreenEnabled, Mode=OneWay}"
+                                    Value="{x:Bind Vm.GreenScreenExpand, Mode=TwoWay}"/>
+                            <Slider Header="Green-screen Feather" Minimum="0" Maximum="1" StepFrequency="0.05"
+                                    IsEnabled="{x:Bind Vm.GreenScreenEnabled, Mode=OneWay}"
+                                    Value="{x:Bind Vm.GreenScreenFeather, Mode=TwoWay}"/>
+                            <ToggleSwitch Header="Eye Contact" IsEnabled="{x:Bind Vm.EyeContactAvailable, Mode=OneWay}"
+                                          IsOn="{x:Bind Vm.EyeContactEnabled, Mode=TwoWay}"/>
+                            <TextBlock Text="{x:Bind Vm.EyeContactDetail, Mode=OneWay}"
+                                       Visibility="{x:Bind EyeContactNotAvailableVisibility, Mode=OneWay}"
+                                       TextWrapping="Wrap"
+                                       Foreground="{ThemeResource SystemFillColorCautionBrush}"/>
+                            <ComboBox Header="AI Sharpness"
+                                      IsEnabled="{x:Bind Vm.SuperResAvailable, Mode=OneWay}"
+                                      SelectedIndex="{x:Bind Vm.SuperResModeIndex, Mode=TwoWay}">
+                                <ComboBoxItem Content="Off"/>
+                                <ComboBoxItem Content="Denoise"/>
+                                <ComboBoxItem Content="Deblur"/>
+                            </ComboBox>
+                            <ComboBox Header="Quality"
+                                      IsEnabled="{x:Bind local:MainWindow.QualityEnabled(Vm.SuperResAvailable, Vm.SuperResModeIndex), Mode=OneWay}"
+                                      SelectedIndex="{x:Bind Vm.SuperResQualityIndex, Mode=TwoWay}">
+                                <ComboBoxItem Content="Low"/>
+                                <ComboBoxItem Content="Medium"/>
+                                <ComboBoxItem Content="High"/>
+                                <ComboBoxItem Content="Ultra"/>
+                            </ComboBox>
+                            <TextBlock Text="{x:Bind Vm.CapabilityDetail, Mode=OneWay}"
+                                       Visibility="{x:Bind NotAvailableVisibility, Mode=OneWay}"
+                                       TextWrapping="Wrap"
+                                       Foreground="{ThemeResource SystemFillColorCautionBrush}"/>
+                        </StackPanel>
+                    </Border>
+                </StackPanel>
+            </StackPanel>
+        </ScrollViewer>
+
+        <!-- Required NVIDIA Maxine attribution (SDK License Supplement §3.1) — always visible. -->
+        <TextBlock Grid.Row="2" Margin="16,8,16,12"
+                   Text="{x:Bind MaxineAttribution}"
+                   Style="{ThemeResource CaptionTextBlockStyle}"
+                   Foreground="{ThemeResource TextFillColorSecondaryBrush}"/>
+    </Grid>
+</Window>
+```
+
+- [ ] **Step 2: Verify the title-bar icon asset path**
+
+Confirm `cos.ico` is reachable at `ms-appx:///Assets/cos.ico`. The csproj sets `<ApplicationIcon>..\..\cos.ico</ApplicationIcon>` (the exe icon) — that is NOT an `ms-appx` Content asset. Check whether an `Assets/` folder with the icon exists in the App project:
+
+Run: `ls src/CameraOnScreen.App/Assets/ 2>/dev/null; grep -n "cos.ico\|Assets" src/CameraOnScreen.App/CameraOnScreen.App.csproj`
+
+If no `ms-appx`-published icon exists, add the icon as Content in the csproj:
+
+```xml
+  <ItemGroup>
+    <Content Include="..\..\cos.ico"><Link>Assets\cos.ico</Link><CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory></Content>
+  </ItemGroup>
+```
+
+…and keep the `ms-appx:///Assets/cos.ico` source. If publishing the icon proves fragid for the unpackaged app, fall back to dropping the `<Image>` and showing the title text only (the title bar still works) — note this in the commit.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/CameraOnScreen.App/MainWindow.xaml src/CameraOnScreen.App/CameraOnScreen.App.csproj
+git commit -m "feat(app): grouped control panel + gesture-help InfoBar"
+```
+
+---
+
+### Task 6: Verify
+
+- [ ] **Step 1: Core tests pass locally**
+
+Run: `dotnet test tests/CameraOnScreen.Core.Tests/CameraOnScreen.Core.Tests.csproj`
+Expected: PASS, 0 failures (~58 tests).
+
+- [ ] **Step 2: CI build gate (self-hosted RTX)**
+
+Open the PR; CI builds the shim SDK config → export-verify → App build (`/warnaserror`) → Core tests. Expected: green, 0 warnings. This is the only place the App project compiles.
+
+- [ ] **Step 3: Visual human gate**
+
+On the RTX host, run the App and confirm:
+- Custom title bar shows the icon + "Camera on Screen"; min/max/close work; the bar is draggable.
+- Two cards: **Camera** (camera combo, Start/Stop + status, Mirror, Lock exposure, Exposure) and **AI Effects** (green screen + sliders, eye contact + note, sharpness + quality + note).
+- The **InfoBar** at top states the scroll-to-resize / drag-the-+-handle gestures.
+- No Lock overlay, Click-through, or Zoom controls anywhere.
+- Window opens sized to fit all controls (no empty space / no clipping); shrinking it scrolls.
+- Overlay is draggable and wheel-resizable (always interactive).
+
+---
+
+## Self-Review
+
+- **Spec coverage:** custom title bar (T4/T5) ✓; grouped cards (T5) ✓; InfoBar help (T5) ✓; remove Lock/ClickThrough/Zoom (T1/T2/T3) ✓; Exposure→Camera, Mirror→Camera (T5) ✓; dynamic sizing (T4) ✓; system theme / no dep (Global Constraints + T5 ThemeResource) ✓; kept fields/enums/setters (T1/T2/T3 ponytail comments) ✓; attribution footer preserved (T5) ✓.
+- **Placeholder scan:** none — every code step shows full code; the one uncertainty (min-size API) has an explicit fallback.
+- **Type consistency:** `RootGrid`/`AppTitleBar` names match between T4 (code-behind) and T5 (XAML); `Mirror` kept consistently; removed props removed everywhere they were referenced (VM, code-behind branches, hotkey cases, XAML Zoom slider).
+- **Note:** Step 2 of Task 1 is honestly labeled — this is a deletion refactor guarded by the existing suite, not a red-green-first test.
diff --git a/docs/superpowers/specs/2026-06-26-winui-control-panel-cleanup-design.md b/docs/superpowers/specs/2026-06-26-winui-control-panel-cleanup-design.md
new file mode 100644
index 0000000..0fc031f
--- /dev/null
+++ b/docs/superpowers/specs/2026-06-26-winui-control-panel-cleanup-design.md
@@ -0,0 +1,136 @@
+# WinUI Control-Panel Cleanup — Design
+
+**Date:** 2026-06-26
+**Branch:** `worktree-feature+winui-panel-cleanup` (worktree, from origin/main)
+
+## Context
+
+The WinUI control panel (`MainWindow.xaml`) is a single flat `ScrollViewer → StackPanel`:
+camera, AI-effect toggles/sliders, overlay-behavior toggles, Start/Stop, and the status line
+are all jammed together with no grouping or hierarchy. The window uses the default WinUI title
+bar and a hardcoded 400×720 size that leaves the panel cramped or empty depending on DPI. Two
+controls (Lock overlay, Click-through) and one (Zoom) are not meaningful for this app's intent —
+a draggable, always-on-top camera overlay. The non-obvious overlay gestures (scroll-to-resize,
+drag-the-handle) are undiscoverable.
+
+Goal: streamline the panel for **clarity and accessibility** — group controls by concern, add a
+custom branded title bar, surface the hidden gestures, drop the controls that don't belong, and
+size the window to its content instead of a magic number.
+
+## Scope
+
+UI-layer change. C# shim, capture pipeline, and Maxine code are untouched.
+
+### Removed
+- **Lock overlay** toggle + VM `Locked` property + config load/save + `OnVmPropertyChanged` branch + `SetLocked` call.
+- **Click-through** toggle + VM `ClickThrough` property + config load/save + branch + `SetClickThrough` call + the `ToggleClickThrough` default hotkey binding.
+- **Zoom** slider + VM `Zoom` property + branch + `SetZoom` call.
+
+Removing `Locked` and `ClickThrough` makes `OverlayWindow.IsInteractive` (`!_locked && !_clickThrough`)
+always `true` — the overlay is permanently draggable/resizable, matching intent. `SetZoom` is no
+longer called, so `UpdateScale`'s `Matrix3x2` uses zoom = 1 (mirror-only transform).
+
+**Deliberately kept (ponytail):** `OverlaySettings.Locked/ClickThrough/Zoom` fields and the
+`HotkeyAction.ToggleLock/ToggleClickThrough` enum members stay (unused), marked with a `ponytail:`
+comment. Removing them would cascade into config-versioning + 3 test files for no user benefit.
+`OverlayWindow.SetLocked/SetClickThrough/SetZoom` stay on the type (now unused by the app); they're
+harmless and the overlay defaults (`_locked=false`, `_clickThrough=false`, zoom=1) give the desired
+always-interactive, no-zoom behavior with no call needed.
+
+### Kept / Moved
+- **Mirror** → folded into the CAMERA group.
+- **Lock exposure + Exposure slider** → CAMERA group (camera-related, not AI).
+- Camera combo, Start/Stop, status line → CAMERA group.
+- Green Screen (+Expand/Feather), Eye Contact (+note), AI Sharpness (+Quality, +note) → AI EFFECTS group.
+
+## Layout
+
+```
+🎥 Camera on Screen                         ─ □ ✕   ← custom title bar
+─────────────────────────────────────────────────
+ ⓘ  Scroll over the overlay to resize ·            ← InfoBar (Informational, IsClosable=False)
+    drag the  ＋  handle to move it.
+
+ CAMERA                                             ← section header (BodyStrongTextBlockStyle)
+   ┌───────────────────────────────────────────┐   ← card: Border, CardBackgroundFillColorDefaultBrush
+   │ Camera             [Logitech ▾]           │
+   │ [ ▶ Start ]  [ ⏹ Stop ]     • Running 30fps│
+   │ Mirror (selfie view)            [ON ●]     │
+   │ Lock exposure (steady FPS)      [OFF]      │
+   │ Exposure           ──●────                 │
+   └───────────────────────────────────────────┘
+
+ AI EFFECTS
+   ┌───────────────────────────────────────────┐
+   │ AI Green Screen                 [ON ●]     │
+   │   Expand  ──●──      Feather  ──●──        │
+   │ Eye Contact                     [OFF]      │
+   │   (caution note when unavailable)          │
+   │ AI Sharpness [Denoise ▾]  Quality [High ▾] │
+   │   (caution note when unavailable)          │
+   └───────────────────────────────────────────┘
+─────────────────────────────────────────────────
+ NVIDIA Maxine attribution (pinned footer — unchanged)
+```
+
+## Components
+
+### 1. Custom title bar
+- `ExtendsContentIntoTitleBar = true` (in `MainWindow` ctor) + `SetTitleBar(<grid>)`.
+- Title bar = a `Grid` (row 0 of the window) holding the app icon (cos.ico, 16×16 `Image`) +
+  "Camera on Screen" `TextBlock` (`CaptionTextBlockStyle`), left-aligned, height 32, with the
+  draggable region excluding the caption-button inset.
+- System caption buttons (min/max/close) and system theme — no custom button drawing.
+- Verify the exact API surface (`AppWindowTitleBar`, drag-region, RTL inset) via context7 / winui-design before coding.
+
+### 2. Grouped cards (native, no new dependency)
+- Each group: a `TextBlock` header (`BodyStrongTextBlockStyle`) + a `Border`
+  (`Background={ThemeResource CardBackgroundFillColorDefaultBrush}`, `CornerRadius=8`,
+  `BorderBrush={ThemeResource CardStrokeColorDefaultBrush}`, padding 12) wrapping a `StackPanel`
+  of the existing controls. No `Expander` (small panel, everything stays visible = clarity).
+- Controls keep their existing `Header` attribute — that is the accessibility name. Add
+  `AutomationProperties.Name` only where a control has no `Header` (e.g. the Start/Stop buttons get
+  explicit names; the status `TextBlock` is `AutomationProperties.LiveSetting=Polite`).
+- Decision: native cards over `CommunityToolkit.WinUI.Controls.SettingsControls` — only 2 groups,
+  a NuGet dep isn't justified.
+
+### 3. Help InfoBar
+- `InfoBar Severity="Informational" IsOpen="True" IsClosable="False"` at the top of the scroll body.
+- Message states both hidden gestures: "Scroll over the overlay to resize it · drag the ＋ handle to move it."
+
+### 4. Dynamic sizing
+- Drop the hardcoded `PanelWidthDip/HeightDip = 400/720`.
+- After first layout, measure the root content's `DesiredSize` and `AppWindow.Resize` to it
+  (DPI-scaled, as `RightSizePanel` already does). Set a **minimum** window size to that measured
+  size so every control stays reachable; window remains user-resizable, `ScrollViewer` is the
+  fallback when shrunk.
+- Min-size enforcement: use `OverlappedPresenter.PreferredMinimumWidth/Height` if available in
+  WinAppSDK 1.8; else hook `WM_GETMINMAXINFO`. Confirm the API via context7 before coding.
+
+## Data flow / contracts
+
+No contract changes. `BuildParams()` still feeds the shim; removing Zoom/Lock/ClickThrough only
+removes their `On…Changed` → `ApplyLiveParams` / overlay-setter wiring. `ToAppConfig` writes the
+kept config fields with the removed ones at their defaults.
+
+## Error handling
+
+Unchanged. Capability probe still gates AI toggles OneWay; caution notes still bind to
+`CapabilityDetail` / `EyeContactDetail` visibility.
+
+## Testing
+
+- **Core unit tests** (`dotnet test`) must stay green. `MainViewModelTests` references
+  `Locked/ClickThrough/Zoom` — update those assertions to the removed-property reality (the props
+  are gone from the VM; config round-trip keeps the fields at default). This is the one runnable
+  check that fails if the VM surgery is wrong.
+- **App build** must be pristine (0 warnings) — but the App project can't be built on a host
+  without the shim DLL + Windows App SDK runtime; CI (self-hosted RTX) is the build gate.
+- **Visual confirmation is a human gate** (per repo convention): the panel layout, title bar, and
+  InfoBar can only be eyeballed by running the app on the RTX host. Document what to look for.
+
+## Out of scope
+- No theme/brand-accent color (system theme only).
+- No SettingsControls toolkit.
+- No removal of the kept-but-unused config fields / enum members / overlay setters.
+- No overlay-window (capture) changes.
diff --git a/src/CameraOnScreen.App/MainWindow.xaml b/src/CameraOnScreen.App/MainWindow.xaml
index c4a79bd..e84b394 100644
--- a/src/CameraOnScreen.App/MainWindow.xaml
+++ b/src/CameraOnScreen.App/MainWindow.xaml
@@ -2,8 +2,10 @@
     x:Class="CameraOnScreen.App.MainWindow"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:local="using:CameraOnScreen.App">
-    <Grid>
+    xmlns:muxc="using:Microsoft.UI.Xaml.Controls"
+    xmlns:local="using:CameraOnScreen.App"
+    Title="Camera On Screen">
+    <Grid x:Name="RootGrid">
         <Grid.RowDefinitions>
             <RowDefinition Height="*"/>
             <RowDefinition Height="Auto"/>
@@ -11,75 +13,87 @@
 
         <!-- Controls scroll; the license-required footer (row 1) stays pinned outside. -->
         <ScrollViewer Grid.Row="0" Padding="16">
-            <StackPanel Spacing="12">
-                <ComboBox Header="Camera"
-                          ItemsSource="{x:Bind Vm.Cameras}"
-                          SelectedItem="{x:Bind Vm.SelectedCamera, Mode=TwoWay}"
-                          DisplayMemberPath="Name" Width="280"/>
+            <StackPanel Spacing="16">
 
-                <StackPanel Spacing="8">
-                    <ToggleSwitch Header="AI Green Screen" IsEnabled="{x:Bind Vm.EffectsAvailable, Mode=OneWay}"
-                                  IsOn="{x:Bind Vm.GreenScreenEnabled, Mode=TwoWay}"/>
-                    <Slider Header="Green-screen Expand" Minimum="0" Maximum="1" StepFrequency="0.05"
-                            IsEnabled="{x:Bind Vm.GreenScreenEnabled, Mode=OneWay}"
-                            Value="{x:Bind Vm.GreenScreenExpand, Mode=TwoWay}"/>
-                    <Slider Header="Green-screen Feather" Minimum="0" Maximum="1" StepFrequency="0.05"
-                            IsEnabled="{x:Bind Vm.GreenScreenEnabled, Mode=OneWay}"
-                            Value="{x:Bind Vm.GreenScreenFeather, Mode=TwoWay}"/>
-                    <ToggleSwitch Header="Eye Contact" IsEnabled="{x:Bind Vm.EyeContactAvailable, Mode=OneWay}"
-                                  IsOn="{x:Bind Vm.EyeContactEnabled, Mode=TwoWay}"/>
-                    <TextBlock Text="{x:Bind Vm.EyeContactDetail, Mode=OneWay}"
-                               Visibility="{x:Bind EyeContactNotAvailableVisibility, Mode=OneWay}"
-                               Foreground="{ThemeResource SystemFillColorCautionBrush}"/>
-
-                    <!-- AI Sharpness (VSR): Denoise (QualityLevel 8-11) or Deblur (12-15), both at
-                         native res. Upscale dropped — wasted on a downscaled overlay. Quality picks
-                         the tier (Low..Ultra). -->
-                    <ComboBox Header="AI Sharpness"
-                              IsEnabled="{x:Bind Vm.SuperResAvailable, Mode=OneWay}"
-                              SelectedIndex="{x:Bind Vm.SuperResModeIndex, Mode=TwoWay}">
-                        <ComboBoxItem Content="Off"/>
-                        <ComboBoxItem Content="Denoise"/>
-                        <ComboBoxItem Content="Deblur"/>
-                    </ComboBox>
-                    <ComboBox Header="Quality"
-                              IsEnabled="{x:Bind local:MainWindow.QualityEnabled(Vm.SuperResAvailable, Vm.SuperResModeIndex), Mode=OneWay}"
-                              SelectedIndex="{x:Bind Vm.SuperResQualityIndex, Mode=TwoWay}">
-                        <ComboBoxItem Content="Low"/>
-                        <ComboBoxItem Content="Medium"/>
-                        <ComboBoxItem Content="High"/>
-                        <ComboBoxItem Content="Ultra"/>
-                    </ComboBox>
-                    <TextBlock Text="{x:Bind Vm.CapabilityDetail, Mode=OneWay}"
-                               Visibility="{x:Bind NotAvailableVisibility, Mode=OneWay}"
-                               Foreground="{ThemeResource SystemFillColorCautionBrush}"/>
-
-                    <!-- Exposure lock (#16): pin the camera to Manual exposure so framerate holds in
-                         low light. Greyed until running AND the camera reports manual-exposure support
-                         (known only after Start, via status poll). Slider trades brightness vs fps. -->
-                    <ToggleSwitch Header="Lock exposure (steady FPS)"
-                                  IsEnabled="{x:Bind Vm.ExposureSupported, Mode=OneWay}"
-                                  IsOn="{x:Bind Vm.ExposureLock, Mode=TwoWay}"/>
-                    <Slider Header="Exposure" Minimum="0" Maximum="1" StepFrequency="0.05"
-                            IsEnabled="{x:Bind local:MainWindow.ExposureSliderEnabled(Vm.ExposureSupported, Vm.ExposureLock), Mode=OneWay}"
-                            Value="{x:Bind Vm.ExposureValue, Mode=TwoWay}"/>
+                <muxc:InfoBar Severity="Informational" IsOpen="True" IsClosable="False"
+                              Title="Overlay tips"
+                              Message="Scroll over the overlay to resize it · drag the + handle to move it."/>
 
-                    <ToggleSwitch Header="Lock overlay"
-                                  IsOn="{x:Bind Vm.Locked, Mode=TwoWay}"/>
-                    <ToggleSwitch Header="Click-through"
-                                  IsOn="{x:Bind Vm.ClickThrough, Mode=TwoWay}"/>
-                    <ToggleSwitch Header="Mirror (selfie view)"
-                                  IsOn="{x:Bind Vm.Mirror, Mode=TwoWay}"/>
-                    <Slider Header="Zoom" Minimum="1" Maximum="3" StepFrequency="0.1"
-                            Value="{x:Bind Vm.Zoom, Mode=TwoWay}"/>
+                <!-- CAMERA -->
+                <StackPanel Spacing="8">
+                    <TextBlock Text="Camera" Style="{ThemeResource BodyStrongTextBlockStyle}"/>
+                    <Border Background="{ThemeResource CardBackgroundFillColorDefaultBrush}"
+                            BorderBrush="{ThemeResource CardStrokeColorDefaultBrush}"
+                            BorderThickness="1" CornerRadius="8" Padding="12">
+                        <StackPanel Spacing="12">
+                            <ComboBox Header="Camera"
+                                      ItemsSource="{x:Bind Vm.Cameras}"
+                                      SelectedItem="{x:Bind Vm.SelectedCamera, Mode=TwoWay}"
+                                      DisplayMemberPath="Name" HorizontalAlignment="Stretch"/>
+                            <StackPanel Orientation="Horizontal" Spacing="8">
+                                <Button Content="Start" Command="{x:Bind Vm.StartCommand}"
+                                        AutomationProperties.Name="Start capture"/>
+                                <Button Content="Stop" Command="{x:Bind Vm.StopCommand}"
+                                        AutomationProperties.Name="Stop capture"/>
+                                <TextBlock Text="{x:Bind StatusLine, Mode=OneWay}"
+                                           VerticalAlignment="Center"
+                                           AutomationProperties.LiveSetting="Polite"/>
+                            </StackPanel>
+                            <ToggleSwitch Header="Mirror (selfie view)"
+                                          IsOn="{x:Bind Vm.Mirror, Mode=TwoWay}"/>
+                            <ToggleSwitch Header="Lock exposure (steady FPS)"
+                                          IsEnabled="{x:Bind Vm.ExposureSupported, Mode=OneWay}"
+                                          IsOn="{x:Bind Vm.ExposureLock, Mode=TwoWay}"/>
+                            <Slider Header="Exposure" Minimum="0" Maximum="1" StepFrequency="0.05"
+                                    IsEnabled="{x:Bind local:MainWindow.ExposureSliderEnabled(Vm.ExposureSupported, Vm.ExposureLock), Mode=OneWay}"
+                                    Value="{x:Bind Vm.ExposureValue, Mode=TwoWay}"/>
+                        </StackPanel>
+                    </Border>
                 </StackPanel>
 
-                <StackPanel Orientation="Horizontal" Spacing="8">
-                    <Button Content="Start" Command="{x:Bind Vm.StartCommand}"/>
-                    <Button Content="Stop" Command="{x:Bind Vm.StopCommand}"/>
+                <!-- AI EFFECTS -->
+                <StackPanel Spacing="8">
+                    <TextBlock Text="AI Effects" Style="{ThemeResource BodyStrongTextBlockStyle}"/>
+                    <Border Background="{ThemeResource CardBackgroundFillColorDefaultBrush}"
+                            BorderBrush="{ThemeResource CardStrokeColorDefaultBrush}"
+                            BorderThickness="1" CornerRadius="8" Padding="12">
+                        <StackPanel Spacing="12">
+                            <ToggleSwitch Header="AI Green Screen" IsEnabled="{x:Bind Vm.EffectsAvailable, Mode=OneWay}"
+                                          IsOn="{x:Bind Vm.GreenScreenEnabled, Mode=TwoWay}"/>
+                            <Slider Header="Green-screen Expand" Minimum="0" Maximum="1" StepFrequency="0.05"
+                                    IsEnabled="{x:Bind Vm.GreenScreenEnabled, Mode=OneWay}"
+                                    Value="{x:Bind Vm.GreenScreenExpand, Mode=TwoWay}"/>
+                            <Slider Header="Green-screen Feather" Minimum="0" Maximum="1" StepFrequency="0.05"
+                                    IsEnabled="{x:Bind Vm.GreenScreenEnabled, Mode=OneWay}"
+                                    Value="{x:Bind Vm.GreenScreenFeather, Mode=TwoWay}"/>
+                            <ToggleSwitch Header="Eye Contact" IsEnabled="{x:Bind Vm.EyeContactAvailable, Mode=OneWay}"
+                                          IsOn="{x:Bind Vm.EyeContactEnabled, Mode=TwoWay}"/>
+                            <TextBlock Text="{x:Bind Vm.EyeContactDetail, Mode=OneWay}"
+                                       Visibility="{x:Bind EyeContactNotAvailableVisibility, Mode=OneWay}"
+                                       TextWrapping="Wrap"
+                                       Foreground="{ThemeResource SystemFillColorCautionBrush}"/>
+                            <ComboBox Header="AI Sharpness"
+                                      IsEnabled="{x:Bind Vm.SuperResAvailable, Mode=OneWay}"
+                                      SelectedIndex="{x:Bind Vm.SuperResModeIndex, Mode=TwoWay}">
+                                <ComboBoxItem Content="Off"/>
+                                <ComboBoxItem Content="Denoise"/>
+                                <ComboBoxItem Content="Deblur"/>
+                            </ComboBox>
+                            <ComboBox Header="Quality"
+                                      IsEnabled="{x:Bind local:MainWindow.QualityEnabled(Vm.SuperResAvailable, Vm.SuperResModeIndex), Mode=OneWay}"
+                                      SelectedIndex="{x:Bind Vm.SuperResQualityIndex, Mode=TwoWay}">
+                                <ComboBoxItem Content="Low"/>
+                                <ComboBoxItem Content="Medium"/>
+                                <ComboBoxItem Content="High"/>
+                                <ComboBoxItem Content="Ultra"/>
+                            </ComboBox>
+                            <TextBlock Text="{x:Bind Vm.CapabilityDetail, Mode=OneWay}"
+                                       Visibility="{x:Bind NotAvailableVisibility, Mode=OneWay}"
+                                       TextWrapping="Wrap"
+                                       Foreground="{ThemeResource SystemFillColorCautionBrush}"/>
+                        </StackPanel>
+                    </Border>
                 </StackPanel>
-
-                <TextBlock Text="{x:Bind StatusLine, Mode=OneWay}"/>
             </StackPanel>
         </ScrollViewer>
 
diff --git a/src/CameraOnScreen.App/MainWindow.xaml.cs b/src/CameraOnScreen.App/MainWindow.xaml.cs
index 8c956da..67ba003 100644
--- a/src/CameraOnScreen.App/MainWindow.xaml.cs
+++ b/src/CameraOnScreen.App/MainWindow.xaml.cs
@@ -9,11 +9,6 @@ namespace CameraOnScreen.App;
 
 public sealed partial class MainWindow : Window, INotifyPropertyChanged
 {
-    // Compact control-panel size (in DIPs) — the panel only holds a few Auto-height rows, so the
-    // WinUI default (~1100×700) leaves it mostly empty. Scaled by the window DPI before Resize,
-    // which wants physical pixels. No layout redesign — sensible defaults only.
-    private const int PanelWidthDip = 400, PanelHeightDip = 720;
-
     [DllImport("user32.dll")] private static extern uint GetDpiForWindow(IntPtr hwnd);
 
     public MainViewModel Vm { get; }
@@ -27,6 +22,9 @@ public sealed partial class MainWindow : Window, INotifyPropertyChanged
     private Microsoft.UI.Dispatching.DispatcherQueueTimer? _timer;
     private Microsoft.UI.Dispatching.DispatcherQueueTimer? _saveTimer; // debounces persist after wheel-resize
     private Overlay.OverlayMouseHook? _mouseHook;
+    private Microsoft.UI.Windowing.AppWindow? _appWindow; // this control-panel window, for size restore/persist
+    // Last control-panel size (physical px) loaded from config; 0 => first launch (size to content).
+    private readonly double _savedPanelW, _savedPanelH;
     // Hook-driven drag state (all touched on the UI thread inside the hook callback).
     private bool _dragging;
     // Cursor-minus-origin offset captured at drag start. The drag MOVE is driven by the frame-pump
@@ -47,17 +45,18 @@ public MainWindow()
         // (e.g. first run, corrupt config, or a config written before geometry was persisted).
         var config = _store.Load();
         var (x, y, w, h) = ResolveStartupBounds(config.Overlay);
+        _savedPanelW = config.PanelWidth;
+        _savedPanelH = config.PanelHeight;
 
         // Build the overlay BEFORE the VM so its D3D device pointer exists when shim.Init runs.
         _overlay = new Overlay.OverlayWindow(x, y, w, h);
         _overlay.Show();
         Vm = Services.BuildViewModel(_overlay);
         Vm.PropertyChanged += OnVmPropertyChanged;
-        // Apply the initial lock / click-through state loaded from config to the overlay.
-        _overlay.SetLocked(Vm.Locked);
-        _overlay.SetClickThrough(Vm.ClickThrough);
+        // Apply the initial state loaded from config to the overlay.
         _overlay.SetMirror(Vm.Mirror);
-        _overlay.SetZoom(Vm.Zoom);
+        // ponytail: overlay stays always-interactive (no SetLocked/SetClickThrough) and unzoomed
+        // (no SetZoom) — Lock/ClickThrough/Zoom were removed from the panel.
 
         // Global hotkeys. RegisterHotKey targets the overlay HWND, so WM_HOTKEY arrives at the
         // overlay proc and is forwarded here via HotkeyPressed → the service. Action handling is
@@ -70,6 +69,12 @@ public MainWindow()
         _overlay.InteractionEnded += Save;
         this.Closed += OnWindowClosed;
         InitializeComponent();
+        // Default Windows title bar (system chrome). Cache the AppWindow for size restore/persist,
+        // and persist (debounced) whenever the user resizes the panel.
+        var panelHwnd = WinRT.Interop.WindowNative.GetWindowHandle(this);
+        _appWindow = Microsoft.UI.Windowing.AppWindow.GetFromWindowId(
+            Microsoft.UI.Win32Interop.GetWindowIdFromWindow(panelHwnd));
+        _appWindow.Changed += OnAppWindowChanged;
         RightSizePanel();
 
         // ~30 Hz frame pump on the WinUI UI thread: pull the latest BGRA frame from the shim and
@@ -110,16 +115,35 @@ public MainWindow()
         _ = Vm.ProbeCapabilitiesAsync();
     }
 
-    // Shrink the control panel from the WinUI default to a compact size that fits its rows.
-    // AppWindow.Resize takes physical pixels, so scale the DIP target by the window's DPI.
+    // Restore the last panel size (physical px) so it reopens as the user left it. First launch
+    // (no saved size): size to content once so every control is visible. ponytail: stored/restored
+    // in physical pixels — a cross-DPI restore (different-scaling monitor between sessions) is
+    // approximate; the user can resize and it re-persists. ScrollViewer is the shrink fallback.
     private void RightSizePanel()
     {
-        var hwnd = WinRT.Interop.WindowNative.GetWindowHandle(this);
-        double scale = GetDpiForWindow(hwnd) / 96.0;
-        var id = Microsoft.UI.Win32Interop.GetWindowIdFromWindow(hwnd);
-        var appWindow = Microsoft.UI.Windowing.AppWindow.GetFromWindowId(id);
-        appWindow.Resize(new Windows.Graphics.SizeInt32(
-            (int)(PanelWidthDip * scale), (int)(PanelHeightDip * scale)));
+        if (_savedPanelW > 0 && _savedPanelH > 0)
+        {
+            _appWindow!.Resize(new Windows.Graphics.SizeInt32((int)_savedPanelW, (int)_savedPanelH));
+            return;
+        }
+        RootGrid.Loaded += (_, _) =>
+        {
+            RootGrid.Measure(new Windows.Foundation.Size(double.PositiveInfinity, double.PositiveInfinity));
+            var hwnd = WinRT.Interop.WindowNative.GetWindowHandle(this);
+            double scale = GetDpiForWindow(hwnd) / 96.0;
+            int w = (int)(RootGrid.DesiredSize.Width * scale);
+            int h = (int)(RootGrid.DesiredSize.Height * scale);
+            if (w > 0 && h > 0)
+                _appWindow!.Resize(new Windows.Graphics.SizeInt32(w, h));
+        };
+    }
+
+    // Persist the panel size when the user resizes it (debounced via _saveTimer, same as wheel-resize).
+    // _saveTimer is created later in the ctor, so the startup Resize's notification no-ops via `?.`.
+    private void OnAppWindowChanged(Microsoft.UI.Windowing.AppWindow sender,
+        Microsoft.UI.Windowing.AppWindowChangedEventArgs args)
+    {
+        if (args.DidSizeChange) { _saveTimer?.Stop(); _saveTimer?.Start(); }
     }
 
     private void OnWindowClosed(object sender, WindowEventArgs args)
@@ -137,7 +161,8 @@ private void OnWindowClosed(object sender, WindowEventArgs args)
         // double-save while teardown is in progress.
         _overlay.InteractionEnded -= Save;
         _overlay.HotkeyPressed -= _hotkeys.OnHotkeyMessage;
-        Save(); // final persist with the closing geometry/state
+        if (_appWindow != null) _appWindow.Changed -= OnAppWindowChanged;
+        Save(); // final persist with the closing geometry/state + panel size
         _hotkeys.Dispose(); // unregister all hotkeys
         Vm.PropertyChanged -= OnVmPropertyChanged;
         Vm.Dispose();
@@ -159,12 +184,11 @@ private void OnHotkeyAction(HotkeyAction action)
         {
             switch (action)
             {
-                case HotkeyAction.ToggleLock: Vm.Locked = !Vm.Locked; break;
-                case HotkeyAction.ToggleClickThrough: Vm.ClickThrough = !Vm.ClickThrough; break;
                 case HotkeyAction.ToggleOverlayVisible: _overlay.ToggleVisible(); break;
                 case HotkeyAction.ToggleRunning:
                     if (Vm.IsRunning) Vm.StopCommand?.Execute(null); else Vm.StartCommand?.Execute(null);
                     break;
+                // ToggleLock/ToggleClickThrough: no-ops now (overlay always interactive); enum kept.
             }
         });
     }
@@ -238,7 +262,12 @@ private static CameraOnScreen.Core.Overlay.Rect GetWorkArea(IntPtr hwnd)
     private void Save()
     {
         var (x, y, w, h) = _overlay.GetBounds();
-        _store.Save(Vm.ToAppConfig(x, y, w, h));
+        var cfg = Vm.ToAppConfig(x, y, w, h);
+        // Also persist the control-panel window size (physical px) so it restores on next launch.
+        var size = _appWindow?.Size ?? default;
+        if (size.Width > 0 && size.Height > 0)
+            cfg = cfg with { PanelWidth = size.Width, PanelHeight = size.Height };
+        _store.Save(cfg);
     }
 
     public Visibility NotAvailableVisibility =>
@@ -271,13 +300,8 @@ private void OnVmPropertyChanged(object? sender, PropertyChangedEventArgs e)
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(NotAvailableVisibility)));
         else if (e.PropertyName == nameof(MainViewModel.EyeContactAvailable))
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(EyeContactNotAvailableVisibility)));
-        else if (e.PropertyName == nameof(MainViewModel.Locked))
-            _overlay.SetLocked(Vm.Locked);
-        else if (e.PropertyName == nameof(MainViewModel.ClickThrough))
-            _overlay.SetClickThrough(Vm.ClickThrough);
         else if (e.PropertyName == nameof(MainViewModel.Mirror))
             _overlay.SetMirror(Vm.Mirror);
-        else if (e.PropertyName == nameof(MainViewModel.Zoom))
-            _overlay.SetZoom(Vm.Zoom);
+        // Locked/ClickThrough/Zoom branches removed — those props no longer exist.
     }
 }
diff --git a/src/CameraOnScreen.Core/Config/Models.cs b/src/CameraOnScreen.Core/Config/Models.cs
index 12aa5e4..0d0d2d5 100644
--- a/src/CameraOnScreen.Core/Config/Models.cs
+++ b/src/CameraOnScreen.Core/Config/Models.cs
@@ -48,12 +48,13 @@ public sealed record AppConfig
     public OverlaySettings Overlay { get; init; } = new();
     public EffectSettings Effects { get; init; } = new();
     public IReadOnlyList<HotkeyBinding> Hotkeys { get; init; } = DefaultHotkeys();
+    // Control-panel window size in physical pixels (0 = unset → first launch sizes to content).
+    public double PanelWidth { get; init; }
+    public double PanelHeight { get; init; }
 
-    // VK codes: F8=0x77, F9=0x78, F10=0x79, F11=0x7A
+    // VK codes: F10=0x79, F11=0x7A. (ToggleLock/ToggleClickThrough F8/F9 defaults removed; enum members kept.)
     public static IReadOnlyList<HotkeyBinding> DefaultHotkeys() => Array.AsReadOnly(new[]
     {
-        new HotkeyBinding { Action = HotkeyAction.ToggleLock,          Modifiers = HotkeyModifiers.Control | HotkeyModifiers.Alt, VirtualKey = 0x77 },
-        new HotkeyBinding { Action = HotkeyAction.ToggleClickThrough,  Modifiers = HotkeyModifiers.Control | HotkeyModifiers.Alt, VirtualKey = 0x78 },
         new HotkeyBinding { Action = HotkeyAction.ToggleOverlayVisible,Modifiers = HotkeyModifiers.Control | HotkeyModifiers.Alt, VirtualKey = 0x79 },
         new HotkeyBinding { Action = HotkeyAction.ToggleRunning,       Modifiers = HotkeyModifiers.Control | HotkeyModifiers.Alt, VirtualKey = 0x7A },
     });
@@ -62,11 +63,13 @@ public bool Equals(AppConfig? other) => other != null
         && CameraId == other.CameraId
         && Overlay == other.Overlay
         && Effects == other.Effects
+        && PanelWidth == other.PanelWidth
+        && PanelHeight == other.PanelHeight
         && Hotkeys.SequenceEqual(other.Hotkeys);
 
     public override int GetHashCode()
     {
         var hk = Hotkeys.Aggregate(0, (h, b) => HashCode.Combine(h, b));
-        return HashCode.Combine(CameraId, Overlay, Effects, hk);
+        return HashCode.Combine(CameraId, Overlay, Effects, hk, PanelWidth, PanelHeight);
     }
 }
diff --git a/src/CameraOnScreen.Core/ViewModels/MainViewModel.cs b/src/CameraOnScreen.Core/ViewModels/MainViewModel.cs
index 2fd8fb4..372e2e7 100644
--- a/src/CameraOnScreen.Core/ViewModels/MainViewModel.cs
+++ b/src/CameraOnScreen.Core/ViewModels/MainViewModel.cs
@@ -73,10 +73,7 @@ public async Task ProbeCapabilitiesAsync()
     [ObservableProperty] private double exposureValue = 0.5;    // 0..1 normalized; only meaningful when locked
     [ObservableProperty] private bool exposureSupported;        // camera exposes manual exposure (status poll, while running)
     [ObservableProperty] private bool isRunning;
-    [ObservableProperty] private bool locked;
-    [ObservableProperty] private bool clickThrough;
     [ObservableProperty] private bool mirror;
-    [ObservableProperty] private double zoom = 1.0;
     [ObservableProperty] private double fps;
     [ObservableProperty] private string? statusError;
     [ObservableProperty] private GazeState gaze;
@@ -103,26 +100,24 @@ public void LoadFrom(AppConfig config)
         SuperResQualityIndex = Math.Clamp(config.Effects.SuperResQuality, 0, 3);
         ExposureLock = config.Effects.ExposureLock;
         ExposureValue = Math.Clamp(config.Effects.ExposureValue, 0.0, 1.0);
-        Locked = config.Overlay.Locked;
-        ClickThrough = config.Overlay.ClickThrough;
         Mirror = config.Overlay.Mirror;
-        Zoom = config.Overlay.Zoom;
         _hotkeys = config.Hotkeys;
         if (config.CameraId is not null)
             SelectedCamera = Cameras.FirstOrDefault(c => c.Id == config.CameraId);
     }
 
     // Capture current VM + overlay state into a persistable AppConfig. Geometry is passed in by the
-    // caller (read from the live overlay window). Locked/ClickThrough are the existing observable
-    // props (Task 13) — used here, not redeclared.
+    // caller (read from the live overlay window). Mirror is the kept observable prop; Lock/ClickThrough/Zoom were removed (overlay is always interactive).
     public AppConfig ToAppConfig(double x, double y, double w, double h) => new()
     {
         CameraId = SelectedCamera?.Id,
         Overlay = new OverlaySettings
         {
             X = x, Y = y, Width = w, Height = h,
-            Locked = Locked, ClickThrough = ClickThrough,
-            Mirror = Mirror, Zoom = Zoom
+            // ponytail: Locked/ClickThrough/Zoom intentionally omitted — fields kept on the record
+            // (default false/false/1.0) so config stays schema-stable; the overlay is always
+            // interactive and unzoomed now.
+            Mirror = Mirror
         },
         Effects = new EffectSettings
         {
diff --git a/tests/CameraOnScreen.Core.Tests/Config/JsonSettingsStoreTests.cs b/tests/CameraOnScreen.Core.Tests/Config/JsonSettingsStoreTests.cs
index f7fb859..462637f 100644
--- a/tests/CameraOnScreen.Core.Tests/Config/JsonSettingsStoreTests.cs
+++ b/tests/CameraOnScreen.Core.Tests/Config/JsonSettingsStoreTests.cs
@@ -104,4 +104,24 @@ public void Save_then_load_round_trips_overlay_mirror_and_zoom()
             if (File.Exists(path)) File.Delete(path);
         }
     }
+
+    [Fact]
+    public void Save_then_load_round_trips_panel_size()
+    {
+        var path = Path.Combine(Path.GetTempPath(), $"cos-cfg-{Guid.NewGuid():N}.json");
+        try
+        {
+            var store = new JsonSettingsStore(path);
+            store.Save(new AppConfig { PanelWidth = 460, PanelHeight = 815 });
+
+            var loaded = store.Load();
+
+            Assert.Equal(460, loaded.PanelWidth);
+            Assert.Equal(815, loaded.PanelHeight);
+        }
+        finally
+        {
+            if (File.Exists(path)) File.Delete(path);
+        }
+    }
 }
diff --git a/tests/CameraOnScreen.Core.Tests/Config/ModelsTests.cs b/tests/CameraOnScreen.Core.Tests/Config/ModelsTests.cs
index 0e8ba89..c052142 100644
--- a/tests/CameraOnScreen.Core.Tests/Config/ModelsTests.cs
+++ b/tests/CameraOnScreen.Core.Tests/Config/ModelsTests.cs
@@ -12,7 +12,7 @@ public class ModelsTests
     [Fact]
     public void Flags_modifiers_round_trip_as_names()
     {
-        var config = new AppConfig(); // defaults include Control|Alt on all 4 hotkeys
+        var config = new AppConfig(); // defaults include Control|Alt on all hotkeys
         var json = ConfigSerializer.Serialize(config);
         _output.WriteLine("Serialized JSON snippet (Modifiers):");
         _output.WriteLine(json);
@@ -37,7 +37,7 @@ public void AppConfig_defaults_are_sane()
         Assert.Equal(OverlayShape.Full, c.Overlay.Shape);
         Assert.True(c.Effects.GreenScreenEnabled);
         Assert.False(c.Effects.EyeContactEnabled);
-        Assert.Equal(4, c.Hotkeys.Count); // one per HotkeyAction
+        Assert.Equal(2, c.Hotkeys.Count); // ToggleOverlayVisible, ToggleRunning (Lock/ClickThrough are dead)
     }
 
     [Fact]
diff --git a/tests/CameraOnScreen.Core.Tests/ViewModels/MainViewModelTests.cs b/tests/CameraOnScreen.Core.Tests/ViewModels/MainViewModelTests.cs
index 2b7b43b..16f53d3 100644
--- a/tests/CameraOnScreen.Core.Tests/ViewModels/MainViewModelTests.cs
+++ b/tests/CameraOnScreen.Core.Tests/ViewModels/MainViewModelTests.cs
@@ -147,30 +147,27 @@ public void Start_sets_running_and_OnStatus_updates_fps()
     }
 
     [Fact]
-    public void LoadFrom_propagates_locked_and_clickthrough()
+    public void LoadFrom_propagates_mirror()
     {
         var vm = Build(GpuTier.Rtx, out _);
         var config = new AppConfig
         {
-            Overlay = new OverlaySettings { Locked = true, ClickThrough = true }
+            Overlay = new OverlaySettings { Mirror = true }
         };
         vm.LoadFrom(config);
-        Assert.True(vm.Locked);
-        Assert.True(vm.ClickThrough);
+        Assert.True(vm.Mirror);
     }
 
     [Fact]
     public void ToAppConfig_captures_geometry_and_effects()
     {
         var vm = Build(GpuTier.Rtx, out _);
-        vm.GreenScreenEnabled = true; vm.Locked = true;
+        vm.GreenScreenEnabled = true;
         var cfg = vm.ToAppConfig(10, 20, 300, 400);
         Assert.Equal(10, cfg.Overlay.X);
         Assert.Equal(20, cfg.Overlay.Y);
         Assert.Equal(300, cfg.Overlay.Width);
         Assert.Equal(400, cfg.Overlay.Height);
-        Assert.True(cfg.Overlay.Locked);
-        Assert.False(cfg.Overlay.ClickThrough);
         Assert.True(cfg.Effects.GreenScreenEnabled);
         Assert.Null(cfg.CameraId);
     }
@@ -194,27 +191,12 @@ public void ToAppConfig_preserves_loaded_hotkeys()
     }
 
     [Fact]
-    public void LoadFrom_propagates_mirror_and_zoom()
-    {
-        var vm = Build(GpuTier.Rtx, out _);
-        var config = new AppConfig
-        {
-            Overlay = new OverlaySettings { Mirror = true, Zoom = 2.0 }
-        };
-        vm.LoadFrom(config);
-        Assert.True(vm.Mirror);
-        Assert.Equal(2.0, vm.Zoom);
-    }
-
-    [Fact]
-    public void ToAppConfig_captures_mirror_and_zoom()
+    public void ToAppConfig_captures_mirror()
     {
         var vm = Build(GpuTier.Rtx, out _);
         vm.Mirror = true;
-        vm.Zoom = 1.5;
         var cfg = vm.ToAppConfig(10, 20, 300, 400);
         Assert.True(cfg.Overlay.Mirror);
-        Assert.Equal(1.5, cfg.Overlay.Zoom);
     }
 
     [Fact]