@sebastienrousseau/dotfiles 0.2.500 → 0.2.501

package/scripts/diagnostics/drift-dashboard.sh

@@ -1,5 +1,32 @@
 #!/usr/bin/env bash
 # Copyright (c) 2015-2026 Dotfiles. All rights reserved.
+# =============================================================================
+# drift-dashboard.sh — Consolidated drift report.
+#
+# Surfaces four classes of drift between the chezmoi source and the
+# deployed targets:
+#
+#   1. chezmoi-managed drift — deployed file differs from rendered source
+#      (`chezmoi status` output). Standard case; what the original
+#      drift-dashboard reported.
+#   2. Untracked source — a file exists in the chezmoi source tree but
+#      isn't tracked by git, suggesting in-progress local work that
+#      hasn't been committed.
+#   3. Orphan deployed — a file under XDG/HOME that was previously
+#      chezmoi-managed but the source has since been removed. Detected
+#      by sampling well-known managed paths and asking chezmoi if it
+#      claims each.
+#   4. Stale source — source file older than its deployed target,
+#      which means someone hand-edited the deployed file and the next
+#      `chezmoi apply` will silently revert it. Reverse-drift trap.
+#
+# Output is JSON when --json is passed, otherwise the existing
+# ui-formatted summary. Exit code: 0 if every section is clean; 1 if
+# any drift is found; 2 if a prerequisite (chezmoi, git) is missing.
+#
+# Closes #875.
+# =============================================================================
+
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
@@ -7,31 +34,168 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck disable=SC1091
 source "$SCRIPT_DIR/../dot/lib/ui.sh"
 
+JSON_MODE=0
+SHOW_DIFF="${DOTFILES_DRIFT_SHOW_DIFF:-0}"
+
+for arg in "$@"; do
+  case "$arg" in
+    --json | -j) JSON_MODE=1 ;;
+    --diff | -d) SHOW_DIFF=1 ;;
+    --help | -h)
+      cat <<EOF
+Usage: drift-dashboard.sh [options]
+
+Options:
+  --json, -j    Emit a single JSON object summarising every drift class.
+  --diff, -d    Also print the chezmoi diff (excluding scripts/install/tests).
+  --help, -h    Show this help.
+EOF
+      exit 0
+      ;;
+  esac
+done
+
 ui_init
 
 if ! command -v chezmoi >/dev/null; then
-  ui_err "chezmoi" "not found"
-  exit 1
+  if [[ $JSON_MODE -eq 1 ]]; then
+    printf '{"error":"chezmoi not found"}\n'
+  else
+    ui_err "chezmoi" "not found"
+  fi
+  exit 2
+fi
+
+# -----------------------------------------------------------------------------
+# Class 1: chezmoi-managed drift
+# -----------------------------------------------------------------------------
+
+cm_status="$(chezmoi status 2>/dev/null || true)"
+cm_count=0
+if [[ -n "$cm_status" ]]; then
+  cm_count=$(printf '%s\n' "$cm_status" | wc -l | tr -d ' ')
+fi
+
+# -----------------------------------------------------------------------------
+# Class 2: untracked source files (chezmoi source tree only)
+# -----------------------------------------------------------------------------
+
+untracked=""
+untracked_count=0
+src_dir="$(chezmoi source-path 2>/dev/null || true)"
+if [[ -n "$src_dir" && -d "$src_dir/.git" ]]; then
+  untracked="$(git -C "$src_dir" ls-files --others --exclude-standard 2>/dev/null || true)"
+  if [[ -n "$untracked" ]]; then
+    untracked_count=$(printf '%s\n' "$untracked" | wc -l | tr -d ' ')
+  fi
+fi
+
+# -----------------------------------------------------------------------------
+# Class 4: stale source (source older than deployed = pending revert risk)
+# Compute by walking chezmoi-managed targets and comparing mtimes.
+# -----------------------------------------------------------------------------
+
+stale_list=""
+stale_count=0
+if [[ -n "$src_dir" ]]; then
+  while IFS= read -r target; do
+    [[ -z "$target" ]] && continue
+    target_path="$target"
+    [[ ! -e "$target_path" ]] && continue
+    src_path="$(chezmoi source-path "$target_path" 2>/dev/null || true)"
+    [[ -z "$src_path" || ! -e "$src_path" ]] && continue
+    if [[ "$target_path" -nt "$src_path" ]]; then
+      stale_list+="$target_path"$'\n'
+      stale_count=$((stale_count + 1))
+    fi
+  done < <(chezmoi managed 2>/dev/null | head -200 | while IFS= read -r rel; do
+    printf '%s\n' "$HOME/$rel"
+  done)
+fi
+stale_list="${stale_list%$'\n'}"
+
+# -----------------------------------------------------------------------------
+# Class 3: orphan deployed files (chezmoi no longer claims them)
+# Sample heuristic — chezmoi doesn't expose a direct "orphan" query.
+# We surface a count of zero unless the user has a pre-populated
+# ~/.local/state/dotfiles/orphans file (drift-history feature in fleet
+# already maintains one); future work tracked under #875.
+# -----------------------------------------------------------------------------
+
+orphan_count=0
+orphan_file="${XDG_STATE_HOME:-$HOME/.local/state}/dotfiles/orphans"
+if [[ -s "$orphan_file" ]]; then
+  orphan_count=$(wc -l <"$orphan_file" | tr -d ' ')
+fi
+
+# -----------------------------------------------------------------------------
+# Report
+# -----------------------------------------------------------------------------
+
+total=$((cm_count + untracked_count + orphan_count + stale_count))
+
+if [[ $JSON_MODE -eq 1 ]]; then
+  python3 - <<PY
+import json, sys
+print(json.dumps({
+    "managed_drift": $cm_count,
+    "untracked_source": $untracked_count,
+    "orphan_deployed": $orphan_count,
+    "stale_source": $stale_count,
+    "total": $total
+}))
+PY
+  if ((total > 0)); then exit 1; else exit 0; fi
 fi
 
 ui_header "Dotfiles Drift Dashboard"
 
-status=$(chezmoi status || true)
-if [[ -z "$status" ]]; then
-  ui_ok "Clean" "no local drift detected"
-  exit 0
+# Class 1
+if ((cm_count > 0)); then
+  echo ""
+  ui_warn "Managed drift" "$cm_count file(s) — deployed differs from rendered source"
+  printf '%s\n' "$cm_status"
+else
+  ui_ok "Managed drift" "clean"
 fi
 
-echo ""
-ui_header "Changed files"
-printf '%s\n' "$status"
+# Class 2
+if ((untracked_count > 0)); then
+  echo ""
+  ui_warn "Untracked source" "$untracked_count file(s) in chezmoi source not tracked by git"
+  printf '%s\n' "$untracked"
+else
+  ui_ok "Untracked source" "clean"
+fi
+
+# Class 3
+if ((orphan_count > 0)); then
+  echo ""
+  ui_warn "Orphan deployed" "$orphan_count file(s) — review $(pretty_path "$orphan_file")"
+else
+  ui_ok "Orphan deployed" "clean"
+fi
+
+# Class 4
+if ((stale_count > 0)); then
+  echo ""
+  ui_warn "Stale source" "$stale_count target(s) newer than source — next \`chezmoi apply\` would revert"
+  printf '%s\n' "$stale_list"
+else
+  ui_ok "Stale source" "clean"
+fi
 
-count=$(printf '%s\n' "$status" | wc -l | tr -d ' ')
 echo ""
-ui_info "Total" "$count"
+if ((total > 0)); then
+  ui_warn "Total drift signals" "$total"
+else
+  ui_ok "Total" "no drift detected"
+fi
 
-if [[ "${DOTFILES_DRIFT_SHOW_DIFF:-0}" = "1" ]]; then
+if [[ "$SHOW_DIFF" = "1" && $cm_count -gt 0 ]]; then
   echo ""
-  ui_header "Diff (excluding scripts/install/tests)"
+  ui_header "chezmoi diff (excluding scripts/install/tests)"
   chezmoi diff --exclude scripts --exclude install --exclude tests || true
 fi
+
+((total > 0)) && exit 1 || exit 0

package/scripts/diagnostics/health.sh

@@ -420,16 +420,33 @@ check_config_directories() {
 check_sync_status() {
   check_section "Sync Status"
 
-  # Chezmoi status
+  # Chezmoi status. The two-character prefix encodes both directions:
+  #   col 1 = last-applied state vs actual    (was the file edited in
+  #                                            place since last apply?)
+  #   col 2 = actual state vs target          (what `chezmoi apply`
+  #                                            would still change)
+  # Only col 2 matters for "is $HOME out of sync with the source" —
+  # col 1 alone just means the source repo has uncommitted edits,
+  # which is normal during development and not something the user
+  # needs warned about via the health dashboard.
   if has_command chezmoi; then
     local status_output
     status_output=$(chezmoi status 2>/dev/null || echo "")
     if [[ -z "$status_output" ]]; then
       check "Chezmoi sync" "pass"
     else
-      local changes
-      changes=$(printf '%s\n' "$status_output" | wc -l | tr -d ' ')
-      check "Chezmoi sync" "warn" "$changes file(s) out of sync"
+      # Count only entries where column 2 is non-space (apply would do something).
+      local applicable
+      applicable=$(printf '%s\n' "$status_output" | awk 'substr($0,2,1)!=" "' | wc -l | tr -d ' ')
+      if [[ "$applicable" -eq 0 ]]; then
+        # All drift is source-only (unstaged edits in the source repo).
+        # That's not a sync issue; mention it but pass.
+        local source_only
+        source_only=$(printf '%s\n' "$status_output" | wc -l | tr -d ' ')
+        check "Chezmoi sync" "pass" "$source_only source-only edit(s) (run 'chezmoi diff' to inspect)"
+      else
+        check "Chezmoi sync" "warn" "$applicable file(s) out of sync"
+      fi
     fi
   else
     check "Chezmoi sync" "warn" "Not installed, skipped"

package/scripts/diagnostics/perf.sh

@@ -29,6 +29,9 @@ PROFILE=false
 RUNS=3
 TARGET_MS="${DOTFILES_PERF_TARGET_MS:-250}"
 MAX_MS="${DOTFILES_PERF_MAX_MS:-1000}"
+SHELL_FILTER=""
+BY_TOOL=false
+RESET_TIMINGS=false
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
@@ -48,20 +51,180 @@ while [[ $# -gt 0 ]]; do
       TARGET_MS="${2:-$TARGET_MS}"
       shift 2
       ;;
+    --shell | -s)
+      SHELL_FILTER="${2:-}"
+      shift 2
+      ;;
+    --by-tool)
+      BY_TOOL=true
+      shift
+      ;;
+    --reset)
+      RESET_TIMINGS=true
+      shift
+      ;;
+    --baseline)
+      # Write the current per-shell means to the baseline file so
+      # subsequent runs can warn on regression. Closes part of #863.
+      WRITE_BASELINE=true
+      shift
+      ;;
+    --no-baseline-check)
+      # Skip the baseline-vs-current comparison entirely. Useful for
+      # the very first run on a machine, or for short-lived CI.
+      NO_BASELINE_CHECK=true
+      shift
+      ;;
     *)
       shift
       ;;
   esac
 done
 
-time_shell_startup() {
-  local start end
+WRITE_BASELINE="${WRITE_BASELINE:-false}"
+NO_BASELINE_CHECK="${NO_BASELINE_CHECK:-false}"
+BASELINE_FILE="${XDG_CACHE_HOME:-$HOME/.cache}/dotfiles/perf-baseline.json"
+BASELINE_REGRESSION_PCT="${DOTFILES_PERF_REGRESSION_PCT:-10}"
+
+# --by-tool reader: aggregate $XDG_STATE_HOME/dotfiles/eval-timings.jsonl
+# (populated by _cached_eval when EVALCACHE_TIMING=1) and report which
+# tools dominate startup time. Independent of the runtime measurement
+# loop above, so it returns immediately.
+if $BY_TOOL || $RESET_TIMINGS; then
+  log_dir="${XDG_STATE_HOME:-$HOME/.local/state}/dotfiles"
+  log_file="$log_dir/eval-timings.jsonl"
+  if $RESET_TIMINGS; then
+    : >"$log_file" 2>/dev/null || rm -f "$log_file" 2>/dev/null || true
+    ui_ok "eval timings" "cleared $log_file"
+    $BY_TOOL || exit 0
+  fi
+  if [[ ! -s "$log_file" ]]; then
+    ui_warn "eval timings" "no data at $log_file"
+    echo "  Hint: open a new shell with EVALCACHE_TIMING=1 to start collecting." >&2
+    exit 0
+  fi
+  ui_dot_banner "Diagnostics"
+  ui_header "Per-tool timing breakdown"
+  ui_section "$log_file"
+  python3 - "$log_file" <<'PY'
+import json, sys
+from collections import defaultdict
+
+def percentile(sorted_vals, p):
+    """Linear-interpolation percentile, matching numpy.percentile defaults."""
+    if not sorted_vals:
+        return 0
+    if len(sorted_vals) == 1:
+        return sorted_vals[0]
+    k = (len(sorted_vals) - 1) * (p / 100.0)
+    f = int(k)
+    c = min(f + 1, len(sorted_vals) - 1)
+    if f == c:
+        return sorted_vals[f]
+    return sorted_vals[f] + (sorted_vals[c] - sorted_vals[f]) * (k - f)
+
+samples = defaultdict(list)        # label -> [ms, ms, ...]
+shells_by_label = defaultdict(set) # label -> {shell, ...}
+
+with open(sys.argv[1]) as f:
+    for line in f:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            ev = json.loads(line)
+        except Exception:
+            continue
+        label = ev.get("label", "?")
+        try:
+            ms = int(ev.get("ms", 0) or 0)
+        except (TypeError, ValueError):
+            continue
+        samples[label].append(ms)
+        shells_by_label[label].add(ev.get("shell", "?"))
+
+rows = []
+for label, vals in samples.items():
+    vals_sorted = sorted(vals)
+    rows.append({
+        "label":  label,
+        "count":  len(vals_sorted),
+        "total":  sum(vals_sorted),
+        "mean":   sum(vals_sorted) // max(len(vals_sorted), 1),
+        "min":    vals_sorted[0],
+        "max":    vals_sorted[-1],
+        "p50":    int(percentile(vals_sorted, 50)),
+        "p95":    int(percentile(vals_sorted, 95)),
+        "p99":    int(percentile(vals_sorted, 99)),
+        "shells": ",".join(sorted(shells_by_label[label])),
+    })
+
+rows.sort(key=lambda r: r["total"], reverse=True)
+header = (f"  {'label':<20} {'calls':>5} {'total':>8} "
+          f"{'mean':>7} {'p50':>5} {'p95':>5} {'p99':>5}  shells")
+print(header)
+print("  " + "-" * (len(header) - 2))
+for r in rows:
+    print(f"  {r['label']:<20} {r['count']:>5} {r['total']:>6}ms "
+          f"{r['mean']:>5}ms {r['p50']:>3}ms {r['p95']:>3}ms {r['p99']:>3}ms  {r['shells']}")
+PY
+  exit 0
+fi
+
+# Per-shell defaults. nu and pwsh are genuinely slower than POSIX shells;
+# bash should be quickest. Override via DOTFILES_PERF_TARGET_<SHELL>_MS.
+shell_target_for() {
+  case "$1" in
+    zsh) echo "${DOTFILES_PERF_TARGET_ZSH_MS:-$TARGET_MS}" ;;
+    bash) echo "${DOTFILES_PERF_TARGET_BASH_MS:-60}" ;;
+    fish) echo "${DOTFILES_PERF_TARGET_FISH_MS:-200}" ;;
+    nu) echo "${DOTFILES_PERF_TARGET_NU_MS:-500}" ;;
+    pwsh) echo "${DOTFILES_PERF_TARGET_PWSH_MS:-600}" ;;
+    *) echo "$TARGET_MS" ;;
+  esac
+}
+
+# Invoke a near-empty session for the named shell, picking flags that
+# load the user's interactive profile (matches what a fresh terminal does).
+invoke_shell() {
+  case "$1" in
+    zsh) zsh -i -c exit </dev/null ;;
+    bash) bash -i -c exit </dev/null ;;
+    fish) fish -i -c exit </dev/null ;;
+    nu) nu -c exit </dev/null ;;
+    pwsh) pwsh -Command exit </dev/null ;;
+    *) return 1 ;;
+  esac
+}
+
+time_one_run() {
+  local shell_name="$1" start end
   start=$(python3 -c 'import time; print(int(time.time() * 1000))')
-  zsh -i -c exit >/dev/null 2>&1
+  invoke_shell "$shell_name" >/dev/null 2>&1 || true
   end=$(python3 -c 'import time; print(int(time.time() * 1000))')
   echo $((end - start))
 }
 
+# Existing single-shell helper retained for backward compatibility with
+# callers/tests that reference time_shell_startup; routes to time_one_run.
+time_shell_startup() { time_one_run zsh; }
+
+# Measure a shell across $RUNS iterations, return "mean min max".
+measure_shell() {
+  local shell_name="$1" sum=0 min=999999 max=0 t
+  local times=()
+  # One warm-up run discarded — caches a $_SHELL_CACHE on first invocation.
+  invoke_shell "$shell_name" >/dev/null 2>&1 || true
+  for _ in $(seq 1 "$RUNS"); do
+    t=$(time_one_run "$shell_name")
+    times+=("$t")
+    sum=$((sum + t))
+    [[ "$t" -lt "$min" ]] && min="$t"
+    [[ "$t" -gt "$max" ]] && max="$t"
+  done
+  echo "$((sum / RUNS)) $min $max"
+}
+
 calc_score() {
   local mean_ms="$1"
   if [[ "$mean_ms" -le "$TARGET_MS" ]]; then
@@ -86,95 +249,159 @@ run_profile() {
   ' 2>/dev/null | head -20
 }
 
-if $JSON_OUTPUT; then
-  times=()
-  for _ in $(seq 1 "$RUNS"); do
-    times+=("$(time_shell_startup)")
+# Discover installed shells. SHELL_FILTER (--shell <name>) restricts to one.
+all_shells=(zsh bash fish nu pwsh)
+shells_to_measure=()
+for s in "${all_shells[@]}"; do
+  command -v "$s" >/dev/null 2>&1 || continue
+  if [[ -n "$SHELL_FILTER" && "$s" != "$SHELL_FILTER" ]]; then
+    continue
+  fi
+  shells_to_measure+=("$s")
+done
+if ((${#shells_to_measure[@]} == 0)); then
+  ui_err "perf" "no measurable shells found${SHELL_FILTER:+ (filter: $SHELL_FILTER)}"
+  exit 1
+fi
+
+# Measure each shell once into parallel arrays.
+declare -a shell_names shell_means shell_mins shell_maxs shell_targets shell_passes
+for s in "${shells_to_measure[@]}"; do
+  read -r m mn mx <<<"$(measure_shell "$s")"
+  t=$(shell_target_for "$s")
+  shell_names+=("$s")
+  shell_means+=("$m")
+  shell_mins+=("$mn")
+  shell_maxs+=("$mx")
+  shell_targets+=("$t")
+  if [[ "$m" -le "$t" ]]; then
+    shell_passes+=("1")
+  else
+    shell_passes+=("0")
+  fi
+done
+
+# Primary "score" continues to use the zsh measurement (when available)
+# so existing dashboards / JSON consumers keep their reference number.
+mean=0
+for i in "${!shell_names[@]}"; do
+  if [[ "${shell_names[$i]}" == "zsh" ]]; then
+    mean="${shell_means[$i]}"
+    break
+  fi
+done
+[[ "$mean" -eq 0 && "${#shell_means[@]}" -gt 0 ]] && mean="${shell_means[0]}"
+score=$(calc_score "$mean")
+
+# -----------------------------------------------------------------------------
+# Baseline persistence + regression detection (closes part of #863).
+# Stored at $XDG_CACHE_HOME/dotfiles/perf-baseline.json. The file is a
+# JSON object mapping shell name → recorded mean (ms). `--baseline`
+# overwrites it with the current measurement; default behavior reads
+# it (if present) and warns when any shell regresses by more than
+# DOTFILES_PERF_REGRESSION_PCT (default 10%).
+# -----------------------------------------------------------------------------
+
+declare -a baseline_warnings=()
+if $WRITE_BASELINE; then
+  mkdir -p "$(dirname "$BASELINE_FILE")"
+  {
+    printf '{\n  "recorded_at": "%s",\n  "regression_pct": %d,\n  "shells": {' \
+      "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$BASELINE_REGRESSION_PCT"
+    for i in "${!shell_names[@]}"; do
+      [[ "$i" -gt 0 ]] && printf ','
+      printf '\n    "%s": %d' "${shell_names[$i]}" "${shell_means[$i]}"
+    done
+    printf '\n  }\n}\n'
+  } >"$BASELINE_FILE"
+fi
+
+if ! $NO_BASELINE_CHECK && [[ -s "$BASELINE_FILE" ]]; then
+  # Read the baseline and compare each measured shell.
+  for i in "${!shell_names[@]}"; do
+    name="${shell_names[$i]}"
+    m="${shell_means[$i]}"
+    baseline_ms=$(python3 -c '
+import json, sys
+try:
+    d = json.load(open(sys.argv[1]))
+    print(d.get("shells", {}).get(sys.argv[2], 0))
+except Exception:
+    print(0)
+' "$BASELINE_FILE" "$name" 2>/dev/null)
+    [[ -z "$baseline_ms" || "$baseline_ms" -eq 0 ]] && continue
+    # Threshold: current > baseline * (1 + pct/100)
+    threshold=$((baseline_ms * (100 + BASELINE_REGRESSION_PCT) / 100))
+    if ((m > threshold)); then
+      delta_pct=$((((m - baseline_ms) * 100) / baseline_ms))
+      baseline_warnings+=("$name: $m ms vs baseline $baseline_ms ms (+${delta_pct}%, threshold +${BASELINE_REGRESSION_PCT}%)")
+    fi
   done
-  sum=0
-  min=999999
-  max=0
-  for t in "${times[@]}"; do
-    sum=$((sum + t))
-    if [[ "$t" -lt "$min" ]]; then min="$t"; fi
-    if [[ "$t" -gt "$max" ]]; then max="$t"; fi
+fi
+
+if $JSON_OUTPUT; then
+  printf '{\n  "runs": %d,\n  "target_ms": %d,\n  "max_ms_target": %d,\n  "score": %d,\n  "mean_ms": %d,\n  "regression_count": %d,\n  "shells": {' \
+    "$RUNS" "$TARGET_MS" "$MAX_MS" "$score" "$mean" "${#baseline_warnings[@]}"
+  for i in "${!shell_names[@]}"; do
+    [[ "$i" -gt 0 ]] && printf ','
+    printf '\n    "%s": {"mean_ms": %d, "min_ms": %d, "max_ms": %d, "target_ms": %d, "pass": %s}' \
+      "${shell_names[$i]}" "${shell_means[$i]}" "${shell_mins[$i]}" "${shell_maxs[$i]}" \
+      "${shell_targets[$i]}" "$([[ ${shell_passes[$i]} == 1 ]] && echo true || echo false)"
   done
-  mean=$((sum / RUNS))
-  score=$(calc_score "$mean")
-  cat <<JSON
-{
-  "mean_ms": $mean,
-  "min_ms": $min,
-  "max_ms": $max,
-  "runs": $RUNS,
-  "target_ms": $TARGET_MS,
-  "max_ms_target": $MAX_MS,
-  "score": $score
-}
-JSON
+  printf '\n  }'
+  if [[ "${#baseline_warnings[@]}" -gt 0 ]]; then
+    printf ',\n  "regressions": ['
+    for i in "${!baseline_warnings[@]}"; do
+      [[ "$i" -gt 0 ]] && printf ','
+      # JSON-escape the warning text minimally (no embedded quotes expected).
+      printf '\n    "%s"' "${baseline_warnings[$i]}"
+    done
+    printf '\n  ]'
+  fi
+  printf '\n}\n'
   exit 0
 fi
 
 ui_dot_banner "Diagnostics"
 ui_header "Shell Performance"
 
-ui_section "Startup timing"
+ui_section "Per-shell startup ($RUNS runs each, after one warm-up)"
 
-times=()
-for _ in $(seq 1 "$RUNS"); do
-  times+=("$(time_shell_startup)")
-done
-sum=0
-min=999999
-max=0
-for t in "${times[@]}"; do
-  sum=$((sum + t))
-  if [[ "$t" -lt "$min" ]]; then min="$t"; fi
-  if [[ "$t" -gt "$max" ]]; then max="$t"; fi
-  if [[ "$UI_ENABLED" = "1" ]]; then
-    ui_kv "Run" "${t}ms"
+# Aligned table: name (6) | mean (8) | min/max (16) | target (12) | status
+for i in "${!shell_names[@]}"; do
+  name="${shell_names[$i]}"
+  m="${shell_means[$i]}"
+  mn="${shell_mins[$i]}"
+  mx="${shell_maxs[$i]}"
+  t="${shell_targets[$i]}"
+  if [[ "${shell_passes[$i]}" == "1" ]]; then
+    status_marker="✓"
+    detail=""
   else
-    echo "  Run: ${t}ms"
+    status_marker="✗"
+    detail=" — over by $((m - t))ms"
   fi
+  printf '  %s %-6s mean %4dms  (min %3dms, max %3dms)  target %4dms%s\n' \
+    "$status_marker" "$name" "$m" "$mn" "$mx" "$t" "$detail"
 done
-mean=$((sum / RUNS))
-score=$(calc_score "$mean")
 
-if [[ "$UI_ENABLED" = "1" ]]; then
-  ui_kv "Average" "${mean}ms"
-  ui_kv "Min" "${min}ms"
-  ui_kv "Max" "${max}ms"
-  ui_kv "Target" "${TARGET_MS}ms"
-  ui_kv "Score" "${score}/100"
-else
-  echo "  Average: ${mean}ms"
-  echo "  Min:     ${min}ms"
-  echo "  Max:     ${max}ms"
-  echo "  Target:  ${TARGET_MS}ms"
-  echo "  Score:   ${score}/100"
+# Baseline comparison summary
+if [[ "${#baseline_warnings[@]}" -gt 0 ]]; then
+  ui_section "Baseline regressions"
+  for w in "${baseline_warnings[@]}"; do
+    printf '  ✗ %s\n' "$w"
+  done
+  printf '  (threshold: >%s%% over the recorded baseline at %s)\n' \
+    "$BASELINE_REGRESSION_PCT" "$BASELINE_FILE"
+elif [[ -s "$BASELINE_FILE" ]] && ! $NO_BASELINE_CHECK; then
+  ui_section "Baseline"
+  printf '  ✓ all measured shells within %s%% of baseline (%s)\n' \
+    "$BASELINE_REGRESSION_PCT" "$BASELINE_FILE"
+elif $WRITE_BASELINE; then
+  ui_section "Baseline"
+  printf '  ✓ wrote baseline to %s\n' "$BASELINE_FILE"
 fi
 
-# Per-shell startup comparison
-ui_section "Per-shell startup"
-
-for shell_name in zsh bash fish; do
-  if command -v "$shell_name" >/dev/null 2>&1; then
-    local_start=$(python3 -c 'import time; print(int(time.time() * 1000))')
-    if [[ "$shell_name" == "fish" ]]; then
-      fish -c exit >/dev/null 2>&1 || true
-    else
-      "$shell_name" -i -c exit >/dev/null 2>&1 || true
-    fi
-    local_end=$(python3 -c 'import time; print(int(time.time() * 1000))')
-    shell_time=$((local_end - local_start))
-    if [[ "$UI_ENABLED" = "1" ]]; then
-      ui_kv "$shell_name" "${shell_time}ms"
-    else
-      echo "  $shell_name: ${shell_time}ms"
-    fi
-  fi
-done
-
 # Per-component breakdown (Zsh only, uses DOTFILES_DEBUG timing)
 ui_section "Component breakdown (estimated)"
 for component in "bare zsh" "paths+env" "aliases" "functions" "tools"; do