# Managing background processes — READ THIS before you `kill` anything

You may start and stop background processes while iterating — a **server**, a long **build** or
**training run**, or an **ncu / nsys profiling** session. **The way you stop one can silently kill
*your own agent process* and end the whole run.** This has happened repeatedly, including via a
hand-rolled `/proc` scan — not just `pkill`. Read this once and follow the safe recipe.

## The trap: matching task text against process command lines

You were launched as roughly:

```
claude --print -- '<the entire task instruction text>'
```

The full task instruction is on **your own** process's command line, and it contains the file names
and commands the task mentions (e.g. `server.py`, `build.sh`, `train.py`, `solution.cu`, `/app/...`).
So **any** command that finds processes by matching those strings will match — and can kill — **the
agent itself**:

```
pkill -9 -f "train.py"                              # matches the claude agent -> kills YOU
pgrep -f "server.py" | xargs kill                   # same: the pid list includes claude
for p in $(pgrep -f build.sh); do kill -9 $p; done  # same
for pid in /proc/*; do case "$(cmdline)" in *solution*) kill -9 $pid;; esac; done   # same
```

It is **not about `pkill`** — it is about **matching a string that appears in your prompt**. `pgrep`,
a `/proc` scan, `fuser`, or `nvidia-smi`-pid loops all have the same failure if the match pattern (or
the surviving pid list) includes the `claude` process. When you `kill -9` yourself the run dies
immediately (`NonZeroAgentExitCodeError`) and you are graded on whatever was already in place — usually
worse than what you were about to finish.

## The one safe rule: kill only the exact PID you recorded

**Start** a background job and record its PID in a file:

```bash
nohup <your command> > /tmp/job.log 2>&1 &
echo $! > /tmp/job.pid
```

**Stop / restart** by that exact PID — never by a name pattern:

```bash
kill "$(cat /tmp/job.pid)" 2>/dev/null      # SIGTERM: lets it release the GPU / flush cleanly
sleep 3
kill -9 "$(cat /tmp/job.pid)" 2>/dev/null   # force only if it did not exit
```

If the job spawns workers, run it in its own process group and signal the group by its (negative)
PGID — still an exact id, never a pattern:

```bash
setsid <your command> > /tmp/job.log 2>&1 < /dev/null & echo $! > /tmp/job.pid
kill -TERM -- "-$(cat /tmp/job.pid)" 2>/dev/null
```

## If you ever enumerate processes, EXCLUDE the agent

Prefer not to. But if you must scan (e.g. hunting a leaked worker), **exclude the `claude` agent and
your own shell**, and match on a **unique token that is NOT anywhere in this prompt** — give your job
a unique name and match only that:

```bash
# job named e.g. job_7x3q9 — a token that appears NOWHERE in the task text
pgrep -af job_7x3q9 | grep -v -E 'claude|--print|pgrep|grep|bash'   # LOOK FIRST
# only kill pids from THIS filtered list, and never a pid whose cmdline contains 'claude' or '--print'
```

Do **not** add a prompt word (a file name, `/app`, `python3`, …) to the pattern "just in case" — that
single addition re-introduces the self-kill. Match the unique token **only**.

## Freeing the GPU without going nuclear

If VRAM stays high after you stop a GPU job, the usual cause is a **child process** or a not-yet-
collected CUDA context — not a stray process you need to hunt across `/proc`. Do this instead of a
`/proc` sweep:

- Kill the job **by its recorded PID / PGID** (above) and `sleep 5–10`; the CUDA context frees after
  the process fully exits.
- Make the job release cleanly on `SIGTERM` (drop the model / `torch.cuda.empty_cache()` / exit) so a
  single `kill $PID` is enough.
- Start it in its own group (`setsid`) so `kill -- -$PGID` takes the workers with it.
- Check with `nvidia-smi` — if a PID still holds memory, `kill` **that exact numeric PID**, after
  confirming its cmdline is **not** `claude` / `--print`.

## Rules of thumb

- **Never** match a task-prompt string (`server.py`, `train.py`, `build.sh`, `/app`, `python3`, …)
  with `pkill -f`, `pgrep -f`, `killall`, `fuser`, or a `/proc` cmdline scan — they all can hit the
  agent (its argv holds the prompt).
- **Always** kill a background job by the exact PID from its pidfile (or its PGID).
- If you must enumerate, match a **unique token not in the prompt** and **exclude `claude` / `--print`
  and your own shell**; `pgrep -af` and look before you kill.
- `SIGTERM` first for a clean release; `-9` only as a last resort on a specific numeric PID.