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 {
 privatesnapshotDir: string|undefined
 privatesnapshotPending=false
 privatesnapshotPromise: 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.
+privatecrashed=false
 
 privateconstructor(exporters: TraceExporter[]){
 this.traceId=randomUUIDv7()
@@ -745,17 +750,26 @@ export class Trace {
 privatesnapshot(){
 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
 
 consttrace=this.buildTraceFile()
 constsafeId=(this.sessionId||"unknown").replace(/[/\\.:]/g,"_")||"unknown"
 constfilePath=path.join(this.snapshotDir,`${safeId}.json`)
 consttmpPath=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
+returnfs.unlink(tmpPath).catch(()=>{})
+}
+returnfs.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
 constrootSpan=this.spans.find((s)=>s.spanId===this.rootSpanId)
 if(rootSpan){