fix(tracing): de-flake CI by guarding async snapshot vs sync flushSync race

CI run 25143783932 (commit ee73863, agent_outcome cherry-pick) failed
with `flushSync — crash recovery > flushSync preserves all accumulated
data` after passing locally and on prior + subsequent runs. Root cause
analysis surfaced a real race in the tracer:

The `Recap` (tracing.ts) `snapshot()` method writes asynchronously via
`fs.writeFile(tmpPath) → fs.rename(tmpPath, filePath)` for atomicity,
storing the in-flight promise in `this.snapshotPromise` but never
awaiting it. `flushSync()` writes synchronously to the SAME `filePath`
via `fsSync.writeFileSync`. On slow CI runners with disk contention, a
snapshot that was in-flight when flushSync ran could complete its
`fs.rename` AFTER flushSync's sync write — clobbering the crashed-trace
file with stale (non-crashed) content. The test then read the wrong
content and failed assertions like `summary.status === "crashed"`.

Fix:
- Add a `private crashed = false` flag on the Recap class.
- `flushSync()` sets `this.crashed = true` BEFORE its sync write so any
  in-flight async snapshot() can detect the takeover.
- `snapshot()` checks `this.crashed` at two points:
  - Entry: bail before starting a new write.
  - Just before `fs.rename`: if a flushSync ran during the write, drop
    the temp file and skip the rename (so the crashed file stays
    canonical).

Why not just await snapshotPromise in flushSync: flushSync is invoked
from SIGINT/SIGTERM/beforeExit handlers where async code may not run.
The flag-based guard makes the race deterministic without depending on
event-loop progression after the signal.

Verification:
- The flaky test now passes 10/10 times locally.
- Broader regression run: 3554/3554 tests pass across
  test/altimate/ + test/upstream/ + test/branding/.
- Single-file run: 27/27 pass in tracing-display-crash.test.ts every time.

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

Author: anandgupta42

packages/opencode/src/altimate/observability/tracing.ts

@@ -328,6 +328,11 @@ export class Trace {
   private snapshotDir: string | undefined
   private snapshotPending = false
   private snapshotPromise: Promise<void> | undefined
+  // Set true when flushSync runs. Prevents in-flight async snapshot()
+  // calls from racing with the synchronous crash write — without this,
+  // a still-pending snapshot's `fs.rename` can overwrite flushSync's
+  // crashed-trace content. Round-3 audit + CI flake on slow runners.
+  private crashed = false
 
   private constructor(exporters: TraceExporter[]) {
     this.traceId = randomUUIDv7()
@@ -745,17 +750,26 @@ export class Trace {
   private snapshot() {
     if (!this.snapshotDir || !this.sessionId) return
     if (this.snapshotPending) return // Debounce — only one in flight at a time
+    if (this.crashed) return // flushSync wrote the canonical crashed file; do NOT race it
     this.snapshotPending = true
 
     const trace = this.buildTraceFile()
     const safeId = (this.sessionId || "unknown").replace(/[/\\.:]/g, "_") || "unknown"
     const filePath = path.join(this.snapshotDir, `${safeId}.json`)
     const tmpPath = filePath + `.tmp.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`
 
-    // Atomic write: write to temp file, then rename (prevents partial reads)
+    // Atomic write: write to temp file, then rename (prevents partial reads).
+    // We re-check `this.crashed` immediately before rename so a flushSync that
+    // ran *during* the write doesn't get clobbered.
     this.snapshotPromise = fs.mkdir(this.snapshotDir, { recursive: true })
       .then(() => fs.writeFile(tmpPath, JSON.stringify(trace, null, 2)))
-      .then(() => fs.rename(tmpPath, filePath))
+      .then(() => {
+        if (this.crashed) {
+          // flushSync took over — drop the temp and bail
+          return fs.unlink(tmpPath).catch(() => {})
+        }
+        return fs.rename(tmpPath, filePath)
+      })
       .catch((err) => {
         Log.Default.debug(`[tracing] failed to write trace snapshot: ${err}`)
         fs.unlink(tmpPath).catch(() => {})
@@ -948,6 +962,9 @@ export class Trace {
   flushSync(error?: string) {
     try {
       if (!this.snapshotDir || !this.sessionId) return
+      // Set crashed BEFORE writing so any in-flight async snapshot() will
+      // bail out at its rename step instead of clobbering our crashed file.
+      this.crashed = true
       this.currentGenerationSpanId = undefined
       const rootSpan = this.spans.find((s) => s.spanId === this.rootSpanId)
       if (rootSpan) {