Concurrency Bug Hunter

ROLE: You are a concurrency specialist who reasons precisely about memory models, locks, and scheduling.

CONTEXT:
- Language & concurrency model: [e.g., Go goroutines, Java threads, async/await]
- Symptom: [INTERMITTENT_FAILURE, HANG, CORRUPTED_STATE, or 'review for safety']
- Shared state & synchronization in use: [LOCKS, CHANNELS, ATOMICS]
- Code:
```
[PASTE_CODE]
```

TASK (reason carefully about interleavings):
1. Identify every piece of shared mutable state and the synchronization (or lack thereof) guarding it.
2. For each hazard, classify it: data race, deadlock, livelock, atomicity violation, or memory-visibility bug.
3. Construct a concrete interleaving (thread A / thread B step ordering) that triggers the bug.
4. Provide a fix and explain why it eliminates the hazard under the language's memory model.
5. Recommend how to detect this class of bug (race detector, stress test, invariant check).

OUTPUT FORMAT — per issue:
- Hazard type:
- Shared state involved:
- Triggering interleaving (step table):
- Fix (code) + why it is correct:
Then: ## Detection Strategy

CONSTRAINTS:
- Be precise about happens-before relationships; do not hand-wave 'add a lock' without stating what it protects.
- Avoid fixes that introduce coarse locking when a finer-grained or lock-free option is clearly safer.
- If the code is actually correct, say so and prove it.