Bug: Linux drop_caches fires unconditionally — defeats the tool's purpose on dev machines

The macOS branch correctly gates purge on actual memory pressure:

if (( pressure < 30 || swap > 200 )) && sudo -n true 2>/dev/null; then

The Linux/WSL branch has no such guard — it drops all page cache, inodes, and dentries on every --clean run as long as sudo -n succeeds. On a developer machine in the middle of a build or with a large open codebase, echo 3 > /proc/sys/vm/drop_caches forces the kernel to evict all cached file data, causing the next git grep, make, or IDE file-watcher pass to repopulate the cache from disk — potentially making the machine measurably slower for several minutes after the "speedup" run.

Suggested fix — apply the same pressure threshold as macOS:

elif $IS_LINUX || $IS_WSL; then
  local pressure swap
  pressure=${MEM_pressure_pct:-100}
  swap=${MEM_swap_mb:-0}
  pressure=$(echo "$pressure" | awk -F. '{print int($1+0)}')
  swap=$(echo "$swap" | awk -F. '{print int($1+0)}')
  if (( pressure < 30 || swap > 200 )) && sudo -n true 2>/dev/null; then
    sync; echo 3 | sudo tee /proc/sys/vm/drop_caches >/dev/null 2>&1 || true
    echo "  ${GRN}✓${RST} Memory caches dropped (pressure=${pressure}% free, swap=${swap}MB)"
  fi
fi

Note: MEM_pressure_pct on Linux is already the free percentage (avail * 100 / total), so the < 30 threshold matches the macOS semantics.

Run power-hog probe for cleanup modes

action_kill_hogs tries to terminate entries from POWER_HOGS_FILE, but run_parallel_scan only launches probe_power_hogs when MODE_SCAN is true. Standard cleanup paths (--clean, --deep, --aggressive) set MODE_CLEAN without MODE_SCAN, so no power-hog file is produced and power-hog termination is silently skipped in the modes where killing hogs is expected.

Useful? React with 👍 / 👎.

Include hog probe results in scan JSON

--scan is documented and consumed as the full probe payload, but emit_json serializes disk/memory/network/startup only and omits cpu_hogs/power_hogs/gpu data entirely. That means downstream automation cannot render or act on top hog lists from scan output, despite run_parallel_scan collecting those probe files.

Useful? React with 👍 / 👎.

Read telemetry from the correct Linux state path

This command hardcodes ~/.ops-speedup/history.jsonl, but the binary writes Linux/WSL state under ${XDG_STATE_HOME:-$HOME/.local/state}/ops-speedup (it only uses ~/.ops-speedup on macOS). On Linux/WSL, trend analysis will look at the wrong file and report missing/empty history.

Useful? React with 👍 / 👎.

declare -g breaks on macOS stock bash 3.2

High Severity

declare -g requires bash 4.2+ but macOS ships bash 3.2 (GPLv3 licensing freeze). Inside run_parallel_scan(), all four declare -g calls will error on stock macOS bash, leaving every DISK_*, MEM_*, NET_*, and STARTUP_* variable unset. This causes emit_json to emit all-default values and, more critically, action_memory_purge to always trigger (MEM_pressure_pct defaults to 0, satisfying pressure < 30). Consider printf -v (available since bash 3.1) or direct assignment with eval (key is already validated).

 

^{Reviewed by Cursor Bugbot for commit b877e87. Configure here.}

Linux memory purge ignores pressure/swap thresholds

Medium Severity

On macOS, action_memory_purge gates the purge on pressure < 30 || swap > 200. On Linux/WSL, drop_caches runs unconditionally whenever sudo is cached — no pressure or swap check. This contradicts the PR's test plan ("Memory purge fires when swap > 200MB OR pressure < 30% free") and causes unnecessary filesystem cache eviction on every --clean run, degrading I/O performance for no benefit when memory is healthy.

 

^{Reviewed by Cursor Bugbot for commit b877e87. Configure here.}

Process killing runs in documented non-destructive mode

Medium Severity

action_kill_hogs is called during --clean mode, which the SKILL.md CLI reference table documents as having "Non-destructive" side effects ("Safe cleanup: caches, tmp, logs, demote daemons, DNS flush, kernel tune"). Sending SIGTERM to processes exceeding 30% CPU is destructive and could terminate user workloads. This action fits better in the --deep or --aggressive mode gate.

 

^{Reviewed by Cursor Bugbot for commit b877e87. Configure here.}

Unused num helper function is dead code

Low Severity

The num() helper function is defined but never called anywhere in the script. A grep for its usage returns only the definition. This is dead code that adds clutter without serving any purpose.

 

^{Reviewed by Cursor Bugbot for commit b877e87. Configure here.}

🔴 --clean mode kills CPU hog processes despite being documented as "Non-destructive"

action_kill_hogs is called at line 714 inside the $MODE_CLEAN block. This function sends SIGTERM to processes identified as CPU hogs (claude-ops/bin/ops-speedup:436). Both the script header (line 9: "safe cleanup (caches, tmp, logs)") and the SKILL.md (line 38: "Safe cleanup: caches, tmp, logs, demote daemons, DNS flush, kernel tune | Non-destructive") explicitly document --clean as non-destructive. Killing processes contradicts this contract. Additionally, the SKILL.md Phase 4 maps the "Quick" option directly to --clean, so users selecting "Quick — caches, tmp, logs, DNS flush" will have processes killed without any indication this would happen.

The action_kill_hogs call on line 714 is inside the MODE_CLEAN block but --clean is documented as non-destructive. Similarly, action_clean_package_managers (line 713) and action_memory_purge (line 718) are not part of --clean's documented scope.

The --clean block (lines 710-731) should be restructured so that only the documented actions run in --clean mode, and the extra actions (kill hogs, package manager cleanup including docker prune, memory purge) are moved into the MODE_DEEP block.

Suggested restructure for lines 710-726:
  if MODE_CLEAN:
    action_clean_caches
    action_demote_background
    action_kernel_tune
    action_dns_flush
  if MODE_DEEP:
    action_clean_package_managers  (including brew, docker)
    action_clean_deep
    action_launch_offenders
    action_animation_cuts
    action_kill_hogs
    action_memory_purge
  if MODE_AGGRESSIVE:
    action_clean_stale_builds

This aligns the code with the header comment (line 10: --deep adds docker prune, brew cleanup) and the SKILL.md contract.

Was this helpful? React with 👍 or 👎 to provide feedback.

🔴 --clean runs docker system prune -f and brew cleanup — documented as --deep features

action_clean_package_managers() is called at line 713 inside the $MODE_CLEAN block. This function runs docker system prune -f (claude-ops/bin/ops-speedup:374) which permanently removes stopped containers, dangling images, and unused networks, and brew cleanup -s --prune=all (claude-ops/bin/ops-speedup:358). The script's own header comment on line 10 explicitly states --deep adds "docker prune, brew cleanup", and the SKILL.md line 38 says --clean is "Non-destructive". Docker prune destroys data that cannot be recovered. This also conflicts with CLAUDE.md Rule 5 which requires confirmation for "Purging container images (ECR, Docker)".

Move the action_clean_package_managers call from the MODE_CLEAN block (line 713) into the MODE_DEEP block (after line 719). This aligns with the header comment on line 10 which says --deep adds docker prune and brew cleanup, and with the SKILL.md which documents --clean as Non-destructive.

The function action_clean_package_managers at line 355 includes docker system prune -f (line 374) and brew cleanup -s --prune=all (line 358). Both are destructive operations that should only run in --deep or --aggressive mode.

Was this helpful? React with 👍 or 👎 to provide feedback.

🔴 Linux action_memory_purge drops page caches unconditionally — missing pressure guard

On Linux/WSL (lines 586-590), action_memory_purge unconditionally writes 3 to /proc/sys/vm/drop_caches whenever passwordless sudo is available, with no check on actual memory pressure. The macOS path (line 582) properly guards the purge with (( pressure < 30 || swap > 200 )). Dropping all page caches, dentries, and inodes on a system with healthy memory pressure degrades I/O performance significantly, as subsequent file reads must hit disk. This runs in --clean mode which is documented as "Non-destructive".

Was this helpful? React with 👍 or 👎 to provide feedback.