diff --git a/alderbench/Cargo.lock b/alderbench/Cargo.lock
index 1d4239a..a2af345 100644
--- a/alderbench/Cargo.lock
+++ b/alderbench/Cargo.lock
@@ -3,7 +3,7 @@
 version = 4
 
 [[package]]
-name = "adlerbench"
+name = "alderbench"
 version = "0.1.0"
 dependencies = [
  "crossterm",
diff --git a/alderbench/Cargo.toml b/alderbench/Cargo.toml
index d3d131f..16e8b50 100644
--- a/alderbench/Cargo.toml
+++ b/alderbench/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "adlerbench"
+name = "alderbench"
 version = "0.1.0"
 edition = "2021"
 
diff --git a/alderbench/README.md b/alderbench/README.md
index 50936c6..7b5e2c8 100644
--- a/alderbench/README.md
+++ b/alderbench/README.md
@@ -1,11 +1,11 @@
-# adlerbench
+# alderbench
 
-Sister app to [adlermon](../adlermon) for the same Alder Lake box
+Sister app to [aldermon](../aldermon) for the same Alder Lake box
 (i5-12600KF, ASRock Z690M ITX/ax). Runs **comparative benchmarks and CPU
 stress tests** across stock vs OC/UV configurations, with a live TUI and
 a JSON report file on exit.
 
-Standalone — no shared code with adlermon. Sensor conventions and the
+Standalone — no shared code with aldermon. Sensor conventions and the
 config parser shape are mirrored, not linked.
 
 ## Usage
@@ -32,8 +32,8 @@ pluggable via the `Workload` trait but not yet implemented — see
 
 ## Config
 
-`adlerbench.conf` is read from the working directory, then
-`~/.config/adlerbench/adlerbench.conf`. Simple `KEY = VALUE` lines; `#`
+`alderbench.conf` is read from the working directory, then
+`~/.config/alderbench/alderbench.conf`. Simple `KEY = VALUE` lines; `#`
 comments; unknown keys ignored. All values optional — defaults target the
 i5-12600KF / Z690M ITX box.
 
@@ -58,11 +58,11 @@ report.
 ## Package power (RAPL)
 
 `energy_uj` is root-only on this kernel. To read watts as a normal user,
-install adlermon's udev rule once (it covers both apps — same box, same
+install aldermon's udev rule once (it covers both apps — same box, same
 device):
 
 ```sh
-doas ../adlermon/powercap-pl-rules.sh
+doas ../aldermon/powercap-pl-rules.sh
 doas usermod -aG adm $USER   # then re-login
 ```
 
diff --git a/alderbench/adlerbench.conf b/alderbench/alderbench.conf
similarity index 91%
rename from alderbench/adlerbench.conf
rename to alderbench/alderbench.conf
index 4a07d04..bdb0580 100644
--- a/alderbench/adlerbench.conf
+++ b/alderbench/alderbench.conf
@@ -1,6 +1,6 @@
-# adlerbench.conf — sample (i5-12600KF / ASRock Z690M ITX/ax)
+# alderbench.conf — sample (i5-12600KF / ASRock Z690M ITX/ax)
 # Simple KEY = VALUE lines; # comments; unknown keys ignored.
-# Loaded from ./ then ~/.config/adlerbench/adlerbench.conf (first wins).
+# Loaded from ./ then ~/.config/alderbench/alderbench.conf (first wins).
 
 # Sensor sample period + cooldown between workloads.
 poll_ms     = 250
diff --git a/alderbench/src/config.rs b/alderbench/src/config.rs
index 2d9c2c1..19cb0a7 100644
--- a/alderbench/src/config.rs
+++ b/alderbench/src/config.rs
@@ -3,9 +3,9 @@
 //! Unknown keys are ignored (forward compatibility). Loaded once at
 //! startup.
 //!
-//! Mirrors adlermon's config.rs shape (same parser, same conf locations)
-//! but the key set is adlerbench's own — no rails (adlerbench doesn't
-//! display the board rail map; adlermon does), and the workload list is
+//! Mirrors aldermon's config.rs shape (same parser, same conf locations)
+//! but the key set is alderbench's own — no rails (alderbench doesn't
+//! display the board rail map; aldermon does), and the workload list is
 //! first-class.
 
 use std::path::PathBuf;
@@ -84,7 +84,7 @@ fn spec(name: &str, duration_secs: u64, cores: &str) -> WorkloadSpec {
 }
 
 /// Parse one config line over a Config (mutates in place). Shape matches
-/// adlermon's apply_line: strip `#` comments, trim, split on `=`, match
+/// aldermon's apply_line: strip `#` comments, trim, split on `=`, match
 /// the key. Unknown keys silently ignored.
 fn apply_line(cfg: &mut Config, line: &str) {
     let line = line.split('#').next().unwrap_or("").trim();
@@ -140,8 +140,8 @@ fn parse_workload_list(val: &str) -> Vec<WorkloadSpec> {
 pub fn load() -> Config {
     let mut cfg = Config::default();
     let candidates = [
-        Some(PathBuf::from("adlerbench.conf")),
-        dirs_home().map(|h| h.join(".config/adlerbench/adlerbench.conf")),
+        Some(PathBuf::from("alderbench.conf")),
+        dirs_home().map(|h| h.join(".config/alderbench/alderbench.conf")),
     ];
     let mut indexed: Vec<WorkloadSpec> = Vec::new();
     let mut saw_indexed = false;
diff --git a/alderbench/src/report.rs b/alderbench/src/report.rs
index 4b040ab..7926296 100644
--- a/alderbench/src/report.rs
+++ b/alderbench/src/report.rs
@@ -1,6 +1,6 @@
 //! JSON report writer. One file per workload run, under `report_dir`
 //! (`./runs/` by default). Schema v2: run metadata, workload verdict,
-//! and the perf score. No sensor fields — adlermon owns sensors; this
+//! and the perf score. No sensor fields — aldermon owns sensors; this
 //! report only records what the workload itself produced.
 //!
 //! Incremental flush: the whole file is rewritten on each call. A v2
diff --git a/alderbench/src/run.rs b/alderbench/src/run.rs
index ac426b3..838bba3 100644
--- a/alderbench/src/run.rs
+++ b/alderbench/src/run.rs
@@ -1,4 +1,4 @@
-//! Run orchestration — the new core (adlermon has no equivalent). Owns
+//! Run orchestration — the new core (aldermon has no equivalent). Owns
 //! the sweep lifecycle: for each workload in the config, cooldown →
 //! workload.start() → wait for exit (polling is_running) → workload.stop()
 //! if needed → workload.wait() for verdict → workload.score() for the
diff --git a/alderbench/src/ui.rs b/alderbench/src/ui.rs
index 3536b3b..0282987 100644
--- a/alderbench/src/ui.rs
+++ b/alderbench/src/ui.rs
@@ -5,7 +5,7 @@
 //!  - **Sweep**: consume `run::Run::tick()` every `poll_ms`, render the
 //!    current workload + progress + a results table. q/Esc quits.
 //!
-//! NO sensor meters — adlermon owns sensors. adlerbench records scores.
+//! NO sensor meters — aldermon owns sensors. alderbench records scores.
 
 use std::io;
 use std::time::Duration;
@@ -89,7 +89,7 @@ const PICKER_ROWS: &[(&str, &str)] = &[
 // ---------------------------------------------------------------------------
 
 /// Entry point. Owns raw mode via ratatui::init/restore (same pattern as
-/// adlermon). The mode loop: draw → poll events (poll_ms timeout) →
+/// aldermon). The mode loop: draw → poll events (poll_ms timeout) →
 /// dispatch by mode. q/Esc at the picker quits; during the sweep it
 /// cancels back to the picker (if the sweep was launched from there) or
 /// quits (if launched from --preset/--tui directly).
@@ -115,7 +115,7 @@ pub fn run_tui(cfg: Config) {
             // every tick — the render loop steals CPU from the workload,
             // which on single-core runs extends the wall time enough to
             // cause false Stopped verdicts. The user can see CPU load via
-            // adlermon. We only re-draw on state transitions (workload
+            // aldermon. We only re-draw on state transitions (workload
             // started / finished / sweep done) + during cooldown (when
             // the CPU is idle anyway).
             let should_draw = match &outcome {
@@ -569,7 +569,7 @@ fn draw_picker(f: &mut Frame, state: &PickerState) {
             Block::default()
                 .borders(Borders::ALL)
                 .border_style(Style::default().fg(Color::DarkGray))
-                .title(Span::styled(" adlerbench — choose a sweep ", Style::default().fg(Color::Cyan))),
+                .title(Span::styled(" alderbench — choose a sweep ", Style::default().fg(Color::Cyan))),
         );
     f.render_widget(list, area);
     // Footer with keybinds.
@@ -600,7 +600,7 @@ fn draw_editor(f: &mut Frame, state: &EditorState) {
     // Header.
     f.render_widget(
         Paragraph::new(Line::from(Span::styled(
-            "adlerbench — custom sweep editor",
+            "alderbench — custom sweep editor",
             Style::default().add_modifier(Modifier::BOLD),
         ))),
         chunks[0],
@@ -753,11 +753,11 @@ fn draw_header(f: &mut Frame, area: Rect, app: &App) {
         format!("loop {loop_idx}/{loop_total}")
     };
     let title = if app.run.is_done() {
-        format!("adlerbench — sweep complete: {} workloads", app.results.len())
+        format!("alderbench — sweep complete: {} workloads", app.results.len())
     } else if current == 0 {
-        format!("adlerbench — starting (0/{total})  {loop_str}")
+        format!("alderbench — starting (0/{total})  {loop_str}")
     } else {
-        format!("adlerbench — workload {current}/{total}  {loop_str}")
+        format!("alderbench — workload {current}/{total}  {loop_str}")
     };
     f.render_widget(
         Paragraph::new(Line::from(Span::styled(
@@ -837,7 +837,7 @@ fn draw_current(f: &mut Frame, area: Rect, app: &App) {
         // Running: the duration is a display-only estimate ("this will
         // probably take X seconds"). No progress bar — the workload runs
         // until it self-exits or the user quits. The user can see CPU
-        // load via adlermon.
+        // load via aldermon.
         [
             Line::from(vec![
                 Span::styled(format!("{:<20}", spec.name), Style::default().add_modifier(Modifier::BOLD)),
@@ -858,7 +858,7 @@ fn draw_current(f: &mut Frame, area: Rect, app: &App) {
                 ),
             ]),
             Line::from(Span::styled(
-                "running... (watch CPU load in adlermon, press q to cancel)",
+                "running... (watch CPU load in aldermon, press q to cancel)",
                 Style::default().fg(Color::DarkGray),
             )),
         ]
diff --git a/aldermon/Cargo.lock b/aldermon/Cargo.lock
index 6970958..da3716b 100644
--- a/aldermon/Cargo.lock
+++ b/aldermon/Cargo.lock
@@ -3,7 +3,7 @@
 version = 4
 
 [[package]]
-name = "adlermon"
+name = "aldermon"
 version = "0.1.0"
 dependencies = [
  "crossterm",
diff --git a/aldermon/Cargo.toml b/aldermon/Cargo.toml
index 558959f..2b9925a 100644
--- a/aldermon/Cargo.toml
+++ b/aldermon/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "adlermon"
+name = "aldermon"
 version = "0.1.0"
 edition = "2021"
 
diff --git a/aldermon/README.md b/aldermon/README.md
index 8b1ed58..49699d0 100644
--- a/aldermon/README.md
+++ b/aldermon/README.md
@@ -1,4 +1,4 @@
-# adlermon
+# aldermon
 
 btop-style TUI monitor for Alder Lake (i5-12600KF), built around real vCore
 voltage for overclock-safety work.
@@ -19,8 +19,8 @@ sections, footer max frequency.
 
 ## Config
 
-`adlermon.conf` is read from the working directory, then
-`~/.config/adlermon/adlermon.conf`. Simple `KEY = VALUE` lines; `#`
+`aldermon.conf` is read from the working directory, then
+`~/.config/aldermon/aldermon.conf`. Simple `KEY = VALUE` lines; `#`
 comments; unknown keys are ignored. All values optional — built-in defaults
 target an ASRock Z690M ITX/ax (nct6798).
 
@@ -45,7 +45,7 @@ rail.in5.hide  = true        # hide unwired/floating inputs
 ```
 
 Rail labels for this board were confirmed against the BIOS and differential
-stress-ng probing (2026-08-29); see comments in `adlermon.conf`. The only
+stress-ng probing (2026-08-29); see comments in `aldermon.conf`. The only
 remaining guess is in4 = VCCIO.
 
 ## Package power (RAPL) — one-time setup
diff --git a/aldermon/adlermon.conf b/aldermon/aldermon.conf
similarity index 100%
rename from aldermon/adlermon.conf
rename to aldermon/aldermon.conf
diff --git a/aldermon/powercap-pl-rules.sh b/aldermon/powercap-pl-rules.sh
index 0c0d931..c852ef8 100755
--- a/aldermon/powercap-pl-rules.sh
+++ b/aldermon/powercap-pl-rules.sh
@@ -1,5 +1,5 @@
 #!/bin/sh
-# powercap-pl-rules.sh - one-shot installer for RAPL access (adlermon).
+# powercap-pl-rules.sh - one-shot installer for RAPL access (aldermon).
 #
 # RAPL energy_uj is 0400 root-only on this kernel, which gates the power
 # panel. This installs a udev rule + helper so any user in group `adm`
@@ -11,8 +11,8 @@
 
 set -eu
 
-HELPER=/usr/local/sbin/adlermon-powercap-chmod
-RULE=/etc/udev/rules.d/60-adlermon-powercap.rules
+HELPER=/usr/local/sbin/aldermon-powercap-chmod
+RULE=/etc/udev/rules.d/60-aldermon-powercap.rules
 
 # Helper: relax energy_uj to 0440, group adm, on every powercap dir.
 cat > "$HELPER" <<'EOF'
diff --git a/aldermon/src/config.rs b/aldermon/src/config.rs
index 81bcc62..30b47b9 100644
--- a/aldermon/src/config.rs
+++ b/aldermon/src/config.rs
@@ -179,10 +179,10 @@ fn set_rail(cfg: &mut Config, input: &str, label: &str, hide: Option<bool>) {
 
 pub fn load() -> Config {
     let mut cfg = Config::default();
-    // Search order: ./adlermon.conf then ~/.config/adlermon/adlermon.conf
+    // Search order: ./aldermon.conf then ~/.config/aldermon/aldermon.conf
     let candidates = [
-        Some(std::path::PathBuf::from("adlermon.conf")),
-        dirs_home().map(|h| h.join(".config/adlermon/adlermon.conf")),
+        Some(std::path::PathBuf::from("aldermon.conf")),
+        dirs_home().map(|h| h.join(".config/aldermon/aldermon.conf")),
     ];
     for path in candidates.into_iter().flatten() {
         if let Ok(text) = std::fs::read_to_string(&path) {
diff --git a/aldermon/src/main.rs b/aldermon/src/main.rs
index e0d9bac..7a8b439 100644
--- a/aldermon/src/main.rs
+++ b/aldermon/src/main.rs
@@ -1,4 +1,4 @@
-//! adlermon — Alder Lake monitor.
+//! aldermon — Alder Lake monitor.
 //!
 //! Currently a dump tool: prints a one-shot sensor snapshot to stdout. The
 //! TUI consumes the same `sensors` layer once the vCore source spike is done.