@sebastienrousseau/dotfiles 0.2.500 → 0.2.502

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

package/scripts/diagnostics/workstation-attestation.sh

@@ -9,6 +9,9 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_ROOT="${REPO_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
+# Export so child processes (the mcp-doctor subprocess below) inherit it
+# without the env-prefix dance that confuses shellcheck (SC2097/SC2098).
+export REPO_ROOT
 
 # shellcheck source=../dot/lib/ui.sh
 source "$SCRIPT_DIR/../dot/lib/ui.sh"
@@ -91,7 +94,9 @@ if [[ -z "$current_profile" ]] && [[ -f "$agent_profile_file" ]]; then
   current_profile="$(jq -r '.defaultProfile // "ask"' "$agent_profile_file")"
 fi
 
-mcp_summary="$(REPO_ROOT="$REPO_ROOT" MCP_CONFIG="$REPO_ROOT/dot_config/claude/mcp_servers.json" bash "$REPO_ROOT/scripts/diagnostics/mcp-doctor.sh" --strict --json)"
+MCP_CONFIG="$REPO_ROOT/dot_config/claude/mcp_servers.json"
+export MCP_CONFIG
+mcp_summary="$(bash "$REPO_ROOT/scripts/diagnostics/mcp-doctor.sh" --strict --json)"
 
 attestation_json="$(
   jq -n \

package/scripts/dot/commands/agent.sh

@@ -76,11 +76,20 @@ _agent_checkpoint_file() {
 _agent_apply_profile_env() {
   local name="$1"
   export DOT_AGENT_PROFILE="$name"
-  export DOT_AGENT_APPROVAL="$(_agent_profile_field "$name" "approval")"
-  export DOT_AGENT_FILESYSTEM="$(_agent_profile_field "$name" "filesystem")"
-  export DOT_AGENT_NETWORK="$(_agent_profile_field "$name" "network")"
-  export DOT_AGENT_MCP_PROFILE="$(_agent_profile_field "$name" "mcpProfile")"
-  export DOT_AGENT_MAX_STEPS="$(_agent_profile_field "$name" "maxSteps")"
+  # Split declare-and-assign to avoid masking the field-getter's exit
+  # code (SC2155). If the profile JSON is malformed, the assignment
+  # now fails the function instead of silently exporting an empty value.
+  local approval filesystem network mcp_profile max_steps
+  approval="$(_agent_profile_field "$name" "approval")"
+  filesystem="$(_agent_profile_field "$name" "filesystem")"
+  network="$(_agent_profile_field "$name" "network")"
+  mcp_profile="$(_agent_profile_field "$name" "mcpProfile")"
+  max_steps="$(_agent_profile_field "$name" "maxSteps")"
+  export DOT_AGENT_APPROVAL="$approval"
+  export DOT_AGENT_FILESYSTEM="$filesystem"
+  export DOT_AGENT_NETWORK="$network"
+  export DOT_AGENT_MCP_PROFILE="$mcp_profile"
+  export DOT_AGENT_MAX_STEPS="$max_steps"
 }
 
 _agent_rbac_enforcement() {
@@ -209,14 +218,15 @@ EOF
       checkpoint_id="$(basename "$checkpoint_file" .json)"
       ui_info "Agent mode" "$name"
       dot_agent_session_log "run_start" "$name" "running" "argv=$*" "checkpoint_id=$checkpoint_id"
-      set +e
-      "$@"
-      local exit_code=$?
-      set -e
-      if [[ "$exit_code" -eq 0 ]]; then
-        dot_agent_session_log "run_finish" "$name" "ok" "exit_code=$exit_code" "checkpoint_id=$checkpoint_id"
-      else
+      # `if !` instead of `set +e / "$@" / set -e` — bash's errexit
+      # is automatically suspended inside a conditional, so we capture
+      # the exit code cleanly without toggling shell options.
+      local exit_code=0
+      if ! "$@"; then
+        exit_code=$?
         dot_agent_session_log "run_finish" "$name" "failed" "exit_code=$exit_code" "checkpoint_id=$checkpoint_id"
+      else
+        dot_agent_session_log "run_finish" "$name" "ok" "exit_code=$exit_code" "checkpoint_id=$checkpoint_id"
       fi
       return "$exit_code"
       ;;
@@ -326,14 +336,12 @@ EOF
           [[ "${#replay_argv[@]}" -gt 0 ]] || die "Checkpoint has no replayable command: $checkpoint_id"
           _agent_apply_profile_env "$replay_profile"
           dot_agent_session_log "checkpoint_replay" "$replay_profile" "running" "checkpoint_id=$checkpoint_id"
-          set +e
-          "${replay_argv[@]}"
-          local exit_code=$?
-          set -e
-          if [[ "$exit_code" -eq 0 ]]; then
-            dot_agent_session_log "checkpoint_replay_finish" "$replay_profile" "ok" "checkpoint_id=$checkpoint_id" "exit_code=$exit_code"
-          else
+          local exit_code=0
+          if ! "${replay_argv[@]}"; then
+            exit_code=$?
             dot_agent_session_log "checkpoint_replay_finish" "$replay_profile" "failed" "checkpoint_id=$checkpoint_id" "exit_code=$exit_code"
+          else
+            dot_agent_session_log "checkpoint_replay_finish" "$replay_profile" "ok" "checkpoint_id=$checkpoint_id" "exit_code=$exit_code"
           fi
           return "$exit_code"
           ;;
@@ -373,16 +381,14 @@ EOF
       export DOT_AGENT_PARENT_PROFILE="$current_profile"
       dot_agent_session_log "delegate_start" "$delegate_profile" "running" "delegate=$delegate_name" "parent=$current_profile" "timeout=$delegate_timeout"
       ui_info "Delegating" "$delegate_name (profile: $delegate_profile, timeout: ${delegate_timeout}s)"
-      set +e
-      timeout "$delegate_timeout" "$@"
-      local exit_code=$?
-      set -e
-      if [[ "$exit_code" -eq 0 ]]; then
-        dot_agent_session_log "delegate_finish" "$delegate_profile" "ok" "delegate=$delegate_name" "exit_code=$exit_code"
-        ui_ok "Delegate" "$delegate_name completed"
-      else
+      local exit_code=0
+      if ! timeout "$delegate_timeout" "$@"; then
+        exit_code=$?
         dot_agent_session_log "delegate_finish" "$delegate_profile" "failed" "delegate=$delegate_name" "exit_code=$exit_code"
         ui_err "Delegate" "$delegate_name failed (exit $exit_code)"
+      else
+        dot_agent_session_log "delegate_finish" "$delegate_profile" "ok" "delegate=$delegate_name" "exit_code=$exit_code"
+        ui_ok "Delegate" "$delegate_name completed"
       fi
       return "$exit_code"
       ;;