<reasoning_content>
Here's a thinking process:

1.  **Understand User Requirements:**
   - Implement a priority-based job scheduling queue
   - 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 expected usage
   - Output only Python code, no explanations

2.  **Identify Key Components:**
   - Need a class `JobQueue`
   - Need to store jobs in a way that supports priority ordering and FIFO for same priority
   - Python's `heapq` module is perfect for priority queues. However, `heapq` is a min-heap by default. To make higher priority come first, we can negate the priority or use a tuple like `(-priority, insertion_order, job_name, job_data)`
   - Need to maintain FIFO for same priority: use a counter/timestamp for insertion order
   - `add_job(name: str, data: dict, priority: int = 0)`
   - `get_next_job() -> tuple[str, dict] | None`

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

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

4.  **Check Requirements:**
   - Modify `add_job` to accept optional priority parameter (default=0) -> Yes
   - Higher priority jobs processed before lower -> Yes, using `-priority` in min-heap
   - Same priority maintain FIFO -> Yes, using `_counter` as second element in tuple
   - Add `get_next_job() -> tuple[str, dict] | None` -> Yes
   - Priority levels 0, 1, 2 -> Handled naturally by integer comparison
   - Example matches -> Yes
   - Only Python code, no explanations -> Will output just the code

5.  **Refine Code:**
   Let's make sure type hints match the requirement exactly: `tuple[str, dict] | None`
   Python 3.10+ supports `|` for union types. I'll use it as requested.
   I'll add necessary imports.
   The class structure looks solid.

   One minor thing: The requirement says "Modify `add_job`", implying there might be an existing structure, but since none is provided, I'll provide the complete class.
   I'll ensure the type hints are correct.
   `from typing import Optional` isn't strictly needed if using `| None`, but I'll stick to the exact signature requested.

   Let's write it out carefully:
   ```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
   ```

   Wait, should I include type hints for `add_job`? The prompt doesn't specify, but it's good practice. I'll keep it simple.
   The prompt says "Write only the Python code, no explanations."
   I'll output exactly the class implementation.

   Let's double-check the FIFO requirement: `heapq` is stable for equal keys? Actually, `heapq` doesn't guarantee stability for equal keys, which is why the counter is necessary. The tuple comparison will compare the second element (counter) when priorities are equal, ensuring FIFO. This is correct.

   One thing: `tuple[str, dict] | None` syntax is Python 3.10+. I'll assume modern Python.
   I'll add `import heapq` at the top.
   All requirements met.

   Final 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 not self._queue:
               return None
           _, _, name, data = heapq.heappop(self._queue)
           return name, data
   ```
   This matches all constraints. I'll output it.✅
   Self-Correction/Verification during thought:
   - Does `heapq` work with tuples? Yes, compares element by element.
   - `-priority` ensures higher priority numbers come first (since min-heap pops smallest first).
   - `_counter` ensures FIFO for same priority.
   - Returns `tuple[str, dict] | None` as specified.
   - Default priority=0.
   - All good.
   Output matches exactly.✅
   Proceed. 
   One minor point: The prompt says "Modify `add_job`", but since I'm providing the full class, it's fine. I'll just provide the complete class implementation.
   I'll make sure the code is standalone and ready to run.
   All set. 
   Output generation. 
   [Code matches the refined version]✅
   Note: I'll use `from typing import Optional` if needed, but the prompt explicitly uses `tuple[str, dict] | None`, so I'll stick to that. Python 3.10+ supports it natively. I'll just write it as requested.
   Ready. 
   Output matches response. 
   [Done] 
   *Self-Correction/Refinement during generation prep*: 
   I should ensure the type hint syntax is exactly as requested. The prompt uses `tuple[str, dict] | None`. I'll keep that.
   I'll add `import heapq` at the top.
   The code is minimal and correct.
   Proceeds. 
   [Output Generation] -> *See response*
   *(Done.)*

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