From 43be393973873a171508bafe4280c2ddd44c8e90 Mon Sep 17 00:00:00 2001
From: Quadstronaut <2138096+Quadstronaut@users.noreply.github.com>
Date: Sat, 25 Apr 2026 19:48:42 -0700
Subject: [PATCH 1/5] Apply Taneth color palette: deep-green hull with gold HUD
 accent

Refreshes the dark theme from neutral grey/green to the Taneth palette
(deep-green surfaces, warm gold accent). Adds AccentForegroundBrush so
text on accent fills uses a dark color that meets WCAG AA contrast.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 windows/App.xaml        | 34 ++++++++++++++++++----------------
 windows/MainWindow.xaml |  4 ++--
 2 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/windows/App.xaml b/windows/App.xaml
index 8aeccde..b6f22f8 100644
--- a/windows/App.xaml
+++ b/windows/App.xaml
@@ -6,20 +6,21 @@
     <Application.Resources>
         <ResourceDictionary>
 
-            <!-- ── Color Palette ─────────────────────────────────────────────── -->
-            <Color x:Key="AccentColor">#50C878</Color>
-            <Color x:Key="AccentHoverColor">#3DAF62</Color>
-            <Color x:Key="AccentPressedColor">#2E9150</Color>
-            <Color x:Key="DangerColor">#E05252</Color>
-            <Color x:Key="DangerHoverColor">#C43C3C</Color>
-            <Color x:Key="BackgroundColor">#1A1A1A</Color>
-            <Color x:Key="SurfaceColor">#242424</Color>
-            <Color x:Key="SurfaceElevatedColor">#2E2E2E</Color>
-            <Color x:Key="BorderColor">#3A3A3A</Color>
-            <Color x:Key="TextPrimaryColor">#F0F0F0</Color>
-            <Color x:Key="TextSecondaryColor">#9A9A9A</Color>
-            <Color x:Key="TextDisabledColor">#555555</Color>
-            <Color x:Key="StatusWaitingColor">#E0A030</Color>
+            <!-- ── Color Palette (Taneth: deep green hull, gold HUD accent) ──── -->
+            <Color x:Key="AccentColor">#E8B547</Color>
+            <Color x:Key="AccentHoverColor">#F5C75A</Color>
+            <Color x:Key="AccentPressedColor">#B88A2A</Color>
+            <Color x:Key="AccentForegroundColor">#0A1410</Color>
+            <Color x:Key="DangerColor">#E04030</Color>
+            <Color x:Key="DangerHoverColor">#C8331E</Color>
+            <Color x:Key="BackgroundColor">#0A1410</Color>
+            <Color x:Key="SurfaceColor">#13211C</Color>
+            <Color x:Key="SurfaceElevatedColor">#1B2E27</Color>
+            <Color x:Key="BorderColor">#2D5448</Color>
+            <Color x:Key="TextPrimaryColor">#E8DCB0</Color>
+            <Color x:Key="TextSecondaryColor">#7A9088</Color>
+            <Color x:Key="TextDisabledColor">#3D5048</Color>
+            <Color x:Key="StatusWaitingColor">#5BA89A</Color>
 
             <!-- ── Brushes ────────────────────────────────────────────────────── -->
             <SolidColorBrush x:Key="AccentBrush"           Color="{StaticResource AccentColor}" />
@@ -35,6 +36,7 @@
             <SolidColorBrush x:Key="TextSecondaryBrush"    Color="{StaticResource TextSecondaryColor}" />
             <SolidColorBrush x:Key="TextDisabledBrush"     Color="{StaticResource TextDisabledColor}" />
             <SolidColorBrush x:Key="StatusWaitingBrush"    Color="{StaticResource StatusWaitingColor}" />
+            <SolidColorBrush x:Key="AccentForegroundBrush" Color="{StaticResource AccentForegroundColor}" />
 
             <!-- ── Label ─────────────────────────────────────────────────────── -->
             <Style TargetType="Label">
@@ -156,7 +158,7 @@
                                 </Trigger>
                                 <Trigger Property="IsSelected" Value="True">
                                     <Setter TargetName="ItemBorder" Property="Background" Value="{StaticResource AccentBrush}" />
-                                    <Setter Property="Foreground" Value="White" />
+                                    <Setter Property="Foreground" Value="{StaticResource AccentForegroundBrush}" />
                                 </Trigger>
                             </ControlTemplate.Triggers>
                         </ControlTemplate>
@@ -195,7 +197,7 @@
             <!-- ── Start Button ──────────────────────────────────────────────── -->
             <Style x:Key="StartButtonStyle" TargetType="Button">
                 <Setter Property="Background"      Value="{StaticResource AccentBrush}" />
-                <Setter Property="Foreground"      Value="White" />
+                <Setter Property="Foreground"      Value="{StaticResource AccentForegroundBrush}" />
                 <Setter Property="FontFamily"      Value="Segoe UI" />
                 <Setter Property="FontSize"        Value="15" />
                 <Setter Property="FontWeight"      Value="Bold" />
diff --git a/windows/MainWindow.xaml b/windows/MainWindow.xaml
index e649180..86ca649 100644
--- a/windows/MainWindow.xaml
+++ b/windows/MainWindow.xaml
@@ -2,8 +2,8 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         Title="QuadClicker"
-        Width="430" Height="470"
-        MinWidth="380" MinHeight="440"
+        Width="430" Height="460"
+        MinWidth="380" MinHeight="430"
         Background="{StaticResource BackgroundBrush}"
         Foreground="{StaticResource TextPrimaryBrush}"
         ResizeMode="CanMinimize"

From 31377210786eefc06559ecbb08f255ca9824244d Mon Sep 17 00:00:00 2001
From: Quadstronaut <2138096+Quadstronaut@users.noreply.github.com>
Date: Sat, 25 Apr 2026 19:50:39 -0700
Subject: [PATCH 2/5] Add design spec for Click Rate redesign

Splits the Click Rate input into a Mode radio (Delay/Frequency) plus
a unit dropdown that swaps with the mode, with a live conversion hint
and a "very fast" warning at >100/s.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../2026-04-25-click-rate-redesign-design.md  | 177 ++++++++++++++++++
 1 file changed, 177 insertions(+)
 create mode 100644 docs/superpowers/specs/2026-04-25-click-rate-redesign-design.md

diff --git a/docs/superpowers/specs/2026-04-25-click-rate-redesign-design.md b/docs/superpowers/specs/2026-04-25-click-rate-redesign-design.md
new file mode 100644
index 0000000..ab20b9e
--- /dev/null
+++ b/docs/superpowers/specs/2026-04-25-click-rate-redesign-design.md
@@ -0,0 +1,177 @@
+# Click Rate Redesign — Design Spec
+
+**Date:** 2026-04-25
+**Scope:** Windows app (`windows/`). macOS and Linux tracks unchanged.
+**Status:** Approved for implementation.
+
+## Problem
+
+The current Click Rate input mixes two paradigms (delay-per-click vs. clicks-per-time-unit) into a single value+unit row:
+
+```
+Click Rate:  [100] [ms ▾]      ← unit dropdown contains: ms, /s, /min
+```
+
+Users have to mentally translate: "I want 10 clicks/sec" → "that's 100 ms" — or rely on the parser to accept either. The current ms default also implies a frame-of-reference (delay) that not all users share. The dropdown silently mixes `ms` (a duration) with `/s` and `/min` (rates), which is the same kind of category error as putting "miles" and "miles per hour" in the same dropdown.
+
+## Goal
+
+Split the control into a **Mode** (Delay vs. Frequency) chosen by radio button, and surface only the units valid for that mode. Show a live conversion hint so users build intuition without having to think in two paradigms at once. Add a "very fast" warning before users land on rates that misbehave on most apps.
+
+## Non-goals
+
+- Not redesigning any other field (mouse button, click type, location, stop conditions, hotkeys).
+- Not changing macOS or Linux apps.
+- Not changing the click engine or input injection.
+- Not breaking existing CLI scripts.
+
+## Design
+
+### 1. UX / Layout (`MainWindow.xaml`)
+
+Replace the single Click Rate row with a two-row block:
+
+```
+Click Rate:   ◉ Delay   ○ Frequency
+              [ 100  ] [ ms     ▾ ]
+              ≈ 10 clicks/sec
+```
+
+Toggling to **Frequency**:
+```
+Click Rate:   ○ Delay   ◉ Frequency
+              [ 10   ] [ per sec ▾ ]
+              ≈ 100 ms between clicks
+```
+
+**Behavior**
+
+- Mode radios live on the same row as the `Click Rate:` label, on the right, in a horizontal `StackPanel`.
+- The value `TextBox` is fixed-width (~80px), the unit `ComboBox` (~110px) follows.
+- Toggling Mode swaps the dropdown's items and re-validates the current value against the new mode's bounds. If out of range for the new mode, the value is clamped (silent — not an error).
+- The hint line below uses `TextSecondary` color, 11px, single line.
+- When the effective rate is **> 100 clicks/second** (delay < 10ms), the hint switches to `Danger` color and shows `⚠ Very fast — input may not register reliably` followed by the conversion (`≈ 50 ms between clicks`) on the same wrapped block.
+- Numeric value box: positive numbers only. Decimals allowed for `sec`, `min`, `per min`, `per hour`. Integer-only enforced for `ms` and `per sec`.
+- Empty / zero / out-of-range hard-rejects only on Start (existing inline `ErrorLabel`) — the live hint just gives feedback.
+- Window height grows ~30px (one extra row). Stays within `MinHeight=430`.
+
+**Units exposed**
+
+| Mode | Dropdown items (Tag values) | Bounds |
+|---|---|---|
+| Delay | `ms`, `sec`, `min` | 1 ms – 360 min |
+| Frequency | `per sec`, `per min`, `per hour` | 1 / hour – 1000 / sec |
+
+Hard floor is **1 ms** (= 1000/sec). Hard ceiling for delay is **360 min** (= 6 hours). These bounds are enforced in the parser, not just the UI.
+
+### 2. Parser (`Core/ClickRateParser.cs`)
+
+**Additive only** — every existing format keeps working. New unit tokens:
+
+| New token forms | Parses to |
+|---|---|
+| `s`, `sec`, `seconds`, `secs` (suffix) | seconds → ms |
+| `m`, `min`, `minutes`, `mins` (suffix) | minutes → ms |
+| `/h`, `cph`, `times per hour` | per hour → ms delay |
+
+**Disambiguation**: `m` alone is ambiguous (minutes vs. milliseconds-prefix-typo) — accept it as **minutes**, since `ms` is parsed first. Order of suffix checks: `ms` → `min`/`m` → `sec`/`s` → `/h`/`cph` → `/min`/`cpm` → `/s`/`cps` → bare integer.
+
+**Bounds enforcement** (all paths, not just new ones):
+
+```
+const long MaxDelayMs = 360L * 60_000;  // 360 minutes
+const double MinDelayMs = 1.0;
+```
+
+If parsed delay falls outside `[MinDelayMs, MaxDelayMs]`, return `false` with a clear error message.
+
+**Public surface unchanged**:
+```csharp
+public static bool TryParse(string text, out TimeSpan delay, out string error)
+```
+
+CLI consumers and existing tests continue to work.
+
+### 3. Settings (`Models/AppSettings.cs`)
+
+**New schema**:
+```csharp
+public ClickRateMode ClickRateMode    { get; set; } = ClickRateMode.Delay;
+public string        ClickRateValue   { get; set; } = "100";
+public string        ClickRateUnit    { get; set; } = "ms";   // canonical Tag value
+```
+
+**New enum** in `Models/ClickRateMode.cs`:
+```csharp
+public enum ClickRateMode { Delay, Frequency }
+```
+
+**Canonical unit tags** (stored as strings for forward-compat, enum'd at runtime):
+- Delay: `"ms"`, `"sec"`, `"min"`
+- Frequency: `"per_sec"`, `"per_min"`, `"per_hour"`
+
+**Migration** (handled in `AppSettings.Load()`):
+- After deserialization, if `ClickRateMode` is missing/default AND the old `ClickRateUnit` is one of the legacy values:
+  - `"ms"` → Mode=Delay, Unit=`"ms"`
+  - `"/s"` → Mode=Frequency, Unit=`"per_sec"`
+  - `"/min"` → Mode=Frequency, Unit=`"per_min"`
+- Migration runs once; the next `Save()` writes the new schema and the legacy unit string is overwritten.
+- Detection: a `[JsonIgnore]` flag isn't needed; we detect by checking whether the deserialized `ClickRateUnit` is one of the legacy values that no longer match the new canonical set.
+
+### 4. Code-behind (`MainWindow.xaml.cs`)
+
+New private state: none (all state lives on the controls).
+
+**New handlers**:
+- `ClickRateMode_Changed` — fires when either Mode radio toggles. Repopulates `ClickRateUnitBox` items, restores selection from the matching settings unit (or the first item), and recomputes the hint.
+- `ClickRateValueBox_TextChanged` and `ClickRateUnitBox_SelectionChanged` — recompute the hint by calling the existing `ClickRateParser.TryParse` against the composed string and rendering a counterpart-side view.
+
+**Hint rendering helper** (private static):
+```csharp
+private void UpdateRateHint()
+{
+    if (!ClickRateParser.TryParse(ComposedRateText, out var delay, out _))
+    {
+        RateHintLabel.Text = string.Empty;
+        return;
+    }
+    double cps = 1000.0 / delay.TotalMilliseconds;
+    bool isDelayMode = ModeDelay.IsChecked == true;
+    string conversion = isDelayMode ? FormatRate(cps) : FormatDelay(delay);
+    bool veryFast = cps > 100;
+    RateHintLabel.Foreground = veryFast ? DangerBrush : TextSecondaryBrush;
+    RateHintLabel.Text = veryFast
+        ? $"⚠ Very fast — input may not register reliably  (≈ {conversion})"
+        : $"≈ {conversion}";
+}
+```
+
+Existing `TryBuildSession` updates: composes `value + unit` differently per mode (e.g., `"10per_sec"` → translate `per_sec` → `/s` for parser input, since the parser still speaks the old DSL externally). Or simpler: have a small `ComposeRateString(mode, value, unitTag)` helper that maps internal tag → parser-compatible suffix.
+
+**Persistence**: `SaveSettings()` records `ClickRateMode`, the numeric `ClickRateValue`, and the canonical unit tag.
+
+### 5. Tests
+
+Add to `Tests/ClickRateParserTests.cs`:
+- `Seconds_ValidInput` — `"5s"`, `"5 sec"`, `"5seconds"` → 5000ms.
+- `Minutes_ValidInput` — `"2min"`, `"2 minutes"`, `"2m"` → 120000ms.
+- `PerHour_ValidInput` — `"60/h"`, `"60cph"`, `"60 times per hour"` → 60000ms.
+- `MaxDelay_AcceptedAtBoundary` — `"360min"` parses; `"361min"` rejects.
+- `MaxRate_AcceptedAtBoundary` — `"1000/s"` parses (= 1ms); `"1001/s"` rejects.
+- `MinDelay_RejectsBelowOne` — `"0.5ms"` rejects.
+
+New `Tests/AppSettingsMigrationTests.cs`:
+- Old JSON with `"ClickRateUnit": "/s"` and no `ClickRateMode` field → loads as Frequency / per_sec.
+- Old JSON with `"/min"` → Frequency / per_min.
+- Old JSON with `"ms"` → Delay / ms.
+- New JSON round-trips unchanged.
+
+## Out-of-scope risks accepted
+
+- **Multi-monitor / DPI**: untouched.
+- **Localization**: hint text is English-only (matches the rest of the app).
+- **Accessibility**: radio buttons + textbox + combobox are all natively keyboard-accessible. No new accessibility work needed.
+
+## Rollback
+
+Single-revert friendly. Settings migration is forward-only; users who downgrade get default Delay/100/ms — minor inconvenience, no corruption.

From e760da86949ca3353566e6858a24adacc53fffc5 Mon Sep 17 00:00:00 2001
From: Quadstronaut <2138096+Quadstronaut@users.noreply.github.com>
Date: Sat, 25 Apr 2026 20:00:17 -0700
Subject: [PATCH 3/5] Redesign Click Rate input: split delay vs. frequency
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Click Rate row now starts with a Mode radio (Delay / Frequency)
that swaps the unit dropdown's contents and shows a live conversion
hint, so users no longer have to mix milliseconds and rates in the
same control.

- Parser: adds sec/min/hour units; enforces 1 ms ≤ delay ≤ 360 min and
  ≤ 1000 clicks/sec via MinDelayMs / MaxDelayMs constants. All previous
  formats keep parsing, so CLI scripts are unaffected.
- Settings: new ClickRateMode field; legacy "/s" and "/min" values
  silently migrate to (Frequency, per_sec) and (Frequency, per_min) on
  first load.
- UI: live "≈ X clicks/sec" / "≈ X ms between clicks" hint; switches
  to Danger color with "Very fast — input may not register reliably"
  warning when effective rate exceeds 100/s.
- Tests: 38 new tests cover new units, both bound boundaries,
  frequency/duration disambiguation, and settings migration.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 README.md                                  |   4 +-
 windows/Cli/CliEntryPoint.cs               |   4 +-
 windows/Core/ClickRateParser.cs            | 122 ++++++++++++----
 windows/MainWindow.xaml                    |  39 +++--
 windows/MainWindow.xaml.cs                 | 161 +++++++++++++++++++--
 windows/Models/AppSettings.cs              |  68 ++++++---
 windows/Models/ClickRateMode.cs            |   3 +
 windows/Tests/AppSettingsMigrationTests.cs | 104 +++++++++++++
 windows/Tests/ClickRateParserTests.cs      | 111 ++++++++++++++
 windows/Tests/QuadClicker.Tests.csproj     |   1 +
 10 files changed, 550 insertions(+), 67 deletions(-)
 create mode 100644 windows/Models/ClickRateMode.cs
 create mode 100644 windows/Tests/AppSettingsMigrationTests.cs

diff --git a/README.md b/README.md
index 994e1bb..032772e 100644
--- a/README.md
+++ b/README.md
@@ -23,7 +23,7 @@ QuadClicker is the definitive open-source auto-clicker: fully configurable, scri
 
 ## Features
 
-- **Click Rate** — Enter any format: `100ms`, `10/s`, `10cps`, `600/min`, `600cpm`, or a bare integer (ms)
+- **Click Rate** — Pick **Delay** (`ms` / `sec` / `min`) or **Frequency** (per sec / per min / per hour) via radio. CLI also accepts free-form: `100ms`, `5s`, `2min`, `10/s`, `10cps`, `600/min`, `600cpm`, `60/h`, `60cph`, or a bare integer (ms). Bounds: 1 ms ≤ delay ≤ 360 min.
 - **Mouse Button** — Left, Right, or Middle
 - **Click Type** — Single or Double (uses OS double-click interval)
 - **Location Modes**
@@ -128,7 +128,7 @@ quadclicker [OPTIONS]
 
 | Argument | Type | Default | Description |
 |---|---|---|---|
-| `--rate <value>` | string | required | Click rate. Formats: `100ms` · `10/s` · `600/min` |
+| `--rate <value>` | string | required | Click rate. Formats: `100ms` · `5s` · `2min` · `10/s` · `600/min` · `60/h` (1 ms – 360 min) |
 | `--button <left\|right\|middle>` | enum | `left` | Mouse button |
 | `--type <single\|double>` | enum | `single` | Click type |
 | `--location <x,y>` | int pair | cursor | Fixed screen coordinate |
diff --git a/windows/Cli/CliEntryPoint.cs b/windows/Cli/CliEntryPoint.cs
index 333f497..6246431 100644
--- a/windows/Cli/CliEntryPoint.cs
+++ b/windows/Cli/CliEntryPoint.cs
@@ -183,7 +183,7 @@ private static void PrintHelp() => Console.WriteLine("""
         When run without arguments, launches the GUI.
 
         Options:
-          --rate <value>               Click rate. Formats: 100ms | 10/s | 600/min  [required in CLI mode]
+          --rate <value>               Click rate. Formats: 100ms | 5s | 2min | 10/s | 600/min | 60/h  [required in CLI mode]
           --button <left|right|middle> Mouse button to click (default: left)
           --type <single|double>       Click type (default: single)
           --location <x,y>             Fixed screen coordinate (default: current cursor)
@@ -206,5 +206,7 @@ 130 Ctrl+C / interrupted
           quadclicker --rate 10/s --location 500,300 --button right --stop-after-clicks 100
           quadclicker --rate 500ms --type double --stop-after-seconds 30
           quadclicker --rate 1ms --button middle --stop-after-clicks 50
+          quadclicker --rate 5s --stop-after-clicks 10
+          quadclicker --rate 60/h --stop-after-seconds 3600
         """);
 }
diff --git a/windows/Core/ClickRateParser.cs b/windows/Core/ClickRateParser.cs
index b3acf36..3762088 100644
--- a/windows/Core/ClickRateParser.cs
+++ b/windows/Core/ClickRateParser.cs
@@ -4,11 +4,19 @@ namespace QuadClicker.Core;
 
 /// <summary>
 /// Parses user-supplied click rate strings into a <see cref="TimeSpan"/> delay.
-/// Accepted formats: bare integer (ms), "100ms", "10/s", "10cps", "10 times per second",
-/// "600/min", "600cpm", "600 times per minute".
+/// Accepted formats:
+///   Delay:     "100", "100ms", "5s" / "5sec" / "5 seconds", "2min" / "2m" / "2 minutes"
+///   Frequency: "10/s" / "10cps" / "10 times per second",
+///              "600/min" / "600cpm" / "600 times per minute",
+///              "60/h" / "60cph" / "60 times per hour"
+/// Bounds: 1 ms ≤ delay ≤ 360 min. Frequencies that would produce a delay outside
+/// this range are rejected with a descriptive error.
 /// </summary>
 public static class ClickRateParser
 {
+    public const double MinDelayMs = 1.0;
+    public const long   MaxDelayMs = 360L * 60_000;  // 360 minutes
+
     public static bool TryParse(string text, out TimeSpan delay, out string error)
     {
         delay = TimeSpan.FromMilliseconds(100);
@@ -24,12 +32,34 @@ public static bool TryParse(string text, out TimeSpan delay, out string error)
         // ── Milliseconds: "100ms" ─────────────────────────────────────────────
         if (text.EndsWith("ms"))
         {
-            if (TryParsePositive(text[..^2].Trim(), out double ms) && ms >= 1)
-            {
-                delay = TimeSpan.FromMilliseconds(ms);
-                return true;
-            }
-            error = "Millisecond value must be a number ≥ 1.";
+            if (TryParsePositive(StripSuffix(text, "ms"), out double ms))
+                return TryBuildDelay(ms, out delay, out error);
+            error = "Millisecond value must be a positive number.";
+            return false;
+        }
+
+        // ── Minutes: "2min", "2 minutes", "2m" ────────────────────────────────
+        // Order: longest suffix first. Guards skip frequency forms that share
+        // a final "m" or "min" (cpm, /min, "times per minute").
+        if (EndsWithAny(text, "minutes", "minute", "mins", "min", "m") &&
+            !text.Contains("per minute") && !text.EndsWith("/min") && !text.EndsWith("cpm"))
+        {
+            string num = StripFirstMatchingSuffix(text, "minutes", "minute", "mins", "min", "m");
+            if (TryParsePositive(num, out double minutes))
+                return TryBuildDelay(minutes * 60_000.0, out delay, out error);
+            error = "Minutes value must be a positive number.";
+            return false;
+        }
+
+        // ── Seconds: "5s", "5sec", "5 seconds" ────────────────────────────────
+        // Guards skip /s, cps, "times per second" frequency forms.
+        if (EndsWithAny(text, "seconds", "second", "secs", "sec", "s") &&
+            !text.Contains("per second") && !text.EndsWith("/s") && !text.EndsWith("cps"))
+        {
+            string num = StripFirstMatchingSuffix(text, "seconds", "second", "secs", "sec", "s");
+            if (TryParsePositive(num, out double seconds))
+                return TryBuildDelay(seconds * 1000.0, out delay, out error);
+            error = "Seconds value must be a positive number.";
             return false;
         }
 
@@ -39,12 +69,7 @@ public static bool TryParse(string text, out TimeSpan delay, out string error)
             string num = text.Replace("times per second", "")
                              .Replace("/s", "").Replace("cps", "").Trim();
             if (TryParsePositive(num, out double tps))
-            {
-                double ms = 1000.0 / tps;
-                if (ms < 1) { error = "Rate exceeds maximum — minimum delay is 1ms."; return false; }
-                delay = TimeSpan.FromMilliseconds(ms);
-                return true;
-            }
+                return TryBuildDelay(1000.0 / tps, out delay, out error);
             error = "Clicks-per-second value must be a positive number.";
             return false;
         }
@@ -55,27 +80,72 @@ public static bool TryParse(string text, out TimeSpan delay, out string error)
             string num = text.Replace("times per minute", "")
                              .Replace("/min", "").Replace("cpm", "").Trim();
             if (TryParsePositive(num, out double tpm))
-            {
-                double ms = 60000.0 / tpm;
-                if (ms < 1) { error = "Rate exceeds maximum — minimum delay is 1ms."; return false; }
-                delay = TimeSpan.FromMilliseconds(ms);
-                return true;
-            }
+                return TryBuildDelay(60_000.0 / tpm, out delay, out error);
             error = "Clicks-per-minute value must be a positive number.";
             return false;
         }
 
-        // ── Bare integer/decimal → milliseconds ───────────────────────────────
-        if (TryParsePositive(text, out double bare) && bare >= 1)
+        // ── Clicks/hour: "60/h", "60cph", "60 times per hour" ────────────────
+        if (text.EndsWith("/h") || text.EndsWith("cph") || text.Contains("times per hour"))
         {
-            delay = TimeSpan.FromMilliseconds(bare);
-            return true;
+            string num = text.Replace("times per hour", "")
+                             .Replace("/h", "").Replace("cph", "").Trim();
+            if (TryParsePositive(num, out double tph))
+                return TryBuildDelay(3_600_000.0 / tph, out delay, out error);
+            error = "Clicks-per-hour value must be a positive number.";
+            return false;
         }
 
-        error = "Invalid format. Examples: 100ms  |  10/s  |  600/min";
+        // ── Bare integer/decimal → milliseconds ───────────────────────────────
+        if (TryParsePositive(text, out double bare))
+            return TryBuildDelay(bare, out delay, out error);
+
+        error = "Invalid format. Examples: 100ms  |  5s  |  10/s  |  600/min  |  60/h";
         return false;
     }
 
+    // ── Helpers ──────────────────────────────────────────────────────────────
+
+    private static bool TryBuildDelay(double ms, out TimeSpan delay, out string error)
+    {
+        delay = TimeSpan.Zero;
+        if (double.IsNaN(ms) || double.IsInfinity(ms))
+        {
+            error = "Rate is not a finite number.";
+            return false;
+        }
+        if (ms < MinDelayMs)
+        {
+            error = "Rate exceeds maximum — minimum delay is 1 ms (1000 clicks/sec).";
+            return false;
+        }
+        if (ms > MaxDelayMs)
+        {
+            error = "Delay exceeds maximum of 360 minutes.";
+            return false;
+        }
+        delay = TimeSpan.FromMilliseconds(ms);
+        error = string.Empty;
+        return true;
+    }
+
     private static bool TryParsePositive(string s, out double value) =>
-        double.TryParse(s, NumberStyles.Any, CultureInfo.InvariantCulture, out value) && value > 0;
+        double.TryParse(s.Trim(), NumberStyles.Any, CultureInfo.InvariantCulture, out value) && value > 0;
+
+    private static string StripSuffix(string text, string suffix) =>
+        text.EndsWith(suffix) ? text[..^suffix.Length].Trim() : text.Trim();
+
+    private static bool EndsWithAny(string text, params string[] suffixes)
+    {
+        foreach (var s in suffixes)
+            if (text.EndsWith(s)) return true;
+        return false;
+    }
+
+    private static string StripFirstMatchingSuffix(string text, params string[] suffixes)
+    {
+        foreach (var s in suffixes)
+            if (text.EndsWith(s)) return text[..^s.Length].Trim();
+        return text.Trim();
+    }
 }
diff --git a/windows/MainWindow.xaml b/windows/MainWindow.xaml
index 86ca649..226ee6d 100644
--- a/windows/MainWindow.xaml
+++ b/windows/MainWindow.xaml
@@ -2,8 +2,8 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         Title="QuadClicker"
-        Width="430" Height="460"
-        MinWidth="380" MinHeight="430"
+        Width="430" Height="500"
+        MinWidth="380" MinHeight="470"
         Background="{StaticResource BackgroundBrush}"
         Foreground="{StaticResource TextPrimaryBrush}"
         ResizeMode="CanMinimize"
@@ -39,16 +39,31 @@
         </Grid.ColumnDefinitions>
 
         <!-- ── Click Rate ──────────────────────────────────────────────────── -->
-        <Label Grid.Row="0" Grid.Column="0" Content="Click Rate:" />
-        <StackPanel Grid.Row="0" Grid.Column="1" Orientation="Horizontal">
-            <TextBox x:Name="ClickRateValueBox" Width="80" Text="100"
-                     ToolTip="Enter a number. Unit selected below." />
-            <ComboBox x:Name="ClickRateUnitBox" Width="80" Margin="6,2,0,2"
-                      ToolTip="Unit for the click rate value">
-                <ComboBoxItem Content="ms"    Tag="ms"  IsSelected="True" />
-                <ComboBoxItem Content="/s"    Tag="/s" />
-                <ComboBoxItem Content="/min"  Tag="/min" />
-            </ComboBox>
+        <Label Grid.Row="0" Grid.Column="0" Content="Click Rate:"
+               VerticalAlignment="Top" Margin="0,4,0,0" />
+        <StackPanel Grid.Row="0" Grid.Column="1" Orientation="Vertical">
+            <StackPanel Orientation="Horizontal" Margin="0,2,0,2">
+                <RadioButton x:Name="ModeDelay" Content="Delay"
+                             GroupName="ClickRateMode" IsChecked="True"
+                             Checked="ClickRateMode_Changed"
+                             ToolTip="Set the time between clicks" />
+                <RadioButton x:Name="ModeFrequency" Content="Frequency"
+                             GroupName="ClickRateMode" Margin="0"
+                             Checked="ClickRateMode_Changed"
+                             ToolTip="Set how often clicks happen" />
+            </StackPanel>
+            <StackPanel Orientation="Horizontal">
+                <TextBox x:Name="ClickRateValueBox" Width="80" Text="100"
+                         TextChanged="ClickRateInput_Changed"
+                         ToolTip="Enter a number. Unit selected on the right." />
+                <ComboBox x:Name="ClickRateUnitBox" Width="110" Margin="6,2,0,2"
+                          SelectionChanged="ClickRateUnit_SelectionChanged"
+                          ToolTip="Unit for the click rate value" />
+            </StackPanel>
+            <TextBlock x:Name="RateHintLabel"
+                       Foreground="{StaticResource TextSecondaryBrush}"
+                       FontSize="11" Margin="2,3,0,2"
+                       TextWrapping="Wrap" />
         </StackPanel>
 
         <!-- ── Mouse Button ────────────────────────────────────────────────── -->
diff --git a/windows/MainWindow.xaml.cs b/windows/MainWindow.xaml.cs
index e6f5a05..299575f 100644
--- a/windows/MainWindow.xaml.cs
+++ b/windows/MainWindow.xaml.cs
@@ -30,6 +30,23 @@ public partial class MainWindow : Window
     // ── Hotkey capture state ──────────────────────────────────────────────────
     private TextBox? _capturingHotkeyBox;
 
+    // ── Click rate UI state ───────────────────────────────────────────────────
+    private bool _rateUiReady;
+
+    private static readonly (string Tag, string Display)[] DelayUnits =
+    {
+        ("ms",  "ms"),
+        ("sec", "seconds"),
+        ("min", "minutes"),
+    };
+
+    private static readonly (string Tag, string Display)[] FrequencyUnits =
+    {
+        ("per_sec",  "per second"),
+        ("per_min",  "per minute"),
+        ("per_hour", "per hour"),
+    };
+
     // ── Settings ──────────────────────────────────────────────────────────────
     private AppSettings Settings => ((App)Application.Current).Settings;
 
@@ -245,11 +262,7 @@ private bool TryBuildSession(out ClickSession? session, out string error)
         session = null;
         error   = string.Empty;
 
-        string rateText = ClickRateValueBox.Text.Trim();
-        string unit     = (ClickRateUnitBox.SelectedItem as ComboBoxItem)?.Tag as string ?? "ms";
-        string combined = unit == "ms" ? rateText + "ms" : rateText + unit;
-
-        if (!ClickRateParser.TryParse(combined, out var delay, out error))
+        if (!ClickRateParser.TryParse(ComposeRateString(), out var delay, out error))
             return false;
 
         if (!int.TryParse(StopClicksBox.Text, out int stopClicks) || stopClicks < 0)
@@ -340,6 +353,123 @@ private static bool TryParseHotkeyText(string text, out uint modifiers, out uint
         return vk != 0;
     }
 
+    // ── Click rate UI ─────────────────────────────────────────────────────────
+
+    private void ClickRateMode_Changed(object sender, RoutedEventArgs e)
+    {
+        if (!IsInitialized) return;
+
+        bool isFrequency = ModeFrequency.IsChecked == true;
+        var units = isFrequency ? FrequencyUnits : DelayUnits;
+        string fallback = isFrequency ? "per_sec" : "ms";
+
+        // Try to keep the user's saved unit if it belongs to the new mode; otherwise fallback.
+        string desired = (ClickRateUnitBox.SelectedItem as ComboBoxItem)?.Tag as string ?? fallback;
+        PopulateUnitBox(units, desired, fallback);
+        UpdateRateHint();
+    }
+
+    private void ClickRateInput_Changed(object sender, TextChangedEventArgs e) =>
+        UpdateRateHint();
+
+    private void ClickRateUnit_SelectionChanged(object sender, SelectionChangedEventArgs e) =>
+        UpdateRateHint();
+
+    private void PopulateUnitBox((string Tag, string Display)[] units, string desiredTag, string fallbackTag)
+    {
+        ClickRateUnitBox.Items.Clear();
+        ComboBoxItem? toSelect = null;
+        ComboBoxItem? fallback = null;
+        foreach (var (tag, display) in units)
+        {
+            var item = new ComboBoxItem { Content = display, Tag = tag };
+            ClickRateUnitBox.Items.Add(item);
+            if (tag == desiredTag) toSelect = item;
+            if (tag == fallbackTag) fallback = item;
+        }
+        (toSelect ?? fallback ?? (ComboBoxItem)ClickRateUnitBox.Items[0]!).IsSelected = true;
+    }
+
+    private string ComposeRateString()
+    {
+        string value = ClickRateValueBox.Text.Trim();
+        string unit  = (ClickRateUnitBox.SelectedItem as ComboBoxItem)?.Tag as string ?? "ms";
+        // Translate canonical tag → parser DSL suffix.
+        return unit switch
+        {
+            "ms"       => value + "ms",
+            "sec"      => value + "s",
+            "min"      => value + "min",
+            "per_sec"  => value + "/s",
+            "per_min"  => value + "/min",
+            "per_hour" => value + "/h",
+            _          => value + "ms",
+        };
+    }
+
+    private void UpdateRateHint()
+    {
+        if (!_rateUiReady || RateHintLabel == null) return;
+
+        if (string.IsNullOrWhiteSpace(ClickRateValueBox.Text))
+        {
+            RateHintLabel.Text = string.Empty;
+            return;
+        }
+
+        if (!ClickRateParser.TryParse(ComposeRateString(), out var delay, out _))
+        {
+            RateHintLabel.Foreground = (Brush)FindResource("TextSecondaryBrush");
+            RateHintLabel.Text = string.Empty;
+            return;
+        }
+
+        bool isDelayMode = ModeDelay.IsChecked == true;
+        double cps = 1000.0 / delay.TotalMilliseconds;
+        bool veryFast = cps > 100.0;
+
+        string conversion = isDelayMode ? FormatRate(cps) : FormatDelay(delay);
+
+        if (veryFast)
+        {
+            RateHintLabel.Foreground = (Brush)FindResource("DangerBrush");
+            RateHintLabel.Text = $"⚠ Very fast — input may not register reliably  (≈ {conversion})";
+        }
+        else
+        {
+            RateHintLabel.Foreground = (Brush)FindResource("TextSecondaryBrush");
+            RateHintLabel.Text = $"≈ {conversion}";
+        }
+    }
+
+    private static string FormatRate(double cps)
+    {
+        if (cps >= 1.0)
+            return $"{Trim(cps)} clicks/sec";
+        double cpm = cps * 60.0;
+        if (cpm >= 1.0)
+            return $"{Trim(cpm)} clicks/min";
+        double cph = cps * 3600.0;
+        return $"{Trim(cph)} clicks/hour";
+    }
+
+    private static string FormatDelay(TimeSpan delay)
+    {
+        double ms = delay.TotalMilliseconds;
+        if (ms < 1000)         return $"{Trim(ms)} ms between clicks";
+        if (ms < 60_000)       return $"{Trim(ms / 1000.0)} sec between clicks";
+        if (ms < 3_600_000)    return $"{Trim(ms / 60_000.0)} min between clicks";
+        return $"{Trim(ms / 3_600_000.0)} hours between clicks";
+    }
+
+    private static string Trim(double v)
+    {
+        // Show integers without ".0", otherwise up to 2 decimals.
+        if (Math.Abs(v - Math.Round(v)) < 0.005)
+            return ((long)Math.Round(v)).ToString(System.Globalization.CultureInfo.InvariantCulture);
+        return v.ToString("0.##", System.Globalization.CultureInfo.InvariantCulture);
+    }
+
     // ── UI helpers ────────────────────────────────────────────────────────────
 
     private void SetButtonState(bool isClicking)
@@ -396,10 +526,21 @@ private void ClearError()
     private void LoadSettings()
     {
         var s = Settings;
-        ClickRateValueBox.Text = s.ClickRateValue;
 
-        foreach (ComboBoxItem item in ClickRateUnitBox.Items)
-            if ((string)item.Tag == s.ClickRateUnit) item.IsSelected = true;
+        // Mode + units must be set BEFORE wiring rate hint, to avoid handler thrash.
+        if (s.ClickRateMode == ClickRateMode.Frequency)
+        {
+            ModeFrequency.IsChecked = true;
+            PopulateUnitBox(FrequencyUnits, s.ClickRateUnit, fallbackTag: "per_sec");
+        }
+        else
+        {
+            ModeDelay.IsChecked = true;
+            PopulateUnitBox(DelayUnits, s.ClickRateUnit, fallbackTag: "ms");
+        }
+        ClickRateValueBox.Text = s.ClickRateValue;
+        _rateUiReady = true;
+        UpdateRateHint();
 
         BtnLeft.IsChecked   = s.Button == QcMouseButton.Left;
         BtnRight.IsChecked  = s.Button == QcMouseButton.Right;
@@ -429,8 +570,10 @@ private void LoadSettings()
     private void SaveSettings()
     {
         var s = Settings;
+        s.ClickRateMode  = ModeFrequency.IsChecked == true ? ClickRateMode.Frequency : ClickRateMode.Delay;
         s.ClickRateValue = ClickRateValueBox.Text;
-        s.ClickRateUnit  = (ClickRateUnitBox.SelectedItem as ComboBoxItem)?.Tag as string ?? "ms";
+        s.ClickRateUnit  = (ClickRateUnitBox.SelectedItem as ComboBoxItem)?.Tag as string
+                           ?? (s.ClickRateMode == ClickRateMode.Frequency ? "per_sec" : "ms");
 
         s.Button     = BtnRight.IsChecked == true ? QcMouseButton.Right
                      : BtnMiddle.IsChecked == true ? QcMouseButton.Middle
diff --git a/windows/Models/AppSettings.cs b/windows/Models/AppSettings.cs
index 384a7f5..16c97e4 100644
--- a/windows/Models/AppSettings.cs
+++ b/windows/Models/AppSettings.cs
@@ -6,19 +6,26 @@ namespace QuadClicker.Models;
 /// <summary>User preferences persisted to %APPDATA%\QuadClicker\settings.json.</summary>
 public sealed class AppSettings
 {
-    public string      ClickRateValue      { get; set; } = "100";
-    public string      ClickRateUnit       { get; set; } = "ms";
-    public MouseButton Button              { get; set; } = MouseButton.Left;
-    public ClickType   ClickType           { get; set; } = ClickType.Single;
-    public bool        UseCurrentPosition  { get; set; } = true;
-    public int         X                   { get; set; } = 0;
-    public int         Y                   { get; set; } = 0;
-    public int         StopAfterClicks     { get; set; } = 0;
-    public double      StopAfterSeconds    { get; set; } = 0;
-    public double      IdleWaitSeconds     { get; set; } = 0;
-    public bool        AlwaysOnTop         { get; set; } = false;
-    public string      StartHotkeyText     { get; set; } = "";
-    public string      StopHotkeyText      { get; set; } = "F10";
+    // ── Click rate ────────────────────────────────────────────────────────────
+    // Mode determines which set of units is valid for ClickRateUnit.
+    //   Delay:     "ms", "sec", "min"
+    //   Frequency: "per_sec", "per_min", "per_hour"
+    public ClickRateMode ClickRateMode  { get; set; } = ClickRateMode.Delay;
+    public string        ClickRateValue { get; set; } = "100";
+    public string        ClickRateUnit  { get; set; } = "ms";
+
+    // ── Click behavior ────────────────────────────────────────────────────────
+    public MouseButton Button             { get; set; } = MouseButton.Left;
+    public ClickType   ClickType          { get; set; } = ClickType.Single;
+    public bool        UseCurrentPosition { get; set; } = true;
+    public int         X                  { get; set; } = 0;
+    public int         Y                  { get; set; } = 0;
+    public int         StopAfterClicks    { get; set; } = 0;
+    public double      StopAfterSeconds   { get; set; } = 0;
+    public double      IdleWaitSeconds    { get; set; } = 0;
+    public bool        AlwaysOnTop        { get; set; } = false;
+    public string      StartHotkeyText    { get; set; } = "";
+    public string      StopHotkeyText     { get; set; } = "F10";
 
     // ── Persistence ───────────────────────────────────────────────────────────
 
@@ -33,15 +40,20 @@ public static AppSettings Load()
         try
         {
             if (File.Exists(SettingsPath))
-            {
-                var json = File.ReadAllText(SettingsPath);
-                return JsonSerializer.Deserialize<AppSettings>(json, JsonOptions) ?? new AppSettings();
-            }
+                return LoadFromJson(File.ReadAllText(SettingsPath));
         }
         catch { /* Corrupt or unreadable — fall back to defaults */ }
         return new AppSettings();
     }
 
+    /// <summary>Deserializes JSON and runs forward-only legacy migration. Public for tests.</summary>
+    public static AppSettings LoadFromJson(string json)
+    {
+        var settings = JsonSerializer.Deserialize<AppSettings>(json, JsonOptions) ?? new AppSettings();
+        settings.MigrateLegacy();
+        return settings;
+    }
+
     public void Save()
     {
         try
@@ -51,4 +63,26 @@ public void Save()
         }
         catch { /* Non-fatal — settings loss is recoverable */ }
     }
+
+    /// <summary>
+    /// Translates pre-redesign unit values ("/s", "/min") into the new (Mode, Unit) shape.
+    /// Idempotent: canonical values pass through unchanged.
+    /// </summary>
+    private void MigrateLegacy()
+    {
+        switch (ClickRateUnit)
+        {
+            case "/s":
+                ClickRateMode = ClickRateMode.Frequency;
+                ClickRateUnit = "per_sec";
+                break;
+            case "/min":
+                ClickRateMode = ClickRateMode.Frequency;
+                ClickRateUnit = "per_min";
+                break;
+            case "ms":
+                ClickRateMode = ClickRateMode.Delay;
+                break;
+        }
+    }
 }
diff --git a/windows/Models/ClickRateMode.cs b/windows/Models/ClickRateMode.cs
new file mode 100644
index 0000000..295823d
--- /dev/null
+++ b/windows/Models/ClickRateMode.cs
@@ -0,0 +1,3 @@
+namespace QuadClicker.Models;
+
+public enum ClickRateMode { Delay, Frequency }
diff --git a/windows/Tests/AppSettingsMigrationTests.cs b/windows/Tests/AppSettingsMigrationTests.cs
new file mode 100644
index 0000000..0b6e495
--- /dev/null
+++ b/windows/Tests/AppSettingsMigrationTests.cs
@@ -0,0 +1,104 @@
+using QuadClicker.Models;
+using Xunit;
+
+namespace QuadClicker.Tests;
+
+public sealed class AppSettingsMigrationTests
+{
+    // ── Legacy → canonical migration ─────────────────────────────────────────
+
+    [Fact]
+    public void LegacyMs_LoadsAsDelayMs()
+    {
+        // Old schema: ClickRateUnit "ms", no ClickRateMode field.
+        const string json = """
+        {
+          "ClickRateValue": "100",
+          "ClickRateUnit": "ms"
+        }
+        """;
+        var s = AppSettings.LoadFromJson(json);
+        Assert.Equal(ClickRateMode.Delay, s.ClickRateMode);
+        Assert.Equal("ms", s.ClickRateUnit);
+        Assert.Equal("100", s.ClickRateValue);
+    }
+
+    [Fact]
+    public void LegacyPerSec_MigratesToFrequencyPerSec()
+    {
+        const string json = """
+        {
+          "ClickRateValue": "10",
+          "ClickRateUnit": "/s"
+        }
+        """;
+        var s = AppSettings.LoadFromJson(json);
+        Assert.Equal(ClickRateMode.Frequency, s.ClickRateMode);
+        Assert.Equal("per_sec", s.ClickRateUnit);
+        Assert.Equal("10", s.ClickRateValue);
+    }
+
+    [Fact]
+    public void LegacyPerMin_MigratesToFrequencyPerMin()
+    {
+        const string json = """
+        {
+          "ClickRateValue": "600",
+          "ClickRateUnit": "/min"
+        }
+        """;
+        var s = AppSettings.LoadFromJson(json);
+        Assert.Equal(ClickRateMode.Frequency, s.ClickRateMode);
+        Assert.Equal("per_min", s.ClickRateUnit);
+        Assert.Equal("600", s.ClickRateValue);
+    }
+
+    // ── Idempotence: new schema round-trips unchanged ────────────────────────
+
+    [Theory]
+    [InlineData("ms")]
+    [InlineData("sec")]
+    [InlineData("min")]
+    public void NewSchema_DelayUnits_PreservedExactly(string unit)
+    {
+        string json = $$"""
+        {
+          "ClickRateMode": 0,
+          "ClickRateValue": "5",
+          "ClickRateUnit": "{{unit}}"
+        }
+        """;
+        var s = AppSettings.LoadFromJson(json);
+        Assert.Equal(ClickRateMode.Delay, s.ClickRateMode);
+        Assert.Equal(unit, s.ClickRateUnit);
+    }
+
+    [Theory]
+    [InlineData("per_sec")]
+    [InlineData("per_min")]
+    [InlineData("per_hour")]
+    public void NewSchema_FrequencyUnits_PreservedExactly(string unit)
+    {
+        string json = $$"""
+        {
+          "ClickRateMode": 1,
+          "ClickRateValue": "5",
+          "ClickRateUnit": "{{unit}}"
+        }
+        """;
+        var s = AppSettings.LoadFromJson(json);
+        Assert.Equal(ClickRateMode.Frequency, s.ClickRateMode);
+        Assert.Equal(unit, s.ClickRateUnit);
+    }
+
+    // ── Empty / minimal JSON ─────────────────────────────────────────────────
+
+    [Fact]
+    public void EmptyJson_ReturnsDefaults()
+    {
+        var s = AppSettings.LoadFromJson("{}");
+        Assert.Equal(ClickRateMode.Delay, s.ClickRateMode);
+        Assert.Equal("ms",  s.ClickRateUnit);
+        Assert.Equal("100", s.ClickRateValue);
+    }
+}
diff --git a/windows/Tests/ClickRateParserTests.cs b/windows/Tests/ClickRateParserTests.cs
index bf09507..4da069e 100644
--- a/windows/Tests/ClickRateParserTests.cs
+++ b/windows/Tests/ClickRateParserTests.cs
@@ -84,4 +84,115 @@ public void ExceedingMaxRate_ReturnsFalse()
         Assert.False(ok);
         Assert.NotEmpty(err);
     }
+
+    // ── New: Seconds ─────────────────────────────────────────────────────────
+
+    [Theory]
+    [InlineData("5s",         5_000)]
+    [InlineData("5 s",        5_000)]
+    [InlineData("5sec",       5_000)]
+    [InlineData("5 sec",      5_000)]
+    [InlineData("5secs",      5_000)]
+    [InlineData("5second",    5_000)]
+    [InlineData("5seconds",   5_000)]
+    [InlineData("0.5sec",     500)]
+    public void Seconds_ValidInput_ReturnsCorrectDelay(string input, double expectedMs)
+    {
+        Assert.True(ClickRateParser.TryParse(input, out var delay, out _));
+        Assert.Equal(expectedMs, delay.TotalMilliseconds, precision: 0);
+    }
+
+    // ── New: Minutes ─────────────────────────────────────────────────────────
+
+    [Theory]
+    [InlineData("2m",        120_000)]
+    [InlineData("2 m",       120_000)]
+    [InlineData("2min",      120_000)]
+    [InlineData("2 min",     120_000)]
+    [InlineData("2mins",     120_000)]
+    [InlineData("2minute",   120_000)]
+    [InlineData("2minutes",  120_000)]
+    [InlineData("0.5min",    30_000)]
+    public void Minutes_ValidInput_ReturnsCorrectDelay(string input, double expectedMs)
+    {
+        Assert.True(ClickRateParser.TryParse(input, out var delay, out _));
+        Assert.Equal(expectedMs, delay.TotalMilliseconds, precision: 0);
+    }
+
+    // ── New: Per-hour frequency ──────────────────────────────────────────────
+
+    [Theory]
+    [InlineData("60/h",                 60_000)]
+    [InlineData("60cph",                60_000)]
+    [InlineData("60 times per hour",    60_000)]
+    [InlineData("3600/h",               1_000)]   // 3600 clicks/hour = 1 click/sec
+    public void ClicksPerHour_ValidInput_ReturnsCorrectDelay(string input, double expectedMs)
+    {
+        Assert.True(ClickRateParser.TryParse(input, out var delay, out _));
+        Assert.Equal(expectedMs, delay.TotalMilliseconds, precision: 0);
+    }
+
+    // ── Boundary: max delay 360 minutes ──────────────────────────────────────
+
+    [Fact]
+    public void MaxDelay_AcceptedAtBoundary()
+    {
+        Assert.True(ClickRateParser.TryParse("360min", out var delay, out _));
+        Assert.Equal(360.0 * 60_000, delay.TotalMilliseconds, precision: 0);
+    }
+
+    [Fact]
+    public void MaxDelay_RejectedAboveBoundary()
+    {
+        Assert.False(ClickRateParser.TryParse("361min", out _, out string err));
+        Assert.NotEmpty(err);
+    }
+
+    [Fact]
+    public void VeryLowFrequency_RejectedWhenDelayExceedsMax()
+    {
+        // 0.001/h would be 3.6e9 ms = ~1000 hours → way over 360 min
+        Assert.False(ClickRateParser.TryParse("0.001/h", out _, out string err));
+        Assert.NotEmpty(err);
+    }
+
+    // ── Boundary: max rate 1000/s ────────────────────────────────────────────
+
+    [Fact]
+    public void MaxRate_AcceptedAtBoundary()
+    {
+        Assert.True(ClickRateParser.TryParse("1000/s", out var delay, out _));
+        Assert.Equal(1.0, delay.TotalMilliseconds, precision: 1);
+    }
+
+    [Fact]
+    public void MaxRate_RejectedAboveBoundary()
+    {
+        Assert.False(ClickRateParser.TryParse("1001/s", out _, out string err));
+        Assert.NotEmpty(err);
+    }
+
+    // ── Disambiguation: frequency forms with shared trailing letters ─────────
+
+    [Fact]
+    public void PerMinute_NotConfusedWithMinutes()
+    {
+        // "10/min" must parse as frequency, not be eaten by the minutes path.
+        Assert.True(ClickRateParser.TryParse("10/min", out var delay, out _));
+        Assert.Equal(6_000, delay.TotalMilliseconds, precision: 0);
+    }
+
+    [Fact]
+    public void Cpm_NotConfusedWithMinutes()
+    {
+        Assert.True(ClickRateParser.TryParse("600cpm", out var delay, out _));
+        Assert.Equal(100, delay.TotalMilliseconds, precision: 0);
+    }
+
+    [Fact]
+    public void TimesPerMinute_NotConfusedWithMinutes()
+    {
+        Assert.True(ClickRateParser.TryParse("600 times per minute", out var delay, out _));
+        Assert.Equal(100, delay.TotalMilliseconds, precision: 0);
+    }
 }
diff --git a/windows/Tests/QuadClicker.Tests.csproj b/windows/Tests/QuadClicker.Tests.csproj
index 7917a49..32dfcbb 100644
--- a/windows/Tests/QuadClicker.Tests.csproj
+++ b/windows/Tests/QuadClicker.Tests.csproj
@@ -31,6 +31,7 @@
     <Compile Include="..\Core\InputInjector.cs" />
     <Compile Include="..\PInvoke\NativeMethods.cs" />
     <Compile Include="..\Models\AppSettings.cs" />
+    <Compile Include="..\Models\ClickRateMode.cs" />
   </ItemGroup>
 
 </Project>

From fe41483249a8f533340599d6b4e6dae8433f4aa0 Mon Sep 17 00:00:00 2001
From: Quadstronaut <2138096+Quadstronaut@users.noreply.github.com>
Date: Sat, 25 Apr 2026 20:03:22 -0700
Subject: [PATCH 4/5] Fix CI: remove --no-build test step that always failed

The first Test step ran `dotnet test --no-build` against a path that
nothing produced, causing every Windows build since the workflow was
added to fail before reaching the second Test step. Drop the broken
step; the remaining `dotnet test` does build + run in one shot, which
is what the test project needs because it Compile-Includes source from
the main project.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .github/workflows/build-windows.yml | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/build-windows.yml b/.github/workflows/build-windows.yml
index 0035420..37668e2 100644
--- a/.github/workflows/build-windows.yml
+++ b/.github/workflows/build-windows.yml
@@ -26,11 +26,8 @@ jobs:
         run: dotnet build windows/QuadClicker.csproj -c Release --no-restore
 
       - name: Test
-        run: dotnet test windows/Tests/QuadClicker.Tests.csproj --no-build -c Release -v normal
-        # Note: test project builds separately since it references source files directly
-        continue-on-error: false
-
-      - name: Test (build + run)
+        # Test project Compile-Includes source files from the main project, so its
+        # output dir is independent — let `dotnet test` handle build + run in one shot.
         run: dotnet test windows/Tests/QuadClicker.Tests.csproj -c Release -v normal
 
       - name: Publish

From bf63dc72a2540aab70d95044c920b93a038c5e2a Mon Sep 17 00:00:00 2001
From: Quadstronaut <2138096+Quadstronaut@users.noreply.github.com>
Date: Sat, 25 Apr 2026 20:23:16 -0700
Subject: [PATCH 5/5] Tighten window height and publish self-contained
 single-file exe
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- MainWindow: 500 → 458 px to match the 16 px side margins after the
  Click Rate block grew to two rows.
- release.yml: switch to self-contained PublishSingleFile so the
  released artifact runs on any Windows machine without requiring the
  .NET 10 preview runtime. Adds compression to keep size down.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .github/workflows/release.yml | 9 +++++++--
 windows/MainWindow.xaml       | 4 ++--
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index cdad953..5ce1357 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -15,8 +15,13 @@ jobs:
         with:
           dotnet-version: '10.0.x'
           dotnet-quality: 'preview'
-      - name: Build & Publish
-        run: dotnet publish windows/QuadClicker.csproj -c Release -r win-x64 --self-contained false -o artifacts/windows
+      - name: Build & Publish (self-contained single-file)
+        run: dotnet publish windows/QuadClicker.csproj -c Release -r win-x64
+             --self-contained true
+             -p:PublishSingleFile=true
+             -p:IncludeNativeLibrariesForSelfExtract=true
+             -p:EnableCompressionInSingleFile=true
+             -o artifacts/windows
       - uses: actions/upload-artifact@v4
         with:
           name: QuadClicker-win-x64
diff --git a/windows/MainWindow.xaml b/windows/MainWindow.xaml
index 226ee6d..95c36bd 100644
--- a/windows/MainWindow.xaml
+++ b/windows/MainWindow.xaml
@@ -2,8 +2,8 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         Title="QuadClicker"
-        Width="430" Height="500"
-        MinWidth="380" MinHeight="470"
+        Width="430" Height="458"
+        MinWidth="380" MinHeight="448"
         Background="{StaticResource BackgroundBrush}"
         Foreground="{StaticResource TextPrimaryBrush}"
         ResizeMode="CanMinimize"