diff --git a/README.md b/README.md
index ca1cccf..686b82a 100644
--- a/README.md
+++ b/README.md
@@ -21,10 +21,10 @@ Works for humans and AI agents alike.
 | `duration` | Prompts for a duration and returns an ISO-8601 duration string (e.g. PT1H30M). | |
 | `color` | Prompts for a color and returns a hex string (#rrggbb). | |
 | `multi-select` | Presents a list of options with checkboxes and returns the selected texts. | `--options`, `args...` |
-| `attribute-picker` | Prompts for text attributes (foreground, background, style) and returns a JSON object. | |
+| `attribute-picker`, `attribute` | Prompts for text attributes (foreground, background, style) and returns a JSON object. | |
 | `pick-file`, `file` | Opens a file picker dialog and returns the selected file path(s). | `--multi`, `--root`, `--filter` |
 | `pick-directory`, `dir` | Opens a directory picker dialog and returns the selected directory path. | `--root` |
-| `range` | Prompts for a numeric range (low..high) and returns a JSON object. | `--step` |
+| `linear-range`, `range` | Presents a linear range selector (single, multi, or bounded range) over labelled options. | `--mode`, `--options`, `--range-kind`, `args...` |
 | `md`, `markdown` | Renders Markdown files in a themed, scrollable viewer. | `--theme`, `--cat`, `args...` |
 
 ## Install
@@ -158,7 +158,7 @@ Esc and Ctrl-C cancel input clets; `q`, Esc, and Ctrl-C dismiss viewer clets. `-
 
 ### Q: Which clets ship in v1.0?
 
-**Input (14):** `text`, `int`, `decimal`, `select`, `multi-select`, `confirm`, `pick-file`, `pick-directory`, `date`, `time`, `duration`, `color`, `attribute-picker`, `range`
+**Input (14):** `text`, `int`, `decimal`, `select`, `multi-select`, `confirm`, `pick-file`, `pick-directory`, `date`, `time`, `duration`, `color`, `attribute-picker`, `linear-range`
 
 **Viewer (1):** `md` (Markdown via Terminal.Gui's built-in `Markdown` View)
 
diff --git a/specs/clet-spec.md b/specs/clet-spec.md
index 64f0eb7..e2810cb 100644
--- a/specs/clet-spec.md
+++ b/specs/clet-spec.md
@@ -235,7 +235,7 @@ For schema-lock at v0.5, the shape of `value` is fixed per alias.
 | `duration`                    | string, ISO-8601 duration (`PT1H30M`)                        |
 | `color`                       | string, `#RRGGBB` (lowercase hex)                            |
 | `attribute-picker`            | object, `{"fg": "#RRGGBB", "bg": "#RRGGBB", "style": "..."}` |
-| `range`                       | object, `{"low": <T>, "high": <T>}` (`int` only at v0.3 — see [D-011](decisions.md)) |
+| `linear-range`                | object, shape depends on `--mode`. Single: `{"mode":"single","value":"<label>","index":N}`. Multi: `{"mode":"multi","values":[...],"indices":[...]}`. Range: `{"mode":"range","kind":"closed\|left\|right\|none",...}` with start/end fields conditional on kind. See [D-032](decisions.md). |
 
 ### 4.4 Registration
 
diff --git a/specs/decisions.md b/specs/decisions.md
index e163e37..4c5f82d 100644
--- a/specs/decisions.md
+++ b/specs/decisions.md
@@ -128,15 +128,15 @@ Format: `## D-NNN: <short title> (status)`. Status is one of `Active`, `Supersed
 
 ---
 
-## D-011: `range` is integer-only at v0.3 (Active)
+## D-011: `range` is integer-only at v0.3 (Superseded by D-032)
 
 **Context.** Spec §4.3.2 defines the `range` value shape as `{"low": <T>, "high": <T>}` where `<T>` is the scalar of the underlying numeric/date/time type.
 
 **Decision.** At v0.3, `T = int` only. The `RangeClet` uses two `NumericUpDown<int>` controls. Decimal range and date/time range are deferred until demand exists — adding them later is a new clet alias or a generic type parameter, not a breaking change to the existing wire format.
 
-**Status.** Active. Revisit if users request decimal or date ranges before v0.5 schema-lock.
+**Status.** Superseded by D-032. The `range` clet itself is gone; `linear-range` replaces it with an option-label string type, so the integer-only constraint no longer applies.
 
-**Pointers.** `src/Clet/Clets/Input/RangeClet.cs`, `src/Clet/Clets/Input/RangeView.cs`.
+**Pointers.** *(Files referenced here have been removed; see D-029.)*
 
 ---
 
@@ -353,8 +353,6 @@ Both channels tag every build (needed for auto-increment). Both publish to NuGet
 
 ---
 
----
-
 ## D-025: Clets declare `AcceptsPositionalArgs`; non-positional clets reject them early (Active)
 
 **Context.** The CLI parser in `CommandLineRoot.DispatchAlias` collected all non-flag tokens into `CletRunOptions.Arguments` and forwarded them unconditionally. Clets that don't consume positional args (everything except `select`, `multi-select`, and `md`) silently ignored them, giving the user no feedback. `clet color - blue` would open the color picker as if the args weren't there. A bare `-` (common stdin convention) also fell through to positional args rather than being flagged.
@@ -456,7 +454,25 @@ This is clet's own defense. TG's cell model is treated as defense-in-depth, not
 
 ---
 
-## D-032: `clet md` file-access confinement policy (Active)
+## D-032: Replace `range` clet with `linear-range` backed by Terminal.Gui's `LinearRange<T>` (Active, supersedes D-011)
+
+**Context.** The original `range` clet wrapped a hand-rolled `RangeView` (`NumericUpDown<int>` × 2 + a `..` label) and emitted `{"low": <int>, "high": <int>}` per spec §4.3.2. It worked, but the UX was poor — two independent spinners with no visual sense of the range relationship — and it duplicated functionality TG shipped via [Terminal.Gui PR #5204](https://github.com/gui-cs/Terminal.Gui/pull/5204) (the `LinearRange<T>` `IValue` refactor).
+
+**Decision.** Delete `RangeClet`, `RangeView`, and their tests. Add `LinearRangeClet` (alias `linear-range`) backed by the `LinearRange<T>` view family, with three modes controlled by `--mode single|multi|range` (default `single`). Wire format changes from `{low, high}` to a mode-dependent JSON object:
+
+- `--mode single` → `{"mode":"single", "value":"<label>", "index":<N>}`
+- `--mode multi` → `{"mode":"multi", "values":[...], "indices":[...]}`
+- `--mode range` → `{"mode":"range", "kind":"closed|left|right|none", "start":"<label>", "end":"<label>", "startIndex":<N>, "endIndex":<M>}` (fields conditional on kind)
+
+Additional options: `--orientation horizontal|vertical`, `--range-kind closed|left|right` (default `closed`, only for `--mode range`), `--allow-empty`, `--hide-legends`.
+
+**Status.** Active. Supersedes [D-011](#d-011-range-is-integer-only-at-v03-active).
+
+**Pointers.** `src/Clet/Clets/Input/LinearRangeClet.cs`, spec §4.3.2, README, [Terminal.Gui PR #5204](https://github.com/gui-cs/Terminal.Gui/pull/5204).
+
+---
+
+## D-033: `clet md` file-access confinement policy (Active)
 
 **Context.** `clet md FILE` is an arbitrary file-read primitive. In agent contexts, positional arguments may be attacker-influenced via indirect prompt injection. An attacker could instruct an agent to run `clet md /home/$USER/.aws/credentials`, exfiltrating file content through the rendered ANSI output or `--cat` stdout. Glob patterns (`clet md '/etc/*.conf'`) amplify this to directory enumeration. Issue #38 documents the full threat surface.
 
@@ -467,7 +483,7 @@ This is clet's own defense. TG's cell model is treated as defense-in-depth, not
 4. **Aggregate size cap:** 32 MiB across all glob matches.
 5. **Glob count cap:** 128 files maximum.
 6. **Binary rejection:** NUL byte in first 8 KiB refuses the file.
-7. **`--allow-file <path>`** (repeatable): Bypasses extension + cwd checks for the named path. Size and binary checks still apply.
+7. **`--allow-file <path>`** (repeatable): Bypasses extension + cwd checks for the named path or directory. Size and binary checks still apply.
 8. **`--allow-binary`:** Disables NUL-byte detection.
 
 For `pick-file`/`pick-directory`, `--root` remains a starting directory, not a sandbox. The interactive file picker is user-driven and OS-permission-gated; confinement is the OS sandbox's responsibility, not clet's. Help text updated to make this explicit.
diff --git a/src/Clet/Clets/Input/AttributePickerClet.cs b/src/Clet/Clets/Input/AttributePickerClet.cs
index b270a6c..9f06afe 100644
--- a/src/Clet/Clets/Input/AttributePickerClet.cs
+++ b/src/Clet/Clets/Input/AttributePickerClet.cs
@@ -10,7 +10,7 @@ namespace Clet;
 internal sealed class AttributePickerClet : IClet<JsonObject?>
 {
     public string PrimaryAlias => "attribute-picker";
-    public IReadOnlyList<string> Aliases => ["attribute-picker"];
+    public IReadOnlyList<string> Aliases => ["attribute-picker", "attribute"];
     public string Description => "Prompts for text attributes (foreground, background, style) and returns a JSON object.";
     public CletKind Kind => CletKind.Input;
     public Type ResultType => typeof (JsonObject);
diff --git a/src/Clet/Clets/Input/LinearRangeClet.cs b/src/Clet/Clets/Input/LinearRangeClet.cs
new file mode 100644
index 0000000..e7b930e
--- /dev/null
+++ b/src/Clet/Clets/Input/LinearRangeClet.cs
@@ -0,0 +1,483 @@
+// Drop-in for gui-cs/clet at: src/Clet/Clets/Input/LinearRangeClet.cs
+//
+// Targets the LinearRange family that landed in Terminal.Gui via #5204:
+//   - LinearSelector<T>      : LinearRangeViewBase<T, T>                   IValue<T>
+//   - LinearMultiSelector<T> : LinearRangeViewBase<T, IReadOnlyList<T>>    IValue<IReadOnlyList<T>>
+//   - LinearRange<T>         : LinearRangeViewBase<T, LinearRangeSpan<T>>  IValue<LinearRangeSpan<T>>
+//
+// All options are surfaced as labels (T = string). The clet returns a JsonObject whose
+// shape depends on --mode, so AI agents can branch on a single, predictable schema:
+//
+//   --mode single → { schemaVersion:1, status:"ok", mode:"single", value:"Pro",       index:1 }
+//   --mode multi  → { schemaVersion:1, status:"ok", mode:"multi",  values:[ ... ],   indices:[ ... ] }
+//   --mode range  → { schemaVersion:1, status:"ok", mode:"range",  kind:"closed",
+//                     start:"...", end:"...", startIndex:N, endIndex:M }
+//
+// Cancel / error envelopes follow the existing clet contract; the JSON envelope itself
+// is built by the host (Hosting/JSON layer), so RunAsync only returns the typed payload.
+
+using System.Text;
+using System.Text.Json.Nodes;
+using Terminal.Gui.App;
+using Terminal.Gui.Drawing;
+using Terminal.Gui.ViewBase;
+using Terminal.Gui.Views;
+
+namespace Clet;
+
+internal sealed class LinearRangeClet : IClet<JsonObject?>
+{
+    public string PrimaryAlias => "linear-range";
+    public IReadOnlyList<string> Aliases => ["linear-range", "range"];
+
+    public string Description =>
+        "Presents a LinearRange (single, multi, or bounded range) over a list of labelled options "
+        + "and returns the selection.";
+
+    public CletKind Kind => CletKind.Input;
+    public Type ResultType => typeof (JsonObject);
+
+    public IReadOnlyList<CletOptionDescriptor> Options =>
+    [
+        new ("mode", "m", typeof (string),
+             "Selection shape: 'single' (default), 'multi', or 'range'.",
+             false, "single"),
+        new ("options", "o", typeof (string),
+             "Comma-separated list of options to display.", true, null),
+        new ("orientation", null, typeof (string),
+             "'horizontal' (default) or 'vertical'.", false, "horizontal"),
+        new ("range-kind", "k", typeof (string),
+             "Range shape when --mode=range: 'closed' (default), 'left' (= ≤ end), or 'right' (= ≥ start).",
+             false, "closed"),
+        new ("allow-empty", null, typeof (bool),
+             "Permit a no-selection result.", false, "false"),
+        new ("hide-legends", null, typeof (bool),
+             "Suppress per-option legend text under the slider.", false, "false"),
+    ];
+
+    public bool AcceptsPositionalArgs => true;
+
+    public async Task<CletRunResult<JsonObject?>> RunAsync (
+        IApplication app,
+        string? initial,
+        CletRunOptions options,
+        CancellationToken cancellationToken)
+    {
+        if (cancellationToken.IsCancellationRequested)
+        {
+            return new () { Status = CletRunStatus.Cancelled };
+        }
+
+        // ----- Parse CLI options -----
+
+        string mode = (GetOption (options, "mode") ?? "single").Trim ().ToLowerInvariant ();
+        string orientationStr = (GetOption (options, "orientation") ?? "horizontal").Trim ().ToLowerInvariant ();
+        string rangeKindStr = (GetOption (options, "range-kind") ?? "closed").Trim ().ToLowerInvariant ();
+        bool allowEmpty = ParseBool (GetOption (options, "allow-empty"));
+        bool hideLegends = ParseBool (GetOption (options, "hide-legends"));
+
+        Orientation orientation = orientationStr switch
+        {
+            "vertical" or "v" => Orientation.Vertical,
+            _ => Orientation.Horizontal
+        };
+
+        string [] labels = options.Arguments is { Count: > 0 }
+                               ? LabelParser.Split (options.Arguments)
+                               : options.CletOptions?.TryGetValue ("options", out string? optionsValue) == true
+                                   ? LabelParser.Split (optionsValue)
+                                   : [];
+
+        if (labels.Length == 0)
+        {
+            return new ()
+            {
+                Status = CletRunStatus.Error,
+                ErrorCode = "validation",
+                ErrorMessage = "linear-range requires --options or positional arguments.",
+            };
+        }
+
+        // Build typed options (T = string) once; reused by whichever view we instantiate.
+        List<LinearRangeOption<string>> linearOptions = labels
+            .Select (s => new LinearRangeOption<string> (s, (Rune)(s.Length > 0 ? s [0] : ' '), s))
+            .ToList ();
+
+        // Dispatch on --mode.
+        return mode switch
+        {
+            "multi" => await RunMulti (app, initial, options, labels, linearOptions, orientation,
+                                       allowEmpty, hideLegends, cancellationToken),
+            "range" => await RunRange (app, initial, options, labels, linearOptions, orientation,
+                                       rangeKindStr, allowEmpty, hideLegends, cancellationToken),
+            _ => await RunSingle (app, initial, options, labels, linearOptions, orientation,
+                                  allowEmpty, hideLegends, cancellationToken),
+        };
+    }
+
+    // -----------------------------------------------------------------------------
+    // Single
+    // -----------------------------------------------------------------------------
+
+    private static async Task<CletRunResult<JsonObject?>> RunSingle (
+        IApplication app,
+        string? initial,
+        CletRunOptions options,
+        string [] labels,
+        List<LinearRangeOption<string>> linearOptions,
+        Orientation orientation,
+        bool allowEmpty,
+        bool hideLegends,
+        CancellationToken cancellationToken)
+    {
+        LinearSelector<string> selector = new ()
+        {
+            Options = linearOptions,
+            Orientation = orientation,
+            AllowEmpty = allowEmpty,
+            ShowLegends = !hideLegends,
+            AssignHotKeys = true,
+        };
+
+        if (initial is { Length: > 0 })
+        {
+            int idx = FindLabelIndex (labels, initial);
+
+            if (idx >= 0)
+            {
+                selector.SelectedIndex = idx;
+            }
+        }
+
+        RunnableWrapper<LinearSelector<string>, string?> wrapper = new (selector)
+        {
+            Title = options.Title ?? "Pick one (Enter to accept, Esc to cancel)",
+            Width = Dim.Fill (),
+            BorderStyle = LineStyle.Rounded,
+            SchemeName = CletStyling.BaseSchemeName,
+        };
+        wrapper.Border.Thickness = new Thickness (0, 1, 0, 0);
+
+        try
+        {
+            await app.RunAsync (wrapper, cancellationToken);
+        }
+        catch (OperationCanceledException)
+        {
+            return new () { Status = CletRunStatus.Cancelled };
+        }
+
+        if (cancellationToken.IsCancellationRequested)
+        {
+            return new () { Status = CletRunStatus.Cancelled };
+        }
+
+        string? value = wrapper.Result;
+        int index = value is null ? -1 : FindLabelIndex (labels, value);
+
+        JsonObject json = new ()
+        {
+            ["mode"] = "single",
+            ["value"] = value,
+            ["index"] = index,
+        };
+
+        return new () { Status = CletRunStatus.Ok, Value = json };
+    }
+
+    // -----------------------------------------------------------------------------
+    // Multi
+    // -----------------------------------------------------------------------------
+
+    private static async Task<CletRunResult<JsonObject?>> RunMulti (
+        IApplication app,
+        string? initial,
+        CletRunOptions options,
+        string [] labels,
+        List<LinearRangeOption<string>> linearOptions,
+        Orientation orientation,
+        bool allowEmpty,
+        bool hideLegends,
+        CancellationToken cancellationToken)
+    {
+        LinearMultiSelector<string> selector = new ()
+        {
+            Options = linearOptions,
+            Orientation = orientation,
+            AllowEmpty = allowEmpty,
+            ShowLegends = !hideLegends,
+            AssignHotKeys = true,
+        };
+
+        if (initial is { Length: > 0 })
+        {
+            string [] initialLabels = initial.Split (',');
+            List<string> seeded = [];
+
+            foreach (string lbl in labels)
+            {
+                if (Array.Exists (initialLabels, l => string.Equals (l.Trim (), lbl, StringComparison.OrdinalIgnoreCase)))
+                {
+                    seeded.Add (lbl);
+                }
+            }
+
+            selector.Value = seeded;
+        }
+
+        RunnableWrapper<LinearMultiSelector<string>, IReadOnlyList<string>?> wrapper = new (selector)
+        {
+            Title = options.Title ?? "Pick one or more (Space to toggle, Enter to accept, Esc to cancel)",
+            Width = Dim.Fill (),
+            BorderStyle = LineStyle.Rounded,
+            SchemeName = CletStyling.BaseSchemeName,
+        };
+        wrapper.Border.Thickness = new Thickness (0, 1, 0, 0);
+
+        try
+        {
+            await app.RunAsync (wrapper, cancellationToken);
+        }
+        catch (OperationCanceledException)
+        {
+            return new () { Status = CletRunStatus.Cancelled };
+        }
+
+        if (cancellationToken.IsCancellationRequested)
+        {
+            return new () { Status = CletRunStatus.Cancelled };
+        }
+
+        IReadOnlyList<string> result = wrapper.Result ?? [];
+
+        JsonArray values = [];
+        JsonArray indices = [];
+
+        foreach (string v in result)
+        {
+            values.Add (JsonValue.Create (v));
+            indices.Add (JsonValue.Create (FindLabelIndex (labels, v)));
+        }
+
+        JsonObject json = new ()
+        {
+            ["mode"] = "multi",
+            ["values"] = values,
+            ["indices"] = indices,
+        };
+
+        return new () { Status = CletRunStatus.Ok, Value = json };
+    }
+
+    // -----------------------------------------------------------------------------
+    // Range
+    // -----------------------------------------------------------------------------
+
+    private static async Task<CletRunResult<JsonObject?>> RunRange (
+        IApplication app,
+        string? initial,
+        CletRunOptions options,
+        string [] labels,
+        List<LinearRangeOption<string>> linearOptions,
+        Orientation orientation,
+        string rangeKindStr,
+        bool allowEmpty,
+        bool hideLegends,
+        CancellationToken cancellationToken)
+    {
+        LinearRangeSpanKind kind = rangeKindStr switch
+        {
+            "left" or "left-bounded" or "l" => LinearRangeSpanKind.LeftBounded,
+            "right" or "right-bounded" or "r" => LinearRangeSpanKind.RightBounded,
+            _ => LinearRangeSpanKind.Closed,
+        };
+
+        LinearRange<string> view = new ()
+        {
+            Options = linearOptions,
+            Orientation = orientation,
+            AllowEmpty = allowEmpty,
+            ShowLegends = !hideLegends,
+            AssignHotKeys = true,
+            RangeKind = kind,
+        };
+
+        if (initial is { Length: > 0 })
+        {
+            LinearRangeSpan<string> seed = ParseInitialSpan (initial, labels, kind);
+
+            if (seed.Kind != LinearRangeSpanKind.None)
+            {
+                view.Value = seed;
+            }
+        }
+
+        RunnableWrapper<LinearRange<string>, LinearRangeSpan<string>> wrapper = new (view)
+        {
+            Title = options.Title ?? "Pick a range (Ctrl+Left/Right to extend, Enter to accept, Esc to cancel)",
+            Width = Dim.Fill (),
+            BorderStyle = LineStyle.Rounded,
+            SchemeName = CletStyling.BaseSchemeName,
+        };
+        wrapper.Border.Thickness = new Thickness (0, 1, 0, 0);
+
+        try
+        {
+            await app.RunAsync (wrapper, cancellationToken);
+        }
+        catch (OperationCanceledException)
+        {
+            return new () { Status = CletRunStatus.Cancelled };
+        }
+
+        if (cancellationToken.IsCancellationRequested)
+        {
+            return new () { Status = CletRunStatus.Cancelled };
+        }
+
+        LinearRangeSpan<string> span = wrapper.Result;
+
+        JsonObject json = new ()
+        {
+            ["mode"] = "range",
+            ["kind"] = SpanKindToString (span.Kind),
+        };
+
+        // Only emit fields that are meaningful for the kind.
+        switch (span.Kind)
+        {
+            case LinearRangeSpanKind.None:
+                json ["start"] = null;
+                json ["end"] = null;
+                json ["startIndex"] = -1;
+                json ["endIndex"] = -1;
+
+                break;
+
+            case LinearRangeSpanKind.LeftBounded:
+                json ["end"] = span.End;
+                json ["endIndex"] = span.EndIndex;
+
+                break;
+
+            case LinearRangeSpanKind.RightBounded:
+                json ["start"] = span.Start;
+                json ["startIndex"] = span.StartIndex;
+
+                break;
+
+            case LinearRangeSpanKind.Closed:
+                json ["start"] = span.Start;
+                json ["end"] = span.End;
+                json ["startIndex"] = span.StartIndex;
+                json ["endIndex"] = span.EndIndex;
+
+                break;
+        }
+
+        return new () { Status = CletRunStatus.Ok, Value = json };
+    }
+
+    // -----------------------------------------------------------------------------
+    // Helpers
+    // -----------------------------------------------------------------------------
+
+    private static string? GetOption (CletRunOptions options, string name)
+    {
+        if (options.CletOptions is null)
+        {
+            return null;
+        }
+
+        return options.CletOptions.TryGetValue (name, out string? v) ? v : null;
+    }
+
+    private static bool ParseBool (string? raw)
+    {
+        if (string.IsNullOrWhiteSpace (raw))
+        {
+            return false;
+        }
+
+        return raw.Trim ().ToLowerInvariant () is "1" or "true" or "yes" or "on";
+    }
+
+    private static int FindLabelIndex (string [] labels, string value)
+    {
+        return Array.FindIndex (labels, l => string.Equals (l, value, StringComparison.OrdinalIgnoreCase));
+    }
+
+    private static string SpanKindToString (LinearRangeSpanKind kind) => kind switch
+    {
+        LinearRangeSpanKind.LeftBounded => "left",
+        LinearRangeSpanKind.RightBounded => "right",
+        LinearRangeSpanKind.Closed => "closed",
+        _ => "none",
+    };
+
+    // Parses initial range strings:
+    //   "Pro..Team"  → Closed
+    //   "..Team"     → LeftBounded (overrides explicit kind only when explicit kind is Closed)
+    //   "Pro.."      → RightBounded
+    //   "Pro"        → single point, mapped per requestedKind
+    // Returns LinearRangeSpan<string>.Empty if nothing valid parses.
+    private static LinearRangeSpan<string> ParseInitialSpan (string initial, string [] labels, LinearRangeSpanKind requestedKind)
+    {
+        string trimmed = initial.Trim ();
+
+        if (trimmed.Length == 0)
+        {
+            return LinearRangeSpan<string>.Empty;
+        }
+
+        int sep = trimmed.IndexOf ("..", StringComparison.Ordinal);
+
+        if (sep < 0)
+        {
+            // Single label — interpret per requested kind.
+            int idx = FindLabelIndex (labels, trimmed);
+
+            if (idx < 0)
+            {
+                return LinearRangeSpan<string>.Empty;
+            }
+
+            return requestedKind switch
+            {
+                LinearRangeSpanKind.LeftBounded => new (LinearRangeSpanKind.LeftBounded, default, labels [idx], -1, idx),
+                LinearRangeSpanKind.RightBounded => new (LinearRangeSpanKind.RightBounded, labels [idx], default, idx, -1),
+                _ => new (LinearRangeSpanKind.Closed, labels [idx], labels [idx], idx, idx),
+            };
+        }
+
+        string left = trimmed [..sep].Trim ();
+        string right = trimmed [(sep + 2)..].Trim ();
+
+        bool hasLeft = left.Length > 0;
+        bool hasRight = right.Length > 0;
+
+        int leftIdx = hasLeft ? FindLabelIndex (labels, left) : -1;
+        int rightIdx = hasRight ? FindLabelIndex (labels, right) : -1;
+
+        if (hasLeft && !hasRight && leftIdx >= 0)
+        {
+            return new (LinearRangeSpanKind.RightBounded, labels [leftIdx], default, leftIdx, -1);
+        }
+
+        if (!hasLeft && hasRight && rightIdx >= 0)
+        {
+            return new (LinearRangeSpanKind.LeftBounded, default, labels [rightIdx], -1, rightIdx);
+        }
+
+        if (hasLeft && hasRight && leftIdx >= 0 && rightIdx >= 0)
+        {
+            // Normalise so Start ≤ End by index.
+            int lo = Math.Min (leftIdx, rightIdx);
+            int hi = Math.Max (leftIdx, rightIdx);
+
+            return new (LinearRangeSpanKind.Closed, labels [lo], labels [hi], lo, hi);
+        }
+
+        return LinearRangeSpan<string>.Empty;
+    }
+}
diff --git a/src/Clet/Clets/Input/RangeClet.cs b/src/Clet/Clets/Input/RangeClet.cs
deleted file mode 100644
index ce157b9..0000000
--- a/src/Clet/Clets/Input/RangeClet.cs
+++ /dev/null
@@ -1,105 +0,0 @@
-using System.Globalization;
-using System.Text.Json.Nodes;
-using Terminal.Gui.App;
-using Terminal.Gui.Drawing;
-using Terminal.Gui.ViewBase;
-using Terminal.Gui.Views;
-
-namespace Clet;
-
-internal sealed class RangeClet : IClet<JsonObject?>
-{
-    public string PrimaryAlias => "range";
-    public IReadOnlyList<string> Aliases => ["range"];
-    public string Description => "Prompts for a numeric range (low..high) and returns a JSON object.";
-    public CletKind Kind => CletKind.Input;
-    public Type ResultType => typeof (JsonObject);
-
-    public IReadOnlyList<CletOptionDescriptor> Options =>
-    [
-        new ("step", null, typeof (int), "Step increment.", false, "1"),
-    ];
-
-    public bool TryValidateInitial (string initial, CletRunOptions options)
-        => TryParseRange (initial, out _, out _);
-
-    public async Task<CletRunResult<JsonObject?>> RunAsync (
-        IApplication app,
-        string? initial,
-        CletRunOptions options,
-        CancellationToken cancellationToken)
-    {
-        if (cancellationToken.IsCancellationRequested)
-        {
-            return new () { Status = CletRunStatus.Cancelled };
-        }
-
-        RangeView rangeView = new ();
-
-        if (options.CletOptions?.TryGetValue ("step", out string? stepStr) == true
-            && int.TryParse (stepStr, CultureInfo.InvariantCulture, out int step))
-        {
-            rangeView.Increment = step;
-        }
-
-        if (initial is not null && TryParseRange (initial, out int low, out int high))
-        {
-            rangeView.LowValue = low;
-            rangeView.HighValue = high;
-        }
-
-        RunnableWrapper<RangeView, (int Low, int High)?> wrapper = new (rangeView)
-        {
-            Title = options.Title ?? "Select a range (Enter to accept, Esc to cancel)",
-            Width = Dim.Fill (),
-            BorderStyle = LineStyle.Rounded,
-            ResultExtractor = rv => rv.RangeResult,
-            SchemeName = CletStyling.BaseSchemeName,
-        };
-        wrapper.Border.Thickness = new Thickness (0, 1, 0, 0);
-
-        try
-        {
-            await app.RunAsync (wrapper, cancellationToken);
-        }
-        catch (OperationCanceledException)
-        {
-            return new () { Status = CletRunStatus.Cancelled };
-        }
-
-        if (cancellationToken.IsCancellationRequested)
-        {
-            return new () { Status = CletRunStatus.Cancelled };
-        }
-
-        (int Low, int High)? result = wrapper.Result;
-
-        if (result is not { } r)
-        {
-            return new () { Status = CletRunStatus.Ok, Value = null };
-        }
-
-        JsonObject obj = new ()
-        {
-            ["low"] = r.Low,
-            ["high"] = r.High,
-        };
-
-        return new () { Status = CletRunStatus.Ok, Value = obj };
-    }
-
-    private static bool TryParseRange (string input, out int low, out int high)
-    {
-        low = 0;
-        high = 0;
-        int separatorIdx = input.IndexOf ("..", StringComparison.Ordinal);
-
-        if (separatorIdx < 0)
-        {
-            return false;
-        }
-
-        return int.TryParse (input.AsSpan (0, separatorIdx), CultureInfo.InvariantCulture, out low)
-               && int.TryParse (input.AsSpan (separatorIdx + 2), CultureInfo.InvariantCulture, out high);
-    }
-}
diff --git a/src/Clet/Clets/Input/RangeView.cs b/src/Clet/Clets/Input/RangeView.cs
deleted file mode 100644
index 0e26318..0000000
--- a/src/Clet/Clets/Input/RangeView.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-using Terminal.Gui.ViewBase;
-using Terminal.Gui.Views;
-
-namespace Clet;
-
-internal sealed class RangeView : View
-{
-    private readonly NumericUpDown<int> _low;
-    private readonly NumericUpDown<int> _high;
-
-    public RangeView ()
-    {
-        Height = 1;
-        Width = Dim.Fill ();
-
-        _low = new NumericUpDown<int> { X = 0, Y = 0, Width = Dim.Percent (45), Height = 1 };
-        _high = new NumericUpDown<int> { X = Pos.Right (_low) + 2, Y = 0, Width = Dim.Percent (45), Height = 1 };
-
-        Label separator = new () { X = Pos.Right (_low), Y = 0, Width = 2, Height = 1, Text = ".." };
-
-        Add (_low, separator, _high);
-    }
-
-    public int Increment
-    {
-        get => _low.Increment;
-        set
-        {
-            _low.Increment = value;
-            _high.Increment = value;
-        }
-    }
-
-    public int LowValue
-    {
-        get => _low.Value;
-        set => _low.Value = value;
-    }
-
-    public int HighValue
-    {
-        get => _high.Value;
-        set => _high.Value = value;
-    }
-
-    public (int Low, int High) RangeResult => (_low.Value, _high.Value);
-}
diff --git a/src/Clet/Clets/Viewer/HelpClet.cs b/src/Clet/Clets/Viewer/HelpClet.cs
new file mode 100644
index 0000000..ad0955e
--- /dev/null
+++ b/src/Clet/Clets/Viewer/HelpClet.cs
@@ -0,0 +1,215 @@
+using Terminal.Gui.App;
+using Terminal.Gui.Drawing;
+using Terminal.Gui.Input;
+using Terminal.Gui.ViewBase;
+using Terminal.Gui.Views;
+using TextMateSharp.Grammars;
+using Command = Terminal.Gui.Input.Command;
+
+namespace Clet;
+
+internal sealed class HelpClet : IViewerClet
+{
+    private readonly ICletRegistry _registry;
+
+    public HelpClet (ICletRegistry registry) => _registry = registry;
+
+    public string PrimaryAlias => "help";
+    public IReadOnlyList<string> Aliases => ["help"];
+    public string Description => "Shows help for clet commands.";
+    public CletKind Kind => CletKind.Viewer;
+    public Type ResultType => typeof (void);
+    public bool AcceptsPositionalArgs => true;
+
+    public IReadOnlyList<CletOptionDescriptor> Options => [];
+
+    public async Task<CletRunResult> RunAsync (
+        IApplication app,
+        string? content,
+        CletRunOptions options,
+        CancellationToken cancellationToken)
+    {
+        if (cancellationToken.IsCancellationRequested)
+        {
+            return new () { Status = CletRunStatus.Cancelled };
+        }
+
+        string? alias = options.Arguments?.FirstOrDefault ();
+
+        // Validate alias early — unknown aliases should error, not render
+        if (alias is not null and not "help" && !_registry.TryResolve (alias, out _))
+        {
+            return new ()
+            {
+                Status = CletRunStatus.Error,
+                ErrorCode = "usage",
+                ErrorMessage = $"Unknown alias '{alias}'. Try 'clet list' to see available clets.",
+            };
+        }
+
+        (string markdown, string title) = BuildHelpContent (alias);
+
+        // --cat mode: render to stdout and exit
+        if (options.Cat)
+        {
+            MarkdownHelpRenderer.RenderToAnsi (markdown, Console.Out);
+
+            return new () { Status = CletRunStatus.Ok };
+        }
+
+        // --- Build TUI ---
+
+        Runnable window = new ()
+        {
+            Title = title,
+            Width = Dim.Fill (),
+            Height = Dim.Fill (),
+        };
+
+        Markdown markdownView = new ()
+        {
+            Width = Dim.Fill (),
+            Height = Dim.Fill (1),
+            SyntaxHighlighter = new TextMateSyntaxHighlighter (ThemeName.DarkPlus),
+        };
+
+        markdownView.ViewportSettings |= ViewportSettingsFlags.HasHorizontalScrollBar;
+
+        Shortcut statusShortcut = new (Key.Empty, title, null) { MouseHighlightStates = MouseState.None };
+
+        markdownView.LinkClicked += (_, e) =>
+        {
+            if (e.Url.StartsWith ("clet:help", StringComparison.OrdinalIgnoreCase))
+            {
+                string? linkAlias = e.Url.Length > "clet:help:".Length
+                    ? e.Url ["clet:help:".Length..]
+                    : null;
+
+                (string md, string t) = BuildHelpContent (linkAlias);
+                markdownView.Text = md;
+                window.Title = t;
+                statusShortcut.Title = t;
+                e.Handled = true;
+
+                return;
+            }
+
+            // Help content is authored by us — links are safe to open.
+            Link.OpenUrl (e.Url);
+            statusShortcut.Title = e.Url;
+            e.Handled = true;
+        };
+
+        StatusBar statusBar = new ([
+            new (Application.GetDefaultKey (Command.Quit), "Quit", window.RequestStop),
+            statusShortcut,
+        ])
+        {
+            AlignmentModes = AlignmentModes.IgnoreFirstOrLast,
+        };
+
+        window.Add (markdownView, statusBar);
+
+        window.Initialized += (_, _) =>
+        {
+            markdownView.Text = markdown;
+        };
+
+        try
+        {
+            await app.RunAsync (window, cancellationToken);
+        }
+        catch (OperationCanceledException)
+        {
+            return new () { Status = CletRunStatus.Cancelled };
+        }
+
+        return new () { Status = CletRunStatus.Ok };
+    }
+
+    private (string Markdown, string Title) BuildHelpContent (string? alias)
+    {
+        if (alias is null)
+        {
+            return BuildOverview ();
+        }
+
+        if (alias is "help")
+        {
+            string helpMd = "# clet help\n\nNavigating clet's built-in help system.\n\n";
+            string? helpExtra = MarkdownHelpRenderer.ReadEmbeddedHelp ("help.md");
+
+            if (helpExtra is not null)
+            {
+                helpMd += helpExtra;
+            }
+
+            helpMd += "\n\n---\n\n[Back to overview](clet:help)\n";
+
+            return (helpMd, "clet help");
+        }
+
+        if (!_registry.TryResolve (alias, out IClet? clet) || clet is null)
+        {
+            return ($"# Unknown clet: {alias}\n\nTry `clet list` to see available clets.", "clet help");
+        }
+
+        string md = MarkdownHelpRenderer.BuildAliasHelpMarkdown (clet);
+        md += "\n\n---\n\n[Back to overview](clet:help)\n";
+
+        return (md, $"clet help {clet.PrimaryAlias}");
+    }
+
+    private (string Markdown, string Title) BuildOverview ()
+    {
+        string? rawMarkdown = MarkdownHelpRenderer.ReadEmbeddedHelp ("overview.md");
+
+        if (rawMarkdown is null)
+        {
+            return ("# clet\n\nNo overview available.", "clet");
+        }
+
+        string cletTable = MarkdownHelpRenderer.BuildCletTableMarkdown (_registry).TrimEnd ();
+        string markdown = rawMarkdown.Replace ("{{CLET_TABLE}}", cletTable);
+        markdown = markdown.Replace ("{{VERSION}}", $"v{GetVersion ()} (Terminal.Gui {GetTerminalGuiVersion ()})");
+
+        return (markdown, "clet");
+    }
+
+    private static string GetVersion ()
+    {
+        string? informational = typeof (Program).Assembly
+            .GetCustomAttributes (typeof (System.Reflection.AssemblyInformationalVersionAttribute), false)
+            .OfType<System.Reflection.AssemblyInformationalVersionAttribute> ()
+            .FirstOrDefault ()
+            ?.InformationalVersion;
+
+        if (!string.IsNullOrWhiteSpace (informational))
+        {
+            int plus = informational.IndexOf ('+');
+
+            return plus >= 0 ? informational [..plus] : informational;
+        }
+
+        return typeof (Program).Assembly.GetName ().Version?.ToString (3) ?? "0.0.0";
+    }
+
+    private static string GetTerminalGuiVersion ()
+    {
+        System.Reflection.Assembly tg = typeof (Application).Assembly;
+        string? informational = tg
+            .GetCustomAttributes (typeof (System.Reflection.AssemblyInformationalVersionAttribute), false)
+            .OfType<System.Reflection.AssemblyInformationalVersionAttribute> ()
+            .FirstOrDefault ()
+            ?.InformationalVersion;
+
+        if (!string.IsNullOrWhiteSpace (informational))
+        {
+            int plus = informational.IndexOf ('+');
+
+            return plus >= 0 ? informational [..plus] : informational;
+        }
+
+        return tg.GetName ().Version?.ToString (3) ?? "unknown";
+    }
+}
diff --git a/src/Clet/Clets/Viewer/MarkdownClet.cs b/src/Clet/Clets/Viewer/MarkdownClet.cs
index 54d79ae..a2f43d2 100644
--- a/src/Clet/Clets/Viewer/MarkdownClet.cs
+++ b/src/Clet/Clets/Viewer/MarkdownClet.cs
@@ -153,7 +153,7 @@ public async Task<CletRunResult> RunAsync (
 
         markdownView.LinkClicked += (_, e) =>
         {
-            // Try to navigate to local .md files that pass the file access policy
+            // Navigate local .md files within the sandbox
             if (currentFileDir is not null && TryResolveLocalMarkdownLink (e.Url, currentFileDir, linkPolicy, out string? resolvedPath))
             {
                 LoadFile (resolvedPath);
@@ -162,6 +162,13 @@ public async Task<CletRunResult> RunAsync (
                 return;
             }
 
+            // Open http/https links in the default browser — they're safe
+            if (e.Url.StartsWith ("http://", StringComparison.OrdinalIgnoreCase)
+                || e.Url.StartsWith ("https://", StringComparison.OrdinalIgnoreCase))
+            {
+                Link.OpenUrl (e.Url);
+            }
+
             // Show URL in status bar as a clickable link
             statusLink.Text = e.Url;
             statusLink.Url = e.Url;
diff --git a/src/Clet/Help/attribute-picker.md b/src/Clet/Help/attribute-picker.md
new file mode 100644
index 0000000..cd623ac
--- /dev/null
+++ b/src/Clet/Help/attribute-picker.md
@@ -0,0 +1,16 @@
+## Examples
+
+```sh
+# Pick text attributes (foreground, background, style):
+clet attribute-picker
+
+# Short alias:
+clet attribute
+
+# With a title:
+clet attribute --title "Choose cell style"
+
+# JSON output:
+clet attribute --json
+# → {"schemaVersion":1,"status":"ok","value":{"fg":"#ffffff","bg":"#000000","style":"bold"}}
+```
diff --git a/src/Clet/Help/color.md b/src/Clet/Help/color.md
new file mode 100644
index 0000000..cd876cd
--- /dev/null
+++ b/src/Clet/Help/color.md
@@ -0,0 +1,16 @@
+## Examples
+
+```sh
+# Color picker:
+clet color
+
+# Pre-filled:
+clet color --initial "#ff6600"
+
+# With a title:
+clet color --title "Choose accent color"
+
+# JSON output (hex):
+clet color --json
+# → {"schemaVersion":1,"status":"ok","value":"#ff6600"}
+```
diff --git a/src/Clet/Help/confirm.md b/src/Clet/Help/confirm.md
new file mode 100644
index 0000000..967e192
--- /dev/null
+++ b/src/Clet/Help/confirm.md
@@ -0,0 +1,22 @@
+## Examples
+
+```sh
+# Yes/No confirmation:
+clet confirm --prompt "Deploy to production?"
+
+# With a title:
+clet confirm --title "Confirm" --prompt "Delete 40k rows?"
+
+# Default to yes:
+clet confirm --initial "true" --prompt "Continue?"
+
+# Use in a script:
+if clet confirm --prompt "Apply patch?"; then
+  git apply patch.diff
+fi
+
+# JSON output:
+clet confirm --json --prompt "OK?"
+# → {"schemaVersion":1,"status":"ok","value":true}
+# → {"schemaVersion":1,"status":"ok","value":false}
+```
diff --git a/src/Clet/Help/date.md b/src/Clet/Help/date.md
new file mode 100644
index 0000000..ff26521
--- /dev/null
+++ b/src/Clet/Help/date.md
@@ -0,0 +1,16 @@
+## Examples
+
+```sh
+# Date picker:
+clet date
+
+# Pre-filled to today:
+clet date --initial "2026-05-06"
+
+# With a title:
+clet date --title "Select deadline"
+
+# JSON output (ISO-8601):
+clet date --json
+# → {"schemaVersion":1,"status":"ok","value":"2026-05-06"}
+```
diff --git a/src/Clet/Help/decimal.md b/src/Clet/Help/decimal.md
new file mode 100644
index 0000000..8208714
--- /dev/null
+++ b/src/Clet/Help/decimal.md
@@ -0,0 +1,19 @@
+## Examples
+
+```sh
+# Decimal spinner:
+clet decimal
+
+# With step size:
+clet decimal --step 0.1
+
+# Pre-filled value:
+clet decimal --initial "3.14"
+
+# With a title:
+clet decimal --title "Enter price" --step 0.01 --initial "9.99"
+
+# JSON output:
+clet decimal --json
+# → {"schemaVersion":1,"status":"ok","value":9.99}
+```
diff --git a/src/Clet/Help/duration.md b/src/Clet/Help/duration.md
new file mode 100644
index 0000000..c6dfd83
--- /dev/null
+++ b/src/Clet/Help/duration.md
@@ -0,0 +1,16 @@
+## Examples
+
+```sh
+# Duration picker:
+clet duration
+
+# Pre-filled (1 hour 30 minutes):
+clet duration --initial "PT1H30M"
+
+# With a title:
+clet duration --title "Timeout duration"
+
+# JSON output (ISO-8601 duration):
+clet duration --json
+# → {"schemaVersion":1,"status":"ok","value":"PT1H30M"}
+```
diff --git a/src/Clet/Help/help.md b/src/Clet/Help/help.md
new file mode 100644
index 0000000..a80b336
--- /dev/null
+++ b/src/Clet/Help/help.md
@@ -0,0 +1,29 @@
+## Examples
+
+```sh
+# Show the main help overview (TUI viewer):
+clet help
+
+# Render to stdout instead of the TUI:
+clet help --cat
+
+# Show help for a specific clet:
+clet help select
+clet help range
+clet help md
+
+# Equivalent forms — all work:
+clet select help
+clet select --help
+clet select -h
+
+# Render a clet's help to stdout:
+clet help select --cat
+clet select help --cat
+```
+
+## Reporting Problems
+
+Found a bug or have a suggestion? [File an issue on GitHub](https://github.com/gui-cs/clet/issues/new).
+
+Include `clet --version` output, your terminal and OS, and what you ran vs. what happened.
diff --git a/src/Clet/Help/int.md b/src/Clet/Help/int.md
new file mode 100644
index 0000000..ee75734
--- /dev/null
+++ b/src/Clet/Help/int.md
@@ -0,0 +1,19 @@
+## Examples
+
+```sh
+# Integer spinner:
+clet int
+
+# With step size:
+clet int --step 5
+
+# Pre-filled value:
+clet int --initial "42"
+
+# With a title:
+clet int --title "How many replicas?" --initial "3"
+
+# JSON output:
+clet int --json
+# → {"schemaVersion":1,"status":"ok","value":42}
+```
diff --git a/src/Clet/Help/linear-range.md b/src/Clet/Help/linear-range.md
new file mode 100644
index 0000000..883bc24
--- /dev/null
+++ b/src/Clet/Help/linear-range.md
@@ -0,0 +1,79 @@
+## Examples
+
+### Single selection (default)
+
+```sh
+clet range "Free" "Pro" "Team" "Enterprise"
+# or
+clet range --options "Free,Pro,Team,Enterprise"
+```
+
+JSON output:
+```json
+{"schemaVersion":1,"status":"ok","value":{"mode":"single","value":"Pro","index":1}}
+```
+
+### Multi selection
+
+```sh
+clet range --mode multi --options "Read,Write,Execute"
+```
+
+JSON output:
+```json
+{"schemaVersion":1,"status":"ok","value":{"mode":"multi","values":["Read","Execute"],"indices":[0,2]}}
+```
+
+### Bounded range
+
+```sh
+clet range --mode range "S" "M" "L" "XL" "XXL"
+# With initial selection:
+clet range --mode range --initial "M..XL" "S" "M" "L" "XL" "XXL"
+```
+
+JSON output:
+```json
+{"schemaVersion":1,"status":"ok","value":{"mode":"range","kind":"closed","start":"M","end":"XL","startIndex":1,"endIndex":3}}
+```
+
+### Numeric range
+
+Generate numeric options in the shell — labels are strings, so any
+sequence works:
+
+```sh
+# Pick a value from 0.0 to 10.0 in 0.1 increments:
+clet range $(seq 0 0.1 10.0)
+
+# Select a sub-range:
+clet range --mode range $(seq 0 0.1 10.0)
+```
+
+```powershell
+# PowerShell equivalent:
+clet range (0..100 | ForEach-Object { $_ / 10 })
+```
+
+### Range kinds
+
+```sh
+# Left-bounded (everything up to an endpoint):
+clet range --mode range --range-kind left "Jan" "Feb" "Mar" "Apr"
+
+# Right-bounded (everything from a starting point):
+clet range --mode range --range-kind right "Jan" "Feb" "Mar" "Apr"
+```
+
+### Layout and display
+
+```sh
+# Vertical orientation:
+clet range --orientation vertical "Low" "Medium" "High"
+
+# Hide option legends:
+clet range --hide-legends true "A" "B" "C" "D"
+
+# Allow empty selection:
+clet range --allow-empty true "Red" "Green" "Blue"
+```
diff --git a/src/Clet/Help/md.md b/src/Clet/Help/md.md
new file mode 100644
index 0000000..9141ead
--- /dev/null
+++ b/src/Clet/Help/md.md
@@ -0,0 +1,21 @@
+## Examples
+
+```sh
+# View a markdown file (full-screen, dismiss with q/Esc):
+clet md ./README.md
+
+# View multiple files (dropdown selector in status bar):
+clet md *.md
+
+# Render to stdout without the TUI:
+clet md --cat ./CHANGELOG.md
+
+# Pipe markdown from stdin:
+echo "# Hello" | clet md
+
+# Change syntax highlighting theme:
+clet md --theme Monokai ./README.md
+
+# View a file outside the working directory:
+clet md --allow-file ../other-repo ../other-repo/README.md
+```
diff --git a/src/Clet/Help/multi-select.md b/src/Clet/Help/multi-select.md
new file mode 100644
index 0000000..8d503ef
--- /dev/null
+++ b/src/Clet/Help/multi-select.md
@@ -0,0 +1,16 @@
+## Examples
+
+```sh
+# Checkbox list (positional arguments):
+clet multi-select "Read" "Write" "Execute"
+
+# Comma-separated --options:
+clet multi-select --options "Linux,macOS,Windows"
+
+# Pre-selected items:
+clet multi-select --initial "Read,Execute" "Read" "Write" "Execute"
+
+# JSON output (array of selected texts):
+clet multi-select --json "Red" "Green" "Blue"
+# → {"schemaVersion":1,"status":"ok","value":["Red","Blue"]}
+```
diff --git a/src/Clet/Help/multiline-text.md b/src/Clet/Help/multiline-text.md
new file mode 100644
index 0000000..f8c38ae
--- /dev/null
+++ b/src/Clet/Help/multiline-text.md
@@ -0,0 +1,16 @@
+## Examples
+
+```sh
+# Multi-line text editor:
+clet multiline-text
+
+# Short alias:
+clet mt --title "Enter a commit message"
+
+# Pre-filled content:
+clet mt --initial "First line\nSecond line"
+
+# JSON output:
+clet mt --json
+# → {"schemaVersion":1,"status":"ok","value":"line 1\nline 2\nline 3"}
+```
diff --git a/src/Clet/Help/overview.md b/src/Clet/Help/overview.md
index 04c0d1f..a6e37e0 100644
--- a/src/Clet/Help/overview.md
+++ b/src/Clet/Help/overview.md
@@ -50,4 +50,6 @@ clet --help
 clet --version
 ```
 
+[Help on help](clet:help:help)
+
 {{VERSION}} - [clet on GitHub](https://github.com/gui-cs/clet) - By [@tig](https://github.com/tig)
diff --git a/src/Clet/Help/pick-directory.md b/src/Clet/Help/pick-directory.md
new file mode 100644
index 0000000..7d13812
--- /dev/null
+++ b/src/Clet/Help/pick-directory.md
@@ -0,0 +1,16 @@
+## Examples
+
+```sh
+# Directory picker:
+clet pick-directory
+
+# Short alias:
+clet dir
+
+# Start in a specific directory:
+clet dir --root ~/projects
+
+# JSON output:
+clet dir --json
+# → {"schemaVersion":1,"status":"ok","value":"/Users/tig/projects/myapp"}
+```
diff --git a/src/Clet/Help/pick-file.md b/src/Clet/Help/pick-file.md
new file mode 100644
index 0000000..38e0c68
--- /dev/null
+++ b/src/Clet/Help/pick-file.md
@@ -0,0 +1,26 @@
+## Examples
+
+```sh
+# File picker (tree dialog):
+clet pick-file
+
+# Short alias:
+clet file
+
+# Start in a specific directory:
+clet file --root ./src
+
+# Filter by extension:
+clet file --filter "*.cs"
+
+# Allow multiple selection:
+clet file --multi true
+
+# JSON output:
+clet file --json --root ./src --filter "*.md"
+# → {"schemaVersion":1,"status":"ok","value":"/path/to/README.md"}
+
+# Multi-select JSON (array):
+clet file --json --multi true
+# → {"schemaVersion":1,"status":"ok","value":["/path/a.md","/path/b.md"]}
+```
diff --git a/src/Clet/Help/select.md b/src/Clet/Help/select.md
new file mode 100644
index 0000000..c6098b9
--- /dev/null
+++ b/src/Clet/Help/select.md
@@ -0,0 +1,16 @@
+## Examples
+
+```sh
+# Positional arguments:
+clet select "prod" "staging" "dev"
+
+# Comma-separated --options:
+clet select --options "prod,staging,dev"
+
+# With an initial selection:
+clet select --initial "staging" "prod" "staging" "dev"
+
+# JSON output for scripting:
+clet select --json "prod" "staging" "dev"
+# → {"schemaVersion":1,"status":"ok","value":"staging"}
+```
diff --git a/src/Clet/Help/text.md b/src/Clet/Help/text.md
new file mode 100644
index 0000000..8d45333
--- /dev/null
+++ b/src/Clet/Help/text.md
@@ -0,0 +1,16 @@
+## Examples
+
+```sh
+# Basic text prompt:
+clet text
+
+# With a title:
+clet text --title "Enter your name"
+
+# Pre-filled initial value:
+clet text --initial "John Doe"
+
+# JSON output:
+clet text --json
+# → {"schemaVersion":1,"status":"ok","value":"Hello world"}
+```
diff --git a/src/Clet/Help/time.md b/src/Clet/Help/time.md
new file mode 100644
index 0000000..2707640
--- /dev/null
+++ b/src/Clet/Help/time.md
@@ -0,0 +1,16 @@
+## Examples
+
+```sh
+# Time picker:
+clet time
+
+# Pre-filled:
+clet time --initial "14:30:00"
+
+# With a title:
+clet time --title "Meeting start time"
+
+# JSON output (ISO-8601):
+clet time --json
+# → {"schemaVersion":1,"status":"ok","value":"14:30:00"}
+```
diff --git a/src/Clet/Hosting/AliasDispatcher.cs b/src/Clet/Hosting/AliasDispatcher.cs
index c1d65a2..faa482e 100644
--- a/src/Clet/Hosting/AliasDispatcher.cs
+++ b/src/Clet/Hosting/AliasDispatcher.cs
@@ -43,16 +43,15 @@ public async Task<int> DispatchAsync (
         {
             string? markdown = ResolveViewerContent (initial, options, stderr);
 
-            if (markdown is null)
+            if (markdown is not null)
             {
-                stderr.WriteLine ("error: --cat requires content via file arguments, --initial, or stdin.");
+                MarkdownHelpRenderer.RenderToAnsi (markdown, stdout);
 
-                return ExitCodes.UsageError;
+                return ExitCodes.Ok;
             }
 
-            MarkdownHelpRenderer.RenderToAnsi (markdown, stdout);
-
-            return ExitCodes.Ok;
+            // No static content resolved — fall through to RunAsync.
+            // The clet may handle --cat internally (e.g. HelpClet builds content dynamically).
         }
 
         BoxedCletResult result;
diff --git a/src/Clet/Hosting/CommandLineRoot.cs b/src/Clet/Hosting/CommandLineRoot.cs
index 8ed32f8..fd4c6a2 100644
--- a/src/Clet/Hosting/CommandLineRoot.cs
+++ b/src/Clet/Hosting/CommandLineRoot.cs
@@ -44,11 +44,6 @@ public async Task<int> InvokeAsync (
 
                 return ExitCodes.Ok;
 
-            case "help":
-                string? helpAlias = args.Length >= 2 ? args [1] : null;
-
-                return await DispatchHelp (helpAlias, cancellationToken, stdout, stderr);
-
             case "list":
                 return WriteList (args, stdout);
         }
@@ -63,6 +58,22 @@ private async Task<int> DispatchAlias (
         TextWriter stderr)
     {
         string alias = args [0];
+
+        // Support `clet <alias> help`, `clet <alias> --help`, `clet <alias> -h`
+        // Rewrite as `clet help <alias> [--cat]` and re-dispatch.
+        // Skip when alias is already "help" to avoid infinite recursion.
+        if (alias != "help" && args.Length >= 2 && args [1] is "help" or "--help" or "-h")
+        {
+            List<string> helpArgs = ["help", alias];
+
+            if (Array.Exists (args, a => a == "--cat"))
+            {
+                helpArgs.Add ("--cat");
+            }
+
+            return await DispatchAlias (helpArgs.ToArray (), cancellationToken, stdout, stderr);
+        }
+
         string? initial = null;
         string? title = null;
         string? outputPath = null;
@@ -270,56 +281,6 @@ private async Task<int> DispatchAlias (
         return await _dispatcher.DispatchAsync (alias, initial, options, cancellationToken, stdout, stderr);
     }
 
-    private async Task<int> DispatchHelp (
-        string? alias,
-        CancellationToken cancellationToken,
-        TextWriter stdout,
-        TextWriter stderr)
-    {
-        string markdown;
-        string title;
-
-        if (alias is not null)
-        {
-            if (!_registry.TryResolve (alias, out IClet? clet) || clet is null)
-            {
-                stderr.WriteLine ($"error: unknown alias '{alias}'. Try 'clet list' to see available clets.");
-
-                return ExitCodes.UsageError;
-            }
-
-            markdown = MarkdownHelpRenderer.BuildAliasHelpMarkdown (clet);
-            title = $"clet help {clet.PrimaryAlias}";
-        }
-        else
-        {
-            string? rawMarkdown = MarkdownHelpRenderer.ReadEmbeddedHelp ("overview.md");
-
-            if (rawMarkdown is null)
-            {
-                stdout.WriteLine ("clet — typed terminal prompts (and viewers) for shells, scripts, and AI agents");
-                stdout.WriteLine ();
-                stdout.WriteLine ("Usage: clet <alias> [options]");
-                stdout.WriteLine ("       clet list [--json]");
-                stdout.WriteLine ("       clet help <alias>");
-
-                return ExitCodes.Ok;
-            }
-
-            string cletTable = MarkdownHelpRenderer.BuildCletTableMarkdown (_registry).TrimEnd ();
-            markdown = rawMarkdown.Replace ("{{CLET_TABLE}}", cletTable);
-            markdown = markdown.Replace ("{{VERSION}}", $"v{GetVersion ()} (Terminal.Gui {GetTerminalGuiVersion ()})");
-            title = "clet";
-        }
-
-        CletRunOptions options = new ()
-        {
-            Title = title,
-        };
-
-        return await _dispatcher.DispatchAsync ("md", markdown, options, cancellationToken, stdout, stderr);
-    }
-
     private int WriteList (string[] args, TextWriter stdout)
     {
         bool json = args.Length > 1 && args [1] is "--json" or "-j";
diff --git a/src/Clet/Hosting/MarkdownHelpRenderer.cs b/src/Clet/Hosting/MarkdownHelpRenderer.cs
index 1b221fd..bf7474d 100644
--- a/src/Clet/Hosting/MarkdownHelpRenderer.cs
+++ b/src/Clet/Hosting/MarkdownHelpRenderer.cs
@@ -189,6 +189,15 @@ public static string BuildAliasHelpMarkdown (IClet clet)
             }
         }
 
+        // Append embedded help content (examples, notes) if available
+        string? extra = ReadEmbeddedHelp ($"{clet.PrimaryAlias}.md");
+
+        if (extra is not null)
+        {
+            sb.AppendLine ();
+            sb.Append (extra);
+        }
+
         return sb.ToString ();
     }
 
@@ -214,6 +223,12 @@ public static string BuildCletTableMarkdown (ICletRegistry registry)
             sb.AppendLine ($"| {aliases} | {clet.Description} | {options} |");
         }
 
+        // Links don't work inside table cells (gui-cs/Terminal.Gui#5227), so add a
+        // clickable list after the table for help navigation.
+        sb.AppendLine ();
+        sb.Append ("Click for details: ");
+        sb.AppendLine (string.Join (", ", registry.All.Select (c => $"[{c.PrimaryAlias}](clet:help:{c.PrimaryAlias})")));
+
         return sb.ToString ();
     }
 
diff --git a/src/Clet/Hosting/TerminalEscapeSanitizer.cs b/src/Clet/Hosting/TerminalEscapeSanitizer.cs
index b02fcc2..b75c121 100644
--- a/src/Clet/Hosting/TerminalEscapeSanitizer.cs
+++ b/src/Clet/Hosting/TerminalEscapeSanitizer.cs
@@ -137,11 +137,73 @@ public static string SanitizeRenderedOutput (string renderedAnsi)
                                 i++;
                             }
                         }
+                        else if (next == ']')
+                        {
+                            // OSC sequence (ESC ]). Preserve OSC 8 (hyperlinks) — they're
+                            // legitimate renderer output for terminals that support them.
+                            // Strip all other OSC sequences.
+                            if (i + 2 < renderedAnsi.Length && renderedAnsi [i + 2] == '8')
+                            {
+                                // OSC 8 hyperlink — pass through until ST (ESC \ or BEL)
+                                sb.Append ('\x1b');
+                                sb.Append (']');
+                                i += 2;
+
+                                while (i < renderedAnsi.Length)
+                                {
+                                    char osc = renderedAnsi [i];
+
+                                    if (osc == '\x07')
+                                    {
+                                        // BEL terminates OSC
+                                        sb.Append (osc);
+
+                                        break;
+                                    }
+
+                                    if (osc == '\x1b' && i + 1 < renderedAnsi.Length && renderedAnsi [i + 1] == '\\')
+                                    {
+                                        // ST (ESC \) terminates OSC
+                                        sb.Append ('\x1b');
+                                        sb.Append ('\\');
+                                        i++;
+
+                                        break;
+                                    }
+
+                                    sb.Append (osc);
+                                    i++;
+                                }
+                            }
+                            else
+                            {
+                                // Non-hyperlink OSC — strip until ST or BEL
+                                i += 2;
+
+                                while (i < renderedAnsi.Length)
+                                {
+                                    char osc = renderedAnsi [i];
+
+                                    if (osc == '\x07')
+                                    {
+                                        break;
+                                    }
+
+                                    if (osc == '\x1b' && i + 1 < renderedAnsi.Length && renderedAnsi [i + 1] == '\\')
+                                    {
+                                        i++;
+
+                                        break;
+                                    }
+
+                                    i++;
+                                }
+                            }
+                        }
                         else if (next >= '@' && next <= '_')
                         {
-                            // C1 7-bit pair (ESC @ through ESC _, excluding ESC [ which was handled above).
-                            // Includes dangerous sequences like OSC (ESC ]), DCS (ESC P), etc.
-                            // Strip the pair.
+                            // Other C1 7-bit pair (ESC @ through ESC _, excluding ESC [ and ESC ]).
+                            // Includes DCS (ESC P), etc. Strip the pair.
                             i++;
                         }
                         else
diff --git a/src/Clet/Registry/BuiltInClets.cs b/src/Clet/Registry/BuiltInClets.cs
index d7b5762..aab3775 100644
--- a/src/Clet/Registry/BuiltInClets.cs
+++ b/src/Clet/Registry/BuiltInClets.cs
@@ -18,7 +18,8 @@ public static void RegisterAll (ICletRegistry registry)
         registry.Register (new AttributePickerClet ());
         registry.Register (new PickFileClet ());
         registry.Register (new PickDirectoryClet ());
-        registry.Register (new RangeClet ());
+        registry.Register (new LinearRangeClet ());
         registry.Register (new MarkdownClet ());
+        registry.Register (new HelpClet (registry));
     }
 }
diff --git a/tests/Clet.IntegrationTests/LinearRangeCletIntegrationTests.cs b/tests/Clet.IntegrationTests/LinearRangeCletIntegrationTests.cs
new file mode 100644
index 0000000..fb2d6a4
--- /dev/null
+++ b/tests/Clet.IntegrationTests/LinearRangeCletIntegrationTests.cs
@@ -0,0 +1,80 @@
+using Terminal.Gui.App;
+using Xunit;
+
+namespace Clet.IntegrationTests;
+
+public class LinearRangeCletIntegrationTests
+{
+    [Fact]
+    public async Task RunAsync_CancellationToken_AlreadyCancelled_ReturnsCancelled ()
+    {
+        using IApplication app = Application.Create ();
+        app.Init ("ansi");
+
+        LinearRangeClet clet = new ();
+        CletRunOptions options = new ()
+        {
+            CletOptions = new Dictionary<string, string> { ["options"] = "A,B,C,D" },
+        };
+
+        using CancellationTokenSource cts = new ();
+        cts.Cancel ();
+
+        CletRunResult<System.Text.Json.Nodes.JsonObject?> result = await clet.RunAsync (
+            app, null, options, cts.Token);
+
+        Assert.Equal (CletRunStatus.Cancelled, result.Status);
+        Assert.Null (result.Value);
+    }
+
+    [Fact]
+    public async Task RunAsync_SingleMode_WithStopAfterFirstIteration_ReturnsOk ()
+    {
+        using IApplication app = Application.Create ();
+        app.Init ("ansi");
+        app.StopAfterFirstIteration = true;
+
+        LinearRangeClet clet = new ();
+        CletRunOptions options = new ()
+        {
+            CletOptions = new Dictionary<string, string>
+            {
+                ["options"] = "10,20,30,40,50",
+                ["mode"] = "single",
+            },
+        };
+
+        using CancellationTokenSource cts = new ();
+
+        CletRunResult<System.Text.Json.Nodes.JsonObject?> result = await clet.RunAsync (
+            app, null, options, cts.Token);
+
+        Assert.Equal (CletRunStatus.Ok, result.Status);
+    }
+
+    [Fact]
+    public async Task RunAsync_RangeMode_WithInitial_StopsCleanly ()
+    {
+        using IApplication app = Application.Create ();
+        app.Init ("ansi");
+        app.StopAfterFirstIteration = true;
+
+        LinearRangeClet clet = new ();
+        CletRunOptions options = new ()
+        {
+            CletOptions = new Dictionary<string, string>
+            {
+                ["options"] = "S,M,L,XL",
+                ["mode"] = "range",
+                ["range-kind"] = "closed",
+            },
+        };
+
+        using CancellationTokenSource cts = new ();
+
+        CletRunResult<System.Text.Json.Nodes.JsonObject?> result = await clet.RunAsync (
+            app, "S..L", options, cts.Token);
+
+        Assert.Equal (CletRunStatus.Ok, result.Status);
+    }
+}
diff --git a/tests/Clet.IntegrationTests/RangeCletIntegrationTests.cs b/tests/Clet.IntegrationTests/RangeCletIntegrationTests.cs
deleted file mode 100644
index 38b0f2b..0000000
--- a/tests/Clet.IntegrationTests/RangeCletIntegrationTests.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-using System.Text.Json.Nodes;
-using Terminal.Gui.App;
-using Xunit;
-
-namespace Clet.IntegrationTests;
-
-public class RangeCletIntegrationTests
-{
-    [Fact]
-    public async Task RunAsync_CancellationToken_AlreadyCancelled_ReturnsCancelled ()
-    {
-        using IApplication app = Application.Create ();
-        app.Init ("ansi");
-
-        RangeClet clet = new ();
-        CletRunOptions options = new ();
-
-        using CancellationTokenSource cts = new ();
-        cts.Cancel ();
-
-        CletRunResult<JsonObject?> result = await clet.RunAsync (app, null, options, cts.Token);
-
-        Assert.Equal (CletRunStatus.Cancelled, result.Status);
-        Assert.Null (result.Value);
-    }
-
-    [Fact]
-    public async Task RunAsync_WithStopAfterFirstIteration_ReturnsOk ()
-    {
-        using IApplication app = Application.Create ();
-        app.Init ("ansi");
-        app.StopAfterFirstIteration = true;
-
-        RangeClet clet = new ();
-        CletRunOptions options = new ();
-
-        using CancellationTokenSource cts = new ();
-
-        CletRunResult<JsonObject?> result = await clet.RunAsync (app, null, options, cts.Token);
-
-        Assert.Equal (CletRunStatus.Ok, result.Status);
-    }
-
-    [Fact]
-    public async Task RunAsync_WithInitialValue_SetsRange ()
-    {
-        using IApplication app = Application.Create ();
-        app.Init ("ansi");
-        app.StopAfterFirstIteration = true;
-
-        RangeClet clet = new ();
-        CletRunOptions options = new ();
-
-        using CancellationTokenSource cts = new ();
-
-        CletRunResult<JsonObject?> result = await clet.RunAsync (app, "5..10", options, cts.Token);
-
-        Assert.Equal (CletRunStatus.Ok, result.Status);
-    }
-}
diff --git a/tests/Clet.SmokeTests/CletSmokeTests.cs b/tests/Clet.SmokeTests/CletSmokeTests.cs
index d1d73da..de49352 100644
--- a/tests/Clet.SmokeTests/CletSmokeTests.cs
+++ b/tests/Clet.SmokeTests/CletSmokeTests.cs
@@ -62,7 +62,7 @@ public async Task HelpAlias_UnknownAlias_ExitsWithUsageError ()
         (int exit, string stdout, string stderr) = await CletProcess.RunAsync (["help", "nope"]);
 
         Assert.Equal (2, exit);
-        Assert.Contains ("unknown alias", stderr);
+        Assert.Contains ("Unknown alias", stderr);
     }
 
     [Fact]
diff --git a/tests/Clet.UnitTests/BuiltInCletsTests.cs b/tests/Clet.UnitTests/BuiltInCletsTests.cs
index 17cde82..6d891e3 100644
--- a/tests/Clet.UnitTests/BuiltInCletsTests.cs
+++ b/tests/Clet.UnitTests/BuiltInCletsTests.cs
@@ -31,10 +31,12 @@ public void RegisterAll_RegistersSelect ()
     [InlineData ("color")]
     [InlineData ("multi-select")]
     [InlineData ("attribute-picker")]
+    [InlineData ("attribute")]
     [InlineData ("pick-file")]
     [InlineData ("file")]
     [InlineData ("pick-directory")]
     [InlineData ("dir")]
+    [InlineData ("linear-range")]
     [InlineData ("range")]
     public void RegisterAll_RegistersInputClet (string alias)
     {
@@ -49,6 +51,7 @@ public void RegisterAll_RegistersInputClet (string alias)
     [Theory]
     [InlineData ("md")]
     [InlineData ("markdown")]
+    [InlineData ("help")]
     public void RegisterAll_RegistersViewerClet (string alias)
     {
         ICletRegistry registry = new CletRegistry ();
@@ -60,11 +63,11 @@ public void RegisterAll_RegistersViewerClet (string alias)
     }
 
     [Fact]
-    public void RegisterAll_Registers16Clets ()
+    public void RegisterAll_Registers17Clets ()
     {
         CletRegistry registry = new ();
         BuiltInClets.RegisterAll (registry);
 
-        Assert.Equal (16, registry.All.Count);
+        Assert.Equal (17, registry.All.Count);
     }
 }
diff --git a/tests/Clet.UnitTests/CommandLineRootTests.cs b/tests/Clet.UnitTests/CommandLineRootTests.cs
index 8163dce..bf2e842 100644
--- a/tests/Clet.UnitTests/CommandLineRootTests.cs
+++ b/tests/Clet.UnitTests/CommandLineRootTests.cs
@@ -70,7 +70,7 @@ public async Task HelpAlias_UnknownAlias_WritesStderrAndExits2 ()
         int exit = await root.InvokeAsync (["help", "nope"], CancellationToken.None, stdout, stderr);
 
         Assert.Equal (ExitCodes.UsageError, exit);
-        Assert.Contains ("unknown alias", stderr.ToString ());
+        Assert.Contains ("Unknown alias", stderr.ToString ());
     }
 
     [Fact]
@@ -342,7 +342,8 @@ public async Task Alias_InitialAtExactLimit_DoesNotReject ()
     [InlineData ("time", "not-a-time")]
     [InlineData ("duration", "not-a-duration")]
     [InlineData ("confirm", "maybe")]
-    [InlineData ("range", "bad")]
+    // `linear-range` doesn't validate --initial strictly — unmatched labels just produce
+    // an empty span. No "invalid --initial value" path to test, so it isn't in this list.
     public async Task Alias_InvalidInitialValue_ExitsWithUsageError (string alias, string initial)
     {
         (CommandLineRoot root, StringWriter stdout, StringWriter stderr) = Build ();
@@ -387,14 +388,20 @@ public async Task MdCat_WithFile_RendersFileToStdout ()
     }
 
     [Fact]
-    public async Task MdCat_NoContent_ExitsWithUsageError ()
+    public async Task MdCat_NoContent_ExitsWithIoError ()
     {
         (CommandLineRoot root, StringWriter stdout, StringWriter stderr) = Build ();
 
         int exit = await root.InvokeAsync (["md", "--cat"], CancellationToken.None, stdout, stderr);
 
-        Assert.Equal (ExitCodes.UsageError, exit);
-        Assert.Contains ("--cat requires content", stderr.ToString ());
+        // When stdin is redirected (test runner / CI), MarkdownClet reads empty stdin
+        // and returns "No input received from stdin". When not redirected, it returns
+        // "No file specified". Both are IO errors.
+        Assert.Equal (ExitCodes.IoError, exit);
+        string err = stderr.ToString ();
+        Assert.True (
+            err.Contains ("No file specified") || err.Contains ("No input received from stdin"),
+            $"Expected IO error message, got: {err}");
     }
 
     [Fact]
diff --git a/tests/Clet.UnitTests/LinearRangeCletTests.cs b/tests/Clet.UnitTests/LinearRangeCletTests.cs
new file mode 100644
index 0000000..5b81f74
--- /dev/null
+++ b/tests/Clet.UnitTests/LinearRangeCletTests.cs
@@ -0,0 +1,72 @@
+using Xunit;
+
+namespace Clet.UnitTests;
+
+public class LinearRangeCletTests
+{
+    [Fact]
+    public void Metadata_AdvertisesAlias ()
+    {
+        LinearRangeClet clet = new ();
+
+        Assert.Equal ("linear-range", clet.PrimaryAlias);
+        Assert.Contains ("linear-range", clet.Aliases);
+        Assert.Equal (CletKind.Input, clet.Kind);
+        Assert.Equal (typeof (System.Text.Json.Nodes.JsonObject), clet.ResultType);
+    }
+
+    [Fact]
+    public void Options_IncludesModeAndOptions ()
+    {
+        LinearRangeClet clet = new ();
+
+        Assert.Contains (clet.Options, o => o.Name == "mode");
+        Assert.Contains (clet.Options, o => o.Name == "options");
+        Assert.Contains (clet.Options, o => o.Name == "orientation");
+        Assert.Contains (clet.Options, o => o.Name == "range-kind");
+        Assert.Contains (clet.Options, o => o.Name == "allow-empty");
+        Assert.Contains (clet.Options, o => o.Name == "hide-legends");
+    }
+
+    [Fact]
+    public void AcceptsPositionalArgs_IsTrue ()
+    {
+        LinearRangeClet clet = new ();
+
+        Assert.True (clet.AcceptsPositionalArgs);
+    }
+
+    [Fact]
+    public async Task RunAsync_NoOptions_ReturnsValidationError ()
+    {
+        LinearRangeClet clet = new ();
+        CletRunOptions options = new ();
+
+        using CancellationTokenSource cts = new ();
+
+        CletRunResult<System.Text.Json.Nodes.JsonObject?> result = await clet.RunAsync (
+            null!, null, options, cts.Token);
+
+        Assert.Equal (CletRunStatus.Error, result.Status);
+        Assert.Equal ("validation", result.ErrorCode);
+        Assert.Contains ("requires --options", result.ErrorMessage ?? "");
+    }
+
+    [Fact]
+    public async Task RunAsync_PreCancelled_ReturnsCancelled ()
+    {
+        LinearRangeClet clet = new ();
+        CletRunOptions options = new ()
+        {
+            CletOptions = new Dictionary<string, string> { ["options"] = "a,b,c" },
+        };
+
+        using CancellationTokenSource cts = new ();
+        cts.Cancel ();
+
+        CletRunResult<System.Text.Json.Nodes.JsonObject?> result = await clet.RunAsync (
+            null!, null, options, cts.Token);
+
+        Assert.Equal (CletRunStatus.Cancelled, result.Status);
+    }
+}
diff --git a/tests/Clet.UnitTests/RangeCletTests.cs b/tests/Clet.UnitTests/RangeCletTests.cs
deleted file mode 100644
index c1bd63f..0000000
--- a/tests/Clet.UnitTests/RangeCletTests.cs
+++ /dev/null
@@ -1,64 +0,0 @@
-using Xunit;
-
-namespace Clet.UnitTests;
-
-public class RangeCletTests
-{
-    [Fact]
-    public void PrimaryAlias_IsRange ()
-    {
-        RangeClet clet = new ();
-
-        Assert.Equal ("range", clet.PrimaryAlias);
-    }
-
-    [Fact]
-    public void Kind_IsInput ()
-    {
-        RangeClet clet = new ();
-
-        Assert.Equal (CletKind.Input, clet.Kind);
-    }
-
-    [Fact]
-    public void ResultType_IsJsonObject ()
-    {
-        RangeClet clet = new ();
-
-        Assert.Equal (typeof (System.Text.Json.Nodes.JsonObject), clet.ResultType);
-    }
-
-    [Fact]
-    public void Description_IsNotEmpty ()
-    {
-        RangeClet clet = new ();
-
-        Assert.NotEmpty (clet.Description);
-    }
-
-    [Fact]
-    public void Aliases_ContainsRange ()
-    {
-        RangeClet clet = new ();
-
-        Assert.Contains ("range", clet.Aliases);
-    }
-
-    [Fact]
-    public void Options_ContainsStep ()
-    {
-        RangeClet clet = new ();
-
-        Assert.Single (clet.Options);
-        Assert.Equal ("step", clet.Options [0].Name);
-        Assert.False (clet.Options [0].Required);
-    }
-
-    [Fact]
-    public void AcceptsPositionalArgs_IsFalse ()
-    {
-        IClet clet = new RangeClet ();
-
-        Assert.False (clet.AcceptsPositionalArgs);
-    }
-}
diff --git a/tests/Clet.UnitTests/RangeViewTests.cs b/tests/Clet.UnitTests/RangeViewTests.cs
deleted file mode 100644
index 62321b3..0000000
--- a/tests/Clet.UnitTests/RangeViewTests.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-using Terminal.Gui.ViewBase;
-using Xunit;
-
-namespace Clet.UnitTests;
-
-public class RangeViewTests
-{
-    [Fact]
-    public void Defaults_HasFillWidthAndUnitHeight ()
-    {
-        RangeView view = new ();
-
-        Assert.Equal (Dim.Fill (), view.Width);
-        Assert.Equal (Dim.Absolute (1), view.Height);
-    }
-
-    [Fact]
-    public void Defaults_LowAndHighStartAtZero ()
-    {
-        RangeView view = new ();
-
-        Assert.Equal (0, view.LowValue);
-        Assert.Equal (0, view.HighValue);
-    }
-
-    [Fact]
-    public void RangeResult_ReflectsValues ()
-    {
-        RangeView view = new () { LowValue = 3, HighValue = 7 };
-
-        Assert.Equal ((3, 7), view.RangeResult);
-    }
-
-    [Fact]
-    public void Increment_AppliesToBothSpinners ()
-    {
-        RangeView view = new () { Increment = 5, LowValue = 0, HighValue = 0 };
-
-        Assert.Equal (5, view.Increment);
-    }
-}