Run the live CPUs at the performance governor during install

archiso boots on whatever governor the kernel defaults to, which on most
laptops ramps conservatively. Package extraction and the UKI build are both
CPU-bound, so pin performance for the whole install and put it back afterwards.

Reduced from #87 by @davydotcom, which also disabled every non-POLL cpuidle
state. That half is left out deliberately: C1 wake latency is 1us on current
hardware, and disabling it leaves POLL as the only idle state, so idle cores
busy-spin instead of halting. Package extraction is single-threaded, so on an
8-core laptop that is 7 cores burning power for no work — on a thermally
limited machine that costs the working core its turbo headroom, which is a
plausible way to make the install slower. #87 measured the two tweaks together
with a page-cache prefetch and an updatedb deferral, so the C-state
contribution was never isolated.

Scoped to the whole install rather than just the pacstrap window, which #87
used: finalize_limine_boot runs mkinitcpio and compresses a UKI, and is the
most purely CPU-bound phase there is.

Restoring only matters when an install fails and the user keeps using the live
environment; a successful one reboots out of it.

Co-Authored-By: David Estes <davydotcom@gmail.com>
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

bin/omarchy-iso-installer

@@ -2,49 +2,89 @@
 # Preview the shipped Omarchy installer dashboard without building an ISO.
 set -euo pipefail
 
+# The dashboard drives the package phase from the target's pacman database, so
+# fake one here; without it the preview falls back to its time curve and the bar
+# barely moves, which reads as a bug.
+PREVIEW_PACKAGES="${PREVIEW_PACKAGES:-925}"
+
 write_simulation_state() {
   local state_file="$1" started_at="$2" phase_started_at="$3" current_phase="$4"
-  local finished_at="${5:-null}" temporary="${state_file}.tmp"
+  local target="$5" index="$6" total="$7"
+  local finished_at="${8:-null}" temporary="${state_file}.tmp"
 
   jq -n \
     --argjson started_at "$started_at" \
     --argjson phase_started_at "$phase_started_at" \
     --arg current_phase "$current_phase" \
+    --arg target "$target" \
+    --argjson current_index "$index" \
+    --argjson total_phases "$total" \
     --argjson finished_at "$finished_at" \
     '{
       started_at: $started_at,
       phase_started_at: $phase_started_at,
-      current_phase: $current_phase
+      current_phase: $current_phase,
+      target: $target,
+      current_index: $current_index,
+      total_phases: $total_phases
     } + if $finished_at == null then {} else {finished_at: $finished_at} end' \
     >"$temporary"
   mv -f -- "$temporary" "$state_file"
 }
 
+# Fill the fake database over the phase's duration, so the bar is driven by the
+# same count it uses on a real install.
+simulate_packages() {
+  local db="$1" duration="$2" total="$3" steps=25 i n
+  for ((i = 1; i <= steps; i++)); do
+    n=$(( total * i / steps ))
+    while (( $(ls -1 "$db" 2>/dev/null | wc -l) < n )); do
+      mkdir -p "$db/preview-$(( $(ls -1 "$db" 2>/dev/null | wc -l) ))-1.0-1"
+    done
+    sleep "$(awk -v d="$duration" -v s="$steps" 'BEGIN { printf "%.3f", d / s }')"
+  done
+}
+
 simulate_install() {
   local state_file="$1"
   local started_at="$EPOCHREALTIME"
-  local phase phase_started_at finished_at duration i
+  local phase phase_started_at finished_at duration i index total
+  local target db
+  target="$(dirname -- "$state_file")/target"
+  db="$target/var/lib/pacman/local"
+  mkdir -p "$db"
   local -a phases=(
     "Starting installation" 0.5
     "Preparing live environment" 0.8
+    "Preparing install target" 0.3
     "Installing Arch + Omarchy" 5.0
+    "Configuring hibernation" 0.4
     "Configuring system" 1.2
     "Finalizing Limine boot" 1.0
     "Finalizing user" 1.0
     "Configuring login" 0.6
+    "Configuring DNS resolver" 0.3
     "Validating boot setup" 0.8
   )
+  total=$(( ${#phases[@]} / 2 ))
 
   for ((i = 0; i < ${#phases[@]}; i += 2)); do
     phase="${phases[i]}"
     duration="${phases[i + 1]}"
+    index=$(( i / 2 ))
     phase_started_at="$EPOCHREALTIME"
-    write_simulation_state "$state_file" "$started_at" "$phase_started_at" "$phase"
-    sleep "$duration"
+    write_simulation_state "$state_file" "$started_at" "$phase_started_at" \
+      "$phase" "$target" "$index" "$total"
+    if [[ $phase == "Installing Arch + Omarchy" ]]; then
+      simulate_packages "$db" "$duration" "$PREVIEW_PACKAGES"
+    else
+      sleep "$duration"
+    fi
   done
 
   finished_at="$EPOCHREALTIME"
-  write_simulation_state "$state_file" "$started_at" "$finished_at" "Installation complete" "$finished_at"
+  write_simulation_state "$state_file" "$started_at" "$finished_at" \
+    "Installation complete" "$target" "$(( total - 1 ))" "$total" "$finished_at"
   sleep 0.3
 }
 
@@ -91,6 +131,12 @@ log_file="$preview_dir/install.log"
 state_file="$preview_dir/state.json"
 touch "$log_file"
 
+# Match what the simulated database will reach, so the preview shows the
+# package-driven bar rather than the missing-signal fallback.
+printf '%s\n' "$PREVIEW_PACKAGES" >"$preview_dir/expected-packages"
+
 OMARCHY_UI_AUTO_REBOOT=no \
+  OMARCHY_EXPECTED_PACKAGES_FILE="$preview_dir/expected-packages" \
+  PREVIEW_PACKAGES="$PREVIEW_PACKAGES" \
   "$dashboard" "$log_file" "$state_file" -- \
   "$0" --simulate-install "$state_file"

builder/build-iso.sh

@@ -116,19 +116,6 @@ cp "/tmp/$NODE_FILENAME" "$build_cache_dir/airootfs/opt/packages/"
 arch_packages=(linux-t2 git gum jq openssl plymouth python-terminaltexteffects tzupdate omarchy-keyring "$OMARCHY_SETTINGS_PACKAGE" lvm2 cryptsetup parted)
 printf '%s\n' "${arch_packages[@]}" >> "$build_cache_dir/packages.x86_64"
 
-# The live ISO boots linux-t2 (see airootfs/etc/mkinitcpio.d/linux-t2.preset), so
-# stock linux is a second kernel nobody boots: ~147MB of ISO, plus its own archiso
-# initramfs, copied into both the ISO tree and the size-constrained FAT EFI image.
-#
-# It cannot just be deleted — releng's broadcom-wl hard-depends on it, and it is
-# the only releng package that does, so pacman would drag the kernel straight back
-# in. broadcom-wl is a prebuilt module for stock linux and cannot load on the
-# kernel we boot, so it has done nothing since we started booting T2 anyway. The
-# install is entirely offline and the live environment needs no Wi-Fi driver.
-#
-# Anchored so linux-t2 and linux-firmware are untouched.
-sed -i -E '/^(linux|broadcom-wl)$/d' "$build_cache_dir/packages.x86_64"
-
 # Build the offline mirror: everything pacstrap might want during the target
 # install. With --local-source, the omarchy* packages we just built are
 # already in the mirror and we filter them out below. Without it, pacman -Syw
@@ -247,6 +234,70 @@ repo-add "$offline_mirror_dir/offline.db.tar.gz" "$offline_mirror_dir/"*.pkg.tar
 mkdir -p /var/cache/omarchy/mirror
 ln -sf "$offline_mirror_dir" /var/cache/omarchy/mirror/offline
 
+# Denominator for the install dashboard's progress bar. Resolving the mirror's
+# own package lists against the mirror we just indexed, with an empty local db,
+# is the question pacstrap asks at install time — same resolver, same repo, same
+# lists — so no hand-kept constant can drift.
+#
+# It over-counts by ~1 in 925: archinstall.packages lists both amd-ucode and
+# intel-ucode because the mirror must contain either. phases.py records expected
+# and actual in the timing JSON, so growing drift shows up in acceptance runs.
+# The early-bootstrap set is already inside this closure, so restating it would
+# only add a second list to drift.
+resolve_expected_packages() {
+  local resolve_root=/tmp/omarchy-expected-packages
+  local resolved
+  local -a targets
+
+  rm -rf "$resolve_root"
+  mkdir -p "$resolve_root/var/lib/pacman"
+
+  mapfile -t targets < <(
+    {
+      grep -hv '^#\|^$' /builder/archinstall.packages
+      # Read the shipped copy, which is what _runtime_package_list reads at
+      # install time, not the build-time source it came from.
+      grep -hv '^#\|^$' \
+        "$build_cache_dir/airootfs/usr/share/omarchy-iso/omarchy-base.packages"
+      printf '%s\n' "$OMARCHY_RUNTIME_PACKAGE" "$OMARCHY_SETTINGS_PACKAGE" \
+        "$OMARCHY_NVIM_PACKAGE"
+    } | sort -u
+  )
+
+  pacman --config "$build_cache_dir/pacman-offline.conf" \
+    --root "$resolve_root" --dbpath "$resolve_root/var/lib/pacman" \
+    --noconfirm -Sy >/dev/null || return 1
+
+  # Capture before counting: no pipefail here, so a pacman failure inside a
+  # pipeline would become a plausible partial count, which never trips the
+  # dashboard's fallback.
+  resolved="$(pacman --config "$build_cache_dir/pacman-offline.conf" \
+    --root "$resolve_root" --dbpath "$resolve_root/var/lib/pacman" \
+    --noconfirm -S --print --print-format '%n' "${targets[@]}")" || return 1
+
+  printf '%s\n' "$resolved" | sort -u | grep -c .
+}
+
+# Worth failing the build over: -S --print only aborts when a target is missing
+# from the offline repo, which would fail pacstrap the same way. A count that
+# merely looks wrong is not — the dashboard falls back without the file.
+if ! expected_packages="$(resolve_expected_packages)"; then
+  echo "ERROR: could not resolve the target package count from the offline mirror." >&2
+  echo "       pacman -S --print aborts the whole transaction if any single target" >&2
+  echo "       is missing, so this almost certainly means pacstrap would fail the" >&2
+  echo "       same way at install time." >&2
+  exit 1
+fi
+if (( expected_packages < 600 || expected_packages > 2000 )); then
+  echo "WARNING: resolved target package count $expected_packages is outside the" >&2
+  echo "         expected 600-2000 range; shipping no denominator so the install" >&2
+  echo "         dashboard falls back to its time-based curve." >&2
+else
+  printf '%s\n' "$expected_packages" \
+    >"$build_cache_dir/airootfs/usr/share/omarchy-iso/expected-packages"
+  echo "Target install resolves to $expected_packages packages."
+fi
+
 # Live ISO uses the same offline pacman.conf.
 cp "$build_cache_dir/pacman-offline.conf" "$build_cache_dir/airootfs/etc/pacman.conf"
 

configs/airootfs/etc/mkinitcpio.d/linux-t2.preset

@@ -1,18 +0,0 @@
-# mkinitcpio preset file for the 'linux-t2' package on archiso
-#
-# The filename is the pkgbase, and that is load-bearing. Kernel packages ship
-# nothing in /boot — they only install usr/lib/modules/<kver>/vmlinuz — so
-# mkinitcpio's alpm hook sources /etc/mkinitcpio.d/<pkgbase>.preset and copies
-# THAT package's kernel to whatever ALL_kver names (is_kernelcopy in
-# /usr/share/libalpm/scripts/mkinitcpio). Named linux.preset, this pointed the
-# stock kernel at the T2 filenames, so the ISO booted stock Arch while every
-# boot entry said linux-t2 and T2 Macs got no keyboard or trackpad.
-#
-# releng ships its own linux.preset for the stock kernel; leave it alone.
-
-PRESETS=('archiso')
-
-ALL_kver='/boot/vmlinuz-linux-t2'
-archiso_config='/etc/mkinitcpio.conf.d/archiso.conf'
-
-archiso_image="/boot/initramfs-linux-t2.img"

configs/airootfs/etc/mkinitcpio.d/linux.preset

@@ -0,0 +1,9 @@
+# mkinitcpio preset file for the 'linux' package on archiso
+
+PRESETS=('archiso')
+
+ALL_kver='/boot/vmlinuz-linux-t2'
+archiso_config='/etc/mkinitcpio.conf.d/archiso.conf'
+
+archiso_image="/boot/initramfs-linux-t2.img"
+

configs/airootfs/usr/local/bin/omarchy-install-dashboard

@@ -137,7 +137,63 @@ LOGO_HEIGHT="$(logo_height)"
 (( LOGO_HEIGHT > 0 )) || LOGO_HEIGHT=1
 CONTENT_WIDTH="$LOGO_WIDTH"
 DYNAMIC_ROW=$((LOGO_HEIGHT + 3))
-LAST_PCT=1
+LAST_PM=10
+
+# ── Install progress ─────────────────────────────────────────────────────────
+#
+# Position = max(floor, work), both non-decreasing, in per-mille of the bar.
+#
+#   floor  lo + (span-1) * t / (t+tau), on time since this process saw the
+#          phase. Asymptotic, so it approaches the band end without reaching it.
+#          tau is a shape constant, not a duration prediction.
+#   work   packages installed / PKG_TOTAL, for the package phase only (~85% of
+#          the install). libalpm makes one directory per package under
+#          <target>/var/lib/pacman/local; the denominator comes from
+#          build-iso.sh, so there is no second package list to drift.
+#
+# Per-mille because a whole-percent asymptote over a 2-point band has two
+# reachable values and stops moving. No give-up predicate: two discontinuous
+# curves behind a monotonic clamp freeze. With no signal the floor alone still
+# finishes the band.
+EXPECTED_PACKAGES_FILE="${OMARCHY_EXPECTED_PACKAGES_FILE:-/usr/share/omarchy-iso/expected-packages}"
+PKG_TOTAL=0
+if [[ -r $EXPECTED_PACKAGES_FILE ]]; then
+  read -r PKG_TOTAL _ <"$EXPECTED_PACKAGES_FILE" 2>/dev/null || PKG_TOTAL=0
+fi
+[[ $PKG_TOTAL =~ ^[0-9]+$ ]] || PKG_TOTAL=0
+# A wrong denominator is worse than none: it never triggers the fallback.
+(( PKG_TOTAL < 300 || PKG_TOTAL > 5000 )) && PKG_TOTAL=0
+
+PKG_BONUS_MAX_PM=100   # cap on how far the bar may run ahead of the count
+PKG_TAIL_PM=40         # band held back so a stalled bar has somewhere to go
+PKG_FLOOR_TAU=900      # with a work signal, time is only a backstop until the
+                       # first package, so slow it until it cannot outrun data
+
+POS=10                 # position, per-mille, monotonic
+PROGRESS_PM=10
+NOW=0                  # monotonic seconds, refreshed once per frame
+DASH_T0=0
+PHASE_NAME=""          # last phase this process observed
+PHASE_T0=0             # NOW when it was first observed
+PHASE_LO=10            # POS on entry, for an unknown phase with no index
+PKG_DB_DIR=""
+PKG_COUNT=0
+PKG_BASE=-1            # package count when the phase started
+PKG_SEEN=0             # running max of packages since PKG_BASE
+PKG_LAST_CHANGE=0
+PKG_BONUS=0
+
+# Monotonic clock: tzupdate and systemd-timesyncd can step the wall clock
+# mid-install, which would jump every time-driven band to its ceiling.
+set_now() {
+  local up rest
+  if read -r up rest </proc/uptime 2>/dev/null && [[ $up == [0-9]* ]]; then
+    NOW=${up%%.*}
+  else
+    NOW=$EPOCHSECONDS
+  fi
+  return 0
+}
 
 left_padding() {
   local width="${1:-$CONTENT_WIDTH}" cols pad
@@ -183,72 +239,146 @@ render_logo() {
 }
 
 progress_bar() {
-  local pct="$1" width="${2:-34}" filled empty
-  (( pct < 0 )) && pct=0
-  (( pct > 100 )) && pct=100
-  filled=$(( pct * width / 100 ))
+  local pm="$1" width="${2:-34}" filled empty
+  (( pm < 0 )) && pm=0
+  (( pm > 1000 )) && pm=1000
+  filled=$(( pm * width / 1000 ))
   empty=$(( width - filled ))
   printf '%s%s%s%s%s' "$WHITE" "$(repeat █ "$filled")" "$DARK" "$(repeat ░ "$empty")" "$RESET"
 }
 
+# Packages libalpm has finished installing. local/ holds one directory per
+# package and nothing else in it is a directory, so */ is exact. One glob, no
+# forks: this runs twice a second while the disk is saturated.
+count_packages() {
+  local -a entries
+  PKG_COUNT=0
+  [[ -n $PKG_DB_DIR ]] || return 0
+  entries=("$PKG_DB_DIR"/*/)
+  # Unmatched globs expand to the pattern; nullglob stays off script-wide.
+  if (( ${#entries[@]} == 1 )) && [[ ! -d ${entries[0]} ]]; then
+    return 0
+  fi
+  PKG_COUNT=${#entries[@]}
+  return 0
+}
+
+# Sets PROGRESS_PM. Never call in a command substitution: POS, the phase timer
+# and the package counters must survive between frames. Print nothing — output
+# here would land on the TTY between the cursor escape and the bar.
 install_progress() {
-  local phase finished phase_started elapsed span active pct
-  local start=1 end=99 expected=90
+  local phase finished index total target
+  local lo hi tau span t pos work gap n pkg_signal=0
   local -a state
 
-  [[ -f $STATE_FILE ]] || { printf '1'; return; }
+  PROGRESS_PM=$POS
+  [[ -f $STATE_FILE ]] || return 0
 
   mapfile -t state < <(jq -r '
     (.current_phase // "Starting installation"),
     ((.finished_at // 0) | tonumber? // 0 | floor),
-    ((.phase_started_at // .started_at // 0) | tonumber? // 0 | floor)
+    ((.current_index // -1) | tonumber? // -1 | floor),
+    ((.total_phases // 0) | tonumber? // 0 | floor),
+    (.target // "/mnt")
   ' "$STATE_FILE" 2>/dev/null)
-  (( ${#state[@]} == 3 )) || { printf '1'; return; }
-  phase="${state[0]}" finished="${state[1]}" phase_started="${state[2]}"
+  (( ${#state[@]} == 5 )) || return 0
+  phase="${state[0]}" finished="${state[1]}"
+  index="${state[2]}" total="${state[3]}" target="${state[4]}"
+  [[ -n $target ]] || target="/mnt"
 
   if (( finished > 0 )) || [[ $phase == "Installation complete" ]]; then
-    printf '100'
-    return
+    POS=1000
+    PROGRESS_PM=1000
+    return 0
   fi
 
-  # Phase weights: start%, end%, expected seconds in phase.
+  # Transitions are observed here rather than read from the state file, which
+  # keeps wall clock out of the dashboard entirely.
+  if [[ $phase != "$PHASE_NAME" ]]; then
+    PHASE_NAME="$phase"
+    PHASE_T0=$NOW
+    PHASE_LO=$POS
+    PKG_BASE=-1
+    PKG_SEEN=0
+    PKG_BONUS=0
+    PKG_LAST_CHANGE=$NOW
+  fi
+
+  # Bands in per-mille, plus tau. The tail bands are wide relative to what they
+  # cost on NVMe: run_system_finalizer can DKMS-build a driver and
+  # finalize_limine_boot rebuilds every UKI, so they vary most on real hardware.
+  # Over-allotting costs a step at a boundary; under-allotting costs a stall.
   case "$phase" in
-    "Starting installation")           start=1  end=2   expected=2 ;;
-    "Preparing live environment")      start=2  end=6   expected=5 ;;
-    "Verifying protected mounts")      start=6  end=8   expected=3 ;;
-    "Installing Arch + Omarchy")       start=8  end=86  expected=95 ;;
-    "Installing base system")          start=8  end=84  expected=85 ;;
-    "Configuring protected boot")      start=84 end=86  expected=8 ;;
-    "Configuring hibernation")         start=86 end=88  expected=5 ;;
-    "Configuring system")              start=88 end=93  expected=10 ;;
-    "Finalizing Limine boot")          start=93 end=96  expected=8 ;;
-    "Finalizing user")                 start=96 end=98  expected=10 ;;
-    "Finalizing in chroot")            start=88 end=98  expected=10 ;;
-    "Configuring login")               start=98 end=99  expected=3 ;;
-    "Configuring DNS resolver")        start=99 end=100 expected=2 ;;
-    "Validating protected boot setup") start=99 end=100 expected=5 ;;
-    "Validating boot setup")           start=99 end=100 expected=5 ;;
+    "Starting installation")      lo=10  hi=25   tau=5   ;;
+    "Preparing live environment") lo=25  hi=50   tau=25  ;;
+    "Preparing install target")   lo=50  hi=65   tau=20  ;;
+    "Installing Arch + Omarchy")  lo=65  hi=700  tau=150 pkg_signal=1 ;;
+    "Configuring hibernation")    lo=700 hi=720  tau=10  ;;
+    "Configuring system")         lo=720 hi=850  tau=120 ;;
+    "Finalizing Limine boot")     lo=850 hi=950  tau=90  ;;
+    "Finalizing user")            lo=950 hi=978  tau=30  ;;
+    "Configuring login")          lo=978 hi=988  tau=5   ;;
+    "Configuring DNS resolver")   lo=988 hi=994  tau=5   ;;
+    "Validating boot setup")      lo=994 hi=1000 tau=5   ;;
+    *)
+      # Unknown names used to inherit a 1->99 sweep. Derive an even band from
+      # the published index instead; with no index, a bounded slice, so a
+      # renamed phase degrades to one cell rather than a runaway.
+      if (( total >= 2 && index >= 0 && index < total )); then
+        lo=$(( 10 + 990 * index / total ))
+        hi=$(( 10 + 990 * (index + 1) / total ))
+      else
+        lo=$PHASE_LO
+        hi=$(( PHASE_LO + 30 ))
+      fi
+      tau=60
+      ;;
   esac
 
-  (( phase_started > 0 )) || phase_started=$EPOCHSECONDS
-  elapsed=$(( EPOCHSECONDS - phase_started ))
-  (( elapsed < 0 )) && elapsed=0
-  span=$(( end - start ))
-  (( span < 0 )) && span=0
-  (( expected < 1 )) && expected=1
-  active=$(( elapsed * span / expected ))
-  (( active > span - 1 )) && active=$(( span - 1 ))
-  (( active < 0 )) && active=0
-  pct=$(( start + active ))
-  (( pct > 100 )) && pct=100
-  printf '%s' "$pct"
+  (( pkg_signal && PKG_TOTAL > 0 )) || pkg_signal=0
+  (( pkg_signal )) && tau=$PKG_FLOOR_TAU
+
+  t=$(( NOW - PHASE_T0 ))
+  (( t < 0 )) && t=0
+  span=$(( hi - lo ))
+  (( span < 2 )) && span=2
+  (( tau < 1 )) && tau=1
+
+  pos=$(( lo + (span - 1) * t / (t + tau) ))
+
+  if (( pkg_signal )); then
+    PKG_DB_DIR="$target/var/lib/pacman/local"
+    count_packages
+    # Baseline on first sight: a target that already holds packages would
+    # otherwise pin the bar at the band ceiling for the whole phase.
+    (( PKG_BASE < 0 )) && PKG_BASE=$PKG_COUNT
+    n=$(( PKG_COUNT - PKG_BASE ))
+    (( n < 0 )) && n=0
+    # Running max: a reinstalled package briefly drops its version-stamped dir.
+    if (( n > PKG_SEEN )); then
+      PKG_SEEN=$n
+      PKG_LAST_CHANGE=$NOW
+    fi
+    gap=$(( NOW - PKG_LAST_CHANGE ))
+    (( gap < 0 )) && gap=0
+    (( gap > PKG_BONUS_MAX_PM )) && gap=$PKG_BONUS_MAX_PM
+    (( gap > PKG_BONUS )) && PKG_BONUS=$gap
+    work=$(( lo + (span - 1 - PKG_TAIL_PM) * PKG_SEEN / PKG_TOTAL + PKG_BONUS ))
+    (( work > pos )) && pos=$work
+  fi
+
+  (( pos > hi - 1 )) && pos=$(( hi - 1 ))
+  (( pos > POS )) && POS=$pos
+  (( POS > 1000 )) && POS=1000
+  PROGRESS_PM=$POS
+  return 0
 }
 
-# One tip per ~8 seconds (frames tick every 0.5s), in order, so each stays
-# readable and none are skipped when progress jumps.
+# One tip per 8 seconds, in order. On elapsed time, not a frame counter: a frame
+# is 0.5s of sleep plus a render, which stretches under pacstrap I/O — on the
+# machine where the tips, not the bar, are carrying liveness.
 current_tip() {
-  local frame="$1"
-  printf '%s' "${tips[$(( frame / 16 % ${#tips[@]} ))]}"
+  printf '%s' "${tips[$(( (NOW - DASH_T0) / 8 % ${#tips[@]} ))]}"
 }
 
 render_static() {
@@ -259,21 +389,24 @@ render_static() {
 }
 
 render_dynamic() {
-  local frame="$1" pct
-  pct="$(install_progress)"
-  [[ $pct =~ ^[0-9]+$ ]] || pct=$LAST_PCT
-  (( pct > 100 )) && pct=100
-  (( pct < LAST_PCT )) && pct=$LAST_PCT
-  LAST_PCT=$pct
+  local pm
+  set_now
+  install_progress
+  pm=$PROGRESS_PM
+  [[ $pm =~ ^[0-9]+$ ]] || pm=$LAST_PM
+  (( pm > 1000 )) && pm=1000
+  # POS is monotone by construction; this is a guard, not the mechanism.
+  (( pm < LAST_PM )) && pm=$LAST_PM
+  LAST_PM=$pm
 
   printf '%s%d;1H' "$CSI" "$DYNAMIC_ROW"
   center "Installing Omarchy" "$CONTENT_WIDTH"
   blank_line
   line_at "$CONTENT_WIDTH" $(( (CONTENT_WIDTH - 34) / 2 )) ""
-  progress_bar "$pct" 34
+  progress_bar "$pm" 34
   printf '\n'
   blank_line
-  center "${DIM}Tip:${RESET} ${GREEN}$(current_tip "$frame")${RESET}" "$CONTENT_WIDTH"
+  center "${DIM}Tip:${RESET} ${GREEN}$(current_tip)${RESET}" "$CONTENT_WIDTH"
   printf '%s' "$CLEAR_TO_END"
 }
 
@@ -541,12 +674,14 @@ launch_child() {
 [[ -e $TTY_PATH ]] || exit 2
 printf '%s' "$HIDE_CURSOR" >"$TTY_PATH"
 render_static >"$TTY_PATH"
+set_now
+DASH_T0=$NOW
+PHASE_T0=$NOW
+PKG_LAST_CHANGE=$NOW
 launch_child
 
-frame=0
 while jobs -pr | grep -qx "$child_pid"; do
-  render_dynamic "$frame" >"$TTY_PATH" 2>/dev/null || true
-  frame=$((frame + 1))
+  render_dynamic >"$TTY_PATH" 2>/dev/null || true
   sleep 0.5
 done
 
@@ -559,6 +694,13 @@ child_pgid=""
 
 dashboard_log "installer child exited with status $status"
 
+if (( status == 0 )); then
+  # finished_at lands microseconds before the child exits, so the 0.5s poll
+  # rarely renders a full bar before the finish screen replaces it.
+  render_dynamic >"$TTY_PATH" 2>/dev/null || true
+  sleep 0.4
+fi
+
 if (( status != 0 )); then
   failure_status="$status"
   failure_summary=""

configs/airootfs/usr/share/omarchy-iso/orchestrator/main.py

@@ -65,11 +65,15 @@ def main() -> int:
     info(f"Installing Omarchy for {ctx.username} → {ctx.target}")
 
     from .phases_impl import (
+        boost_cpu_governor,
         cleanup_bind_mounts,
         cleanup_protected_state,
         cleanup_target_hook_masks,
+        restore_cpu_governors,
     )
 
+    governors = boost_cpu_governor()
+
     success = False
     try:
         try:
@@ -85,6 +89,7 @@ def main() -> int:
         info("Installation complete.")
         return 0
     finally:
+        restore_cpu_governors(governors)
         cleanup_bind_mounts(ctx)
         cleanup_target_hook_masks(ctx)
         if not success:

configs/airootfs/usr/share/omarchy-iso/orchestrator/phases.py

@@ -4,6 +4,7 @@ the InstallContext and either return cleanly or raise to abort the install."""
 from __future__ import annotations
 
 import json
+import os
 import time
 import traceback
 from collections.abc import Callable
@@ -25,6 +26,9 @@ def run(ctx: InstallContext, phases: list[tuple[str, PhaseFn]]) -> None:
     state_path = ctx.state_dir / "state.json"
     state = {
         "started_at": time.time(),
+        # The dashboard counts packages under <target>/var/lib/pacman/local;
+        # publish the path rather than have the UI assume /mnt.
+        "target": str(ctx.target),
         "total_phases": len(phases),
         "current_index": 0,
         "current_phase": "Starting installation",
@@ -63,6 +67,10 @@ def run(ctx: InstallContext, phases: list[tuple[str, PhaseFn]]) -> None:
     state["current_index"] = max(len(phases) - 1, 0)
     state["current_phase"] = "Installation complete"
     state["finished_at"] = time.time()
+    # Expected vs actual for the bar's denominator, so drift is visible in
+    # acceptance runs rather than only by watching a bar creep.
+    state["installed_packages"] = _installed_package_count(ctx.target)
+    state["expected_packages"] = _expected_package_count()
     _write_state(state_path, state)
 
     timing_path = ctx.target / "var" / "log" / "omarchy-install-timing.json"
@@ -70,6 +78,25 @@ def run(ctx: InstallContext, phases: list[tuple[str, PhaseFn]]) -> None:
     _write_state(timing_path, state)
 
 
+def _installed_package_count(target: Path) -> int:
+    """Packages libalpm installed into the target — one directory each under
+    local/, which is what the dashboard counts live."""
+    local_db = target / "var" / "lib" / "pacman" / "local"
+    try:
+        with os.scandir(local_db) as entries:
+            return sum(1 for entry in entries if entry.is_dir())
+    except OSError:
+        return 0
+
+
+def _expected_package_count() -> int:
+    path = Path("/usr/share/omarchy-iso/expected-packages")
+    try:
+        return int(path.read_text().split()[0])
+    except (OSError, ValueError, IndexError):
+        return 0
+
+
 def _write_state(path: Path, state: dict) -> None:
     # Dashboard polls this file while phases update it. Write atomically so the
     # reader never observes a truncated/partial JSON document and resets UI.

configs/airootfs/usr/share/omarchy-iso/orchestrator/phases_impl.py

@@ -1396,6 +1396,40 @@ def _validate_pre_mounted_filesystems(ctx: InstallContext) -> None:
             raise RuntimeError(f"{crypttab} missing LUKS UUID {storage['luks_uuid']}")
 
 
+CPU_SYSFS = Path("/sys/devices/system/cpu")
+
+
+def boost_cpu_governor() -> dict[Path, str]:
+    """Run the live CPUs flat out for the install.
+
+    Package extraction and the UKI build are both CPU-bound, and archiso boots
+    on whatever governor the kernel defaults to. Writing an unsupported
+    governor just fails, so nothing needs probing first, and hosts without
+    cpufreq (most VMs) have no paths at all. Returns the prior governors.
+    """
+    saved: dict[Path, str] = {}
+    for path in sorted(CPU_SYSFS.glob("cpu*/cpufreq/scaling_governor")):
+        try:
+            saved[path] = path.read_text().strip()
+            path.write_text("performance\n")
+        except OSError:
+            saved.pop(path, None)
+
+    if saved:
+        info(f"› CPU governor set to performance ({len(saved)} CPUs)")
+    return saved
+
+
+def restore_cpu_governors(saved: dict[Path, str]) -> None:
+    """Only matters when an install fails and the user keeps using the live
+    environment — a successful one reboots out of it."""
+    for path, governor in saved.items():
+        try:
+            path.write_text(f"{governor}\n")
+        except OSError:
+            continue
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # cleanup_bind_mounts: invoked from main()'s finally so bind mounts get
 # unwound on success, failure, or interrupt. Idempotent.

plans/aarch64-support.md

@@ -76,9 +76,9 @@ aarch64 has no BIOS — only UEFI. Drop the syslinux path entirely on ARM.
 
 The cleanest cut: keep one `grub.cfg` shared, strip the x86 shell/memtest fragments at build time when `OMARCHY_ARCH=aarch64`. Don't fork the file.
 
-### 6. mkinitcpio preset — `configs/airootfs/etc/mkinitcpio.d/linux-t2.preset`
+### 6. mkinitcpio preset — `configs/airootfs/etc/mkinitcpio.d/linux.preset`
 
-Names `vmlinuz-linux-t2` and `initramfs-linux-t2.img`. The filename is the pkgbase and the alpm hook keys off it, so aarch64 does not rename this file — it simply does not ship it, and releng's own `linux.preset` covers the stock kernel. Drop `linux-t2` from `arch_packages` on aarch64 and the boot entries point at `vmlinuz-linux` / `initramfs-linux.img`.
+References `vmlinuz-linux-t2` and `initramfs-linux-t2.img` (lines 5, 8). For aarch64, swap to `vmlinuz-linux` / `initramfs-linux.img`. Generate the file at build time from a template, keyed on arch.
 
 ### 7. Configurator — `configs/airootfs/root/configurator`
 
@@ -145,7 +145,7 @@ Code:
 - `configs/efiboot/loader/loader.conf` — per-arch default entry
 - `configs/efiboot/loader/entries/01-archiso-x86_64-linux.conf` — generate aarch64 sibling at build time
 - `configs/grub/grub.cfg`, `loopback.cfg` — strip x86-only fragments on aarch64
-- `configs/airootfs/etc/mkinitcpio.d/linux-t2.preset` — omit on aarch64 (drop linux-t2 there; releng's linux.preset covers the stock kernel)
+- `configs/airootfs/etc/mkinitcpio.d/linux.preset` — template by arch (drop linux-t2 on aarch64)
 - `configs/airootfs/root/configurator` — branch archinstall JSON mirror list on `uname -m`; optionally guard lspci T2 probe
 - `.github/workflows/nightly-build.yml` — matrix x86_64/aarch64