diag: SIGABRT watchdog on CI test hang so backtrace survives

v0.255.9 fixed one real bug at transient-survives-gc-yield (use-
after-free reproducible locally under ASan), but mino's CI matrix
still hangs at the same test on macos-14 / ubuntu-24.04{,-arm}.
Without a stack trace from the hung process we can't tell whether
mino is in a tight loop, a pthread cv_wait, a GC mark-stack drain,
or somewhere else.

.github/workflows/ci.yml's Test step now wraps `./mino tests/
run.clj` in a watchdog:

* Streams stderr to /tmp/test_trace.log (already an artifact on
  failure since v0.255.8).
* Backgrounds mino via `(exec ./mino ...)` so the subshell's $!
  is mino's pid directly.
* 7m30s into the run, if mino is still alive, sends SIGABRT.
* mino's existing crash_handler (main.c:711) prints fatal
  signal, GC stats (minor / major / live / alloc / freed / phase
  / remset), and a libc-backtrace stack frame list.
* The 30s buffer before GHA's own SIGKILL gives the handler
  time to flush and exit cleanly with code 134.

Local behaviour unchanged. The wrapper only lives in CI.

This release contains no runtime change; v0.255.9's fix is still
load-bearing.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: leifericf

.github/workflows/ci.yml

@@ -89,14 +89,53 @@ jobs:
         # an opaque "Test timed out" actionable. Keeps trace off
         # locally (env-gated) so a normal `./mino tests/run.clj`
         # produces the same output as before.
+        #
+        # Watchdog wrapper: GHA's timeout-minutes sends a SIGKILL after
+        # the cap, which gives no diagnostic at all on a hang. We
+        # spawn mino in the background, sleep just inside the cap,
+        # then SIGABRT it -- mino's crash_handler (main.c:711) prints
+        # a backtrace + gc stats on SIGABRT, so a hang now leaves a
+        # readable stack in the log instead of a silent kill. mino
+        # exits non-zero after the dump, which fails the step
+        # normally (no continue-on-error masking).
         env:
           MINO_TEST_TRACE: "1"
         run: |
-          set -o pipefail
-          ./mino tests/run.clj 2> >(tee /tmp/test_trace.log >&2)
+          set +e
+          # Pre-create + tail the trace file so its lines stream to
+          # the live job log as mino emits them. Without the tail,
+          # the trace only appears via the failure artifact, which
+          # makes a live `gh run watch` opaque.
+          : > /tmp/test_trace.log
+          (tail -F /tmp/test_trace.log 2>/dev/null) &
+          TAIL_PID=$!
+          # exec replaces the subshell with mino so $! is mino's
+          # pid directly -- the watchdog's kill -ABRT then lands
+          # on mino, not on an outer shell wrapper.
+          (exec ./mino tests/run.clj) 2> /tmp/test_trace.log &
+          MINO_PID=$!
+          # Wake at 7m30s (the cap is 8m) so SIGABRT has time to
+          # run mino's handler before GHA's own SIGKILL lands.
+          # mino's crash_handler (main.c:711) prints a backtrace +
+          # GC stats on SIGABRT, so a hang now leaves a readable
+          # stack in the log + trace artifact instead of a silent
+          # kill. mino exits 134 (128 + SIGABRT) after the dump.
+          (sleep 450; if kill -0 $MINO_PID 2>/dev/null; then
+             echo "##[warning]Watchdog firing SIGABRT on hung mino (pid $MINO_PID)"
+             kill -ABRT $MINO_PID
+           fi) &
+          WD_PID=$!
+          wait $MINO_PID
+          RC=$?
+          # Give the trace tail a moment to flush mino's last lines.
+          sleep 1
+          kill $WD_PID 2>/dev/null || true
+          kill $TAIL_PID 2>/dev/null || true
+          exit $RC
         # Tests usually finish in seconds; a hang means a deadlock, not
         # a slow runner. Cap so we get diagnostic output instead of
-        # waiting on the 6h job-default timeout.
+        # waiting on the 6h job-default timeout. The watchdog above
+        # fires 30s before this cap so we keep the stack trace.
         timeout-minutes: 8
         # The Windows test suite has documented divergence: cmd.exe's
         # echo emits a trailing space before \n, which the proc-test

CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## v0.255.10 — Diagnostic: SIGABRT Watchdog on CI Test Hang
+
+A diagnostic-only release that converts the remaining CI test
+hang from "silent SIGKILL at the 8-min cap" into "SIGABRT 30s
+before the cap, mino's crash_handler dumps a backtrace + GC
+stats". v0.255.9 fixed one real bug at `transient-survives-gc-
+yield` (use-after-free reproducible locally under ASan) but
+mino's CI matrix still hangs at the same test on macos-14 /
+ubuntu-24.04 / ubuntu-24.04-arm. Without a stack trace from the
+hung process we can't tell whether mino is in a tight loop, a
+pthread cv_wait, a GC mark-stack drain, or somewhere else.
+
+`.github/workflows/ci.yml`'s Test step now wraps `./mino
+tests/run.clj` in a watchdog:
+
+* Streams stderr to `/tmp/test_trace.log` (already an artifact
+  on failure since v0.255.8).
+* Backgrounds mino via `(exec ./mino ...)` so the subshell's
+  `$!` is mino's pid directly.
+* 7m30s into the run, if mino is still alive, sends SIGABRT.
+* mino's existing crash_handler (`main.c:711`) prints
+  `[mino] fatal SIGABRT (signal 6)`, GC stats (minor / major /
+  live / alloc / freed / phase / remset), and a libc-backtrace
+  stack frame list.
+* The 30s buffer before GHA's own SIGKILL gives the handler
+  time to flush stdout/stderr and exit cleanly with code 134.
+
+Local behaviour unchanged: a plain `./mino tests/run.clj` still
+exits 0 in ~1.6s without the watchdog firing. The wrapper only
+lives in CI.
+
+This release does not include any runtime change; v0.255.9's
+fix is still load-bearing for the use-after-free path.
+
 ## v0.255.9 — Fix: `(gc!)` During In-Flight Major Mark Use-After-Free
 
 Root cause of the v0.255.6 / .7 / .8 CI hang: `mino_gc_collect(MINO_GC_FULL)`

src/mino.h

@@ -28,7 +28,7 @@
  */
 #define MINO_VERSION_MAJOR 0
 #define MINO_VERSION_MINOR 255
-#define MINO_VERSION_PATCH 9
+#define MINO_VERSION_PATCH 10
 
 /*
  * Human-readable version string of the *linked* runtime, e.g. "0.48.0".