@@ -634,7 +634,7 @@ def scan_output_request(
         start_time = time.perf_counter()
         violation = self._limits.check_input_length(request.text)
         if violation is not None:
-            return _limit_result(violation, len(request.text))
+            return self._report_ml_degraded(_limit_result(violation, len(request.text)))
         try:
             with correlation_scope():
                 if self._server_client is not None:
@@ -644,11 +644,11 @@ def scan_output_request(
                 result = self._output_pipeline.run(body, context=ctx)
                 if not isolated:
                     self._maybe_mark_session_tainted_from_scan(Source.TOOL_OUTPUT)
-                return result
+                return self._report_ml_degraded(result)
         except Exception as exc:
             _log.error("guard.scan_output_request failed: %s", exc)
             latency_ms = (time.perf_counter() - start_time) * 1000
-            return _fail_closed(exc, latency_ms)
+            return self._report_ml_degraded(_fail_closed(exc, latency_ms))
 
     def check_tool_call(
         self,
@@ -662,16 +662,19 @@ def check_tool_call(
         start_time = time.perf_counter()
         _ = approved  # resume-only via ApprovalProvider; caller flag is ignored
         if not self._limits.is_tool_allowed(tool_name):
-            return _limit_result(
+            return self._report_ml_degraded(
+    _limit_result(
                 LimitViolation(
                     kind="tool_blocked",
                     limit=0,
                     actual=0,
                     message=f"Tool not allowed: {tool_name}",
                 ),
             )
+            )
         if not self._config.tools.is_permitted(tool_name):
-            return _limit_result(
+            return self._report_ml_degraded(
+    _limit_result(
                 LimitViolation(
                     kind="tool_profile_blocked",
                     limit=0,
@@ -681,9 +684,10 @@ def check_tool_call(
                     ),
                 ),
             )
+            )
         count_violation = self._limits.check_tool_call_count(len(self._context.tool_calls) + 1)
         if count_violation is not None:
-            return _limit_result(count_violation)
+            return self._report_ml_degraded(_limit_result(count_violation))
         tc = ToolCall(
             tool_name=tool_name,
             arguments=arguments,
@@ -705,11 +709,11 @@ def check_tool_call(
                     self._context.add_tool_call(tc)
                     if self._config.tools.is_taint_source(tool_name):
                         self.notify_taint_source(tool_name)
-                return result
+                return self._report_ml_degraded(result)
         except Exception as exc:
             _log.error("guard.check_tool_call failed: %s", exc)
             latency_ms = (time.perf_counter() - start_time) * 1000
-            return _fail_closed(exc, latency_ms)
+            return self._report_ml_degraded(_fail_closed(exc, latency_ms))
 
     def scan_request(
         self,
@@ -721,7 +725,7 @@ def scan_request(
         start_time = time.perf_counter()
         violation = self._limits.check_input_length(request.text)
         if violation is not None:
-            return _limit_result(violation, len(request.text))
+            return self._report_ml_degraded(_limit_result(violation, len(request.text)))
         try:
             with correlation_scope():
                 if self._server_client is not None:
@@ -744,15 +748,15 @@ def scan_request(
                     result = self._run_input_with_cache(request, ctx)
                     if not isolated:
                         self._maybe_mark_session_tainted_from_scan(request.source)
-                    return result
+                    return self._report_ml_degraded(result)
                 finally:
                     ctx.allowed_scanners = prev_allowed
         except ConfigError:
             raise
         except Exception as exc:
             _log.error("guard.scan_request failed: %s", exc)
             latency_ms = (time.perf_counter() - start_time) * 1000
-            return _fail_closed(exc, latency_ms)
+            return self._report_ml_degraded(_fail_closed(exc, latency_ms))
 
     @property
     def is_server_mode(self) -> bool:
@@ -762,6 +766,23 @@ def is_server_mode(self) -> bool:
     def ml_model_loaded(self) -> bool:
         return self._ml_provider is not None and self._ml_provider.loaded
 
+
+    def _report_ml_degraded(self, result: ScanResult) -> ScanResult:
+        """Copy the private ML-unavailable flag onto the result callers inspect.
+
+        ``require_ml=True`` already fails closed. The default path keeps scanning
+        with regex only, but ``ScanResult.degraded`` stayed false because nothing
+        copied ``_ml_degraded`` onto the result. Server mode reports this itself.
+        """
+        if not self._ml_degraded:
+            return result
+        layers = list(result.degraded_layers)
+        if "injection_ml" not in layers:
+            layers.append("injection_ml")
+        if result.degraded and layers == list(result.degraded_layers):
+            return result
+        return result.model_copy(update={"degraded": True, "degraded_layers": layers})
+
     @property
     def ml_degraded(self) -> bool:
         """True when active_model is configured but ML failed to load."""
 
@@ -74,3 +74,22 @@ def test_no_active_model_does_not_warn(self, caplog: pytest.LogCaptureFixture) -
 
         assert _degraded_records(caplog) == []
         assert guard._ml_degraded is False
+
+    def test_scan_result_reports_injection_ml_degraded(self) -> None:
+        """Callers inspect ScanResult, not the private flag. #107."""
+        with patch("unplug.guard.prepare_active_model_spec", return_value=None):
+            guard = Guard(config=GuardConfig(active_model="tiny"))
+
+        assert guard.ml_degraded is True
+        result = guard.scan("some text")
+        assert result.degraded is True
+        assert result.degraded_layers == ["injection_ml"]
+
+    def test_regex_only_scan_is_not_degraded(self) -> None:
+        """No active_model means the ML layer was never configured."""
+        guard = Guard(config=GuardConfig())
+        result = guard.scan("some text")
+        assert guard.ml_degraded is False
+        assert result.degraded is False
+        assert result.degraded_layers == []
+