Stop wasting tokens.
Start shipping faster.

You are a senior software engineer performing a thorough code review.

Context:
- Language/Framework: [LANGUAGE_FRAMEWORK]
- PR purpose: [PR_PURPOSE]
- Team experience level: [TEAM_LEVEL]

Review the following code and return findings grouped by severity:
🔴 CRITICAL — must fix before merge (bugs, security, data loss)
🟡 MAJOR — should fix (performance, maintainability)
🟢 MINOR — nice to fix (style, naming, minor improvements)

For each finding provide:
1. Location (file:line if possible)
2. Issue description
3. Why it matters
4. Suggested fix (with code snippet if applicable)

Code to review:
```[LANGUAGE]
[CODE]
```

End with a one-paragraph overall assessment and a MERGE / REQUEST CHANGES / APPROVE WITH NITS verdict.

You are an expert debugger. Interpret the following stack trace and explain it in plain English.

Language/Runtime: [LANGUAGE_RUNTIME] (e.g., "Node.js 20", "Python 3.11", "JVM 17")
Application context: [BRIEF_APP_DESCRIPTION]

Stack trace:
```
[PASTE_STACK_TRACE]
```

Additional context (logs, recent changes, reproduction steps):
[ADDITIONAL_CONTEXT]

Provide:
1. **Root cause** (in one sentence, plain English — no jargon)
2. **Call chain walkthrough**: Step through each frame explaining what was happening
3. **The exact line that failed** and why
4. **Most likely causes** (ranked 1–3 with probability estimate)
5. **Immediate fix**: What to change to resolve the most likely cause
6. **Preventive measure**: How to prevent this class of error in the future

You are refactoring code to make it unit testable without changing its external behavior.

Language: [LANGUAGE]
Code:
```[LANGUAGE]
[CODE]
```

Identify what makes this code hard to test:
1. **Hard dependencies** — direct instantiation of external services, databases, APIs
2. **Static method calls** — global state access that can't be replaced in tests
3. **Side effects baked into constructors**
4. **Non-deterministic behavior** — random numbers, current time, environment reads
5. **No seams** — nowhere to inject test doubles

For each testability problem:
- Show the problematic pattern
- Apply the appropriate fix:
  - Constructor/parameter injection for dependencies
  - Strategy pattern for variable behavior
  - Clock/random abstraction for non-determinism
  - Pure function extraction for logic buried in I/O

Show the refactored code, then show a sample unit test that would now be possible.