@@ -17,7 +17,7 @@
 
 from ._state import state
 from .client import AgentControlClient
-from .evaluation_events import build_control_execution_events, deliver_oss_events
+from .evaluation_events import build_control_execution_events, enqueue_observability_events
 from .telemetry import emit_control_events, has_control_event_sink
 from .tracing import get_trace_and_span_ids
 from .validation import ensure_agent_name
@@ -49,7 +49,20 @@ def _get_applicable_controls(
 def _build_server_control_lookup(
     server_control_payloads: list[dict[str, Any]],
 ) -> dict[int, ControlDefinition]:
-    """Return best-effort parsed server control definitions keyed by control ID."""
+    """Build a best-effort lookup of server control definitions.
+
+    The merged-event path reconstructs server-side events in the SDK after the
+    server returns a lightweight ``EvaluationResponse``. This helper parses the
+    cached server control payloads so the shared event builder can reconstruct
+    those events locally.
+
+    Args:
+        server_control_payloads: Raw cached server control payloads.
+
+    Returns:
+        A mapping of control ID to parsed ``ControlDefinition`` for every
+        payload that can be parsed locally.
+    """
     control_lookup: dict[int, ControlDefinition] = {}
 
     for control in server_control_payloads:
@@ -107,7 +120,20 @@ def _merge_results(
     local_result: EvaluationResponse,
     server_result: EvaluationResponse,
 ) -> EvaluationResult:
-    """Merge local and server evaluation results."""
+    """Merge local and server evaluation results into one SDK-facing result.
+
+    This helper merges only evaluation semantics. Event reconstruction happens
+    later so the response shape can stay lightweight regardless of which event
+    ingestion path is used.
+
+    Args:
+        local_result: Evaluation response produced by SDK-local controls.
+        server_result: Evaluation response produced by server-side controls.
+
+    Returns:
+        A merged ``EvaluationResult`` with combined matches, errors,
+        non-matches, and the strictest safety/confidence outcome.
+    """
     is_safe = local_result.is_safe and server_result.is_safe
     confidence = min(local_result.confidence, server_result.confidence)
 
@@ -173,7 +199,33 @@ async def check_evaluation_with_local(
     span_id: str | None = None,
     event_agent_name: str | None = None,
 ) -> EvaluationResult:
-    """Check if agent interaction is safe, running local controls first."""
+    """Evaluate controls with local-first execution and configurable event flow.
+
+    This is the main decision boundary between the two supported event
+    ingestion styles:
+    - default behavior: local events are reconstructed and queued immediately in
+      the SDK, while server-side events are still emitted by the server
+    - merged-event behavior: local and server events are reconstructed in the
+      SDK and emitted once through a registered sink
+
+    In both cases, the evaluation result itself stays lightweight and event
+    reconstruction happens after evaluation completes.
+
+    Args:
+        client: Configured AgentControl client.
+        agent_name: Agent name to evaluate against.
+        step: Step payload to evaluate.
+        stage: Evaluation stage, ``pre`` or ``post``.
+        controls: Cached control payloads used to split local vs server
+            execution.
+        trace_id: Optional explicit trace ID.
+        span_id: Optional explicit span ID.
+        event_agent_name: Optional override for the agent name stamped on
+            reconstructed events.
+
+    Returns:
+        A merged evaluation result across local and server execution.
+    """
     normalized_name = ensure_agent_name(agent_name)
     resolved_trace_id = trace_id
     resolved_span_id = span_id
@@ -264,7 +316,9 @@ def _with_parse_errors(result: EvaluationResult) -> EvaluationResult:
     if applicable_local_controls:
         engine = ControlEngine(applicable_local_controls, context="sdk")
         local_result = await engine.process(request)
-        local_control_lookup = {control.id: control.control for control in applicable_local_controls}
+        local_control_lookup = {
+            control.id: control.control for control in applicable_local_controls
+        }
         local_events = build_control_execution_events(
             local_result,
             request,
@@ -275,7 +329,7 @@ def _with_parse_errors(result: EvaluationResult) -> EvaluationResult:
         )
 
         if not merged_emission_enabled:
-            deliver_oss_events(local_events)
+            enqueue_observability_events(local_events)
 
         if not local_result.is_safe:
             result = _with_parse_errors(EvaluationResult.model_validate(local_result.model_dump()))
 
@@ -125,7 +125,28 @@ def build_control_execution_events(
     span_id: str | None,
     agent_name: str | None,
 ) -> list[ControlExecutionEvent]:
-    """Construct final ControlExecutionEvents from an evaluation response."""
+    """Reconstruct control execution events from an evaluation response.
+
+    This is the shared reconstruction step used by both supported ingestion
+    styles:
+    - the default SDK observability path, where reconstructed local events are
+      queued into the existing SDK batcher
+    - the merged-event path, where local and server events are reconstructed in
+      the SDK and emitted together through a registered sink
+
+    Args:
+        response: Evaluation response containing matches, errors, and
+            non-matches.
+        request: Original evaluation request used to derive stage and
+            ``applies_to``.
+        control_lookup: Parsed controls keyed by control ID.
+        trace_id: Optional trace ID for correlation.
+        span_id: Optional span ID for correlation.
+        agent_name: Optional override for the agent name stamped on events.
+
+    Returns:
+        A list of reconstructed ``ControlExecutionEvent`` objects.
+    """
     resolved_trace_id, resolved_span_id = _resolve_event_trace_context(trace_id, span_id)
     resolved_agent_name = agent_name or request.agent_name
     now = datetime.now(UTC)
@@ -170,8 +191,18 @@ def build_control_execution_events(
     return events
 
 
-def deliver_oss_events(events: list[ControlExecutionEvent]) -> None:
-    """Send reconstructed events through the existing OSS SDK observability path."""
+def enqueue_observability_events(events: list[ControlExecutionEvent]) -> None:
+    """Enqueue reconstructed events through the existing SDK observability path.
+
+    This preserves the default SDK behavior of forwarding local events through
+    the existing observability batcher rather than a custom merged-event sink.
+
+    Args:
+        events: Reconstructed control execution events to enqueue.
+
+    Returns:
+        None.
+    """
     if not is_observability_enabled():
         return
 
 
@@ -10,13 +10,33 @@
 
 
 def set_control_event_sink(sink: ControlEventSink | None) -> None:
-    """Register a sink for merged control execution events."""
+    """Register a sink for merged control execution events.
+
+    Registering a sink enables the optional merged-event path, where the SDK
+    reconstructs local and server events and emits them together after merging
+    results.
+
+    Args:
+        sink: Sink callback to receive merged control execution events, or
+            ``None`` to clear the current sink.
+
+    Returns:
+        None.
+    """
     global _control_event_sink
     _control_event_sink = sink
 
 
 def emit_control_events(events: list[ControlExecutionEvent]) -> None:
-    """Emit merged control execution events to the registered sink."""
+    """Emit merged control execution events to the registered sink.
+
+    Args:
+        events: Merged control execution events to emit.
+
+    Returns:
+        None. Sink failures are swallowed so evaluation behavior is not changed
+        by telemetry issues.
+    """
     if not events or _control_event_sink is None:
         return
 
@@ -28,7 +48,14 @@ def emit_control_events(events: list[ControlExecutionEvent]) -> None:
 
 
 def has_control_event_sink() -> bool:
-    """Return whether a merged control event sink is currently registered."""
+    """Return whether the optional merged-event path is enabled.
+
+    Args:
+        None.
+
+    Returns:
+        ``True`` when a merged control event sink has been registered.
+    """
     return _control_event_sink is not None
 
 
 
@@ -7,7 +7,7 @@
 from agent_control.evaluation import _ControlAdapter, _merge_results
 from agent_control.evaluation_events import (
     build_control_execution_events,
-    deliver_oss_events,
+    enqueue_observability_events,
     map_applies_to,
 )
 from agent_control.telemetry.trace_context import (
@@ -183,7 +183,7 @@ def test_composite_control_uses_representative_observability_identity(self):
         assert event.metadata["all_evaluators"] == ["regex"]
         assert event.metadata["all_selector_paths"] == ["input", "output"]
 
-    def test_deliver_oss_events_uses_existing_batcher(self):
+    def test_enqueue_observability_events_uses_existing_batcher(self):
         from agent_control_models import ControlExecutionEvent
 
         events = [
@@ -203,7 +203,7 @@ def test_deliver_oss_events_uses_existing_batcher(self):
 
         with patch("agent_control.evaluation_events.is_observability_enabled", return_value=True), \
              patch("agent_control.evaluation_events.add_event") as mock_add:
-            deliver_oss_events(events)
+            enqueue_observability_events(events)
 
         mock_add.assert_called_once_with(events[0])
 
@@ -253,7 +253,7 @@ async def test_delivers_local_events_in_oss_mode(self):
 
         with patch("agent_control.evaluation.ControlEngine", return_value=mock_engine), \
              patch("agent_control.evaluation.list_evaluators", return_value=["regex"]), \
-             patch("agent_control.evaluation.deliver_oss_events") as mock_deliver:
+             patch("agent_control.evaluation.enqueue_observability_events") as mock_enqueue:
             result = await evaluation.check_evaluation_with_local(
                 client=client,
                 agent_name="agent-000000000001",
@@ -265,8 +265,8 @@ async def test_delivers_local_events_in_oss_mode(self):
                 event_agent_name="test-agent",
             )
 
-        mock_deliver.assert_called_once()
-        delivered_events = mock_deliver.call_args.args[0]
+        mock_enqueue.assert_called_once()
+        delivered_events = mock_enqueue.call_args.args[0]
         assert len(delivered_events) == 1
         assert delivered_events[0].trace_id == "abc123"
         assert delivered_events[0].span_id == "def456"
@@ -275,9 +275,20 @@ async def test_delivers_local_events_in_oss_mode(self):
 
     @pytest.mark.asyncio
     async def test_resolves_provider_trace_context_for_local_events(self):
-        from agent_control_models import EvaluationResponse, Step
+        from agent_control_models import ControlMatch, EvaluationResponse, EvaluatorResult, Step
 
-        mock_response = EvaluationResponse(is_safe=True, confidence=1.0)
+        mock_response = EvaluationResponse(
+            is_safe=True,
+            confidence=1.0,
+            non_matches=[
+                ControlMatch(
+                    control_id=1,
+                    control_name="test-ctrl",
+                    action="allow",
+                    result=EvaluatorResult(matched=False, confidence=0.1),
+                )
+            ],
+        )
         mock_engine = MagicMock()
         mock_engine.process = AsyncMock(return_value=mock_response)
         controls = [{
@@ -300,7 +311,7 @@ async def test_resolves_provider_trace_context_for_local_events(self):
 
         with patch("agent_control.evaluation.ControlEngine", return_value=mock_engine), \
              patch("agent_control.evaluation.list_evaluators", return_value=["regex"]), \
-             patch("agent_control.evaluation.deliver_oss_events") as mock_deliver:
+             patch("agent_control.evaluation.enqueue_observability_events") as mock_enqueue:
             await evaluation.check_evaluation_with_local(
                 client=client,
                 agent_name="agent-000000000001",
@@ -309,7 +320,7 @@ async def test_resolves_provider_trace_context_for_local_events(self):
                 controls=controls,
             )
 
-        delivered_events = mock_deliver.call_args.args[0]
+        delivered_events = mock_enqueue.call_args.args[0]
         assert delivered_events[0].trace_id == "a" * 32
         assert delivered_events[0].span_id == "b" * 16
 
@@ -500,7 +511,7 @@ async def test_merged_event_sink_emits_reconstructed_local_and_server_events_onc
              patch("agent_control.evaluation.list_evaluators", return_value=["regex"]), \
              patch("agent_control.evaluation.has_control_event_sink", return_value=True), \
              patch("agent_control.evaluation.emit_control_events") as mock_emit, \
-             patch("agent_control.evaluation.deliver_oss_events") as mock_deliver:
+             patch("agent_control.evaluation.enqueue_observability_events") as mock_enqueue:
             result = await evaluation.check_evaluation_with_local(
                 client=client,
                 agent_name="agent-000000000001",
@@ -512,7 +523,7 @@ async def test_merged_event_sink_emits_reconstructed_local_and_server_events_onc
                 event_agent_name="test-agent",
             )
 
-        mock_deliver.assert_not_called()
+        mock_enqueue.assert_not_called()
         mock_emit.assert_called_once()
         merged_events = mock_emit.call_args.args[0]
         assert len(merged_events) == 2
 
@@ -274,10 +274,24 @@ def _build_observability_events(
     control_lookup: dict,
     total_duration_ms: float,
     ) -> list[ControlExecutionEvent]:
-    """Create observability events for all evaluated controls.
-
-    Uses control_execution_id from the engine response to ensure correlation
-    between SDK logs and server observability events.
+    """Build observability events for all evaluated controls.
+
+    This preserves the existing server-side event shape while allowing the
+    merged-event path to skip server-side ingestion and keep the response
+    lightweight.
+
+    Args:
+        response: Raw evaluation response from the engine.
+        request: Original evaluation request.
+        trace_id: Trace ID to stamp on emitted events.
+        span_id: Span ID to stamp on emitted events.
+        agent_name: Agent name to stamp on emitted events.
+        applies_to: Observability applies_to value derived from the step type.
+        control_lookup: Controls keyed by control ID.
+        total_duration_ms: Total request execution duration in milliseconds.
+
+    Returns:
+        A list of reconstructed server-side control execution events.
     """
     events: list[ControlExecutionEvent] = []
     now = datetime.now(UTC)
@@ -398,3 +412,28 @@ async def _ingest_observability_events(
             f"Dropped {result.dropped} observability events, "
             f"processed {result.processed}"
         )
+
+
+async def _emit_observability_events(
+    response: EvaluationResponse,
+    request: EvaluationRequest,
+    trace_id: str,
+    span_id: str,
+    agent_name: str,
+    applies_to: Literal["llm_call", "tool_call"],
+    control_lookup: dict,
+    total_duration_ms: float,
+    ingestor: EventIngestor | None,
+) -> None:
+    """Backward-compatible wrapper around build + ingest observability helpers."""
+    events = _build_observability_events(
+        response=response,
+        request=request,
+        trace_id=trace_id,
+        span_id=span_id,
+        agent_name=agent_name,
+        applies_to=applies_to,
+        control_lookup=control_lookup,
+        total_duration_ms=total_duration_ms,
+    )
+    await _ingest_observability_events(events, ingestor)