diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0218e88..f5b89a5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -15,8 +15,41 @@ on:
       - "*.*.*"
 
 jobs:
+  # On pull requests, only linux-x64 runs, to prove AOT still links without burning the full matrix
+  # on packages nobody sees. All five run on push, where the packages are actually uploaded.
+  aot-pack:
+    runs-on: ${{ matrix.runner }}
+    name: AOT pack (${{ matrix.rid }})
+    strategy:
+      fail-fast: false
+      matrix:
+        include: ${{ fromJSON(github.event_name == 'pull_request'
+          && '[{"rid":"linux-x64","runner":"ubuntu-latest"}]'
+          || '[{"rid":"linux-x64","runner":"ubuntu-latest"},{"rid":"linux-arm64","runner":"ubuntu-24.04-arm"},{"rid":"win-x64","runner":"windows-latest"},{"rid":"win-arm64","runner":"windows-11-arm"},{"rid":"osx-arm64","runner":"macos-latest"}]') }}
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 1
+      - uses: actions/setup-dotnet@v5
+        with:
+          dotnet-version: |
+            10.0.x
+
+      - run: dotnet pack src/release-notes/release-notes.csproj -c Release -r ${{ matrix.rid }} -o build/output
+        name: Pack native-AOT tool for ${{ matrix.rid }}
+        shell: bash
+
+      - name: Upload per-RID package
+        if: github.event_name == 'push'
+        uses: actions/upload-artifact@v4
+        with:
+          name: nupkg-${{ matrix.rid }}
+          path: build/output/*.nupkg
+          if-no-files-found: error
+
   build:
     runs-on: ubuntu-latest
+    needs: aot-pack
     steps:
     - uses: actions/checkout@v5
       with:
@@ -37,6 +70,15 @@ jobs:
       name: Build
     - run: ./build.sh generatepackages -s true
       name: Generate local nuget packages
+
+    - name: Download per-RID AOT packages
+      if: github.event_name == 'push'
+      uses: actions/download-artifact@v4
+      with:
+        pattern: nupkg-*
+        path: build/output
+        merge-multiple: true
+
     - run: ./build.sh validatepackages -s true
       name: "validate *.npkg files that were created"
     - run: ./build.sh generateapichanges -s true
diff --git a/Directory.Build.props b/Directory.Build.props
index d05fa3e..169a30a 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -3,6 +3,8 @@
   <PropertyGroup>
     <MinVerDefaultPreReleaseIdentifiers>canary.0</MinVerDefaultPreReleaseIdentifiers>
     <MinVerMinimumMajorMinor>0.1</MinVerMinimumMajorMinor>
+    <!-- Nullean.Argh's source-generated dispatch code uses C# 13 syntax regardless of the TFM it targets. -->
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="MinVer" Version="6.0.0">
diff --git a/README.md b/README.md
index e0e9507..b33dc71 100644
--- a/README.md
+++ b/README.md
@@ -14,39 +14,98 @@ Distributed as a .NET tool so install using the following
 dotnet tool install release-notes
 ```
 
-## Run 
+On Linux, Windows and macOS/arm64, this resolves to a self-contained native-AOT executable — no
+shared .NET runtime required, and no first-run JIT warmup. Everywhere else, it falls back to a
+framework-dependent build (requires the .NET runtime the tool targets to already be installed).
+
+## Run
 
 ```bat
-dotnet release-notes
+dotnet release-notes <command> <owner> <repository-name> --version <string> [options]
+```
+
+You can omit `dotnet` if you install this as a global tool.
+
+> [!IMPORTANT]
+> Starting from `1.0.0`, every invocation requires an explicit command name (`generate`,
+> `apply-labels`, `find-previous`, `current-version` or `create-release`) — there is no longer a bare
+> `release-notes <owner> <repo> ...` shorthand for `generate`. `--label` also changes from two tokens
+> (`--label <label> <description>`) to one combined token (`--label <label>=<description>`), and every
+> other flag moves from a single word to kebab-case (e.g. `--oldversion` → `--old-version`). This is a
+> breaking change from earlier `0.x` releases, a side effect of moving off `Argu` (which no longer
+> worked once this tool was AOT-compiled) onto [`Nullean.Argh`](https://github.com/nullean/argh).
+
+```bat
+Usage: release-notes <namespace|command> [options]
+
+Commands:
+  apply-labels     Creates the version and backport labels for the next release.
+  create-release   Makes sure the tag exists as a release on GitHub, and
+                   introduces new version labels for the next major/minor/patch.
+  current-version  Given a search query, finds the current and the next versions
+                   and prints them on separate lines.
+  find-previous    Finds and prints the previous release for the given version.
+  generate         Generates release notes for version from closed GitHub issues
+                   and PRs, printed to standard out and optionally written to a
+                   file.
 ```
 
-You can omit `dotnet` if you install this as a global tool
+Every command takes the same `<owner> <repository-name>` positionals and shared options:
 
 ```bat
-USAGE: release-notes [--help] [--label <label> <description>] [--token <string>] [--version <string>]
-                     [--oldversion <string>] [--releaselabel <string>] [--uncategorizedheader <string>]
-                     <owner> <repository name>
+Arguments:
+  <owner>            GitHub repository owner.
+  <repository-name>  GitHub repository name.
 
-REPOSITORY:
+Options:
+  --version <string>                [required] Version that is being released.
+  --token <string>                  The GitHub token to use. If the issue list is long this may be necessary; defaults to anonymous.
+  --old-version <string>            The previous version to generate release notes since. Optional; the tool will find the previous release.
+  --release-tag-format <string>     The release tag format. VERSION is replaced by the actual version. [default: VERSION]
+  --release-label-format <string>   The release label format. VERSION is replaced by the actual version. [default: vVERSION]
+  --backport-label-format <string>  The backport label format, e.g. "Backport BRANCH". BRANCH is calculated from the version.
+  --format <enum>                   The format in which to print the results: Markdown or AsciiDoc. [default: markdown]
+  --uncategorized-header <string>   The header to use in the markdown for uncategorized issues/PRs.
+  --label <values>                  [repeatable] Map a GitHub label to a categorization heading, formatted as <label>=<description>. May be given
+                                     more than once. Defaults to bug=Bug Fixes, enhancement=New Features, documentation=Documentation Improvements.
+  --output <string>                 Write the release notes to a file as well as standard out. VERSION is replaced by the actual version.
+```
 
-    <owner> <repository name>
-                          Repository to use in <owner> <repos_name> format
+#### Examples
 
-OPTIONS:
+Generate markdown release notes to standard out (and print to a file with `--output`):
 
-    --label <label> <description>
-                          Map Github labels to categorizations, format <label> <description>, can be specified
-                          multiple times
-    --token <string>      The github token to use, if the issue list is long this may be necessary, defaults to
-                          anonymoys
-    --version <string>    The version that we are generating release notes for
-    --oldversion <string> The previous version to generates release notes since
-    --releaselabel <string>
-                          The version label on the issues / github prs, defaults to v[VERSION]
-    --uncategorizedheader <string>
-                          The header to use in the markdown for uncategorized issues/prs
-    --help                display this list of options.
+```bat
+dotnet release-notes generate nullean release-notes --version 1.0.0
 ```
 
-#### Examples:
+Find the previous release for a version:
 
+```bat
+dotnet release-notes find-previous nullean release-notes --version 1.0.0
+```
+
+Given a search query (`M.N`, `M.x`, or `master`/`main`), print the current and next version on separate lines:
+
+```bat
+dotnet release-notes current-version nullean release-notes --version 1.0.0 --query master
+```
+
+Create the version and backport labels for the next release:
+
+```bat
+dotnet release-notes apply-labels nullean release-notes --version 1.0.0 --backport-label-format "Backport BRANCH"
+```
+
+Make sure the tag exists as a release on GitHub, using one or more files for the release body, and
+introduce new version labels for the next major/minor/patch:
+
+```bat
+dotnet release-notes create-release nullean release-notes --version 1.0.0 --body notes.md --body breaking-changes.md --token $GITHUB_TOKEN
+```
+
+Map GitHub labels to custom categorization headings (replaces the default bug/enhancement/documentation set):
+
+```bat
+dotnet release-notes generate nullean release-notes --version 1.0.0 --label bug=Bug Fixes --label enhancement=New Features
+```
diff --git a/build/scripts/Paths.fs b/build/scripts/Paths.fs
index 9c7b95e..c23d1d1 100644
--- a/build/scripts/Paths.fs
+++ b/build/scripts/Paths.fs
@@ -6,6 +6,14 @@ open System.IO
 let ToolName = "release-notes"
 let Repository = sprintf "nullean/%s" ToolName
 
+/// The RIDs we ship native-AOT tool packages for. AOT compilation requires a matching
+/// OS/arch, so CI packs one RID per runner; this list only documents the set.
+let AotRuntimeIdentifiers = ["linux-x64"; "linux-arm64"; "win-x64"; "win-arm64"; "osx-arm64"]
+
+/// Must mirror release-notes.csproj's TargetFrameworks. Used to patch the signed managed dll back
+/// into the packed 'any' fallback for every TFM it ships — see fixAnyPackageSigning in Targets.fs.
+let ManagedTargetFrameworks = ["net8.0"; "net10.0"]
+
 let Root =
     let mutable dir = DirectoryInfo(".")
     while dir.GetFiles("*.slnx").Length = 0 do dir <- dir.Parent
diff --git a/build/scripts/Targets.fs b/build/scripts/Targets.fs
index 0e9b0a2..4057484 100644
--- a/build/scripts/Targets.fs
+++ b/build/scripts/Targets.fs
@@ -3,6 +3,7 @@ module Targets
 open Argu
 open System
 open System.IO
+open System.IO.Compression
 open Bullseye
 open CommandLine
 open Fake.Tools.Git
@@ -34,13 +35,62 @@ let private pristineCheck (arguments:ParseResults<Arguments>) =
     | true  -> printfn "The checkout folder does not have pending changes, proceeding"
     | _ -> failwithf "The checkout folder has pending changes, aborting"
 
+let private isPerRidPackage (name: string) =
+    Paths.AotRuntimeIdentifiers |> List.exists (fun rid -> name.Contains(sprintf ".%s." rid))
+
+/// `dotnet pack`'s RID-aware tool-packaging path (used once RuntimeIdentifiers is declared) copies
+/// the *unsigned* obj/ build of this project's own assembly into the portable 'any' package, even
+/// though the normal bin/ output is correctly strong-name signed — a long-standing obj-vs-bin mixup
+/// in `dotnet pack` (see https://github.com/dotnet/sdk/issues/20197) that resurfaces here. Patched in
+/// place after packing by swapping in the signed bin/ copies for every TFM the 'any' package ships.
+let private fixAnyPackageSigning (anyPackagePath: string) =
+    use archive = ZipFile.Open(anyPackagePath, ZipArchiveMode.Update)
+    for tfm in Paths.ManagedTargetFrameworks do
+        let entryName = sprintf "tools/%s/any/%s.dll" tfm Paths.ToolName
+        let signedDll = Path.Combine(Paths.ToolProject.FullName, "bin", "Release", tfm, sprintf "%s.dll" Paths.ToolName)
+        match archive.GetEntry(entryName), File.Exists signedDll with
+        | null, _ | _, false -> ()
+        | entry, true ->
+            entry.Delete()
+            let newEntry = archive.CreateEntry(entryName)
+            use entryStream = newEntry.Open()
+            use fileStream = File.OpenRead(signedDll)
+            fileStream.CopyTo(entryStream)
+
 let private generatePackages (arguments:ParseResults<Arguments>) =
     let output = Paths.RootRelative Paths.Output.FullName
-    exec "dotnet" ["pack"; "-c"; "Release"; "-o"; output] |> ignore
-    
+    if not Paths.Output.Exists then Paths.Output.Create()
+
+    // A plain `dotnet pack` emits the root package (whose DotnetToolSettings.xml v2 maps each RID to
+    // its own package) AND a package per RID — but native AOT can only compile for the machine it
+    // runs on, so those per-RID outputs from a single machine are self-contained MANAGED builds,
+    // silently missing the AOT compilation. We therefore keep only the root and the portable 'any'
+    // fallback here, and take the real per-RID packages from the CI matrix, where each is compiled
+    // on a matching runner (see aot-pack in .github/workflows/ci.yml).
+    let staging = Paths.RootRelative <| Path.Combine(Paths.Output.FullName, "..", "release-notes-staging")
+    if Directory.Exists staging then Directory.Delete(staging, true)
+    exec "dotnet" ["pack"; sprintf "src/%s/%s.csproj" Paths.ToolName Paths.ToolName; "-c"; "Release"; "-o"; staging] |> ignore
+
+    DirectoryInfo(staging).GetFiles("*.nupkg")
+    |> Seq.filter (fun f -> not (isPerRidPackage f.Name))
+    |> Seq.iter (fun f ->
+        let destination = Path.Combine(Paths.Output.FullName, f.Name)
+        printfn "keeping %s" f.Name
+        f.CopyTo(destination, true) |> ignore
+        if f.Name.Contains(sprintf "%s.any." Paths.ToolName) then
+            fixAnyPackageSigning destination)
+
+    Directory.Delete(staging, true)
+
 let private validatePackages (arguments:ParseResults<Arguments>) =
     let nugetPackage =
-        let p = Paths.Output.GetFiles("*.nupkg") |> Seq.sortByDescending(fun f -> f.CreationTimeUtc) |> Seq.head
+        // Only the 'any' package carries a signed managed assembly to check: the root package is
+        // just a DotnetToolSettings.xml pointer with no dll of its own, and the per-RID AOT packages
+        // hold a native binary with no managed identity either.
+        let p =
+            Paths.Output.GetFiles("*.nupkg")
+            |> Seq.filter (fun f -> f.Name.Contains(sprintf "%s.any." Paths.ToolName))
+            |> Seq.sortByDescending(fun f -> f.CreationTimeUtc) |> Seq.head
         Paths.RootRelative p.FullName
     exec "dotnet" ["nupkg-validator"; nugetPackage; "-v"; currentVersionInformational.Value; "-a"; Paths.ToolName; "-k"; "96c599bbe3e70f5d"] |> ignore
 
@@ -68,11 +118,12 @@ let private generateReleaseNotes (arguments:ParseResults<Arguments>) =
         | None -> []
         | Some token -> ["--token"; token;]
     let releaseNotesArgs =
-        (Paths.Repository.Split("/") |> Seq.toList)
+        ["generate"]
+        @ (Paths.Repository.Split("/") |> Seq.toList)
         @ ["--version"; currentVersion
-           "--label"; "enhancement"; "New Features"
-           "--label"; "bug"; "Bug Fixes"
-           "--label"; "documentation"; "Docs Improvements"
+           "--label"; "enhancement=New Features"
+           "--label"; "bug=Bug Fixes"
+           "--label"; "documentation=Docs Improvements"
         ] @ tokenArgs
         @ ["--output"; output]
         
@@ -89,9 +140,9 @@ let private createReleaseOnGithub (arguments:ParseResults<Arguments>) =
     let releaseNotes = Paths.RootRelative <| Path.Combine(Paths.Output.FullName, sprintf "release-notes-%s.md" currentVersion)
     let breakingChanges = Paths.RootRelative <| Path.Combine(Paths.Output.FullName, "github-breaking-changes-comments.md")
     let releaseArgs =
-        (Paths.Repository.Split("/") |> Seq.toList)
-        @ ["create-release"
-           "--version"; currentVersion
+        ["create-release"]
+        @ (Paths.Repository.Split("/") |> Seq.toList)
+        @ ["--version"; currentVersion
            "--body"; releaseNotes; 
            "--body"; breakingChanges; 
         ] @ tokenArgs
diff --git a/release-notes.slnx b/release-notes.slnx
index bafb048..04624c3 100644
--- a/release-notes.slnx
+++ b/release-notes.slnx
@@ -10,6 +10,6 @@
     <Project Path="build/scripts/scripts.fsproj" />
   </Folder>
   <Folder Name="/src/">
-    <Project Path="src/release-notes/release-notes.fsproj" />
+    <Project Path="src/release-notes/release-notes.csproj" />
   </Folder>
 </Solution>
diff --git a/src/release-notes/Arguments.fs b/src/release-notes/Arguments.fs
deleted file mode 100644
index e56e07d..0000000
--- a/src/release-notes/Arguments.fs
+++ /dev/null
@@ -1,94 +0,0 @@
-module ReleaseNotes.Arguments
-
-open Argu
-
-type CreateReleaseArguments =
-    | [<CustomCommandLine("--body")>]BodyFilePath of string  
-    with
-    interface IArgParserTemplate with
-        member s.Usage =
-            match s with
-            | BodyFilePath _ -> "Path to file that will be read and used for the body for the release, can be specified multiple times to combine"
-            
-type CurrentVersionArguments =
-    | [<CustomCommandLine("--query")>]Query of string  
-    with
-    interface IArgParserTemplate with
-        member s.Usage =
-            match s with
-            | Query _ -> "An anchor query, M.N, M.x, or master. will find the current and next patch, minor, major respectfully"
-
-type Format = Markdown | AsciiDoc
-
-type Arguments =
-    | [<MainCommand;Mandatory;Inherit; CliPrefix(CliPrefix.None);>] Repository of owner:string * repository_name:string
-    | [<SubCommand; CustomCommandLine("apply-labels"); CliPrefix(CliPrefix.None)>] ApplyLabels 
-    | [<SubCommand; CustomCommandLine("find-previous"); CliPrefix(CliPrefix.None);>] FindPreviousVersion 
-    | [<SubCommand; CustomCommandLine("current-version"); CliPrefix(CliPrefix.None);>] CurrentVersion of ParseResults<CurrentVersionArguments>
-    | [<SubCommand; CustomCommandLine("create-release"); CliPrefix(CliPrefix.None)>] CreateRelease of ParseResults<CreateReleaseArguments>
-    | [<Inherit;Mandatory>]Version of string
-    | [<Inherit>]Token of string
-    | [<Inherit>]Label of label:string * description:string
-    | OldVersion of string
-    | [<Inherit>]ReleaseTagFormat of string
-    | [<Inherit>]ReleaseLabelFormat of string
-    | [<Inherit>]BackportLabelFormat of string
-    | Format of Format
-    | UncategorizedHeader of string
-    | Output of string
-    
-    with
-    interface IArgParserTemplate with
-        member s.Usage =
-            match s with
-            | Version _ -> "Version that is being released"
-            | Token _ -> "The github token to use, if the issue list is long this may be necessary, defaults to anonymous"
-            
-            | ApplyLabels -> "Creates version and backport labels"
-            | FindPreviousVersion -> "Find the previous release for the passed version"
-            | CurrentVersion _ -> "Given search syntax finds the current and the next versions on separate lines"
-            | CreateRelease _ -> "Makes sure the tag exists as release on github and introduces new version labels for the next major/minor/patch"
-            
-            | Repository _ -> "Repository to use in <owner> <repos_name> format"
-            | Label _ -> "Map Github labels to categorizations, format <label> <description>, can be specified multiple times"
-            | OldVersion _ -> "The previous version to generate release notes since, optional the tool will find the previous release"
-            | ReleaseTagFormat _ ->
-                sprintf "The release tag format, defaults to VERSION, VERSION will be replaced by the actual version" 
-            | ReleaseLabelFormat _ ->
-                sprintf "The release label format, defaults to vVERSION, VERSION will be replaced by the actual version" 
-            | BackportLabelFormat _ ->
-                sprintf "The backport label format, defaults to 'Backport BRANCH`, BRANCH will be calculated from the version" 
-            | UncategorizedHeader _ -> "The header to use in the markdown for uncategorized issues/prs"
-            | Output _ -> "write the release notes to a file as well as standard out, VERSION will be replaced by the actual version"
-            | Format _ -> "The format in which to print the results, can be markdown and asciidoc"
-
-type GitHubRepository(owner, repository) =
-    member this.Owner = owner
-    member this.Repository = repository
-    member this.Url =
-        sprintf "https://github.com/%s/%s/" this.Owner this.Repository
-        
-type ReleaseNotesConfig =
-    {
-        GitHub: GitHubRepository
-        Labels: Map<string, string>
-        ApplyLabels: bool
-        Token: string option
-        Version: string
-        OldVersion: string option
-        ReleaseTagFormat: string 
-        ReleaseLabelFormat: string 
-        BackportLabelFormat: string option 
-        UncategorizedLabel: string 
-        UncategorizedHeader: string 
-        Output: string option
-        OldVersionOnly: bool
-        LabelColor: string
-        GenerateReleaseOnGithub: bool
-        ReleaseBodyFiles: string list option
-        VersionQuery: string option
-        Format: Format
-    }
-
-
-
diff --git a/src/release-notes/GitHubItem.cs b/src/release-notes/GitHubItem.cs
new file mode 100644
index 0000000..10aad7b
--- /dev/null
+++ b/src/release-notes/GitHubItem.cs
@@ -0,0 +1,50 @@
+using System.Text;
+using Octokit;
+
+namespace ReleaseNotes;
+
+public sealed class GitHubItem(Issue issue, IReadOnlyList<int> relatedIssues)
+{
+	public Issue Issue { get; } = issue;
+	public IReadOnlyList<int> RelatedIssues { get; } = relatedIssues;
+	public int Number => Issue.Number;
+	public IReadOnlyList<Label> Labels => Issue.Labels;
+
+	public string Title
+	{
+		get
+		{
+			var builder = new StringBuilder("#").Append(Issue.Number).Append(' ');
+			if (Issue.PullRequest is null)
+				builder.AppendFormat("[ISSUE] {0}", Issue.Title);
+			else
+			{
+				builder.Append(Issue.Title);
+				if (RelatedIssues.Count > 0)
+				{
+					var related = string.Join(", ", RelatedIssues.Select(i => $"#{i}"));
+					var noun = RelatedIssues.Count == 1 ? "issue" : "issues";
+					builder.Append($" ({noun}: {related})");
+				}
+			}
+
+			return builder.ToString();
+		}
+	}
+
+	public string TitleAsciiDoc(string githubUrl)
+	{
+		if (Issue.PullRequest is null)
+			return $"* {Issue.Title} {githubUrl}issues/{Issue.Number}[#{Issue.Number}]";
+
+		var related = "";
+		if (RelatedIssues.Count > 0)
+		{
+			var links = string.Join(", ", RelatedIssues.Select(i => $"{githubUrl}issues/{i}[#{i}]"));
+			var noun = RelatedIssues.Count == 1 ? "issue" : "issues";
+			related = $" ({noun}: {links})";
+		}
+
+		return $"* {Issue.Title} {githubUrl}pull/{Issue.Number}[#{Issue.Number}] {related}";
+	}
+}
diff --git a/src/release-notes/GithubItem.fs b/src/release-notes/GithubItem.fs
deleted file mode 100644
index 48a572d..0000000
--- a/src/release-notes/GithubItem.fs
+++ /dev/null
@@ -1,42 +0,0 @@
-namespace ReleaseNotes
-
-open System.Text
-open Octokit
-
-type GitHubItem(issue: Issue, relatedIssues: int list) =  
-    member val Issue = issue
-    member val RelatedIssues = relatedIssues
-    member this.Title =
-        let builder = StringBuilder("#")
-                          .Append(issue.Number)
-                          .Append(" ")       
-        if issue.PullRequest = null then
-            builder.AppendFormat("[ISSUE] {0}", issue.Title)
-        else
-            builder.Append(issue.Title) |> ignore
-            if relatedIssues.Length > 0 then
-                relatedIssues
-                |> List.map(fun i -> sprintf "#%i" i)
-                |> String.concat ", "
-                |> sprintf " (%s: %s)" (if relatedIssues.Length = 1 then "issue" else "issues")
-                |> builder.Append
-            else builder
-        |> ignore                  
-        builder.ToString()
-        
-    member this.TitleAsciiDoc githubUrl =
-        if issue.PullRequest = null then
-            sprintf "* %s %sissues/%i[#%i]" issue.Title githubUrl issue.Number issue.Number
-        else
-            let related =
-                if relatedIssues.Length > 0 then
-                    relatedIssues
-                    |> List.map(fun i -> sprintf "%sissues/%i[#%i]" githubUrl i i)
-                    |> String.concat ", "
-                    |> sprintf " (%s: %s)" (if relatedIssues.Length = 1 then "issue" else "issues")
-                else ""
-            sprintf "* %s %spull/%i[#%i] %s" issue.Title githubUrl issue.Number issue.Number related
-        
-    member this.Labels = issue.Labels   
-    member this.Number = issue.Number
-
diff --git a/src/release-notes/GithubScanner.cs b/src/release-notes/GithubScanner.cs
new file mode 100644
index 0000000..e632547
--- /dev/null
+++ b/src/release-notes/GithubScanner.cs
@@ -0,0 +1,106 @@
+using System.Text.RegularExpressions;
+using Octokit;
+
+namespace ReleaseNotes;
+
+public static class GithubScanner
+{
+	public static Regex IssueNumberRegex(string url)
+	{
+		var pattern = $@"\s(?:#|{Regex.Escape(url)}issues/)(?<num>\d+)";
+		return new Regex(pattern, RegexOptions.Multiline | RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture | RegexOptions.Compiled);
+	}
+
+	// Preserves the upstream (Argu/F#) tool's grouping order exactly: within each label bucket, items are
+	// prepended rather than appended, so display order ends up reversed relative to scan order. Kept as-is
+	// rather than "fixed" so existing consumers relying on the current output ordering aren't surprised.
+	private static Dictionary<string, List<GitHubItem>> GroupByLabel(ReleaseNotesConfig config, IReadOnlyList<GitHubItem> items)
+	{
+		var dict = new Dictionary<string, List<GitHubItem>>();
+		foreach (var item in items)
+		{
+			var categorized = false;
+			foreach (var label in config.Labels)
+			{
+				if (item.Labels.Any(l => l.Name == label.Key))
+				{
+					if (dict.TryGetValue(label.Key, out var list))
+						list.Insert(0, item);
+					else
+						dict[label.Key] = [item];
+
+					categorized = true;
+				}
+			}
+
+			if (!categorized)
+			{
+				if (dict.TryGetValue(ReleaseNotesOptions.UncategorizedLabel, out var list))
+				{
+					if (!list.Any(i => i.Number == item.Number))
+						list.Insert(0, item);
+				}
+				else
+					dict[ReleaseNotesOptions.UncategorizedLabel] = [item];
+			}
+		}
+
+		return dict;
+	}
+
+	private static List<GitHubItem> FilterByPullRequests(Regex issueNumberRegex, IReadOnlyList<Issue> issues)
+	{
+		List<int> ExtractRelatedIssues(Issue issue)
+		{
+			if (issue.Body is null) return [];
+
+			var matches = issueNumberRegex.Matches(issue.Body);
+			return matches.Count == 0
+				? []
+				: matches.Where(m => m.Success).Select(m => int.Parse(m.Groups["num"].Value)).ToList();
+		}
+
+		var collectedIssues = new List<GitHubItem>();
+		var items = new List<GitHubItem>();
+
+		foreach (var issue in issues)
+		{
+			if (issue.PullRequest is not null)
+			{
+				var relatedIssues = ExtractRelatedIssues(issue);
+				items.Add(new GitHubItem(issue, relatedIssues));
+			}
+			else
+				collectedIssues.Add(new GitHubItem(issue, []));
+		}
+
+		// Remove all issues that are referenced by pull requests.
+		foreach (var pullRequest in items)
+		foreach (var relatedIssue in pullRequest.RelatedIssues)
+			collectedIssues.RemoveAll(i => i.Issue.Number == relatedIssue);
+
+		// Any remaining issues do not have an associated pull request, so add them.
+		items.AddRange(collectedIssues);
+		return items;
+	}
+
+	public static async Task<Dictionary<string, List<GitHubItem>>> GetClosedIssues(ReleaseNotesConfig config, GitHubClient client, string releasedLabel)
+	{
+		var issueNumberRegex = IssueNumberRegex(config.GitHub.Url);
+		var filter = new RepositoryIssueRequest { State = ItemStateFilter.Closed };
+		filter.Labels.Add(releasedLabel);
+
+		List<GitHubItem> issues;
+		try
+		{
+			var found = await client.Issue.GetAllForRepository(config.GitHub.Owner, config.GitHub.Repository, filter);
+			issues = FilterByPullRequests(issueNumberRegex, found);
+		}
+		catch
+		{
+			issues = [];
+		}
+
+		return GroupByLabel(config, issues);
+	}
+}
diff --git a/src/release-notes/GithubScanner.fs b/src/release-notes/GithubScanner.fs
deleted file mode 100644
index 48c15b8..0000000
--- a/src/release-notes/GithubScanner.fs
+++ /dev/null
@@ -1,84 +0,0 @@
-module ReleaseNotes.GithubScanner
-
-open Octokit
-open System.Collections.Generic
-open System.Linq
-open ReleaseNotes.Arguments
-open System.Text.RegularExpressions
-
-let issueNumberRegex(url: string) =
-    let pattern = sprintf "\s(?:#|%sissues/)(?<num>\d+)" url
-    Regex(pattern, RegexOptions.Multiline ||| RegexOptions.IgnoreCase ||| RegexOptions.CultureInvariant ||| RegexOptions.ExplicitCapture ||| RegexOptions.Compiled)
-
-let private groupByLabel (config:ReleaseNotesConfig) (items: List<GitHubItem>) =
-    let dict = Dictionary<string, GitHubItem list>()     
-    for item in items do
-        let mutable categorized = false
-        // if an item is categorized with multiple config labels, it'll appear multiple times, once under each label
-        for label in config.Labels do
-            if item.Labels.Any(fun l -> l.Name = label.Key) then
-                let exists,list = dict.TryGetValue(label.Key)
-                match exists with 
-                | true -> dict.[label.Key] <- item :: list
-                | false -> dict.Add(label.Key, [item])
-                categorized <- true
-                
-        if categorized = false then
-            let exists,list = dict.TryGetValue(config.UncategorizedLabel)
-            match exists with 
-            | true ->
-                match List.tryFind(fun (i:GitHubItem)-> i.Number = item.Number) list with 
-                | Some _ -> ()
-                | None -> dict.[config.UncategorizedLabel] <- item :: list                         
-            | false -> dict.Add(config.UncategorizedLabel, [item])
-    dict
-    
-let private filterByPullRequests (issueNumberRegex: Regex) (issues:IReadOnlyList<Issue>): List<GitHubItem> =
-    let extractRelatedIssues(issue: Issue) =
-        if (issue.Body = null) then list.Empty
-        else
-            let matches = issueNumberRegex.Matches(issue.Body)
-            if matches.Count = 0 then list.Empty
-            else         
-                matches
-                |> Seq.cast<Match>
-                |> Seq.filter(fun m -> m.Success)
-                |> Seq.map(fun m -> m.Groups.["num"].Value |> int)
-                |> Seq.toList
-    
-    let collectedIssues = List<GitHubItem>()
-    let items = List<GitHubItem>()
-    
-    for issue in issues do
-        if issue.PullRequest <> null then
-            let relatedIssues = extractRelatedIssues issue
-            items.Add(GitHubItem(issue, relatedIssues))
-        else
-            collectedIssues.Add(GitHubItem(issue, list.Empty))
-         
-    // remove all issues that are referenced by pull requests            
-    for pullRequest in items do
-        for relatedIssue in pullRequest.RelatedIssues do
-            collectedIssues.RemoveAll(fun i -> i.Issue.Number = relatedIssue) |> ignore
-            
-    // any remaining issues do not have an associated pull request, so add them
-    items.AddRange(collectedIssues)       
-    items
-    
-let getClosedIssues (config:ReleaseNotesConfig) (client:GitHubClient) releasedLabel =
-    let issueNumberRegex = issueNumberRegex config.GitHub.Url   
-    let filter = RepositoryIssueRequest()
-    filter.Labels.Add releasedLabel
-    filter.State <- ItemStateFilter.Closed
-    
-    let issues =
-        try
-            client.Issue.GetAllForRepository(config.GitHub.Owner, config.GitHub.Repository, filter)
-            |> Async.AwaitTask
-            |> Async.RunSynchronously
-            |> filterByPullRequests issueNumberRegex
-        with _ ->
-           List<GitHubItem>()
-            
-    issues |> groupByLabel config
-
diff --git a/src/release-notes/Labeler.cs b/src/release-notes/Labeler.cs
new file mode 100644
index 0000000..7378531
--- /dev/null
+++ b/src/release-notes/Labeler.cs
@@ -0,0 +1,94 @@
+using NuGet.Versioning;
+using Octokit;
+
+namespace ReleaseNotes;
+
+public static class Labeler
+{
+	public static string ReleaseLabel(string version, string format) => format.Replace("VERSION", version);
+	public static string BackportLabel(string branch, string format) => format.Replace("BRANCH", branch);
+
+	private static async Task Create(ReleaseNotesConfig config, GitHubClient client, string label)
+	{
+		try
+		{
+			await client.Issue.Labels.Get(config.GitHub.Owner, config.GitHub.Repository, label);
+			return;
+		}
+		catch
+		{
+			// Label does not exist yet; fall through and create it.
+		}
+
+		await client.Issue.Labels.Create(config.GitHub.Owner, config.GitHub.Repository, new NewLabel(label, config.LabelColor));
+	}
+
+	private static async Task<Branch?> ExistsBranch(ReleaseNotesConfig config, GitHubClient client, string branch)
+	{
+		try
+		{
+			return await client.Repository.Branch.Get(config.GitHub.Owner, config.GitHub.Repository, branch);
+		}
+		catch
+		{
+			return null;
+		}
+	}
+
+	public static async Task AddNewVersionLabels(ReleaseNotesConfig config, GitHubClient client)
+	{
+		var v = NuGetVersion.Parse(config.Version);
+		var newMajor = $"{v.Major + 1}.0.0";
+		var newMinor = $"{v.Major}.{v.Minor + 1}.0";
+		var newPatch = $"{v.Major}.{v.Minor}.{v.Patch + 1}";
+
+		await Create(config, client, ReleaseLabel(newMajor, config.ReleaseLabelFormat));
+		await Create(config, client, ReleaseLabel(newMinor, config.ReleaseLabelFormat));
+		await Create(config, client, ReleaseLabel(newPatch, config.ReleaseLabelFormat));
+	}
+
+	public static async Task AddBackportLabels(ReleaseNotesConfig config, GitHubClient client)
+	{
+		if (config.BackportLabelFormat is not { } backportLabelFormat)
+		{
+			Console.WriteLine("No backport label format given, skipping creation of backport labels");
+			return;
+		}
+
+		var mainExists = await ExistsBranch(config, client, "main");
+		var masterExists = await ExistsBranch(config, client, "master");
+		switch (mainExists, masterExists)
+		{
+			case (not null, not null):
+				await Create(config, client, BackportLabel("main", backportLabelFormat));
+				await Create(config, client, BackportLabel("master", backportLabelFormat));
+				break;
+			case (not null, null):
+				await Create(config, client, BackportLabel("main", backportLabelFormat));
+				break;
+			case (null, not null):
+				await Create(config, client, BackportLabel("master", backportLabelFormat));
+				break;
+			default:
+				Console.WriteLine("Repository does not have either main or master branch");
+				break;
+		}
+
+		var v = NuGetVersion.Parse(config.Version);
+		string[] backportBranches =
+		[
+			$"{v.Major}.x",
+			$"{v.Major}.{v.Minor}",
+			$"{v.Major + 1}.x",
+			$"{v.Major}.{v.Minor + 1}"
+		];
+
+		foreach (var branch in backportBranches)
+		{
+			if (await ExistsBranch(config, client, branch) is not null)
+				await Create(config, client, BackportLabel(branch, backportLabelFormat));
+			else
+				Console.WriteLine($"branch {branch} does not exist yet so skipping creating a backport label");
+		}
+	}
+}
diff --git a/src/release-notes/Labeler.fs b/src/release-notes/Labeler.fs
deleted file mode 100644
index de0c46c..0000000
--- a/src/release-notes/Labeler.fs
+++ /dev/null
@@ -1,75 +0,0 @@
-module ReleaseNotes.Labeler
-
-open Fake.Core
-open Octokit
-open ReleaseNotes.Arguments
-
-let releaseLabel version (format:string) = format.Replace("VERSION", version)
-let backportLabel version (format:string) = format.Replace("BRANCH", version)
-
-let private create (config:ReleaseNotesConfig) (client:GitHubClient) label =
-    let existing =
-        try
-            Some <|
-                (client.Issue.Labels.Get(config.GitHub.Owner, config.GitHub.Repository, label)
-                |> Async.AwaitTask
-                |> Async.RunSynchronously)
-        with _ -> None
-        
-    match existing with
-    | Some s -> ignore()
-    | None ->
-        client.Issue.Labels.Create(
-            config.GitHub.Owner, config.GitHub.Repository,
-            NewLabel(label, config.LabelColor))
-            |> Async.AwaitTask
-            |> Async.RunSynchronously
-            |> ignore
-
-let private existsBranch (config:ReleaseNotesConfig) (client:GitHubClient) branch =
-    try
-        Some <|
-            (client.Repository.Branch.Get(config.GitHub.Owner, config.GitHub.Repository, branch)
-            |> Async.AwaitTask
-            |> Async.RunSynchronously)
-    with _ -> None
-    
-let addNewVersionLabels (config:ReleaseNotesConfig) (client:GitHubClient) =
-    let v = SemVer.parse config.Version
-    let newMajor = sprintf "%i.0.0" (v.Major+1u)
-    let newMinor = sprintf "%i.%i.0" v.Major (v.Minor+1u)
-    let newPatch = sprintf "%i.%i.%i" v.Major (v.Minor) (v.Patch+1u)
-    
-    create config client <| releaseLabel newMajor config.ReleaseLabelFormat
-    create config client <| releaseLabel newMinor config.ReleaseLabelFormat 
-    create config client <| releaseLabel newPatch config.ReleaseLabelFormat
-    
-let addBackportLabels (config:ReleaseNotesConfig) (client:GitHubClient) =
-    match config.BackportLabelFormat with
-    | None ->
-        printfn "No backport label format given, skipping creation of backport labels"
-    | Some backportLabelFormat ->
-        let mainExists = existsBranch config client "main"
-        let masterExists = existsBranch config client "master"
-        match (mainExists, masterExists) with 
-        | (Some _, Some _)  ->
-            create config client <| backportLabel "main" backportLabelFormat
-            create config client <| backportLabel "master" backportLabelFormat
-        | (Some _, _)  -> create config client <| backportLabel "main" backportLabelFormat
-        | (None, Some _)  -> create config client <| backportLabel "master" backportLabelFormat
-        | _ -> printfn "Repository does not have either main or master branch"
-        
-        let v = SemVer.parse config.Version
-        let backportBranches = [
-            sprintf "%i.x" (v.Major);
-            sprintf "%i.%i" v.Major v.Minor;
-            sprintf "%i.x" (v.Major+1u);
-            sprintf "%i.%i" v.Major (v.Minor+1u);
-        ] 
-        for branch in backportBranches do
-            match existsBranch config client branch with
-            | Some _ -> create config client <| backportLabel branch backportLabelFormat
-            | None -> printfn "branch %s does not exist yet so skipping creating a backport label" branch
-    
-    
-
diff --git a/src/release-notes/OutputWriter.cs b/src/release-notes/OutputWriter.cs
new file mode 100644
index 0000000..99bf008
--- /dev/null
+++ b/src/release-notes/OutputWriter.cs
@@ -0,0 +1,44 @@
+using System.Text;
+
+namespace ReleaseNotes;
+
+public sealed class OutputWriter : IDisposable
+{
+	private readonly TextWriter _stdout = Console.Out;
+	private readonly StringBuilder _sb = new();
+	private readonly string? _output;
+
+	public OutputWriter(string? output)
+	{
+		_output = output;
+		if (output is null) return;
+
+		Console.WriteLine();
+		Console.WriteLine($"Building {output}");
+		Console.WriteLine("-------------------");
+	}
+
+	public void EmptyLine()
+	{
+		_stdout.WriteLine();
+		_sb.AppendLine();
+	}
+
+	public void WriteLine(string s)
+	{
+		_stdout.WriteLine(s);
+		_sb.AppendLine(s);
+	}
+
+	public override string ToString() => _sb.ToString();
+
+	public void Dispose()
+	{
+		if (_output is not null)
+		{
+			var fi = new FileInfo(_output);
+			Directory.CreateDirectory(fi.DirectoryName!);
+			File.WriteAllText(_output, _sb.ToString());
+		}
+	}
+}
diff --git a/src/release-notes/OutputWriter.fs b/src/release-notes/OutputWriter.fs
deleted file mode 100644
index 6ef293b..0000000
--- a/src/release-notes/OutputWriter.fs
+++ /dev/null
@@ -1,33 +0,0 @@
-namespace ReleaseNotes
-
-open System
-open System.IO
-open System.Text
-
-type OutputWriter(output: string option) =
-    let stdout = Console.Out
-    let sb = new StringBuilder()
-    do
-        output |> Option.iter (fun o ->
-            printfn ""
-            printfn "Building %s" o
-            printfn "-------------------"   
-        )
-    
-    member this.EmptyLine () =
-        stdout.WriteLine()
-        sb.AppendLine() |> ignore
-    member this.WriteLine (s:string) =
-        stdout.WriteLine(s)
-        sb.AppendLine(s) |> ignore
-    override this.ToString () = sb.ToString()
-    interface IDisposable with 
-        member __.Dispose() =
-            stdout.Dispose()
-            match output with
-            | None -> ()
-            | Some path ->
-                let fi = FileInfo(path)
-                Directory.CreateDirectory(fi.Directory.FullName) |> ignore
-                File.WriteAllText(path, sb.ToString())
-        
diff --git a/src/release-notes/Program.cs b/src/release-notes/Program.cs
new file mode 100644
index 0000000..2fdb99d
--- /dev/null
+++ b/src/release-notes/Program.cs
@@ -0,0 +1,7 @@
+using Nullean.Argh;
+using ReleaseNotes;
+
+var app = new ArghApp();
+app.Map<ReleaseNotesCommands>();
+
+return await app.RunAsync(args);
diff --git a/src/release-notes/Program.fs b/src/release-notes/Program.fs
deleted file mode 100644
index 4fd3127..0000000
--- a/src/release-notes/Program.fs
+++ /dev/null
@@ -1,482 +0,0 @@
-module ReleaseNotes.Program
-
-open System
-open System.IO
-open System.Text
-open System.Text.RegularExpressions
-open Argu
-open Fake.Core
-open Octokit
-open ReleaseNotes
-open ReleaseNotes.Arguments
-
-let private hasLatestRelease (config: ReleaseNotesConfig) (client: GitHubClient) =
-    try
-        let release =
-            client.Repository.Release.GetLatest(config.GitHub.Owner, config.GitHub.Repository)
-            |> Async.AwaitTask
-            |> Async.RunSynchronously
-        Some release
-     with _ ->
-        None
-
-let private releaseExists (config: ReleaseNotesConfig) (client: GitHubClient) version =
-    let releaseTag = Labeler.releaseLabel version config.ReleaseTagFormat
-
-    let existing =
-        try
-            Some
-            <| (client.Repository.Release.Get(config.GitHub.Owner, config.GitHub.Repository, releaseTag)
-                |> Async.AwaitTask
-                |> Async.RunSynchronously)
-        with _ ->
-            None
-
-    existing
-
-
-let private createRelease (config: ReleaseNotesConfig) (client: GitHubClient) =
-    let files =
-        match config.ReleaseBodyFiles with
-        | None -> []
-        | Some s ->
-            s
-            |> List.map (fun f -> Path.GetFullPath(f))
-            |> List.map (fun f -> (File.Exists(f), f))
-
-    let unknownFiles =
-        files |> List.filter (fun (found, f) -> not found) |> List.map (fun (_, f) -> f)
-
-    if unknownFiles.Length > 0 then
-        failwithf
-            "The following files were not found and can not be read to include in the release body: %A"
-            unknownFiles
-
-    let body =
-        let body =
-            files
-            |> List.fold
-                (fun (state: StringBuilder) (found, f) -> state.AppendLine(File.ReadAllText(f)))
-                (StringBuilder())
-
-        body.ToString()
-
-    match releaseExists config client config.Version with
-    | Some s ->
-        printfn "Found release"
-
-        client.Repository.Release.Edit(config.GitHub.Owner, config.GitHub.Repository, s.Id, ReleaseUpdate(Body = body))
-        |> Async.AwaitTask
-        |> Async.RunSynchronously
-    | None ->
-        client.Repository.Release.Create(
-            config.GitHub.Owner,
-            config.GitHub.Repository,
-            NewRelease(config.Version, Body = body)
-        )
-        |> Async.AwaitTask
-        |> Async.RunSynchronously
-
-
-let private locateOldVersion (config: ReleaseNotesConfig) (client: GitHubClient) =
-    match config.OldVersion with
-    | Some v -> Some v
-    | None ->
-        let semVerVersion = SemVer.parse config.Version
-        
-        match hasLatestRelease config client with
-        | None -> None
-        | Some _ -> 
-            let releases =
-                client.Repository.Release.GetAll(config.GitHub.Owner, config.GitHub.Repository)
-                |> Async.AwaitTask
-                |> Async.RunSynchronously
-
-            let foundOldVersion =
-                releases
-                |> Seq.filter (fun t -> SemVer.isValid t.TagName)
-                |> Seq.map (fun t -> SemVer.parse t.TagName)
-                |> Seq.filter (fun v -> v < semVerVersion)
-                |> Seq.sortByDescending (fun v -> v)
-                |> Seq.tryHead
-
-            match releases.Count, foundOldVersion with
-            | 0, _ -> None
-            | 1, None -> None
-            | _, Some v -> Some(v.ToString())
-            | _ ->
-                None
-
-let private findCurrentAndNextVersion (config: ReleaseNotesConfig) (client: GitHubClient) versionQuery =
-    let releases =
-        client.Repository.Release.GetAll(config.GitHub.Owner, config.GitHub.Repository)
-        |> Async.AwaitTask
-        |> Async.RunSynchronously
-
-    let minVersion =
-        match versionQuery with
-        | "master"
-        | "main" -> SemVer.parse "0.0.1"
-        | query when Regex.IsMatch(query, "\d+\.x") -> SemVer.parse <| query.Replace(".x", ".0") + ".0"
-        | query when Regex.IsMatch(query, "\d+\.\d+") -> SemVer.parse <| query + ".0"
-        | query when Regex.IsMatch(query, "\d+\.\d+.0") -> SemVer.parse <| query
-        | _ -> failwithf "%s is not a valid version query" versionQuery
-
-    let re =
-        let prefix =
-            match config.ReleaseTagFormat.Replace("VERSION", "") with
-            | p when String.IsNullOrWhiteSpace p -> ""
-            | p -> sprintf "(?:%s)" p
-
-        Regex <| sprintf @"^%s(\d+\.\d+\.\d+(?:-\w+)?)$" prefix
-
-    let foundOldVersion =
-        releases
-        |> Seq.choose (fun t ->
-            match re.Match(t.TagName).Groups |> Seq.toList with
-            | [ _; capture ] -> Some capture.Value
-            | _ -> None)
-        |> Seq.filter (SemVer.isValid)
-        |> Seq.map (SemVer.parse)
-        |> Seq.filter (fun v ->
-            match versionQuery with
-            | "master"
-            | "main" -> true
-            | query when Regex.IsMatch(query, "\d+\.x") -> v.Major = minVersion.Major
-            | query when Regex.IsMatch(query, "\d+\.\d+") -> v.Major = minVersion.Major && v.Minor = minVersion.Minor
-            | query when Regex.IsMatch(query, "\d+\.\d+.0") -> v.Major = minVersion.Major && v.Minor = minVersion.Minor
-            | _ -> false)
-        |> Seq.sortByDescending (fun v -> v)
-        |> Seq.tryHead
-
-    let v = foundOldVersion |> Option.defaultValue minVersion
-
-    match versionQuery with
-    | "master"
-    | "main" ->
-        let nextVersion = SemVer.parse <| sprintf "%i.0.0" (v.Major + 1u)
-        Some <| (v, nextVersion)
-    | query when Regex.IsMatch(query, "\d+\.x") ->
-        let nextVersion = SemVer.parse <| sprintf "%i.%i.0" v.Major (v.Minor + 1u)
-        Some <| (v, nextVersion)
-
-    | query when Regex.IsMatch(query, "^\d+\.\d+.0$") || Regex.IsMatch(query, "^\d+\.\d+$") ->
-        let nextVersion =
-            let bumped = SemVer.parse <| sprintf "%i.%i.%i" v.Major v.Minor (v.Patch + 1u)
-
-            match releaseExists config client (v.ToString()) with
-            | Some _ -> bumped
-            | None -> v
-
-        Some <| (v, nextVersion)
-    | _ -> failwithf "%s is not a valid version query" versionQuery
-
-let private writeMarkDownReleaseNotes (config: ReleaseNotesConfig) (client: GitHubClient) oldVersion =
-    let gitHub = config.GitHub
-    use writer = new OutputWriter(config.Output)
-    //oldVersion can be none if the repository has never had a release
-    oldVersion
-    |> Option.iter (fun oldVersion ->
-        writer.WriteLine(sprintf "%scompare/%s...%s" gitHub.Url oldVersion config.Version)
-        writer.EmptyLine())
-
-    let releasedLabel = Labeler.releaseLabel config.Version config.ReleaseLabelFormat
-    let closedIssues = GithubScanner.getClosedIssues config client releasedLabel
-
-    for closedIssue in closedIssues do
-        config.Labels.[closedIssue.Key] |> sprintf "## %s" |> writer.WriteLine
-        writer.EmptyLine()
-
-        for issue in closedIssue.Value do
-            sprintf "- %s" issue.Title |> writer.WriteLine
-
-        writer.EmptyLine()
-
-    sprintf
-        "### [View the full list of issues and PRs](%sissues?utf8=%%E2%%9C%%93&q=label%%3A%s)"
-        config.GitHub.Url
-        releasedLabel
-    |> writer.WriteLine
-
-    writer.ToString()
-
-let private writeAsciiDocReleaseNotes (config: ReleaseNotesConfig) (client: GitHubClient) oldVersion =
-
-
-    config.Output
-    |> Option.iter (fun output ->
-        let d = Directory.CreateDirectory(output)
-        let path f = FileInfo <| Path.Combine(d.FullName, f)
-        let cv = SemVer.parse config.Version
-
-        let releaseNotes = path "release-notes.asciidoc"
-
-        let generatedNotes = path <| sprintf "release-notes-%O-generated.asciidoc" cv
-        let humanNotes = path <| sprintf "release-notes-%O-human.asciidoc" cv
-
-        let writeHuman () =
-            use writer = new OutputWriter(Some humanNotes.FullName)
-            writer.WriteLine <| sprintf ""
-
-        let writeGenerated () =
-            use writer = new OutputWriter(Some generatedNotes.FullName)
-            writer.WriteLine <| sprintf ""
-            let releasedLabel = Labeler.releaseLabel config.Version config.ReleaseLabelFormat
-
-            let groupedClosedIssues =
-                GithubScanner.getClosedIssues config client releasedLabel
-                |> Seq.sortBy (fun kv ->
-                    if kv.Key = config.UncategorizedLabel then
-                        -1
-                    else
-                        kv.Key.Length)
-
-            for kv in groupedClosedIssues do
-                let header = kv.Key.ToLowerInvariant().Replace(" ", "-")
-                let value = config.Labels.[kv.Key]
-
-                sprintf
-                    @"[float]
-[[%s]]
-=== %s"
-                    header
-                    value
-                |> writer.WriteLine
-
-                writer.EmptyLine()
-
-                for issue in kv.Value do
-                    sprintf "- %s" (issue.TitleAsciiDoc config.GitHub.Url) |> writer.WriteLine
-
-                writer.EmptyLine()
-
-            writer.WriteLine ""
-
-        if not humanNotes.Exists then
-            writeHuman ()
-
-        writeGenerated ()
-
-        let versionNotes = path <| sprintf "release-notes-%O.asciidoc" cv
-
-        let writeVersioned () =
-            use writer = new OutputWriter(Some versionNotes.FullName)
-
-            writer.WriteLine
-            <| sprintf
-                """[float]
-[[release-notes-%O]]
-== Release-Notes %O
-
-include::%s[]
-include::%s[]
-
-"""
-                cv
-                cv
-                humanNotes.Name
-                generatedNotes.Name
-
-        writeVersioned ()
-
-        //write release notes landing page
-
-        let currentPatchReleases =
-            seq { 0 .. Convert.ToInt32(cv.Patch) }
-            |> Seq.rev
-            |> Seq.map (fun patch -> SemVer.parse <| sprintf "%i.%i.%i" cv.Major cv.Minor patch)
-            |> Seq.toList
-
-        use writer = new OutputWriter(Some releaseNotes.FullName)
-
-        writer.WriteLine
-        <| sprintf
-            @"[[release-notes]]
-= Release notes
-
-[partintro]
---
-Review important information about %i.%i.x releases.
-
-* <<release-notes-%O>>
---
-"
-            cv.Major
-            cv.Minor
-            cv
-
-        currentPatchReleases
-        |> List.iter (fun (v: SemVerInfo) ->
-            let fileName = sprintf "release-notes-%O.asciidoc" v
-            let versionReleaseNotes = path fileName
-
-            if versionReleaseNotes.Exists then
-                writer.WriteLine <| sprintf "\n\ninclude::%s[]\n\n" fileName
-            else
-                match releaseExists config client (v.ToString()) with
-                | Some r ->
-                    writer.WriteLine
-                    <| sprintf
-                        """[float]
-[[release-notes-%O]]
-== Release-Notes %O
-%s[Available on github]
-
-"""
-                        v
-                        v
-                        r.HtmlUrl
-                | None ->
-                    writer.WriteLine
-                    <| sprintf
-                        """[float]
-[[release-notes-%O]]
-== Release-Notes %O
-No release notes available
-
-"""
-                        v
-                        v
-
-
-        ))
-
-    ignore ()
-
-
-let private writeReleaseNotes (config: ReleaseNotesConfig) (client: GitHubClient) oldVersion =
-    match config.Format with
-    | Markdown -> writeMarkDownReleaseNotes config client oldVersion |> ignore
-    | AsciiDoc -> writeAsciiDocReleaseNotes config client oldVersion
-
-let run (config: ReleaseNotesConfig) =
-    let client = GitHubClient(ProductHeaderValue("ReleaseNotesGenerator"))
-
-    client.Credentials <-
-        match config.Token with
-        | Some token -> Credentials(token)
-        | None -> Credentials.Anonymous
-
-    try
-        match (config.OldVersionOnly, config.GenerateReleaseOnGithub, config.ApplyLabels, config.VersionQuery) with
-        | (true, _, _, _) ->
-            let oldVersion = locateOldVersion config client
-            printfn "%s" (oldVersion |> Option.defaultValue "")
-        | (_, true, _, _) ->
-            let oldVersion = locateOldVersion config client
-            let release = createRelease config client
-            Labeler.addNewVersionLabels config client
-            writeReleaseNotes config client oldVersion |> ignore
-        | (_, _, true, _) ->
-            Labeler.addNewVersionLabels config client
-            Labeler.addBackportLabels config client
-        | (false, false, false, Some versionQuery) ->
-            match findCurrentAndNextVersion config client versionQuery with
-            | Some (current, next) ->
-                printfn "%O" current
-                printfn "%O" next
-            | _ -> printfn "%O" config.Version
-        | (false, false, false, None) ->
-            let oldVersion = locateOldVersion config client
-            writeReleaseNotes config client oldVersion |> ignore
-
-        0
-    with ex ->
-        Console.Error.Write ex
-        1
-
-[<EntryPoint>]
-let main argv =
-
-    let parser = ArgumentParser.Create<Arguments>(programName = "release-notes")
-
-    let parsed =
-        try
-            Some <| parser.ParseCommandLine(inputs = argv, raiseOnUsage = true)
-        with e ->
-            printfn "%s" e.Message
-            None
-
-    match parsed with
-    | None -> 2
-    | Some p ->
-        try
-            let token = p.TryGetResult Token
-            let (owner, repos) = p.GetResult Repository
-            let version = p.GetResult Version
-            let oldVersion = p.TryGetResult OldVersion
-
-            let format = p.TryGetResult Format |> Option.defaultValue Markdown
-
-            let uncategorizedLabel = "Uncategorized"
-
-            let uncategorizedHeader =
-                p.TryGetResult UncategorizedHeader |> Option.defaultValue uncategorizedLabel
-
-            let oldVersionOnly =
-                match p.TryGetSubCommand() with
-                | Some FindPreviousVersion -> true
-                | _ -> false
-
-            let generateRelease =
-                match p.TryGetSubCommand() with
-                | Some (CreateRelease _) -> true
-                | _ -> false
-
-            let applyLabels =
-                match p.TryGetSubCommand() with
-                | Some ApplyLabels -> true
-                | _ -> false
-
-            let versionQuery =
-                match p.TryGetSubCommand() with
-                | Some (CurrentVersion v) -> Some <| v.GetResult Query
-                | _ -> None
-
-            let labels =
-                let labels =
-                    match p.GetResults Label with
-                    | [] ->
-                        [
-                            ("bug", "Bug Fixes")
-                            ("enhancement", "New Features")
-                            ("documentation", "Documentation Improvements")
-                        ]
-                    | filled -> filled
-
-                [ (uncategorizedLabel, uncategorizedHeader) ] @ labels |> Map.ofList
-
-            let bodyFilePaths =
-                match p.TryGetSubCommand() with
-                | Some (CreateRelease a) -> Some <| a.GetResults BodyFilePath
-                | _ -> None
-
-            let config =
-                {
-                    GitHub = GitHubRepository(owner, repos)
-                    Labels = labels
-                    ApplyLabels = applyLabels
-                    Token = token
-                    Version = version
-                    OldVersion = oldVersion
-                    ReleaseTagFormat = p.TryGetResult ReleaseTagFormat |> Option.defaultValue "VERSION"
-                    ReleaseLabelFormat = p.TryGetResult ReleaseLabelFormat |> Option.defaultValue "vVERSION"
-                    BackportLabelFormat = p.TryGetResult BackportLabelFormat
-                    UncategorizedLabel = uncategorizedLabel
-                    UncategorizedHeader = uncategorizedHeader
-                    Output = p.TryGetResult Output
-                    // TODO parameter
-                    LabelColor = "e3e3e3"
-                    OldVersionOnly = oldVersionOnly
-                    GenerateReleaseOnGithub = generateRelease
-                    ReleaseBodyFiles = bodyFilePaths
-                    VersionQuery = versionQuery
-                    Format = format
-                }
-
-            run config
-        with e ->
-            Console.ForegroundColor <- ConsoleColor.Red
-            eprintfn "%s" e.Message
-            Console.ResetColor()
-            1
diff --git a/src/release-notes/ReleaseNotesCommands.cs b/src/release-notes/ReleaseNotesCommands.cs
new file mode 100644
index 0000000..00b4370
--- /dev/null
+++ b/src/release-notes/ReleaseNotesCommands.cs
@@ -0,0 +1,77 @@
+using Nullean.Argh;
+
+namespace ReleaseNotes;
+
+internal sealed class ReleaseNotesCommands
+{
+	private static ReleaseNotesConfig BuildConfig(
+		string owner, string repositoryName, ReleaseNotesOptions opts,
+		bool applyLabels = false, bool generateReleaseOnGithub = false, bool oldVersionOnly = false,
+		string? versionQuery = null, IReadOnlyList<string>? releaseBodyFiles = null) =>
+		new()
+		{
+			GitHub = new GitHubRepository(owner, repositoryName),
+			Labels = opts.ToLabelMap(),
+			ApplyLabels = applyLabels,
+			Token = opts.Token,
+			Version = opts.Version,
+			OldVersion = opts.OldVersion,
+			ReleaseTagFormat = opts.ReleaseTagFormat,
+			ReleaseLabelFormat = opts.ReleaseLabelFormat,
+			BackportLabelFormat = opts.BackportLabelFormat,
+			UncategorizedLabel = ReleaseNotesOptions.UncategorizedLabel,
+			UncategorizedHeader = opts.UncategorizedHeader ?? ReleaseNotesOptions.UncategorizedLabel,
+			Output = opts.Output,
+			OldVersionOnly = oldVersionOnly,
+			LabelColor = "e3e3e3",
+			GenerateReleaseOnGithub = generateReleaseOnGithub,
+			ReleaseBodyFiles = releaseBodyFiles,
+			VersionQuery = versionQuery,
+			Format = opts.Format
+		};
+
+	/// <summary>
+	/// Generates release notes for <paramref name="version"/> from closed GitHub issues and PRs, printed to
+	/// standard out and optionally written to a file.
+	/// </summary>
+	/// <param name="owner">GitHub repository owner.</param>
+	/// <param name="repositoryName">GitHub repository name.</param>
+	public async Task<int> Generate([Argument] string owner, [Argument] string repositoryName, [AsParameters] ReleaseNotesOptions opts) =>
+		await ReleaseNotesRunner.Run(BuildConfig(owner, repositoryName, opts));
+
+	/// <summary>Creates the version and backport labels for the next release.</summary>
+	/// <param name="owner">GitHub repository owner.</param>
+	/// <param name="repositoryName">GitHub repository name.</param>
+	[CommandName("apply-labels")]
+	public async Task<int> ApplyLabels([Argument] string owner, [Argument] string repositoryName, [AsParameters] ReleaseNotesOptions opts) =>
+		await ReleaseNotesRunner.Run(BuildConfig(owner, repositoryName, opts, applyLabels: true));
+
+	/// <summary>Finds and prints the previous release for the given version.</summary>
+	/// <param name="owner">GitHub repository owner.</param>
+	/// <param name="repositoryName">GitHub repository name.</param>
+	[CommandName("find-previous")]
+	public async Task<int> FindPrevious([Argument] string owner, [Argument] string repositoryName, [AsParameters] ReleaseNotesOptions opts) =>
+		await ReleaseNotesRunner.Run(BuildConfig(owner, repositoryName, opts, oldVersionOnly: true));
+
+	/// <summary>Given a search query, finds the current and the next versions and prints them on separate lines.</summary>
+	/// <param name="owner">GitHub repository owner.</param>
+	/// <param name="repositoryName">GitHub repository name.</param>
+	/// <param name="query">--query, An anchor query: M.N, M.x, or master/main. Finds the current and next patch, minor, or major release respectively.</param>
+	[CommandName("current-version")]
+	public async Task<int> CurrentVersion([Argument] string owner, [Argument] string repositoryName, [AsParameters] ReleaseNotesOptions opts, string query) =>
+		await ReleaseNotesRunner.Run(BuildConfig(owner, repositoryName, opts, versionQuery: query));
+
+	/// <summary>
+	/// Makes sure the tag exists as a release on GitHub, and introduces new version labels for the next
+	/// major/minor/patch.
+	/// </summary>
+	/// <param name="owner">GitHub repository owner.</param>
+	/// <param name="repositoryName">GitHub repository name.</param>
+	/// <param name="body">
+	/// --body, Path to a file that will be read and used for the body of the release. May be given more than
+	/// once to combine multiple files.
+	/// </param>
+	[CommandName("create-release")]
+	public async Task<int> CreateRelease([Argument] string owner, [Argument] string repositoryName, [AsParameters] ReleaseNotesOptions opts, List<string>? body = null) =>
+		await ReleaseNotesRunner.Run(BuildConfig(owner, repositoryName, opts, generateReleaseOnGithub: true, releaseBodyFiles: body));
+}
diff --git a/src/release-notes/ReleaseNotesConfig.cs b/src/release-notes/ReleaseNotesConfig.cs
new file mode 100644
index 0000000..05df803
--- /dev/null
+++ b/src/release-notes/ReleaseNotesConfig.cs
@@ -0,0 +1,36 @@
+namespace ReleaseNotes;
+
+public enum Format
+{
+	Markdown,
+	AsciiDoc
+}
+
+public sealed class GitHubRepository(string owner, string repository)
+{
+	public string Owner { get; } = owner;
+	public string Repository { get; } = repository;
+	public string Url => $"https://github.com/{Owner}/{Repository}/";
+}
+
+public sealed class ReleaseNotesConfig
+{
+	public required GitHubRepository GitHub { get; init; }
+	public required IReadOnlyDictionary<string, string> Labels { get; init; }
+	public bool ApplyLabels { get; init; }
+	public string? Token { get; init; }
+	public required string Version { get; init; }
+	public string? OldVersion { get; init; }
+	public required string ReleaseTagFormat { get; init; }
+	public required string ReleaseLabelFormat { get; init; }
+	public string? BackportLabelFormat { get; init; }
+	public required string UncategorizedLabel { get; init; }
+	public required string UncategorizedHeader { get; init; }
+	public string? Output { get; init; }
+	public bool OldVersionOnly { get; init; }
+	public required string LabelColor { get; init; }
+	public bool GenerateReleaseOnGithub { get; init; }
+	public IReadOnlyList<string>? ReleaseBodyFiles { get; init; }
+	public string? VersionQuery { get; init; }
+	public required Format Format { get; init; }
+}
diff --git a/src/release-notes/ReleaseNotesOptions.cs b/src/release-notes/ReleaseNotesOptions.cs
new file mode 100644
index 0000000..d77f385
--- /dev/null
+++ b/src/release-notes/ReleaseNotesOptions.cs
@@ -0,0 +1,64 @@
+namespace ReleaseNotes;
+
+/// <summary>
+/// Flags shared by every <see cref="ReleaseNotesCommands"/> command, expanded with <c>[AsParameters]</c>
+/// so they don't need repeating on each method signature.
+/// </summary>
+/// <param name="Version">Version that is being released.</param>
+/// <param name="Token">The GitHub token to use. If the issue list is long this may be necessary; defaults to anonymous.</param>
+/// <param name="OldVersion">The previous version to generate release notes since. Optional; the tool will find the previous release.</param>
+/// <param name="ReleaseTagFormat">The release tag format. VERSION is replaced by the actual version.</param>
+/// <param name="ReleaseLabelFormat">The release label format. VERSION is replaced by the actual version.</param>
+/// <param name="BackportLabelFormat">The backport label format, e.g. "Backport BRANCH". BRANCH is calculated from the version.</param>
+/// <param name="Format">The format in which to print the results: Markdown or AsciiDoc.</param>
+/// <param name="UncategorizedHeader">The header to use in the markdown for uncategorized issues/PRs.</param>
+/// <param name="Label">
+/// Map a GitHub label to a categorization heading, formatted as &lt;label&gt;=&lt;description&gt;. May be given
+/// more than once. Defaults to bug=Bug Fixes, enhancement=New Features, documentation=Documentation Improvements.
+/// </param>
+/// <param name="Output">Write the release notes to a file as well as standard out. VERSION is replaced by the actual version.</param>
+public sealed record ReleaseNotesOptions(
+	string Version,
+	string? Token = null,
+	string? OldVersion = null,
+	string ReleaseTagFormat = "VERSION",
+	string ReleaseLabelFormat = "vVERSION",
+	string? BackportLabelFormat = null,
+	Format Format = Format.Markdown,
+	string? UncategorizedHeader = null,
+	List<string>? Label = null,
+	string? Output = null)
+{
+	public const string UncategorizedLabel = "Uncategorized";
+
+	/// <summary>
+	/// Parses <see cref="Label"/> (each entry formatted as <c>label=description</c>) into a lookup from GitHub
+	/// label to its categorization heading, defaulting to bug/enhancement/documentation when none were given.
+	/// </summary>
+	public IReadOnlyDictionary<string, string> ToLabelMap()
+	{
+		var entries = Label is { Count: > 0 }
+			? Label.Select(ParseLabel)
+			:
+			[
+				("bug", "Bug Fixes"),
+				("enhancement", "New Features"),
+				("documentation", "Documentation Improvements")
+			];
+
+		var map = new Dictionary<string, string> { [UncategorizedLabel] = UncategorizedHeader ?? UncategorizedLabel };
+		foreach (var (label, description) in entries)
+			map[label] = description;
+
+		return map;
+	}
+
+	private static (string Label, string Description) ParseLabel(string entry)
+	{
+		var separatorIndex = entry.IndexOf('=');
+		if (separatorIndex < 0)
+			throw new ArgumentException($"--label '{entry}' is not in the expected <label>=<description> format");
+
+		return (entry[..separatorIndex], entry[(separatorIndex + 1)..]);
+	}
+}
diff --git a/src/release-notes/ReleaseNotesRunner.cs b/src/release-notes/ReleaseNotesRunner.cs
new file mode 100644
index 0000000..2412389
--- /dev/null
+++ b/src/release-notes/ReleaseNotesRunner.cs
@@ -0,0 +1,338 @@
+using System.Text;
+using System.Text.RegularExpressions;
+using NuGet.Versioning;
+using Octokit;
+
+namespace ReleaseNotes;
+
+public static class ReleaseNotesRunner
+{
+	private static async Task<Release?> HasLatestRelease(ReleaseNotesConfig config, GitHubClient client)
+	{
+		try
+		{
+			return await client.Repository.Release.GetLatest(config.GitHub.Owner, config.GitHub.Repository);
+		}
+		catch
+		{
+			return null;
+		}
+	}
+
+	private static async Task<Release?> ReleaseExists(ReleaseNotesConfig config, GitHubClient client, string version)
+	{
+		var releaseTag = Labeler.ReleaseLabel(version, config.ReleaseTagFormat);
+		try
+		{
+			return await client.Repository.Release.Get(config.GitHub.Owner, config.GitHub.Repository, releaseTag);
+		}
+		catch
+		{
+			return null;
+		}
+	}
+
+	private static async Task CreateRelease(ReleaseNotesConfig config, GitHubClient client)
+	{
+		var files = config.ReleaseBodyFiles?.Select(Path.GetFullPath).ToList() ?? [];
+		var unknownFiles = files.Where(f => !File.Exists(f)).ToList();
+		if (unknownFiles.Count > 0)
+			throw new InvalidOperationException(
+				$"The following files were not found and can not be read to include in the release body: {string.Join(", ", unknownFiles)}");
+
+		var body = new StringBuilder();
+		foreach (var f in files)
+			body.AppendLine(await File.ReadAllTextAsync(f));
+
+		var existing = await ReleaseExists(config, client, config.Version);
+		if (existing is not null)
+		{
+			Console.WriteLine("Found release");
+			await client.Repository.Release.Edit(config.GitHub.Owner, config.GitHub.Repository, existing.Id, new ReleaseUpdate { Body = body.ToString() });
+		}
+		else
+			await client.Repository.Release.Create(config.GitHub.Owner, config.GitHub.Repository, new NewRelease(config.Version) { Body = body.ToString() });
+	}
+
+	private static async Task<string?> LocateOldVersion(ReleaseNotesConfig config, GitHubClient client)
+	{
+		if (config.OldVersion is not null) return config.OldVersion;
+
+		var semVerVersion = NuGetVersion.Parse(config.Version);
+		if (await HasLatestRelease(config, client) is null) return null;
+
+		var releases = await client.Repository.Release.GetAll(config.GitHub.Owner, config.GitHub.Repository);
+
+		var foundOldVersion = releases
+			.Where(r => NuGetVersion.TryParse(r.TagName, out _))
+			.Select(r => NuGetVersion.Parse(r.TagName))
+			.Where(v => v < semVerVersion)
+			.OrderByDescending(v => v)
+			.FirstOrDefault();
+
+		return releases.Count switch
+		{
+			0 => null,
+			1 when foundOldVersion is null => null,
+			_ => foundOldVersion?.ToString()
+		};
+	}
+
+	private static async Task<(NuGetVersion Current, NuGetVersion Next)?> FindCurrentAndNextVersion(ReleaseNotesConfig config, GitHubClient client, string versionQuery)
+	{
+		var releases = await client.Repository.Release.GetAll(config.GitHub.Owner, config.GitHub.Repository);
+
+		var minVersion = versionQuery switch
+		{
+			"master" or "main" => NuGetVersion.Parse("0.0.1"),
+			var q when Regex.IsMatch(q, @"\d+\.x") => NuGetVersion.Parse(q.Replace(".x", ".0")),
+			var q when Regex.IsMatch(q, @"\d+\.\d+") => NuGetVersion.Parse(q + ".0"),
+			_ => throw new InvalidOperationException($"{versionQuery} is not a valid version query")
+		};
+
+		var prefix = config.ReleaseTagFormat.Replace("VERSION", "");
+		var prefixPattern = string.IsNullOrWhiteSpace(prefix) ? "" : $"(?:{Regex.Escape(prefix)})";
+		var re = new Regex($@"^{prefixPattern}(\d+\.\d+\.\d+(?:-\w+)?)$");
+
+		bool MatchesQuery(NuGetVersion v) => versionQuery switch
+		{
+			"master" or "main" => true,
+			var q when Regex.IsMatch(q, @"\d+\.x") => v.Major == minVersion.Major,
+			var q when Regex.IsMatch(q, @"\d+\.\d+") => v.Major == minVersion.Major && v.Minor == minVersion.Minor,
+			_ => false
+		};
+
+		var foundOldVersion = releases
+			.Select(r => re.Match(r.TagName))
+			.Where(m => m.Success)
+			.Select(m => m.Groups[1].Value)
+			.Where(v => NuGetVersion.TryParse(v, out _))
+			.Select(NuGetVersion.Parse)
+			.Where(MatchesQuery)
+			.OrderByDescending(v => v)
+			.FirstOrDefault();
+
+		var v = foundOldVersion ?? minVersion;
+
+		switch (versionQuery)
+		{
+			case "master" or "main":
+				return (v, NuGetVersion.Parse($"{v.Major + 1}.0.0"));
+			case var q when Regex.IsMatch(q, @"\d+\.x"):
+				return (v, NuGetVersion.Parse($"{v.Major}.{v.Minor + 1}.0"));
+			case var q when Regex.IsMatch(q, @"^\d+\.\d+\.0$") || Regex.IsMatch(q, @"^\d+\.\d+$"):
+				var bumped = NuGetVersion.Parse($"{v.Major}.{v.Minor}.{v.Patch + 1}");
+				var next = await ReleaseExists(config, client, v.ToString()) is not null ? bumped : v;
+				return (v, next);
+			default:
+				throw new InvalidOperationException($"{versionQuery} is not a valid version query");
+		}
+	}
+
+	private static async Task<string> WriteMarkDownReleaseNotes(ReleaseNotesConfig config, GitHubClient client, string? oldVersion)
+	{
+		var gitHub = config.GitHub;
+		using var writer = new OutputWriter(config.Output);
+
+		// oldVersion can be null if the repository has never had a release.
+		if (oldVersion is not null)
+		{
+			writer.WriteLine($"{gitHub.Url}compare/{oldVersion}...{config.Version}");
+			writer.EmptyLine();
+		}
+
+		var releasedLabel = Labeler.ReleaseLabel(config.Version, config.ReleaseLabelFormat);
+		var closedIssues = await GithubScanner.GetClosedIssues(config, client, releasedLabel);
+
+		foreach (var (label, issues) in closedIssues)
+		{
+			writer.WriteLine($"## {config.Labels[label]}");
+			writer.EmptyLine();
+
+			foreach (var issue in issues)
+				writer.WriteLine($"- {issue.Title}");
+
+			writer.EmptyLine();
+		}
+
+		writer.WriteLine($"### [View the full list of issues and PRs]({config.GitHub.Url}issues?utf8=%E2%9C%93&q=label%3A{releasedLabel})");
+
+		return writer.ToString();
+	}
+
+	private static async Task WriteAsciiDocReleaseNotes(ReleaseNotesConfig config, GitHubClient client, string? oldVersion)
+	{
+		_ = oldVersion;
+		if (config.Output is null) return;
+
+		var d = Directory.CreateDirectory(config.Output);
+		FileInfo Path_(string f) => new(Path.Combine(d.FullName, f));
+
+		var cv = NuGetVersion.Parse(config.Version);
+		var releaseNotes = Path_("release-notes.asciidoc");
+		var generatedNotes = Path_($"release-notes-{cv}-generated.asciidoc");
+		var humanNotes = Path_($"release-notes-{cv}-human.asciidoc");
+
+		void WriteHuman()
+		{
+			using var writer = new OutputWriter(humanNotes.FullName);
+			writer.WriteLine("");
+		}
+
+		async Task WriteGenerated()
+		{
+			using var writer = new OutputWriter(generatedNotes.FullName);
+			writer.WriteLine("");
+			var releasedLabel = Labeler.ReleaseLabel(config.Version, config.ReleaseLabelFormat);
+
+			var groupedClosedIssues = (await GithubScanner.GetClosedIssues(config, client, releasedLabel))
+				.OrderBy(kv => kv.Key == ReleaseNotesOptions.UncategorizedLabel ? -1 : kv.Key.Length);
+
+			foreach (var (key, issues) in groupedClosedIssues)
+			{
+				var header = key.ToLowerInvariant().Replace(" ", "-");
+				var value = config.Labels[key];
+
+				writer.WriteLine($"[float]\n[[{header}]]\n=== {value}");
+				writer.EmptyLine();
+
+				foreach (var issue in issues)
+					writer.WriteLine(issue.TitleAsciiDoc(config.GitHub.Url));
+
+				writer.EmptyLine();
+			}
+
+			writer.WriteLine("");
+		}
+
+		if (!humanNotes.Exists)
+			WriteHuman();
+
+		await WriteGenerated();
+
+		var versionNotes = Path_($"release-notes-{cv}.asciidoc");
+
+		void WriteVersioned()
+		{
+			using var writer = new OutputWriter(versionNotes.FullName);
+			writer.WriteLine($"""
+				[float]
+				[[release-notes-{cv}]]
+				== Release-Notes {cv}
+
+				include::{humanNotes.Name}[]
+				include::{generatedNotes.Name}[]
+
+				""");
+		}
+
+		WriteVersioned();
+
+		// Write release notes landing page.
+		var currentPatchReleases = Enumerable.Range(0, (int)cv.Patch + 1)
+			.Reverse()
+			.Select(patch => NuGetVersion.Parse($"{cv.Major}.{cv.Minor}.{patch}"))
+			.ToList();
+
+		using var indexWriter = new OutputWriter(releaseNotes.FullName);
+		indexWriter.WriteLine($"""
+			[[release-notes]]
+			= Release notes
+
+			[partintro]
+			--
+			Review important information about {cv.Major}.{cv.Minor}.x releases.
+
+			* <<release-notes-{cv}>>
+			--
+
+			""");
+
+		foreach (var v in currentPatchReleases)
+		{
+			var fileName = $"release-notes-{v}.asciidoc";
+			var versionReleaseNotes = Path_(fileName);
+
+			if (versionReleaseNotes.Exists)
+				indexWriter.WriteLine($"\n\ninclude::{fileName}[]\n\n");
+			else
+			{
+				var r = await ReleaseExists(config, client, v.ToString());
+				indexWriter.WriteLine(r is not null
+					? $"""
+						[float]
+						[[release-notes-{v}]]
+						== Release-Notes {v}
+						{r.HtmlUrl}[Available on github]
+
+						"""
+					: $"""
+						[float]
+						[[release-notes-{v}]]
+						== Release-Notes {v}
+						No release notes available
+
+						""");
+			}
+		}
+	}
+
+	private static async Task WriteReleaseNotes(ReleaseNotesConfig config, GitHubClient client, string? oldVersion)
+	{
+		if (config.Format == Format.Markdown)
+			await WriteMarkDownReleaseNotes(config, client, oldVersion);
+		else
+			await WriteAsciiDocReleaseNotes(config, client, oldVersion);
+	}
+
+	public static async Task<int> Run(ReleaseNotesConfig config)
+	{
+		var client = new GitHubClient(new ProductHeaderValue("ReleaseNotesGenerator"))
+		{
+			Credentials = config.Token is { } token ? new Credentials(token) : Credentials.Anonymous
+		};
+
+		try
+		{
+			if (config.OldVersionOnly)
+			{
+				var oldVersion = await LocateOldVersion(config, client);
+				Console.WriteLine(oldVersion ?? "");
+			}
+			else if (config.GenerateReleaseOnGithub)
+			{
+				var oldVersion = await LocateOldVersion(config, client);
+				await CreateRelease(config, client);
+				await Labeler.AddNewVersionLabels(config, client);
+				await WriteReleaseNotes(config, client, oldVersion);
+			}
+			else if (config.ApplyLabels)
+			{
+				await Labeler.AddNewVersionLabels(config, client);
+				await Labeler.AddBackportLabels(config, client);
+			}
+			else if (config.VersionQuery is { } versionQuery)
+			{
+				if (await FindCurrentAndNextVersion(config, client, versionQuery) is { } found)
+				{
+					Console.WriteLine(found.Current);
+					Console.WriteLine(found.Next);
+				}
+				else
+					Console.WriteLine(config.Version);
+			}
+			else
+			{
+				var oldVersion = await LocateOldVersion(config, client);
+				await WriteReleaseNotes(config, client, oldVersion);
+			}
+
+			return 0;
+		}
+		catch (Exception ex)
+		{
+			Console.Error.WriteLine(ex);
+			return 1;
+		}
+	}
+}
diff --git a/src/release-notes/release-notes.csproj b/src/release-notes/release-notes.csproj
new file mode 100644
index 0000000..16866e8
--- /dev/null
+++ b/src/release-notes/release-notes.csproj
@@ -0,0 +1,56 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
+    <AssemblyName>release-notes</AssemblyName>
+    <RootNamespace>ReleaseNotes</RootNamespace>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <PackAsTool>true</PackAsTool>
+    <ToolCommandName>release-notes</ToolCommandName>
+    <RollForward>Major</RollForward>
+
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>$(MSBuildThisFileDirectory)..\..\build\keys\keypair.snk</AssemblyOriginatorKeyFile>
+
+    <PackageIcon>nuget-icon.png</PackageIcon>
+    <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    <RepositoryUrl>https://github.com/nullean/release-notes</RepositoryUrl>
+    <PackageProjectUrl>https://github.com/nullean/release-notes</PackageProjectUrl>
+    <PackageReleaseNotes>https://github.com/nullean/release-notes/releases</PackageReleaseNotes>
+
+    <Title>release-notes: a dotnet tool to generate release notes from GitHub</Title>
+    <Description>Generate release notes from closed github issues and PR's through the power of version labels</Description>
+
+    <!-- Native-AOT tool packaging: one package per RID plus an 'any' framework-dependent fallback.
+         The root package's DotnetToolSettings.xml (v2) maps each RID to its per-RID package.
+         Installing requires the .NET 10 SDK or greater. -->
+    <RuntimeIdentifiers>linux-x64;linux-arm64;win-x64;win-arm64;osx-arm64;any</RuntimeIdentifiers>
+  </PropertyGroup>
+
+  <!-- AOT settings apply only when a specific RID is targeted (dotnet pack -r <rid>). Without this
+       guard they get baked into the runtimeconfig.json of the portable 'any' fallback too. Signing is
+       skipped for the same reason: a native-AOT build has no loadable managed assembly to sign. -->
+  <PropertyGroup Condition="'$(RuntimeIdentifier)' != ''">
+    <PublishAot>true</PublishAot>
+    <PublishSelfContained>true</PublishSelfContained>
+    <StripSymbols>true</StripSymbols>
+    <SignAssembly>false</SignAssembly>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Nullean.Argh" Version="0.18.0" />
+    <PackageReference Include="Octokit" Version="14.0.0" />
+    <PackageReference Include="NuGet.Versioning" Version="6.13.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="..\..\nuget-icon.png" CopyToOutputDirectory="PreserveNewest">
+      <Link>nuget-icon.png</Link>
+      <Pack>True</Pack>
+      <PackagePath>nuget-icon.png</PackagePath>
+    </Content>
+  </ItemGroup>
+
+</Project>
diff --git a/src/release-notes/release-notes.fsproj b/src/release-notes/release-notes.fsproj
deleted file mode 100644
index fc87e1d..0000000
--- a/src/release-notes/release-notes.fsproj
+++ /dev/null
@@ -1,48 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
-    <AssemblyName>release-notes</AssemblyName>
-    <RootNamespace>ReleaseNotes</RootNamespace>
-    <PackAsTool>true</PackAsTool>
-    <ToolCommandName>release-notes</ToolCommandName>
-
-    <SignAssembly>true</SignAssembly>
-    <AssemblyOriginatorKeyFile>..\..\build\keys\keypair.snk</AssemblyOriginatorKeyFile>
-
-    <PackageIcon>nuget-icon.png</PackageIcon>
-    <PackageLicenseExpression>MIT</PackageLicenseExpression>
-    <RepositoryUrl>https://github.com/nullean/release-notes</RepositoryUrl>
-    <PackageProjectUrl>https://github.com/nullean/release-notes</PackageProjectUrl>
-    <PackageReleaseNotes>https://github.com/nullean/release-notes/releases</PackageReleaseNotes>
-
-    <Title>release-notes: a dotnet tool to generate release notes from GitHub</Title>
-    <Description>Generate release notes from closed github issues and PR's through the power of version labels</Description>
-
-  </PropertyGroup>
-  
-  <ItemGroup>
-    <Content Include="..\..\nuget-icon.png" CopyToOutputDirectory="PreserveNewest">
-      <Link>nuget-icon.png</Link>
-      <Pack>True</Pack>
-      <PackagePath>nuget-icon.png</PackagePath>
-    </Content>
-  </ItemGroup>
-
-  <ItemGroup>
-    <Compile Include="Arguments.fs" />
-    <Compile Include="OutputWriter.fs" />
-    <Compile Include="GithubItem.fs" />
-    <Compile Include="GithubScanner.fs" />
-    <Compile Include="Labeler.fs" />
-    <Compile Include="Program.fs" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Argu" Version="6.1.1" />
-    <PackageReference Include="Octokit" Version="0.43.0" />
-    <PackageReference Include="Fake.Core.SemVer" Version="5.15.0" />
-  </ItemGroup>
-
-</Project>