diff --git a/ser/_internal/transcription/compatibility.py b/ser/_internal/transcription/compatibility.py
index 1e57c373..2a6cd66d 100644
--- a/ser/_internal/transcription/compatibility.py
+++ b/ser/_internal/transcription/compatibility.py
@@ -4,15 +4,17 @@
 
 import logging
 from collections.abc import Callable
-from typing import Literal, Protocol, TypeVar
+from typing import TYPE_CHECKING, Literal, Protocol, TypeVar
 
 from ser.config import AppConfig
 from ser.profiles import TranscriptionBackendId
-from ser.transcript.backends import (
-    BackendRuntimeRequest,
-    CompatibilityIssueImpact,
-    CompatibilityReport,
-)
+
+if TYPE_CHECKING:
+    from ser.transcript.backends.base import (
+        BackendRuntimeRequest,
+        CompatibilityIssueImpact,
+        CompatibilityReport,
+    )
 
 type _CompatibilityIssueKind = Literal["noise", "operational"]
 type _EmittedIssueKeySet = set[tuple[str, str, str]]
diff --git a/ser/_internal/transcription/process_isolation.py b/ser/_internal/transcription/process_isolation.py
index 85e46c44..f98b083e 100644
--- a/ser/_internal/transcription/process_isolation.py
+++ b/ser/_internal/transcription/process_isolation.py
@@ -4,9 +4,10 @@
 
 import logging
 from collections.abc import Callable
+from numbers import Real
 from pathlib import Path
 from types import ModuleType
-from typing import Literal, Never, Protocol, TypeVar, cast
+from typing import TYPE_CHECKING, Literal, Never, Protocol, TypeVar, cast
 
 from ser.config import AppConfig
 from ser.profiles import TranscriptionBackendId
@@ -20,11 +21,14 @@
     log_phase_failed,
     log_phase_started,
 )
-from ser.transcript.backends import BackendRuntimeRequest
+
+if TYPE_CHECKING:
+    from ser.transcript.backends.base import BackendRuntimeRequest
 
 type _WorkerPhase = Literal["setup_complete", "model_loaded"]
 type WorkerPhaseMessage = tuple[Literal["phase"], _WorkerPhase]
-type WorkerSuccessMessage = tuple[Literal["ok"], list[tuple[str, float, float]]]
+type SerializedTranscriptWord = tuple[str, float, float]
+type WorkerSuccessMessage = tuple[Literal["ok"], list[SerializedTranscriptWord]]
 type WorkerErrorMessage = tuple[Literal["err"], str, str, str]
 type WorkerMessage = WorkerPhaseMessage | WorkerSuccessMessage | WorkerErrorMessage
 
@@ -247,6 +251,71 @@ def transcribe(
 type _AdapterResolver = Callable[[TranscriptionBackendId], object]
 
 
+def _is_real_timestamp(value: object) -> bool:
+    """Returns whether one worker timestamp payload is numeric and non-bool."""
+    return isinstance(value, Real) and not isinstance(value, bool)
+
+
+def _serialize_transcript_words(
+    transcript_words: list[object],
+) -> list[SerializedTranscriptWord]:
+    """Converts backend transcript words into a validated worker payload."""
+    serialized_words: list[SerializedTranscriptWord] = []
+    for index, raw_word in enumerate(transcript_words):
+        word = cast(_TranscriptWordLike, raw_word)
+        if not isinstance(word.word, str):
+            raise TypeError(
+                "Transcription worker produced a non-string token " f"at index {index}."
+            )
+        if not _is_real_timestamp(word.start_seconds) or not _is_real_timestamp(word.end_seconds):
+            raise TypeError(
+                "Transcription worker produced non-numeric timestamps " f"at index {index}."
+            )
+        serialized_words.append(
+            (
+                word.word,
+                float(word.start_seconds),
+                float(word.end_seconds),
+            )
+        )
+    return serialized_words
+
+
+def _deserialize_transcript_words(
+    serialized_words: object,
+    *,
+    transcript_word_factory: Callable[[str, float, float], _TTranscriptWord],
+    error_factory: _ErrorFactory,
+) -> list[_TTranscriptWord]:
+    """Builds transcript words from validated worker payload tuples."""
+    if not isinstance(serialized_words, list):
+        raise error_factory("Transcription worker returned malformed transcript payload.")
+    transcript_words: list[_TTranscriptWord] = []
+    for index, raw_word in enumerate(serialized_words):
+        if not isinstance(raw_word, tuple) or len(raw_word) != 3:
+            raise error_factory(
+                "Transcription worker returned malformed transcript payload " f"at index {index}."
+            )
+        word, start_seconds, end_seconds = raw_word
+        if not isinstance(word, str):
+            raise error_factory(
+                "Transcription worker returned non-string transcript token " f"at index {index}."
+            )
+        if not _is_real_timestamp(start_seconds) or not _is_real_timestamp(end_seconds):
+            raise error_factory(
+                "Transcription worker returned non-numeric transcript timestamps "
+                f"at index {index}."
+            )
+        transcript_words.append(
+            transcript_word_factory(
+                word,
+                float(start_seconds),
+                float(end_seconds),
+            )
+        )
+    return transcript_words
+
+
 def should_use_process_isolated_path(profile: _ProcessIsolatedProfile) -> bool:
     """Returns whether one transcription profile should use worker-process isolation."""
     return profile.backend_id == "faster_whisper"
@@ -260,6 +329,8 @@ def runtime_request_for_isolated_faster_whisper(
     logger: logging.Logger,
 ) -> BackendRuntimeRequest:
     """Builds one faster-whisper runtime request without importing torch in worker."""
+    from ser.transcript.backends.base import BackendRuntimeRequest
+
     if profile.backend_id != "faster_whisper":
         raise error_factory(
             "Process-isolated runtime request only supports faster-whisper backend."
@@ -388,14 +459,7 @@ def transcription_worker_entry(
             language=payload.language,
             settings=settings,
         )
-        serialized_words = [
-            (
-                cast(_TranscriptWordLike, word).word,
-                cast(_TranscriptWordLike, word).start_seconds,
-                cast(_TranscriptWordLike, word).end_seconds,
-            )
-            for word in transcript_words
-        ]
+        serialized_words = _serialize_transcript_words(transcript_words)
         connection.send(("ok", serialized_words))
     except BaseException as err:
         connection.send(("err", stage, type(err).__name__, str(err)))
@@ -488,9 +552,7 @@ def run_faster_whisper_process_isolated(
             isinstance(completion_message, tuple)
             and len(completion_message) == 2
             and completion_message[0] == "ok"
-            and isinstance(completion_message[1], list)
         ):
-            serialized_words = completion_message[1]
             if transcription_started_at is None:
                 raise error_factory(
                     "Transcription worker completed transcription before phase timer start."
@@ -500,10 +562,11 @@ def run_faster_whisper_process_isolated(
                 phase_name=PHASE_TRANSCRIPTION,
                 started_at=transcription_started_at,
             )
-            return [
-                transcript_word_factory(word, start_seconds, end_seconds)
-                for word, start_seconds, end_seconds in serialized_words
-            ]
+            return _deserialize_transcript_words(
+                completion_message[1],
+                transcript_word_factory=transcript_word_factory,
+                error_factory=error_factory,
+            )
         raise_worker_error_fn(completion_message)
     except Exception:
         if transcription_started_at is not None:
diff --git a/ser/_internal/transcription/process_worker.py b/ser/_internal/transcription/process_worker.py
index 25b7ba15..6b1ac758 100644
--- a/ser/_internal/transcription/process_worker.py
+++ b/ser/_internal/transcription/process_worker.py
@@ -8,11 +8,13 @@
 from dataclasses import dataclass
 from pathlib import Path
 from types import ModuleType
-from typing import Protocol
+from typing import TYPE_CHECKING, Protocol
 
 from ser.config import AppConfig
 from ser.profiles import TranscriptionBackendId
-from ser.transcript.backends import BackendRuntimeRequest
+
+if TYPE_CHECKING:
+    from ser.transcript.backends.base import BackendRuntimeRequest
 
 
 class ProcessIsolatedProfileLike(Protocol):
diff --git a/ser/_internal/transcription/public_boundary_process.py b/ser/_internal/transcription/public_boundary_process.py
index c0169b29..e62db3b4 100644
--- a/ser/_internal/transcription/public_boundary_process.py
+++ b/ser/_internal/transcription/public_boundary_process.py
@@ -6,16 +6,18 @@
 from collections.abc import Callable
 from multiprocessing.connection import Connection
 from multiprocessing.process import BaseProcess
-from typing import Never, Protocol, TypeVar, cast
+from typing import TYPE_CHECKING, Never, Protocol, TypeVar, cast
 
 from ser.config import AppConfig
 from ser.domain import TranscriptWord
 from ser.profiles import TranscriptionBackendId
-from ser.transcript.backends import BackendRuntimeRequest
 
 from .process_isolation import WorkerMessage
 from .process_worker import TranscriptionProcessPayload
 
+if TYPE_CHECKING:
+    from ser.transcript.backends.base import BackendRuntimeRequest
+
 
 class _ProcessIsolatedProfile(Protocol):
     """Minimal profile contract for public-boundary worker execution."""
diff --git a/ser/_internal/transcription/public_boundary_runtime.py b/ser/_internal/transcription/public_boundary_runtime.py
index 7a690568..06e659e0 100644
--- a/ser/_internal/transcription/public_boundary_runtime.py
+++ b/ser/_internal/transcription/public_boundary_runtime.py
@@ -4,12 +4,14 @@
 
 import logging
 from collections.abc import Callable
-from typing import cast
+from typing import TYPE_CHECKING, cast
 
 from ser.config import AppConfig
 from ser.domain import TranscriptWord
 from ser.profiles import TranscriptionBackendId
-from ser.transcript.backends import BackendRuntimeRequest, CompatibilityReport
+
+if TYPE_CHECKING:
+    from ser.transcript.backends.base import BackendRuntimeRequest, CompatibilityReport
 
 type _ResolveTranscriptionProfileImpl = Callable[..., object]
 type _ResolveBackendId = Callable[..., TranscriptionBackendId]
diff --git a/ser/_internal/transcription/public_boundary_support.py b/ser/_internal/transcription/public_boundary_support.py
index 75ba5227..dfd2c169 100644
--- a/ser/_internal/transcription/public_boundary_support.py
+++ b/ser/_internal/transcription/public_boundary_support.py
@@ -5,7 +5,7 @@
 import logging
 import multiprocessing as mp
 from collections.abc import Callable
-from typing import Literal, Never, Protocol, cast
+from typing import TYPE_CHECKING, Literal, Never, Protocol, cast
 
 from ser._internal.transcription.compatibility import (
     check_adapter_compatibility as _check_adapter_compatibility_impl,
@@ -113,16 +113,15 @@
 from ser.config import AppConfig
 from ser.domain import TranscriptWord
 from ser.profiles import TranscriptionBackendId
-from ser.transcript.backends import (
-    BackendRuntimeRequest,
-    CompatibilityReport,
-    resolve_transcription_backend_adapter,
-)
+from ser.transcript.backends.factory import resolve_transcription_backend_adapter
 from ser.transcript.runtime_policy import (
     DEFAULT_MPS_LOW_MEMORY_THRESHOLD_GB,
     resolve_transcription_runtime_policy,
 )
 
+if TYPE_CHECKING:
+    from ser.transcript.backends.base import BackendRuntimeRequest, CompatibilityReport
+
 _CompatibilityIssueKind = Literal["noise", "operational"]
 
 
diff --git a/ser/_internal/transcription/runtime_profile.py b/ser/_internal/transcription/runtime_profile.py
index 4bb0f739..16ffa2e0 100644
--- a/ser/_internal/transcription/runtime_profile.py
+++ b/ser/_internal/transcription/runtime_profile.py
@@ -3,11 +3,13 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import Protocol, cast
+from typing import TYPE_CHECKING, Protocol, cast
 
 from ser.config import AppConfig
 from ser.profiles import TranscriptionBackendId
-from ser.transcript.backends import BackendRuntimeRequest
+
+if TYPE_CHECKING:
+    from ser.transcript.backends.base import BackendRuntimeRequest
 
 
 class _RuntimeProfile(Protocol):
@@ -119,6 +121,8 @@ def runtime_request_from_profile(
     default_mps_low_memory_threshold_gb: float,
 ) -> BackendRuntimeRequest:
     """Builds one backend runtime request from transcription profile settings."""
+    from ser.transcript.backends.base import BackendRuntimeRequest
+
     torch_runtime = getattr(settings, "torch_runtime", None)
     transcription_settings = getattr(settings, "transcription", None)
     requested_device = getattr(torch_runtime, "device", "cpu")
diff --git a/tests/suites/integration/docs/test_architecture_docs.py b/tests/suites/integration/docs/test_architecture_docs.py
index 07cb7664..68bbef7a 100644
--- a/tests/suites/integration/docs/test_architecture_docs.py
+++ b/tests/suites/integration/docs/test_architecture_docs.py
@@ -13,11 +13,6 @@
     r"https://github\.com/jsugg/ser/(?:blob|tree)/main/(docs/[A-Za-z0-9_./-]+)"
 )
 _ARCHITECTURE_RELATIVE_LINK_PATTERN = re.compile(r"\(([^)]+)\)")
-_ARCHITECTURE_COUNT_PATTERN = re.compile(
-    r"- (?P<label>Source modules under `ser/`|Test modules under `tests/`|"
-    r"Public modules outside `_internal/`|Internal owner/helper modules under `_internal/`): "
-    r"`(?P<count>\d+)`"
-)
 _REMOVED_TRACKER_REFERENCES = (
     "ser_refactor_implementation_journal.md",
     "ser_refactor_status.md",
@@ -29,22 +24,6 @@ def _repo_root() -> Path:
     return Path(__file__).resolve().parents[4]
 
 
-def _expected_codebase_counts(root: Path) -> dict[str, int]:
-    """Builds the current architecture snapshot counts from the working tree."""
-    source_files = list((root / "ser").rglob("*.py"))
-    test_files = list((root / "tests").rglob("*.py"))
-    return {
-        "Source modules under `ser/`": len(source_files),
-        "Test modules under `tests/`": len(test_files),
-        "Public modules outside `_internal/`": sum(
-            1 for path in source_files if "_internal" not in path.parts
-        ),
-        "Internal owner/helper modules under `_internal/`": sum(
-            1 for path in source_files if "_internal" in path.parts
-        ),
-    }
-
-
 def test_readme_architecture_links_resolve_to_existing_docs() -> None:
     """README architecture links should point at docs artifacts that exist in-tree."""
     root = _repo_root()
@@ -70,18 +49,6 @@ def test_architecture_index_links_resolve_to_existing_docs() -> None:
     assert all(target.is_file() for target in resolved_targets)
 
 
-def test_codebase_architecture_snapshot_counts_match_current_tree() -> None:
-    """Architecture snapshot counts should match the current repository tree."""
-    root = _repo_root()
-    architecture_text = (root / "docs" / "codebase-architecture.md").read_text(encoding="utf-8")
-    reported_counts = {
-        match.group("label"): int(match.group("count"))
-        for match in _ARCHITECTURE_COUNT_PATTERN.finditer(architecture_text)
-    }
-
-    assert reported_counts == _expected_codebase_counts(root)
-
-
 def test_compatibility_matrix_does_not_reference_removed_tracker_docs() -> None:
     """Compatibility matrix should not point contributors at removed tracker files."""
     root = _repo_root()
diff --git a/tests/suites/integration/test_process_isolation.py b/tests/suites/integration/test_process_isolation.py
index d90dcafb..63143e1a 100644
--- a/tests/suites/integration/test_process_isolation.py
+++ b/tests/suites/integration/test_process_isolation.py
@@ -9,7 +9,8 @@
 from multiprocessing.connection import Connection
 from multiprocessing.process import BaseProcess
 from pathlib import Path
-from typing import cast
+from types import SimpleNamespace
+from typing import TYPE_CHECKING, cast
 
 import pytest
 from tests.utils.helpers import process_spawn_support
@@ -20,9 +21,13 @@
 from ser._internal.transcription import public_boundary_support as transcription_boundary_support
 from ser.config import AppConfig, reload_settings
 from ser.domain import TranscriptWord
-from ser.transcript.backends import BackendRuntimeRequest
 from ser.transcript.transcript_extractor import TranscriptionProfile
 
+if TYPE_CHECKING:
+    from ser.transcript.backends.base import BackendRuntimeRequest
+else:
+    BackendRuntimeRequest = object
+
 pytestmark = [
     pytest.mark.integration,
     pytest.mark.process_isolation,
@@ -136,14 +141,17 @@ def _parse_worker_completion_message(message: tuple[object, ...]) -> str:
 
 
 def _transcription_runtime_request() -> BackendRuntimeRequest:
-    return BackendRuntimeRequest(
-        model_name="tiny",
-        use_demucs=False,
-        use_vad=True,
-        device_spec="cpu",
-        device_type="cpu",
-        precision_candidates=("float32",),
-        memory_tier="not_applicable",
+    return cast(
+        BackendRuntimeRequest,
+        SimpleNamespace(
+            model_name="tiny",
+            use_demucs=False,
+            use_vad=True,
+            device_spec="cpu",
+            device_type="cpu",
+            precision_candidates=("float32",),
+            memory_tier="not_applicable",
+        ),
     )
 
 
diff --git a/tests/suites/unit/transcription/process/test_process_isolation_internal.py b/tests/suites/unit/transcription/process/test_process_isolation_internal.py
new file mode 100644
index 00000000..1f74a4fe
--- /dev/null
+++ b/tests/suites/unit/transcription/process/test_process_isolation_internal.py
@@ -0,0 +1,543 @@
+"""Unit tests for process-isolated transcription orchestration helpers."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from types import ModuleType, SimpleNamespace
+from typing import TYPE_CHECKING, cast
+
+import pytest
+
+from ser._internal.transcription import process_isolation as isolation
+from ser._internal.transcription.process_worker import (
+    TranscriptionProcessPayload,
+    TranscriptionWorkerModelsConfig,
+    TranscriptionWorkerSettings,
+)
+from ser.config import AppConfig
+from ser.domain import TranscriptWord
+from ser.profiles import TranscriptionBackendId
+
+if TYPE_CHECKING:
+    from ser.transcript.backends.base import BackendRuntimeRequest
+else:
+    BackendRuntimeRequest = object
+
+pytestmark = pytest.mark.unit
+
+
+@dataclass(frozen=True)
+class _Profile:
+    """Minimal process-isolated transcription profile stub."""
+
+    backend_id: TranscriptionBackendId = "faster_whisper"
+    model_name: str = "tiny"
+    use_demucs: bool = False
+    use_vad: bool = True
+
+
+class _Connection:
+    """In-memory connection stub for worker message tests."""
+
+    def __init__(self, received: list[object] | None = None) -> None:
+        self._received = list(received or [])
+        self.sent: list[object] = []
+        self.closed = False
+
+    def recv(self) -> object:
+        if not self._received:
+            raise EOFError()
+        return self._received.pop(0)
+
+    def send(self, obj: object) -> None:
+        self.sent.append(obj)
+
+    def close(self) -> None:
+        self.closed = True
+
+
+class _Process:
+    """Worker process stub that tracks lifecycle method calls."""
+
+    def __init__(self, *, alive_after_join: bool = False) -> None:
+        self.args: tuple[object, ...] | None = None
+        self.target: object | None = None
+        self.daemon: bool | None = None
+        self.started = False
+        self.join_calls: list[float | None] = []
+        self.terminated = False
+        self.killed = False
+        self.closed = False
+        self._alive_after_join = alive_after_join
+
+    def start(self) -> None:
+        self.started = True
+
+    def join(self, timeout: float | None = None) -> None:
+        self.join_calls.append(timeout)
+
+    def is_alive(self) -> bool:
+        return self._alive_after_join and not self.killed
+
+    def terminate(self) -> None:
+        self.terminated = True
+
+    def kill(self) -> None:
+        self.killed = True
+
+    def close(self) -> None:
+        self.closed = True
+
+
+class _SpawnContext:
+    """Spawn-context stub returning predetermined pipe and process objects."""
+
+    def __init__(
+        self,
+        *,
+        parent_connection: _Connection,
+        child_connection: _Connection,
+        process: _Process,
+    ) -> None:
+        self.parent_connection = parent_connection
+        self.child_connection = child_connection
+        self.process = process
+        self.pipe_duplex: bool | None = None
+
+    def Pipe(self, duplex: bool = False) -> tuple[_Connection, _Connection]:
+        self.pipe_duplex = duplex
+        return self.parent_connection, self.child_connection
+
+    def Process(
+        self,
+        *,
+        target: object,
+        args: tuple[object, ...],
+        daemon: bool,
+    ) -> _Process:
+        self.process.target = target
+        self.process.args = args
+        self.process.daemon = daemon
+        return self.process
+
+
+class _Adapter:
+    """Backend adapter stub for worker-entry tests."""
+
+    def __init__(self, *, transcript_words: list[object] | None = None) -> None:
+        self.transcript_words = transcript_words or [TranscriptWord("hello", 0.0, 0.5)]
+        self.calls: list[str] = []
+
+    def setup_required(self, *, runtime_request: object, settings: object) -> bool:
+        del runtime_request, settings
+        self.calls.append("setup_required")
+        return True
+
+    def prepare_assets(self, *, runtime_request: object, settings: object) -> None:
+        del runtime_request, settings
+        self.calls.append("prepare_assets")
+
+    def load_model(self, *, runtime_request: object, settings: object) -> object:
+        del runtime_request, settings
+        self.calls.append("load_model")
+        return object()
+
+    def transcribe(
+        self,
+        *,
+        model: object,
+        runtime_request: object,
+        file_path: str,
+        language: str,
+        settings: object,
+    ) -> list[object]:
+        del model, runtime_request, file_path, language, settings
+        self.calls.append("transcribe")
+        return self.transcript_words
+
+
+def _runtime_request() -> BackendRuntimeRequest:
+    return cast(
+        BackendRuntimeRequest,
+        SimpleNamespace(
+            model_name="tiny",
+            use_demucs=False,
+            use_vad=True,
+            device_spec="cpu",
+            device_type="cpu",
+            precision_candidates=("float32",),
+            memory_tier="not_applicable",
+        ),
+    )
+
+
+def _worker_payload(*, profile: _Profile | None = None) -> TranscriptionProcessPayload:
+    active_profile = profile or _Profile()
+    return TranscriptionProcessPayload(
+        file_path="sample.wav",
+        language="en",
+        profile=active_profile,
+        runtime_request=_runtime_request(),
+        settings=TranscriptionWorkerSettings(
+            models=TranscriptionWorkerModelsConfig(
+                whisper_download_root=Path("/tmp/cache"),
+            )
+        ),
+    )
+
+
+def test_should_use_process_isolated_path_only_for_faster_whisper() -> None:
+    """Only faster-whisper profiles should use the spawned-worker path."""
+    assert isolation.should_use_process_isolated_path(_Profile()) is True
+    assert (
+        isolation.should_use_process_isolated_path(_Profile(backend_id="stable_whisper")) is False
+    )
+
+
+def test_runtime_request_for_isolated_faster_whisper_uses_cuda_precision_candidates() -> None:
+    """CUDA runtime request should preserve device and use legal precision fallbacks."""
+    settings = cast(
+        AppConfig,
+        SimpleNamespace(torch_runtime=SimpleNamespace(device="cuda:1", dtype="auto")),
+    )
+
+    resolved = isolation.runtime_request_for_isolated_faster_whisper(
+        profile=_Profile(),
+        settings=settings,
+        error_factory=RuntimeError,
+        logger=logging.getLogger("ser.tests.process_isolation"),
+    )
+
+    assert resolved.device_spec == "cuda:1"
+    assert resolved.device_type == "cuda"
+    assert resolved.precision_candidates == ("float16", "float32")
+
+
+def test_runtime_request_for_isolated_faster_whisper_falls_back_to_cpu_for_unsupported_device(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Unsupported devices should fall back to cpu/float32 with an info log."""
+    settings = cast(
+        AppConfig,
+        SimpleNamespace(torch_runtime=SimpleNamespace(device="mps", dtype="bfloat16")),
+    )
+
+    with caplog.at_level(logging.INFO):
+        resolved = isolation.runtime_request_for_isolated_faster_whisper(
+            profile=_Profile(),
+            settings=settings,
+            error_factory=RuntimeError,
+            logger=logging.getLogger("ser.tests.process_isolation"),
+        )
+
+    assert resolved.device_spec == "cpu"
+    assert resolved.device_type == "cpu"
+    assert resolved.precision_candidates == ("float32",)
+    assert "is unsupported; using cpu/float32" in caplog.text
+
+
+def test_recv_worker_message_wraps_eof_errors() -> None:
+    """EOF during worker recv should become a domain-specific runtime error."""
+    with pytest.raises(RuntimeError, match="exited before sending setup payload"):
+        isolation.recv_worker_message(
+            _Connection(),
+            stage="setup",
+            error_factory=RuntimeError,
+        )
+
+
+def test_recv_worker_message_rejects_malformed_payload() -> None:
+    """Non-tuple worker payloads should be rejected immediately."""
+    with pytest.raises(RuntimeError, match="malformed payload"):
+        isolation.recv_worker_message(
+            _Connection(received=["bad-payload"]),
+            stage="setup",
+            error_factory=RuntimeError,
+        )
+
+
+def test_raise_worker_error_formats_known_worker_error_payload() -> None:
+    """Error payloads should be rethrown with stage and type context."""
+    with pytest.raises(
+        RuntimeError,
+        match="Transcription worker transcription failed with ValueError: bad input",
+    ):
+        isolation.raise_worker_error(
+            ("err", "transcription", "ValueError", "bad input"),
+            error_factory=RuntimeError,
+        )
+
+
+def test_raise_worker_error_rejects_unexpected_payload_shape() -> None:
+    """Unexpected worker payloads should surface a deterministic boundary error."""
+    with pytest.raises(RuntimeError, match="unexpected payload shape"):
+        isolation.raise_worker_error(
+            ("phase", "setup_complete"),
+            error_factory=RuntimeError,
+        )
+
+
+def test_terminate_worker_process_kills_after_grace_timeout() -> None:
+    """Termination helper should escalate to kill when the worker stays alive."""
+    process = _Process(alive_after_join=True)
+
+    isolation.terminate_worker_process(
+        process,
+        terminate_grace_seconds=0.1,
+        kill_grace_seconds=0.2,
+    )
+
+    assert process.terminated is True
+    assert process.killed is True
+    assert process.join_calls == [0.1, 0.2]
+
+
+def test_transcription_worker_entry_reports_success_and_serializes_words(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Worker entry should emit phase notifications and a serialized success payload."""
+    adapter = _Adapter()
+    connection = _Connection()
+    payload = _worker_payload()
+    monkeypatch.setitem(sys.modules, "torch", ModuleType("torch"))
+
+    isolation.transcription_worker_entry(
+        payload,
+        connection,
+        settings_resolver=lambda: payload.settings,
+        adapter_resolver=lambda backend_id: adapter,
+    )
+
+    assert adapter.calls == ["setup_required", "prepare_assets", "load_model", "transcribe"]
+    assert connection.sent == [
+        ("phase", "setup_complete"),
+        ("phase", "model_loaded"),
+        ("ok", [("hello", 0.0, 0.5)]),
+    ]
+    assert connection.closed is True
+
+
+def test_transcription_worker_entry_maps_non_serializable_words_to_error_payload(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Worker entry should translate invalid transcript-word payloads into worker errors."""
+    adapter = _Adapter(
+        transcript_words=[SimpleNamespace(word="hello", start_seconds="bad", end_seconds=0.5)]
+    )
+    connection = _Connection()
+    payload = _worker_payload()
+    monkeypatch.setitem(sys.modules, "torch", ModuleType("torch"))
+
+    isolation.transcription_worker_entry(
+        payload,
+        connection,
+        settings_resolver=lambda: payload.settings,
+        adapter_resolver=lambda backend_id: adapter,
+    )
+
+    assert connection.sent[-1] == (
+        "err",
+        "transcription",
+        "TypeError",
+        "Transcription worker produced non-numeric timestamps at index 0.",
+    )
+    assert connection.closed is True
+
+
+def test_run_faster_whisper_process_isolated_returns_validated_transcript_words(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Parent orchestration should deserialize worker success payloads into TranscriptWord rows."""
+    phase_events: list[tuple[str, str]] = []
+
+    def _log_started(_logger: object, *, phase_name: str) -> float:
+        phase_events.append(("start", phase_name))
+        return 1.0
+
+    def _log_completed(
+        _logger: object,
+        *,
+        phase_name: str,
+        started_at: float,
+    ) -> None:
+        del started_at
+        phase_events.append(("complete", phase_name))
+
+    def _log_failed(
+        _logger: object,
+        *,
+        phase_name: str,
+        started_at: float,
+    ) -> None:
+        del started_at
+        phase_events.append(("failed", phase_name))
+
+    monkeypatch.setattr(
+        isolation,
+        "log_phase_started",
+        _log_started,
+    )
+    monkeypatch.setattr(
+        isolation,
+        "log_phase_completed",
+        _log_completed,
+    )
+    monkeypatch.setattr(
+        isolation,
+        "log_phase_failed",
+        _log_failed,
+    )
+    parent_connection = _Connection(
+        received=[
+            ("phase", "setup_complete"),
+            ("phase", "model_loaded"),
+            ("ok", [("hello", 0.0, 0.5), ("world", 0.5, 1.0)]),
+        ]
+    )
+    child_connection = _Connection()
+    process = _Process()
+    context = _SpawnContext(
+        parent_connection=parent_connection,
+        child_connection=child_connection,
+        process=process,
+    )
+    settings = cast(
+        AppConfig, SimpleNamespace(torch_runtime=SimpleNamespace(device="cpu", dtype="auto"))
+    )
+    profile = _Profile()
+
+    resolved = isolation.run_faster_whisper_process_isolated(
+        file_path="sample.wav",
+        language="en",
+        profile=profile,
+        settings_resolver=lambda: settings,
+        runtime_request_resolver=lambda _profile, _settings: _runtime_request(),
+        payload_factory=lambda **kwargs: kwargs,
+        get_spawn_context=lambda: context,
+        worker_entry=lambda _payload, _connection: None,
+        recv_worker_message_fn=lambda connection, *, stage: isolation.recv_worker_message(
+            connection,
+            stage=stage,
+            error_factory=RuntimeError,
+        ),
+        raise_worker_error_fn=lambda message: isolation.raise_worker_error(
+            message,
+            error_factory=RuntimeError,
+        ),
+        terminate_worker_process_fn=lambda _process: None,
+        transcript_word_factory=TranscriptWord,
+        logger=logging.getLogger("ser.tests.process_isolation"),
+        error_factory=RuntimeError,
+        terminate_grace_seconds=0.1,
+    )
+
+    assert resolved == [
+        TranscriptWord("hello", 0.0, 0.5),
+        TranscriptWord("world", 0.5, 1.0),
+    ]
+    assert context.pipe_duplex is False
+    assert process.started is True
+    assert child_connection.closed is True
+    assert parent_connection.closed is True
+    assert process.closed is True
+    assert phase_events == [
+        ("start", "transcription_setup"),
+        ("complete", "transcription_setup"),
+        ("start", "transcription_model_load"),
+        ("complete", "transcription_model_load"),
+        ("start", "transcription"),
+        ("complete", "transcription"),
+    ]
+
+
+def test_run_faster_whisper_process_isolated_rejects_malformed_transcript_payload(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Parent orchestration should fail cleanly on malformed worker success payloads."""
+    phase_events: list[tuple[str, str]] = []
+
+    def _log_started(_logger: object, *, phase_name: str) -> float:
+        phase_events.append(("start", phase_name))
+        return 1.0
+
+    def _log_completed(
+        _logger: object,
+        *,
+        phase_name: str,
+        started_at: float,
+    ) -> None:
+        del started_at
+        phase_events.append(("complete", phase_name))
+
+    def _log_failed(
+        _logger: object,
+        *,
+        phase_name: str,
+        started_at: float,
+    ) -> None:
+        del started_at
+        phase_events.append(("failed", phase_name))
+
+    monkeypatch.setattr(
+        isolation,
+        "log_phase_started",
+        _log_started,
+    )
+    monkeypatch.setattr(
+        isolation,
+        "log_phase_completed",
+        _log_completed,
+    )
+    monkeypatch.setattr(
+        isolation,
+        "log_phase_failed",
+        _log_failed,
+    )
+    context = _SpawnContext(
+        parent_connection=_Connection(
+            received=[
+                ("phase", "setup_complete"),
+                ("phase", "model_loaded"),
+                ("ok", [("hello", "bad", 0.5)]),
+            ]
+        ),
+        child_connection=_Connection(),
+        process=_Process(),
+    )
+    settings = cast(
+        AppConfig, SimpleNamespace(torch_runtime=SimpleNamespace(device="cpu", dtype="auto"))
+    )
+
+    with pytest.raises(
+        RuntimeError,
+        match="non-numeric transcript timestamps at index 0",
+    ):
+        isolation.run_faster_whisper_process_isolated(
+            file_path="sample.wav",
+            language="en",
+            profile=_Profile(),
+            settings_resolver=lambda: settings,
+            runtime_request_resolver=lambda _profile, _settings: _runtime_request(),
+            payload_factory=lambda **kwargs: kwargs,
+            get_spawn_context=lambda: context,
+            worker_entry=lambda _payload, _connection: None,
+            recv_worker_message_fn=lambda connection, *, stage: isolation.recv_worker_message(
+                connection,
+                stage=stage,
+                error_factory=RuntimeError,
+            ),
+            raise_worker_error_fn=lambda message: isolation.raise_worker_error(
+                message,
+                error_factory=RuntimeError,
+            ),
+            terminate_worker_process_fn=lambda _process: None,
+            transcript_word_factory=TranscriptWord,
+            logger=logging.getLogger("ser.tests.process_isolation"),
+            error_factory=RuntimeError,
+            terminate_grace_seconds=0.1,
+        )
+
+    assert ("failed", "transcription") in phase_events
diff --git a/tests/suites/unit/transcription/process/test_process_worker.py b/tests/suites/unit/transcription/process/test_process_worker.py
new file mode 100644
index 00000000..e4e67662
--- /dev/null
+++ b/tests/suites/unit/transcription/process/test_process_worker.py
@@ -0,0 +1,134 @@
+"""Unit tests for process-worker payload and cleanup helpers."""
+
+from __future__ import annotations
+
+import logging
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from types import ModuleType, SimpleNamespace
+from typing import TYPE_CHECKING, cast
+
+import pytest
+
+from ser._internal.transcription import process_worker
+from ser.config import AppConfig
+from ser.profiles import TranscriptionBackendId
+
+if TYPE_CHECKING:
+    from ser.transcript.backends.base import BackendRuntimeRequest
+else:
+    BackendRuntimeRequest = object
+
+pytestmark = pytest.mark.unit
+
+
+@dataclass(frozen=True)
+class _Profile:
+    """Minimal process-isolated transcription profile stub."""
+
+    backend_id: TranscriptionBackendId = "faster_whisper"
+    model_name: str = "tiny"
+    use_demucs: bool = False
+    use_vad: bool = True
+
+
+def _runtime_request() -> BackendRuntimeRequest:
+    return cast(
+        BackendRuntimeRequest,
+        SimpleNamespace(
+            model_name="tiny",
+            use_demucs=False,
+            use_vad=True,
+        ),
+    )
+
+
+def test_build_transcription_worker_settings_projects_whisper_root() -> None:
+    """Worker settings should keep only the serializable model subset."""
+    settings = cast(
+        AppConfig,
+        SimpleNamespace(models=SimpleNamespace(whisper_download_root=Path("/tmp/whisper-cache"))),
+    )
+
+    resolved = process_worker.build_transcription_worker_settings(settings)
+
+    assert resolved.models.whisper_download_root == Path("/tmp/whisper-cache")
+
+
+def test_build_transcription_process_payload_embeds_worker_settings() -> None:
+    """Process payload should include the stripped worker settings snapshot."""
+    settings = cast(
+        AppConfig,
+        SimpleNamespace(models=SimpleNamespace(whisper_download_root=Path("/tmp/whisper-cache"))),
+    )
+    profile = _Profile()
+    runtime_request = _runtime_request()
+
+    resolved = process_worker.build_transcription_process_payload(
+        file_path="sample.wav",
+        language="en",
+        profile=profile,
+        runtime_request=runtime_request,
+        settings=settings,
+    )
+
+    assert resolved.file_path == "sample.wav"
+    assert resolved.language == "en"
+    assert resolved.profile is profile
+    assert resolved.runtime_request == runtime_request
+    assert resolved.settings.models.whisper_download_root == Path("/tmp/whisper-cache")
+
+
+def test_release_transcription_runtime_memory_clears_available_accelerator_caches(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Cleanup helper should empty available MPS and CUDA caches."""
+    cache_events: list[str] = []
+    torch_module = ModuleType("torch")
+    mps_module = ModuleType("torch.mps")
+    cuda_module = ModuleType("torch.cuda")
+    mps_module.is_available = lambda: True  # type: ignore[attr-defined]
+    mps_module.empty_cache = lambda: cache_events.append("mps")  # type: ignore[attr-defined]
+    cuda_module.is_available = lambda: True  # type: ignore[attr-defined]
+    cuda_module.empty_cache = lambda: cache_events.append("cuda")  # type: ignore[attr-defined]
+    torch_module.mps = mps_module  # type: ignore[attr-defined]
+    torch_module.cuda = cuda_module  # type: ignore[attr-defined]
+    monkeypatch.setitem(sys.modules, "torch", torch_module)
+
+    process_worker.release_transcription_runtime_memory(
+        model=object(),
+        logger=logging.getLogger("ser.tests.process_worker"),
+    )
+
+    assert cache_events == ["mps", "cuda"]
+
+
+def test_release_transcription_runtime_memory_logs_and_ignores_cache_failures(
+    monkeypatch: pytest.MonkeyPatch,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Cleanup helper should swallow accelerator cache errors after debug logging."""
+    torch_module = ModuleType("torch")
+    mps_module = ModuleType("torch.mps")
+    cuda_module = ModuleType("torch.cuda")
+    mps_module.is_available = lambda: True  # type: ignore[attr-defined]
+    cuda_module.is_available = lambda: True  # type: ignore[attr-defined]
+
+    def _raise_cache_error() -> None:
+        raise RuntimeError("cache boom")
+
+    mps_module.empty_cache = _raise_cache_error  # type: ignore[attr-defined]
+    cuda_module.empty_cache = _raise_cache_error  # type: ignore[attr-defined]
+    torch_module.mps = mps_module  # type: ignore[attr-defined]
+    torch_module.cuda = cuda_module  # type: ignore[attr-defined]
+    monkeypatch.setitem(sys.modules, "torch", torch_module)
+
+    with caplog.at_level(logging.DEBUG):
+        process_worker.release_transcription_runtime_memory(
+            model=object(),
+            logger=logging.getLogger("ser.tests.process_worker"),
+        )
+
+    assert "Ignored failure while emptying torch MPS cache after transcription." in caplog.text
+    assert "Ignored failure while emptying torch CUDA cache after transcription." in caplog.text
diff --git a/tests/suites/unit/transcription/process/test_public_boundary_process.py b/tests/suites/unit/transcription/process/test_public_boundary_process.py
new file mode 100644
index 00000000..a5094d2d
--- /dev/null
+++ b/tests/suites/unit/transcription/process/test_public_boundary_process.py
@@ -0,0 +1,207 @@
+"""Unit tests for public-boundary process-isolation glue."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from types import SimpleNamespace
+from typing import TYPE_CHECKING, Never, cast
+
+import pytest
+
+from ser._internal.transcription import public_boundary_process as boundary_process
+from ser._internal.transcription.process_worker import (
+    TranscriptionProcessPayload,
+    TranscriptionWorkerModelsConfig,
+    TranscriptionWorkerSettings,
+)
+from ser.config import AppConfig
+from ser.domain import TranscriptWord
+from ser.profiles import TranscriptionBackendId
+
+if TYPE_CHECKING:
+    from ser.transcript.backends.base import BackendRuntimeRequest
+else:
+    BackendRuntimeRequest = object
+
+pytestmark = pytest.mark.unit
+
+
+@dataclass(frozen=True)
+class _Profile:
+    """Minimal profile satisfying the process-isolated public boundary."""
+
+    backend_id: TranscriptionBackendId = "faster_whisper"
+    model_name: str = "tiny"
+    use_demucs: bool = False
+    use_vad: bool = True
+
+
+def _runtime_request() -> BackendRuntimeRequest:
+    return cast(
+        BackendRuntimeRequest,
+        SimpleNamespace(
+            model_name="tiny",
+            use_demucs=False,
+            use_vad=False,
+        ),
+    )
+
+
+def test_run_faster_whisper_process_isolated_from_public_boundary_injects_settings_snapshot() -> (
+    None
+):
+    """Boundary runner should pass explicit settings and TranscriptWord factory downstream."""
+    settings = cast(AppConfig, SimpleNamespace(name="settings"))
+    profile = _Profile()
+    captured: dict[str, object] = {}
+
+    def _run_impl(**kwargs: object) -> list[TranscriptWord]:
+        captured.update(kwargs)
+        settings_resolver = kwargs["settings_resolver"]
+        assert callable(settings_resolver)
+        assert settings_resolver() is settings
+        transcript_word_factory = cast(type[TranscriptWord], kwargs["transcript_word_factory"])
+        assert transcript_word_factory("word", 0.0, 0.5) == TranscriptWord("word", 0.0, 0.5)
+        return [TranscriptWord("word", 0.0, 0.5)]
+
+    resolved = boundary_process.run_faster_whisper_process_isolated_from_public_boundary(
+        file_path="sample.wav",
+        language="en",
+        profile=profile,
+        settings=settings,
+        run_faster_whisper_process_isolated_impl=_run_impl,
+        runtime_request_resolver=lambda _profile, _settings: _runtime_request(),
+        payload_factory=lambda **kwargs: kwargs,
+        spawn_context_resolver=lambda: "spawn-context",
+        worker_entry=lambda _payload, _connection: None,
+        recv_worker_message_fn=lambda _connection, *, stage: ("phase", "setup_complete"),
+        raise_worker_error_fn=lambda _message: (_ for _ in ()).throw(RuntimeError("boom")),
+        terminate_worker_process_fn=lambda _process: None,
+        logger=logging.getLogger("ser.tests.public_boundary_process"),
+        error_factory=RuntimeError,
+        terminate_grace_seconds=0.1,
+    )
+
+    assert resolved == [TranscriptWord("word", 0.0, 0.5)]
+    assert captured["file_path"] == "sample.wav"
+    assert captured["language"] == "en"
+    assert captured["profile"] is profile
+
+
+def test_recv_worker_message_from_public_boundary_delegates_to_impl() -> None:
+    """Boundary receiver should pass through the stage and error factory."""
+    connection = object()
+    captured: dict[str, object] = {}
+
+    resolved = boundary_process.recv_worker_message_from_public_boundary(
+        connection,
+        stage="setup",
+        recv_worker_message_impl=lambda active_connection, *, stage, error_factory: captured.update(
+            {
+                "connection": active_connection,
+                "stage": stage,
+                "error_factory": error_factory,
+            }
+        )
+        or ("phase", "setup_complete"),
+        error_factory=RuntimeError,
+    )
+
+    assert resolved == ("phase", "setup_complete")
+    assert captured == {
+        "connection": connection,
+        "stage": "setup",
+        "error_factory": RuntimeError,
+    }
+
+
+def test_raise_worker_error_from_public_boundary_delegates_to_impl() -> None:
+    """Boundary error raiser should forward the worker payload unchanged."""
+    captured: dict[str, object] = {}
+
+    def _raise_impl(message: object, *, error_factory: type[Exception]) -> Never:
+        captured.update({"message": message, "error_factory": error_factory})
+        raise error_factory("worker boom")
+
+    with pytest.raises(RuntimeError, match="worker boom"):
+        boundary_process.raise_worker_error_from_public_boundary(
+            ("err", "setup", "RuntimeError", "worker boom"),
+            raise_worker_error_impl=_raise_impl,
+            error_factory=RuntimeError,
+        )
+
+    assert captured["message"] == ("err", "setup", "RuntimeError", "worker boom")
+    assert captured["error_factory"] is RuntimeError
+
+
+def test_terminate_worker_process_from_public_boundary_delegates_to_impl() -> None:
+    """Boundary terminator should pass grace-period policy to the implementation."""
+    process = object()
+    captured: dict[str, object] = {}
+
+    boundary_process.terminate_worker_process_from_public_boundary(
+        process,
+        terminate_worker_process_impl=lambda active_process, *, terminate_grace_seconds, kill_grace_seconds: captured.update(
+            {
+                "process": active_process,
+                "terminate_grace_seconds": terminate_grace_seconds,
+                "kill_grace_seconds": kill_grace_seconds,
+            }
+        ),
+        terminate_grace_seconds=0.2,
+        kill_grace_seconds=0.3,
+    )
+
+    assert captured == {
+        "process": process,
+        "terminate_grace_seconds": 0.2,
+        "kill_grace_seconds": 0.3,
+    }
+
+
+def test_spawn_context_for_public_boundary_requests_spawn() -> None:
+    """Boundary spawn helper should always request the multiprocessing spawn context."""
+    captured: dict[str, object] = {}
+
+    resolved = boundary_process.spawn_context_for_public_boundary(
+        get_context=lambda mode: captured.setdefault("mode", mode) or "context"
+    )
+
+    assert resolved == "spawn"
+    assert captured["mode"] == "spawn"
+
+
+def test_transcription_worker_entry_from_public_boundary_casts_payload_and_adapter() -> None:
+    """Boundary worker entry should resolve worker settings and adapter through boundary helpers."""
+    payload = TranscriptionProcessPayload(
+        file_path="sample.wav",
+        language="en",
+        profile=_Profile(use_vad=False),
+        runtime_request=_runtime_request(),
+        settings=TranscriptionWorkerSettings(
+            models=TranscriptionWorkerModelsConfig(
+                whisper_download_root=Path("/tmp/whisper-cache"),
+            )
+        ),
+    )
+    captured: dict[str, object] = {}
+
+    boundary_process.transcription_worker_entry_from_public_boundary(
+        payload,
+        connection=object(),
+        transcription_worker_entry_impl=lambda active_payload, active_connection, *, settings_resolver, adapter_resolver: captured.update(
+            {
+                "payload": active_payload,
+                "connection": active_connection,
+                "settings": settings_resolver(),
+                "adapter": adapter_resolver("faster_whisper"),
+            }
+        ),
+        adapter_resolver=lambda backend_id: {"backend_id": backend_id},
+    )
+
+    assert captured["payload"] == payload
+    assert captured["settings"] == payload.settings
+    assert captured["adapter"] == {"backend_id": "faster_whisper"}
diff --git a/tests/utils/helpers/process_spawn_support.py b/tests/utils/helpers/process_spawn_support.py
index b3efa05c..29496383 100644
--- a/tests/utils/helpers/process_spawn_support.py
+++ b/tests/utils/helpers/process_spawn_support.py
@@ -6,9 +6,12 @@
 from dataclasses import dataclass
 from multiprocessing.connection import Connection
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from ser.profiles import TranscriptionBackendId
-from ser.transcript.backends import BackendRuntimeRequest
+
+if TYPE_CHECKING:
+    from ser.transcript.backends.base import BackendRuntimeRequest
 
 
 @dataclass(frozen=True, slots=True)