refactor: simplify RouteHealthCheckFilter and clean up health-check docs

- ``RouteHealthCheckFilter.health_check_required`` becomes a plain
  ``bool`` (default ``False``): ``False`` skips the filter, ``True``
  keeps only routes whose revision has a resolved health-check block.
  The previous ``Optional[bool]`` carried a third "keep only opt-out
  routes" mode no caller used and whose meaning was easy to misread
  off the field name.
- Drop ``_passes_health_check`` helper; inline the single remaining
  predicate at the call site in ``get_routes_by_statuses``.
- Remove the ``health_check_required=False`` repository test that
  exercised the dropped semantic.
- Strip the ``hc-`` shorthand from AppProxy sync handler comments and
  the repository test docstring — the abbreviation reads as jargon to
  anyone outside this branch.
- Trim verbose docstrings on ``RouteData`` (back to main's one-liner)
  and ``RouteSessionData`` (single sentence, no FK invariant note).

Author: fregataa

src/ai/backend/manager/data/deployment/types.py

@@ -265,12 +265,11 @@ class RouteTargetStatuses:
 class RouteHealthCheckFilter:
     """In-memory gating on a revision's ``health_check_config``.
 
-    ``True`` keeps only routes whose revision has a config; ``False``
-    keeps only routes without; ``None`` skips the filter. Anything more
-    specific belongs in the calling handler.
+    ``health_check_required=True`` keeps only routes whose revision has
+    a resolved health-check block; ``False`` (default) skips the filter.
     """
 
-    health_check_required: bool | None = None
+    health_check_required: bool = False
 
 
 @dataclass(frozen=True)

src/ai/backend/manager/repositories/deployment/db_source/db_source.py

@@ -232,20 +232,6 @@ def _project_health_check_config(
     return model_definition.health_check_config()
 
 
-def _passes_health_check(
-    has_health_check_config: bool,
-    health_check_required: bool | None,
-) -> bool:
-    """Whether the revision's ``health_check_config`` presence matches
-    ``health_check_required`` (``None`` skips the check).
-    """
-    if health_check_required is True:
-        return has_health_check_config
-    if health_check_required is False:
-        return not has_health_check_config
-    return True
-
-
 def _project_preset_slots(
     preset_row: DeploymentRevisionPresetRow | None,
     slot_entries: list[tuple[str, Decimal]],
@@ -1666,8 +1652,7 @@ async def get_routes_by_statuses(
             routes: list[RouteData] = []
             for row, model_definition, session_status in result.all():
                 health_check_config = _project_health_check_config(model_definition)
-                has_config = health_check_config is not None
-                if not _passes_health_check(has_config, health_check_filter.health_check_required):
+                if health_check_filter.health_check_required and health_check_config is None:
                     continue
                 routes.append(
                     RouteData(

src/ai/backend/manager/repositories/deployment/types/endpoint.py

@@ -62,26 +62,15 @@ class EndpointData:
 
 @dataclass(frozen=True)
 class RouteSessionData:
-    """Session id + status snapshot attached to a RouteData.
-
-    ``RoutingRow.session`` has ``ondelete=RESTRICT`` so a route cannot
-    reference a missing session row; ``status`` therefore is always set
-    when ``session_id`` is.
-    """
+    """Session id paired with its current status."""
 
     session_id: SessionId
     status: SessionStatus
 
 
 @dataclass
 class RouteData:
-    """Data structure for model service route.
-
-    ``health_check_config`` is the resolved ``ModelHealthCheck`` from the
-    revision's ``model_definition`` (or ``None`` when the revision opted
-    out). It is loaded eagerly with the route, so consumers do not need
-    to re-query the revision row to know how (or whether) to probe.
-    """
+    """Data structure for model service route."""
 
     route_id: uuid.UUID
     deployment_id: DeploymentID

src/ai/backend/manager/sokovan/deployment/route/handlers/appproxy_sync.py

@@ -58,8 +58,11 @@ def category(cls) -> RouteHandlerCategory:
 
     @classmethod
     def target_statuses(cls) -> RouteTargetStatuses:
-        # NOT_CHECKED rows pass through for hc-disabled revisions; ``execute``
-        # rejects hc-enabled NOT_CHECKED rows whose probe is still pending.
+        # NOT_CHECKED is included because revisions that omit
+        # ``service.health_check`` stay NOT_CHECKED for life and must
+        # still receive traffic. ``execute`` filters out NOT_CHECKED
+        # rows whose revision DID declare a probe (still waiting on the
+        # first result).
         return RouteTargetStatuses(
             lifecycle=[RouteStatus.RUNNING],
             health=[RouteHealthStatus.HEALTHY, RouteHealthStatus.NOT_CHECKED],
@@ -80,7 +83,8 @@ def status_transitions(cls) -> RouteStatusTransitions:
         )
 
     async def execute(self, routes: Sequence[RouteData]) -> RouteExecutionResult:
-        # Skip NOT_CHECKED hc-enabled rows: their first probe hasn't run yet.
+        # Routes with a configured probe must reach HEALTHY before sync;
+        # routes whose revision declared no probe sync as soon as RUNNING.
         eligible = [
             r
             for r in routes

tests/unit/manager/repositories/deployment/test_deployment_repository.py

@@ -3986,7 +3986,7 @@ async def test_traffic_status_filter(
             populated_routes["running_hc_on_healthy_inactive"],
         }
 
-    async def test_health_check_required_true_keeps_only_configured_revisions(
+    async def test_health_check_required_keeps_only_configured_revisions(
         self,
         deployment_repository: DeploymentRepository,
         populated_routes: dict[str, uuid.UUID],
@@ -4009,34 +4009,15 @@ async def test_health_check_required_true_keeps_only_configured_revisions(
             populated_routes["running_hc_on_healthy_inactive"],
         }
 
-    async def test_health_check_required_false_keeps_only_unconfigured_revisions(
-        self,
-        deployment_repository: DeploymentRepository,
-        populated_routes: dict[str, uuid.UUID],
-    ) -> None:
-        """``health_check_required=False`` keeps only routes whose revision
-        has no ``ModelHealthCheck``.
-        """
-        result = await deployment_repository.get_routes_by_statuses(
-            RouteTargetStatuses(
-                lifecycle=[RouteStatus.RUNNING],
-                health=list(RouteHealthStatus),
-            ),
-            RouteHealthCheckFilter(health_check_required=False),
-        )
-
-        assert {r.route_id for r in result} == {
-            populated_routes["running_hc_off_not_checked_active"],
-        }
-
     async def test_health_check_config_projected_from_model_definition(
         self,
         deployment_repository: DeploymentRepository,
         populated_routes: dict[str, uuid.UUID],
     ) -> None:
         """``RouteData.health_check_config`` mirrors the revision's
         ``model_definition.health_check_config()``: a populated
-        :class:`ModelHealthCheck` for hc-enabled revisions, ``None`` otherwise.
+        :class:`ModelHealthCheck` when the revision declares
+        ``service.health_check``, ``None`` otherwise.
         """
         result = await deployment_repository.get_routes_by_statuses(
             RouteTargetStatuses(

tests/unit/manager/sokovan/deployment/route/handlers/test_appproxy_sync_handler.py

@@ -72,7 +72,7 @@ def test_health_check_filter_imposes_no_repo_level_gating(self) -> None:
         case that AppProxy must skip is rejected in ``execute`` instead.
         """
         filt = AppProxySyncRouteHandler.health_check_filter()
-        assert filt.health_check_required is None
+        assert filt.health_check_required is False
 
     async def test_execute_keeps_healthy_and_unprobed_routes(self) -> None:
         """HEALTHY rows pass through; NOT_CHECKED rows pass only when their