fix(scripts): address Copilot review round 2 on #2147

Two findings, both of which quietly undo the PR.

1. `SMOKE_TUI_SURVIVE_MS` was unvalidated. `??` guards only nullish, so
   an env var set to the empty string reaches `Number("")` -> 0 and a typo
   reaches NaN; `setTimeout` fires immediately on both. The survival check
   would then resolve before the child could possibly have died, printing
   "still running 0ms later" and asserting nothing — the exact first-paint
   false green this PR removes, restored by an empty environment variable,
   on a green run.

   Fixed at the module rather than only at the env-parse site, so every
   caller is covered: `normalizeMs` (same shape as child-cleanup.mjs's
   `normalizeGraceMs`, matching an existing policy rather than inventing a
   second one) applied to all four durations before anything reads them,
   which also stops the messages interpolating "NaNms". Defaults moved to
   an exported DEFAULTS so the smoke and the module cannot drift.

   `surviveMs: 0` is deliberately NOT honored as "skip the wait": no
   caller wants that, and it is indistinguishable from the typo.

2. (suppressed comment) `spawnSync` REPORTS ENOENT in `result.error` — it
   does not throw — so `probeScriptVersion`'s try/catch read a missing
   binary as "ran, printed nothing". On linux that empty output fell
   through to the util-linux guess, and the smoke then hard-failed
   spawning a binary that does not exist instead of taking the documented
   skip.

   `probeScriptVersion` now returns `{ available, output }`, and
   `resolvePtyWrapper` returns `{ ok: true, flavor, wrap }` or
   `{ ok: false, reason }` — the two unavailability causes deserve
   different skip messages, since "no script(1) on PATH" and "nobody has
   verified this platform's invocation" send the reader elsewhere. A
   non-zero exit is explicitly not unavailability: BSD `script` has no
   `--version` and answers with its usage, which is the evidence the
   flavor fallback reads.

Tests for both, since each finding lives entirely in a branch no happy
path reaches: the normalizeMs table (empty string, typo, undefined, -1,
Infinity, a numeric string, 0), an end-to-end run proving a
`surviveMs: Number("")` paint-then-die stub still fails, the
`result.error` ENOENT and timeout shapes, and both `resolvePtyWrapper`
failure reasons.

Verified: `SMOKE_TUI_SURVIVE_MS="" npm run smoke:tui` reports "still
running 2000ms later"; with PATH blanked, resolvePtyWrapper returns
`{ok: false, reason: "no `script(1)` on PATH"}` rather than guessing.

Signed-off-by: Cliff Hall <cliff@futurescale.com>
Signed-off-by: cliffhall <cliff@futurescale.com>

scripts/lib/render-smoke.test.mjs

@@ -1,7 +1,12 @@
 import { strict as assert } from "node:assert";
 import test from "node:test";
 
-import { outputTail, runRenderSmoke } from "./render-smoke.mjs";
+import {
+  DEFAULTS,
+  normalizeMs,
+  outputTail,
+  runRenderSmoke,
+} from "./render-smoke.mjs";
 
 const MARKER = "MCP Servers";
 
@@ -105,6 +110,39 @@ test("scans stderr as well as stdout for the marker", async () => {
   assert.equal(r.code, 0, `expected pass, got: ${r.message}`);
 });
 
+// `Number("")` is 0 and `Number("typo")` is NaN, and `??` catches neither
+// because both are non-nullish. `setTimeout` fires immediately on either, so an
+// un-normalized `surviveMs` resolves the survival check before the child could
+// possibly have died — restoring the exact first-paint false green, on a run
+// that still prints OK. This is the guard on the guard.
+test("normalizeMs rejects the values a bad env var actually produces", () => {
+  assert.equal(normalizeMs(Number(""), 2000), 2000);
+  assert.equal(normalizeMs(Number("typo"), 2000), 2000);
+  assert.equal(normalizeMs(undefined, 2000), 2000);
+  assert.equal(normalizeMs(-1, 2000), 2000);
+  assert.equal(normalizeMs(Infinity, 2000), 2000);
+  assert.equal(normalizeMs("3000", 2000), 2000, "a string is not a duration");
+  // 0 is a typo, never "skip the check" — there is no caller who wants that.
+  assert.equal(normalizeMs(0, 2000), 2000);
+  // A real value passes through untouched.
+  assert.equal(normalizeMs(1234, 2000), 1234);
+});
+
+test("a zero survival window falls back rather than passing instantly", async () => {
+  // End to end through the real state machine: with surviveMs honored as 0 the
+  // paint-then-exit stub would settle OK before the child's exit was seen.
+  const r = await runRenderSmoke({
+    ...opts,
+    ...paintThenExit(1),
+    surviveMs: Number(""),
+  });
+  assert.equal(r.code, 1, `expected failure, got: ${r.message}`);
+  assert.match(
+    r.message,
+    new RegExp(`${DEFAULTS.surviveMs}ms survival window`),
+  );
+});
+
 test("outputTail drops a leading partial line but keeps short output whole", () => {
   assert.equal(outputTail("short", 800), "short");
   // Over the limit: the slice can land mid-escape-sequence, so it starts after