<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 shows usage
   - Output only Python code, no explanations

2.  **Identify Key Components:**
   - Need a `JobQueue` class
   - `add_job(name: str, params: dict, priority: int = 0)`
   - `get_next_job() -> tuple[str, dict] | None`
   - Internal data structure to maintain priority and FIFO order
   - Python's `heapq` module is perfect for priority queues, but it's a min-heap by default. We want higher priority processed first, so we can negate the priority or use a max-heap approach. Alternatively, store `(-priority, insertion_order, name, params)` to maintain FIFO for same priority.
   - Need a counter for insertion order to maintain FIFO for same priority.

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, params: dict, priority: int = 0) -> None:
           # Use negative priority so higher priority comes first in min-heap
           # Use counter to maintain FIFO for same priority
           heapq.heappush(self._queue, (-priority, self._counter, name, params))
           self._counter += 1

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

4.  **Check Requirements:**
   - `add_job` accepts optional priority (default=0)? Yes.
   - Higher priority processed first? Yes, using `-priority` in min-heap.
   - Same priority maintains FIFO? Yes, using `_counter`.
   - `get_next_job() -> tuple[str, dict] | None`? Yes, returns tuple or None.
   - Priority levels mentioned are just documentation, but the code handles any integer priority.
   - Example matches usage.
   - Only Python code, no explanations? Yes.

5.  **Refine Code:**
   Let's make sure type hints match exactly what's requested. The prompt says `get_next_job() -> tuple[str, dict] | None`. I'll use `typing` module for compatibility or just Python 3.10+ syntax. The prompt uses `tuple[str, dict] | None`, so I'll stick with that.

   ```python
   import heapq

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

       def add_job(self, name: str, params: dict, priority: int = 0) -> None:
           heapq.heappush(self._queue, (-priority, self._counter, name, params))
           self._counter += 1

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

   Wait, should I include type imports? The prompt uses `tuple[str, dict] | None` which is valid in Python 3.10+. I'll keep it as is. I can add `from typing import Tuple, Dict` if needed, but modern Python supports built-in generics. I'll stick to built-in generics as requested.

   Let's double-check the FIFO requirement: "Jobs with the same priority should maintain FIFO order". The counter ensures that. When priorities are equal, `-priority` is equal, so heapq compares the next element, which is `_counter`. Since `_counter` increases, earlier jobs have smaller counters, so they come out first. Perfect.

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

   Code looks solid. I'll output just the code as requested.
   Should I include the `import heapq`? Yes.
   Should I wrap it in a class? Yes, `JobQueue`.
   All requirements met.

   Final check of the prompt: "Write only the Python code, no explanations."
   I will output exactly the code block.
   One thing: `tuple[str, dict] | None` syntax requires Python 3.10+. I'll use it as is. Alternatively, I can use `typing` to be safe, but the prompt explicitly shows that syntax. I'll stick with it.

   Let's write it out. 
   I'll make sure the class name matches the example: `JobQueue`.
   Methods: `add_job`, `get_next_job`.
   All good.
   Output matches exactly.✅
   Proceed. 
   Self-Correction/Verification during thought:
   - Does `heapq` handle tuples correctly? Yes, it compares element by element.
   - `-priority` ensures higher priority comes first.
   - `_counter` ensures FIFO for same priority.
   - Return type matches.
   - Default priority=0 matches.
   - Example usage would work.
   - No extra text.
   Ready. 
   Output matches the refined code.✅
   One minor point: The prompt says `get_next_job() -> tuple[str, dict] | None`. I'll keep the type hint exactly as requested.
   I'll produce the code now. 
   ```python
   import heapq

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

       def add_job(self, name: str, params: dict, priority: int = 0) -> None:
           heapq.heappush(self._queue, (-priority, self._counter, name, params))
           self._counter += 1

       def get_next_job(self) -> tuple[str, dict] | None:
           if self._queue:
               _, _, name, params = heapq.heappop(self._queue)
               return name, params
           return None
   ```
   This looks correct and complete. No extra fluff. Matches all constraints. Output matches.✅
   Proceeds. 
   [Output Generation] -> *Proceeds*
   *(Self-Correction/Refinement during generation prep)*: 
   I should ensure the type hint `tuple[str, dict] | None` is valid. In Python 3.9+, `tuple[str, dict]` works. `| None` works in 3.10+. It's fine. I'll keep it.
   All good. 
   Output matches exactly. 
   [Done] 
   *Output Generation* (matches the refined code)
   ```python
   import heapq

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

       def add_job(self, name: str, params: dict, priority: int = 0) -> None:
           heapq.heappush(self._queue, (-priority, self._counter, name, params))
           self._counter += 1

       def get_next_job(self) -> tuple[str, dict] | None:
           if self._queue:
               _, _, name, params = heapq.heappop(self._queue)
               return name, params
           return None
   ```
   This is exactly what's needed. No extra text. Matches requirements. Done. 
   [Output Generation] -> *Proceeds* (matches response)
   *(Note: I'll make sure formatting is exact as requested)*
   All good. 
   [Final Check of the Prompt]: "Write only the Python code, no explanations." -> I will output just the code block.
   Ready. 
   [Output] -> *Proceeds*

</reasoning_content>

<content>
```python
import heapq

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

    def add_job(self, name: str, params: dict, priority: int = 0) -> None:
        heapq.heappush(self._queue, (-priority, self._counter, name, params))
        self._counter += 1

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