<reasoning_content>
*   Goal: Implement priority-based job scheduling for a queue.
    *   Input requirements:
        1.  Modify `add_job` to accept `priority` (default=0).
        2.   Higher priority = higher precedence (e.g., 2 > 1 > 0).
        3.   Same priority = FIFO (First-In, First-Out).
        4.   Add `get_next_job()` to return the highest priority job.
    *   Priority levels: 0 (Normal), 1 (High), 2 (Critical).

    *   Standard `queue.Queue` or `list` won't work easily for priority without sorting or specialized structures.
    *   `heapq` (min-heap) is the standard Python way to handle priority queues.
    *   Since `heapq` is a min-heap and I want *higher* priority values (2 > 0) to come out first, I should store the priority as a negative number (e.g., -2, -1, 0).
    *   To maintain FIFO for same priorities, I need an entry count/timestamp to act as a tie-breaker.

    *   `JobQueue` class.
    *   `__init__`: Initialize `heapq` list and a counter.
    *   `add_job(job_name, metadata, priority=0)`:
        *   Convert priority to negative: `-priority`.
        *   Push `(-priority, count, job_name, metadata)` into the heap.
    *   `get_next_job()`:
        *   Pop from the heap.
        *   Return `(job_name, metadata)`.

    *   *Wait*, the prompt asks to *modify* the existing structure (implied by "Modify `add_job`"). Usually, this implies a class structure where `add_job` is already there. Since the user didn't provide the original code, I should provide a complete class structure that satisfies the requirements.

    *   *Self-Correction on Priority*: If priority 2 is "Critical" and 0 is "Normal", and `heapq` is a min-heap:
        *   Value 2 should come out before Value 0.
        *   In a min-heap, -2 comes before -0. Correct.

    ```python
    import heapq

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

        def add_job(self, name: str, metadata: dict, priority: int = 0):
            # Use negative priority for max-heap behavior with heapq (min-heap)
            # Use counter to maintain FIFO for same priority
            heapq.heappush(self._queue, (-priority, self._counter, name, metadata))
            self._counter += 1

        def get_next_job(self) -> tuple[str, dict] | None:
            if not self._queue:
                return None
            priority_neg, count, name, metadata = heapq.heappop(self._queue)
            return (name, metadata)
    ```

    *   Requirement 1: `add_job` accepts `priority=0`. Check.
    *   Requirement 2: Higher priority (2) before lower (0). `-2 < -1 < 0`, so `-2` comes out first. Check.
    *   Requirement 3: Same priority FIFO. `count` ensures this. Check.
    *   Requirement 4: `get_next_job() -> tuple[str, dict] | None`. Check.
</reasoning_content>

<content>
```python
import heapq

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

    def add_job(self, name: str, metadata: dict, priority: int = 0):
        # heapq is a min-heap. To make higher numbers higher priority, 
        # we store priority as a negative number.
        # self._counter ensures FIFO order for jobs with the same priority.
        heapq.heappush(self._queue, (-priority, self._counter, name, metadata))
        self._counter += 1

    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._queue:
            return None
        
        priority_neg, count, name, metadata = heapq.heappop(self._queue)
        return (name, metadata)
```
</content>