<reasoning_content>
*   Requirement 1: Modify `add_job` to accept `priority` (default=0).
    *   Requirement 2: Higher priority jobs first (Priority 2 > 1 > 0).
    *   Requirement 3: FIFO for same priority.
    *   Requirement 4: `get_next_job()` returns the highest priority job.
    *   Data structure: A priority queue is ideal here. Specifically, since we need FIFO for same priorities, we need a way to handle ties. Python's `heapq` is the standard for priority queues.

    *   `heapq` implements a min-heap. To make it a max-priority queue, we can store priorities as negative numbers (e.g., -2 for priority 2).
    *   To maintain FIFO order for equal priorities, we should include an auto-incrementing counter in the heap tuple: `(negative_priority, entry_count, job_id, job_data)`.

    *   `__init__`: Initialize `self.jobs` (list for heap) and `self.counter` (integer).
    *   `add_job(self, job_id: str, data: dict, priority: int = 0)`:
        *   Push `(-priority, self.counter, job_id, data)` into `self.jobs`.
        *   Increment `self.counter`.
    *   `get_next_job(self) -> tuple[str, dict] | None`:
        *   Pop from `self.jobs`.
        *   Return `(job_id, data)`.
        *   Handle empty queue.

    *   `priority=2` -> stored as `-2`.
    *   `priority=1` -> stored as `-1`.
    *   `priority=0` -> stored as `0`.
    *   `heapq.heappop` gives the smallest value. `-2` is smaller than `-1`. Correct.
    *   Counter handles FIFO. If priorities are the same, the smaller counter value wins. Correct.

    ```python
    import heapq

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

        def add_job(self, job_id: str, data: dict, priority: int = 0):
            # Use negative priority because heapq is a min-heap
            # counter ensures FIFO for same priority
            heapq.heappush(self.jobs, (-priority, self.counter, job_id, data))
            self.counter += 1

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

    *   Accept optional priority? Yes.
    *   Higher priority first? Yes (via negative numbers).
    *   FIFO for same priority? Yes (via counter).
    *   `get_next_job` signature correct? Yes.
</reasoning_content>

<content>
```python
import heapq

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

    def add_job(self, job_id: str, data: dict, priority: int = 0):
        # Use negative priority because heapq is a min-heap (lower value = higher priority)
        # Use a counter to maintain FIFO order for jobs with the same priority
        heapq.heappush(self.jobs, (-priority, self.counter, job_id, data))
        self.counter += 1

    def get_next_job(self) -> tuple[str, dict] | None:
        if not self.jobs:
            return None
        
        _, _, job_id, data = heapq.heappop(self.jobs)
        return (job_id, data)
```
</content>