GPT took 14 seconds to answer a question about cleaning up orphaned child processes in bash, against its usual 25 seconds.

An orphan is not a zombie: once its parent dies, it is reparented, and Bash can no longer reliably identify it by its original parent. The idiomatic Bash approach is therefore to track children and terminate them during parent cleanup:

#!/usr/bin/env bash
set -Eeuo pipefail

children=()

cleanup() {
    status=$?
    trap - EXIT HUP INT TERM

    if ((${#children[@]})); then
        kill -TERM "${children[@]}" 2>/dev/null || :
        wait "${children[@]}" 2>/dev/null || :
    fi

    exit "$status"
}

trap cleanup EXIT
trap 'exit 129' HUP
trap 'exit 130' INT
trap 'exit 143' TERM

worker_one &
children+=("$!")

worker_two &
children+=("$!")

wait

Important limitations:

• •Traps do not run if the parent receives SIGKILL, crashes severely, or the machine loses power.
• •Killing direct child PIDs does not necessarily kill grandchildren.
• •Avoid trap 'kill 0' EXIT; it signals the entire current process group and may kill the invoking shell or unrelated processes.

If cleanup must also work after an untrappable parent death, use an OS-level mechanism rather than pure Bash:

• •Linux: have each child set prctl(PR_SET_PDEATHSIG, SIGTERM) before exec—usually via a small C wrapper or a suitable utility.
• •systemd: run the workload as a service/scope with KillMode=control-group; systemd will clean up the whole cgroup.
• •Containers/cgroups: place the workload in its own cgroup and terminate the cgroup.
• •Process groups: useful for descendants, but require an external supervisor to kill the group if the group leader itself dies.

For production supervision, systemd or another process supervisor is generally the most reliable and idiomatic solution.