<reasoning_content>
The user wants a Python implementation of a priority-based job scheduling queue.
Requirements:
1. Class `JobQueue` with `add_job` and `get_next_job` methods.
2. `add_job` accepts job name (str), data (dict), and optional priority (int, default=0).
3. Higher priority jobs processed first.
4. FIFO for same priority.
5. `get_next_job` returns `tuple[str, dict] | None`.
6. Priority levels: 0 (Normal), 1 (High), 2 (Critical).
7. Output only Python code.

I'll use `heapq` for efficient priority queue implementation.
To maintain FIFO order for same priorities, I'll use a counter as a tie-breaker in the heap tuples.
Heap tuples will be: `(-priority, counter, job_name, job_data)`.
Wait, the requirement says "Higher priority jobs should be processed before lower priority jobs". So priority 2 should come before priority 0.
Using `heapq` (min-heap), I can negate priority or use a custom class. Negating priority is easier: `(-priority, counter, name, data)`.
Counter will increment with each `add_job` to maintain FIFO.

Let's draft the class:

```python
import heapq

class JobQueue:
    def __init__(self):
        self._queue = []
        self._counter = 0
        
    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        # Negate priority so higher priority comes first in min-heap
        heapq.heappush(self._queue, (-priority, self._counter, name, data))
        self._counter += 1
        
    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._queue:
            return None
        _, _, name, data = heapq.heappop(self._queue)
        return name, data
```

Wait, should I copy the data dict to avoid external modification? The requirement doesn't specify, but it's good practice. I'll stick to the exact signature requested.
The requirement says `get_next_job() -> tuple[str, dict] | None`.
I'll implement exactly that.

Check constraints:
- `add_job` accepts optional priority parameter (default=0) -> `def add_job(self, name: str, data: dict, priority: int = 0) -> None:`
- Higher priority first -> handled by `-priority`
- FIFO for same priority -> handled by `_counter`
- `get_next_job` returns tuple or None -> handled.

One minor point: `tuple[str, dict] | None` is Python 3.10+ syntax. I'll assume modern Python.
I'll make sure the code is clean and matches requirements.

Let's test mentally:
```python
queue = JobQueue()
queue.add_job("normal", {"type": "normal"}, priority=0) # (-0, 0, "normal", ...)
queue.add_job("critical", {"type": "critical"}, priority=2) # (-2, 1, "critical", ...)
queue.add_job("high", {"type": "high"}, priority=1) # (-1, 2, "high", ...)

heap pops: (-2, 1, ...) -> critical
Then (-1, 2, ...) -> high
Then (-0, 0, ...) -> normal
Matches requirement.

What about `get_next_job` signature? The prompt says `get_next_job() -> tuple[str, dict] | None`. It doesn't pass arguments.
I'll write the code exactly as requested.

One thing: `data` is passed as a dict. Should I deep copy it? Usually not required unless specified. I'll just store it as is.

Code structure:
```python
import heapq

class JobQueue:
    def __init__(self):
        self._heap = []
        self._counter = 0

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        heapq.heappush(self._heap, (-priority, self._counter, name, data))
        self._counter += 1

    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._heap:
            return None
        _, _, name, data = heapq.heappop(self._heap)
        return name, data
```

Wait, should `add_job` signature match exactly `add_job(self, name, data, priority=0)`? The prompt says "Modify `add_job` to accept an optional priority parameter (default=0)". It implies the method exists or I'm creating it. I'll just provide the class.

Is there any specific naming for parameters? The example shows `queue.add_job("normal", {"type": "normal"}, priority=0)`. So positional args for name and data, keyword for priority. That matches.

I'll output only the Python code as requested.

One detail: `tuple[str, dict] | None` type hint requires Python 3.10+. I'll keep it as is, or use `Optional[Tuple[str, dict]]` for broader compatibility, but the prompt uses `|` syntax, so I'll stick with it.

Final check of the prompt: "Write only the Python code, no explanations."
I will provide just the class definition.

```python
import heapq

class JobQueue:
    def __init__(self):
        self._queue = []
        self._counter = 0
        
    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        heapq.heappush(self._queue, (-priority, self._counter, name, data))
        self._counter += 1
        
    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._queue:
            return None
        _, _, name, data = heapq.heappop(self._queue)
        return name, data
```

This looks solid. Matches all requirements. Handles priority correctly. Maintains FIFO. Returns correct type. Uses standard library. No extra fluff.
I will output this code block.
One minor consideration: Should I copy `data` to prevent mutation issues? It's not strictly required but often good practice. I'll skip it to keep it simple and direct, as per typical coding challenge expectations. If needed, `data.copy()` could be used, but I'll stick to the simplest correct implementation.
The prompt says "Modify `add_job`...", implying I should just provide the class.
All good.
Output matches request.✅
Proceed. 
Self-Correction/Refinement during thought: 
Wait, `tuple[str, dict] | None` might cause a syntax error in older Python versions if not using `from __future__ import annotations`, but the prompt uses it, so it's fine. I'll keep it.
The code is ready.
Output matches exactly.✅
Proceeds. 
Generating response. 
[Output Generation] -> *Provides the code block*
Done. 
Let's double check the exact prompt: "Implement priority-based job scheduling for the queue."
"Modify `add_job` to accept an optional priority parameter (default=0)"
"Higher priority jobs should be processed before lower priority jobs"
"Jobs with the same priority should maintain FIFO order"
"Add `get_next_job() -> tuple[str, dict] | None` to get the highest priority job"
"Priority levels: 0: Normal, 1: High, 2: Critical"
"Example: ..."
"Write only the Python code, no explanations."

Everything is covered. I will produce the code now. 
One thing: `heapq` is standard, but sometimes people prefer `queue.PriorityQueue`. However, `heapq` is more flexible and doesn't require threading locks (which aren't needed here). `heapq` is fine.
I'll stick with `heapq`.
Code:
```python
import heapq

class JobQueue:
    def __init__(self):
        self._heap = []
        self._counter = 0
        
    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        heapq.heappush(self._heap, (-priority, self._counter, name, data))
        self._counter += 1
        
    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._heap:
            return None
        _, _, name, data = heapq.heappop(self._heap)
        return name, data
```
Looks perfect. Output matches.✅
Proceeds. 
(Self-Correction/Note during generation prep)
I should make sure the type hints match exactly. `tuple[str, dict] | None` is fine.
I'll output exactly this.
Done. 
[Output Generation] -> *Proceeds*

</reasoning_content>

<content>
```python
import heapq

class JobQueue:
    def __init__(self):
        self._heap = []
        self._counter = 0
        
    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        heapq.heappush(self._heap, (-priority, self._counter, name, data))
        self._counter += 1
        
    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._heap:
            return None
        _, _, name, data = heapq.heappop(self._heap)
        return name, data
```
</content>