Here's the complete refactored package. Since the original monolithic code wasn't provided, I've reconstructed it using standard, production-ready patterns that align exactly with your specified responsibilities.

### `queue/__init__.py`
```python
from .core import Job, JobQueue

__all__ = ["Job", "JobQueue"]
```
*Exports only the public API as requested. Submodules remain accessible via `queue.priority` or `queue.retry` if needed.*

---

### `queue/core.py`
```python
from dataclasses import dataclass, field
from typing import List, Optional
import time
import threading

@dataclass
class Job:
    """Represents a single job to be processed."""
    id: str
    payload: any
    status: str = "pending"
    retries: int = 0
    priority: int = 0
    created_at: float = field(default_factory=time.time)
    updated_at: float = field(default_factory=time.time)

class JobQueue:
    """Basic FIFO job queue with thread-safe operations."""
    def __init__(self):
        self._queue: List[Job] = []
        self._lock = threading.Lock()

    def add(self, job: Job) -> None:
        with self._lock:
            self._queue.append(job)

    def get(self) -> Optional[Job]:
        with self._lock:
            return self._queue.pop(0) if self._queue else None

    def complete(self, job: Job) -> None:
        with self._lock:
            job.status = "completed"
            job.updated_at = time.time()

    def fail(self, job: Job) -> None:
        with self._lock:
            job.status = "failed"
            job.updated_at = time.time()
```

---

### `queue/priority.py`
```python
import heapq
from typing import Optional
from .core import Job, JobQueue

class PriorityQueue(JobQueue):
    """Priority queue that processes lower priority numbers first."""
    def __init__(self):
        super().__init__()
        self._heap: list = []
        self._counter: int = 0  # Tie-breaker for stable ordering

    def add(self, job: Job) -> None:
        # heapq is a min-heap; lower number = higher priority
        with self._lock:
            entry = (job.priority, self._counter, job)
            self._counter += 1
            heapq.heappush(self._heap, entry)

    def get(self) -> Optional[Job]:
        with self._lock:
            while self._heap:
                _, _, job = heapq.heappop(self._heap)
                # Skip already completed jobs
                if job.status != "completed":
                    return job
            return None
```

---

### `queue/retry.py`
```python
import time
import random
from typing import Callable, Any
from .core import Job

def process_with_retry(
    job: Job,
    processor: Callable[[Job], Any],
    max_retries: int = 3,
    base_delay: float = 1.0,
    jitter: bool = True
) -> Any:
    """Process a job with exponential backoff retry logic."""
    last_exception = None

    for attempt in range(max_retries + 1):
        try:
            return processor(job)
        except Exception as e:
            last_exception = e
            job.retries += 1
            job.status = "retrying"
            job.updated_at = time.time()

            if attempt < max_retries:
                delay = base_delay * (2 ** attempt)
                if jitter:
                    delay += random.uniform(0, delay * 0.25)
                time.sleep(delay)

    job.status = "failed"
    job.updated_at = time.time()
    raise last_exception
```

---

### Key Design Decisions
1. **Single Responsibility**: 
   - `core.py`: Data modeling & basic FIFO queue mechanics
   - `priority.py`: Ordering logic via `heapq` (inherits queue base)
   - `retry.py`: Fault tolerance & backoff strategy
2. **Thread Safety**: Added `threading.Lock` to queue operations to prevent race conditions in concurrent workers.
3. **Clean API**: `__init__.py` strictly exposes only `Job` and `JobQueue`. Consumers can still access `PriorityQueue` and `process_with_retry` via relative imports if needed:
   ```python
   from queue.priority import PriorityQueue
   from queue.retry import process_with_retry
   ```
4. **Type Safety**: Full type hints and type-safe dataclasses ensure IDE support and static analysis compatibility.

Let me know if you need async variants, persistence backing, or worker pool integration!