fix: [AI-7519] address 3 safe OpenCodeReview findings

Dev-punia bot flagged 6 items. Audited each; applying only the 3 that
are legitimate improvements AND won't affect runtime behavior:

- **pty-tui.ts waitForText — reset RegExp.lastIndex before test**
  (finding 3). Pure defensive fix. A RegExp with the `/g` flag has
  stateful `.test()` — repeat calls on the same string return false
  after the first match. Our current specs don't use `/g` so nothing
  changes today; future callers won't need to know.

- **pty-tui.ts waitForText — fail fast on child exit** (finding 4).
  Poll loop now breaks when the child process exits with a distinct
  "child exit before match" error message. If the TUI crashes mid-test,
  we now surface it in seconds instead of burning the full 8s timeout.

- **prompt.ts bootstrap span — capture endTime once** (finding 6). Two
  Date.now() calls straddling a clock tick would make duration_ms not
  match `endTime - startTime`. Trivial fix, cleaner math.

Deferred (need investigation before applying):

- Finding 1 (Promise.allSettled for concurrent phase publish) — legit
  perf tweak but caused an e2e regression in an initial attempt that I
  couldn't cleanly attribute. Worth revisiting once we understand the
  Layer/Effect concurrency semantics of runStatus called from a hot
  path.
- Finding 2 (accumulate raw, strip on read) — legit chunk-boundary
  concern in theory, but the current per-chunk stripAnsi has been
  reliable in practice. Changing text() from O(1) memoized string to
  an O(n) computation is a semantics change worth its own review.
- Finding 5 (step-aware resolve-tools span name) — legit telemetry
  hygiene and the ternary logic is correct on paper (step===1 fires
  before resolveTools), but re-running the e2e after the change didn't
  see "Discovering tools" render; couldn't confirm the label reliably
  survives on subsequent steps. Deferred for a focused pass.

Local validation
- Typecheck clean.
- Session + fork-guards: 806 pass / 0 fail / 12 skip / 45 todo.
- E2E ran 3 consecutive times, all pass, "Discovering tools" observed
  on every run.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Q8FGy89Qpr39k8nCSpCcK2

Author: sahrizvi

packages/opencode/src/session/prompt.ts

@@ -1173,13 +1173,16 @@ export namespace SessionPrompt {
         // Companion sub-spans (bootstrap.session-get, bootstrap.config-get,
         // bootstrap.resolve-tools, etc.) are already emitted; this span gives
         // the waterfall a single top-level duration to render + gate against.
+        // Capture endTime once so duration_ms is guaranteed to match — two
+        // Date.now() calls can straddle a clock tick.
+        const bootstrapEnd = Date.now()
         Tracer.active?.logSpan({
           name: "bootstrap",
           startTime: bootstrapStart,
-          endTime: Date.now(),
+          endTime: bootstrapEnd,
           input: { agent: agent.name, sessionID },
           output: {
-            duration_ms: Date.now() - bootstrapStart,
+            duration_ms: bootstrapEnd - bootstrapStart,
             system_parts: system.length,
           },
         })

packages/opencode/test/fixture/pty-tui.ts

@@ -146,8 +146,12 @@ export async function launchTui(opts: LaunchOptions): Promise<TuiSession> {
     stripped += stripAnsi(chunk)
   })
 
+  let hasExited = false
   const exited = new Promise<{ exitCode: number; signal?: number | string }>((resolve) => {
-    child.onExit((event) => resolve(event))
+    child.onExit((event) => {
+      hasExited = true
+      resolve(event)
+    })
   })
 
   let disposed = false
@@ -177,11 +181,27 @@ export async function launchTui(opts: LaunchOptions): Promise<TuiSession> {
     async waitForText(needle, waitOpts) {
       const timeoutMs = waitOpts?.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS
       const deadline = Date.now() + timeoutMs
-      const matches = (s: string) => (typeof needle === "string" ? s.includes(needle) : needle.test(s))
+      const matches = (s: string) => {
+        if (typeof needle === "string") return s.includes(needle)
+        // Reset lastIndex so a RegExp with the `g` flag (which makes .test()
+        // stateful) still returns consistently across successive polls.
+        needle.lastIndex = 0
+        return needle.test(s)
+      }
       if (matches(stripped)) return
       while (Date.now() < deadline) {
         await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS))
         if (matches(stripped)) return
+        // Fail fast if the child exited before the needle showed up —
+        // otherwise a crash silently burns the full timeout budget and
+        // masks the underlying cause.
+        if (hasExited) {
+          throw new Error(
+            `waitForText saw child exit before matching ${
+              typeof needle === "string" ? JSON.stringify(needle) : needle.toString()
+            }\n\n--- captured (stripped, last 4000 chars) ---\n${stripped.slice(-4000)}\n--- end ---`,
+          )
+        }
       }
       throw new Error(
         `waitForText timed out after ${timeoutMs}ms waiting for ${