Ctrl-C runs neither teardown under `--parallel`

[Chemaclass]

Q	A
OS	macOS 26.5.2 (arm64)
Shell & version	bash 3.2.57
bashunit version	0.50.0 (main @ e1b9de0)

Summary

Under --parallel, Ctrl-C runs neither the per-test tear_down nor the file's tear_down_after_script. Both are skipped, so everything the interrupted file and its tests acquired is leaked.

#1323 fixed the sequential half of this. Its fix cannot reach the parallel case, and the reason is structural rather than an oversight, so this is tracked on its own.

Current behavior

bashunit::main::cleanup sends pkill -P $$. The file's worker is a { ... } & group with no trap, so it dies on the spot: neither the test bodies inside it nor the tear_down_after_script after them get to run.

The parent has nothing to settle either. Since #1320 the worker owns the file hook, so the parent clears the pending-teardown debt right after dispatch.

How to reproduce

interrupted_test.sh:

function set_up_before_script() { : >"$M.setupfile"; }
function tear_down_after_script() { : >"$M.RAN_FILE_TEARDOWN"; }
function set_up() { : >"$M.setuptest"; }
function tear_down() { : >"$M.RAN_TEST_TEARDOWN"; }
function test_slow() { sleep 10; assert_true true; }

The signal has to reach a bashunit whose SIGINT disposition is still the default. A shell that backgrounds a job sets SIGINT to SIG_IGN in the child, and bash can neither trap nor reset a signal ignored on entry, so the run is launched through perl:

$ M=/tmp/bu-p perl -e '$SIG{INT}="DEFAULT"; exec @ARGV' \
 ./bashunit --parallel interrupted_test.sh &
$ sleep 3; kill -INT $!

$ ls /tmp/bu-p.*
/tmp/bu-p.setupfile
/tmp/bu-p.setuptest

Neither RAN_ marker exists. The same run under --no-parallel produces both.

Expected behavior

Ctrl-C releases what an interrupted --parallel run acquired, as it now does sequentially: the per-test tear_down for a test in flight, and the file's tear_down_after_script.

Where it happens

• src/main/run.sh:382: bashunit::main::cleanup runs pkill -P $$, then settles the parent's pending file teardown, which under --parallel is always empty
• src/runner/discovery.sh:231-243: the worker group that owns the file hook since tear_down_after_script runs before the file's tests under --parallel #1320
• src/runner/discovery.sh:250: the parent drops the debt right after dispatch

Acceptance criteria

• An interrupted --parallel run releases the file-scoped resource, and the per-test resource for a test in flight.
• No hook runs twice when the interrupt lands while the worker is already inside its teardown.
• Ctrl-C still prints "Caught Ctrl-C, killing all child processes...", still exits 1, and still returns promptly. A hook that never returns must not make the interrupt unescapable.
• A deterministic test. Delivering SIGINT to a real run depends on job control and on which frame the shell is in when it lands, which is not reproducible under a loaded --parallel suite: an acceptance test doing that failed 2 runs in 3 while Ctrl-C does not run tear_down_after_script for the file in flight #1323 was being written. tests/unit/main/cleanup_test.sh is the shape that worked, exercising the handler body with the killing and sweeping calls shadowed.
• CHANGELOG.md gets a Fixed entry.

Notes for the implementer

• The parent cannot do this. Several files are in flight at once under --parallel, and each file's hook is unset and redefined as the loop advances (clean_set_up_and_tear_down_after_script), so by interrupt time the parent no longer holds the right function body. It belongs in the worker.
• A trap inside the worker group is the shape: it still holds its own copy of the file's functions, and it is the frame that owns the hook. Both TERM (what pkill sends) and INT need covering, since a terminal delivers INT to the whole foreground group.
• Per-test tear_down already survives a plain pkill sequentially, through the test subshell's EXIT trap (src/runner/hooks.sh:37). Under --parallel that subshell is a grandchild of the runner, so pkill -P $$ never reaches it. Whatever kills the worker has to pass the signal down.
• Bounding matters here as it did in Ctrl-C does not run tear_down_after_script for the file in flight #1323: src/main/run.sh resets SIGINT to its default disposition before running user code, so a second Ctrl-C ends the process rather than being swallowed by the handler.
• Bash 3.0+ only. See .claude/rules/bash-style.md.
• make sa, make lint, ./bashunit tests/, ./bashunit --parallel tests/.

[Chemaclass]

Done in #1336 (merged).