@@ -16,6 +16,9 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = [
+    "agent-control-sdk>=8.11.0",
+    "agent-control-telemetry>=8.6.0",
+    "agent-control-engine>=8.6.0",
     "pytest>=8.0.0",
     "pytest-asyncio>=0.23.0",
     "pytest-cov>=4.0.0",
@@ -37,3 +40,6 @@ packages = ["src/agent_control_evaluator_galileo"]
 [tool.uv.sources]
 agent-control-evaluators = { path = "../../builtin", editable = true }
 agent-control-models = { path = "../../../models", editable = true }
+agent-control-sdk = { path = "../../../sdks/python", editable = true }
+agent-control-telemetry = { path = "../../../telemetry", editable = true }
+agent-control-engine = { path = "../../../engine", editable = true }
@@ -1,38 +1,9 @@
-"""Cross-package check: StepRecorder trees feed the Galileo record factory.
-
-The galileo extras are normally installed in the dev environment (see
-``test_evaluators_optional_imports.py``), so this skips cleanly when they
-are not available instead of failing the suite.
-"""
+"""Cross-package check: StepRecorder trees feed the Galileo record factory."""
 
 from __future__ import annotations
 
-import importlib.util
-
-import pytest
-
 from agent_control import record_step
-
-
-def _module_available(name: str) -> bool:
-    try:
-        return importlib.util.find_spec(name) is not None
-    except (ImportError, ValueError):
-        return False
-
-
-_GALILEO_INSTALLED = _module_available("agent_control_evaluator_galileo.records")
-
-pytestmark = pytest.mark.skipif(
-    not _GALILEO_INSTALLED,
-    reason="agent-control-evaluator-galileo extras not installed in this environment",
-)
-
-
-def _record_from_step(step):
-    from agent_control_evaluator_galileo.records.factory import record_from_step
-
-    return record_from_step(step)
+from agent_control_evaluator_galileo.records.factory import record_from_step as _record_from_step
 
 
 def test_recorder_built_trace_matches_demo_shape():
 
@@ -84,53 +84,59 @@ async with agent_control.AgentControlClient() as client:
 The existing `evaluate_controls` helper remains available for callers that
 prefer its field-based convenience arguments.
 
-## Building trace/session steps
+## Building a step with children
 
-Trace- and session-level controls evaluate the aggregate of several
-already-executed child steps, so `Step.children` has to be populated by the
-caller. Building that tree by hand means hand-rolling a side-channel record
-for every leaf call and converting it into `Step` objects afterward:
+A control's scope can target any step type, including one that aggregates
+several already-executed child steps - `Step.children` just has to be
+populated by the caller. Building that tree by hand means hand-rolling a
+side-channel record for every leaf call and converting it into `Step`
+objects afterward:
 
 ```python
 # Before: a hand-built dict record next to the real return value
 def execute_policy_search(query):
     docs = search_policy_documents(query)
-    record = {"type": "retriever", "query": query, "docs": docs}
+    record = {"type": "lookup", "query": query, "docs": docs}
     return StepExecution(value=docs, record=record)
 
-spans = []
+children = []
 result = execute_policy_search(query)
-spans.append(result.record)
+children.append(result.record)
 ...
-trace_step = build_agent_control_step({"type": "trace", "spans": spans, ...})
+workflow_step = build_agent_control_step({"type": "workflow", "children": children, ...})
 ```
 
 `agent_control.record_step()` builds the same tree incrementally, in `Step`
 vocabulary, with no intermediate dict and no converter:
 
 ```python
-with agent_control.record_step("trace", "banking_trace", input={"request": req}) as trace:
-    with trace.child("retriever", "policy_lookup", input=query) as span:
+with agent_control.record_step("workflow", "banking_workflow", input={"request": req}) as workflow:
+    with workflow.child("lookup", "policy_lookup", input=query) as span:
         span.output = search_policy_documents(query)
 
-    account = trace.call(lookup_account, account_id="acct-1001", step_type="tool")
-    plan = trace.call(run_banking_model, req, step_type="llm", tools=TOOL_DEFINITIONS)
-    trace.output = {"status": "planned", "message": plan["content"]}
+    account = workflow.call(lookup_account, account_id="acct-1001", step_type="tool")
+    plan = workflow.call(run_banking_model, req, step_type="llm", tools=TOOL_DEFINITIONS)
+    workflow.output = {"status": "planned", "message": plan["content"]}
 
-result = await trace.evaluate(stage="post")
+result = await workflow.evaluate(stage="post")
 ```
 
-`trace.call(...)`/`await trace.acall(...)` run the function and record it as
-a child using the same capture logic as `@control()` (input from bound
+`workflow.call(...)`/`await workflow.acall(...)` run the function and record
+it as a child using the same capture logic as `@control()` (input from bound
 arguments, output from the return value), then return the real result -
 removing the need for a separate `StepExecution`-style wrapper. A failed
 call is still recorded (with the error in `context`) before the exception is
-re-raised. `trace.child(...)` nests another recorder the same way, so
-sessions nest traces with `session.child("trace", ...)`.
-
-`trace.build()` produces the frozen `Step`; `trace.evaluate(...)` builds it
-and evaluates it in one call via `evaluate_step()` - the same function
-`evaluate_controls()` uses internally once its `Step` is built.
+re-raised. `workflow.child(...)` nests another recorder the same way, so a
+parent step can nest children of any depth, e.g. `session.child("trace",
+...)` for callers that model multi-turn sessions of traces.
+
+`workflow.build()` produces the frozen `Step`, with `children=[]` instead of
+omitted (`None`) for a step type passed via `container_types` even when no
+children were recorded - e.g. `record_step("workflow", ..., container_types=
+{"workflow"})` for a workflow that legitimately ran with zero children.
+`workflow.evaluate(...)` builds the step and evaluates it in one call via
+`evaluate_step()` - the same function `evaluate_controls()` uses internally
+once its `Step` is built.
 
 ## Sharing an OpenTelemetry provider with Google ADK
 
 
@@ -9,7 +9,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable, Mapping
+from collections.abc import Awaitable, Callable, Collection, Mapping
 from typing import Any, Literal, TypeVar
 
 from agent_control_models import EvaluationResult, JSONObject, JSONValue, Step
@@ -21,12 +21,6 @@
 
 T = TypeVar("T")
 
-# Step types whose children are reported as a span/trace tree; an absent
-# recording means "nothing happened", which the record factory treats
-# differently from "not applicable" (None). See models/agent.py and
-# records/factory.py for the trace/session child-shape rules this mirrors.
-_EMPTY_CHILDREN_STEP_TYPES = frozenset({"trace", "session"})
-
 
 def record_step(
     step_type: str,
@@ -36,15 +30,26 @@ def record_step(
     context: dict[str, Any] | None = None,
     tools: list[JSONObject] | None = None,
     ground_truth: JSONValue | None = None,
+    container_types: Collection[str] = (),
 ) -> StepRecorder:
-    """Start building a ``Step`` tree. Use as a context manager."""
+    """Start building a ``Step`` tree. Use as a context manager.
+
+    ``container_types`` names step types whose ``children`` should be
+    serialized as ``[]`` rather than omitted when none were recorded - e.g.
+    a trace/session that legitimately ran with zero children, as opposed to
+    a leaf type for which children isn't a meaningful concept at all. Step
+    types are caller-defined strings, so this isn't assumed; opt in with
+    e.g. ``container_types={"trace", "session"}``. Inherited by nested
+    ``.child()`` recorders unless overridden there.
+    """
     return StepRecorder(
         step_type,
         name,
         input=input,
         context=context,
         tools=tools,
         ground_truth=ground_truth,
+        container_types=frozenset(container_types),
     )
 
 
@@ -64,6 +69,7 @@ def __init__(
         context: dict[str, Any] | None = None,
         tools: list[JSONObject] | None = None,
         ground_truth: JSONValue | None = None,
+        container_types: frozenset[str] = frozenset(),
         _parent: StepRecorder | None = None,
     ) -> None:
         self.type = ensure_step_type(step_type)
@@ -75,6 +81,7 @@ def __init__(
         self.ground_truth = ground_truth
         self._children: list[Step] = []
         self._parent = _parent
+        self._container_types = container_types
 
     def __enter__(self) -> StepRecorder:
         return self
@@ -92,15 +99,23 @@ def child(
         context: dict[str, Any] | None = None,
         tools: list[JSONObject] | None = None,
         ground_truth: JSONValue | None = None,
+        container_types: Collection[str] | None = None,
     ) -> StepRecorder:
-        """Start a nested recorder; it attaches to this node on ``__exit__``."""
+        """Start a nested recorder; it attaches to this node on ``__exit__``.
+
+        Inherits this node's ``container_types`` unless ``container_types``
+        is given explicitly.
+        """
         return StepRecorder(
             step_type,
             name,
             input=input,
             context=context,
             tools=tools,
             ground_truth=ground_truth,
+            container_types=(
+                self._container_types if container_types is None else frozenset(container_types)
+            ),
             _parent=self,
         )
 
@@ -178,7 +193,7 @@ def build(self) -> Step:
             step_dict["ground_truth"] = self.ground_truth
         if self._children:
             step_dict["children"] = list(self._children)
-        elif self.type in _EMPTY_CHILDREN_STEP_TYPES:
+        elif self.type in self._container_types:
             step_dict["children"] = []
         return Step(**step_dict)  # type: ignore[arg-type]
 
 
@@ -140,25 +140,48 @@ def test_build_includes_context_tools_ground_truth():
     assert step.ground_truth == "hello"
 
 
-def test_empty_trace_and_session_build_empty_children_list():
-    """A trace/session with no recorded children gets children=[], not None."""
-    with record_step("trace", "empty_trace") as trace:
+def test_container_types_opts_in_to_empty_children_list():
+    """A declared container type with no recorded children gets children=[], not None."""
+    with record_step("trace", "empty_trace", container_types={"trace", "session"}) as trace:
         pass
-    with record_step("session", "empty_session") as session:
+    with record_step("session", "empty_session", container_types={"trace", "session"}) as session:
         pass
 
     assert trace.build().children == []
     assert session.build().children == []
 
 
-def test_llm_step_without_children_stays_none():
-    """Non trace/session step types are untouched when no children were recorded."""
+def test_step_type_without_container_types_stays_none():
+    """Step types are caller-defined strings; children stays None unless the
+    caller opts a type into container_types - no type is a container by default."""
+    with record_step("trace", "empty_trace") as trace:
+        pass
     with record_step("llm", "respond", input="hi") as leaf:
         leaf.output = "hello"
 
+    assert trace.build().children is None
     assert leaf.build().children is None
 
 
+def test_child_inherits_parent_container_types():
+    """A nested .child() recorder inherits the parent's container_types unless overridden."""
+    with record_step("session", "s", container_types={"trace", "session"}) as session:
+        with session.child("trace", "empty_trace") as trace:
+            pass
+
+    assert trace.build().children == []
+    assert session.build().children == [trace.build()]
+
+
+def test_child_can_override_container_types():
+    """A nested .child() recorder can override the inherited container_types."""
+    with record_step("session", "s", container_types={"trace", "session"}) as session:
+        with session.child("trace", "empty_trace", container_types=()) as trace:
+            pass
+
+    assert trace.build().children is None
+
+
 def test_add_attaches_prebuilt_step_or_dict():
     """add() accepts both a real Step and a plain dict (coerced via Step.model_validate)."""
     with record_step("trace", "t") as trace: