<reasoning_content>
*   Goal: Implement priority-based job scheduling for a queue.
    *   Requirements:
        1. `add_job` takes an optional `priority` (default=0).
        2. Higher priority (larger number) comes first.
        3. Same priority = FIFO (First-In, First-Out).
        4. `get_next_job()` returns a tuple `(job_name, job_data)` or `None`.
    *   Priority Levels: 0 (Normal), 1 (High), 2 (Critical).
    *   Constraint: Write only Python code, no explanations.

    *   Python's `heapq` module is perfect for priority queues.
    *   However, `heapq` is a *min-heap* (lowest value comes first).
    *   Requirement: Higher priority (higher number) comes first.
    *   Solution: Use negative numbers for priority in the heap (e.g., priority 2 becomes -2, priority 0 becomes 0). Or, use a custom comparison or just stick to negative numbers.
    *   Requirement: FIFO for same priority.
    *   Solution: Include a counter (serial number) in the heap elements. A tuple `(priority_score, counter, job_name, job_data)` ensures that if priority scores are equal, the smaller counter (earlier entry) is popped first.

    ```python
    import heapq
    import threading

    class JobQueue:
        def __init__(self):
            self._queue = []
            self._counter = 0
            self._lock = threading.Lock() # Good practice for thread safety, though not strictly requested.

        def add_job(self, name: str, data: dict, priority: int = 0):
            # Priority is 0, 1, 2.
            # heapq is min-heap. We want highest priority first.
            # Use -priority so that -2 < -1 < 0.
            with self._lock:
                heapq.heappush(self._queue, (-priority, self._counter, name, data))
                self._counter += 1

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

    *   `add_job` signature: `add_job(self, name: str, data: dict, priority: int = 0)` - OK.
    *   Higher priority first: Yes, `heapq` pops the smallest value. `-2` is smaller than `-1`. OK.
    *   FIFO for same priority: Yes, `self._counter` ensures order. OK.
    *   `get_next_job` return type: `tuple[str, dict] | None`. OK.

    *   Need to include `heapq`.
    *   Class definition.
    *   Methods.

    Wait, the prompt doesn't specify thread safety, but it's a queue, so a lock is usually implied in production code. However, keep it simple unless necessary. The prompt asks to "Modify", implying an existing structure, but since no base code was provided, I must define the class.

    Actually, let's check the input again. "Modify `add_job`... Add `get_next_job()`...". I'll provide the full class structure.

    ```python
    import heapq
    from typing import Tuple, Dict, Optional

    class JobQueue:
        def __init__(self):
            self.queue = []
            self.counter = 0

        def add_job(self, name: str, data: dict, priority: int = 0):
            # Using negative priority because heapq is a min-heap
            # and we want higher priority values to be processed first.
            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
            priority_score, counter, name, data = heapq.heappop(self.queue)
            return (name, data)
    ```

    Let's double check priority levels:
    0: Normal
    1: High
    2: Critical
    If I push (-2, 0, "crit", {}) and (-1, 1, "high", {}), `-2` is smaller than `-1`, so `heapq.heappop` will return the `-2` one first. This is correct.

    One small detail: The return type requested is `tuple[str, dict] | None`. Python 3.10+ syntax is allowed.

    Final 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):
            # heapq is a min-heap. To prioritize higher numbers,
            # we store them as negative values.
            # The counter ensures FIFO for identical priorities.
            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, the example shows `queue.add_job("normal", {"type": "normal"}, priority=0)`.
    My method signature: `add_job(self, name: str, data: dict, priority: int = 0)`. Matches.

    Check imports. `heapq` is standard.

    Final Code check:
    - `add_job` signature? Yes.
    - Higher priority first? Yes (-2 < -1 < 0).
    - FIFO same priority? Yes (counter).
    - `get_next_job` return type? Yes.

    Wait, should I use `typing`? The prompt uses `tuple[str, dict] | None` which is native in modern Python. I'll use that style.

    One detail: the prompt doesn't provide the base class, but asks to "Modify" and "Add". I will provide the full class.

    One final check: The instructions say "Write only the Python code, no explanations."

    ```python
    import heapq

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

        def add_job(self, name: str, data: dict, priority: int = 0):
            # heapq is a min-heap. We use negative priority so that 
            # higher priority values are popped first. 
            # Counter maintains FIFO for same priority.
            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)
    ```
</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):
        # heapq is a min-heap. By using a negative priority, 
        # higher priority values (e.g., 2) become smaller 
        # values (-2) and are popped first. 
        # The counter ensures FIFO order for identical priorities.
        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>