Assert boot screen renders, not just absence of fatals

The previous smoke test and e2e test both checked for known error markers
("Fatal error during startup", etc.). That misses anything we didn't
think to add — novel error messages, silent crashes, hangs, segfaults
that produce no stderr.

Switch both to a positive signal: assert the binary actually rendered a
known boot screen. If something goes wrong we don't anticipate, the
boot text never appears and the test fails with a clear "binary never
reached a known boot screen" diagnostic. Negative pattern matches stay
for clearer error messages on regressions of bugs we've already seen.

- cli/scripts/smoke-binary.ts: gate pass/fail on at least one of N boot
  signals appearing in stdout/stderr (chat surface header, login modal,
  freebuff queue states, freebuff country-block screen, chat input
  prompt). Verified locally: passes on real binaries, fails on a stub
  that hangs without rendering.

- freebuff/e2e/tests/startup.e2e.test.ts: wait for the FREEBUFF ASCII
  logo's F+R crossbar pattern (`█████╗  ██████╔╝`). The logo renders
  for every valid boot state — including the country-block screen that
  GitHub Actions runners hit because their egress is flagged as
  anonymized network — so this assertion survives the geo gate that
  was tripping the previous "Pick a model to start" wait.

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

Author: jahooma

cli/scripts/smoke-binary.ts

@@ -5,24 +5,58 @@
  * `--version` and `--help` exit via commander synchronously, before async
  * startup failures (e.g. the unhandled rejection from Parser.init when the
  * tree-sitter wasm load fails) get a chance to fire. This script spawns the
- * binary, lets it run for a few seconds, then kills it and asserts no fatal
- * startup markers showed up in stdout/stderr.
+ * binary, lets it run for a few seconds, then kills it and asserts the TUI
+ * actually rendered a known boot screen.
+ *
+ * The positive check matters more than the negative one: a "did the boot
+ * screen appear" assertion catches *any* startup failure — known fatals,
+ * novel error messages, silent crashes, hangs, segfaults that produce no
+ * output. Negative pattern matches are kept only for clearer diagnostics
+ * when a known regression recurs.
  *
  * Designed to run on every supported platform (Linux, macOS, Windows) without
- * extra deps. The binary doesn't need a TTY: `earlyFatalHandler` in
- * `cli/src/index.tsx` writes its diagnostic to stdout/stderr regardless.
+ * extra deps. The binary doesn't need a TTY: OpenTUI emits ANSI escapes to
+ * stdout regardless, and the static text we look for renders contiguously.
  *
  * Usage:
  *   bun cli/scripts/smoke-binary.ts <path-to-binary> [seconds]
  *
- * Exits 0 if no fatal markers detected, 1 otherwise.
+ * Exits 0 if a boot signal is detected and no fatal markers are present, 1
+ * otherwise.
  */
 
 import { spawn } from 'child_process'
 import { existsSync } from 'fs'
 
-// Markers that indicate the CLI crashed during startup. Match what
-// `earlyFatalHandler` writes plus the specific tree-sitter regression.
+// Any one of these strings appearing in stdout/stderr proves the binary
+// reached its post-init UI: React tree mounted, OpenTUI rendered, async
+// wasm init survived. Strings are static text from rendered components
+// (not shimmer / animated) so they survive ANSI styling as contiguous
+// substrings. Cover the multiple boot states the binary might land on:
+//
+//   - "will run commands on your behalf" — codebuff/freebuff main surface
+//     header (authed + session ready)
+//   - "Press ENTER to login" / "Open this URL" — login modal (no cached
+//     creds — typical CI smoke)
+//   - "Pick a model to start" / waiting-room copy — freebuff queue gate
+//   - "Free mode isn't available" — freebuff country-block screen (CI
+//     runners with anonymized-network egress like GitHub Actions land here)
+//   - "Enter a coding task" — chat input prompt
+const BOOT_SIGNAL_PATTERNS = [
+  /will run commands on your behalf/,
+  /Pick a model to start/,
+  /You're in the waiting room/,
+  /You're next in line/,
+  /Free mode isn't available/,
+  /Press ENTER to login/,
+  /Open this URL/,
+  /Enter a coding task/,
+] as const
+
+// Fatal markers we already know about — kept for nicer error messages on
+// regressions of bugs we've already seen. The boot-signal check above is
+// the real gate: it fails on *any* startup problem, including ones whose
+// error text we never thought to add here.
 const FATAL_PATTERNS = [
   /Fatal error during startup/i,
   /Internal error: tree-sitter\.wasm not found/i,
@@ -80,19 +114,35 @@ async function main(): Promise<void> {
   await exited
   clearTimeout(killTimer)
 
+  const fail = (reason: string): never => {
+    console.error(`smoke-binary: FAIL — ${reason} (exit code ${earlyExitCode}).`)
+    console.error('--- captured output (truncated to 8KB) ---')
+    console.error(captured.slice(0, 8 * 1024))
+    process.exit(1)
+  }
+
+  // Negative gate first: a known fatal marker gives us a more specific error
+  // message than "no boot signal found" would. Both gates would fire on a
+  // crash; preferring the negative one just makes the failure log clearer.
   for (const pattern of FATAL_PATTERNS) {
     if (pattern.test(captured)) {
-      console.error(
-        `smoke-binary: FAIL — output matched ${pattern} (exit code ${earlyExitCode}).`,
-      )
-      console.error('--- captured output (truncated to 8KB) ---')
-      console.error(captured.slice(0, 8 * 1024))
-      process.exit(1)
+      fail(`output matched ${pattern}`)
     }
   }
 
+  // Positive gate: the binary must have rendered a known boot screen. This
+  // is the load-bearing assertion — it catches *any* startup failure (silent
+  // crashes, hangs, novel error messages, segfaults), not just the listed
+  // fatals.
+  const matchedSignal = BOOT_SIGNAL_PATTERNS.find((p) => p.test(captured))
+  if (!matchedSignal) {
+    fail(
+      `binary never reached a known boot screen — checked ${BOOT_SIGNAL_PATTERNS.length} patterns`,
+    )
+  }
+
   console.log(
-    `smoke-binary: OK (exit code ${earlyExitCode}, ${captured.length} bytes captured).`,
+    `smoke-binary: OK (matched ${matchedSignal}, exit code ${earlyExitCode}, ${captured.length} bytes captured).`,
   )
 }
 

freebuff/e2e/tests/startup.e2e.test.ts

@@ -15,22 +15,24 @@ describe('Freebuff: Startup', () => {
   })
 
   test(
-    'binary reaches the model selection screen',
+    'binary renders its boot screen',
     async () => {
       const binary = requireFreebuffBinary()
       session = await FreebuffSession.start(binary)
 
-      // Wait for the model selector to render. This proves the binary survived
-      // module init (including the eager tree-sitter Parser.init that crashed
-      // Windows binaries after the OpenTUI 0.2.2 upgrade), passed the auth /
-      // session API call, and successfully mounted the React tree. A pure
-      // "non-empty output" check would pass on a half-rendered crash screen.
-      const output = await session.waitForText('Pick a model to start')
-
-      // earlyFatalHandler in cli/src/index.tsx writes this to stderr on
-      // unhandled rejections during startup. Belt-and-braces: the wait above
-      // would already have timed out, but if some race ever surfaces a fatal
-      // *after* the model selector renders, we still want it to fail.
+      // The 3rd row of the FREEBUFF ASCII logo: the crossbars of F and R
+      // adjacent. Picked because the logo renders for *every* valid boot
+      // state — model picker, waiting room, country-blocked (which is what
+      // CI runners hit, since GitHub Actions egress is flagged as anonymized
+      // network) — but never appears if module init crashes before React
+      // mounts (the post-OpenTUI-upgrade tree-sitter wasm regression). This
+      // gives us a positive "boot succeeded" signal that's robust against
+      // novel error modes, not just the ones we listed below.
+      const output = await session.waitForText('█████╗  ██████╔╝')
+
+      // Belt-and-braces: known fatal markers should never coexist with a
+      // rendered logo, but if some race ever surfaces one we still want to
+      // see it called out clearly rather than buried in raw output.
       expect(output).not.toContain('Fatal error during startup')
       expect(output).not.toContain('Internal error: tree-sitter.wasm not found')
       expect(output).not.toContain('FATAL')