<reasoning_content>
Here's a thinking process:

1.  **Understand User Requirements:**
   - Modify `add_job` to accept an optional `priority` parameter (default=0)
   - Higher priority jobs processed first
   - Same priority jobs 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 provided shows usage
   - Output: Only Python code, no explanations

2.  **Identify Key Data Structures:**
   - Need a queue that supports priority ordering
   - Must maintain FIFO for same priority
   - Python's `heapq` module is perfect for priority queues, but it's a min-heap by default. Since higher priority should be processed first, I can either negate the priority or use a max-heap approach. Actually, `heapq` is a min-heap, so if I store `(-priority, sequence_number, job_name, job_data)`, it will pop the highest priority first, and for equal priorities, the lowest sequence number (earliest added) first.
   - Alternatively, I could use `collections.deque` with multiple levels, but `heapq` is simpler and standard.
   - Let's stick with `heapq` and a counter for FIFO ordering.

3.  **Design the Class:**
   ```python
   import heapq
   from typing import Optional, Tuple, Dict

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

       def add_job(self, name: str, data: dict, priority: int = 0) -> None:
           # Use negative priority so higher priority pops first in min-heap
           # Use counter to maintain FIFO for same priority
           heapq.heappush(self._queue, (-priority, self._counter, name, data))
           self._counter += 1

       def get_next_job(self) -> Optional[Tuple[str, dict]]:
           if self._queue:
               _, _, name, data = heapq.heappop(self._queue)
               return name, data
           return None
   ```

4.  **Check Requirements:**
   - `add_job` accepts optional priority (default=0) ✓
   - Higher priority processed first ✓ (using `-priority`)
   - Same priority maintains FIFO ✓ (using `_counter`)
   - `get_next_job() -> tuple[str, dict] | None` ✓
   - Priority levels 0, 1, 2 work as expected ✓
   - Only Python code, no explanations ✓

   Wait, the return type hint in the prompt is `tuple[str, dict] | None`. In Python 3.10+, this is valid. I'll use it exactly as specified or stick to standard typing. The prompt says `tuple[str, dict] | None`, so I'll match that.

   Let's verify the heap behavior:
   - Push: `(-priority, counter, name, data)`
   - Pop: returns smallest `-priority` (largest priority), then smallest counter (FIFO)
   - This matches requirements perfectly.

   One minor thing: The prompt says `get_next_job() -> tuple[str, dict] | None`. I'll make sure the type hints match.

   Code structure:
   ```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 self._queue:
               _, _, name, data = heapq.heappop(self._queue)
               return name, data
           return None
   ```

   Check edge cases:
   - Empty queue: returns None ✓
   - Same priority: counter ensures FIFO ✓
   - Higher priority first: negative priority ensures max priority first ✓
   - Type hints: matches prompt ✓

   The prompt says "Write only the Python code, no explanations." So I'll output exactly that.

   One thing: `tuple[str, dict] | None` requires Python 3.10+. I'll assume that's fine since it's in the prompt. Alternatively, I could use `Optional[tuple[str, dict]]` but the prompt explicitly shows the union syntax. I'll stick with it.

   Let's double check the exact signature requested:
   `get_next_job() -> tuple[str, dict] | None`
   `add_job` should accept priority parameter. The prompt doesn't specify exact signature for `add_job`, but I'll make it `def add_job(self, name: str, data: dict, priority: int = 0) -> None:`

   All good. I'll produce the code.
   One minor consideration: Should I include `import heapq`? Yes.
   Should I include type hints for `add_job`? It's good practice.
   The code is straightforward.

   Final check of the code:
   ```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 self._queue:
               _, _, name, data = heapq.heappop(self._queue)
               return name, data
           return None
   ```
   Matches all requirements. Output matches exactly. No extra text. Ready. 
   One thing: The prompt says "Modify `add_job`", implying there might be an existing class, but since none is provided, I'll provide the full class implementation. That's standard for these prompts.
   I'll output just the code block.✅
   Proceed. 
   Output matches response. 
   [Done] 
   Self-Correction/Refinement during thought: 
   Should I use `typing.Optional` for compatibility? The prompt explicitly uses `tuple[str, dict] | None`, so I'll keep it. Python 3.10+ supports it. It's fine.
   The heap tuple: `(-priority, self._counter, name, data)` works perfectly.
   All constraints met.
   Output generation. 
   [Code Generation] -> *Proceeds*
   ```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 self._queue:
               _, _, name, data = heapq.heappop(self._queue)
               return name, data
           return None
   ```
   Looks solid. No extra text. Matches requirements exactly.✅
   Output matches. 
   [Final Check of the Prompt]: "Write only the Python code, no explanations." -> I will strictly follow this.
   All good. 
   Proceeds. 
   [Output Generation] -> *Done.* 
   *(Self-Correction/Note during generation)*: I should make sure the class name matches the example: `JobQueue`. Yes.
   The example shows `queue.add_job("normal", {"type": "normal"}, priority=0)`. My signature matches.
   All set. 
   Output matches the refined code.✅
   [Final Output Generation] (matches the response)
   ```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 self._queue:
               _, _, name, data = heapq.heappop(self._queue)
               return name, data
           return None
   ```
   Done. 
   [Output Generation] -> *Proceeds* (Note: I'll output exactly this block)
   *(Self-Correction/Verification during thought)*: Wait, `tuple[str, dict] | None` is valid in 3.10+. If they want strict compatibility, I could use `Optional[tuple[str, dict]]`, but the prompt explicitly uses the union syntax. I'll keep it as is. It's fine.
   All requirements met. Output matches.✅
   [Final Response Generation] -> *Proceeds*

</reasoning_content>

<content>
```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 self._queue:
            _, _, name, data = heapq.heappop(self._queue)
            return name, data
        return None
```
</content>