From c55b733fbe2c233d415f342ab3f56b1b73d95ddf Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Tue, 26 May 2026 23:54:40 +0100
Subject: [PATCH 01/15] Add experiment rollout trainer adapter path

---
 .../infrastructure/http/routes/rollouts.py    |  20 +++
 .../ergon_core/core/rl/rollout_service.py     | 134 ++++++++++++++++++
 .../ergon_core/core/rl/rollout_types.py       |  19 ++-
 .../rl/test_rollout_experiment_submission.py  |  64 +++++++++
 .../ergon_infra/adapters/openrlhf_http.py     |  25 ++--
 ergon_infra/ergon_infra/adapters/trl_http.py  |  17 ++-
 ergon_infra/ergon_infra/adapters/verl_http.py |  19 ++-
 ergon_infra/ergon_infra/training/config.py    |   6 +-
 .../ergon_infra/training/trl_runner.py        |  12 +-
 .../test_training_experiment_submission.py    |  59 ++++++++
 10 files changed, 345 insertions(+), 30 deletions(-)
 create mode 100644 ergon_core/tests/unit/rl/test_rollout_experiment_submission.py
 create mode 100644 ergon_infra/tests/unit/test_training_experiment_submission.py

diff --git a/ergon_core/ergon_core/core/infrastructure/http/routes/rollouts.py b/ergon_core/ergon_core/core/infrastructure/http/routes/rollouts.py
index 89fc62633..50634eb8b 100644
--- a/ergon_core/ergon_core/core/infrastructure/http/routes/rollouts.py
+++ b/ergon_core/ergon_core/core/infrastructure/http/routes/rollouts.py
@@ -15,6 +15,7 @@
     RolloutBatchSummary,
     SubmitRequest,
     SubmitResponse,
+    TrainingRolloutRequest,
     WeightSyncRequest,
     WeightSyncResponse,
 )
@@ -51,6 +52,25 @@ def submit_rollout(
     return service.submit(request)
 
 
+@router.post(
+    "/experiments/{experiment_id}/rollout-batches",
+    response_model=RolloutBatchSummary,
+    status_code=202,
+)
+async def submit_experiment_rollout_batch(
+    experiment_id: UUID,
+    request: TrainingRolloutRequest,
+    service: Annotated[RolloutService, Depends(get_rollout_service)],
+) -> RolloutBatchSummary:
+    """Start a trainer batch from a persisted experiment candidate pool."""
+    if request.experiment_id != experiment_id:
+        raise HTTPException(400, "experiment_id mismatch")
+    try:
+        return await service.submit_experiment_batch(request)
+    except ValueError as exc:
+        raise HTTPException(400, str(exc)) from exc
+
+
 @router.get("/{batch_id}", response_model=PollResponse)
 def poll_rollout(
     batch_id: UUID,
diff --git a/ergon_core/ergon_core/core/rl/rollout_service.py b/ergon_core/ergon_core/core/rl/rollout_service.py
index 481f07bed..a8ab87530 100644
--- a/ergon_core/ergon_core/core/rl/rollout_service.py
+++ b/ergon_core/ergon_core/core/rl/rollout_service.py
@@ -12,8 +12,20 @@
 from uuid import UUID, uuid4
 
 import inngest
+from ergon_core.api.experiment.experiment import ExperimentRef
+from ergon_core.core.application.experiments.candidate_pool import sample_from_pool_entry
+from ergon_core.core.application.experiments.repositories import (
+    ExperimentRepository,
+    record_sampler_invocation,
+)
+from ergon_core.core.application.samples.materialization import materialize_sample
 from ergon_core.core.persistence.context.models import SampleContextEvent
 from ergon_core.core.persistence.definitions.models import ExperimentDefinition
+from ergon_core.core.persistence.experiments.models import (
+    ExperimentRow,
+    ExperimentSamplerInvocationRow,
+    ExperimentSamplePoolEntryRow,
+)
 from ergon_core.core.persistence.shared.enums import (
     TERMINAL_SAMPLE_STATUSES,
     SampleStatus,
@@ -39,6 +51,7 @@
     SubmitRequest,
     SubmitResponse,
     Trajectory,
+    TrainingRolloutRequest,
 )
 from ergon_core.core.application.events.runtime import WorkflowStartedEvent
 from sqlmodel import Session, select
@@ -193,6 +206,110 @@ def get_rollout_batch_by_id(self, batch_id: UUID) -> RolloutBatchSummary | None:
         with self._session_factory() as session:
             return self.get_rollout_batch(session, batch_id)
 
+    async def submit_experiment_batch(
+        self,
+        request: TrainingRolloutRequest,
+    ) -> RolloutBatchSummary:
+        """Launch a trainer batch from already-buffered experiment candidates."""
+        with self._session_factory() as session:
+            experiment = session.get(ExperimentRow, request.experiment_id)
+            if experiment is None:
+                raise ValueError(f"Experiment {request.experiment_id} not found")
+
+            repository = ExperimentRepository(session)
+            pool_size = request.candidate_pool_size or request.k
+            candidates = repository.pending_unselected_pool_entries(request.experiment_id)
+            if len(candidates) < request.k:
+                raise ValueError(
+                    "Experiment candidate pool does not contain enough unselected samples. "
+                    "Submit through the Python experiment API to replenish streamed environments."
+                )
+            selected_entries = _select_candidate_entries(
+                candidates[:pool_size],
+                k=request.k,
+                sampler=request.sampler,
+                sampler_config=request.sampler_config,
+            )
+            invocation = record_sampler_invocation(
+                session=session,
+                experiment_ref=ExperimentRef(
+                    id=experiment.id,
+                    name=experiment.name,
+                    environment_ids=repository.environment_ids_for_experiment(experiment.id),
+                    created_at=experiment.created_at,
+                    metadata=experiment.metadata_json,
+                ),
+                sampler_name=request.sampler,
+                requested_k=request.k,
+                candidate_pool_size=pool_size,
+                selected_count=len(selected_entries),
+                sampler_config=request.sampler_config,
+            )
+            repository.mark_pool_entries_selected(
+                list(selected_entries),
+                sampler_invocation_id=invocation.id,
+            )
+            sample_ids = await self._materialize_pool_entries(
+                session=session,
+                invocation=invocation,
+                entries=selected_entries,
+            )
+            summary = self.create_rollout_batch(
+                session,
+                sample_ids=sample_ids,
+                sampler_invocation_id=invocation.id,
+            )
+            session.commit()
+
+        for sample_id in summary.sample_ids:
+            self._inngest_send(
+                inngest.Event(
+                    name=WorkflowStartedEvent.name,
+                    data=WorkflowStartedEvent(sample_id=sample_id).model_dump(mode="json"),
+                )
+            )
+        return summary
+
+    async def _materialize_pool_entries(
+        self,
+        *,
+        session: Session,
+        invocation: ExperimentSamplerInvocationRow,
+        entries: Sequence[ExperimentSamplePoolEntryRow],
+    ) -> list[UUID]:
+        sample_ids: list[UUID] = []
+        for entry in entries:
+            sample = await sample_from_pool_entry(entry)
+            row = SampleRecord(
+                experiment_id=entry.experiment_id,
+                environment_id=entry.environment_id,
+                sampler_invocation_id=invocation.id,
+                pool_entry_id=entry.id,
+                sample_key=sample.sample_key,
+                sample_ref_json=dict(sample.sample_ref),
+                benchmark_type="experiment",
+                instance_key=sample.sample_key,
+                sample_id=sample.sample_key,
+                worker_team_json={},
+                dependency_extras_json={},
+                assignment_json={
+                    "sample_key": sample.sample_key,
+                    "sample_name": sample.name,
+                    "environment_name": sample.environment_name,
+                    "sample_ref": dict(sample.sample_ref),
+                    "source_metadata": dict(sample.source_metadata),
+                    "metadata": dict(sample.metadata),
+                },
+                experiment=str(entry.experiment_id),
+                status=SampleStatus.PENDING,
+            )
+            session.add(row)
+            session.flush()
+            materialize_sample(session=session, sample=sample, sample_row=row)
+            sample_ids.append(row.id)
+        session.flush()
+        return sample_ids
+
     def poll(self, batch_id: UUID) -> PollResponse | None:
         """Non-blocking status check. Extracts trajectories when all done."""
         with self._session_factory() as session:
@@ -374,3 +491,20 @@ def _extract_trajectories(self, sample_ids: list[UUID]) -> list[Trajectory]:
                     )
                 )
         return result
+
+
+def _select_candidate_entries(
+    entries: Sequence[ExperimentSamplePoolEntryRow],
+    *,
+    k: int,
+    sampler: str,
+    sampler_config: dict[str, object],
+) -> list[ExperimentSamplePoolEntryRow]:
+    selected = list(entries)
+    if sampler == "random":
+        import random
+
+        random.Random(sampler_config.get("seed")).shuffle(selected)
+    elif sampler not in {"sequential", "all"}:
+        raise ValueError(f"Unsupported trainer sampler: {sampler}")
+    return selected[: min(k, len(selected))]
diff --git a/ergon_core/ergon_core/core/rl/rollout_types.py b/ergon_core/ergon_core/core/rl/rollout_types.py
index 99b37d0cf..cefb5adc5 100644
--- a/ergon_core/ergon_core/core/rl/rollout_types.py
+++ b/ergon_core/ergon_core/core/rl/rollout_types.py
@@ -7,7 +7,12 @@
 from uuid import UUID
 
 from ergon_core.core.shared.rollout_status import RolloutStatus as BatchStatus
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
+
+
+def _to_camel(value: str) -> str:
+    parts = value.split("_")
+    return parts[0] + "".join(part.capitalize() for part in parts[1:])
 
 
 class SubmitRequest(BaseModel):
@@ -27,6 +32,18 @@ class SubmitResponse(BaseModel):
     status: BatchStatus = BatchStatus.PENDING
 
 
+class TrainingRolloutRequest(BaseModel):
+    """Trainer → Ergon: select and launch samples from a persisted experiment."""
+
+    model_config = ConfigDict(alias_generator=_to_camel, populate_by_name=True)
+
+    experiment_id: UUID
+    k: int = Field(ge=1)
+    sampler: str = "random"
+    sampler_config: dict[str, object] = Field(default_factory=dict)
+    candidate_pool_size: int | None = None
+
+
 class RolloutBatchSummary(BaseModel):
     """Durable trainer batch membership exposed by sample id."""
 
diff --git a/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py b/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py
new file mode 100644
index 000000000..66b1de1a4
--- /dev/null
+++ b/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py
@@ -0,0 +1,64 @@
+from uuid import uuid4
+
+from ergon_core.core.infrastructure.http.routes.rollouts import router
+from ergon_core.core.rl.rollout_types import BatchStatus, RolloutBatchSummary
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+
+class _FakeRolloutService:
+    def __init__(self) -> None:
+        self.request = None
+
+    async def submit_experiment_batch(self, request):
+        self.request = request
+        return RolloutBatchSummary(
+            batch_id=uuid4(),
+            sample_ids=[uuid4()],
+            status=BatchStatus.PENDING,
+            sampler_invocation_id=uuid4(),
+        )
+
+
+def test_experiment_rollout_route_accepts_camel_case_training_request() -> None:
+    experiment_id = uuid4()
+    service = _FakeRolloutService()
+    app = FastAPI()
+    app.state.rollout_service = service
+    app.include_router(router)
+    client = TestClient(app)
+
+    response = client.post(
+        f"/rollouts/experiments/{experiment_id}/rollout-batches",
+        json={
+            "experimentId": str(experiment_id),
+            "k": 32,
+            "sampler": "random",
+            "samplerConfig": {"seed": 7},
+            "candidatePoolSize": 256,
+        },
+    )
+
+    assert response.status_code == 202
+    assert service.request.experiment_id == experiment_id
+    assert service.request.k == 32
+    assert service.request.sampler == "random"
+    assert service.request.sampler_config == {"seed": 7}
+    assert service.request.candidate_pool_size == 256
+
+
+def test_experiment_rollout_route_rejects_mismatched_experiment_id() -> None:
+    app = FastAPI()
+    app.state.rollout_service = _FakeRolloutService()
+    app.include_router(router)
+    client = TestClient(app)
+
+    response = client.post(
+        f"/rollouts/experiments/{uuid4()}/rollout-batches",
+        json={
+            "experimentId": str(uuid4()),
+            "k": 1,
+        },
+    )
+
+    assert response.status_code == 400
diff --git a/ergon_infra/ergon_infra/adapters/openrlhf_http.py b/ergon_infra/ergon_infra/adapters/openrlhf_http.py
index 557fea678..0333ea5ba 100644
--- a/ergon_infra/ergon_infra/adapters/openrlhf_http.py
+++ b/ergon_infra/ergon_infra/adapters/openrlhf_http.py
@@ -4,7 +4,7 @@
 
     # OpenRLHF CLI:
     --agent_func_path ergon_infra/adapters/openrlhf_http.py
-    --agent_func_kwargs '{"ergon_url": "http://macbook:9000/api", "definition_id": "<uuid>"}'
+    --agent_func_kwargs '{"ergon_url": "http://macbook:9000/api", "experiment_id": "<uuid>"}'
 """
 
 import asyncio
@@ -17,7 +17,9 @@
 logger = logging.getLogger(__name__)
 
 _client: httpx.AsyncClient | None = None
-_definition_id: str = ""
+_experiment_id: str = ""
+_sampler: str = "random"
+_candidate_pool_size: int | None = None
 _poll_interval_s: float = 2.0
 _timeout_s: float = 300.0
 
@@ -28,14 +30,18 @@ class OpenRLHFCallbackContext(Protocol):
 
 def configure(
     ergon_url: str,
-    definition_id: str,
+    experiment_id: str,
+    sampler: str = "random",
+    candidate_pool_size: int | None = None,
     poll_interval_s: float = 2.0,
     timeout_s: float = 300.0,
 ) -> None:
     """Module-level configuration (called by OpenRLHF before agent_func)."""
-    global _client, _definition_id, _poll_interval_s, _timeout_s
+    global _client, _experiment_id, _sampler, _candidate_pool_size, _poll_interval_s, _timeout_s
     _client = httpx.AsyncClient(base_url=ergon_url, timeout=30.0)
-    _definition_id = definition_id
+    _experiment_id = experiment_id
+    _sampler = sampler
+    _candidate_pool_size = candidate_pool_size
     _poll_interval_s = poll_interval_s
     _timeout_s = timeout_s
 
@@ -54,10 +60,13 @@ async def agent_func(
         raise RuntimeError("Call configure() before agent_func()")
 
     resp = await _client.post(
-        "/rollouts/submit",
+        f"/rollouts/experiments/{_experiment_id}/rollout-batches",
         json={
-            "definition_id": _definition_id,
-            "num_episodes": 1,
+            "experimentId": _experiment_id,
+            "k": 1,
+            "sampler": _sampler,
+            "samplerConfig": {},
+            "candidatePoolSize": _candidate_pool_size,
         },
     )
     resp.raise_for_status()
diff --git a/ergon_infra/ergon_infra/adapters/trl_http.py b/ergon_infra/ergon_infra/adapters/trl_http.py
index 9d82663a5..d692665ae 100644
--- a/ergon_infra/ergon_infra/adapters/trl_http.py
+++ b/ergon_infra/ergon_infra/adapters/trl_http.py
@@ -9,7 +9,7 @@
 
     rollout_func = make_ergon_http_rollout_func(
         ergon_url="http://macbook:9000/api",
-        definition_id="<uuid>",
+        experiment_id="<uuid>",
     )
     trainer = GRPOTrainer(..., rollout_func=rollout_func)
 """
@@ -40,7 +40,9 @@ class TRLTrainerContext(Protocol):
 
 def make_ergon_http_rollout_func(
     ergon_url: str,
-    definition_id: str,
+    experiment_id: str,
+    sampler: str = "random",
+    candidate_pool_size: int | None = None,
     poll_interval_s: float = 2.0,
     timeout_s: float = 300.0,
 ) -> Callable[[list, TRLTrainerContext], "RolloutBatch"]:
@@ -48,7 +50,7 @@ def make_ergon_http_rollout_func(
 
     Args:
         ergon_url: base URL of the Ergon API (e.g. ``http://localhost:9000/api``).
-        definition_id: ExperimentDefinition UUID to run episodes against.
+        experiment_id: persisted experiment UUID to sample from.
         poll_interval_s: seconds between poll requests.
         timeout_s: max wall-clock seconds to wait for a batch to complete.
 
@@ -59,10 +61,13 @@ def make_ergon_http_rollout_func(
 
     def rollout_func(prompts: list, trainer: TRLTrainerContext) -> RolloutBatch:
         resp = client.post(
-            "/rollouts/submit",
+            f"/rollouts/experiments/{experiment_id}/rollout-batches",
             json={
-                "definition_id": definition_id,
-                "num_episodes": len(prompts),
+                "experimentId": experiment_id,
+                "k": len(prompts),
+                "sampler": sampler,
+                "samplerConfig": {},
+                "candidatePoolSize": candidate_pool_size,
             },
         )
         resp.raise_for_status()
diff --git a/ergon_infra/ergon_infra/adapters/verl_http.py b/ergon_infra/ergon_infra/adapters/verl_http.py
index ab3c803b6..0915fdbe5 100644
--- a/ergon_infra/ergon_infra/adapters/verl_http.py
+++ b/ergon_infra/ergon_infra/adapters/verl_http.py
@@ -6,7 +6,7 @@
     agent_loop: ergon
     agent_loop_kwargs:
       ergon_url: http://macbook:9000/api
-      definition_id: <uuid>
+      experiment_id: <uuid>
 """
 
 import logging
@@ -26,23 +26,30 @@ class ErgonAgentLoop(AgentLoopBase):
         def __init__(
             self,
             ergon_url: str,
-            definition_id: str,
+            experiment_id: str,
+            sampler: str = "random",
+            candidate_pool_size: int | None = None,
             poll_interval_s: float = 2.0,
             timeout_s: float = 300.0,
             **kwargs: object,
         ) -> None:
             super().__init__(**kwargs)
             self._client = httpx.AsyncClient(base_url=ergon_url, timeout=30.0)
-            self._definition_id = definition_id
+            self._experiment_id = experiment_id
+            self._sampler = sampler
+            self._candidate_pool_size = candidate_pool_size
             self._poll_interval_s = poll_interval_s
             self._timeout_s = timeout_s
 
         async def run(self, sampling_params: dict, **kwargs: object) -> AgentLoopOutput:
             resp = await self._client.post(
-                "/rollouts/submit",
+                f"/rollouts/experiments/{self._experiment_id}/rollout-batches",
                 json={
-                    "definition_id": self._definition_id,
-                    "num_episodes": 1,
+                    "experimentId": self._experiment_id,
+                    "k": 1,
+                    "sampler": self._sampler,
+                    "samplerConfig": {},
+                    "candidatePoolSize": self._candidate_pool_size,
                 },
             )
             resp.raise_for_status()
diff --git a/ergon_infra/ergon_infra/training/config.py b/ergon_infra/ergon_infra/training/config.py
index b9817abcb..d9d37e229 100644
--- a/ergon_infra/ergon_infra/training/config.py
+++ b/ergon_infra/ergon_infra/training/config.py
@@ -19,7 +19,7 @@ class TrainingConfig(BaseModel):
     benchmark: str
     evaluator: str = "stub-rubric"
     limit: int | None = None
-    definition_id: str | None = None
+    experiment_id: str | None = None
 
     # -- Model ----------------------------------------------------------------
     model: str = "Qwen/Qwen2.5-1.5B"
@@ -68,7 +68,7 @@ def _build_training_parser() -> argparse.ArgumentParser:
     p.add_argument("--evaluator", type=str, default="stub-rubric", help="Evaluator slug")
     p.add_argument("--limit", type=int, default=None, help="Max tasks per episode")
     p.add_argument(
-        "--definition-id", type=str, default=None, help="Existing ExperimentDefinition UUID"
+        "--experiment-id", type=str, default=None, help="Existing experiment UUID"
     )
 
     p.add_argument("--model", type=str, default="Qwen/Qwen2.5-1.5B", help="HuggingFace model ID")
@@ -134,7 +134,7 @@ def training_config_from_args(argv: list[str] | None = None) -> TrainingConfig:
         benchmark=args.benchmark,
         evaluator=args.evaluator,
         limit=args.limit,
-        definition_id=args.definition_id,
+        experiment_id=args.experiment_id,
         model=args.model,
         device=args.device,
         vllm_mode=vllm_mode,
diff --git a/ergon_infra/ergon_infra/training/trl_runner.py b/ergon_infra/ergon_infra/training/trl_runner.py
index 13b9c5126..24b18fc6a 100644
--- a/ergon_infra/ergon_infra/training/trl_runner.py
+++ b/ergon_infra/ergon_infra/training/trl_runner.py
@@ -46,11 +46,11 @@ def run_trl_training(config: TrainingConfig) -> int:
             "(e.g. http://localhost:9000/api for local dev)."
         )
 
-    definition_id = config.definition_id
-    if not definition_id:
+    experiment_id = config.experiment_id
+    if not experiment_id:
         raise ValueError(
-            "--definition-id is required. Create one via: "
-            "ergon experiment define <slug> --limit 1 --worker <worker> --model <model>"
+            "--experiment-id is required. Create one via the Python experiment API "
+            "and persist its candidate pool before starting trainer rollouts."
         )
 
     tokenizer = AutoTokenizer.from_pretrained(config.model)
@@ -59,7 +59,7 @@ def run_trl_training(config: TrainingConfig) -> int:
 
     rollout_func = make_ergon_http_rollout_func(
         ergon_url=config.ergon_url,
-        definition_id=definition_id,
+        experiment_id=experiment_id,
         timeout_s=config.timeout_s,
     )
 
@@ -99,7 +99,7 @@ def reward_fn(completions: list[str], **kwargs: object) -> list[float]:
     logger.info("Starting TRL GRPO training")
     logger.info("  Ergon API:     %s", config.ergon_url)
     logger.info("  Model:         %s", config.model)
-    logger.info("  Definition:    %s", definition_id)
+    logger.info("  Experiment:    %s", experiment_id)
     logger.info("  Device:        %s", config.device)
     logger.info("  Output dir:    %s", config.output_dir)
 
diff --git a/ergon_infra/tests/unit/test_training_experiment_submission.py b/ergon_infra/tests/unit/test_training_experiment_submission.py
new file mode 100644
index 000000000..f55aca724
--- /dev/null
+++ b/ergon_infra/tests/unit/test_training_experiment_submission.py
@@ -0,0 +1,59 @@
+from uuid import uuid4
+
+import ergon_infra.adapters.trl_http as trl_http
+
+
+class _FakeResponse:
+    def __init__(self, payload):
+        self._payload = payload
+
+    def raise_for_status(self) -> None:
+        return None
+
+    def json(self):
+        return self._payload
+
+
+class _FakeClient:
+    def __init__(self, *args, **kwargs) -> None:
+        self.requests = []
+        self._polls = 0
+
+    def post(self, path, *, json):
+        self.requests.append(("POST", path, json))
+        return _FakeResponse({"batch_id": "batch-1"})
+
+    def get(self, path):
+        self.requests.append(("GET", path, None))
+        return _FakeResponse({"status": "complete", "trajectories": []})
+
+    def delete(self, path):
+        self.requests.append(("DELETE", path, None))
+        return _FakeResponse({})
+
+
+def test_trl_rollout_func_submits_experiment_batch(monkeypatch) -> None:
+    fake = _FakeClient()
+    monkeypatch.setattr(trl_http.httpx, "Client", lambda *args, **kwargs: fake)
+    experiment_id = uuid4()
+
+    rollout_func = trl_http.make_ergon_http_rollout_func(
+        ergon_url="http://ergon.test",
+        experiment_id=str(experiment_id),
+        sampler="random",
+        candidate_pool_size=256,
+    )
+
+    rollout_func([{"prompt": "a"}, {"prompt": "b"}], object())
+
+    assert fake.requests[0] == (
+        "POST",
+        f"/rollouts/experiments/{experiment_id}/rollout-batches",
+        {
+            "experimentId": str(experiment_id),
+            "k": 2,
+            "sampler": "random",
+            "samplerConfig": {},
+            "candidatePoolSize": 256,
+        },
+    )

From f2a91be92567280b5a2398879c36a95208b774b3 Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Wed, 27 May 2026 00:25:19 +0100
Subject: [PATCH 02/15] Tighten experiment rollout trainer path

---
 .../ergon_core/core/rl/rollout_service.py       |  8 +++++---
 .../test_definition_identity_naming.py          |  6 ++++++
 .../tests/unit/rl/test_rollout_service.py       | 17 +++++++++++++++++
 ergon_infra/ergon_infra/training/config.py      |  4 +---
 4 files changed, 29 insertions(+), 6 deletions(-)

diff --git a/ergon_core/ergon_core/core/rl/rollout_service.py b/ergon_core/ergon_core/core/rl/rollout_service.py
index a8ab87530..4a17942a5 100644
--- a/ergon_core/ergon_core/core/rl/rollout_service.py
+++ b/ergon_core/ergon_core/core/rl/rollout_service.py
@@ -14,7 +14,7 @@
 import inngest
 from ergon_core.api.experiment.experiment import ExperimentRef
 from ergon_core.core.application.experiments.candidate_pool import sample_from_pool_entry
-from ergon_core.core.application.experiments.repositories import (
+from ergon_core.core.application.experiments.repository import (
     ExperimentRepository,
     record_sampler_invocation,
 )
@@ -99,7 +99,9 @@ def submit(self, request: SubmitRequest) -> SubmitResponse:
 
         with self._session_factory() as session:
             definition = session.get(ExperimentDefinition, request.definition_id)
-            benchmark_type = definition.benchmark_type if definition else "rl-rollout"
+            if definition is None:
+                raise ValueError(f"Definition {request.definition_id} not found")
+            benchmark_type = definition.benchmark_type
             session.add(
                 RolloutBatch(
                     id=batch_id,
@@ -235,7 +237,7 @@ async def submit_experiment_batch(
                 experiment_ref=ExperimentRef(
                     id=experiment.id,
                     name=experiment.name,
-                    environment_ids=repository.environment_ids_for_experiment(experiment.id),
+                    environment_ids={},
                     created_at=experiment.created_at,
                     metadata=experiment.metadata_json,
                 ),
diff --git a/ergon_core/tests/unit/architecture/test_definition_identity_naming.py b/ergon_core/tests/unit/architecture/test_definition_identity_naming.py
index 3de9e4c39..4b8c0b794 100644
--- a/ergon_core/tests/unit/architecture/test_definition_identity_naming.py
+++ b/ergon_core/tests/unit/architecture/test_definition_identity_naming.py
@@ -25,14 +25,19 @@
     ROOT / "ergon_core" / "ergon_core" / "core" / "persistence" / "experiments",
     ROOT / "ergon_core" / "ergon_core" / "core" / "views" / "experiments",
     ROOT / "ergon_core" / "ergon_core" / "core" / "views" / "samples",
+    ROOT / "ergon_core" / "ergon_core" / "core" / "rl",
     ROOT / "ergon_core" / "tests" / "integration" / "experiments",
     ROOT / "ergon_core" / "tests" / "unit" / "api",
     ROOT / "ergon_core" / "tests" / "unit" / "core" / "application" / "experiments",
     ROOT / "ergon_core" / "tests" / "unit" / "read_models",
     ROOT / "ergon_core" / "tests" / "unit" / "rest_api",
+    ROOT / "ergon_core" / "tests" / "unit" / "rl",
     ROOT / "ergon_cli" / "ergon_cli" / "domains" / "experiments",
     ROOT / "ergon_cli" / "ergon_cli" / "domains" / "samples",
     ROOT / "ergon_cli" / "tests" / "unit" / "cli",
+    ROOT / "ergon_infra" / "ergon_infra" / "adapters",
+    ROOT / "ergon_infra" / "ergon_infra" / "training",
+    ROOT / "ergon_infra" / "tests" / "unit",
     ROOT / "ergon-dashboard" / "src" / "app" / "experiments",
     ROOT / "ergon-dashboard" / "src" / "app" / "samples",
     ROOT / "ergon-dashboard" / "src" / "components" / "experiments",
@@ -66,6 +71,7 @@
     ROOT / "ergon-dashboard" / "src" / "lib" / "contracts" / "rest.ts",
     ROOT / "ergon-dashboard" / "src" / "lib" / "server-data" / "experiments.ts",
     ROOT / "ergon-dashboard" / "src" / "lib" / "server-data" / "samples.ts",
+    ROOT / "ergon_core" / "ergon_core" / "core" / "infrastructure" / "http" / "routes" / "rollouts.py",
 }
 ALLOWED_EXPERIMENT_ID_PATTERNS_BY_FILE = {
     ROOT / "ergon_core" / "ergon_core" / "api" / "experiment" / "experiment.py": (
diff --git a/ergon_core/tests/unit/rl/test_rollout_service.py b/ergon_core/tests/unit/rl/test_rollout_service.py
index c8c271a8a..d4e6c6cdb 100644
--- a/ergon_core/tests/unit/rl/test_rollout_service.py
+++ b/ergon_core/tests/unit/rl/test_rollout_service.py
@@ -78,3 +78,20 @@ def test_rollout_submit_uses_rollout_batch_and_run_definition_without_legacy_rec
     assert {run.model_target for run in runs} == {"openai:test"}
     assert {membership.sample_id for membership in memberships} == {run.id for run in runs}
     assert len(sent_events) == 2
+
+
+def test_rollout_submit_rejects_missing_definition_without_fallback(session_factory) -> None:
+    service = RolloutService(
+        session_factory=session_factory,
+        inngest_send=lambda event: None,
+        tokenizer_name="unused-in-submit",
+    )
+    definition_id = uuid4()
+
+    with pytest.raises(ValueError, match=f"Definition {definition_id} not found"):
+        service.submit(
+            SubmitRequest(
+                definition_id=definition_id,
+                num_episodes=1,
+            )
+        )
diff --git a/ergon_infra/ergon_infra/training/config.py b/ergon_infra/ergon_infra/training/config.py
index d9d37e229..f52c32642 100644
--- a/ergon_infra/ergon_infra/training/config.py
+++ b/ergon_infra/ergon_infra/training/config.py
@@ -67,9 +67,7 @@ def _build_training_parser() -> argparse.ArgumentParser:
     p.add_argument("--benchmark", type=str, required=True, help="Benchmark slug")
     p.add_argument("--evaluator", type=str, default="stub-rubric", help="Evaluator slug")
     p.add_argument("--limit", type=int, default=None, help="Max tasks per episode")
-    p.add_argument(
-        "--experiment-id", type=str, default=None, help="Existing experiment UUID"
-    )
+    p.add_argument("--experiment-id", type=str, default=None, help="Existing experiment UUID")
 
     p.add_argument("--model", type=str, default="Qwen/Qwen2.5-1.5B", help="HuggingFace model ID")
 

From b68bd04cae25245ddce2a5b7722df9d039278589 Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Wed, 27 May 2026 00:26:48 +0100
Subject: [PATCH 03/15] Format trainer identity guard

---
 .../unit/architecture/test_definition_identity_naming.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/ergon_core/tests/unit/architecture/test_definition_identity_naming.py b/ergon_core/tests/unit/architecture/test_definition_identity_naming.py
index 4b8c0b794..34e0c7160 100644
--- a/ergon_core/tests/unit/architecture/test_definition_identity_naming.py
+++ b/ergon_core/tests/unit/architecture/test_definition_identity_naming.py
@@ -71,7 +71,14 @@
     ROOT / "ergon-dashboard" / "src" / "lib" / "contracts" / "rest.ts",
     ROOT / "ergon-dashboard" / "src" / "lib" / "server-data" / "experiments.ts",
     ROOT / "ergon-dashboard" / "src" / "lib" / "server-data" / "samples.ts",
-    ROOT / "ergon_core" / "ergon_core" / "core" / "infrastructure" / "http" / "routes" / "rollouts.py",
+    ROOT
+    / "ergon_core"
+    / "ergon_core"
+    / "core"
+    / "infrastructure"
+    / "http"
+    / "routes"
+    / "rollouts.py",
 }
 ALLOWED_EXPERIMENT_ID_PATTERNS_BY_FILE = {
     ROOT / "ergon_core" / "ergon_core" / "api" / "experiment" / "experiment.py": (

From b2deec81765b64556ad8c4781020ef66f89434f7 Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Wed, 27 May 2026 00:40:30 +0100
Subject: [PATCH 04/15] Align trainer rollout with experiment samples

---
 .../ergon_cli/domains/training/commands.py    |  2 +-
 .../ergon_cli/domains/training/models.py      |  2 +-
 .../ergon_cli/domains/training/parser.py      |  2 +-
 .../ergon_cli/domains/training/service.py     |  2 +-
 ergon_cli/tests/unit/cli/test_training_cli.py |  7 +-
 .../application/experiments/candidate_pool.py | 86 ++++++++++++++++++-
 .../ergon_core/core/rl/rollout_service.py     | 63 ++------------
 ergon_infra/ergon_infra/training/__main__.py  |  2 +-
 8 files changed, 102 insertions(+), 64 deletions(-)

diff --git a/ergon_cli/ergon_cli/domains/training/commands.py b/ergon_cli/ergon_cli/domains/training/commands.py
index d99f2dca6..9a92a94ab 100644
--- a/ergon_cli/ergon_cli/domains/training/commands.py
+++ b/ergon_cli/ergon_cli/domains/training/commands.py
@@ -20,7 +20,7 @@ def handle_train(args: Namespace) -> int:
         benchmark=args.benchmark,
         evaluator=args.evaluator,
         limit=args.limit,
-        definition_id=args.definition_id,
+        experiment_id=args.experiment_id,
         model=args.model,
         device=args.device,
         vllm_mode=None if args.device == "cpu" else args.vllm_mode,
diff --git a/ergon_cli/ergon_cli/domains/training/models.py b/ergon_cli/ergon_cli/domains/training/models.py
index 94af1d887..070ef90fa 100644
--- a/ergon_cli/ergon_cli/domains/training/models.py
+++ b/ergon_cli/ergon_cli/domains/training/models.py
@@ -11,7 +11,7 @@ class TrainingCommand(BaseModel):
     benchmark: str
     evaluator: str
     limit: int | None
-    definition_id: str | None
+    experiment_id: str | None
     model: str
     device: Literal["cpu", "cuda"]
     vllm_mode: Literal["colocate", "server"] | None
diff --git a/ergon_cli/ergon_cli/domains/training/parser.py b/ergon_cli/ergon_cli/domains/training/parser.py
index a359701cc..905fbfbb2 100644
--- a/ergon_cli/ergon_cli/domains/training/parser.py
+++ b/ergon_cli/ergon_cli/domains/training/parser.py
@@ -17,7 +17,7 @@ def register_train_parser(subparsers: argparse._SubParsersAction) -> None:
     train_local.add_argument("--benchmark", required=True, help="Benchmark slug")
     train_local.add_argument("--evaluator", default="stub-rubric", help="Evaluator slug")
     train_local.add_argument("--limit", type=int, default=None, help="Max tasks per episode")
-    train_local.add_argument("--definition-id", default=None, help="ExperimentDefinition UUID")
+    train_local.add_argument("--experiment-id", default=None, help="Experiment UUID")
     train_local.add_argument("--model", default="Qwen/Qwen2.5-1.5B", help="HuggingFace model ID")
     train_local.add_argument(
         "--device", default="cuda", choices=["cpu", "cuda"], help="Device type"
diff --git a/ergon_cli/ergon_cli/domains/training/service.py b/ergon_cli/ergon_cli/domains/training/service.py
index 76a7394a9..1333422f1 100644
--- a/ergon_cli/ergon_cli/domains/training/service.py
+++ b/ergon_cli/ergon_cli/domains/training/service.py
@@ -26,7 +26,7 @@ def run_training(command: TrainingCommand) -> int:
         benchmark=command.benchmark,
         evaluator=command.evaluator,
         limit=command.limit,
-        definition_id=command.definition_id,
+        experiment_id=command.experiment_id,
         model=command.model,
         device=command.device,
         vllm_mode=None if command.device == "cpu" else command.vllm_mode,
diff --git a/ergon_cli/tests/unit/cli/test_training_cli.py b/ergon_cli/tests/unit/cli/test_training_cli.py
index 4da99067b..b57eb65e0 100644
--- a/ergon_cli/tests/unit/cli/test_training_cli.py
+++ b/ergon_cli/tests/unit/cli/test_training_cli.py
@@ -10,7 +10,7 @@ def _train_args(**overrides: object) -> Namespace:
         "benchmark": "bench",
         "evaluator": "stub-rubric",
         "limit": None,
-        "definition_id": None,
+        "experiment_id": None,
         "model": "Qwen/Qwen2.5-1.5B",
         "device": "cuda",
         "vllm_mode": "server",
@@ -43,8 +43,11 @@ def fake_run_training(command):
 
     monkeypatch.setattr(training_commands, "run_training", fake_run_training)
 
-    rc = training_commands.handle_train(_train_args(device="cpu", vllm_mode="server"))
+    rc = training_commands.handle_train(
+        _train_args(device="cpu", vllm_mode="server", experiment_id="experiment-1")
+    )
 
     assert rc == 0
+    assert captured["command"].experiment_id == "experiment-1"
     assert captured["command"].device == "cpu"
     assert captured["command"].vllm_mode is None
diff --git a/ergon_core/ergon_core/core/application/experiments/candidate_pool.py b/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
index a5d236563..aa6239139 100644
--- a/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
+++ b/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
@@ -3,6 +3,7 @@
 from collections.abc import Sequence
 from uuid import UUID, uuid4
 
+from pydantic import JsonValue
 from sqlmodel import Session
 
 from ergon_core.api.benchmark import Task
@@ -11,8 +12,13 @@
 from ergon_core.api.experiment.sample import Sample
 from ergon_core.core.application.experiments.repository import (
     ExperimentRepository,
+    record_sampler_invocation,
+)
+from ergon_core.core.persistence.experiments.models import (
+    ExperimentRow,
+    ExperimentSamplerInvocationRow,
+    ExperimentSamplePoolEntryRow,
 )
-from ergon_core.core.persistence.experiments.models import ExperimentSamplePoolEntryRow
 
 
 class SampleCandidatePool:
@@ -95,6 +101,64 @@ def mark_selected(
         )
 
 
+def reserve_sample_pool_entries_for_sampler(
+    *,
+    session: Session,
+    experiment_id: UUID,
+    k: int,
+    candidate_pool_size: int | None,
+    sampler_name: str,
+    sampler_config: dict[str, JsonValue] | None = None,
+) -> tuple[ExperimentSamplerInvocationRow, list[ExperimentSamplePoolEntryRow]]:
+    """Reserve existing candidate-pool rows for a trainer sampler.
+
+    Trainer rollout services can ask the experiment application domain for
+    already-buffered samples without importing the experiment repository
+    directly. Stream replenishment remains the Python authoring API's job.
+    """
+
+    experiment = session.get(ExperimentRow, experiment_id)
+    if experiment is None:
+        raise ValueError(f"Experiment {experiment_id} not found")
+
+    repository = ExperimentRepository(session)
+    pool_size = candidate_pool_size or k
+    candidates = repository.pending_unselected_pool_entries(experiment_id)
+    if len(candidates) < k:
+        raise ValueError(
+            "Experiment candidate pool does not contain enough unselected samples. "
+            "Submit through the Python experiment API to replenish streamed environments."
+        )
+
+    config = dict(sampler_config or {})
+    selected_entries = _select_candidate_entries(
+        candidates[:pool_size],
+        k=k,
+        sampler_name=sampler_name,
+        sampler_config=config,
+    )
+    invocation = record_sampler_invocation(
+        session=session,
+        experiment_ref=ExperimentRef(
+            id=experiment.id,
+            name=experiment.name,
+            environment_ids={},
+            created_at=experiment.created_at,
+            metadata=experiment.metadata_json,
+        ),
+        sampler_name=sampler_name,
+        requested_k=k,
+        candidate_pool_size=pool_size,
+        selected_count=len(selected_entries),
+        sampler_config=config,
+    )
+    repository.mark_pool_entries_selected(
+        selected_entries,
+        sampler_invocation_id=invocation.id,
+    )
+    return invocation, selected_entries
+
+
 async def sample_from_pool_entry(entry: ExperimentSamplePoolEntryRow) -> Sample:
     """Rehydrate retained candidate JSON into an authored, unmaterialized Sample."""
 
@@ -133,3 +197,23 @@ async def _task_from_candidate_snapshot(task_json: object) -> Task:
         task.task_payload = EmptyTaskPayload()
     task._task_id = None
     return task
+
+
+def _select_candidate_entries(
+    entries: Sequence[ExperimentSamplePoolEntryRow],
+    *,
+    k: int,
+    sampler_name: str,
+    sampler_config: dict[str, JsonValue],
+) -> list[ExperimentSamplePoolEntryRow]:
+    selected = list(entries)
+    if sampler_name == "random":
+        import random
+
+        seed = sampler_config.get("seed")
+        if seed is not None and not isinstance(seed, (str, bytes, bytearray, int, float)):
+            raise ValueError("Random trainer sampler seed must be a scalar value")
+        random.Random(seed).shuffle(selected)
+    elif sampler_name not in {"sequential", "all"}:
+        raise ValueError(f"Unsupported trainer sampler: {sampler_name}")
+    return selected[: min(k, len(selected))]
diff --git a/ergon_core/ergon_core/core/rl/rollout_service.py b/ergon_core/ergon_core/core/rl/rollout_service.py
index 4a17942a5..8c7e78b9b 100644
--- a/ergon_core/ergon_core/core/rl/rollout_service.py
+++ b/ergon_core/ergon_core/core/rl/rollout_service.py
@@ -12,17 +12,14 @@
 from uuid import UUID, uuid4
 
 import inngest
-from ergon_core.api.experiment.experiment import ExperimentRef
-from ergon_core.core.application.experiments.candidate_pool import sample_from_pool_entry
-from ergon_core.core.application.experiments.repository import (
-    ExperimentRepository,
-    record_sampler_invocation,
+from ergon_core.core.application.experiments.candidate_pool import (
+    reserve_sample_pool_entries_for_sampler,
+    sample_from_pool_entry,
 )
 from ergon_core.core.application.samples.materialization import materialize_sample
 from ergon_core.core.persistence.context.models import SampleContextEvent
 from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.experiments.models import (
-    ExperimentRow,
     ExperimentSamplerInvocationRow,
     ExperimentSamplePoolEntryRow,
 )
@@ -214,43 +211,14 @@ async def submit_experiment_batch(
     ) -> RolloutBatchSummary:
         """Launch a trainer batch from already-buffered experiment candidates."""
         with self._session_factory() as session:
-            experiment = session.get(ExperimentRow, request.experiment_id)
-            if experiment is None:
-                raise ValueError(f"Experiment {request.experiment_id} not found")
-
-            repository = ExperimentRepository(session)
-            pool_size = request.candidate_pool_size or request.k
-            candidates = repository.pending_unselected_pool_entries(request.experiment_id)
-            if len(candidates) < request.k:
-                raise ValueError(
-                    "Experiment candidate pool does not contain enough unselected samples. "
-                    "Submit through the Python experiment API to replenish streamed environments."
-                )
-            selected_entries = _select_candidate_entries(
-                candidates[:pool_size],
-                k=request.k,
-                sampler=request.sampler,
-                sampler_config=request.sampler_config,
-            )
-            invocation = record_sampler_invocation(
+            invocation, selected_entries = reserve_sample_pool_entries_for_sampler(
                 session=session,
-                experiment_ref=ExperimentRef(
-                    id=experiment.id,
-                    name=experiment.name,
-                    environment_ids={},
-                    created_at=experiment.created_at,
-                    metadata=experiment.metadata_json,
-                ),
+                experiment_id=request.experiment_id,
+                k=request.k,
+                candidate_pool_size=request.candidate_pool_size,
                 sampler_name=request.sampler,
-                requested_k=request.k,
-                candidate_pool_size=pool_size,
-                selected_count=len(selected_entries),
                 sampler_config=request.sampler_config,
             )
-            repository.mark_pool_entries_selected(
-                list(selected_entries),
-                sampler_invocation_id=invocation.id,
-            )
             sample_ids = await self._materialize_pool_entries(
                 session=session,
                 invocation=invocation,
@@ -493,20 +461,3 @@ def _extract_trajectories(self, sample_ids: list[UUID]) -> list[Trajectory]:
                     )
                 )
         return result
-
-
-def _select_candidate_entries(
-    entries: Sequence[ExperimentSamplePoolEntryRow],
-    *,
-    k: int,
-    sampler: str,
-    sampler_config: dict[str, object],
-) -> list[ExperimentSamplePoolEntryRow]:
-    selected = list(entries)
-    if sampler == "random":
-        import random
-
-        random.Random(sampler_config.get("seed")).shuffle(selected)
-    elif sampler not in {"sequential", "all"}:
-        raise ValueError(f"Unsupported trainer sampler: {sampler}")
-    return selected[: min(k, len(selected))]
diff --git a/ergon_infra/ergon_infra/training/__main__.py b/ergon_infra/ergon_infra/training/__main__.py
index e1529a765..fabf9ce2e 100644
--- a/ergon_infra/ergon_infra/training/__main__.py
+++ b/ergon_infra/ergon_infra/training/__main__.py
@@ -10,7 +10,7 @@
 
     python -m ergon_infra.training \\
         --benchmark smoke-test \\
-        --definition-id <uuid> \\
+        --experiment-id <uuid> \\
         --model Qwen/Qwen2.5-1.5B \\
         --vllm-mode colocate \\
         --output-dir /checkpoints/test

From 92db2d79732d0e31f9bb237fb74d907588380f7a Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Wed, 27 May 2026 00:43:51 +0100
Subject: [PATCH 05/15] Allow trainer CLI experiment identity

---
 .../tests/unit/architecture/test_definition_identity_naming.py   | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ergon_core/tests/unit/architecture/test_definition_identity_naming.py b/ergon_core/tests/unit/architecture/test_definition_identity_naming.py
index 34e0c7160..7e21e7884 100644
--- a/ergon_core/tests/unit/architecture/test_definition_identity_naming.py
+++ b/ergon_core/tests/unit/architecture/test_definition_identity_naming.py
@@ -34,6 +34,7 @@
     ROOT / "ergon_core" / "tests" / "unit" / "rl",
     ROOT / "ergon_cli" / "ergon_cli" / "domains" / "experiments",
     ROOT / "ergon_cli" / "ergon_cli" / "domains" / "samples",
+    ROOT / "ergon_cli" / "ergon_cli" / "domains" / "training",
     ROOT / "ergon_cli" / "tests" / "unit" / "cli",
     ROOT / "ergon_infra" / "ergon_infra" / "adapters",
     ROOT / "ergon_infra" / "ergon_infra" / "training",

From 95d02e46afe0c0ea3e8c5dc8924cf2a3587f4bae Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Wed, 27 May 2026 01:05:43 +0100
Subject: [PATCH 06/15] Remove stale definition rollout launch surfaces

---
 ergon_builtins/AGENTS.md                      |  18 +--
 .../ergon_builtins/benchmarks/README.md       |   5 +-
 ergon_cli/ergon_cli/domains/eval/service.py   |   3 +-
 .../infrastructure/http/routes/rollouts.py    |  11 --
 .../http/routes/test_harness.py               |   6 +-
 ergon_core/ergon_core/core/rl/eval_runner.py  | 112 ++++--------------
 .../ergon_core/core/rl/rollout_service.py     |  74 +-----------
 .../ergon_core/core/rl/rollout_types.py       |  17 ---
 .../test_definition_identity_naming.py        |   1 +
 .../tests/unit/rest_api/test_rollouts_di.py   |  15 ++-
 ergon_core/tests/unit/rl/test_eval_runner.py  |  20 ++++
 .../rl/test_rollout_experiment_submission.py  |  17 +++
 .../tests/unit/rl/test_rollout_service.py     |  97 ---------------
 .../ergon_infra/templates/eval-only.yaml      |  22 ++--
 .../templates/train-trl-multinode.yaml        |   6 +-
 .../ergon_infra/templates/train-trl.yaml      |   6 +-
 .../templates/train-with-eval.yaml            |  12 +-
 .../ergon_infra/training/trl_runner.py        |   2 +-
 tests/e2e/conftest.py                         | 110 -----------------
 19 files changed, 117 insertions(+), 437 deletions(-)
 create mode 100644 ergon_core/tests/unit/rl/test_eval_runner.py
 delete mode 100644 ergon_core/tests/unit/rl/test_rollout_service.py

diff --git a/ergon_builtins/AGENTS.md b/ergon_builtins/AGENTS.md
index ec20e7845..39593da36 100644
--- a/ergon_builtins/AGENTS.md
+++ b/ergon_builtins/AGENTS.md
@@ -14,13 +14,13 @@ update this doc in the same PR.
 
 | Goal | Command |
 |---|---|
-| Populate **SANDBOX** panel (stdin/stdout events) with no LLM | `ergon experiment define researchrubrics-smoke --worker canonical-smoke --model stub:constant --limit 1 && ergon experiment run <experiment-id>` |
-| Populate **GENERATIONS** without calling a model | `ergon experiment define smoke-test --worker training-stub --model stub:constant --limit 1 && ergon experiment run <experiment-id>` |
-| Populate **EVALUATION** with a passing gate, no LLM | any benchmark + `--evaluator stub-rubric` |
-| Populate **EVALUATION** with varied scores (RL reward-shape test) | any benchmark + `--evaluator varied-stub-rubric` |
-| Test a real ReAct agent end-to-end | `ergon experiment define swebench-verified --worker swebench-react --model openai:gpt-4o --limit 1 && ergon experiment run <experiment-id>` |
-| Test manager → researcher delegation with a real LLM | `ergon experiment define researchrubrics-smoke --worker researchrubrics-researcher --model openai:gpt-4o --limit 1 && ergon experiment run <experiment-id>` |
-| Test Lean 4 proof verification | `ergon experiment define minif2f --worker minif2f-react --model openai:gpt-4o --limit 1 && ergon experiment run <experiment-id>` (needs Lean sandbox) |
+| Populate **SANDBOX** panel (stdin/stdout events) with no LLM | Use a Python submit script that builds a `ResearchRubricsEnvironment` with the canonical smoke worker and calls `Experiment.submit(...)`. |
+| Populate **GENERATIONS** without calling a model | Use a Python submit script with an environment bound to `TrainingStubWorker`; inspect with `ergon sample show <sample-id>`. |
+| Populate **EVALUATION** with a passing gate, no LLM | Bind `stub-rubric` in the environment's evaluator list. |
+| Populate **EVALUATION** with varied scores (RL reward-shape test) | Bind `varied-stub-rubric` in the environment's evaluator list. |
+| Test a real ReAct agent end-to-end | Build the relevant builtin environment in Python with the ReAct worker and submit it through `Experiment.submit(...)`. |
+| Test manager -> researcher delegation with a real LLM | Build `ResearchRubricsEnvironment` in Python with `researchrubrics-researcher` and submit it through `Experiment.submit(...)`. |
+| Test Lean 4 proof verification | Build `MiniF2FEnvironment` in Python with the MiniF2F worker/rubric and submit it through `Experiment.submit(...)` (needs Lean sandbox). |
 
 ---
 
@@ -36,8 +36,8 @@ Which worker emits what.  `—` = not applicable, `✗` = nothing emitted.
 | `minif2f-react` | ✓ | ✓ (proof artifact) | ✓ (Lean files) | ✓ |
 | `researchrubrics-researcher` | ✓ | ✓ (SampleResource kind=REPORT) | ✓ (writes `final_output/report.md`) | ✗ |
 
-EVALUATION is populated by whichever **evaluator** you pass with
-`--evaluator`; see table below.
+EVALUATION is populated by the **evaluators** bound to the submitted
+environment; see table below.
 
 ---
 
diff --git a/ergon_builtins/ergon_builtins/benchmarks/README.md b/ergon_builtins/ergon_builtins/benchmarks/README.md
index d464dae97..3c655ea5b 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/README.md
+++ b/ergon_builtins/ergon_builtins/benchmarks/README.md
@@ -1,8 +1,7 @@
 # Builtin Benchmarks
 
 Each subdirectory is one benchmark.  Import from Python; **there is no
-CLI authoring path** (PR 6.5 deleted `ergon experiment define` /
-`ergon run <benchmark>`).  Authoring is Python-only; the CLI is for
+CLI authoring path**.  Authoring is Python-only; the CLI is for
 observation (`ergon experiment show`, `ergon sample status`, and related read
 commands).
 
@@ -95,6 +94,6 @@ Or just `ls ergon_builtins/ergon_builtins/benchmarks/`.
 After persisting and launching a benchmark from Python, use the CLI to observe its state:
 
 - `ergon run status <run-id>` — current state of one run
-- `ergon run list [--status=S] [--definition-id=<UUID>]` — list runs, optionally filtered
+- `ergon sample list [--status=S] [--experiment-id=<UUID>]` — list samples, optionally filtered
 - `ergon experiment show <UUID>` — full experiment detail (UUID-based)
 - `ergon experiment list` — list recent experiments
diff --git a/ergon_cli/ergon_cli/domains/eval/service.py b/ergon_cli/ergon_cli/domains/eval/service.py
index df1e23eaa..99cdf2805 100644
--- a/ergon_cli/ergon_cli/domains/eval/service.py
+++ b/ergon_cli/ergon_cli/domains/eval/service.py
@@ -20,11 +20,10 @@ async def run_eval(command: EvalCommand) -> int:
 
     if command.checkpoint is None:
         raise CliUsageError("Usage: ergon eval checkpoint --checkpoint <path>")
-    await evaluate_checkpoint(
+    return await evaluate_checkpoint(
         checkpoint_path=command.checkpoint,
         benchmark_type=command.benchmark,
         evaluator_type=command.evaluator,
         model_base=command.model_base,
         eval_limit=command.eval_limit,
     )
-    return 0
diff --git a/ergon_core/ergon_core/core/infrastructure/http/routes/rollouts.py b/ergon_core/ergon_core/core/infrastructure/http/routes/rollouts.py
index 50634eb8b..9b0894dda 100644
--- a/ergon_core/ergon_core/core/infrastructure/http/routes/rollouts.py
+++ b/ergon_core/ergon_core/core/infrastructure/http/routes/rollouts.py
@@ -13,8 +13,6 @@
 from ergon_core.core.rl.rollout_types import (
     PollResponse,
     RolloutBatchSummary,
-    SubmitRequest,
-    SubmitResponse,
     TrainingRolloutRequest,
     WeightSyncRequest,
     WeightSyncResponse,
@@ -43,15 +41,6 @@ def get_vllm_manager(request: Request) -> VLLMManager | None:
     return cast(VLLMManager, manager)
 
 
-@router.post("/submit", response_model=SubmitResponse, status_code=202)
-def submit_rollout(
-    request: SubmitRequest,
-    service: Annotated[RolloutService, Depends(get_rollout_service)],
-) -> SubmitResponse:
-    """Start a batch of episodes. Returns immediately with batch_id."""
-    return service.submit(request)
-
-
 @router.post(
     "/experiments/{experiment_id}/rollout-batches",
     response_model=RolloutBatchSummary,
diff --git a/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py b/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py
index bfd08f3ab..1424dfc55 100644
--- a/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py
+++ b/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py
@@ -33,7 +33,11 @@
     SweBenchSmokeBenchmark,
 )
 
-router = APIRouter(prefix="/api/__danger__/test-harness", tags=["danger-test-harness"])
+router = APIRouter(
+    prefix="/api/__danger__/test-harness",
+    tags=["danger-test-harness"],
+    include_in_schema=False,
+)
 
 _SMOKE_BENCHMARKS = {
     benchmark.type_slug: benchmark
diff --git a/ergon_core/ergon_core/core/rl/eval_runner.py b/ergon_core/ergon_core/core/rl/eval_runner.py
index 2f2181413..ab30cb04a 100644
--- a/ergon_core/ergon_core/core/rl/eval_runner.py
+++ b/ergon_core/ergon_core/core/rl/eval_runner.py
@@ -1,8 +1,9 @@
-"""Eval watcher: score checkpoints on Ergon benchmarks.
+"""Eval watcher: score checkpoints through Pythonic experiment submit scripts.
 
-Watches a checkpoint directory, detects new checkpoints, runs
-``ergon experiment define`` + ``ergon experiment run`` against each,
-and optionally reports results.
+Watches a checkpoint directory, detects new checkpoints, and delegates each
+checkpoint to an explicit command supplied by the caller. The CLI no longer
+constructs or submits experiment work itself; benchmark/environment composition
+stays in Python authoring code.
 
 The watcher runs on CPU.  For vLLM-based evaluation, use
 ``--on-checkpoint`` to spawn a SkyPilot GPU job per checkpoint.
@@ -10,17 +11,13 @@
 
 import asyncio
 import logging
-import re
 import shlex
 import subprocess
 
 from ergon_core.core.rl.checkpoint import CheckpointInfo, discover_checkpoints
 
 logger = logging.getLogger(__name__)
-_UUID_RE = re.compile(
-    r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}",
-    re.IGNORECASE,
-)
+LOCAL_EVAL_UNSUPPORTED_EXIT_CODE = 2
 
 
 async def watch_and_evaluate(
@@ -103,83 +100,24 @@ async def _run_local_eval(
     model_base: str,
     eval_limit: int | None,
 ) -> int:
-    """Run checkpoint evaluation locally via the experiment CLI. Returns exit code.
+    """Reject local CLI-launched evaluation.
 
-    Uses the checkpoint path as the vLLM model target so each checkpoint
-    is actually evaluated (not just the base model).
+    The removed CLI launch path used to hide benchmark composition inside the
+    eval CLI. Callers should use ``--on-checkpoint`` with
+    a Python entrypoint that builds the desired Experiment/Environment/Sampler
+    objects and submits them directly.
     """
-    if eval_limit is None:
-        raise ValueError("--eval-limit is required for local checkpoint evaluation")
-
-    model_target = f"vllm:{ckpt.path}"
-
-    define_cmd = [
-        "ergon",
-        "experiment",
-        "define",
+    logger.error(
+        "Local checkpoint evaluation is no longer supported by the CLI. "
+        "Use --on-checkpoint with a Python experiment submission command "
+        "(checkpoint=%s benchmark=%s evaluator=%s model_base=%s eval_limit=%s).",
+        ckpt.path,
         benchmark_type,
-        "--worker",
-        "training-stub",
-        "--evaluator",
         evaluator_type,
-        "--model",
-        model_target,
-        "--limit",
-        str(eval_limit),
-    ]
-
-    logger.info("Defining local eval experiment for step %d: %s", ckpt.step, " ".join(define_cmd))
-
-    env = dict(__import__("os").environ)
-    env["ERGON_CHECKPOINT_STEP"] = str(ckpt.step)
-    env["ERGON_CHECKPOINT_PATH"] = ckpt.path
-
-    try:
-        define_proc = await asyncio.create_subprocess_exec(
-            *define_cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            env=env,
-        )
-        stdout, stderr = await define_proc.communicate()
-
-        exit_code = 0 if define_proc.returncode is None else define_proc.returncode
-        output = stdout.decode() + stderr.decode()
-        if exit_code != 0:
-            logger.warning(
-                "Eval experiment definition failed for step %d (exit %d): %s",
-                ckpt.step,
-                exit_code,
-                output[:500],
-            )
-            return exit_code
-
-        definition_id = _parse_uuid_line("EXPERIMENT_ID=", output)
-        run_cmd = ["ergon", "experiment", "run", definition_id]
-        logger.info("Running local eval for step %d: %s", ckpt.step, " ".join(run_cmd))
-
-        run_proc = await asyncio.create_subprocess_exec(
-            *run_cmd,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            env=env,
-        )
-        _stdout, stderr = await run_proc.communicate()
-
-        exit_code = 0 if run_proc.returncode is None else run_proc.returncode
-        if exit_code == 0:
-            logger.info("Eval complete for step %d", ckpt.step)
-        else:
-            logger.warning(
-                "Eval failed for step %d (exit %d): %s",
-                ckpt.step,
-                exit_code,
-                stderr.decode()[:500],
-            )
-        return exit_code
-    except Exception:  # slopcop: ignore[no-broad-except]
-        logger.exception("Eval crashed for step %d", ckpt.step)
-        return 1
+        model_base,
+        eval_limit,
+    )
+    return LOCAL_EVAL_UNSUPPORTED_EXIT_CODE
 
 
 async def evaluate_checkpoint(
@@ -205,13 +143,3 @@ async def evaluate_checkpoint(
         model_base=model_base,
         eval_limit=eval_limit,
     )
-
-
-def _parse_uuid_line(prefix: str, output: str) -> str:
-    for line in output.splitlines():
-        if not line.startswith(prefix):
-            continue
-        match = _UUID_RE.search(line)
-        if match is not None:
-            return match.group(0)
-    raise RuntimeError(f"missing {prefix} line in CLI output:\n{output}")
diff --git a/ergon_core/ergon_core/core/rl/rollout_service.py b/ergon_core/ergon_core/core/rl/rollout_service.py
index 8c7e78b9b..0ead10e2e 100644
--- a/ergon_core/ergon_core/core/rl/rollout_service.py
+++ b/ergon_core/ergon_core/core/rl/rollout_service.py
@@ -1,7 +1,7 @@
 """Rollout-as-a-Service: orchestrate episode batches for RL trainers.
 
 Encapsulates all logic previously inline in trl_adapter.py. Both the
-HTTP endpoint (/rollouts/) and any in-process callers delegate here.
+HTTP endpoints (/rollouts/) and any in-process callers delegate here.
 
 Batch state is durable in PG — survives API restarts.
 """
@@ -9,7 +9,7 @@
 import logging
 from collections import defaultdict
 from collections.abc import Callable, Sequence
-from uuid import UUID, uuid4
+from uuid import UUID
 
 import inngest
 from ergon_core.core.application.experiments.candidate_pool import (
@@ -18,7 +18,6 @@
 )
 from ergon_core.core.application.samples.materialization import materialize_sample
 from ergon_core.core.persistence.context.models import SampleContextEvent
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.experiments.models import (
     ExperimentSamplerInvocationRow,
     ExperimentSamplePoolEntryRow,
@@ -27,7 +26,6 @@
     TERMINAL_SAMPLE_STATUSES,
     SampleStatus,
 )
-from ergon_core.core.persistence.shared.ids import new_id
 from ergon_core.core.persistence.telemetry.models import (
     RolloutBatch,
     RolloutBatchSampleMembership,
@@ -45,8 +43,6 @@
     EpisodeFailure,
     PollResponse,
     RolloutBatchSummary,
-    SubmitRequest,
-    SubmitResponse,
     Trajectory,
     TrainingRolloutRequest,
 )
@@ -60,7 +56,7 @@ class RolloutService:
     """Orchestrate rollout batches: create runs, fire events, poll, extract.
 
     Lifecycle:
-      1. Trainer calls ``submit()`` → SampleRecords + RolloutBatch created, Inngest events fired
+      1. Trainer calls ``submit_experiment_batch()`` → SampleRecords + RolloutBatch created, Inngest events fired
       2. Trainer polls ``poll()`` → returns RUNNING until all episodes finish
       3. When all terminal → ``poll()`` extracts trajectories and returns COMPLETE
 
@@ -89,70 +85,6 @@ def _get_tokenizer(self) -> Tokenizer:
             self._tokenizer = AutoTokenizer.from_pretrained(self._tokenizer_name)
         return self._tokenizer
 
-    def submit(self, request: SubmitRequest) -> SubmitResponse:
-        """Create SampleRecords, RolloutBatch, and fire Inngest workflow/started events."""
-        batch_id = uuid4()
-        sample_ids: list[UUID] = []
-
-        with self._session_factory() as session:
-            definition = session.get(ExperimentDefinition, request.definition_id)
-            if definition is None:
-                raise ValueError(f"Definition {request.definition_id} not found")
-            benchmark_type = definition.benchmark_type
-            session.add(
-                RolloutBatch(
-                    id=batch_id,
-                    status=BatchStatus.PENDING,
-                )
-            )
-
-            for index in range(request.num_episodes):
-                sample_id = new_id()
-                session.add(
-                    SampleRecord(
-                        id=sample_id,
-                        definition_id=request.definition_id,
-                        benchmark_type=benchmark_type,
-                        instance_key=f"episode-{index}",
-                        worker_team_json={"primary": "rl-rollout"},
-                        model_target=request.model_target_override,
-                        status=SampleStatus.PENDING,
-                    )
-                )
-                session.add(
-                    RolloutBatchSampleMembership(
-                        batch_id=batch_id,
-                        sample_id=sample_id,
-                        ordinal=index,
-                    )
-                )
-                sample_ids.append(sample_id)
-
-            session.commit()
-
-        for sample_id in sample_ids:
-            self._inngest_send(
-                inngest.Event(
-                    name=WorkflowStartedEvent.name,
-                    data=WorkflowStartedEvent(
-                        sample_id=sample_id,
-                        definition_id=request.definition_id,
-                    ).model_dump(mode="json"),
-                )
-            )
-
-        logger.info(
-            "Submitted batch %s: %d episodes for definition %s",
-            batch_id,
-            request.num_episodes,
-            request.definition_id,
-        )
-        return SubmitResponse(
-            batch_id=batch_id,
-            sample_ids=sample_ids,
-            status=BatchStatus.PENDING,
-        )
-
     def create_rollout_batch(
         self,
         session: Session,
diff --git a/ergon_core/ergon_core/core/rl/rollout_types.py b/ergon_core/ergon_core/core/rl/rollout_types.py
index cefb5adc5..95bea5036 100644
--- a/ergon_core/ergon_core/core/rl/rollout_types.py
+++ b/ergon_core/ergon_core/core/rl/rollout_types.py
@@ -15,23 +15,6 @@ def _to_camel(value: str) -> str:
     return parts[0] + "".join(part.capitalize() for part in parts[1:])
 
 
-class SubmitRequest(BaseModel):
-    """Trainer → Ergon: start a batch of episodes."""
-
-    definition_id: UUID
-    num_episodes: int = Field(ge=1)
-    policy_version: int | None = None
-    model_target_override: str | None = None
-
-
-class SubmitResponse(BaseModel):
-    """Ergon → Trainer: batch accepted."""
-
-    batch_id: UUID
-    sample_ids: list[UUID]
-    status: BatchStatus = BatchStatus.PENDING
-
-
 class TrainingRolloutRequest(BaseModel):
     """Trainer → Ergon: select and launch samples from a persisted experiment."""
 
diff --git a/ergon_core/tests/unit/architecture/test_definition_identity_naming.py b/ergon_core/tests/unit/architecture/test_definition_identity_naming.py
index 7e21e7884..a5a03c337 100644
--- a/ergon_core/tests/unit/architecture/test_definition_identity_naming.py
+++ b/ergon_core/tests/unit/architecture/test_definition_identity_naming.py
@@ -44,6 +44,7 @@
     ROOT / "ergon-dashboard" / "src" / "components" / "experiments",
     ROOT / "ergon-dashboard" / "src" / "components" / "indexes",
     ROOT / "ergon-dashboard" / "src" / "components" / "samples",
+    ROOT / "ergon-dashboard" / "src" / "generated" / "rest",
     ROOT / "ergon-dashboard" / "src" / "lib" / "sample-state",
     ROOT / "ergon-dashboard" / "tests" / "components",
     ROOT / "ergon-dashboard" / "tests" / "contracts",
diff --git a/ergon_core/tests/unit/rest_api/test_rollouts_di.py b/ergon_core/tests/unit/rest_api/test_rollouts_di.py
index 6dab21ad4..89bd199f2 100644
--- a/ergon_core/tests/unit/rest_api/test_rollouts_di.py
+++ b/ergon_core/tests/unit/rest_api/test_rollouts_di.py
@@ -9,12 +9,15 @@ class _FakeRolloutService:
     def __init__(self) -> None:
         self.batch_id = uuid4()
         self.sample_id = uuid4()
+        self.submitted_request = None
 
-    def submit(self, _request: object) -> dict[str, object]:
+    async def submit_experiment_batch(self, request: object) -> dict[str, object]:
+        self.submitted_request = request
         return {
             "batch_id": self.batch_id,
             "sample_ids": [self.sample_id],
             "status": "pending",
+            "sampler_invocation_id": str(uuid4()),
         }
 
     def get_rollout_batch_by_id(self, _batch_id: object) -> dict[str, object]:
@@ -33,21 +36,23 @@ def restart(self, checkpoint_path: str) -> None:
         self.restarted_with = checkpoint_path
 
 
-def test_rollout_router_gets_service_from_app_state() -> None:
+def test_rollout_router_gets_experiment_service_from_app_state() -> None:
+    experiment_id = uuid4()
     app = FastAPI()
     app.state.rollout_service = _FakeRolloutService()
     app.include_router(router)
     client = TestClient(app)
 
     resp = client.post(
-        "/rollouts/submit",
+        f"/rollouts/experiments/{experiment_id}/rollout-batches",
         json={
-            "definition_id": str(uuid4()),
-            "num_episodes": 1,
+            "experimentId": str(experiment_id),
+            "k": 1,
         },
     )
 
     assert resp.status_code == 202
+    assert app.state.rollout_service.submitted_request.experiment_id == experiment_id
 
 
 def test_rollout_batch_route_exposes_sample_ids() -> None:
diff --git a/ergon_core/tests/unit/rl/test_eval_runner.py b/ergon_core/tests/unit/rl/test_eval_runner.py
new file mode 100644
index 000000000..b8b69e334
--- /dev/null
+++ b/ergon_core/tests/unit/rl/test_eval_runner.py
@@ -0,0 +1,20 @@
+import asyncio
+
+from ergon_core.core.rl.eval_runner import (
+    LOCAL_EVAL_UNSUPPORTED_EXIT_CODE,
+    evaluate_checkpoint,
+)
+
+
+def test_checkpoint_eval_does_not_submit_experiments_through_cli() -> None:
+    exit_code = asyncio.run(
+        evaluate_checkpoint(
+            checkpoint_path="/tmp/checkpoint-1",
+            benchmark_type="gdpeval",
+            evaluator_type="stub-rubric",
+            model_base="base-model",
+            eval_limit=1,
+        )
+    )
+
+    assert exit_code == LOCAL_EVAL_UNSUPPORTED_EXIT_CODE
diff --git a/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py b/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py
index 66b1de1a4..c090dfecf 100644
--- a/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py
+++ b/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py
@@ -62,3 +62,20 @@ def test_experiment_rollout_route_rejects_mismatched_experiment_id() -> None:
     )
 
     assert response.status_code == 400
+
+
+def test_definition_rollout_submit_route_does_not_accept_public_submissions() -> None:
+    app = FastAPI()
+    app.state.rollout_service = _FakeRolloutService()
+    app.include_router(router)
+    client = TestClient(app)
+
+    response = client.post(
+        "/rollouts/submit",
+        json={
+            "definitionId": str(uuid4()),
+            "numEpisodes": 1,
+        },
+    )
+
+    assert response.status_code in {404, 405}
diff --git a/ergon_core/tests/unit/rl/test_rollout_service.py b/ergon_core/tests/unit/rl/test_rollout_service.py
deleted file mode 100644
index d4e6c6cdb..000000000
--- a/ergon_core/tests/unit/rl/test_rollout_service.py
+++ /dev/null
@@ -1,97 +0,0 @@
-from uuid import uuid4
-
-import inngest
-import pytest
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
-from ergon_core.core.persistence.telemetry.models import (
-    RolloutBatch,
-    RolloutBatchSampleMembership,
-    SampleRecord,
-)
-from ergon_core.core.rl.rollout_service import RolloutService
-from ergon_core.core.rl.rollout_types import SubmitRequest
-from sqlalchemy.pool import StaticPool
-from sqlmodel import Session, SQLModel, create_engine, select
-
-
-@pytest.fixture()
-def session_factory():
-    engine = create_engine(
-        "sqlite://",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    SQLModel.metadata.create_all(
-        engine,
-        tables=[
-            ExperimentDefinition.__table__,
-            SampleRecord.__table__,
-            RolloutBatch.__table__,
-            RolloutBatchSampleMembership.__table__,
-        ],
-    )
-
-    def _get_session() -> Session:
-        return Session(engine)
-
-    return _get_session
-
-
-def test_rollout_submit_uses_rollout_batch_and_run_definition_without_legacy_record(
-    session_factory,
-) -> None:
-    sent_events: list[inngest.Event] = []
-    definition_id = uuid4()
-    with session_factory() as session:
-        session.add(
-            ExperimentDefinition(
-                id=definition_id,
-                benchmark_type="ci-benchmark",
-                name="ci definition",
-                metadata_json={},
-            )
-        )
-        session.commit()
-
-    service = RolloutService(
-        session_factory=session_factory,
-        inngest_send=sent_events.append,
-        tokenizer_name="unused-in-submit",
-    )
-
-    response = service.submit(
-        SubmitRequest(
-            definition_id=definition_id,
-            num_episodes=2,
-            model_target_override="openai:test",
-        )
-    )
-
-    with session_factory() as session:
-        batch = session.get(RolloutBatch, response.batch_id)
-        runs = list(session.exec(select(SampleRecord)).all())
-        memberships = list(session.exec(select(RolloutBatchSampleMembership)).all())
-
-    assert batch is not None
-    assert batch.experiment_id is None
-    assert {run.definition_id for run in runs} == {definition_id}
-    assert {run.model_target for run in runs} == {"openai:test"}
-    assert {membership.sample_id for membership in memberships} == {run.id for run in runs}
-    assert len(sent_events) == 2
-
-
-def test_rollout_submit_rejects_missing_definition_without_fallback(session_factory) -> None:
-    service = RolloutService(
-        session_factory=session_factory,
-        inngest_send=lambda event: None,
-        tokenizer_name="unused-in-submit",
-    )
-    definition_id = uuid4()
-
-    with pytest.raises(ValueError, match=f"Definition {definition_id} not found"):
-        service.submit(
-            SubmitRequest(
-                definition_id=definition_id,
-                num_episodes=1,
-            )
-        )
diff --git a/ergon_infra/ergon_infra/templates/eval-only.yaml b/ergon_infra/ergon_infra/templates/eval-only.yaml
index 0c9a13745..cc1529db7 100644
--- a/ergon_infra/ergon_infra/templates/eval-only.yaml
+++ b/ergon_infra/ergon_infra/templates/eval-only.yaml
@@ -6,7 +6,8 @@
 #
 #   sky launch ergon_infra/ergon_infra/templates/eval-only.yaml -y \
 #     --env CHECKPOINT=s3://bucket/checkpoint-500 \
-#     --env BENCHMARK=gdpeval
+#     --env BENCHMARK=gdpeval \
+#     --env EVAL_COMMAND='python examples/my_eval_submit.py'
 
 name: ergon-eval
 
@@ -19,6 +20,7 @@ envs:
   BENCHMARK:
   EVALUATOR: ${EVALUATOR:-stub-rubric}
   EVAL_LIMIT: ${EVAL_LIMIT:-50}
+  EVAL_COMMAND:
 
 setup: |
   git clone https://github.com/DeepFlow-research/ergon.git /tmp/ergon
@@ -39,9 +41,15 @@ run: |
     sleep 1
   done
 
-  EXPERIMENT_ID="$(ergon experiment define "$BENCHMARK" \
-    --model "vllm:http://localhost:8000" \
-    --worker "training-stub" \
-    --evaluator "$EVALUATOR" \
-    --limit "$EVAL_LIMIT" 2>&1 | sed -n 's/^EXPERIMENT_ID=//p')"
-  ergon experiment run "$EXPERIMENT_ID"
+  if [ -z "$EVAL_COMMAND" ]; then
+    echo "EVAL_COMMAND must be a Python experiment submission command."
+    echo "The command receives MODEL_TARGET, BENCHMARK, EVALUATOR, EVAL_LIMIT, and CHECKPOINT."
+    exit 2
+  fi
+
+  export MODEL_TARGET="vllm:http://localhost:8000"
+  export ERGON_EVAL_MODEL_TARGET="$MODEL_TARGET"
+  export ERGON_EVAL_BENCHMARK="$BENCHMARK"
+  export ERGON_EVAL_EVALUATOR="$EVALUATOR"
+  export ERGON_EVAL_LIMIT="$EVAL_LIMIT"
+  eval "$EVAL_COMMAND"
diff --git a/ergon_infra/ergon_infra/templates/train-trl-multinode.yaml b/ergon_infra/ergon_infra/templates/train-trl-multinode.yaml
index 0bde52727..8ca8d75a0 100644
--- a/ergon_infra/ergon_infra/templates/train-trl-multinode.yaml
+++ b/ergon_infra/ergon_infra/templates/train-trl-multinode.yaml
@@ -7,7 +7,7 @@
 # Weight sync between training and vLLM happens via NCCL automatically.
 #
 #   sky launch ergon_infra/ergon_infra/templates/train-trl-multinode.yaml -y \
-#     --env DEFINITION_ID=<uuid> \
+#     --env EXPERIMENT_ID=<uuid> \
 #     --env MODEL=Qwen/Qwen2.5-1.5B
 
 name: ergon-training-multinode
@@ -23,7 +23,7 @@ file_mounts:
     mode: MOUNT_CACHED
 
 envs:
-  DEFINITION_ID:
+  EXPERIMENT_ID:
   MODEL:
   BENCHMARK: ${BENCHMARK:-smoke-test}
   VLLM_TP_SIZE: ${VLLM_TP_SIZE:-1}
@@ -60,7 +60,7 @@ run: |
 
     ergon train local \
       --benchmark "$BENCHMARK" \
-      --definition-id "$DEFINITION_ID" \
+      --experiment-id "$EXPERIMENT_ID" \
       --model "$MODEL" \
       --vllm-mode server \
       --vllm-server-url "http://$HEAD_IP:8000" \
diff --git a/ergon_infra/ergon_infra/templates/train-trl.yaml b/ergon_infra/ergon_infra/templates/train-trl.yaml
index f7d3d8f68..8bae5ebf2 100644
--- a/ergon_infra/ergon_infra/templates/train-trl.yaml
+++ b/ergon_infra/ergon_infra/templates/train-trl.yaml
@@ -3,7 +3,7 @@
 #       file_mounts to sync local source (see /tmp/ac2-gpu-test.yaml pattern).
 #
 #   sky launch ergon_infra/ergon_infra/templates/train-trl.yaml -y \
-#     --env DEFINITION_ID=<uuid> \
+#     --env EXPERIMENT_ID=<uuid> \
 #     --env MODEL=Qwen/Qwen2.5-7B \
 #     --env BENCHMARK=smoke-test
 
@@ -19,7 +19,7 @@ file_mounts:
     mode: MOUNT_CACHED
 
 envs:
-  DEFINITION_ID:
+  EXPERIMENT_ID:
   MODEL:
   BENCHMARK: ${BENCHMARK:-smoke-test}
   VLLM_MODE: ${VLLM_MODE:-server}
@@ -56,7 +56,7 @@ run: |
 
   ergon train local \
     --benchmark "$BENCHMARK" \
-    --definition-id "$DEFINITION_ID" \
+    --experiment-id "$EXPERIMENT_ID" \
     --model "$MODEL" \
     --vllm-mode "$VLLM_MODE" \
     --vllm-server-url "http://localhost:$VLLM_PORT" \
diff --git a/ergon_infra/ergon_infra/templates/train-with-eval.yaml b/ergon_infra/ergon_infra/templates/train-with-eval.yaml
index be0c7fff5..ea43f2a8f 100644
--- a/ergon_infra/ergon_infra/templates/train-with-eval.yaml
+++ b/ergon_infra/ergon_infra/templates/train-with-eval.yaml
@@ -3,9 +3,10 @@
 #       file_mounts to sync local source (see /tmp/ac2-gpu-test.yaml pattern).
 #
 #   sky jobs launch ergon_infra/ergon_infra/templates/train-with-eval.yaml -y \
-#     --env DEFINITION_ID=<uuid> \
+#     --env EXPERIMENT_ID=<uuid> \
 #     --env MODEL=Qwen/Qwen2.5-7B \
-#     --env BENCHMARK=gdpeval
+#     --env BENCHMARK=gdpeval \
+#     --env EVAL_COMMAND='python examples/my_eval_submit.py'
 
 name: ergon-rl-full
 execution: parallel
@@ -22,7 +23,7 @@ file_mounts:
     mode: MOUNT_CACHED
 
 envs:
-  DEFINITION_ID:
+  EXPERIMENT_ID:
   MODEL:
   BENCHMARK: ${BENCHMARK:-smoke-test}
 
@@ -35,7 +36,7 @@ setup: |
 run: |
   ergon train local \
     --benchmark "$BENCHMARK" \
-    --definition-id "$DEFINITION_ID" \
+    --experiment-id "$EXPERIMENT_ID" \
     --model "$MODEL" \
     --vllm-mode server \
     --output-dir /checkpoints \
@@ -55,6 +56,7 @@ file_mounts:
 envs:
   BENCHMARK:
   EVALUATOR: ${EVALUATOR:-stub-rubric}
+  EVAL_COMMAND:
 
 setup: |
   git clone https://github.com/DeepFlow-research/ergon.git /tmp/ergon
@@ -68,4 +70,4 @@ run: |
     --benchmark "$BENCHMARK" \
     --evaluator "$EVALUATOR" \
     --poll-interval "${POLL_INTERVAL:-120}" \
-    --on-checkpoint "sky launch ergon_infra/ergon_infra/templates/eval-only.yaml -y --env CHECKPOINT={path} --env BENCHMARK=$BENCHMARK"
+    --on-checkpoint "sky launch ergon_infra/ergon_infra/templates/eval-only.yaml -y --env CHECKPOINT={path} --env BENCHMARK=$BENCHMARK --env EVALUATOR=$EVALUATOR --env EVAL_COMMAND='$EVAL_COMMAND'"
diff --git a/ergon_infra/ergon_infra/training/trl_runner.py b/ergon_infra/ergon_infra/training/trl_runner.py
index 24b18fc6a..562c44ee6 100644
--- a/ergon_infra/ergon_infra/training/trl_runner.py
+++ b/ergon_infra/ergon_infra/training/trl_runner.py
@@ -8,7 +8,7 @@
 
     GPU Node (this process)              Ergon API (MacBook / cloud)
     ───────────────────────              ──────────────────────────
-    TRL GRPOTrainer                      POST /rollouts/submit
+    TRL GRPOTrainer                      POST /rollouts/experiments/{id}/rollout-batches
       → rollout_func() ────HTTP────────►   → Inngest pipeline
       ← trajectories   ◄──HTTP────────    → workers call vLLM
       → forward/backward (GPU)            → eval + score
diff --git a/tests/e2e/conftest.py b/tests/e2e/conftest.py
index 1bbc9f5e2..93ddcd8bc 100644
--- a/tests/e2e/conftest.py
+++ b/tests/e2e/conftest.py
@@ -5,19 +5,12 @@
 """
 
 import os
-import re
 import socket
-import subprocess
 from urllib.parse import urlparse
 
 import pytest
 from ergon_core.core.shared.settings import settings
 
-_UUID_RE = re.compile(
-    r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}",
-    re.IGNORECASE,
-)
-
 # NOTE: smoke fixture registration now lives exclusively inside the local API
 # composition target.
 # Host-side pytest is a black-box client (``_submit.py`` → HTTP) and
@@ -73,106 +66,3 @@ def _require_infra():
         "",
     ]
     pytest.fail("\n".join(lines))
-
-
-def run_benchmark(
-    slug: str,
-    *,
-    worker: str,
-    evaluator: str,
-    sandbox: str,
-    extras: str = "none",
-    model: str = "stub:constant",
-    limit: int = 1,
-    experiment: str = "ci",
-    timeout: int = 120,
-) -> subprocess.CompletedProcess:
-    """Define and run an experiment via the ergon CLI."""
-    define_cmd = [
-        "ergon",
-        "experiment",
-        "define",
-        slug,
-        "--worker",
-        worker,
-        "--model",
-        model,
-        "--evaluator",
-        evaluator,
-        "--sandbox",
-        sandbox,
-        "--extras",
-        extras,
-        "--limit",
-        str(limit),
-        "--experiment",
-        experiment,
-    ]
-    env = {**os.environ, "PYTHONUNBUFFERED": "1"}
-    define = subprocess.run(
-        define_cmd,
-        capture_output=True,
-        text=True,
-        env=env,
-        timeout=timeout + 30,
-    )
-    if define.returncode != 0:
-        return define
-
-    definition_id = _parse_uuid_line("EXPERIMENT_ID=", define.stdout + define.stderr)
-    return subprocess.run(
-        ["ergon", "experiment", "run", definition_id, "--timeout", str(timeout)],
-        capture_output=True,
-        text=True,
-        env=env,
-        timeout=timeout + 30,
-    )
-
-
-def _parse_uuid_line(prefix: str, output: str) -> str:
-    for line in output.splitlines():
-        if not line.startswith(prefix):
-            continue
-        match = _UUID_RE.search(line)
-        if match is not None:
-            return match.group(0)
-    raise AssertionError(f"missing {prefix} line in CLI output:\n{output}")
-
-
-@pytest.fixture(scope="session")
-def benchmarked():
-    """Memoize `run_benchmark` calls by explicit runtime configuration.
-
-    The stubbed E2E tests each assert against the *latest* SampleRecord; re-running
-    the same benchmark per-test burned ~4× subprocess launches with identical
-    outcomes. This fixture runs each unique config exactly once per session and
-    returns the cached `CompletedProcess`.
-    """
-    cache: dict[tuple[str, str, str, str, str, str], subprocess.CompletedProcess] = {}
-
-    def _run(
-        slug: str,
-        *,
-        worker: str,
-        evaluator: str,
-        sandbox: str,
-        extras: str = "none",
-        limit: int = 1,
-        experiment: str = "ci",
-        timeout: int = 120,
-    ) -> subprocess.CompletedProcess:
-        key = (slug, worker, evaluator, sandbox, extras, experiment)
-        if key not in cache:
-            cache[key] = run_benchmark(
-                slug,
-                worker=worker,
-                evaluator=evaluator,
-                sandbox=sandbox,
-                extras=extras,
-                limit=limit,
-                experiment=experiment,
-                timeout=timeout,
-            )
-        return cache[key]
-
-    return _run

From b4401546aaa6810cc78922a8c6095bfe92e2f8c2 Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Wed, 27 May 2026 14:59:40 +0100
Subject: [PATCH 07/15] Fix experiment ref identity in trainer candidate pool

---
 .../ergon_core/core/application/experiments/candidate_pool.py   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ergon_core/ergon_core/core/application/experiments/candidate_pool.py b/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
index aa6239139..60833a3ba 100644
--- a/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
+++ b/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
@@ -140,7 +140,7 @@ def reserve_sample_pool_entries_for_sampler(
     invocation = record_sampler_invocation(
         session=session,
         experiment_ref=ExperimentRef(
-            id=experiment.id,
+            experiment_id=experiment.id,
             name=experiment.name,
             environment_ids={},
             created_at=experiment.created_at,

From b6a180e04dd694930afefb67d7676d1f5ffc2eda Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Wed, 27 May 2026 15:43:20 +0100
Subject: [PATCH 08/15] Preserve experiment identity on trainer rollout batches

---
 ergon_core/ergon_core/core/rl/rollout_service.py              | 1 +
 ergon_core/ergon_core/core/rl/rollout_types.py                | 2 ++
 ergon_core/tests/unit/rest_api/test_rollouts_di.py            | 4 ++--
 .../tests/unit/rl/test_rollout_experiment_submission.py       | 2 ++
 4 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/ergon_core/ergon_core/core/rl/rollout_service.py b/ergon_core/ergon_core/core/rl/rollout_service.py
index 0ead10e2e..65cc70653 100644
--- a/ergon_core/ergon_core/core/rl/rollout_service.py
+++ b/ergon_core/ergon_core/core/rl/rollout_service.py
@@ -159,6 +159,7 @@ async def submit_experiment_batch(
             summary = self.create_rollout_batch(
                 session,
                 sample_ids=sample_ids,
+                experiment_id=request.experiment_id,
                 sampler_invocation_id=invocation.id,
             )
             session.commit()
diff --git a/ergon_core/ergon_core/core/rl/rollout_types.py b/ergon_core/ergon_core/core/rl/rollout_types.py
index 95bea5036..9593b78d2 100644
--- a/ergon_core/ergon_core/core/rl/rollout_types.py
+++ b/ergon_core/ergon_core/core/rl/rollout_types.py
@@ -30,6 +30,8 @@ class TrainingRolloutRequest(BaseModel):
 class RolloutBatchSummary(BaseModel):
     """Durable trainer batch membership exposed by sample id."""
 
+    model_config = ConfigDict(alias_generator=_to_camel, populate_by_name=True)
+
     batch_id: UUID
     sample_ids: list[UUID]
     status: BatchStatus
diff --git a/ergon_core/tests/unit/rest_api/test_rollouts_di.py b/ergon_core/tests/unit/rest_api/test_rollouts_di.py
index 89bd199f2..f8c653c74 100644
--- a/ergon_core/tests/unit/rest_api/test_rollouts_di.py
+++ b/ergon_core/tests/unit/rest_api/test_rollouts_di.py
@@ -65,8 +65,8 @@ def test_rollout_batch_route_exposes_sample_ids() -> None:
 
     assert resp.status_code == 200
     body = resp.json()
-    assert body["sample_ids"] == [str(app.state.rollout_service.sample_id)]
-    assert "run_ids" not in body
+    assert body["sampleIds"] == [str(app.state.rollout_service.sample_id)]
+    assert "runIds" not in body
 
 
 def test_sync_weights_gets_vllm_manager_from_app_state() -> None:
diff --git a/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py b/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py
index c090dfecf..90efa095f 100644
--- a/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py
+++ b/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py
@@ -16,6 +16,7 @@ async def submit_experiment_batch(self, request):
             batch_id=uuid4(),
             sample_ids=[uuid4()],
             status=BatchStatus.PENDING,
+            experiment_id=request.experiment_id,
             sampler_invocation_id=uuid4(),
         )
 
@@ -40,6 +41,7 @@ def test_experiment_rollout_route_accepts_camel_case_training_request() -> None:
     )
 
     assert response.status_code == 202
+    assert response.json()["experimentId"] == str(experiment_id)
     assert service.request.experiment_id == experiment_id
     assert service.request.k == 32
     assert service.request.sampler == "random"

From 2a1bb44f4e3f3aea869bcbe0360d449d1a63c9b7 Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Wed, 27 May 2026 23:15:00 +0100
Subject: [PATCH 09/15] stabilize sample runtime stack

---
 .../scripts/generate-event-contracts.mjs      |   9 -
 .../app/samples/[sampleId]/detail/page.tsx    |  21 -
 .../src/app/samples/[sampleId]/page.tsx       |  13 +-
 ergon-dashboard/src/app/samples/page.tsx      |  22 +-
 .../components/experiments/SampleTable.tsx    |   2 +-
 .../sampleRunMetricExplorerModel.test.ts      |   4 +-
 .../components/indexes/SampleIndexTable.tsx   |  13 +-
 .../components/sample/SampleWorkspacePage.tsx |  10 +-
 .../sample/replayNavigation.test.ts           |   4 +-
 .../src/components/sample/replayNavigation.ts |   4 +-
 .../sample/useSampleDisplayState.ts           |  10 +-
 .../sample/useSampleKeyboardShortcuts.ts      |   4 +-
 .../activity/buildSampleActivities.test.ts    |   8 +-
 .../activity/buildSampleActivities.ts         |   6 +-
 .../components/ActivityStackTimeline.tsx      |   4 +-
 .../features/activity/goldenFixture.test.ts   |   4 +-
 .../activity/snapshotSequence.test.ts         |   4 +-
 .../src/features/activity/snapshotSequence.ts |   6 +-
 .../src/features/evaluation/selectors.test.ts |   2 +-
 .../graph/components/MutationTimeline.tsx     |   4 +-
 .../graph/contracts/graphMutations.test.ts    |  18 +-
 .../graph/contracts/graphMutations.ts         |  12 +-
 .../features/graph/hooks/useGraphMutations.ts |   6 +-
 .../graph/layout/goldenLayout.test.ts         |   4 +-
 .../graph/state/graphMutationReducer.ts       |  22 +-
 .../events/DashboardWorkflowStartedEvent.ts   |   2 +-
 .../DashboardWorkflowStartedEvent.schema.json |  18 -
 .../src/generated/rest/contracts.ts           |  46 +-
 .../src/generated/rest/openapi.json           |  82 ++--
 .../src/hooks/useSampleWorkspaceState.ts      |   8 +-
 .../src/inngest/functions/index.ts            |  10 +-
 ergon-dashboard/src/lib/contracts/events.ts   | 128 +++++-
 .../src/lib/sample-state/hydrate.ts           |   2 +-
 .../src/lib/server-data/samples.ts            |  10 +-
 ergon-dashboard/src/lib/socket/server.ts      |   6 +-
 ergon-dashboard/src/lib/state/store.ts        |   6 +-
 .../src/lib/testing/dashboardHarness.ts       |   4 +-
 ergon-dashboard/src/lib/types.ts              |  16 +-
 .../tests/components/ExperimentDetail.test.ts |   2 +-
 .../tests/contracts/contracts.test.ts         | 133 +++++-
 .../frontend-regressions.contract.test.ts     |   6 +-
 .../contracts/server-data.contract.test.ts    |   9 +-
 ergon-dashboard/tests/e2e/_shared/smoke.ts    |  14 +-
 .../mas-samples/concurrent-mas-run.json       |   2 +-
 .../tests/helpers/backendHarnessClient.ts     |  14 +-
 .../tests/helpers/dashboardFixtures.ts        |  12 +-
 .../tests/helpers/testHarnessClient.ts        |  16 +-
 .../benchmarks/gdpeval/benchmark.py           |   6 +-
 .../benchmarks/minif2f/benchmark.py           |   3 +-
 .../benchmarks/researchrubrics/benchmark.py   |   6 +-
 .../benchmarks/swebench_verified/benchmark.py |   6 +-
 .../toolkits/subagents/toolkit.py             |   7 +-
 ergon_builtins/tests/fixtures/toy_workflow.py |  10 +-
 .../tools/test_subtask_lifecycle_toolkit.py   |   8 +-
 .../tools/test_workflow_command_adapter.py    |   4 +-
 .../unit/state/test_benchmark_contract.py     |  39 +-
 .../workers/test_react_worker_contract.py     |   1 -
 ergon_core/ergon_core/api/__init__.py         |   2 -
 .../ergon_core/api/benchmark/__init__.py      |   3 +-
 .../ergon_core/api/benchmark/requirements.py  |  11 -
 ergon_core/ergon_core/api/worker/context.py   |  11 -
 .../core/application/evaluation/service.py    |  57 +--
 .../core/application/events/runtime.py        |   8 -
 .../core/application/experiments/__init__.py  |  10 +-
 .../experiments/definition_writer.py          | 247 -----------
 .../core/application/experiments/errors.py    |  34 +-
 .../core/application/experiments/handles.py   |   5 -
 .../core/application/experiments/launch.py    |  70 ---
 .../core/application/experiments/models.py    |  31 --
 .../core/application/experiments/service.py   |  79 +---
 .../core/application/runtime/events.py        |   6 +-
 .../application/runtime/graph_repository.py   | 190 --------
 .../core/application/runtime/lifecycle.py     |  25 +-
 .../core/application/runtime/models.py        |   2 -
 .../core/application/runtime/orchestration.py |   8 -
 .../application/runtime/sample_identity.py    |  17 -
 .../application/runtime/sample_lifecycle.py   | 112 +----
 .../application/runtime/sample_records.py     |  53 ---
 .../core/application/runtime/task_errors.py   |   6 +-
 .../application/runtime/task_execution.py     |  74 +---
 .../application/runtime/task_management.py    |  30 +-
 .../application/samples/materialization.py    |   5 +-
 .../application/testing/suppression_budget.py |  11 +-
 .../testing/test_harness_service.py           |  82 ++--
 .../infrastructure/http/routes/samples.py     |   2 -
 .../http/routes/test_harness.py               | 138 +++---
 .../resources/persist_outputs/contract.py     |   1 -
 .../core/jobs/sandbox/setup/contract.py       |   1 -
 .../core/jobs/task/cancel_orphans/job.py      |   3 -
 .../ergon_core/core/jobs/task/evaluate/job.py |  22 +-
 .../ergon_core/core/jobs/task/execute/job.py  |   8 -
 .../core/jobs/task/propagate/job.py           |   6 -
 .../core/jobs/task/worker_execute/contract.py |   1 -
 .../core/jobs/task/worker_execute/job.py      |   8 +-
 .../core/jobs/workflow/complete/job.py        |   3 -
 .../ergon_core/core/jobs/workflow/fail/job.py |   2 -
 .../core/jobs/workflow/start/job.py           |  34 +-
 .../core/persistence/definitions/__init__.py  |   0
 .../core/persistence/definitions/models.py    | 280 ------------
 .../core/persistence/graph/models.py          |  17 +-
 .../core/persistence/shared/types.py          |   1 -
 .../core/persistence/telemetry/models.py      |  39 +-
 .../core/views/dashboard_events/contracts.py  |   7 +-
 .../core/views/experiments/models.py          | 121 +-----
 .../core/views/experiments/service.py         | 411 +-----------------
 .../ergon_core/core/views/samples/models.py   |   8 +-
 .../ergon_core/core/views/samples/service.py  |  53 +--
 .../ergon_core/core/views/samples/snapshot.py |  18 +-
 ergon_core/migrations/env.py                  |   1 -
 .../versions/00000000_initial_v2.py           |   9 -
 ...000002_add_sample_experiment_provenance.py |  12 -
 ...00003_delete_definition_runtime_columns.py | 276 ++++++++++++
 .../test_experiment_persistence_roundtrip.py  |   2 +-
 .../test_public_experiment_submit_smoke.py    |   1 -
 .../test_submit_starts_materialized_sample.py |  34 +-
 .../api/worker/test_worker_context_facade.py  |  14 -
 .../architecture/test_core_schema_sources.py  |  47 +-
 .../test_model_field_descriptions.py          |   6 +-
 .../test_no_deleted_v2_symbols.py             |  38 ++
 .../test_persistence_boundaries.py            |   6 +-
 .../test_public_api_boundaries.py             |   6 +-
 .../test_public_api_target_structure.py       |   2 -
 .../test_runtime_application_ownership.py     |   1 -
 .../architecture/test_single_alembic_head.py  |   3 +-
 .../test_inline_evaluator_persistence.py      |  92 +---
 .../experiments/test_candidate_pool.py        |   1 -
 ...est_definition_writer_inline_evaluators.py | 107 -----
 .../test_experiment_persistence.py            |   1 -
 .../experiments/test_experiment_submit.py     |   1 -
 .../test_sample_materialization.py            |   3 +-
 .../test_execute_task_object_bound_fanout.py  |  11 +-
 .../test_persist_outputs_public_sandbox.py    |   1 -
 .../jobs/test_sandbox_setup_public_sandbox.py |   1 -
 ...test_worker_execute_live_sandbox_attach.py |   7 +-
 .../tasks/test_spawn_dynamic_task_dispatch.py |  19 +-
 .../evaluation/test_evaluation_dto_mapping.py |   2 +-
 .../evaluation/test_evaluation_persistence.py |  43 +-
 .../test_context_event_repository.py          |  13 -
 .../test_experiment_read_service.py           | 385 ++--------------
 .../read_models/test_sample_read_service.py   |  48 +-
 .../unit/rest_api/test_samples_routes.py      |  15 +-
 .../rest_api/test_samples_routes_existing.py  |  14 +-
 .../tests/unit/rest_api/test_test_harness.py  | 124 +++++-
 .../test_rollout_batch_sample_memberships.py  |  22 +-
 .../rl/test_rollout_experiment_submission.py  |   4 +-
 .../runtime/test_child_function_payloads.py   |  10 +-
 .../runtime/test_cleanup_cancelled_task.py    |   1 -
 ...st_definition_repository_and_latest_run.py | 134 ------
 .../test_definition_task_payload_typing.py    |  25 --
 .../test_dynamic_task_evaluation_mapping.py   |   2 +-
 .../test_execute_task_evaluator_fanout.py     |   9 +-
 .../test_experiment_definition_service.py     |  57 ---
 .../runtime/test_experiment_launch_service.py | 152 -------
 .../unit/runtime/test_experiment_schemas.py   |  14 -
 .../test_failed_task_sandbox_cleanup.py       |   2 -
 .../runtime/test_graph_mutation_contracts.py  |   5 +-
 .../runtime/test_graph_worker_identity.py     | 144 ++----
 .../unit/runtime/test_identity_invariants.py  | 158 +++----
 .../unit/runtime/test_persist_outputs.py      |   1 -
 .../runtime/test_persist_outputs_resources.py |   1 -
 .../runtime/test_propagation_contracts.py     |   2 -
 .../runtime/test_sample_annotation_events.py  |   3 +-
 .../test_sample_graph_task_snapshot.py        | 143 ++----
 .../test_sample_record_missing_error.py       |  18 +-
 .../runtime/test_sample_record_service.py     |  60 ---
 .../tests/unit/runtime/test_sample_service.py |  60 ---
 .../unit/runtime/test_sample_state_replay.py  |   3 +-
 .../unit/runtime/test_sandbox_cleanup.py      |   3 -
 .../unit/runtime/test_spawn_dynamic_task.py   |  16 +-
 .../runtime/test_task_execution_repository.py |   1 -
 .../unit/runtime/test_typed_sample_wal.py     |   3 +-
 .../runtime/test_walkthrough_smoketest.py     | 170 ++------
 .../test_worker_context_containment.py        |  18 +-
 .../unit/runtime/test_workflow_service.py     |   4 -
 .../unit/state/test_event_schema_phase0.py    |   8 +-
 .../tests/unit/state/test_type_invariants.py  |  25 +-
 .../ergon_ingestion/exports/sharded.py        |   2 +-
 .../writers/external_run_writer.py            |  60 +--
 .../tests/unit/test_external_run_writer.py    |   9 +-
 .../tests/unit/test_sharded_export.py         |   2 +-
 tests/e2e/_asserts.py                         |   4 +-
 tests/e2e/_submit.py                          |   8 +-
 tests/e2e/test_minif2f_smoke.py               |  20 +-
 tests/e2e/test_researchrubrics_smoke.py       |  20 +-
 tests/e2e/test_swebench_smoke.py              |  20 +-
 tests/fixtures/smoke_components/benchmarks.py |   2 -
 tests/integration/propagation/_helpers.py     |  14 +-
 .../propagation/test_propagation_blocked.py   |  35 +-
 .../propagation/test_propagation_cancel.py    |  19 +-
 .../test_propagation_edge_cases.py            |  22 +-
 .../propagation/test_propagation_happy.py     |  14 +-
 .../propagation/test_propagation_restart.py   |  13 +-
 tests/integration/restart/_helpers.py         |   6 +-
 .../restart/test_downstream_invalidation.py   |  26 +-
 .../restart/test_manager_dag_scenario.py      |   8 +-
 .../integration/restart/test_reactivation.py  |  24 +-
 .../integration/restart/test_restart_task.py  |  44 +-
 .../integration/smokes/test_smoke_harness.py  |  41 +-
 .../integration/swebench_verified/conftest.py | 121 ------
 199 files changed, 1662 insertions(+), 4721 deletions(-)
 delete mode 100644 ergon-dashboard/src/app/samples/[sampleId]/detail/page.tsx
 delete mode 100644 ergon_core/ergon_core/api/benchmark/requirements.py
 delete mode 100644 ergon_core/ergon_core/core/application/experiments/definition_writer.py
 delete mode 100644 ergon_core/ergon_core/core/application/experiments/handles.py
 delete mode 100644 ergon_core/ergon_core/core/application/experiments/launch.py
 delete mode 100644 ergon_core/ergon_core/core/application/runtime/sample_identity.py
 delete mode 100644 ergon_core/ergon_core/core/persistence/definitions/__init__.py
 delete mode 100644 ergon_core/ergon_core/core/persistence/definitions/models.py
 create mode 100644 ergon_core/migrations/versions/00000003_delete_definition_runtime_columns.py
 delete mode 100644 ergon_core/tests/unit/core/application/experiments/test_definition_writer_inline_evaluators.py
 delete mode 100644 ergon_core/tests/unit/runtime/test_definition_repository_and_latest_run.py
 delete mode 100644 ergon_core/tests/unit/runtime/test_definition_task_payload_typing.py
 delete mode 100644 ergon_core/tests/unit/runtime/test_experiment_definition_service.py
 delete mode 100644 ergon_core/tests/unit/runtime/test_experiment_launch_service.py
 delete mode 100644 ergon_core/tests/unit/runtime/test_experiment_schemas.py
 delete mode 100644 ergon_core/tests/unit/runtime/test_sample_record_service.py
 delete mode 100644 ergon_core/tests/unit/runtime/test_sample_service.py
 delete mode 100644 tests/integration/swebench_verified/conftest.py

diff --git a/ergon-dashboard/scripts/generate-event-contracts.mjs b/ergon-dashboard/scripts/generate-event-contracts.mjs
index 607f4fa4c..ec32502c0 100644
--- a/ergon-dashboard/scripts/generate-event-contracts.mjs
+++ b/ergon-dashboard/scripts/generate-event-contracts.mjs
@@ -41,15 +41,6 @@ function patchZod4Compat(source) {
 }
 
 function customEventContractSource(entry) {
-  if (entry.modelName === "DashboardGraphMutationEvent") {
-    return `import { z } from "zod";
-import { GraphMutationDtoSchema } from "@/features/graph/contracts/graphMutations";
-
-export const DashboardGraphMutationEventSchema = z.object({
-  mutation: GraphMutationDtoSchema,
-}).catchall(z.any());
-`;
-  }
   if (entry.modelName === "DashboardSampleRuntimeEvent") {
     return `import { z } from "zod";
 import { SampleRuntimeEventViewSchema } from "@/lib/contracts/rest";
diff --git a/ergon-dashboard/src/app/samples/[sampleId]/detail/page.tsx b/ergon-dashboard/src/app/samples/[sampleId]/detail/page.tsx
deleted file mode 100644
index 13ca16277..000000000
--- a/ergon-dashboard/src/app/samples/[sampleId]/detail/page.tsx
+++ /dev/null
@@ -1,21 +0,0 @@
-import { notFound } from "next/navigation";
-
-import { SampleDetail } from "@/components/samples/SampleDetail";
-import { loadSampleState } from "@/lib/server-data/samples";
-
-interface SampleDetailPageProps {
-  params: Promise<{
-    sampleId: string;
-  }>;
-}
-
-export default async function SampleDetailPage({ params }: SampleDetailPageProps) {
-  const { sampleId } = await params;
-  const result = await loadSampleState(sampleId);
-  if (!result.ok) {
-    if (result.status === 404) notFound();
-    throw new Error(`Failed to load sample ${sampleId}: ${result.status}`);
-  }
-
-  return <SampleDetail state={result.data} />;
-}
diff --git a/ergon-dashboard/src/app/samples/[sampleId]/page.tsx b/ergon-dashboard/src/app/samples/[sampleId]/page.tsx
index 0b5e79c52..96769d641 100644
--- a/ergon-dashboard/src/app/samples/[sampleId]/page.tsx
+++ b/ergon-dashboard/src/app/samples/[sampleId]/page.tsx
@@ -1,4 +1,7 @@
-import { redirect } from "next/navigation";
+import { notFound } from "next/navigation";
+
+import { SampleWorkspacePage } from "@/components/sample/SampleWorkspacePage";
+import { loadSampleSnapshot } from "@/lib/server-data/samples";
 
 interface SamplePageProps {
   params: Promise<{
@@ -8,5 +11,11 @@ interface SamplePageProps {
 
 export default async function SamplePage({ params }: SamplePageProps) {
   const { sampleId } = await params;
-  redirect(`/samples/${sampleId}/detail`);
+  const result = await loadSampleSnapshot(sampleId);
+  if (!result.ok) {
+    if (result.status === 404) notFound();
+    return <SampleWorkspacePage sampleId={sampleId} ssrError={`API returned ${result.status}`} />;
+  }
+
+  return <SampleWorkspacePage sampleId={sampleId} initialRunState={result.data} />;
 }
diff --git a/ergon-dashboard/src/app/samples/page.tsx b/ergon-dashboard/src/app/samples/page.tsx
index 42d8ce6ca..fac9d73f0 100644
--- a/ergon-dashboard/src/app/samples/page.tsx
+++ b/ergon-dashboard/src/app/samples/page.tsx
@@ -1,29 +1,33 @@
 import { SampleIndexTable } from "@/components/indexes/SampleIndexTable";
 import { loadSampleList, type SampleSummary } from "@/lib/server-data/samples";
 
-export default async function RunsPage() {
-  let runs: SampleSummary[] = [];
+export default async function SamplesPage() {
+  let samples: SampleSummary[] = [];
   let error: string | null = null;
 
   const result = await loadSampleList({ limit: 100 });
   if (result.ok) {
-    runs = result.data;
+    samples = result.data;
   } else {
     const detail = (result.body as { detail?: string })?.detail;
     error = detail ?? `API returned ${result.status}`;
   }
 
-  const runningCount = runs.filter((run) => ["executing", "evaluating"].includes(run.status)).length;
-  const failedCount = runs.filter((run) => run.status === "failed" || run.failed_tasks > 0).length;
-  const completedCount = runs.filter((run) => run.status === "completed").length;
+  const runningCount = samples.filter((sample) =>
+    ["executing", "evaluating"].includes(sample.status),
+  ).length;
+  const failedCount = samples.filter(
+    (sample) => sample.status === "failed" || sample.failed_tasks > 0,
+  ).length;
+  const completedCount = samples.filter((sample) => sample.status === "completed").length;
 
   return (
     <main className="mx-auto w-full max-w-7xl px-6 py-8">
       <div className="mb-5">
         <p className="text-xs font-semibold uppercase tracking-[0.12em] text-[var(--faint)]">
-          Run Index
+          Sample Index
         </p>
-        <h1 className="mt-2 text-3xl font-semibold text-[var(--ink)]">Runs</h1>
+        <h1 className="mt-2 text-3xl font-semibold text-[var(--ink)]">Samples</h1>
       </div>
 
       {error ? (
@@ -47,7 +51,7 @@ export default async function RunsPage() {
         </div>
       </div>
 
-      <SampleIndexTable runs={runs} />
+      <SampleIndexTable runs={samples} />
     </main>
   );
 }
diff --git a/ergon-dashboard/src/components/experiments/SampleTable.tsx b/ergon-dashboard/src/components/experiments/SampleTable.tsx
index fb0ca5ad2..b72c6fb79 100644
--- a/ergon-dashboard/src/components/experiments/SampleTable.tsx
+++ b/ergon-dashboard/src/components/experiments/SampleTable.tsx
@@ -26,7 +26,7 @@ export function SampleTable({ samples }: { samples: ExperimentSampleSummaryView[
             >
               <td>
                 <Link
-                  href={`/samples/${sample.sampleId}/detail`}
+                  href={`/samples/${sample.sampleId}`}
                   className="block px-3 py-2 font-mono text-xs text-[var(--ink)] underline-offset-2 group-hover:underline"
                 >
                   {sample.sampleKey}
diff --git a/ergon-dashboard/src/components/experiments/sampleRunMetricExplorerModel.test.ts b/ergon-dashboard/src/components/experiments/sampleRunMetricExplorerModel.test.ts
index 4837b3f5f..1d7685e95 100644
--- a/ergon-dashboard/src/components/experiments/sampleRunMetricExplorerModel.test.ts
+++ b/ergon-dashboard/src/components/experiments/sampleRunMetricExplorerModel.test.ts
@@ -11,7 +11,7 @@ import {
   type RunMetricPoint,
 } from "./sampleRunMetricExplorerModel";
 
-const definitionId = "11111111-1111-4111-8111-111111111111";
+const experimentId = "11111111-1111-4111-8111-111111111111";
 const defaultSampleId = "22222222-2222-4222-8222-222222222222";
 
 function metrics(overrides: Partial<ExperimentRunRow["metrics"]> = {}): ExperimentRunRow["metrics"] {
@@ -28,7 +28,7 @@ function metrics(overrides: Partial<ExperimentRunRow["metrics"]> = {}): Experime
 function runRow(overrides: Partial<ExperimentRunRow> = {}): ExperimentRunRow {
   return {
     sample_id: defaultSampleId,
-    definition_id: definitionId,
+    experiment_id: experimentId,
     benchmark_type: "minif2f",
     instance_key: "sample-a",
     status: "completed",
diff --git a/ergon-dashboard/src/components/indexes/SampleIndexTable.tsx b/ergon-dashboard/src/components/indexes/SampleIndexTable.tsx
index ecd1fabe4..7d2ade3a1 100644
--- a/ergon-dashboard/src/components/indexes/SampleIndexTable.tsx
+++ b/ergon-dashboard/src/components/indexes/SampleIndexTable.tsx
@@ -23,7 +23,6 @@ export function SampleIndexTable({ runs }: { runs: SampleSummary[] }) {
       const matchesStatus = status === "all" || run.status === status;
       const text = [
         run.name,
-        run.definition_name,
         run.experiment,
         run.benchmark_type,
         run.instance_key,
@@ -45,7 +44,7 @@ export function SampleIndexTable({ runs }: { runs: SampleSummary[] }) {
         <input
           value={query}
           onChange={(event) => setQuery(event.target.value)}
-          placeholder="Search runs"
+          placeholder="Search samples"
           className="h-9 w-full max-w-sm rounded-md border border-[var(--line)] bg-[var(--card)] px-3 text-sm text-[var(--ink)] outline-none focus:border-[var(--ink-2)]"
         />
         <select
@@ -67,7 +66,7 @@ export function SampleIndexTable({ runs }: { runs: SampleSummary[] }) {
         <table className="w-full min-w-[1180px] text-left text-[13px]">
           <thead className="border-b border-[var(--line)] bg-[var(--paper-2)] text-[11px] uppercase tracking-[0.08em] text-[var(--faint)]">
             <tr>
-              <th className="px-3 py-2 font-semibold">Run</th>
+              <th className="px-3 py-2 font-semibold">Sample</th>
               <th className="px-3 py-2 font-semibold">Experiment</th>
               <th className="px-3 py-2 font-semibold">Benchmark / Sample</th>
               <th className="px-3 py-2 font-semibold">Status</th>
@@ -96,13 +95,13 @@ export function SampleIndexTable({ runs }: { runs: SampleSummary[] }) {
                 </td>
                 <td className="px-3 py-2.5">
                   <Link
-                    href={`/experiments/${run.definition_id}`}
+                    href={run.experiment_id ? `/experiments/${run.experiment_id}` : "/experiments"}
                     className="text-[var(--ink-2)] underline-offset-2 hover:underline"
                   >
-                    {run.definition_name ?? run.experiment ?? "Experiment"}
+                    {run.experiment ?? "Experiment"}
                   </Link>
                   <div className="mt-0.5 text-xs text-[var(--faint)]">
-                    {run.experiment ?? run.definition_id}
+                    {run.experiment_id ?? "-"}
                   </div>
                 </td>
                 <td className="px-3 py-2.5 font-mono text-xs text-[var(--ink-2)]">
@@ -144,7 +143,7 @@ export function SampleIndexTable({ runs }: { runs: SampleSummary[] }) {
             {filtered.length === 0 ? (
               <tr>
                 <td colSpan={10} className="px-3 py-8 text-center text-sm text-[var(--muted)]">
-                  No runs match the current filters.
+                  No samples match the current filters.
                 </td>
               </tr>
             ) : null}
diff --git a/ergon-dashboard/src/components/sample/SampleWorkspacePage.tsx b/ergon-dashboard/src/components/sample/SampleWorkspacePage.tsx
index a74f379d0..cfb59eb92 100644
--- a/ergon-dashboard/src/components/sample/SampleWorkspacePage.tsx
+++ b/ergon-dashboard/src/components/sample/SampleWorkspacePage.tsx
@@ -14,7 +14,7 @@ import { ActivityStackTimeline } from "@/features/activity/components/ActivitySt
 import { buildSampleActivities } from "@/features/activity/buildSampleActivities";
 import { resolveActivitySnapshotSequence } from "@/features/activity/snapshotSequence";
 import type { SampleActivity } from "@/features/activity/types";
-import type { GraphMutationDto, MutationType } from "@/features/graph/contracts/graphMutations";
+import type { SampleGraphEventDto, MutationType } from "@/features/graph/contracts/graphMutations";
 import { useSampleWorkspaceState } from "@/hooks/useSampleWorkspaceState";
 import { buildSampleEvents } from "@/lib/sampleEvents";
 import { parseSampleRuntimeEvents, type SampleRuntimeEventView } from "@/lib/contracts/rest";
@@ -126,7 +126,7 @@ function graphMutationValue(event: SampleRuntimeEventView, mutationType: Mutatio
   return payload;
 }
 
-function sampleRuntimeEventsToGraphMutations(events: SampleRuntimeEventView[]): GraphMutationDto[] {
+function sampleRuntimeEventsToGraphEvents(events: SampleRuntimeEventView[]): SampleGraphEventDto[] {
   return events.flatMap((event, index) => {
     const mutationType = graphMutationType(event.eventType);
     const targetId = event.targetId;
@@ -176,7 +176,7 @@ export function SampleWorkspacePage({
 
   const [runtimeEvents, setRuntimeEvents] = useState<SampleRuntimeEventView[]>([]);
   const mutations = useMemo(
-    () => sampleRuntimeEventsToGraphMutations(runtimeEvents),
+    () => sampleRuntimeEventsToGraphEvents(runtimeEvents),
     [runtimeEvents],
   );
   const requestedSequenceRef = useRef<number | null>(null);
@@ -208,7 +208,7 @@ export function SampleWorkspacePage({
       .then((data) => {
         if (cancelled) return;
         const events = parseSampleRuntimeEvents(data);
-        const parsed = sampleRuntimeEventsToGraphMutations(events);
+        const parsed = sampleRuntimeEventsToGraphEvents(events);
         mutationsLoadedRef.current = true;
         setRuntimeEvents(events);
         const requestedSequence = requestedSequenceRef.current;
@@ -340,7 +340,7 @@ export function SampleWorkspacePage({
   }, [displayState, selectedTaskId]);
 
   const status = runState?.status ?? "pending";
-  const experimentHref = runState?.definitionId ? `/experiments/${runState.definitionId}` : "/experiments";
+  const experimentHref = runState?.experimentId ? `/experiments/${runState.experimentId}` : "/experiments";
   const isInspectorOpen = selectedTaskId !== null;
 
   const handleTaskClick = (taskId: string) => {
diff --git a/ergon-dashboard/src/components/sample/replayNavigation.test.ts b/ergon-dashboard/src/components/sample/replayNavigation.test.ts
index c8bf4912d..557c35c25 100644
--- a/ergon-dashboard/src/components/sample/replayNavigation.test.ts
+++ b/ergon-dashboard/src/components/sample/replayNavigation.test.ts
@@ -1,10 +1,10 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import type { GraphMutationDto } from "@/features/graph/contracts/graphMutations";
+import type { SampleGraphEventDto } from "@/features/graph/contracts/graphMutations";
 import { resolveReplayStep } from "./replayNavigation";
 
-function mutation(sequence: number, id = `mutation-${sequence}`): GraphMutationDto {
+function mutation(sequence: number, id = `mutation-${sequence}`): SampleGraphEventDto {
   return {
     id,
     sample_id: "run-1",
diff --git a/ergon-dashboard/src/components/sample/replayNavigation.ts b/ergon-dashboard/src/components/sample/replayNavigation.ts
index 664fd8525..fd59d05a1 100644
--- a/ergon-dashboard/src/components/sample/replayNavigation.ts
+++ b/ergon-dashboard/src/components/sample/replayNavigation.ts
@@ -1,9 +1,9 @@
-import type { GraphMutationDto } from "@/features/graph/contracts/graphMutations";
+import type { SampleGraphEventDto } from "@/features/graph/contracts/graphMutations";
 
 export type ReplayDirection = "previous" | "next";
 
 export function resolveReplayStep(
-  mutations: GraphMutationDto[],
+  mutations: SampleGraphEventDto[],
   currentSequence: number | null,
   direction: ReplayDirection,
 ): number | null {
diff --git a/ergon-dashboard/src/components/sample/useSampleDisplayState.ts b/ergon-dashboard/src/components/sample/useSampleDisplayState.ts
index 2b6e6993d..675b50aef 100644
--- a/ergon-dashboard/src/components/sample/useSampleDisplayState.ts
+++ b/ergon-dashboard/src/components/sample/useSampleDisplayState.ts
@@ -2,15 +2,15 @@
 
 import { useMemo, useState } from "react";
 
-import type { GraphMutationDto } from "@/features/graph/contracts/graphMutations";
+import type { SampleGraphEventDto } from "@/features/graph/contracts/graphMutations";
 import { createReplayInitialState, replayToSequence } from "@/features/graph/state/graphMutationReducer";
 import type { SampleWorkspaceState } from "@/lib/types";
 
 export function nearestMutationAtOrBefore(
-  mutations: GraphMutationDto[],
+  mutations: SampleGraphEventDto[],
   sequence: number,
-): GraphMutationDto | null {
-  let selected: GraphMutationDto | null = null;
+): SampleGraphEventDto | null {
+  let selected: SampleGraphEventDto | null = null;
   for (const mutation of mutations) {
     if (mutation.sequence > sequence) break;
     selected = mutation;
@@ -20,7 +20,7 @@ export function nearestMutationAtOrBefore(
 
 export function useSampleDisplayState(
   runState: SampleWorkspaceState | null,
-  mutations: GraphMutationDto[],
+  mutations: SampleGraphEventDto[],
 ) {
   // Activities and trace rows are built from full live run state.
   // Inspector and graph may render replay display state.
diff --git a/ergon-dashboard/src/components/sample/useSampleKeyboardShortcuts.ts b/ergon-dashboard/src/components/sample/useSampleKeyboardShortcuts.ts
index f430cc2d0..91de12559 100644
--- a/ergon-dashboard/src/components/sample/useSampleKeyboardShortcuts.ts
+++ b/ergon-dashboard/src/components/sample/useSampleKeyboardShortcuts.ts
@@ -2,7 +2,7 @@
 
 import { useEffect } from "react";
 
-import type { GraphMutationDto } from "@/features/graph/contracts/graphMutations";
+import type { SampleGraphEventDto } from "@/features/graph/contracts/graphMutations";
 import { TaskStatus } from "@/lib/types";
 import { resolveReplayStep } from "./replayNavigation";
 
@@ -14,7 +14,7 @@ export function useSampleKeyboardShortcuts(options: {
   statusFilter: TaskStatus | null;
   setStatusFilter: (status: TaskStatus | null | ((previous: TaskStatus | null) => TaskStatus | null)) => void;
   toggleEventStream: () => void;
-  mutations: GraphMutationDto[];
+  mutations: SampleGraphEventDto[];
 }) {
   useEffect(() => {
     const statusOrder: TaskStatus[] = [
diff --git a/ergon-dashboard/src/features/activity/buildSampleActivities.test.ts b/ergon-dashboard/src/features/activity/buildSampleActivities.test.ts
index 537d224b2..d24f7b307 100644
--- a/ergon-dashboard/src/features/activity/buildSampleActivities.test.ts
+++ b/ergon-dashboard/src/features/activity/buildSampleActivities.test.ts
@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import fixture from "../../../tests/fixtures/mas-samples/concurrent-mas-run.json";
-import { parseGraphMutationDtoArray } from "@/features/graph/contracts/graphMutations";
+import { parseSampleGraphEventDtoArray } from "@/features/graph/contracts/graphMutations";
 import type { SampleEvent } from "@/lib/sampleEvents";
 import { buildSampleEvents } from "@/lib/sampleEvents";
 import { deserializeSampleState } from "@/lib/sampleState";
@@ -12,7 +12,7 @@ import { resolveActivitySnapshotSequence } from "./snapshotSequence";
 
 test("buildSampleActivities surfaces semantic activity kinds without creating actor lanes", () => {
   const runState = deserializeSampleState(fixture.runState);
-  const mutations = parseGraphMutationDtoArray(fixture.mutations);
+  const mutations = parseSampleGraphEventDtoArray(fixture.mutations);
   const noisyTaskId = "10000000-0000-4000-8000-000000000002";
   runState.sandboxesByTask.set(noisyTaskId, {
     sandboxId: "sandbox-noisy",
@@ -247,7 +247,7 @@ test("buildSampleActivities surfaces semantic activity kinds without creating ac
 
 test("completed trace spans keep full duration when replaying an earlier sequence", () => {
   const runState = deserializeSampleState(fixture.runState);
-  const mutations = parseGraphMutationDtoArray(fixture.mutations);
+  const mutations = parseSampleGraphEventDtoArray(fixture.mutations);
   const events = buildSampleEvents(runState);
 
   const activities = buildSampleActivities({
@@ -276,7 +276,7 @@ test("completed trace spans keep full duration when replaying an earlier sequenc
 
 test("context/tool event sequence does not masquerade as graph replay sequence", () => {
   const runState = deserializeSampleState(fixture.runState);
-  const mutations = parseGraphMutationDtoArray(fixture.mutations);
+  const mutations = parseSampleGraphEventDtoArray(fixture.mutations);
   const activities = buildSampleActivities({
     runState,
     events: buildSampleEvents(runState),
diff --git a/ergon-dashboard/src/features/activity/buildSampleActivities.ts b/ergon-dashboard/src/features/activity/buildSampleActivities.ts
index 6be5e2ba0..c5f628d06 100644
--- a/ergon-dashboard/src/features/activity/buildSampleActivities.ts
+++ b/ergon-dashboard/src/features/activity/buildSampleActivities.ts
@@ -1,4 +1,4 @@
-import type { GraphMutationDto } from "@/features/graph/contracts/graphMutations";
+import type { SampleGraphEventDto } from "@/features/graph/contracts/graphMutations";
 import type {
   ContextEventState,
   ExecutionAttemptState,
@@ -11,7 +11,7 @@ import type { SampleActivity } from "./types";
 export interface BuildSampleActivitiesInput {
   runState: SampleWorkspaceState | null;
   events: SampleEvent[];
-  mutations: GraphMutationDto[];
+  mutations: SampleGraphEventDto[];
   currentSequence: number | null;
 }
 
@@ -302,7 +302,7 @@ function eventMarkerActivities(events: SampleEvent[]): SampleActivity[] {
   });
 }
 
-function graphMutationActivities(mutations: GraphMutationDto[]): SampleActivity[] {
+function graphMutationActivities(mutations: SampleGraphEventDto[]): SampleActivity[] {
   return mutations.map((mutation) => ({
     id: `graph:${mutation.id}`,
     kind: "graph",
diff --git a/ergon-dashboard/src/features/activity/components/ActivityStackTimeline.tsx b/ergon-dashboard/src/features/activity/components/ActivityStackTimeline.tsx
index 0e530cd91..b7275e9f2 100644
--- a/ergon-dashboard/src/features/activity/components/ActivityStackTimeline.tsx
+++ b/ergon-dashboard/src/features/activity/components/ActivityStackTimeline.tsx
@@ -2,7 +2,7 @@
 
 import { useMemo, useState } from "react";
 
-import type { GraphMutationDto } from "@/features/graph/contracts/graphMutations";
+import type { SampleGraphEventDto } from "@/features/graph/contracts/graphMutations";
 import { ACTIVITY_BAND_ORDER, stackActivities } from "@/features/activity/stackLayout";
 import type { ActivityBand, SampleActivity } from "@/features/activity/types";
 import { resolveCurrentActivityId } from "@/features/activity/currentActivity";
@@ -11,7 +11,7 @@ import { ActivityBar, activityKindLegendLabel, activityKindColor } from "./Activ
 
 interface ActivityStackTimelineProps {
   activities: SampleActivity[];
-  mutations: GraphMutationDto[];
+  mutations: SampleGraphEventDto[];
   currentSequence: number | null;
   selectedTaskId: string | null;
   selectedActivityId: string | null;
diff --git a/ergon-dashboard/src/features/activity/goldenFixture.test.ts b/ergon-dashboard/src/features/activity/goldenFixture.test.ts
index 9f81ae1ba..bfde5d205 100644
--- a/ergon-dashboard/src/features/activity/goldenFixture.test.ts
+++ b/ergon-dashboard/src/features/activity/goldenFixture.test.ts
@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import fixture from "../../../tests/fixtures/mas-samples/concurrent-mas-run.json";
-import { parseGraphMutationDtoArray } from "@/features/graph/contracts/graphMutations";
+import { parseSampleGraphEventDtoArray } from "@/features/graph/contracts/graphMutations";
 import { replayToSequence } from "@/features/graph/state/graphMutationReducer";
 import { buildSampleEvents } from "@/lib/sampleEvents";
 import { deserializeSampleState } from "@/lib/sampleState";
@@ -34,7 +34,7 @@ function emptyRunStateFrom(runState: SampleWorkspaceState): SampleWorkspaceState
 
 test("golden concurrent fixture replays the whole graph at selected sequence and stacks overlapping activity", () => {
   const runState = deserializeSampleState(fixture.runState);
-  const mutations = parseGraphMutationDtoArray(fixture.mutations);
+  const mutations = parseSampleGraphEventDtoArray(fixture.mutations);
   const checkpoint = fixture.checkpoints.find((entry) => entry.sequence === 14);
   assert.ok(checkpoint);
 
diff --git a/ergon-dashboard/src/features/activity/snapshotSequence.test.ts b/ergon-dashboard/src/features/activity/snapshotSequence.test.ts
index 416d21172..11884d12b 100644
--- a/ergon-dashboard/src/features/activity/snapshotSequence.test.ts
+++ b/ergon-dashboard/src/features/activity/snapshotSequence.test.ts
@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import type { GraphMutationDto } from "@/features/graph/contracts/graphMutations";
+import type { SampleGraphEventDto } from "@/features/graph/contracts/graphMutations";
 import type { SampleActivity } from "./types";
 import { resolveActivitySnapshotSequence } from "./snapshotSequence";
 
@@ -25,7 +25,7 @@ function activity(overrides: Partial<SampleActivity> = {}): SampleActivity {
   };
 }
 
-function mutation(sequence: number, createdAt: string): GraphMutationDto {
+function mutation(sequence: number, createdAt: string): SampleGraphEventDto {
   return {
     id: "00000000-0000-4000-8000-000000000001",
     sample_id: "00000000-0000-4000-8000-000000000002",
diff --git a/ergon-dashboard/src/features/activity/snapshotSequence.ts b/ergon-dashboard/src/features/activity/snapshotSequence.ts
index 15876619d..21733338c 100644
--- a/ergon-dashboard/src/features/activity/snapshotSequence.ts
+++ b/ergon-dashboard/src/features/activity/snapshotSequence.ts
@@ -1,16 +1,16 @@
-import type { GraphMutationDto } from "@/features/graph/contracts/graphMutations";
+import type { SampleGraphEventDto } from "@/features/graph/contracts/graphMutations";
 import type { SampleActivity } from "./types";
 
 export function resolveActivitySnapshotSequence(
   activity: SampleActivity,
-  mutations: GraphMutationDto[],
+  mutations: SampleGraphEventDto[],
 ): number | null {
   if (activity.sequence !== null) return activity.sequence;
 
   const activityMs = Date.parse(activity.startAt);
   if (!Number.isFinite(activityMs)) return null;
 
-  let selected: GraphMutationDto | null = null;
+  let selected: SampleGraphEventDto | null = null;
   let selectedMs = Number.NEGATIVE_INFINITY;
   for (const mutation of mutations) {
     const mutationMs = Date.parse(mutation.created_at);
diff --git a/ergon-dashboard/src/features/evaluation/selectors.test.ts b/ergon-dashboard/src/features/evaluation/selectors.test.ts
index 0aee8dbed..1af687d57 100644
--- a/ergon-dashboard/src/features/evaluation/selectors.test.ts
+++ b/ergon-dashboard/src/features/evaluation/selectors.test.ts
@@ -74,7 +74,7 @@ function evaluation(taskId: string, statuses: Array<"passed" | "failed" | "error
 function state(evaluationsByTask: Map<string, TaskEvaluationState>): SampleWorkspaceState {
   return {
     id: "run-1",
-    definitionId: "experiment-1",
+    experimentId: "experiment-1",
     name: "run",
     status: "completed",
     tasks: new Map([
diff --git a/ergon-dashboard/src/features/graph/components/MutationTimeline.tsx b/ergon-dashboard/src/features/graph/components/MutationTimeline.tsx
index 261ef7f6b..bac9b83a8 100644
--- a/ergon-dashboard/src/features/graph/components/MutationTimeline.tsx
+++ b/ergon-dashboard/src/features/graph/components/MutationTimeline.tsx
@@ -1,11 +1,11 @@
 "use client";
 
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import type { GraphMutationDto } from "@/features/graph/contracts/graphMutations";
+import type { SampleGraphEventDto } from "@/features/graph/contracts/graphMutations";
 import { formatClockTimeMs } from "@/lib/timeFormat";
 
 interface MutationTimelineProps {
-  mutations: GraphMutationDto[];
+  mutations: SampleGraphEventDto[];
   currentSequence: number;
   onSequenceChange: (sequence: number) => void;
   isPlaying: boolean;
diff --git a/ergon-dashboard/src/features/graph/contracts/graphMutations.test.ts b/ergon-dashboard/src/features/graph/contracts/graphMutations.test.ts
index 4cea5429a..8f73f6ea9 100644
--- a/ergon-dashboard/src/features/graph/contracts/graphMutations.test.ts
+++ b/ergon-dashboard/src/features/graph/contracts/graphMutations.test.ts
@@ -12,13 +12,13 @@ import { EdgeAddedValueSchema, MutationTypeSchema } from "./graphMutations";
 import { applyGraphMutation, createReplayInitialState, replayToSequence } from "../state/graphMutationReducer";
 import type { SampleWorkspaceState } from "@/lib/types";
 import { TaskStatus } from "@/lib/types";
-import type { DashboardGraphMutationData } from "@/lib/contracts/events";
-import type { GraphMutationDto } from "./graphMutations";
+import type { DashboardSampleRuntimeEventData } from "@/lib/contracts/events";
+import type { SampleGraphEventDto } from "./graphMutations";
 
 function emptyState(): SampleWorkspaceState {
   return {
     id: "run-test",
-    definitionId: "00000000-0000-0000-0000-000000000000",
+    experimentId: "00000000-0000-0000-0000-000000000000",
     name: "test",
     status: "executing",
     tasks: new Map(),
@@ -52,7 +52,7 @@ function emptyState(): SampleWorkspaceState {
  */
 function syntheticMutation(
   mutationType: string,
-): DashboardGraphMutationData {
+): DashboardSampleRuntimeEventData {
   const nodeId = "11111111-1111-4111-8111-111111111111";
   const newValueByType: Record<string, Record<string, unknown>> = {
     "node.added": {
@@ -100,7 +100,7 @@ function syntheticMutation(
     id: "77777777-7777-4777-8777-777777777777",
     sample_id: "00000000-0000-0000-0000-000000000000",
     sequence: 1,
-    mutation_type: mutationType as DashboardGraphMutationData["mutation_type"],
+    mutation_type: mutationType as DashboardSampleRuntimeEventData["mutation_type"],
     target_type: "node",
     target_id: nodeId,
     actor: "test",
@@ -247,7 +247,7 @@ test("replay base preserves snapshot hierarchy while dependency edges remain dep
     ],
   ]);
 
-  const mutations: GraphMutationDto[] = [
+  const mutations: SampleGraphEventDto[] = [
     graphNodeAdded(0, "11111111-1111-4111-8111-111111111111", "root"),
     graphNodeAdded(1, "22222222-2222-4222-8222-222222222222", "dependency"),
     graphNodeAdded(2, "33333333-3333-4333-8333-333333333333", "dependent"),
@@ -344,7 +344,7 @@ test("replay base does not leak future dependency edges or node field changes",
     ],
   ]);
 
-  const mutations: GraphMutationDto[] = [
+  const mutations: SampleGraphEventDto[] = [
     graphNodeAdded(0, "11111111-1111-4111-8111-111111111111", "root"),
     graphNodeAdded(1, "22222222-2222-4222-8222-222222222222", "source"),
     graphNodeAdded(2, "33333333-3333-4333-8333-333333333333", "target"),
@@ -434,7 +434,7 @@ test("dependency edges between root-level tasks do not become containment", () =
       },
     ],
   ]);
-  const mutations: GraphMutationDto[] = [
+  const mutations: SampleGraphEventDto[] = [
     graphNodeAdded(0, "22222222-2222-4222-8222-222222222222", "source"),
     graphNodeAdded(1, "33333333-3333-4333-8333-333333333333", "target"),
     {
@@ -471,7 +471,7 @@ function graphNodeAdded(
   sequence: number,
   targetId: string,
   slug: string,
-): GraphMutationDto {
+): SampleGraphEventDto {
   return {
     id: `55555555-5555-4555-8555-55555555555${sequence}`,
     sample_id: "00000000-0000-0000-0000-000000000000",
diff --git a/ergon-dashboard/src/features/graph/contracts/graphMutations.ts b/ergon-dashboard/src/features/graph/contracts/graphMutations.ts
index 6f6494d68..d6fdc5f29 100644
--- a/ergon-dashboard/src/features/graph/contracts/graphMutations.ts
+++ b/ergon-dashboard/src/features/graph/contracts/graphMutations.ts
@@ -69,7 +69,7 @@ export const AnnotationValueSchema = z.object({
 });
 export type AnnotationValue = z.infer<typeof AnnotationValueSchema>;
 
-export const GraphMutationDtoSchema = z.object({
+export const SampleGraphEventDtoSchema = z.object({
   id: z.string().uuid(),
   sample_id: z.string().uuid(),
   sequence: z.number().int().nonnegative(),
@@ -82,12 +82,12 @@ export const GraphMutationDtoSchema = z.object({
   reason: z.string().nullable(),
   created_at: z.string().datetime({ offset: true }),
 });
-export type GraphMutationDto = z.infer<typeof GraphMutationDtoSchema>;
+export type SampleGraphEventDto = z.infer<typeof SampleGraphEventDtoSchema>;
 
-export function parseGraphMutationDto(input: unknown): GraphMutationDto {
-  return GraphMutationDtoSchema.parse(input);
+export function parseSampleGraphEventDto(input: unknown): SampleGraphEventDto {
+  return SampleGraphEventDtoSchema.parse(input);
 }
 
-export function parseGraphMutationDtoArray(input: unknown): GraphMutationDto[] {
-  return z.array(GraphMutationDtoSchema).parse(input);
+export function parseSampleGraphEventDtoArray(input: unknown): SampleGraphEventDto[] {
+  return z.array(SampleGraphEventDtoSchema).parse(input);
 }
diff --git a/ergon-dashboard/src/features/graph/hooks/useGraphMutations.ts b/ergon-dashboard/src/features/graph/hooks/useGraphMutations.ts
index de4b0b43f..a2488303f 100644
--- a/ergon-dashboard/src/features/graph/hooks/useGraphMutations.ts
+++ b/ergon-dashboard/src/features/graph/hooks/useGraphMutations.ts
@@ -1,5 +1,5 @@
 import { useRef, useCallback } from "react";
-import type { DashboardGraphMutationData } from "@/lib/contracts/events";
+import type { DashboardSampleRuntimeEventData } from "@/lib/contracts/events";
 import type { SampleWorkspaceState } from "@/lib/types";
 import { applyGraphMutation } from "@/features/graph/state/graphMutationReducer";
 
@@ -8,7 +8,7 @@ const DEBOUNCE_MS = 200;
 export function useGraphMutations(
   setRunState: React.Dispatch<React.SetStateAction<SampleWorkspaceState | null>>,
 ) {
-  const buffer = useRef<DashboardGraphMutationData[]>([]);
+  const buffer = useRef<DashboardSampleRuntimeEventData[]>([]);
   const timer = useRef<ReturnType<typeof setTimeout> | null>(null);
 
   const flush = useCallback(() => {
@@ -25,7 +25,7 @@ export function useGraphMutations(
   }, [setRunState]);
 
   const handleGraphMutation = useCallback(
-    (mutation: DashboardGraphMutationData) => {
+    (mutation: DashboardSampleRuntimeEventData) => {
       buffer.current.push(mutation);
       if (timer.current) clearTimeout(timer.current);
       timer.current = setTimeout(flush, DEBOUNCE_MS);
diff --git a/ergon-dashboard/src/features/graph/layout/goldenLayout.test.ts b/ergon-dashboard/src/features/graph/layout/goldenLayout.test.ts
index 1792ed4cf..5442bb4b0 100644
--- a/ergon-dashboard/src/features/graph/layout/goldenLayout.test.ts
+++ b/ergon-dashboard/src/features/graph/layout/goldenLayout.test.ts
@@ -3,7 +3,7 @@ import test from "node:test";
 import type { Node } from "@xyflow/react";
 
 import fixture from "../../../../tests/fixtures/mas-samples/concurrent-mas-run.json";
-import { parseGraphMutationDtoArray } from "@/features/graph/contracts/graphMutations";
+import { parseSampleGraphEventDtoArray } from "@/features/graph/contracts/graphMutations";
 import { createReplayInitialState, replayToSequence } from "@/features/graph/state/graphMutationReducer";
 import { deserializeSampleState } from "@/lib/sampleState";
 import { calculateExpandedContainers, computeHierarchicalLayout } from "./hierarchicalLayout";
@@ -55,7 +55,7 @@ function overlappingSiblingPairs(nodes: Node[]): Array<[string, string]> {
 
 test("golden layout renders the full recursive graph without overlapping sibling boxes", () => {
   const runState = deserializeSampleState(fixture.runState);
-  const mutations = parseGraphMutationDtoArray(fixture.mutations);
+  const mutations = parseSampleGraphEventDtoArray(fixture.mutations);
   const checkpoint = fixture.checkpoints.find((entry) => entry.sequence === 14);
   assert.ok(checkpoint);
   const displayState = replayToSequence(
diff --git a/ergon-dashboard/src/features/graph/state/graphMutationReducer.ts b/ergon-dashboard/src/features/graph/state/graphMutationReducer.ts
index f471ecb85..d63b53001 100644
--- a/ergon-dashboard/src/features/graph/state/graphMutationReducer.ts
+++ b/ergon-dashboard/src/features/graph/state/graphMutationReducer.ts
@@ -7,12 +7,12 @@ import type {
   SampleWorkspaceState,
 } from "@/lib/types";
 import { TaskStatus } from "@/lib/types";
-import type { DashboardGraphMutationData } from "@/lib/contracts/events";
+import type { DashboardSampleRuntimeEventData } from "@/lib/contracts/events";
 import type {
   AnnotationValue,
   EdgeAddedValue,
   EdgeStatusChangedValue,
-  GraphMutationDto,
+  SampleGraphEventDto,
   NodeAddedValue,
   NodeFieldChangedValue,
   NodeStatusChangedValue,
@@ -34,7 +34,7 @@ const TERMINAL_STATUSES: Set<string> = new Set([
 ]);
 
 interface MutationContext {
-  /** Sequence number from the original GraphMutationDto, if available. */
+  /** Sequence number from the original SampleGraphEventDto, if available. */
   sequence: number | null;
   createdAt: string;
   mutationId: string | null;
@@ -42,7 +42,7 @@ interface MutationContext {
   reason: string | null;
 }
 
-function ctxFromMutation(mutation: DashboardGraphMutationData): MutationContext {
+function ctxFromMutation(mutation: DashboardSampleRuntimeEventData): MutationContext {
   const m = mutation as unknown as {
     sequence?: number | null;
     created_at?: string;
@@ -77,7 +77,7 @@ function ensureUnhandled(state: SampleWorkspaceState): UnhandledMutationRecord[]
 
 function recordUnhandled(
   state: SampleWorkspaceState,
-  mutation: DashboardGraphMutationData,
+  mutation: DashboardSampleRuntimeEventData,
   note: string,
 ): void {
   const ctx = ctxFromMutation(mutation);
@@ -108,7 +108,7 @@ function edgeId(sourceId: string, targetId: string): string {
  */
 export function applyGraphMutation(
   state: SampleWorkspaceState,
-  mutation: DashboardGraphMutationData,
+  mutation: DashboardSampleRuntimeEventData,
 ): SampleWorkspaceState {
   const next: SampleWorkspaceState = { ...state, tasks: new Map(state.tasks) };
   if (state.edges) next.edges = new Map(state.edges);
@@ -452,7 +452,7 @@ function recalculateMetrics(state: SampleWorkspaceState): void {
 const SNAPSHOT_INTERVAL = 50;
 
 function nodeIdsAddedAtOrBefore(
-  mutations: GraphMutationDto[],
+  mutations: SampleGraphEventDto[],
   upToSequence: number,
 ): Set<string> {
   const ids = new Set<string>();
@@ -466,7 +466,7 @@ function nodeIdsAddedAtOrBefore(
 }
 
 function initialNodeValueById(
-  mutations: GraphMutationDto[],
+  mutations: SampleGraphEventDto[],
   upToSequence: number,
 ): Map<string, NodeAddedValue> {
   const values = new Map<string, NodeAddedValue>();
@@ -502,7 +502,7 @@ function countStatus(
  */
 export function createReplayInitialState(
   runState: SampleWorkspaceState,
-  mutations: GraphMutationDto[],
+  mutations: SampleGraphEventDto[],
   upToSequence: number,
 ): SampleWorkspaceState {
   const includedNodeIds = nodeIdsAddedAtOrBefore(mutations, upToSequence);
@@ -561,7 +561,7 @@ export function createReplayInitialState(
  * `SNAPSHOT_INTERVAL` sequences for faster scrubbing.
  */
 export function replayToSequence(
-  mutations: GraphMutationDto[],
+  mutations: SampleGraphEventDto[],
   upToSequence: number,
   initialState: SampleWorkspaceState,
   snapshotCache?: Map<number, SampleWorkspaceState>,
@@ -588,7 +588,7 @@ export function replayToSequence(
     state = applyGraphMutation(state, {
       ...m,
       timestamp: m.created_at,
-    } as DashboardGraphMutationData);
+    } as DashboardSampleRuntimeEventData);
 
     if (snapshotCache && m.sequence % SNAPSHOT_INTERVAL === 0) {
       snapshotCache.set(m.sequence, { ...state, tasks: new Map(state.tasks) });
diff --git a/ergon-dashboard/src/generated/events/DashboardWorkflowStartedEvent.ts b/ergon-dashboard/src/generated/events/DashboardWorkflowStartedEvent.ts
index 307e0d069..e5a66a963 100644
--- a/ergon-dashboard/src/generated/events/DashboardWorkflowStartedEvent.ts
+++ b/ergon-dashboard/src/generated/events/DashboardWorkflowStartedEvent.ts
@@ -1,3 +1,3 @@
 import { z } from "zod"
 
-export const DashboardWorkflowStartedEventSchema = z.object({ "sample_id": z.string().uuid(), "definition_id": z.string().uuid(), "workflow_name": z.string(), "snapshot": z.any(), "started_at": z.string().datetime({ offset: true }), "total_tasks": z.number().int(), "total_leaf_tasks": z.number().int() }).catchall(z.any())
+export const DashboardWorkflowStartedEventSchema = z.object({ "sample_id": z.string().uuid(), "workflow_name": z.string(), "snapshot": z.any(), "started_at": z.string().datetime({ offset: true }), "total_tasks": z.number().int(), "total_leaf_tasks": z.number().int() }).catchall(z.any())
diff --git a/ergon-dashboard/src/generated/events/schemas/DashboardWorkflowStartedEvent.schema.json b/ergon-dashboard/src/generated/events/schemas/DashboardWorkflowStartedEvent.schema.json
index 496fe15ce..5ed203843 100644
--- a/ergon-dashboard/src/generated/events/schemas/DashboardWorkflowStartedEvent.schema.json
+++ b/ergon-dashboard/src/generated/events/schemas/DashboardWorkflowStartedEvent.schema.json
@@ -1091,18 +1091,6 @@
           "title": "Id",
           "type": "string"
         },
-        "definitionId": {
-          "anyOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "title": "Definitionid"
-        },
         "name": {
           "title": "Name",
           "type": "string"
@@ -1743,11 +1731,6 @@
       "title": "Sample Id",
       "type": "string"
     },
-    "definition_id": {
-      "format": "uuid",
-      "title": "Definition Id",
-      "type": "string"
-    },
     "workflow_name": {
       "title": "Workflow Name",
       "type": "string"
@@ -1771,7 +1754,6 @@
   },
   "required": [
     "sample_id",
-    "definition_id",
     "workflow_name",
     "snapshot",
     "started_at",
diff --git a/ergon-dashboard/src/generated/rest/contracts.ts b/ergon-dashboard/src/generated/rest/contracts.ts
index dc5a3b0b4..693912d21 100644
--- a/ergon-dashboard/src/generated/rest/contracts.ts
+++ b/ergon-dashboard/src/generated/rest/contracts.ts
@@ -19,8 +19,8 @@ const SampleSummaryDto = z
     completed_at: z.union([z.string(), z.null()]).optional(),
     latest_activity_at: z.union([z.string(), z.null()]).optional(),
     duration_seconds: z.union([z.number(), z.null()]).optional(),
-    definition_id: z.union([z.string(), z.null()]).optional(),
-    definition_name: z.union([z.string(), z.null()]).optional(),
+    experiment_id: z.union([z.string(), z.null()]).optional(),
+    experiment_name: z.union([z.string(), z.null()]).optional(),
     experiment: z.union([z.string(), z.null()]).optional(),
     benchmark_type: z.string(),
     instance_key: z.string(),
@@ -306,7 +306,7 @@ const SampleSnapshotMetricsDto = z.object({
 });
 const SampleSnapshotDto = z.object({
   id: z.string(),
-  definitionId: z.union([z.string(), z.null()]).optional(),
+  experimentId: z.union([z.string(), z.null()]).optional(),
   name: z.string(),
   status: z.string(),
   tasks: z.record(z.string(), SampleTaskDto).optional(),
@@ -694,25 +694,25 @@ const SamplerInvocationsView = z
   .passthrough();
 const ExperimentRunRequest = z
   .object({
-    definition_id: z.string().uuid(),
+    experiment_id: z.string().uuid(),
     timeout_seconds: z.union([z.number(), z.null()]).optional(),
     wait: z.boolean().optional().default(true),
   })
   .passthrough();
-const run_experiment_experiments__definition_id__run_post_Body = z.union([
+const submit_experiment_experiments__experiment_id__run_post_Body = z.union([
   ExperimentRunRequest,
   z.null(),
 ]);
 const ExperimentRunResult = z
   .object({
-    definition_id: z.string().uuid(),
+    experiment_id: z.string().uuid(),
     sample_ids: z.array(z.string().uuid()),
-    definition_ids: z.array(z.string().uuid()).optional(),
+    experiment_ids: z.array(z.string().uuid()).optional(),
   })
   .passthrough();
 const SubmitRequest = z
   .object({
-    definition_id: z.string().uuid(),
+    experiment_id: z.string().uuid(),
     num_episodes: z.number().int().gte(1),
     policy_version: z.union([z.number(), z.null()]).optional(),
     model_target_override: z.union([z.string(), z.null()]).optional(),
@@ -805,7 +805,7 @@ const TestExecutionDto = z
     error: z.union([z.string(), z.null()]),
   })
   .passthrough();
-const TestRunStateDto = z
+const TestSampleStateDto = z
   .object({
     sample_id: z.string().uuid(),
     status: z.string(),
@@ -820,12 +820,12 @@ const TestRunStateDto = z
     context_event_count: z.number().int(),
   })
   .passthrough();
-const TestExperimentRunDto = z
+const TestExperimentSampleDto = z
   .object({ sample_id: z.string().uuid(), status: z.string() })
   .passthrough();
-const SeedRunRequest = z
+const SeedSampleRequest = z
   .object({
-    definition_id: z.string().uuid(),
+    experiment_id: z.string().uuid(),
     benchmark_type: z.string().optional().default("test-harness"),
     instance_key: z.string().optional().default("seeded"),
     worker_team: z.object({}).partial().passthrough().optional(),
@@ -835,13 +835,13 @@ const SeedRunRequest = z
   })
   .passthrough();
 const ResetRequest = z.object({ experiment_prefix: z.string() }).passthrough();
-const ExperimentRunSlotRequest = z
+const ExperimentSampleSlotRequest = z
   .object({ worker_slug: z.string(), evaluator_slug: z.string() })
   .passthrough();
-const SubmitExperimentRunsRequest = z
+const SubmitExperimentSamplesRequest = z
   .object({
     benchmark_slug: z.string(),
-    slots: z.array(ExperimentRunSlotRequest),
+    slots: z.array(ExperimentSampleSlotRequest),
     experiment: z.string(),
     sandbox_slug: z.union([z.string(), z.null()]).optional(),
     dependency_extras: z.array(z.string()).optional().default(["none"]),
@@ -849,7 +849,7 @@ const SubmitExperimentRunsRequest = z
     limit: z.number().int().optional().default(1),
   })
   .passthrough();
-const SubmitExperimentRunsResponse = z
+const SubmitExperimentSamplesResponse = z
   .object({ sample_ids: z.array(z.string().uuid()) })
   .passthrough();
 
@@ -912,7 +912,7 @@ export const schemas = {
   ExperimentSamplesView,
   SamplerInvocationsView,
   ExperimentRunRequest,
-  run_experiment_experiments__definition_id__run_post_Body,
+  submit_experiment_experiments__experiment_id__run_post_Body,
   ExperimentRunResult,
   SubmitRequest,
   RolloutStatus,
@@ -927,11 +927,11 @@ export const schemas = {
   TestSampleRuntimeEventDto,
   TestEvaluationDto,
   TestExecutionDto,
-  TestRunStateDto,
-  TestExperimentRunDto,
-  SeedRunRequest,
+  TestSampleStateDto,
+  TestExperimentSampleDto,
+  SeedSampleRequest,
   ResetRequest,
-  ExperimentRunSlotRequest,
-  SubmitExperimentRunsRequest,
-  SubmitExperimentRunsResponse,
+  ExperimentSampleSlotRequest,
+  SubmitExperimentSamplesRequest,
+  SubmitExperimentSamplesResponse,
 };
diff --git a/ergon-dashboard/src/generated/rest/openapi.json b/ergon-dashboard/src/generated/rest/openapi.json
index 1df32454b..75d8f9b91 100644
--- a/ergon-dashboard/src/generated/rest/openapi.json
+++ b/ergon-dashboard/src/generated/rest/openapi.json
@@ -42,7 +42,7 @@
             }
           },
           {
-            "name": "definition_id",
+            "name": "experiment_id",
             "in": "query",
             "required": false,
             "schema": {
@@ -513,16 +513,16 @@
         }
       }
     },
-    "/experiments/{definition_id}/run": {
+    "/experiments/{experiment_id}/run": {
       "post": {
         "tags": [
           "experiments"
         ],
         "summary": "Run Experiment",
-        "operationId": "run_experiment_experiments__definition_id__run_post",
+        "operationId": "submit_experiment_experiments__experiment_id__run_post",
         "parameters": [
           {
-            "name": "definition_id",
+            "name": "experiment_id",
             "in": "path",
             "required": true,
             "schema": {
@@ -827,7 +827,7 @@
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/TestRunStateDto"
+                  "$ref": "#/components/schemas/TestSampleStateDto"
                 }
               }
             }
@@ -850,9 +850,9 @@
         "tags": [
           "danger-test-harness"
         ],
-        "summary": "Read Experiment Runs",
+        "summary": "Read Experiment Samples",
         "description": "List all runs attached to a v2 experiment grouping tag.",
-        "operationId": "read_experiment_runs_api___danger___test_harness_read_experiment__experiment__samples_get",
+        "operationId": "read_experiment_samples_api___danger___test_harness_read_experiment__experiment__samples_get",
         "parameters": [
           {
             "name": "experiment",
@@ -872,9 +872,9 @@
                 "schema": {
                   "type": "array",
                   "items": {
-                    "$ref": "#/components/schemas/TestExperimentRunDto"
+                    "$ref": "#/components/schemas/TestExperimentSampleDto"
                   },
-                  "title": "Response Read Experiment Runs Api   Danger   Test Harness Read Experiment  Experiment  Samples Get"
+                  "title": "Response Read Experiment Samples Api   Danger   Test Harness Read Experiment  Experiment  Samples Get"
                 }
               }
             }
@@ -903,7 +903,7 @@
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/SeedRunRequest"
+                "$ref": "#/components/schemas/SeedSampleRequest"
               }
             }
           },
@@ -969,19 +969,19 @@
         }
       }
     },
-    "/api/__danger__/test-harness/write/experiment-runs": {
+    "/api/__danger__/test-harness/write/experiment-samples": {
       "post": {
         "tags": [
           "danger-test-harness"
         ],
-        "summary": "Submit Experiment Runs",
-        "description": "Build + persist + dispatch N runs under one experiment tag.\n\nPer-slot flow persists the object-bound smoke ``Benchmark`` into the\nimmutable ``ExperimentDefinition`` tables. The v2 experiment grouping tag\nis written into definition metadata and copied to ``SampleRecord.experiment``\nby launch. Slots submit sequentially \u2014 typical N \u2264 3, so the\nparallel-gather savings are negligible.",
-        "operationId": "submit_experiment_runs_api___danger___test_harness_write_experiment_runs_post",
+        "summary": "Submit Experiment Samples",
+        "description": "Build + persist + dispatch N samples under one experiment tag.\n\nPer-slot flow builds sample DAGs through the experiment/environment authoring path and submits them sequentially for deterministic smoke coverage.",
+        "operationId": "submit_experiment_samples_api___danger___test_harness_write_experiment_samples_post",
         "requestBody": {
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/SubmitExperimentRunsRequest"
+                "$ref": "#/components/schemas/SubmitExperimentSamplesRequest"
               }
             }
           },
@@ -993,7 +993,7 @@
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/SubmitExperimentRunsResponse"
+                  "$ref": "#/components/schemas/SubmitExperimentSamplesResponse"
                 }
               }
             }
@@ -1368,7 +1368,7 @@
       },
       "ExperimentRunRequest": {
         "properties": {
-          "definition_id": {
+          "experiment_id": {
             "type": "string",
             "format": "uuid",
             "title": "Definition Id"
@@ -1392,13 +1392,13 @@
         },
         "type": "object",
         "required": [
-          "definition_id"
+          "experiment_id"
         ],
         "title": "ExperimentRunRequest"
       },
       "ExperimentRunResult": {
         "properties": {
-          "definition_id": {
+          "experiment_id": {
             "type": "string",
             "format": "uuid",
             "title": "Definition Id"
@@ -1411,7 +1411,7 @@
             "type": "array",
             "title": "Sample Ids"
           },
-          "definition_ids": {
+          "experiment_ids": {
             "items": {
               "type": "string",
               "format": "uuid"
@@ -1422,12 +1422,12 @@
         },
         "type": "object",
         "required": [
-          "definition_id",
+          "experiment_id",
           "sample_ids"
         ],
         "title": "ExperimentRunResult"
       },
-      "ExperimentRunSlotRequest": {
+      "ExperimentSampleSlotRequest": {
         "properties": {
           "worker_slug": {
             "type": "string",
@@ -1443,7 +1443,7 @@
           "worker_slug",
           "evaluator_slug"
         ],
-        "title": "ExperimentRunSlotRequest"
+        "title": "ExperimentSampleSlotRequest"
       },
       "ExperimentSampleSummaryView": {
         "properties": {
@@ -3529,7 +3529,7 @@
             "type": "string",
             "title": "Id"
           },
-          "definitionId": {
+          "experimentId": {
             "anyOf": [
               {
                 "type": "string"
@@ -3930,7 +3930,7 @@
             ],
             "title": "Duration Seconds"
           },
-          "definition_id": {
+          "experiment_id": {
             "anyOf": [
               {
                 "type": "string",
@@ -3942,7 +3942,7 @@
             ],
             "title": "Definition Id"
           },
-          "definition_name": {
+          "experiment_name": {
             "anyOf": [
               {
                 "type": "string"
@@ -4747,9 +4747,9 @@
         "type": "object",
         "title": "SamplerInvocationsView"
       },
-      "SeedRunRequest": {
+      "SeedSampleRequest": {
         "properties": {
-          "definition_id": {
+          "experiment_id": {
             "type": "string",
             "format": "uuid",
             "title": "Definition Id"
@@ -4790,11 +4790,11 @@
         },
         "type": "object",
         "required": [
-          "definition_id"
+          "experiment_id"
         ],
-        "title": "SeedRunRequest"
+        "title": "SeedSampleRequest"
       },
-      "SubmitExperimentRunsRequest": {
+      "SubmitExperimentSamplesRequest": {
         "properties": {
           "benchmark_slug": {
             "type": "string",
@@ -4802,7 +4802,7 @@
           },
           "slots": {
             "items": {
-              "$ref": "#/components/schemas/ExperimentRunSlotRequest"
+              "$ref": "#/components/schemas/ExperimentSampleSlotRequest"
             },
             "type": "array",
             "title": "Slots"
@@ -4849,9 +4849,9 @@
           "slots",
           "experiment"
         ],
-        "title": "SubmitExperimentRunsRequest"
+        "title": "SubmitExperimentSamplesRequest"
       },
-      "SubmitExperimentRunsResponse": {
+      "SubmitExperimentSamplesResponse": {
         "properties": {
           "sample_ids": {
             "items": {
@@ -4866,11 +4866,11 @@
         "required": [
           "sample_ids"
         ],
-        "title": "SubmitExperimentRunsResponse"
+        "title": "SubmitExperimentSamplesResponse"
       },
       "SubmitRequest": {
         "properties": {
-          "definition_id": {
+          "experiment_id": {
             "type": "string",
             "format": "uuid",
             "title": "Definition Id"
@@ -4905,7 +4905,7 @@
         },
         "type": "object",
         "required": [
-          "definition_id",
+          "experiment_id",
           "num_episodes"
         ],
         "title": "SubmitRequest",
@@ -5033,7 +5033,7 @@
         ],
         "title": "TestExecutionDto"
       },
-      "TestExperimentRunDto": {
+      "TestExperimentSampleDto": {
         "properties": {
           "sample_id": {
             "type": "string",
@@ -5050,7 +5050,7 @@
           "sample_id",
           "status"
         ],
-        "title": "TestExperimentRunDto"
+        "title": "TestExperimentSampleDto"
       },
       "TestGraphNodeDto": {
         "properties": {
@@ -5106,7 +5106,7 @@
         ],
         "title": "TestGraphNodeDto"
       },
-      "TestRunStateDto": {
+      "TestSampleStateDto": {
         "properties": {
           "sample_id": {
             "type": "string",
@@ -5180,7 +5180,7 @@
           "thread_count",
           "context_event_count"
         ],
-        "title": "TestRunStateDto"
+        "title": "TestSampleStateDto"
       },
       "TestSampleRuntimeEventDto": {
         "properties": {
diff --git a/ergon-dashboard/src/hooks/useSampleWorkspaceState.ts b/ergon-dashboard/src/hooks/useSampleWorkspaceState.ts
index b122fc671..d96e2bd02 100644
--- a/ergon-dashboard/src/hooks/useSampleWorkspaceState.ts
+++ b/ergon-dashboard/src/hooks/useSampleWorkspaceState.ts
@@ -22,7 +22,7 @@ import {
   parseSandboxCreatedSocketData,
   parseTaskStatusSocketData,
 } from "@/lib/contracts/events";
-import type { GraphMutationSocketData } from "@/lib/contracts/events";
+import type { SampleRuntimeEventSocketData } from "@/lib/contracts/events";
 import type { SampleSandbox, SampleSandboxCommand } from "@/lib/contracts/rest";
 import {
   ContextEventState,
@@ -328,7 +328,7 @@ export function useSampleWorkspaceState(
   const { handleGraphMutation } = useGraphMutations(setRunState);
 
   const handleGraphMutationSocket = useCallback(
-    (data: GraphMutationSocketData) => {
+    (data: SampleRuntimeEventSocketData) => {
       if (data.sampleId !== sampleId) return;
       handleGraphMutation(data.mutation);
     },
@@ -411,7 +411,7 @@ export function useSampleWorkspaceState(
     socket.on("thread:message", handleThreadMessage);
     socket.on("task:evaluation", handleTaskEvaluation);
     socket.on("context:event", handleContextEvent);
-    socket.on("graph:mutation", handleGraphMutationSocket);
+    socket.on("sample:runtime-event", handleGraphMutationSocket);
 
     return () => {
       if (retryTimeout) clearTimeout(retryTimeout);
@@ -425,7 +425,7 @@ export function useSampleWorkspaceState(
       socket.off("thread:message", handleThreadMessage);
       socket.off("task:evaluation", handleTaskEvaluation);
       socket.off("context:event", handleContextEvent);
-      socket.off("graph:mutation", handleGraphMutationSocket);
+      socket.off("sample:runtime-event", handleGraphMutationSocket);
     };
   }, [
     socket,
diff --git a/ergon-dashboard/src/inngest/functions/index.ts b/ergon-dashboard/src/inngest/functions/index.ts
index 25af1f019..8394e75b4 100644
--- a/ergon-dashboard/src/inngest/functions/index.ts
+++ b/ergon-dashboard/src/inngest/functions/index.ts
@@ -20,7 +20,8 @@ import {
   broadcastSandboxClosed,
 } from "@/lib/socket/server";
 import {
-  parseDashboardGraphMutationData,
+  isDashboardSampleRuntimeGraphEvent,
+  parseDashboardSampleRuntimeEventData,
   parseDashboardTaskEvaluationUpdatedData,
   parseDashboardThreadMessageCreatedData,
   parseDashboardWorkflowStartedData,
@@ -51,7 +52,6 @@ const onWorkflowStarted = inngest.createFunction(
     const payload = parseDashboardWorkflowStartedData(event.data);
     const {
       sample_id,
-      definition_id,
       workflow_name,
       snapshot,
       started_at,
@@ -68,7 +68,6 @@ const onWorkflowStarted = inngest.createFunction(
     // Update store
     store.initializeSample(
       sample_id,
-      definition_id,
       workflow_name,
       snapshot,
       started_at,
@@ -413,7 +412,10 @@ const onGraphMutation = inngest.createFunction(
   { id: "handle-sample-runtime-event", name: "Handle Sample Runtime Event" },
   { event: "dashboard/sample.runtime_event" },
   async ({ event }) => {
-    const mutation = parseDashboardGraphMutationData(event.data);
+    if (!isDashboardSampleRuntimeGraphEvent(event.data)) {
+      return { success: true, ignored: true };
+    }
+    const mutation = parseDashboardSampleRuntimeEventData(event.data);
     store.applyGraphMutation(mutation.sample_id, mutation);
     broadcastGraphMutation(mutation.sample_id, mutation);
     return { success: true };
diff --git a/ergon-dashboard/src/lib/contracts/events.ts b/ergon-dashboard/src/lib/contracts/events.ts
index 3831cfeee..392f4150a 100644
--- a/ergon-dashboard/src/lib/contracts/events.ts
+++ b/ergon-dashboard/src/lib/contracts/events.ts
@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { GraphMutationDtoSchema } from "@/features/graph/contracts/graphMutations";
+import { SampleGraphEventDtoSchema } from "@/features/graph/contracts/graphMutations";
 import {
   dashboardEventSchemas,
   DashboardContextEventEventSchema as GeneratedDashboardContextEventEventSchema,
@@ -21,6 +21,7 @@ import {
   parseSampleSnapshot,
   parseSampleTaskEvaluation,
   SampleRuntimeEventView,
+  SampleRuntimeEventViewSchema,
   SampleCommunicationMessageSchema,
   SampleCommunicationThreadSchema,
   SampleResourceSchema,
@@ -62,7 +63,6 @@ export type EvaluatorRef = z.infer<typeof EvaluatorRefSchema>;
 
 export const DashboardWorkflowStartedDataSchema = z.object({
   sample_id: z.string().uuid(),
-  definition_id: z.string().uuid(),
   workflow_name: z.string(),
   snapshot: z.unknown(),
   started_at: z.string().datetime({ offset: true }),
@@ -133,7 +133,6 @@ export const SandboxClosedSocketDataSchema = z.object({
 export type TaskTrigger = z.infer<typeof TaskTriggerSchema>;
 export interface DashboardWorkflowStartedData {
   sample_id: string;
-  definition_id: string;
   workflow_name: string;
   snapshot: SampleSnapshot;
   started_at: string;
@@ -248,7 +247,6 @@ export function parseDashboardWorkflowStartedData(input: unknown): DashboardWork
   });
   return {
     sample_id: parsed.sample_id,
-    definition_id: parsed.definition_id,
     workflow_name: parsed.workflow_name,
     snapshot: parseSampleSnapshot(parsed.snapshot),
     started_at: parsed.started_at,
@@ -306,16 +304,21 @@ function asRecord(value: unknown): Record<string, unknown> {
   return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {};
 }
 
-export const DashboardGraphMutationDataSchema = z.preprocess((input) => {
+export const DashboardSampleRuntimeEventDataSchema = z.preprocess((input) => {
   const outer = asRecord(input);
   if (outer.mutation !== undefined) {
     return outer.mutation;
   }
-  const event = (outer.event === undefined ? outer : GeneratedDashboardSampleRuntimeEventSchema.parse(input).event) as SampleRuntimeEventView;
+  const event =
+    outer.event === undefined
+      ? SampleRuntimeEventViewSchema.parse(input)
+      : GeneratedDashboardSampleRuntimeEventSchema.parse(input).event;
   const targetType = event.targetType === "task" ? "node" : event.targetType;
-  const mutationType = event.eventType
+  const rawMutationType = event.eventType
     .replace("task.", "node.")
     .replace("sample.", "node.");
+  const mutationType =
+    rawMutationType === "annotation.updated" ? "annotation.set" : rawMutationType;
   return {
     id: event.eventId,
     sample_id: event.sampleId,
@@ -325,23 +328,118 @@ export const DashboardGraphMutationDataSchema = z.preprocess((input) => {
     target_id: event.targetId ?? event.sampleId,
     actor: "typed-sample-wal",
     old_value: null,
-    new_value: event.payload,
+    new_value: sampleRuntimeGraphMutationValue(event),
     reason: null,
     created_at: event.timestamp,
   };
-}, GraphMutationDtoSchema);
+}, SampleGraphEventDtoSchema);
 
-export type DashboardGraphMutationData = z.infer<typeof DashboardGraphMutationDataSchema>;
+export type DashboardSampleRuntimeEventData = z.infer<typeof DashboardSampleRuntimeEventDataSchema>;
 
-export function parseDashboardGraphMutationData(input: unknown): DashboardGraphMutationData {
-  return DashboardGraphMutationDataSchema.parse(input);
+export function parseDashboardSampleRuntimeEventData(input: unknown): DashboardSampleRuntimeEventData {
+  return DashboardSampleRuntimeEventDataSchema.parse(input);
 }
 
-export const GraphMutationSocketDataSchema = z.object({
+const GRAPH_RUNTIME_EVENT_TYPES = new Set([
+  "task.added",
+  "task.removed",
+  "task.status_changed",
+  "edge.added",
+  "edge.removed",
+  "edge.status_changed",
+  "annotation.set",
+  "annotation.updated",
+  "annotation.deleted",
+]);
+
+export function isDashboardSampleRuntimeGraphEvent(input: unknown): boolean {
+  const outer = asRecord(input);
+  if (outer.mutation !== undefined) {
+    return true;
+  }
+  const parsed = GeneratedDashboardSampleRuntimeEventSchema.parse(input);
+  return GRAPH_RUNTIME_EVENT_TYPES.has(parsed.event.eventType);
+}
+
+function stringField(input: Record<string, unknown>, ...keys: string[]): string | null {
+  for (const key of keys) {
+    const value = input[key];
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  return null;
+}
+
+function jsonRecord(input: unknown): Record<string, unknown> {
+  return asRecord(input);
+}
+
+function annotationValue(input: unknown, namespace: string): Record<string, unknown> {
+  const value = jsonRecord(input);
+  const payload = jsonRecord(value.payload ?? value);
+  return {
+    namespace: stringField(value, "namespace") ?? namespace,
+    payload,
+  };
+}
+
+function sampleRuntimeGraphMutationValue(
+  event: SampleRuntimeEventView,
+): Record<string, unknown> {
+  switch (event.eventType) {
+    case "task.added": {
+      const task = jsonRecord(event.task);
+      const payload = jsonRecord(event.payload);
+      const taskSlug =
+        event.taskSlug ?? stringField(payload, "task_slug", "taskSlug") ?? event.targetId;
+      return {
+        task_slug: taskSlug,
+        instance_key:
+          stringField(task, "instance_key", "instanceKey") ??
+          stringField(payload, "instance_key", "instanceKey") ??
+          taskSlug,
+        description: stringField(task, "description") ?? "",
+        status: event.status ?? "pending",
+        assigned_worker_slug:
+          stringField(payload, "worker_slug", "workerSlug", "assigned_worker_slug") ?? null,
+      };
+    }
+    case "task.status_changed":
+      return { status: event.status };
+    case "edge.added":
+      return {
+        mutation_type: "edge.added",
+        source_task_id: event.sourceTaskId,
+        target_task_id: event.targetTaskId,
+        status: event.status ?? "pending",
+      };
+    case "edge.removed":
+      return {
+        mutation_type: "edge.removed",
+        source_task_id: event.sourceTaskId,
+        target_task_id: event.targetTaskId,
+        status: "removed",
+      };
+    case "edge.status_changed":
+      return { status: event.status };
+    case "annotation.set":
+    case "annotation.updated":
+      return annotationValue(event.value, event.key);
+    case "annotation.deleted":
+      return annotationValue(event.payload, event.key);
+    case "task.removed":
+      return {};
+    default:
+      return jsonRecord(event.payload);
+  }
+}
+
+export const SampleRuntimeEventSocketDataSchema = z.object({
   sampleId: z.string().uuid(),
-  mutation: DashboardGraphMutationDataSchema,
+  mutation: DashboardSampleRuntimeEventDataSchema,
 });
-export type GraphMutationSocketData = z.infer<typeof GraphMutationSocketDataSchema>;
+export type SampleRuntimeEventSocketData = z.infer<typeof SampleRuntimeEventSocketDataSchema>;
 
 // =============================================================================
 // Context Event Events
diff --git a/ergon-dashboard/src/lib/sample-state/hydrate.ts b/ergon-dashboard/src/lib/sample-state/hydrate.ts
index e3d862718..69eacc754 100644
--- a/ergon-dashboard/src/lib/sample-state/hydrate.ts
+++ b/ergon-dashboard/src/lib/sample-state/hydrate.ts
@@ -101,7 +101,7 @@ export function hydrateSampleSnapshot(input: unknown): SampleWorkspaceState {
 
   return {
     id: data.id,
-    definitionId: data.definitionId ?? "",
+    experimentId: data.experimentId ?? null,
     name: data.name,
     status: data.status as SampleWorkspaceState["status"],
     tasks: new Map(
diff --git a/ergon-dashboard/src/lib/server-data/samples.ts b/ergon-dashboard/src/lib/server-data/samples.ts
index db328e384..826230214 100644
--- a/ergon-dashboard/src/lib/server-data/samples.ts
+++ b/ergon-dashboard/src/lib/server-data/samples.ts
@@ -16,7 +16,7 @@ export interface SampleListFilters {
   limit?: number;
   offset?: number;
   status?: string;
-  definitionId?: string;
+  experimentId?: string;
   experiment?: string;
 }
 
@@ -29,8 +29,7 @@ export interface SampleSummary {
   completed_at: string | null;
   latest_activity_at: string | null;
   duration_seconds: number | null;
-  definition_id: string;
-  definition_name: string | null;
+  experiment_id: string | null;
   experiment: string | null;
   benchmark_type: string;
   instance_key: string;
@@ -57,7 +56,7 @@ export async function loadSampleList(
   searchParams.set("limit", String(filters.limit ?? 100));
   if (filters.offset) searchParams.set("offset", String(filters.offset));
   if (filters.status) searchParams.set("status", filters.status);
-  if (filters.definitionId) searchParams.set("definition_id", filters.definitionId);
+  if (filters.experimentId) searchParams.set("experiment_id", filters.experimentId);
   if (filters.experiment) searchParams.set("experiment", filters.experiment);
 
   try {
@@ -162,8 +161,7 @@ function parseSampleList(input: unknown): SampleSummary[] {
       completed_at: optionalString(record.completed_at),
       latest_activity_at: optionalString(record.latest_activity_at),
       duration_seconds: optionalNumber(record.duration_seconds),
-      definition_id: String(record.definition_id ?? ""),
-      definition_name: optionalString(record.definition_name),
+      experiment_id: optionalString(record.experiment_id),
       experiment: optionalString(record.experiment),
       benchmark_type: String(record.benchmark_type ?? ""),
       instance_key: String(record.instance_key ?? ""),
diff --git a/ergon-dashboard/src/lib/socket/server.ts b/ergon-dashboard/src/lib/socket/server.ts
index c32ec7832..199c82a17 100644
--- a/ergon-dashboard/src/lib/socket/server.ts
+++ b/ergon-dashboard/src/lib/socket/server.ts
@@ -21,7 +21,7 @@ import {
   SandboxCommandState,
   TaskStatus,
 } from "../types";
-import type { DashboardGraphMutationData } from "@/lib/contracts/events";
+import type { DashboardSampleRuntimeEventData } from "@/lib/contracts/events";
 
 // Typed Socket.io server
 type TypedServer = SocketServer<ClientToServerEvents, ServerToClientEvents>;
@@ -266,10 +266,10 @@ export function broadcastTaskEvaluation(
 
 export function broadcastGraphMutation(
   sampleId: string,
-  mutation: DashboardGraphMutationData,
+  mutation: DashboardSampleRuntimeEventData,
 ): void {
   const io = getIO();
-  io?.to(`sample:${sampleId}`).emit("graph:mutation", { sampleId, mutation });
+  io?.to(`sample:${sampleId}`).emit("sample:runtime-event", { sampleId, mutation });
 }
 
 export function broadcastContextEvent(
diff --git a/ergon-dashboard/src/lib/state/store.ts b/ergon-dashboard/src/lib/state/store.ts
index 5c3a39f1a..c967e31be 100644
--- a/ergon-dashboard/src/lib/state/store.ts
+++ b/ergon-dashboard/src/lib/state/store.ts
@@ -24,7 +24,7 @@ import {
   SampleWorkspaceState,
 } from "../types";
 import { applyGraphMutation as reduceGraphMutation } from "@/features/graph/state/graphMutationReducer";
-import type { DashboardGraphMutationData } from "@/lib/contracts/events";
+import type { DashboardSampleRuntimeEventData } from "@/lib/contracts/events";
 import type { SampleSnapshot } from "@/lib/contracts/rest";
 import { hydrateSampleSnapshot } from "@/lib/sample-state/hydrate";
 import {
@@ -105,7 +105,6 @@ class DashboardStore {
    */
   initializeSample(
     sampleId: string,
-    definitionId: string,
     name: string,
     snapshot: SampleSnapshot,
     startedAt: string,
@@ -115,7 +114,6 @@ class DashboardStore {
     const hydrated = hydrateSampleSnapshot({
       ...snapshot,
       id: sampleId,
-      definitionId,
       name,
       status: "executing",
       startedAt,
@@ -305,7 +303,7 @@ class DashboardStore {
     this.runs.set(sampleId, applySandboxClosed(run, taskId, reason, timestamp));
   }
 
-  applyGraphMutation(sampleId: string, mutation: DashboardGraphMutationData): void {
+  applyGraphMutation(sampleId: string, mutation: DashboardSampleRuntimeEventData): void {
     const run = this.runs.get(sampleId);
     if (!run) return;
     const updated = reduceGraphMutation(run, mutation);
diff --git a/ergon-dashboard/src/lib/testing/dashboardHarness.ts b/ergon-dashboard/src/lib/testing/dashboardHarness.ts
index f3d502902..b656a1c59 100644
--- a/ergon-dashboard/src/lib/testing/dashboardHarness.ts
+++ b/ergon-dashboard/src/lib/testing/dashboardHarness.ts
@@ -79,9 +79,9 @@ export function seedDashboardHarness(payload: DashboardHarnessSeedPayload): void
   }
 }
 
-export function getHarnessExperiment(definitionId: string): unknown | null {
+export function getHarnessExperiment(experimentId: string): unknown | null {
   requireHarnessEnabled();
-  return getHarnessState().experimentDetails[definitionId] ?? null;
+  return getHarnessState().experimentDetails[experimentId] ?? null;
 }
 
 export function getHarnessSampleState(sampleId: string): SampleDashboardState | null {
diff --git a/ergon-dashboard/src/lib/types.ts b/ergon-dashboard/src/lib/types.ts
index 6bcf3c049..ca73ccca1 100644
--- a/ergon-dashboard/src/lib/types.ts
+++ b/ergon-dashboard/src/lib/types.ts
@@ -13,9 +13,9 @@ import type {
 } from "@/lib/contracts/rest";
 export type { SampleDashboardState } from "@/lib/sample-state/dashboard";
 import type {
-  DashboardGraphMutationData as GeneratedDashboardGraphMutationData,
+  DashboardSampleRuntimeEventData as GeneratedDashboardSampleRuntimeEventData,
   DashboardResourcePublishedData as GeneratedDashboardResourcePublishedData,
-  GraphMutationSocketData as GeneratedGraphMutationSocketData,
+  SampleRuntimeEventSocketData as GeneratedSampleRuntimeEventSocketData,
   ResourceSocketData,
   SampleCompletedSocketData,
   DashboardSandboxClosedData as GeneratedDashboardSandboxClosedData,
@@ -101,8 +101,8 @@ export type DashboardTaskEvaluationUpdatedData = GeneratedDashboardTaskEvaluatio
 import type { DashboardContextEventEventData as _GeneratedDashboardContextEventEventData } from "@/lib/contracts/events";
 export type DashboardContextEventEventData = _GeneratedDashboardContextEventEventData;
 
-export type DashboardGraphMutationData = GeneratedDashboardGraphMutationData;
-export type GraphMutationSocketData = GeneratedGraphMutationSocketData;
+export type DashboardSampleRuntimeEventData = GeneratedDashboardSampleRuntimeEventData;
+export type SampleRuntimeEventSocketData = GeneratedSampleRuntimeEventSocketData;
 
 // =============================================================================
 // Union Types for Inngest Event Handling
@@ -118,7 +118,7 @@ export type DashboardEventData =
   | DashboardSandboxClosedData
   | DashboardThreadMessageCreatedData
   | DashboardTaskEvaluationUpdatedData
-  | DashboardGraphMutationData
+  | DashboardSampleRuntimeEventData
   | DashboardContextEventEventData;
 
 // =============================================================================
@@ -135,7 +135,7 @@ export type DashboardEvents = {
   "dashboard/sandbox.closed": { data: DashboardSandboxClosedData };
   "dashboard/thread.message_created": { data: DashboardThreadMessageCreatedData };
   "dashboard/task.evaluation_updated": { data: DashboardTaskEvaluationUpdatedData };
-  "dashboard/sample.runtime_event": { data: DashboardGraphMutationData };
+  "dashboard/sample.runtime_event": { data: DashboardSampleRuntimeEventData };
   "dashboard/context.event": { data: DashboardContextEventEventData };
 };
 
@@ -293,7 +293,7 @@ export interface UnhandledMutationRecord {
  */
 export interface SampleWorkspaceState {
   id: string;
-  definitionId: string;
+  experimentId: string | null;
   name: string;
   status: SampleLifecycleStatus;
 
@@ -364,7 +364,7 @@ export interface ServerToClientEvents {
   "sandbox:closed": (data: SandboxClosedSocketData) => void;
   "thread:message": (data: DashboardThreadMessageCreatedData) => void;
   "task:evaluation": (data: DashboardTaskEvaluationUpdatedData) => void;
-  "graph:mutation": (data: GraphMutationSocketData) => void;
+  "sample:runtime-event": (data: SampleRuntimeEventSocketData) => void;
   "context:event": (data: { sampleId: string; taskId: string; event: ContextEventState }) => void;
   // Sync event - sends all current runs to a client on request
   "sync:samples": (runs: SampleListEntry[]) => void;
diff --git a/ergon-dashboard/tests/components/ExperimentDetail.test.ts b/ergon-dashboard/tests/components/ExperimentDetail.test.ts
index 82f8c6087..96f48d2ca 100644
--- a/ergon-dashboard/tests/components/ExperimentDetail.test.ts
+++ b/ergon-dashboard/tests/components/ExperimentDetail.test.ts
@@ -13,6 +13,6 @@ test("experiment detail renders sample rows and environment contributions", () =
   );
 
   assert.match(html, /mini-validation/);
-  assert.match(html, /href="\/samples\/sample-1\/detail"/);
+  assert.match(html, /href="\/samples\/sample-1"/);
   assert.doesNotMatch(html, />Runs</);
 });
diff --git a/ergon-dashboard/tests/contracts/contracts.test.ts b/ergon-dashboard/tests/contracts/contracts.test.ts
index d28f2f7f8..ccd65c3f4 100644
--- a/ergon-dashboard/tests/contracts/contracts.test.ts
+++ b/ergon-dashboard/tests/contracts/contracts.test.ts
@@ -5,8 +5,9 @@ import test from "node:test";
 
 import {
   dashboardEventSchemas,
+  isDashboardSampleRuntimeGraphEvent,
   parseDashboardContextEventData,
-  parseDashboardGraphMutationData,
+  parseDashboardSampleRuntimeEventData,
   parseDashboardTaskEvaluationUpdatedData,
   parseDashboardThreadMessageCreatedData,
   parseDashboardWorkflowStartedData,
@@ -130,7 +131,6 @@ test("workflow started event parser validates run snapshots", () => {
 
   const payload = {
     sample_id: FIXTURE_IDS.sampleId,
-    definition_id: FIXTURE_IDS.definitionId,
     workflow_name: "parallel",
     started_at: "2026-03-18T12:00:00.000Z",
     total_tasks: run.totalTasks,
@@ -224,8 +224,8 @@ test("dashboard nested DTO event parser accepts backend snake-case payloads", ()
   assert.equal(parsedEvaluation.evaluation.totalScore, evaluation.totalScore);
 });
 
-test("dashboard graph mutation parser accepts backend wrapped mutation event", () => {
-  const parsed = parseDashboardGraphMutationData({
+test("dashboard sample runtime event parser accepts backend wrapped event", () => {
+  const parsed = parseDashboardSampleRuntimeEventData({
     mutation: {
       id: "77777777-7777-4777-8777-777777777777",
       sample_id: FIXTURE_IDS.sampleId,
@@ -250,8 +250,8 @@ test("dashboard graph mutation parser accepts backend wrapped mutation event", (
   assert.equal(parsed.created_at, "2026-03-18T12:00:14.000000Z");
 });
 
-test("dashboard graph mutation parser preserves canonical edge task ids", () => {
-  const parsed = parseDashboardGraphMutationData({
+test("dashboard sample runtime event parser preserves canonical edge task ids", () => {
+  const parsed = parseDashboardSampleRuntimeEventData({
     mutation: {
       id: "77777777-7777-4777-8777-777777777777",
       sample_id: FIXTURE_IDS.sampleId,
@@ -278,6 +278,127 @@ test("dashboard graph mutation parser preserves canonical edge task ids", () =>
   assert.equal("target_node_id" in parsed.new_value, false);
 });
 
+test("dashboard sample runtime graph guard ignores component-only WAL events", () => {
+  assert.equal(
+    isDashboardSampleRuntimeGraphEvent({
+      event: {
+        eventId: "77777777-7777-4777-8777-777777777777",
+        sampleId: FIXTURE_IDS.sampleId,
+        timestamp: "2026-03-18T12:00:14.000000Z",
+        eventType: "worker.added",
+        targetType: "task",
+        targetId: FIXTURE_IDS.solveTaskNodeUuid,
+        workerSlug: "minif2f-smoke-worker",
+        workerType: "tests.fixtures.smoke_components.workers:Worker",
+        modelTarget: "openai:gpt-4o",
+        worker: {},
+        payload: {},
+      },
+    }),
+    false,
+  );
+});
+
+test("dashboard sample runtime graph guard ignores sample lifecycle WAL events", () => {
+  assert.equal(
+    isDashboardSampleRuntimeGraphEvent({
+      event: {
+        eventId: "77777777-7777-4777-8777-777777777777",
+        sampleId: FIXTURE_IDS.sampleId,
+        timestamp: "2026-03-18T12:00:14.000000Z",
+        eventType: "sample.status_changed",
+        targetType: "sample",
+        targetId: FIXTURE_IDS.sampleId,
+        status: "completed",
+        payload: { reason: "workflow completed" },
+      },
+    }),
+    false,
+  );
+});
+
+test("dashboard sample runtime event parser projects typed task events into graph mutations", () => {
+  const parsed = parseDashboardSampleRuntimeEventData({
+    event: {
+      eventId: "77777777-7777-4777-8777-777777777777",
+      sampleId: FIXTURE_IDS.sampleId,
+      timestamp: "2026-03-18T12:00:14.000000Z",
+      eventType: "task.added",
+      targetType: "task",
+      targetId: FIXTURE_IDS.solveTaskNodeUuid,
+      taskSlug: "solve",
+      status: "pending",
+      task: {
+        instance_key: "proof-1",
+        description: "Write the proof.",
+      },
+      payload: {
+        worker_slug: "minif2f-smoke-worker",
+      },
+    },
+  });
+
+  assert.equal(parsed.mutation_type, "node.added");
+  assert.equal(parsed.target_type, "node");
+  assert.deepEqual(parsed.new_value, {
+    task_slug: "solve",
+    instance_key: "proof-1",
+    description: "Write the proof.",
+    status: "pending",
+    assigned_worker_slug: "minif2f-smoke-worker",
+  });
+});
+
+test("dashboard sample runtime event parser projects typed edge events into graph mutations", () => {
+  const parsed = parseDashboardSampleRuntimeEventData({
+    event: {
+      eventId: "77777777-7777-4777-8777-777777777777",
+      sampleId: FIXTURE_IDS.sampleId,
+      timestamp: "2026-03-18T12:00:14.000000Z",
+      eventType: "edge.added",
+      targetType: "edge",
+      targetId: "99999999-9999-4999-8999-999999999999",
+      sourceTaskId: FIXTURE_IDS.actionId,
+      targetTaskId: FIXTURE_IDS.solveTaskNodeUuid,
+      status: "pending",
+      payload: {},
+    },
+  });
+
+  assert.equal(parsed.mutation_type, "edge.added");
+  assert.deepEqual(parsed.new_value, {
+    mutation_type: "edge.added",
+    source_task_id: FIXTURE_IDS.actionId,
+    target_task_id: FIXTURE_IDS.solveTaskNodeUuid,
+    status: "pending",
+  });
+});
+
+test("dashboard sample runtime event parser treats annotation updates as sets", () => {
+  const parsed = parseDashboardSampleRuntimeEventData({
+    event: {
+      eventId: "77777777-7777-4777-8777-777777777777",
+      sampleId: FIXTURE_IDS.sampleId,
+      timestamp: "2026-03-18T12:00:14.000000Z",
+      eventType: "annotation.updated",
+      targetType: "task",
+      targetId: FIXTURE_IDS.solveTaskNodeUuid,
+      key: "review",
+      value: {
+        namespace: "review",
+        payload: { label: "important" },
+      },
+      payload: {},
+    },
+  });
+
+  assert.equal(parsed.mutation_type, "annotation.set");
+  assert.deepEqual(parsed.new_value, {
+    namespace: "review",
+    payload: { label: "important" },
+  });
+});
+
 test("dashboard context event parser accepts backend context part payloads", () => {
   const parsed = parseDashboardContextEventData({
     id: "88888888-8888-4888-8888-888888888888",
diff --git a/ergon-dashboard/tests/contracts/frontend-regressions.contract.test.ts b/ergon-dashboard/tests/contracts/frontend-regressions.contract.test.ts
index e5879183c..826bee8cf 100644
--- a/ergon-dashboard/tests/contracts/frontend-regressions.contract.test.ts
+++ b/ergon-dashboard/tests/contracts/frontend-regressions.contract.test.ts
@@ -18,7 +18,7 @@ test("experiment detail sample table exposes each row as sample navigation", ()
   const source = readFileSync("src/components/experiments/SampleTable.tsx", "utf8");
 
   assert.match(source, /data-testid=\{`experiment-sample-row-\$\{sample\.sampleId\}`\}/);
-  assert.match(source, /href=\{`\/samples\/\$\{sample\.sampleId\}\/detail`\}/);
+  assert.match(source, /href=\{`\/samples\/\$\{sample\.sampleId\}`\}/);
 });
 
 test("run workspace can collapse the bottom activity timeline", () => {
@@ -46,9 +46,9 @@ test("run workspace does not render the task inspection placeholder", () => {
   assert.doesNotMatch(source, /data-testid="workspace-launcher"/);
 });
 
-test("run workspace links back to the owning experiment detail", () => {
+test("sample workspace links back to the owning experiment detail", () => {
   const source = readFileSync("src/components/sample/SampleWorkspacePage.tsx", "utf8");
 
-  assert.match(source, /const experimentHref = runState\?\.definitionId \? `\/experiments\/\$\{runState\.definitionId\}` : "\/experiments"/);
+  assert.match(source, /const experimentHref = runState\?\.experimentId \? `\/experiments\/\$\{runState\.experimentId\}` : "\/experiments"/);
   assert.match(source, /href=\{experimentHref\}/);
 });
diff --git a/ergon-dashboard/tests/contracts/server-data.contract.test.ts b/ergon-dashboard/tests/contracts/server-data.contract.test.ts
index 48d63141d..56c090084 100644
--- a/ergon-dashboard/tests/contracts/server-data.contract.test.ts
+++ b/ergon-dashboard/tests/contracts/server-data.contract.test.ts
@@ -65,8 +65,7 @@ test("run list server data applies list filters and parses index summary fields"
           completed_at: "2026-05-20T12:10:00Z",
           latest_activity_at: "2026-05-20T12:10:00Z",
           duration_seconds: 600,
-          definition_id: "11111111-1111-1111-1111-111111111111",
-          definition_name: "MiniWob comparison",
+          experiment_id: "11111111-1111-1111-1111-111111111111",
           experiment: "alpha",
           benchmark_type: "miniwob",
           instance_key: "task-1",
@@ -92,7 +91,7 @@ test("run list server data applies list filters and parses index summary fields"
       limit: 25,
       offset: 50,
       status: "completed",
-      definitionId: "11111111-1111-1111-1111-111111111111",
+      experimentId: "11111111-1111-1111-1111-111111111111",
       experiment: "alpha",
     });
 
@@ -100,11 +99,11 @@ test("run list server data applies list filters and parses index summary fields"
     assert.match(requestedUrl, /limit=25/);
     assert.match(requestedUrl, /offset=50/);
     assert.match(requestedUrl, /status=completed/);
-    assert.match(requestedUrl, /definition_id=11111111-1111-1111-1111-111111111111/);
+    assert.match(requestedUrl, /experiment_id=11111111-1111-1111-1111-111111111111/);
     assert.match(requestedUrl, /experiment=alpha/);
     assert.equal(result.ok, true);
     assert.equal(result.ok && result.data[0].name, "alpha task 1");
-    assert.equal(result.ok && result.data[0].definition_name, "MiniWob comparison");
+    assert.equal(result.ok && result.data[0].experiment_id, "11111111-1111-1111-1111-111111111111");
     assert.equal(result.ok && result.data[0].total_tasks, 3);
     assert.deepEqual(result.ok && result.data[0].metrics, { pass_rate: 0.9 });
   } finally {
diff --git a/ergon-dashboard/tests/e2e/_shared/smoke.ts b/ergon-dashboard/tests/e2e/_shared/smoke.ts
index 755db925b..21bf9b296 100644
--- a/ergon-dashboard/tests/e2e/_shared/smoke.ts
+++ b/ergon-dashboard/tests/e2e/_shared/smoke.ts
@@ -18,7 +18,7 @@ import * as path from "node:path";
 
 import { expect, Locator, Page, test } from "@playwright/test";
 
-import { BackendHarnessClient, BackendRunState } from "../../helpers/backendHarnessClient";
+import { BackendHarnessClient, BackendSampleState } from "../../helpers/backendHarnessClient";
 import { EXPECTED_NESTED_SUBTASK_SLUGS, EXPECTED_SUBTASK_SLUGS } from "./expected";
 
 export interface SmokeSpecConfig {
@@ -74,10 +74,10 @@ function graphElementForTask(page: Page, taskId: string): Locator {
 
 async function selectRenderedGraphTask(
   page: Page,
-  state: BackendRunState,
+  state: BackendSampleState,
   sampleId: string,
   evaluatedTaskIds: Set<string>,
-): Promise<BackendRunState["graph_nodes"][number]> {
+): Promise<BackendSampleState["graph_nodes"][number]> {
   const candidates = [
     ...state.graph_nodes.filter((node) => node.level > 0 && node.task_slug === "d_root"),
     ...state.graph_nodes.filter((node) => node.level > 0 && evaluatedTaskIds.has(node.id)),
@@ -125,7 +125,7 @@ async function expectNoTimelinePlaybackControls(page: Page): Promise<void> {
 
 async function assertRunWorkspace(
   page: Page,
-  state: BackendRunState,
+  state: BackendSampleState,
   sampleId: string,
 ): Promise<void> {
   await expect(page.getByTestId("sample-header")).toBeVisible();
@@ -211,7 +211,7 @@ export function defineSmokeSpec(cfg: SmokeSpecConfig): void {
   test.describe(`${cfg.env} canonical smoke`, () => {
     for (const { sample_id, kind } of experimentRuns) {
       test(`run ${sample_id} (${kind})`, async ({ page }) => {
-        const state = await client.getRunState(sample_id);
+        const state = await client.getSampleState(sample_id);
 
         // Backend-DTO assertions are the load-bearing contract.  The UI
         // assertions below use graph-canvas + page-load + screenshot
@@ -306,8 +306,8 @@ export function defineSmokeSpec(cfg: SmokeSpecConfig): void {
     }
 
     test(`experiment ${experimentKey} grouping lists all runs`, async () => {
-      const groupedRuns = await client.getExperimentRuns(experimentKey);
-      expect(groupedRuns.length).toBeGreaterThanOrEqual(experimentRuns.length);
+      const groupedSamples = await client.getExperimentSamples(experimentKey);
+      expect(groupedSamples.length).toBeGreaterThanOrEqual(experimentRuns.length);
     });
   });
 }
diff --git a/ergon-dashboard/tests/fixtures/mas-samples/concurrent-mas-run.json b/ergon-dashboard/tests/fixtures/mas-samples/concurrent-mas-run.json
index a17f16fd6..cb8b180f4 100644
--- a/ergon-dashboard/tests/fixtures/mas-samples/concurrent-mas-run.json
+++ b/ergon-dashboard/tests/fixtures/mas-samples/concurrent-mas-run.json
@@ -2,7 +2,7 @@
   "name": "concurrent-mas-run",
   "runState": {
     "id": "99999999-9999-4999-8999-999999999999",
-    "definitionId": "33333333-3333-4333-8333-333333333333",
+    "experimentId": "33333333-3333-4333-8333-333333333333",
     "name": "Concurrent MAS run",
     "status": "executing",
     "rootTaskId": "10000000-0000-4000-8000-000000000001",
diff --git a/ergon-dashboard/tests/helpers/backendHarnessClient.ts b/ergon-dashboard/tests/helpers/backendHarnessClient.ts
index ffa90b2d5..2218822ea 100644
--- a/ergon-dashboard/tests/helpers/backendHarnessClient.ts
+++ b/ergon-dashboard/tests/helpers/backendHarnessClient.ts
@@ -3,13 +3,13 @@
  * /api/__danger__/test-harness/dashboard/* client in ./testHarnessClient.ts).
  *
  * Hits the FastAPI backend at ERGON_API_BASE_URL. Read-only; smoke specs use this to
- * assert against real run state by polling the backend directly (not
+ * assert against real sample state by polling the backend directly (not
  * through the dashboard's Socket.io stream).
  *
  * Kept narrow — only the DTOs smoke specs need.  Additive-only.
  */
 
-export interface BackendRunState {
+export interface BackendSampleState {
   sample_id: string;
   status: "completed" | "failed" | "cancelled" | "in_progress" | string;
   graph_nodes: {
@@ -44,7 +44,7 @@ export interface BackendRunState {
   context_event_count: number;
 }
 
-export interface BackendExperimentRun {
+export interface BackendExperimentSample {
   sample_id: string;
   status: string;
 }
@@ -52,23 +52,23 @@ export interface BackendExperimentRun {
 export class BackendHarnessClient {
   constructor(private readonly baseUrl: string) {}
 
-  async getRunState(sampleId: string): Promise<BackendRunState> {
+  async getSampleState(sampleId: string): Promise<BackendSampleState> {
     const r = await fetch(
       `${this.baseUrl}/api/__danger__/test-harness/read/samples/${sampleId}/state`,
     );
     if (!r.ok) {
       throw new Error(`harness ${r.status}: ${await r.text()}`);
     }
-    return r.json() as Promise<BackendRunState>;
+    return r.json() as Promise<BackendSampleState>;
   }
 
-  async getExperimentRuns(experiment: string): Promise<BackendExperimentRun[]> {
+  async getExperimentSamples(experiment: string): Promise<BackendExperimentSample[]> {
     const r = await fetch(
       `${this.baseUrl}/api/__danger__/test-harness/read/experiment/${encodeURIComponent(experiment)}/samples`,
     );
     if (!r.ok) {
       throw new Error(`harness ${r.status}: ${await r.text()}`);
     }
-    return r.json() as Promise<BackendExperimentRun[]>;
+    return r.json() as Promise<BackendExperimentSample[]>;
   }
 }
diff --git a/ergon-dashboard/tests/helpers/dashboardFixtures.ts b/ergon-dashboard/tests/helpers/dashboardFixtures.ts
index aed9f6684..01c614e03 100644
--- a/ergon-dashboard/tests/helpers/dashboardFixtures.ts
+++ b/ergon-dashboard/tests/helpers/dashboardFixtures.ts
@@ -11,7 +11,7 @@ import { TaskStatus } from "../../src/lib/types";
 
 export const FIXTURE_IDS = {
   sampleId: "22222222-2222-4222-8222-222222222222",
-  definitionId: "33333333-3333-4333-8333-333333333333",
+  experimentId: "33333333-3333-4333-8333-333333333333",
   rootTaskId: "task-root",
   exploreTaskId: "task-explore",
   solveTaskId: "task-solve",
@@ -30,7 +30,7 @@ export const FIXTURE_IDS = {
 } as const;
 
 export const CONCURRENT_MAS_FIXTURE_IDS = {
-  definitionId: "33333333-3333-4333-8333-333333333333",
+  experimentId: "33333333-3333-4333-8333-333333333333",
   sampleId: "99999999-9999-4999-8999-999999999999",
   searchTaskId: "10000000-0000-4000-8000-000000000002",
   checkTaskId: "10000000-0000-4000-8000-000000000003",
@@ -142,7 +142,7 @@ function serializedRunState(): SerializedSampleWorkspaceState {
 
   return {
     id: FIXTURE_IDS.sampleId,
-    definitionId: FIXTURE_IDS.definitionId,
+    experimentId: FIXTURE_IDS.experimentId,
     name: "parallel",
     status: "executing",
     tasks: {
@@ -458,7 +458,7 @@ export function createDashboardSeed(): DashboardHarnessSeedPayload {
   const runState = serializedRunState();
   const experimentDetail = {
     experiment: {
-      definition_id: FIXTURE_IDS.definitionId,
+      experiment_id: FIXTURE_IDS.experimentId,
       name: "minif2f smoke n=3",
       description: null,
       benchmark_type: "minif2f",
@@ -489,7 +489,7 @@ export function createDashboardSeed(): DashboardHarnessSeedPayload {
     runs: [
       {
         sample_id: FIXTURE_IDS.sampleId,
-        definition_id: FIXTURE_IDS.definitionId,
+        experiment_id: FIXTURE_IDS.experimentId,
         benchmark_type: "minif2f",
         instance_key: "algebra_sample",
         status: "completed",
@@ -551,7 +551,7 @@ export function createDashboardSeed(): DashboardHarnessSeedPayload {
   const concurrent = createConcurrentMasSeedOnly();
   return {
     experimentDetails: {
-      [FIXTURE_IDS.definitionId]: experimentDetail,
+      [FIXTURE_IDS.experimentId]: experimentDetail,
       ...(concurrent.experimentDetails ?? {}),
     },
     runs: [runState, ...(concurrent.runs ?? [])],
diff --git a/ergon-dashboard/tests/helpers/testHarnessClient.ts b/ergon-dashboard/tests/helpers/testHarnessClient.ts
index e0f2d95ef..9def81dac 100644
--- a/ergon-dashboard/tests/helpers/testHarnessClient.ts
+++ b/ergon-dashboard/tests/helpers/testHarnessClient.ts
@@ -16,17 +16,17 @@ export interface TestEvaluationDto {
   reason: string;
 }
 
-export interface TestGraphMutationDto {
+export interface TestSampleRuntimeEventDto {
   sequence: number;
-  mutation_type: string;
+  event_type: string;
   target_task_slug: string | null;
 }
 
-export interface TestRunStateDto {
+export interface TestSampleStateDto {
   sample_id: string;
   status: string;
   graph_nodes: TestGraphNodeDto[];
-  mutations: TestGraphMutationDto[];
+  events: TestSampleRuntimeEventDto[];
   evaluations: TestEvaluationDto[];
   executions: {
     task_slug: string | null;
@@ -34,7 +34,7 @@ export interface TestRunStateDto {
     error: string | null;
   }[];
   execution_count: number;
-  mutation_count: number;
+  event_count: number;
   resource_count: number;
   thread_count: number;
   context_event_count: number;
@@ -46,15 +46,15 @@ export class BackendHarnessClient {
     private readonly baseUrl: string,
   ) {}
 
-  async getRunState(sampleId: string): Promise<TestRunStateDto> {
+  async getSampleState(sampleId: string): Promise<TestSampleStateDto> {
     const response = await this.request.get(
       `${this.baseUrl}/api/__danger__/test-harness/read/samples/${sampleId}/state`,
     );
     if (!response.ok()) {
       throw new Error(
-        `BackendHarnessClient.getRunState failed: ${response.status()} ${await response.text()}`,
+        `BackendHarnessClient.getSampleState failed: ${response.status()} ${await response.text()}`,
       );
     }
-    return (await response.json()) as TestRunStateDto;
+    return (await response.json()) as TestSampleStateDto;
   }
 }
diff --git a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/benchmark.py b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/benchmark.py
index 37c01b8f1..2b51d1f35 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/benchmark.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/benchmark.py
@@ -8,7 +8,7 @@
 from collections.abc import Callable, Iterator, Mapping, Sequence
 from typing import Any, ClassVar
 
-from ergon_core.api import Benchmark, BenchmarkRequirements, Task
+from ergon_core.api import Benchmark, Task
 from ergon_core.api.rubric import Evaluator
 from ergon_core.api.sandbox import Sandbox
 from ergon_core.api.worker import Worker
@@ -54,10 +54,6 @@ class GDPEvalBenchmark(Benchmark):
 
     type_slug: ClassVar[str] = "gdpeval"
     task_payload_model: ClassVar[type[GDPTaskConfig]] = GDPTaskConfig
-    onboarding_deps: ClassVar[BenchmarkRequirements] = BenchmarkRequirements(
-        e2b=True,
-        extras=("ergon-builtins[data]",),
-    )
     required_packages: ClassVar[list[str]] = ["pandas", "huggingface_hub"]
     install_hint: ClassVar[str] = "pip install 'ergon-builtins[data]'"
 
diff --git a/ergon_builtins/ergon_builtins/benchmarks/minif2f/benchmark.py b/ergon_builtins/ergon_builtins/benchmarks/minif2f/benchmark.py
index dc1135f17..a3d238a43 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/minif2f/benchmark.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/minif2f/benchmark.py
@@ -11,7 +11,7 @@
 from pathlib import Path
 from typing import Any, ClassVar
 
-from ergon_core.api import Benchmark, BenchmarkRequirements, Task
+from ergon_core.api import Benchmark, Task
 from ergon_core.api.rubric import Evaluator
 from ergon_core.api.sandbox import Sandbox
 from ergon_core.api.worker import Worker
@@ -48,7 +48,6 @@ class MiniF2FBenchmark(Benchmark):
 
     type_slug: ClassVar[str] = "minif2f"
     task_payload_model: ClassVar[type[MiniF2FTaskPayload]] = MiniF2FTaskPayload
-    onboarding_deps: ClassVar[BenchmarkRequirements] = BenchmarkRequirements(e2b=True)
 
     def __init__(
         self,
diff --git a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/benchmark.py b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/benchmark.py
index 1e28e4fe3..47eaa36b8 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/benchmark.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/benchmark.py
@@ -8,7 +8,7 @@
 from typing import Any, ClassVar
 
 from datasets import load_dataset
-from ergon_core.api import Benchmark, BenchmarkRequirements, Task
+from ergon_core.api import Benchmark, Task
 from ergon_core.api.rubric import Evaluator
 from ergon_core.api.sandbox import Sandbox
 from ergon_core.api.worker import Worker
@@ -51,10 +51,6 @@ class ResearchRubricsBenchmark(Benchmark):
     type_slug: ClassVar[str] = "researchrubrics"
     dataset_name: ClassVar[str] = "ScaleAI/researchrubrics"
     task_payload_model: ClassVar[type[ResearchRubricsTaskPayload]] = ResearchRubricsTaskPayload
-    onboarding_deps: ClassVar[BenchmarkRequirements] = BenchmarkRequirements(
-        extras=("ergon-builtins[data]",),
-        optional_keys=("EXA_API_KEY",),
-    )
     required_packages: ClassVar[list[str]] = ["datasets", "huggingface_hub"]
     install_hint: ClassVar[str] = "pip install 'ergon-builtins[data]'"
 
diff --git a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/benchmark.py b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/benchmark.py
index 2e661e447..61992360a 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/benchmark.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/benchmark.py
@@ -10,7 +10,7 @@
 from typing import Any, ClassVar
 
 from datasets import load_dataset
-from ergon_core.api import Benchmark, BenchmarkRequirements, Task
+from ergon_core.api import Benchmark, Task
 from ergon_core.api.rubric import Evaluator
 from ergon_core.api.sandbox import Sandbox
 from ergon_core.api.worker import Worker
@@ -50,10 +50,6 @@ class SweBenchVerifiedBenchmark(Benchmark):
 
     type_slug: ClassVar[str] = "swebench-verified"
     task_payload_model: ClassVar[type[SWEBenchTaskPayload]] = SWEBenchTaskPayload
-    onboarding_deps: ClassVar[BenchmarkRequirements] = BenchmarkRequirements(
-        e2b=True,
-        extras=("ergon-builtins[data]",),
-    )
 
     def __init__(
         self,
diff --git a/ergon_builtins/ergon_builtins/toolkits/subagents/toolkit.py b/ergon_builtins/ergon_builtins/toolkits/subagents/toolkit.py
index 94f954d22..ffce13eda 100644
--- a/ergon_builtins/ergon_builtins/toolkits/subagents/toolkit.py
+++ b/ergon_builtins/ergon_builtins/toolkits/subagents/toolkit.py
@@ -49,10 +49,9 @@ class SubtaskLifecycleToolkit:
     descendant before calling runtime task services, so the toolkit keeps
     only response-shaping and UUID parsing logic here.
 
-    ``definition_id`` is NOT captured here --- the service resolves it
-    from ``sample_id`` at dispatch time, keeping the tool surface
-    thin and eliminating a class of stale-id bugs when definitions are
-    reloaded mid-run.
+    The toolkit only captures sample and task identity. Component
+    bindings are read from the materialized sample graph at dispatch
+    time, keeping the tool surface thin and avoiding stale runtime state.
     """
 
     def __init__(
diff --git a/ergon_builtins/tests/fixtures/toy_workflow.py b/ergon_builtins/tests/fixtures/toy_workflow.py
index f59aebe5d..c25fef8e0 100644
--- a/ergon_builtins/tests/fixtures/toy_workflow.py
+++ b/ergon_builtins/tests/fixtures/toy_workflow.py
@@ -11,7 +11,6 @@
 from ergon_core.core.application.runtime import management as management_module
 from ergon_core.core.application.runtime.task_inspection import TaskInspectionService
 from ergon_core.core.application.runtime.task_management import TaskManagementService
-from ergon_core.core.persistence.definitions.models import ExperimentDefinitionTask
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.persistence.shared.enums import SampleStatus
 from ergon_core.core.persistence.telemetry.models import SampleRecord
@@ -61,7 +60,7 @@ async def graph_mutation(self, row: object) -> None:
         return None
 
 
-async def _dispatch_task_ready(sample_id: UUID, definition_id: UUID, task_id: UUID) -> None:
+async def _dispatch_task_ready(sample_id: UUID, task_id: UUID) -> None:
     return None
 
 
@@ -101,8 +100,8 @@ def edges(self) -> list[SampleGraphEdge]:
             ).all()
         )
 
-    def definition_tasks(self) -> list[ExperimentDefinitionTask]:
-        return list(self.session.exec(select(ExperimentDefinitionTask)).all())
+    def dynamic_nodes(self) -> list[SampleGraphNode]:
+        return [node for node in self.nodes() if node.is_dynamic]
 
 
 def make_toy_workflow_harness(monkeypatch: pytest.MonkeyPatch) -> ToyWorkflowHarness:
@@ -120,7 +119,6 @@ def make_toy_workflow_harness(monkeypatch: pytest.MonkeyPatch) -> ToyWorkflowHar
     )
 
     sample_id = uuid4()
-    definition_id = uuid4()
     parent_task = Task(
         task_slug="parent",
         instance_key="sample-1",
@@ -132,7 +130,6 @@ def make_toy_workflow_harness(monkeypatch: pytest.MonkeyPatch) -> ToyWorkflowHar
     session.add(
         SampleRecord(
             id=sample_id,
-            definition_id=definition_id,
             benchmark_type="toy",
             instance_key="sample-1",
             worker_team_json={},
@@ -174,7 +171,6 @@ def make_toy_workflow_harness(monkeypatch: pytest.MonkeyPatch) -> ToyWorkflowHar
         sample_id=sample_id,
         task_id=parent.task_id,
         execution_id=uuid4(),
-        definition_id=definition_id,
         sandbox_id="toy-sandbox-id",
         task_mgmt=TaskManagementService(
             dashboard_emitter=_DashboardEmitter(),
diff --git a/ergon_builtins/tests/integration/tools/test_subtask_lifecycle_toolkit.py b/ergon_builtins/tests/integration/tools/test_subtask_lifecycle_toolkit.py
index 308085653..7dd84e9fa 100644
--- a/ergon_builtins/tests/integration/tools/test_subtask_lifecycle_toolkit.py
+++ b/ergon_builtins/tests/integration/tools/test_subtask_lifecycle_toolkit.py
@@ -13,18 +13,18 @@ async def test_subtask_lifecycle_toolkit_spawns_dynamic_object_bound_child(
     toy_workflow_harness,
 ) -> None:
     toolkit = SubtaskLifecycleToolkit(context=toy_workflow_harness.context)
-    spawn_task = next(tool for tool in toolkit.get_tools() if tool.__name__ == "spawn_task")
+    add_subtask = next(tool for tool in toolkit.get_tools() if tool.__name__ == "add_subtask")
     task = toy_workflow_harness.child_task(task_slug="typed-child", description="Typed child")
 
-    result = await spawn_task(task)
+    result = await add_subtask(task)
     child = next(node for node in toy_workflow_harness.nodes() if node.task_slug == "typed-child")
 
     assert result.kind == "success"
-    assert result.task_id == child.task_id
+    assert result.node_id == child.task_id
     assert child.is_dynamic is True
     assert child.task_json["task_slug"] == "typed-child"
     assert child.task_json["worker"]["_type"].endswith(":ToyWorker")
-    assert toy_workflow_harness.definition_tasks() == []
+    assert toy_workflow_harness.dynamic_nodes() == [child]
 
 
 @pytest.mark.asyncio
diff --git a/ergon_builtins/tests/integration/tools/test_workflow_command_adapter.py b/ergon_builtins/tests/integration/tools/test_workflow_command_adapter.py
index e73d8a11b..4ae810755 100644
--- a/ergon_builtins/tests/integration/tools/test_workflow_command_adapter.py
+++ b/ergon_builtins/tests/integration/tools/test_workflow_command_adapter.py
@@ -61,7 +61,7 @@ async def test_workflow_command_spawns_dynamic_object_bound_child(
     assert child.task_json["_type"].endswith(":Task")
     assert child.task_json["worker"]["_type"].endswith(":ToyWorker")
     assert child.task_json["sandbox"]["_type"].endswith(":ToySandbox")
-    assert toy_workflow_harness.definition_tasks() == []
+    assert toy_workflow_harness.dynamic_nodes() == [child]
 
 
 @pytest.mark.asyncio
@@ -85,7 +85,7 @@ async def test_agent_workflow_tool_spawns_dynamic_object_bound_child(
     assert child.is_dynamic is True
     assert child.task_slug == "tool-child"
     assert child.task_json["worker"]["_type"].endswith(":ToyWorker")
-    assert toy_workflow_harness.definition_tasks() == []
+    assert toy_workflow_harness.dynamic_nodes() == [child]
 
 
 @pytest.mark.asyncio
diff --git a/ergon_builtins/tests/unit/state/test_benchmark_contract.py b/ergon_builtins/tests/unit/state/test_benchmark_contract.py
index 7792083f6..4bc6e4acc 100644
--- a/ergon_builtins/tests/unit/state/test_benchmark_contract.py
+++ b/ergon_builtins/tests/unit/state/test_benchmark_contract.py
@@ -4,7 +4,7 @@
 from ergon_builtins.benchmarks.minif2f.benchmark import MiniF2FBenchmark
 from ergon_builtins.benchmarks.researchrubrics.benchmark import ResearchRubricsBenchmark
 from ergon_builtins.benchmarks.swebench_verified.benchmark import SweBenchVerifiedBenchmark
-from ergon_core.api.benchmark import Benchmark, BenchmarkRequirements, EmptyTaskPayload, Task
+from ergon_core.api.benchmark import Benchmark, EmptyTaskPayload, Task
 from pydantic import BaseModel, ValidationError
 from ergon_core.test_support.task_factory import TestSandbox, TestWorker
 
@@ -18,21 +18,8 @@
 }
 
 
-def _require_onboarding_deps(slug: str, cls: type[Benchmark]) -> BenchmarkRequirements:
-    deps = cls.onboarding_deps
-    assert isinstance(deps, BenchmarkRequirements), (
-        f"Benchmark '{slug}' ({cls.__qualname__}).onboarding_deps is not a "
-        f"BenchmarkRequirements instance; got {type(deps)!r}."
-    )
-    return deps
-
-
-class TestBenchmarkOnboardingDepsContract:
-    """Every importable benchmark must declare onboarding_deps."""
-
-    @pytest.mark.parametrize("slug, cls", [*CORE_BENCHMARKS.items(), *DATA_BENCHMARKS.items()])
-    def test_benchmarks_have_onboarding_deps(self, slug: str, cls: type[Benchmark]) -> None:
-        _require_onboarding_deps(slug, cls)
+class TestBenchmarkDependencyMetadataContract:
+    """Every importable benchmark exposes current runtime dependency metadata."""
 
     @pytest.mark.parametrize("slug, cls", [*CORE_BENCHMARKS.items(), *DATA_BENCHMARKS.items()])
     def test_benchmarks_declare_payload_models(self, slug: str, cls: type[Benchmark]) -> None:
@@ -40,15 +27,19 @@ def test_benchmarks_declare_payload_models(self, slug: str, cls: type[Benchmark]
             f"Benchmark '{slug}' ({cls.__qualname__}) must declare a Pydantic task_payload_model."
         )
 
-    def test_onboarding_deps_is_frozen(self) -> None:
-        for cls in CORE_BENCHMARKS.values():
-            deps = cls.onboarding_deps
-            with pytest.raises(ValidationError):
-                setattr(deps, "e2b", not deps.e2b)
+    @pytest.mark.parametrize("slug, cls", [*CORE_BENCHMARKS.items(), *DATA_BENCHMARKS.items()])
+    def test_required_packages_are_plain_strings(self, slug: str, cls: type[Benchmark]) -> None:
+        assert isinstance(cls.required_packages, list), (
+            f"Benchmark '{slug}' ({cls.__qualname__}).required_packages must be a list."
+        )
+        assert all(isinstance(package, str) for package in cls.required_packages), (
+            f"Benchmark '{slug}' ({cls.__qualname__}).required_packages must contain strings."
+        )
 
-    def test_known_e2b_benchmarks(self) -> None:
-        assert MiniF2FBenchmark.onboarding_deps.e2b is True
-        assert SweBenchVerifiedBenchmark.onboarding_deps.e2b is True
+    def test_data_benchmarks_with_package_deps_include_install_hint(self) -> None:
+        for cls in DATA_BENCHMARKS.values():
+            if cls.required_packages:
+                assert cls.install_hint
 
 
 class TestBenchmarkSubclassEnforcement:
diff --git a/ergon_builtins/tests/unit/workers/test_react_worker_contract.py b/ergon_builtins/tests/unit/workers/test_react_worker_contract.py
index 3afb7fc4f..139d91e2e 100644
--- a/ergon_builtins/tests/unit/workers/test_react_worker_contract.py
+++ b/ergon_builtins/tests/unit/workers/test_react_worker_contract.py
@@ -198,7 +198,6 @@ def _minimal_task() -> Task:
 def _minimal_context() -> WorkerContext:
     return WorkerContext(
         sample_id=UUID(int=3),
-        definition_id=UUID(int=4),
         execution_id=UUID(int=5),
         sandbox_id="test-sandbox",
         task_id=UUID(int=6),
diff --git a/ergon_core/ergon_core/api/__init__.py b/ergon_core/ergon_core/api/__init__.py
index fe4a49e89..eeecfbafc 100644
--- a/ergon_core/ergon_core/api/__init__.py
+++ b/ergon_core/ergon_core/api/__init__.py
@@ -2,7 +2,6 @@
 
 from ergon_core.api.benchmark import (
     Benchmark,
-    BenchmarkRequirements,
     EmptyTaskPayload,
     Task,
 )
@@ -55,7 +54,6 @@
 
 __all__ = [
     "Benchmark",
-    "BenchmarkRequirements",
     "AwaitCompletionNotSupportedError",
     "ContainmentViolation",
     "Criterion",
diff --git a/ergon_core/ergon_core/api/benchmark/__init__.py b/ergon_core/ergon_core/api/benchmark/__init__.py
index b4205ee4d..09016f9e5 100644
--- a/ergon_core/ergon_core/api/benchmark/__init__.py
+++ b/ergon_core/ergon_core/api/benchmark/__init__.py
@@ -1,7 +1,6 @@
 """Public benchmark authoring API."""
 
 from ergon_core.api.benchmark.benchmark import Benchmark
-from ergon_core.api.benchmark.requirements import BenchmarkRequirements
 from ergon_core.api.benchmark.task import EmptyTaskPayload, Task
 
-__all__ = ["Benchmark", "BenchmarkRequirements", "Task", "EmptyTaskPayload"]
+__all__ = ["Benchmark", "Task", "EmptyTaskPayload"]
diff --git a/ergon_core/ergon_core/api/benchmark/requirements.py b/ergon_core/ergon_core/api/benchmark/requirements.py
deleted file mode 100644
index 1a1cd3d82..000000000
--- a/ergon_core/ergon_core/api/benchmark/requirements.py
+++ /dev/null
@@ -1,11 +0,0 @@
-"""Onboarding dependency descriptor for Benchmark subclasses."""
-
-from pydantic import BaseModel
-
-
-class BenchmarkRequirements(BaseModel, frozen=True):
-    """Onboarding requirements for a single benchmark."""
-
-    e2b: bool = False
-    extras: tuple[str, ...] = ()
-    optional_keys: tuple[str, ...] = ()
diff --git a/ergon_core/ergon_core/api/worker/context.py b/ergon_core/ergon_core/api/worker/context.py
index 954dc06cf..76a63dd42 100644
--- a/ergon_core/ergon_core/api/worker/context.py
+++ b/ergon_core/ergon_core/api/worker/context.py
@@ -71,15 +71,6 @@ class WorkerContext(BaseModel):
     task_id: UUID = Field(
         description="SampleGraphNode.task_id — canonical runtime task identity.",
     )
-    definition_id: UUID | None = Field(
-        default=None,
-        description=(
-            "ExperimentDefinition.id — the experiment template that governs "
-            "this run's worker bindings, evaluator bindings, and benchmark "
-            "config. Used by delegation tools to resolve assigned_worker_slug "
-            "to worker_type."
-        ),
-    )
     execution_id: UUID
     sandbox_id: str
     metadata: dict[str, Any] = Field(default_factory=dict)
@@ -109,7 +100,6 @@ def _for_job(
         sample_id: UUID,
         task_id: UUID,
         execution_id: UUID,
-        definition_id: UUID | None,
         sandbox_id: str,
         task_mgmt: TaskManagementServiceAlias,
         task_inspect: TaskInspectionServiceAlias,
@@ -127,7 +117,6 @@ def _for_job(
             sample_id=sample_id,
             task_id=task_id,
             execution_id=execution_id,
-            definition_id=definition_id,
             sandbox_id=sandbox_id,
             task_mgmt=task_mgmt,
             task_inspect=task_inspect,
diff --git a/ergon_core/ergon_core/core/application/evaluation/service.py b/ergon_core/ergon_core/core/application/evaluation/service.py
index 51f2312a3..1b9b1fee8 100644
--- a/ergon_core/ergon_core/core/application/evaluation/service.py
+++ b/ergon_core/ergon_core/core/application/evaluation/service.py
@@ -14,8 +14,6 @@
     aggregate_evaluation_scores,
 )
 from ergon_core.core.application.evaluation.summary import EvaluationSummary
-from ergon_core.core.infrastructure.inngest.errors import ContractViolationError
-from ergon_core.core.persistence.definitions.models import ExperimentDefinitionEvaluator
 from ergon_core.core.persistence.shared.db import get_session
 from ergon_core.core.persistence.shared.ids import new_id
 from ergon_core.core.persistence.telemetry.models import (
@@ -114,13 +112,12 @@ async def persist_success(
         result = service_result.result
         session = get_session()
         try:
-            evaluator_id = self.lookup_evaluator_id(session, sample_id, binding_key)
             evaluation = await _create_task_evaluation(
                 session,
                 sample_id=sample_id,
                 task_execution_id=task_execution_id,
                 task_id=task_id,
-                definition_evaluator_id=evaluator_id,
+                evaluator_slug=binding_key,
                 score=result.score,
                 passed=result.passed,
                 feedback=result.feedback,
@@ -160,13 +157,12 @@ async def persist_failure(
         )
         session = get_session()
         try:
-            evaluator_id = self.lookup_evaluator_id(session, sample_id, binding_key)
             await _create_task_evaluation(
                 session,
                 sample_id=sample_id,
                 task_execution_id=task_execution_id,
                 task_id=task_id,
-                definition_evaluator_id=evaluator_id,
+                evaluator_slug=binding_key,
                 score=0.0,
                 passed=False,
                 feedback=f"{error_type}: {exc}",
@@ -177,51 +173,6 @@ async def persist_failure(
         finally:
             session.close()
 
-    def lookup_evaluator_id(
-        self,
-        session: Session,
-        sample_id: UUID,
-        binding_key: str,
-        *,
-        evaluator_type: str | None = None,
-        snapshot_json: dict | None = None,
-    ) -> UUID:
-        """Resolve the ``ExperimentDefinitionEvaluator.id`` for a binding key.
-
-        The eval body receives an id-only payload, so it executes the
-        inline ``task.evaluators[i]`` object and passes only its
-        ``evaluator.name``. The persistence layer needs the normalized
-        evaluator id for the FK on
-        ``sample_task_evaluations.definition_evaluator_id``.
-
-        The normalized evaluator row remains the persistence/read-model
-        target for evaluation summaries, even though runtime dispatch
-        executes the inline evaluator from ``task.evaluators``.
-        """
-
-        run = session.get(SampleRecord, sample_id)
-        if run is None:
-            raise ContractViolationError(
-                f"SampleRecord {sample_id} not found while resolving evaluator id"
-            )
-        evaluator_def = session.exec(
-            select(ExperimentDefinitionEvaluator).where(
-                ExperimentDefinitionEvaluator.experiment_definition_id == run.definition_id,
-                ExperimentDefinitionEvaluator.binding_key == binding_key,
-            )
-        ).first()
-        if evaluator_def is None:
-            evaluator_def = ExperimentDefinitionEvaluator(
-                id=new_id(),
-                experiment_definition_id=run.definition_id,
-                binding_key=binding_key,
-                evaluator_type=evaluator_type or binding_key,
-                snapshot_json=snapshot_json or {},
-            )
-            session.add(evaluator_def)
-            session.flush()
-        return evaluator_def.id
-
     def _refresh_run_evaluation_summary(self, session: Session, sample_id: UUID) -> None:
         run = session.get(SampleRecord, sample_id)
         if run is None:
@@ -252,7 +203,7 @@ async def _create_task_evaluation(
     sample_id: UUID,
     task_execution_id: UUID,
     task_id: UUID,
-    definition_evaluator_id: UUID,
+    evaluator_slug: str,
     score: float | None = None,
     passed: bool | None = None,
     feedback: str | None = None,
@@ -263,7 +214,7 @@ async def _create_task_evaluation(
         sample_id=sample_id,
         task_execution_id=task_execution_id,
         task_id=task_id,
-        definition_evaluator_id=definition_evaluator_id,
+        evaluator_slug=evaluator_slug,
         score=score,
         passed=passed,
         feedback=feedback,
diff --git a/ergon_core/ergon_core/core/application/events/runtime.py b/ergon_core/ergon_core/core/application/events/runtime.py
index beba967f7..26ee5185b 100644
--- a/ergon_core/ergon_core/core/application/events/runtime.py
+++ b/ergon_core/ergon_core/core/application/events/runtime.py
@@ -31,7 +31,6 @@ class TaskReadyEvent(InngestEventContract):
     name: ClassVar[str] = "task/ready"
 
     sample_id: UUID
-    definition_id: UUID | None = None
     task_id: UUID
 
 
@@ -39,7 +38,6 @@ class TaskStartedEvent(InngestEventContract):
     name: ClassVar[str] = "task/started"
 
     sample_id: UUID
-    definition_id: UUID | None = None
     task_id: UUID
     execution_id: UUID
 
@@ -58,7 +56,6 @@ class TaskCancelledEvent(InngestEventContract):
     name: ClassVar[str] = "task/cancelled"
 
     sample_id: UUID
-    definition_id: UUID | None = None
     task_id: UUID
     execution_id: UUID | None
     cause: CancelCause
@@ -70,7 +67,6 @@ class TaskCompletedEvent(InngestEventContract):
     name: ClassVar[str] = "task/completed"
 
     sample_id: UUID
-    definition_id: UUID | None = None
     task_id: UUID
     execution_id: UUID
     sandbox_id: str
@@ -80,7 +76,6 @@ class TaskFailedEvent(InngestEventContract):
     name: ClassVar[str] = "task/failed"
 
     sample_id: UUID
-    definition_id: UUID | None = None
     task_id: UUID
     execution_id: UUID
     error: str
@@ -91,7 +86,6 @@ class WorkflowStartedEvent(InngestEventContract):
     name: ClassVar[str] = "workflow/started"
 
     sample_id: UUID
-    definition_id: UUID | None = None
 
     def model_dump(self, *args: Any, **kwargs: Any) -> dict[str, Any]:
         kwargs.setdefault("exclude_none", True)
@@ -102,12 +96,10 @@ class WorkflowCompletedEvent(InngestEventContract):
     name: ClassVar[str] = "workflow/completed"
 
     sample_id: UUID
-    definition_id: UUID | None = None
 
 
 class WorkflowFailedEvent(InngestEventContract):
     name: ClassVar[str] = "workflow/failed"
 
     sample_id: UUID
-    definition_id: UUID | None = None
     error: str
diff --git a/ergon_core/ergon_core/core/application/experiments/__init__.py b/ergon_core/ergon_core/core/application/experiments/__init__.py
index 6dd8aa9e4..c9c2ef67b 100644
--- a/ergon_core/ergon_core/core/application/experiments/__init__.py
+++ b/ergon_core/ergon_core/core/application/experiments/__init__.py
@@ -1,9 +1 @@
-__all__ = ["run_experiment"]
-
-
-def __getattr__(name: str) -> object:
-    if name == "run_experiment":
-        from ergon_core.core.application.experiments.service import run_experiment
-
-        return run_experiment
-    raise AttributeError(name)
+__all__: list[str] = []
diff --git a/ergon_core/ergon_core/core/application/experiments/definition_writer.py b/ergon_core/ergon_core/core/application/experiments/definition_writer.py
deleted file mode 100644
index d6cb1b7df..000000000
--- a/ergon_core/ergon_core/core/application/experiments/definition_writer.py
+++ /dev/null
@@ -1,247 +0,0 @@
-"""Persist a Benchmark directly into immutable definition rows.
-
-Reads identity fields inline from the live Benchmark object graph: no
-domain Experiment wrapper and no Task template bridge.
-"""
-
-from typing import Any
-from uuid import uuid4
-
-from ergon_core.api.benchmark import Benchmark
-from ergon_core.api.errors import SandboxKindMismatch
-from ergon_core.core.application.experiments.models import DefinitionHandle
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionEvaluator,
-    ExperimentDefinitionInstance,
-    ExperimentDefinitionTask,
-    ExperimentDefinitionTaskAssignment,
-    ExperimentDefinitionTaskDependency,
-    ExperimentDefinitionTaskEvaluator,
-    ExperimentDefinitionWorker,
-)
-from ergon_core.core.persistence.shared.db import get_session
-from ergon_core.core.shared.json_types import JsonObject
-from ergon_core.core.shared.utils import utcnow
-from sqlalchemy.exc import SQLAlchemyError
-
-
-def validate_sandbox_compatibility(benchmark: Benchmark) -> None:
-    """Reject benchmarks whose worker requires a different sandbox type."""
-
-    for tasks in benchmark.build_instances().values():
-        for task in tasks:
-            required = type(task.worker).requires_sandbox
-            if not isinstance(task.sandbox, required):
-                raise SandboxKindMismatch(
-                    task_id=task._task_id if task._task_id else uuid4(),
-                    component=type(task.worker).__name__,
-                    required=required,
-                    actual=type(task.sandbox),
-                )
-
-
-def persist_benchmark(benchmark: Benchmark) -> DefinitionHandle:  # noqa: C901
-    """Persist a configured object-bound Benchmark as a definition row."""
-
-    validate_sandbox_compatibility(benchmark)
-
-    instances_map = benchmark.build_instances()
-    benchmark_type: str = benchmark.type_slug
-    resolved_metadata: dict[str, Any] = dict(benchmark.metadata)  # slopcop: ignore[no-typing-any]
-    now = utcnow()
-    definition_id = uuid4()
-
-    definition_row = ExperimentDefinition(
-        id=definition_id,
-        benchmark_type=benchmark_type,
-        name=benchmark.name,
-        description=benchmark.description,
-        created_by=benchmark.created_by,
-        metadata_json=resolved_metadata,
-        created_at=now,
-    )
-
-    instance_rows: list[ExperimentDefinitionInstance] = []
-    task_rows_by_key: dict[tuple[str, str], ExperimentDefinitionTask] = {}
-
-    for instance_key, tasks in instances_map.items():
-        instance_id = uuid4()
-        instance_rows.append(
-            ExperimentDefinitionInstance(
-                id=instance_id,
-                experiment_definition_id=definition_id,
-                instance_key=instance_key,
-                created_at=now,
-            )
-        )
-        for task in tasks:
-            task_row = ExperimentDefinitionTask(
-                id=uuid4(),
-                experiment_definition_id=definition_id,
-                instance_id=instance_id,
-                task_slug=task.task_slug,
-                description=task.description,
-                task_payload_json=task.task_payload.model_dump(mode="json"),
-                task_json=task.model_dump(mode="json"),
-                created_at=now,
-            )
-            task_rows_by_key[(instance_key, task.task_slug)] = task_row
-
-    for instance_key, tasks in instances_map.items():
-        for task in tasks:
-            if task.parent_task_slug is not None:
-                child = task_rows_by_key[(instance_key, task.task_slug)]
-                parent = task_rows_by_key[(instance_key, task.parent_task_slug)]
-                child.parent_task_id = parent.id
-
-    task_rows = list(task_rows_by_key.values())
-
-    worker_rows_by_key: dict[str, ExperimentDefinitionWorker] = {}
-    worker_snapshot_by_key: dict[str, JsonObject] = {}
-    task_assignment_rows: list[ExperimentDefinitionTaskAssignment] = []
-    for instance_key, tasks in instances_map.items():
-        for task in tasks:
-            task_id = task_rows_by_key[(instance_key, task.task_slug)].id
-            if task_id is None:
-                raise ValueError(f"Task {task.task_slug!r} has no assigned ID for worker binding")
-            worker = task.worker
-            binding_key = worker.type_slug
-            snapshot = worker.model_dump(mode="json")
-            prior_snapshot = worker_snapshot_by_key.get(binding_key)
-            if prior_snapshot is not None and prior_snapshot != snapshot:
-                raise ValueError(
-                    f"Duplicate worker binding {binding_key!r} has conflicting snapshots"
-                )
-            worker_snapshot_by_key[binding_key] = snapshot
-            if binding_key not in worker_rows_by_key:
-                if worker.model is None:
-                    raise ValueError(
-                        f"Worker {binding_key!r} on task {task.task_slug!r} has no model"
-                    )
-                worker_rows_by_key[binding_key] = ExperimentDefinitionWorker(
-                    id=uuid4(),
-                    experiment_definition_id=definition_id,
-                    binding_key=binding_key,
-                    worker_type=worker.type_slug,
-                    model_target=worker.model,
-                    snapshot_json=snapshot,
-                    created_at=now,
-                )
-            task_assignment_rows.append(
-                ExperimentDefinitionTaskAssignment(
-                    id=uuid4(),
-                    experiment_definition_id=definition_id,
-                    task_id=task_id,
-                    worker_binding_key=binding_key,
-                    assignment_type="initial",
-                    created_at=now,
-                )
-            )
-
-    evaluator_rows_by_key: dict[str, ExperimentDefinitionEvaluator] = {}
-    evaluator_snapshot_by_key: dict[str, JsonObject] = {}
-
-    dependency_rows: list[ExperimentDefinitionTaskDependency] = []
-    for instance_key, tasks in instances_map.items():
-        for task in tasks:
-            task_id = task_rows_by_key[(instance_key, task.task_slug)].id
-            if task_id is None:
-                raise ValueError(f"Task {task.task_slug!r} has no assigned ID")
-            for dep_slug in task.dependency_task_slugs:
-                dep_task_id = task_rows_by_key[(instance_key, dep_slug)].id
-                if dep_task_id is None:
-                    raise ValueError(f"Dependency task {dep_slug!r} has no assigned ID")
-                dependency_rows.append(
-                    ExperimentDefinitionTaskDependency(
-                        id=uuid4(),
-                        experiment_definition_id=definition_id,
-                        task_id=task_id,
-                        depends_on_task_id=dep_task_id,
-                        created_at=now,
-                    )
-                )
-
-    task_evaluator_rows: list[ExperimentDefinitionTaskEvaluator] = []
-    for instance_key, tasks in instances_map.items():
-        for task in tasks:
-            task_id = task_rows_by_key[(instance_key, task.task_slug)].id
-            if task_id is None:
-                raise ValueError(
-                    f"Task {task.task_slug!r} has no assigned ID for evaluator binding"
-                )
-            inline_names_for_task: set[str] = set()
-            for index, evaluator in enumerate(task.evaluators):
-                binding_key = evaluator.name or f"inline-{index}"
-                if binding_key in inline_names_for_task:
-                    raise ValueError(
-                        f"Duplicate inline evaluator name {binding_key!r} "
-                        f"on task {task.task_slug!r}"
-                    )
-                inline_names_for_task.add(binding_key)
-
-                snapshot = evaluator.model_dump(mode="json")
-                prior_snapshot = evaluator_snapshot_by_key.get(binding_key)
-                if prior_snapshot is not None and prior_snapshot != snapshot:
-                    raise ValueError(
-                        f"Duplicate inline evaluator name {binding_key!r} "
-                        "has conflicting snapshots in one definition"
-                    )
-                evaluator_snapshot_by_key[binding_key] = snapshot
-                if binding_key not in evaluator_rows_by_key:
-                    evaluator_rows_by_key[binding_key] = ExperimentDefinitionEvaluator(
-                        id=uuid4(),
-                        experiment_definition_id=definition_id,
-                        binding_key=binding_key,
-                        evaluator_type=evaluator.type_slug,
-                        snapshot_json=snapshot,
-                        created_at=now,
-                    )
-                task_evaluator_rows.append(
-                    ExperimentDefinitionTaskEvaluator(
-                        id=uuid4(),
-                        experiment_definition_id=definition_id,
-                        task_id=task_id,
-                        evaluator_binding_key=binding_key,
-                        created_at=now,
-                    )
-                )
-    DefinitionRow = (
-        ExperimentDefinition
-        | ExperimentDefinitionEvaluator
-        | ExperimentDefinitionInstance
-        | ExperimentDefinitionTask
-        | ExperimentDefinitionTaskAssignment
-        | ExperimentDefinitionTaskDependency
-        | ExperimentDefinitionTaskEvaluator
-        | ExperimentDefinitionWorker
-    )
-    all_rows: list[DefinitionRow] = [
-        definition_row,
-        *worker_rows_by_key.values(),
-        *evaluator_rows_by_key.values(),
-        *instance_rows,
-        *task_rows,
-        *task_assignment_rows,
-        *dependency_rows,
-        *task_evaluator_rows,
-    ]
-
-    session = get_session()
-    try:
-        session.add_all(all_rows)
-        session.commit()
-    except SQLAlchemyError:
-        session.rollback()
-        raise
-    finally:
-        session.close()
-
-    return DefinitionHandle(
-        definition_id=definition_id,
-        benchmark_type=benchmark_type,
-        instance_count=len(instance_rows),
-        task_count=len(task_rows),
-        created_at=now,
-        metadata=resolved_metadata,
-    )
diff --git a/ergon_core/ergon_core/core/application/experiments/errors.py b/ergon_core/ergon_core/core/application/experiments/errors.py
index 29dbcf5fc..f3809b140 100644
--- a/ergon_core/ergon_core/core/application/experiments/errors.py
+++ b/ergon_core/ergon_core/core/application/experiments/errors.py
@@ -1,37 +1,5 @@
-"""Errors raised by the experiments domain.
-
-Typed exceptions so callers can `except DefinitionNotFoundError:`
-specifically rather than catching generic `ValueError` and string-
-matching the message. See 07-test-strategy.md § Repository layer
-standard rule 8.
-"""
-
-from uuid import UUID
+"""Errors raised by the experiments domain."""
 
 
 class ExperimentDomainError(Exception):
     """Base for all experiments-domain errors."""
-
-
-class DefinitionNotFoundError(ExperimentDomainError):
-    """Lookup failed for an `ExperimentDefinition` row."""
-
-    def __init__(self, definition_id: UUID) -> None:
-        super().__init__(f"ExperimentDefinition {definition_id} not found")
-        self.definition_id = definition_id
-
-
-class DefinitionTaskNotFoundError(ExperimentDomainError):
-    """Lookup failed for an `ExperimentDefinitionTask` row."""
-
-    def __init__(self, task_id: UUID) -> None:
-        super().__init__(f"ExperimentDefinitionTask {task_id} not found")
-        self.task_id = task_id
-
-
-class DefinitionInstanceNotFoundError(ExperimentDomainError):
-    """Lookup failed for an `ExperimentDefinitionInstance` row."""
-
-    def __init__(self, instance_id: UUID) -> None:
-        super().__init__(f"ExperimentDefinitionInstance {instance_id} not found")
-        self.instance_id = instance_id
diff --git a/ergon_core/ergon_core/core/application/experiments/handles.py b/ergon_core/ergon_core/core/application/experiments/handles.py
deleted file mode 100644
index 00ec41c43..000000000
--- a/ergon_core/ergon_core/core/application/experiments/handles.py
+++ /dev/null
@@ -1,5 +0,0 @@
-"""Compatibility import for experiment handle contracts."""
-
-from ergon_core.core.application.experiments.models import DefinitionHandle
-
-__all__ = ["DefinitionHandle"]
diff --git a/ergon_core/ergon_core/core/application/experiments/launch.py b/ergon_core/ergon_core/core/application/experiments/launch.py
deleted file mode 100644
index f8fba6c60..000000000
--- a/ergon_core/ergon_core/core/application/experiments/launch.py
+++ /dev/null
@@ -1,70 +0,0 @@
-"""Experiment definition launch service."""
-
-from collections.abc import Awaitable, Callable, Mapping
-from uuid import UUID
-
-import inngest
-from ergon_core.core.application.events import WorkflowStartedEvent
-from ergon_core.core.application.experiments.errors import DefinitionNotFoundError
-from ergon_core.core.application.experiments.models import DefinitionHandle, ExperimentRunResult
-from ergon_core.core.application.runtime.sample_lifecycle import (
-    create_run as create_definition_backed_sample,
-)
-from ergon_core.core.infrastructure.inngest.client import inngest_client
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
-from ergon_core.core.persistence.shared.db import get_session
-from ergon_core.core.shared.json_types import JsonValue
-
-WorkflowStartedEmitter = Callable[[UUID, UUID], Awaitable[None]]
-
-
-async def launch_sample(
-    definition_id: UUID,
-    *,
-    assignment_metadata: Mapping[str, JsonValue] | None = None,
-    emit_workflow_started: WorkflowStartedEmitter | None = None,
-) -> ExperimentRunResult:
-    """Materialize a sample directly from an ExperimentDefinition row."""
-
-    emitter = emit_workflow_started or _emit_workflow_started
-    with get_session() as session:
-        definition = session.get(ExperimentDefinition, definition_id)
-        if definition is None:
-            raise DefinitionNotFoundError(definition_id)
-        metadata = definition.parsed_metadata()
-        experiment = metadata.get("experiment")
-        sample = create_definition_backed_sample(
-            DefinitionHandle(
-                definition_id=definition.id,
-                benchmark_type=definition.benchmark_type,
-            ),
-            definition_id=definition.id,
-            instance_key="default",
-            worker_team_json={},
-            evaluator_slug=None,
-            model_target=None,
-            sandbox_slug=None,
-            dependency_extras_json={},
-            assignment_json=dict(assignment_metadata or {}),
-            seed=None,
-            experiment=experiment if isinstance(experiment, str) else None,
-        )
-    await emitter(sample.id, definition_id)
-    return ExperimentRunResult(
-        definition_id=definition_id,
-        sample_ids=[sample.id],
-        definition_ids=[definition_id],
-    )
-
-
-launch_run = launch_sample
-
-
-async def _emit_workflow_started(sample_id: UUID, definition_id: UUID) -> None:
-    event = WorkflowStartedEvent(sample_id=sample_id, definition_id=definition_id)
-    await inngest_client.send(
-        inngest.Event(
-            name=WorkflowStartedEvent.name,
-            data=event.model_dump(mode="json"),
-        )
-    )
diff --git a/ergon_core/ergon_core/core/application/experiments/models.py b/ergon_core/ergon_core/core/application/experiments/models.py
index 6d2d906f3..b269944d9 100644
--- a/ergon_core/ergon_core/core/application/experiments/models.py
+++ b/ergon_core/ergon_core/core/application/experiments/models.py
@@ -1,42 +1,11 @@
 """DTOs and public contracts for experiment services."""
 
-from datetime import datetime
-from typing import Any
 from typing import Self
-from uuid import UUID
 
 from ergon_core.core.shared.json_types import JsonObject
-from ergon_core.core.shared.utils import utcnow
 from pydantic import BaseModel, Field, model_validator
 
 
-class DefinitionHandle(BaseModel):
-    """Rich handle returned after a benchmark definition is persisted."""
-
-    model_config = {"frozen": True}
-
-    definition_id: UUID
-    benchmark_type: str
-    worker_bindings: dict[str, str] = Field(default_factory=dict)
-    evaluator_bindings: dict[str, str] = Field(default_factory=dict)
-    instance_count: int = 0
-    task_count: int = 0
-    created_at: datetime = Field(default_factory=utcnow)
-    metadata: dict[str, Any] = Field(default_factory=dict)  # slopcop: ignore[no-typing-any]
-
-
-class ExperimentRunRequest(BaseModel):
-    definition_id: UUID
-    timeout_seconds: int | None = None
-    wait: bool = True
-
-
-class ExperimentRunResult(BaseModel):
-    definition_id: UUID
-    sample_ids: list[UUID]
-    definition_ids: list[UUID] = Field(default_factory=list)
-
-
 class SampleAssignment(BaseModel):
     instance_key: str
     sample_id: str | None = None
diff --git a/ergon_core/ergon_core/core/application/experiments/service.py b/ergon_core/ergon_core/core/application/experiments/service.py
index 2697d0504..96c63f28a 100644
--- a/ergon_core/ergon_core/core/application/experiments/service.py
+++ b/ergon_core/ergon_core/core/application/experiments/service.py
@@ -1,80 +1,7 @@
-"""Module-level launch for persisted object-bound benchmark definitions."""
+"""Experiment submission service exports."""
 
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable
-from typing import TYPE_CHECKING, Protocol, runtime_checkable
-from uuid import UUID
+from ergon_core.core.application.experiments.submission import ExperimentSubmissionService
 
-from ergon_core.core.application.experiments.models import (
-    DefinitionHandle,
-    ExperimentRunRequest,
-    ExperimentRunResult,
-)
-
-if TYPE_CHECKING:
-    from ergon_core.api.benchmark import Benchmark
-    from ergon_core.api.experiment.experiment import (
-        Experiment,
-        ExperimentSubmitResult,
-    )
-    from ergon_core.api.experiment.sampling import Sampler
-
-WorkflowStartedEmitter = Callable[[UUID, UUID], Awaitable[None]]
-
-
-@runtime_checkable
-class ExperimentSubmissionService(Protocol):
-    # TODO(PR05): replace this protocol with the concrete core submission service
-    # once sample materialization is wired into the runtime path.
-    async def submit(
-        self,
-        *,
-        experiment: "Experiment",
-        k: int,
-        sampler: Sampler,
-        candidate_pool_size: int | None,
-        policy_version: int | None,
-    ) -> "ExperimentSubmitResult": ...
-
-
-def persist_benchmark(benchmark: "Benchmark") -> DefinitionHandle:
-    """Persist a configured object-bound Benchmark as an experiment definition."""
-
-    from ergon_core.core.application.experiments.definition_writer import (
-        persist_benchmark as _persist_benchmark,
-    )
-
-    return _persist_benchmark(benchmark)
-
-
-async def launch_sample(
-    definition_id: UUID,
-    *,
-    emit_workflow_started: WorkflowStartedEmitter | None = None,
-) -> ExperimentRunResult:
-    """Launch a persisted definition while keeping the heavy runtime import lazy."""
-
-    # reason: keep HTTP app imports from cycling through runtime models and public API exports.
-    from ergon_core.core.application.experiments.launch import launch_sample as _launch_sample
-
-    return await _launch_sample(
-        definition_id,
-        emit_workflow_started=emit_workflow_started,
-    )
-
-
-async def run_experiment(
-    request: ExperimentRunRequest,
-    *,
-    emit_workflow_started: WorkflowStartedEmitter | None = None,
-) -> ExperimentRunResult:
-    """Materialize one sample directly from an ExperimentDefinition row."""
-
-    return await launch_sample(
-        request.definition_id,
-        emit_workflow_started=emit_workflow_started,
-    )
-
-
-launch_run = launch_sample
+__all__ = ["ExperimentSubmissionService"]
diff --git a/ergon_core/ergon_core/core/application/runtime/events.py b/ergon_core/ergon_core/core/application/runtime/events.py
index d14588f0f..aeee75c08 100644
--- a/ergon_core/ergon_core/core/application/runtime/events.py
+++ b/ergon_core/ergon_core/core/application/runtime/events.py
@@ -18,7 +18,7 @@
 
 logger = logging.getLogger(__name__)
 
-TaskReadyDispatcher = Callable[[UUID, UUID | None, UUID], Awaitable[None]]
+TaskReadyDispatcher = Callable[[UUID, UUID], Awaitable[None]]
 
 
 class RuntimeEventDispatcher:
@@ -31,18 +31,16 @@ async def dispatch_task_ready(
         self,
         *,
         sample_id: UUID,
-        definition_id: UUID | None,
         task_id: UUID,
     ) -> None:
         """Emit the canonical ``task/ready`` event for a committed task state."""
         if self._task_ready_dispatcher is not None:
-            await self._task_ready_dispatcher(sample_id, definition_id, task_id)
+            await self._task_ready_dispatcher(sample_id, task_id)
             logger.info("dispatch_task_ready: fired custom dispatcher for task %s", task_id)
             return
 
         event = TaskReadyEvent(
             sample_id=sample_id,
-            definition_id=definition_id,
             task_id=task_id,
         )
         inngest_client.send_sync(
diff --git a/ergon_core/ergon_core/core/application/runtime/graph_repository.py b/ergon_core/ergon_core/core/application/runtime/graph_repository.py
index adc438147..33db1dd28 100644
--- a/ergon_core/ergon_core/core/application/runtime/graph_repository.py
+++ b/ergon_core/ergon_core/core/application/runtime/graph_repository.py
@@ -16,13 +16,6 @@
 from typing import Literal
 from uuid import UUID, uuid4
 
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinitionInstance,
-    ExperimentDefinitionTask,
-    ExperimentDefinitionTaskAssignment,
-    ExperimentDefinitionTaskDependency,
-    ExperimentDefinitionWorker,
-)
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.persistence.samples.models import (
     SampleAnnotationEventRow,
@@ -89,188 +82,6 @@ def add_runtime_event_listener(
 
     # ── Initialization ──────────────────────────────────────
 
-    def initialize_from_definition(
-        self,
-        session: Session,
-        sample_id: UUID,
-        definition_id: UUID,
-        *,
-        initial_node_status: str,
-        initial_edge_status: str,
-        meta: MutationMeta,
-    ) -> WorkflowGraphDto:
-        """Copy definition tables into run graph tables.
-
-        Nodes are created with ``initial_node_status`` and edges with
-        ``initial_edge_status``. The caller decides what status values
-        to use (the core does not interpret them).
-
-        Task payloads from the definition are stored as annotations
-        with namespace ``"payload"``.
-        """
-        now = utcnow()
-
-        instances = list(
-            session.exec(
-                select(ExperimentDefinitionInstance).where(
-                    ExperimentDefinitionInstance.experiment_definition_id == definition_id,
-                )
-            ).all()
-        )
-        instance_key_by_id = {i.id: i.instance_key for i in instances}
-
-        tasks = list(
-            session.exec(
-                select(ExperimentDefinitionTask).where(
-                    ExperimentDefinitionTask.experiment_definition_id == definition_id,
-                )
-            ).all()
-        )
-
-        assignments_stmt = select(ExperimentDefinitionTaskAssignment).where(
-            ExperimentDefinitionTaskAssignment.experiment_definition_id == definition_id,
-        )
-        assignments = list(session.exec(assignments_stmt).all())
-
-        workers_stmt = select(ExperimentDefinitionWorker).where(
-            ExperimentDefinitionWorker.experiment_definition_id == definition_id,
-        )
-        worker_type_by_binding = {
-            worker.binding_key: worker.worker_type for worker in session.exec(workers_stmt).all()
-        }
-        worker_by_task: dict[UUID, str] = {}
-        for a in assignments:
-            worker_by_task[a.task_id] = worker_type_by_binding[a.worker_binding_key]
-
-        deps = list(
-            session.exec(
-                select(ExperimentDefinitionTaskDependency).where(
-                    ExperimentDefinitionTaskDependency.experiment_definition_id == definition_id,
-                )
-            ).all()
-        )
-
-        def_to_node: dict[UUID, UUID] = {}
-        node_rows: list[SampleGraphNode] = []
-
-        for task in tasks:
-            def_to_node[task.id] = task.id
-            node_rows.append(
-                SampleGraphNode(
-                    task_id=task.id,
-                    sample_id=sample_id,
-                    instance_key=instance_key_by_id[task.instance_id],
-                    task_slug=task.task_slug,
-                    description=task.description,
-                    task_json=task.task_json,
-                    is_dynamic=False,
-                    status=initial_node_status,
-                    assigned_worker_slug=worker_by_task.get(task.id),
-                    created_at=now,
-                    updated_at=now,
-                )
-            )
-
-        edge_rows: list[SampleGraphEdge] = []
-        for dep in deps:
-            edge_rows.append(
-                SampleGraphEdge(
-                    id=uuid4(),
-                    sample_id=sample_id,
-                    definition_dependency_id=dep.id,
-                    source_task_id=def_to_node[dep.depends_on_task_id],
-                    target_task_id=def_to_node[dep.task_id],
-                    status=initial_edge_status,
-                    created_at=now,
-                    updated_at=now,
-                )
-            )
-
-        appender = SampleRuntimeEventAppender(session)
-        status_event = appender.append_status_event(
-            SampleStatusEventRow(
-                sample_id=sample_id,
-                event_type="sample.status_changed",
-                status="pending",
-                actor=meta.actor,
-                event_timestamp=now,
-                payload_json={"reason": meta.reason},
-            )
-        )
-        runtime_events: list[SampleRuntimeEventRow] = [status_event]
-
-        for task, node in zip(tasks, node_rows):
-            runtime_events.append(
-                appender.append_task_event(
-                    SampleTaskEventRow(
-                        sample_id=sample_id,
-                        task_id=node.task_id,
-                        task_slug=node.task_slug,
-                        event_type="task.added",
-                        status=initial_node_status,
-                        actor=meta.actor,
-                        event_timestamp=now,
-                        task_snapshot_json=node.task_json,
-                        payload_json=_task_payload(node),
-                    )
-                )
-            )
-            runtime_events.extend(
-                self._append_task_component_events(
-                    appender,
-                    sample_id=sample_id,
-                    actor=meta.actor,
-                    event_timestamp=now,
-                    task_id=node.task_id,
-                    task_json=node.task_json,
-                    assigned_worker_slug=node.assigned_worker_slug,
-                )
-            )
-
-            payload = task.task_json.get("task_payload") or {}
-            if payload:
-                runtime_events.append(
-                    appender.append_annotation_event(
-                        SampleAnnotationEventRow(
-                            sample_id=sample_id,
-                            target_type="task",
-                            target_id=node.task_id,
-                            key="payload",
-                            event_type="annotation.set",
-                            event_timestamp=now,
-                            payload_json={"value": payload},
-                        )
-                    )
-                )
-
-        for edge in edge_rows:
-            runtime_events.append(
-                appender.append_edge_event(
-                    SampleEdgeEventRow(
-                        sample_id=sample_id,
-                        edge_id=edge.id,
-                        source_task_id=edge.source_task_id,
-                        target_task_id=edge.target_task_id,
-                        event_type="edge.added",
-                        status=initial_edge_status,
-                        actor=meta.actor,
-                        event_timestamp=now,
-                        edge_snapshot_json=_edge_payload(edge),
-                        payload_json=_edge_payload(edge),
-                    )
-                )
-            )
-
-        session.add_all(node_rows)
-        session.add_all(edge_rows)
-        session.flush()
-
-        return WorkflowGraphDto(
-            sample_id=sample_id,
-            nodes=[_to_node_dto(n) for n in node_rows],
-            edges=[_to_edge_dto(e) for e in edge_rows],
-        )
-
     # ── Task operations ─────────────────────────────────────
 
     async def node(
@@ -783,7 +594,6 @@ def _to_edge_dto(row: SampleGraphEdge) -> GraphEdgeDto:
     return GraphEdgeDto(
         id=row.id,
         sample_id=row.sample_id,
-        definition_dependency_id=row.definition_dependency_id,
         source_task_id=row.source_task_id,
         target_task_id=row.target_task_id,
         status=row.status,
diff --git a/ergon_core/ergon_core/core/application/runtime/lifecycle.py b/ergon_core/ergon_core/core/application/runtime/lifecycle.py
index a01acae66..2f7157fee 100644
--- a/ergon_core/ergon_core/core/application/runtime/lifecycle.py
+++ b/ergon_core/ergon_core/core/application/runtime/lifecycle.py
@@ -8,10 +8,6 @@
 from uuid import UUID
 
 from ergon_core.core.shared.json_types import JsonObject
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinitionTask,
-    ExperimentDefinitionTaskDependency,
-)
 from ergon_core.core.application.runtime import status as graph_status
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.application.runtime.models import MutationMeta
@@ -107,7 +103,6 @@ async def mark_task_failed(
 async def get_initial_ready_tasks(
     session: Session,
     sample_id: UUID,
-    definition_id: UUID | None = None,
     *,
     graph_repo: RuntimeGraphRepository | None = None,
     graph_lookup: GraphNodeLookup | None = None,
@@ -116,20 +111,12 @@ async def get_initial_ready_tasks(
     """Return task IDs that have zero dependencies."""
     graph_repo = graph_repo or RuntimeGraphRepository()
     graph_lookup = graph_lookup or GraphNodeLookup(session, sample_id)
-    if definition_id is None:
-        all_tasks_stmt = select(SampleGraphNode.task_id).where(
-            SampleGraphNode.sample_id == sample_id,
-        )
-        tasks_with_deps_stmt = select(SampleGraphEdge.target_task_id).where(
-            SampleGraphEdge.sample_id == sample_id,
-        )
-    else:
-        all_tasks_stmt = select(ExperimentDefinitionTask.id).where(
-            ExperimentDefinitionTask.experiment_definition_id == definition_id,
-        )
-        tasks_with_deps_stmt = select(ExperimentDefinitionTaskDependency.task_id).where(
-            ExperimentDefinitionTaskDependency.experiment_definition_id == definition_id,
-        )
+    all_tasks_stmt = select(SampleGraphNode.task_id).where(
+        SampleGraphNode.sample_id == sample_id,
+    )
+    tasks_with_deps_stmt = select(SampleGraphEdge.target_task_id).where(
+        SampleGraphEdge.sample_id == sample_id,
+    )
     all_task_ids = set(session.exec(all_tasks_stmt).all())
     tasks_with_deps = set(session.exec(tasks_with_deps_stmt).all())
 
diff --git a/ergon_core/ergon_core/core/application/runtime/models.py b/ergon_core/ergon_core/core/application/runtime/models.py
index 6f736b567..cc8493322 100644
--- a/ergon_core/ergon_core/core/application/runtime/models.py
+++ b/ergon_core/ergon_core/core/application/runtime/models.py
@@ -13,7 +13,6 @@
 from ergon_core.api.benchmark import Task
 from ergon_core.core.application.runtime.status import NodeStatus
 from ergon_core.core.persistence.shared.types import (
-    DefinitionId,
     EdgeId,
     NodeId,
     SampleId,
@@ -75,7 +74,6 @@ class GraphEdgeDto(BaseModel):
 
     id: EdgeId
     sample_id: SampleId
-    definition_dependency_id: DefinitionId | None
     source_task_id: NodeId
     target_task_id: NodeId
     status: str = Field(
diff --git a/ergon_core/ergon_core/core/application/runtime/orchestration.py b/ergon_core/ergon_core/core/application/runtime/orchestration.py
index 47ff91d60..1c2655a89 100644
--- a/ergon_core/ergon_core/core/application/runtime/orchestration.py
+++ b/ergon_core/ergon_core/core/application/runtime/orchestration.py
@@ -1,7 +1,6 @@
 """Typed command/result DTOs for orchestration services.
 
 These are the contracts between Inngest functions and services.
-Adapted from ref: definition_id replaces definition_id.
 """
 
 import sys
@@ -36,14 +35,12 @@ class InitializeWorkflowCommand(BaseModel):
     model_config = {"frozen": True}
 
     sample_id: UUID
-    definition_id: UUID | None = None
 
 
 class InitializedWorkflow(BaseModel):
     model_config = {"frozen": True}
 
     sample_id: UUID
-    definition_id: UUID | None = None
     benchmark_type: str
     total_tasks: int
     total_root_tasks: int
@@ -55,7 +52,6 @@ class PrepareTaskExecutionCommand(BaseModel):
     model_config = {"frozen": True}
 
     sample_id: UUID
-    definition_id: UUID | None = None
     task_id: UUID
 
 
@@ -69,7 +65,6 @@ class PreparedTaskExecution(BaseModel):
     model_config = {"frozen": True}
 
     sample_id: UUID
-    definition_id: UUID | None = None
     task_id: UUID
     task_slug: str
     task_description: str
@@ -110,7 +105,6 @@ class PropagateTaskCompletionCommand(BaseModel):
     model_config = {"frozen": True}
 
     sample_id: UUID
-    definition_id: UUID | None = None
     task_id: UUID
     execution_id: UUID
 
@@ -119,7 +113,6 @@ class PropagationResult(BaseModel):
     model_config = {"frozen": True}
 
     sample_id: UUID
-    definition_id: UUID | None = None
     completed_task_id: UUID
     ready_tasks: list[TaskDescriptor] = Field(default_factory=list)
     workflow_terminal_state: WorkflowTerminalState = WorkflowTerminalState.NONE
@@ -129,7 +122,6 @@ class FinalizeWorkflowCommand(BaseModel):
     model_config = {"frozen": True}
 
     sample_id: UUID
-    definition_id: UUID | None = None
 
 
 class FinalizedWorkflowResult(BaseModel):
diff --git a/ergon_core/ergon_core/core/application/runtime/sample_identity.py b/ergon_core/ergon_core/core/application/runtime/sample_identity.py
deleted file mode 100644
index 1e9358d1e..000000000
--- a/ergon_core/ergon_core/core/application/runtime/sample_identity.py
+++ /dev/null
@@ -1,17 +0,0 @@
-"""Run identity helpers owned by the runtime layer."""
-
-from __future__ import annotations
-
-from uuid import UUID
-
-from ergon_core.core.application.runtime.task_errors import SampleRecordMissingError
-from ergon_core.core.persistence.telemetry.models import SampleRecord
-from sqlmodel import Session, select
-
-
-def definition_id_for_run(session: Session, sample_id: UUID) -> UUID | None:
-    """Return the definition id for a run or fail the runtime invariant loudly."""
-    run = session.exec(select(SampleRecord).where(SampleRecord.id == sample_id)).first()
-    if run is None:
-        raise SampleRecordMissingError(sample_id)
-    return run.definition_id
diff --git a/ergon_core/ergon_core/core/application/runtime/sample_lifecycle.py b/ergon_core/ergon_core/core/application/runtime/sample_lifecycle.py
index 3d6f5b0b1..984e78984 100644
--- a/ergon_core/ergon_core/core/application/runtime/sample_lifecycle.py
+++ b/ergon_core/ergon_core/core/application/runtime/sample_lifecycle.py
@@ -3,10 +3,6 @@
 from typing import Literal, Protocol
 from uuid import UUID, uuid4
 
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionTask,
-)
 from ergon_core.core.application.runtime import status as graph_status
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.persistence.shared.db import get_session
@@ -25,12 +21,7 @@
     RuntimeEventDispatcher,
     TaskReadyDispatcher,
 )
-from ergon_core.core.application.runtime.sample_records import (
-    cancel_run,
-    create_run,
-    latest_run_for_definition,
-)
-from ergon_core.core.application.runtime.sample_identity import definition_id_for_run
+from ergon_core.core.application.runtime.sample_records import cancel_sample
 from ergon_core.core.application.runtime.graph_lookup import GraphNodeLookup
 from ergon_core.core.application.runtime.lifecycle import (
     get_initial_ready_tasks,
@@ -110,7 +101,7 @@ async def initialize(
         *,
         session: Session | None = None,
     ) -> InitializedWorkflow:
-        """Load a definition, seed graph state, and return initially ready tasks."""
+        """Load materialized sample graph state and return initially ready tasks."""
         if session is not None:
             return await self._initialize_in_session(session, command, commit=False)
         with get_session() as session:
@@ -128,99 +119,14 @@ async def _initialize_in_session(
                 select(SampleGraphNode).where(SampleGraphNode.sample_id == command.sample_id)
             ).all()
         )
-        if materialized_nodes:
-            return await self._initialize_materialized_sample(
-                session,
-                command,
-                nodes=materialized_nodes,
-                commit=commit,
-            )
-        if command.definition_id is None:
-            raise ValueError(
-                f"Sample {command.sample_id} has no materialized graph and no definition_id"
-            )
-        return await self._initialize_definition_backed_sample(session, command, commit=commit)
-
-    async def _initialize_definition_backed_sample(
-        self,
-        session: Session,
-        command: InitializeWorkflowCommand,
-        *,
-        commit: bool,
-    ) -> InitializedWorkflow:
-        definition = require_not_none(
-            session.get(ExperimentDefinition, command.definition_id),
-            f"Definition {command.definition_id} not found",
-        )
-        all_tasks = list(
-            session.exec(
-                select(ExperimentDefinitionTask).where(
-                    ExperimentDefinitionTask.experiment_definition_id == command.definition_id,
-                )
-            ).all()
-        )
-
-        self._graph_repo.initialize_from_definition(
-            session,
-            command.sample_id,
-            command.definition_id,
-            initial_node_status=graph_status.PENDING,
-            initial_edge_status=graph_status.EDGE_PENDING,
-            meta=MutationMeta(actor="system:workflow_init"),
-        )
-        if commit:
-            session.commit()
-
-        task_descriptors = [
-            TaskDescriptor(
-                task_id=t.id,
-                task_slug=t.task_slug,
-                parent_task_id=t.parent_task_id,
-            )
-            for t in all_tasks
-        ]
-        graph_lookup = GraphNodeLookup(session, command.sample_id)
-
-        run_record = require_not_none(
-            session.get(SampleRecord, command.sample_id),
-            f"SampleRecord {command.sample_id} not found",
-        )
-        if run_record.status == SampleStatus.PENDING:
-            run_record.status = SampleStatus.EXECUTING
-            run_record.started_at = utcnow()
-            session.add(run_record)
-            append_sample_status_changed(
-                session,
-                sample_id=command.sample_id,
-                status=SampleStatus.EXECUTING,
-                actor="system:workflow_init",
-                event_timestamp=run_record.started_at,
-            )
-        if commit:
-            session.commit()
-
-        ready_ids = await get_initial_ready_tasks(
+        if not materialized_nodes:
+            raise ValueError(f"Sample {command.sample_id} has no materialized graph")
+        return await self._initialize_materialized_sample(
             session,
-            command.sample_id,
-            command.definition_id,
-            graph_repo=self._graph_repo,
-            graph_lookup=graph_lookup,
+            command,
+            nodes=materialized_nodes,
             commit=commit,
         )
-        if not commit:
-            session.flush()
-        ready_id_set = set(ready_ids)
-        root_count = sum(1 for t in all_tasks if t.parent_task_id is None)
-
-        return InitializedWorkflow(
-            sample_id=command.sample_id,
-            definition_id=command.definition_id,
-            benchmark_type=definition.benchmark_type,
-            total_tasks=len(all_tasks),
-            total_root_tasks=root_count,
-            pending_tasks=task_descriptors,
-            initial_ready_tasks=[td for td in task_descriptors if td.task_id in ready_id_set],
-        )
 
     async def _initialize_materialized_sample(
         self,
@@ -249,7 +155,6 @@ async def _initialize_materialized_sample(
         ready_ids = await get_initial_ready_tasks(
             session,
             command.sample_id,
-            None,
             graph_repo=self._graph_repo,
             graph_lookup=graph_lookup,
             commit=commit,
@@ -279,7 +184,6 @@ async def _initialize_materialized_sample(
         ]
         return InitializedWorkflow(
             sample_id=command.sample_id,
-            definition_id=command.definition_id,
             benchmark_type=run_record.benchmark_type,
             total_tasks=len(nodes),
             total_root_tasks=sum(1 for node in nodes if node.task_id not in dependency_target_ids),
@@ -369,7 +273,6 @@ async def propagate(self, command: PropagateTaskCompletionCommand) -> Propagatio
 
             return PropagationResult(
                 sample_id=command.sample_id,
-                definition_id=command.definition_id,
                 completed_task_id=command.task_id,
                 ready_tasks=ready_descriptors,
                 workflow_terminal_state=terminal,
@@ -404,7 +307,6 @@ async def propagate_failure(self, command: PropagateTaskCompletionCommand) -> Pr
 
             return PropagationResult(
                 sample_id=command.sample_id,
-                definition_id=command.definition_id,
                 completed_task_id=command.task_id,
                 workflow_terminal_state=terminal,
             )
diff --git a/ergon_core/ergon_core/core/application/runtime/sample_records.py b/ergon_core/ergon_core/core/application/runtime/sample_records.py
index a6dbb3fc4..62ecc52cd 100644
--- a/ergon_core/ergon_core/core/application/runtime/sample_records.py
+++ b/ergon_core/ergon_core/core/application/runtime/sample_records.py
@@ -4,7 +4,6 @@
 from uuid import UUID
 
 import inngest
-from ergon_core.core.application.experiments.models import DefinitionHandle
 from ergon_core.core.application.events import SampleCancelledEvent, SampleCleanupEvent
 from ergon_core.core.application.samples.events import SampleRuntimeEventAppender
 from ergon_core.core.shared.json_types import JsonObject
@@ -12,7 +11,6 @@
 from ergon_core.core.persistence.shared.db import get_session
 from ergon_core.core.persistence.shared.enums import TERMINAL_SAMPLE_STATUSES, SampleStatus
 from ergon_core.core.persistence.telemetry.models import SampleRecord
-from sqlmodel import select
 from ergon_core.core.infrastructure.inngest.client import inngest_client
 from ergon_core.core.shared.settings import settings
 from ergon_core.core.shared.utils import utcnow
@@ -34,43 +32,6 @@ def _checkpoint_metadata() -> JsonObject:
     }
 
 
-def create_definition_backed_sample(  # slopcop: ignore[max-function-params] -- service boundary mirrors SampleRecord provenance fields
-    definition: DefinitionHandle,
-    *,
-    definition_id: UUID,
-    instance_key: str,
-    worker_team_json: JsonObject,
-    evaluator_slug: str | None = None,
-    model_target: str | None = None,
-    sandbox_slug: str | None = None,
-    dependency_extras_json: JsonObject | None = None,
-    assignment_json: JsonObject | None = None,
-    seed: int | None = None,
-    experiment: str | None = None,
-) -> SampleRecord:
-    with get_session() as session:
-        sample = SampleRecord(
-            definition_id=definition_id,
-            benchmark_type=definition.benchmark_type,
-            instance_key=instance_key,
-            worker_team_json=worker_team_json,
-            evaluator_slug=evaluator_slug,
-            model_target=model_target,
-            sandbox_slug=sandbox_slug,
-            dependency_extras_json=dependency_extras_json or {},
-            assignment_json=assignment_json or {},
-            seed=seed,
-            experiment=experiment,
-            status=SampleStatus.PENDING,
-            created_at=utcnow(),
-            summary_json=_checkpoint_metadata(),
-        )
-        session.add(sample)
-        session.commit()
-        session.refresh(sample)
-        return sample
-
-
 def cancel_sample(sample_id: UUID) -> SampleRecord:
     """Cancel a sample: mark CANCELLED in PG, kill Inngest functions, trigger cleanup."""
     with get_session() as session:
@@ -116,18 +77,4 @@ def cancel_sample(sample_id: UUID) -> SampleRecord:
     return sample
 
 
-def latest_sample_for_definition(definition_id: UUID) -> SampleRecord | None:
-    """Most-recent ``SampleRecord`` for a given definition, or None."""
-    with get_session() as session:
-        stmt = (
-            select(SampleRecord)
-            .where(SampleRecord.definition_id == definition_id)
-            .order_by(SampleRecord.created_at.desc())
-            .limit(1)
-        )
-        return session.exec(stmt).first()
-
-
-create_run = create_definition_backed_sample
 cancel_run = cancel_sample
-latest_run_for_definition = latest_sample_for_definition
diff --git a/ergon_core/ergon_core/core/application/runtime/task_errors.py b/ergon_core/ergon_core/core/application/runtime/task_errors.py
index b852ca16d..49b589b3f 100644
--- a/ergon_core/ergon_core/core/application/runtime/task_errors.py
+++ b/ergon_core/ergon_core/core/application/runtime/task_errors.py
@@ -57,9 +57,9 @@ def __init__(self, task_id: UUID, current_status: str) -> None:
 class SampleRecordMissingError(DelegationError):
     """Raised when a service is asked to mutate a run that has no SampleRecord.
 
-    Every run must have a SampleRecord (with ``experiment_definition_id``)
-    before any task/graph service is invoked on it. This is enforced as a
-    hard invariant so missing fixtures in tests surface as a loud failure.
+    Every task/graph service mutation must have a SampleRecord. This is
+    enforced as a hard invariant so missing fixtures in tests surface as a
+    loud failure.
     """
 
     def __init__(self, sample_id: UUID) -> None:
diff --git a/ergon_core/ergon_core/core/application/runtime/task_execution.py b/ergon_core/ergon_core/core/application/runtime/task_execution.py
index d44d7cd11..7419bfad3 100644
--- a/ergon_core/ergon_core/core/application/runtime/task_execution.py
+++ b/ergon_core/ergon_core/core/application/runtime/task_execution.py
@@ -5,10 +5,6 @@
 
 from ergon_core.api.benchmark import Task
 from ergon_core.core.application.events.service import get_dashboard_event_publisher
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionWorker,
-)
 from ergon_core.core.application.runtime import status as graph_status
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.shared.db import get_session
@@ -33,7 +29,7 @@
 )
 from ergon_core.core.shared.utils import require_not_none, utcnow
 from ergon_core.core.views.dashboard_events.contracts import DashboardTaskStatusChangedEvent
-from sqlmodel import Session, select
+from sqlmodel import Session
 
 logger = logging.getLogger(__name__)
 
@@ -161,34 +157,16 @@ async def _prepare_run_node(
                 session.get(SampleRecord, command.sample_id),
                 f"SampleRecord {command.sample_id} not found",
             )
-            if command.definition_id is None:
-                (
-                    worker_type,
-                    model_target,
-                    definition_worker_id,
-                ) = await _resolve_sample_worker_config(
-                    node.task_json,
-                    task_id=view.task_id,
-                    assigned_worker_slug=assigned_worker_slug,
-                )
-                benchmark_type = run_record.benchmark_type
-            else:
-                definition = require_not_none(
-                    session.get(ExperimentDefinition, command.definition_id),
-                    f"Definition {command.definition_id} not found",
-                )
-                worker_type, model_target, definition_worker_id = self._resolve_worker_config(
-                    session,
-                    definition_id=command.definition_id,
-                    sample_id=command.sample_id,
-                    assigned_worker_slug=assigned_worker_slug,
-                )
-                benchmark_type = definition.benchmark_type
+            worker_type, model_target = await _resolve_sample_worker_config(
+                node.task_json,
+                task_id=view.task_id,
+                assigned_worker_slug=assigned_worker_slug,
+            )
+            benchmark_type = run_record.benchmark_type
 
             execution = SampleTaskAttempt(
                 sample_id=command.sample_id,
                 task_id=view.task_id,
-                definition_worker_id=definition_worker_id,
                 attempt_number=self._task_execution_repo.next_attempt_for_node(
                     session, command.sample_id, view.task_id
                 ),
@@ -220,12 +198,10 @@ async def _prepare_run_node(
             task_slug=view.task.task_slug,
             new_status=graph_status.RUNNING,
             old_status=None,
-            worker_id=definition_worker_id,
             worker_slug=assigned_worker_slug,
         )
         return PreparedTaskExecution(
             sample_id=command.sample_id,
-            definition_id=command.definition_id,
             task_id=view.task_id,
             task_slug=view.task.task_slug,
             task_description=view.task.description,
@@ -236,38 +212,6 @@ async def _prepare_run_node(
             execution_id=execution_id,
         )
 
-    def _resolve_worker_config(
-        self,
-        session: Session,
-        *,
-        definition_id: UUID,
-        sample_id: UUID,
-        assigned_worker_slug: str | None,
-    ) -> tuple[str | None, str | None, UUID | None]:
-        """Resolve (worker_type, model_target, definition_worker_id) for a
-        given assigned_worker_slug.
-
-        Falls back to the run's default model_target when no
-        ExperimentDefinitionWorker row matches the binding key. The object-bound
-        worker instance is authoritative at runtime; these values populate
-        execution metadata and read-model fields.
-        """
-
-        if assigned_worker_slug is None:
-            return None, None, None
-        worker_row = session.exec(
-            select(ExperimentDefinitionWorker).where(
-                ExperimentDefinitionWorker.experiment_definition_id == definition_id,
-                ExperimentDefinitionWorker.binding_key == assigned_worker_slug,
-            )
-        ).first()
-        if worker_row is not None:
-            return worker_row.worker_type, worker_row.model_target, worker_row.id
-        # No matching binding — use the run-level default model_target.
-        run = session.get(SampleRecord, sample_id)
-        model_target = run.model_target if run is not None else None
-        return assigned_worker_slug, model_target, None
-
     async def finalize_success(self, command: FinalizeTaskExecutionCommand) -> None:
         with get_session() as session:
             execution = require_not_none(
@@ -329,6 +273,6 @@ async def _resolve_sample_worker_config(
     *,
     task_id: UUID,
     assigned_worker_slug: str | None,
-) -> tuple[str, str, None]:
+) -> tuple[str, str]:
     task = await Task.from_definition(task_json, task_id=task_id)
-    return assigned_worker_slug or task.worker.type_slug, task.worker.model, None
+    return assigned_worker_slug or task.worker.type_slug, task.worker.model
diff --git a/ergon_core/ergon_core/core/application/runtime/task_management.py b/ergon_core/ergon_core/core/application/runtime/task_management.py
index 94f0c9f13..77536e3c5 100644
--- a/ergon_core/ergon_core/core/application/runtime/task_management.py
+++ b/ergon_core/ergon_core/core/application/runtime/task_management.py
@@ -2,7 +2,7 @@
 
 Dynamic task creation is intentionally object-bound: callers pass a public
 ``Task`` snapshot to ``spawn_dynamic_task(Task)`` and the runtime persists that
-snapshot directly on the run graph. Slug-only dynamic task APIs are retired so
+snapshot directly on the sample graph. Slug-only dynamic task APIs are retired so
 new runtime nodes cannot be created without the worker, criteria, and payload
 invariants carried by the public task object.
 """
@@ -36,7 +36,6 @@
     RuntimeEventDispatcher,
     TaskReadyDispatcher,
 )
-from ergon_core.core.application.runtime.sample_identity import definition_id_for_run
 from ergon_core.core.application.runtime.task_errors import (
     TaskAlreadyTerminalError,
     TaskNotTerminalError,
@@ -118,14 +117,13 @@ async def spawn_dynamic_task(
         task: Task,
         depends_on: tuple[UUID, ...] = (),
     ) -> SpawnedTaskHandle:
-        """Insert a dynamic graph node with task JSON; no definition row.
+        """Insert a dynamic graph node with task JSON.
 
         Used by WorkerContext.spawn_task to make dynamic subtasks
-        graph-native. No experiment_definition_tasks row is written —
-        the full Task snapshot lives in sample_graph_nodes.task_json with
-        is_dynamic=True.
+        graph-native. The full Task snapshot lives in
+        sample_graph_nodes.task_json with is_dynamic=True.
         """
-        dispatch: tuple[UUID, UUID | None, UUID] | None = None
+        dispatch: tuple[UUID, UUID] | None = None
         with get_session() as session:
             parent = self._graph_repo.get_node(session, sample_id=sample_id, task_id=parent_task_id)
             node = await self._graph_repo.add_node(
@@ -153,15 +151,13 @@ async def spawn_dynamic_task(
                 )
             task_id = node.task_id
             if not depends_on:
-                definition_id = definition_id_for_run(session, sample_id)
-                dispatch = (sample_id, definition_id, task_id)
+                dispatch = (sample_id, task_id)
             session.commit()
 
         if dispatch is not None:
             await self._runtime_events.dispatch_task_ready(
                 sample_id=dispatch[0],
-                definition_id=dispatch[1],
-                task_id=dispatch[2],
+                task_id=dispatch[1],
             )
 
         return SpawnedTaskHandle(task_id=task_id)
@@ -207,11 +203,9 @@ async def cancel_task(
         session.commit()
 
         if applied:
-            definition_id = definition_id_for_run(session, command.sample_id)
             event = self._task_cancelled_event(
                 session,
                 sample_id=command.sample_id,
-                definition_id=definition_id,
                 task_id=command.task_id,
                 cause="manager_decision",
             )
@@ -240,7 +234,6 @@ async def cancel_orphans(
         session: Session,
         *,
         sample_id: UUID,
-        definition_id: UUID | None,
         parent_task_id: UUID,
         cause: PropagationCancelCause,
     ) -> CancelOrphansResult:
@@ -266,7 +259,6 @@ async def cancel_orphans(
             self._task_cancelled_event(
                 session,
                 sample_id=sample_id,
-                definition_id=definition_id,
                 task_id=nid,
                 cause=cause,
             )
@@ -412,11 +404,8 @@ async def restart_task(
         )
 
         session.commit()
-
-        definition_id = definition_id_for_run(session, command.sample_id)
         await self._runtime_events.dispatch_task_ready(
             sample_id=command.sample_id,
-            definition_id=definition_id,
             task_id=command.task_id,
         )
 
@@ -551,12 +540,9 @@ async def _cancel_for_invalidation(
             ),
             only_if_not_terminal=False,
         )
-
-        definition_id = definition_id_for_run(session, sample_id)
         event = self._task_cancelled_event(
             session,
             sample_id=sample_id,
-            definition_id=definition_id,
             task_id=task_id,
             cause="downstream_invalidation",
         )
@@ -636,14 +622,12 @@ def _task_cancelled_event(
         session: Session,
         *,
         sample_id: UUID,
-        definition_id: UUID | None,
         task_id: UUID,
         cause: CancelCause,
     ) -> TaskCancelledEvent:
         execution = self._task_execution_repo.latest_for_node(session, task_id)
         return TaskCancelledEvent(
             sample_id=sample_id,
-            definition_id=definition_id,
             task_id=task_id,
             execution_id=None if execution is None else execution.id,
             cause=cause,
diff --git a/ergon_core/ergon_core/core/application/samples/materialization.py b/ergon_core/ergon_core/core/application/samples/materialization.py
index 998255ce4..b8839a718 100644
--- a/ergon_core/ergon_core/core/application/samples/materialization.py
+++ b/ergon_core/ergon_core/core/application/samples/materialization.py
@@ -111,15 +111,16 @@ def materialize_sample(
         )
         for evaluator in task.evaluators:
             evaluator_snapshot = evaluator.model_dump(mode="json")
+            evaluator_slug = evaluator.name
             wal.append_evaluator_event(
                 SampleEvaluatorEventRow(
                     sample_id=sample_row.id,
                     task_id=task_id,
                     event_type="evaluator.added",
-                    evaluator_slug=evaluator.type_slug,
+                    evaluator_slug=evaluator_slug,
                     evaluator_type=_snapshot_type(
                         evaluator_snapshot,
-                        fallback=evaluator.type_slug,
+                        fallback=evaluator_slug,
                     ),
                     evaluator_snapshot_json=evaluator_snapshot,
                     payload_json={"task_id": str(task_id), "evaluator": evaluator_snapshot},
diff --git a/ergon_core/ergon_core/core/application/testing/suppression_budget.py b/ergon_core/ergon_core/core/application/testing/suppression_budget.py
index c4f4bf534..ef0dcf664 100644
--- a/ergon_core/ergon_core/core/application/testing/suppression_budget.py
+++ b/ergon_core/ergon_core/core/application/testing/suppression_budget.py
@@ -54,15 +54,8 @@ class SuppressionCounts(NamedTuple):
     # deleted with `_retired_workers.py`, decrement `slopcop_ignore` by ~3
     # (the v1 retired `Any` annotations) and update this comment to reflect
     # the post-PR-11 baseline.
-    # PR 6.5 net: persist_benchmark module-level function adds 1×no-typing-any
-    # (resolved_metadata dict[str,Any]) in definition_writer.py. The
-    # ExperimentService façade is gone (deleted persist_benchmark method
-    # contributed 1×no-typing-any + 1×guarded-function-import; the surviving
-    # module-level run_experiment hoists the launch import to top-level so
-    # no guarded-function-import is needed). api/experiment.py deletion
-    # contributed -1.
-    # +1 noqa (PR 6.5): noqa: C901 on persist_benchmark (complex by design,
-    # same as the persist_definition it supplements).
+    # Historical PR 6.5 experiment-authoring suppressions were retired with
+    # the sample-first experiment submission path.
     # +6 (PR 9 Task 2): WorkerContext injected services typed as ``Any``
     # to break the historical api → core → api import cycle. 3 PrivateAttr fields
     # (_task_mgmt, _task_inspect, _resource_repo) + 3 _for_job kwargs
diff --git a/ergon_core/ergon_core/core/application/testing/test_harness_service.py b/ergon_core/ergon_core/core/application/testing/test_harness_service.py
index bad34add7..9fd976b61 100644
--- a/ergon_core/ergon_core/core/application/testing/test_harness_service.py
+++ b/ergon_core/ergon_core/core/application/testing/test_harness_service.py
@@ -4,8 +4,9 @@
 from dataclasses import dataclass
 from uuid import UUID
 
+from sqlalchemy import or_
 from ergon_core.core.persistence.context.models import SampleContextEvent
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
+from ergon_core.core.persistence.experiments.models import ExperimentRow
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.shared.db import get_engine
 from ergon_core.core.persistence.shared.enums import SampleStatus
@@ -21,11 +22,7 @@
 
 
 class UnknownSampleStatusError(ValueError):
-    """Raised when a test seed request names an unknown run status."""
-
-
-class DefinitionNotFoundError(LookupError):
-    """Raised when a test seed request references an unknown definition."""
+    """Raised when a test seed request names an unknown sample status."""
 
 
 @dataclass(frozen=True)
@@ -62,7 +59,7 @@ class HarnessExecution:
 
 
 @dataclass(frozen=True)
-class HarnessRunState:
+class HarnessSampleState:
     sample_id: UUID
     status: str
     graph_nodes: list[HarnessGraphNode]
@@ -77,7 +74,7 @@ class HarnessRunState:
 
 
 @dataclass(frozen=True)
-class HarnessExperimentRun:
+class HarnessExperimentSample:
     sample_id: UUID
     status: str
 
@@ -88,9 +85,9 @@ def get_session_dep() -> Iterator[Session]:
         yield session
 
 
-def read_run_state(sample_id: UUID, session: Session) -> HarnessRunState | None:
-    run = session.exec(select(SampleRecord).where(SampleRecord.id == sample_id)).first()
-    if run is None:
+def read_sample_state(sample_id: UUID, session: Session) -> HarnessSampleState | None:
+    sample = session.exec(select(SampleRecord).where(SampleRecord.id == sample_id)).first()
+    if sample is None:
         return None
 
     nodes = list(
@@ -113,7 +110,7 @@ def read_run_state(sample_id: UUID, session: Session) -> HarnessRunState | None:
     event_rows = SampleRuntimeEventReadService().list_events(session, sample_id)
     events = [
         HarnessSampleRuntimeEvent(
-            table=event.table,
+            table=_sample_runtime_event_table(event.event_type),
             event_type=event.event_type,
             target_id=event.target_id,
             payload=dict(event.payload),
@@ -166,9 +163,9 @@ def read_run_state(sample_id: UUID, session: Session) -> HarnessRunState | None:
         )
     )
 
-    return HarnessRunState(
+    return HarnessSampleState(
         sample_id=sample_id,
-        status=run.status,
+        status=sample.status,
         graph_nodes=graph_nodes,
         events=events,
         evaluations=evaluations,
@@ -181,16 +178,21 @@ def read_run_state(sample_id: UUID, session: Session) -> HarnessRunState | None:
     )
 
 
-def read_experiment_runs(experiment: str, session: Session) -> list[HarnessExperimentRun]:
-    runs = list(
-        session.exec(select(SampleRecord).where(SampleRecord.experiment == experiment)).all(),
+def read_experiment_samples(experiment: str, session: Session) -> list[HarnessExperimentSample]:
+    samples = list(
+        session.exec(
+            select(SampleRecord)
+            .join(ExperimentRow, SampleRecord.experiment_id == ExperimentRow.id, isouter=True)
+            .where(or_(SampleRecord.experiment == experiment, ExperimentRow.name == experiment))
+        ).all(),
     )
-    return [HarnessExperimentRun(sample_id=r.id, status=r.status) for r in runs]
+    return [
+        HarnessExperimentSample(sample_id=sample.id, status=sample.status) for sample in samples
+    ]
 
 
-def seed_run(
+def seed_sample(
     *,
-    definition_id: UUID,
     benchmark_type: str,
     instance_key: str,
     worker_team: dict,
@@ -199,32 +201,27 @@ def seed_run(
     task_slugs: list[str],
 ) -> UUID:
     try:
-        run_status = SampleStatus(status)
+        sample_status = SampleStatus(status)
     except ValueError as exc:
         raise UnknownSampleStatusError(status) from exc
 
     with Session(get_engine()) as session:
-        definition = session.get(ExperimentDefinition, definition_id)
-        if definition is None:
-            raise DefinitionNotFoundError(str(definition_id))
-
-        run = SampleRecord(
-            definition_id=definition_id,
+        sample = SampleRecord(
             benchmark_type=benchmark_type,
             instance_key=instance_key,
             worker_team_json=worker_team,
             experiment=experiment,
-            status=run_status,
+            status=sample_status,
             summary_json={
                 "_test_seeded": True,
                 "_test_experiment": experiment,
                 "_test_task_slugs": task_slugs,
             },
         )
-        session.add(run)
+        session.add(sample)
         session.commit()
-        session.refresh(run)
-        return run.id
+        session.refresh(sample)
+        return sample.id
 
 
 def reset_test_rows(*, experiment_prefix: str) -> None:
@@ -232,13 +229,13 @@ def reset_test_rows(*, experiment_prefix: str) -> None:
         # Cannot SQL-filter on JSON prefix portably; load seeded rows and
         # filter in Python. Bounded by the seed endpoint being test-only.
         candidates = list(session.exec(select(SampleRecord)).all())
-        for run in candidates:
-            metadata = {} if run.summary_json is None else run.summary_json
+        for sample in candidates:
+            metadata = {} if sample.summary_json is None else sample.summary_json
             if not metadata.get("_test_seeded"):
                 continue
             tag = metadata.get("_test_experiment")
             if isinstance(tag, str) and tag.startswith(experiment_prefix):
-                session.delete(run)
+                session.delete(sample)
         session.commit()
 
 
@@ -251,3 +248,20 @@ def _execution_error_message(execution: SampleTaskAttempt) -> str | None:
         if isinstance(value, str):
             return value
     return str(error)
+
+
+def _sample_runtime_event_table(event_type: str) -> str:
+    prefix = event_type.split(".", maxsplit=1)[0]
+    table_by_prefix = {
+        "sample": "sample_status_events",
+        "task": "sample_task_events",
+        "edge": "sample_edge_events",
+        "worker": "sample_worker_events",
+        "evaluator": "sample_evaluator_events",
+        "sandbox": "sample_sandbox_events",
+        "annotation": "sample_annotation_events",
+    }
+    try:
+        return table_by_prefix[prefix]
+    except KeyError as exc:
+        raise ValueError(f"unknown sample runtime event type: {event_type!r}") from exc
diff --git a/ergon_core/ergon_core/core/infrastructure/http/routes/samples.py b/ergon_core/ergon_core/core/infrastructure/http/routes/samples.py
index d0161be7f..3a1ecad94 100644
--- a/ergon_core/ergon_core/core/infrastructure/http/routes/samples.py
+++ b/ergon_core/ergon_core/core/infrastructure/http/routes/samples.py
@@ -21,7 +21,6 @@
 def list_samples(
     limit: int = 20,
     status: str | None = None,
-    definition_id: UUID | None = None,
     experiment: str | None = None,
     offset: int = 0,
 ) -> list[SampleSummaryDto]:
@@ -29,7 +28,6 @@ def list_samples(
     return SampleSnapshotReadService().list_samples(
         limit=limit,
         status=status,
-        definition_id=definition_id,
         experiment=experiment,
         offset=offset,
     )
diff --git a/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py b/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py
index 1424dfc55..d47e36317 100644
--- a/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py
+++ b/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py
@@ -6,24 +6,21 @@
 """
 
 from dataclasses import asdict
-from typing import Annotated
+from collections.abc import Iterator
+from typing import Annotated, Literal
 from uuid import UUID
 
-from ergon_core.core.application.experiments.models import (
-    ExperimentRunRequest,
-)
-from ergon_core.core.application.experiments.service import (
-    run_experiment as _run_experiment,
-)
+from ergon_core.api.experiment import Environment, Experiment, Sample
+from ergon_core.core.application.experiments.service import ExperimentSubmissionService
 from ergon_core.core.application.testing.test_harness_service import (
-    DefinitionNotFoundError,
     UnknownSampleStatusError,
     get_session_dep,
-    read_experiment_runs as _read_experiment_runs,
-    read_run_state as _read_run_state,
+    read_experiment_samples as _read_experiment_samples,
+    read_sample_state as _read_sample_state,
     reset_test_rows as _reset_test_rows,
-    seed_run as _seed_run,
+    seed_sample as _seed_sample,
 )
+from ergon_core.core.persistence.shared.db import get_session
 from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel, Field
 from tests.fixtures.smoke_components.benchmarks import (
@@ -84,7 +81,7 @@ class TestExecutionDto(BaseModel):
     error: str | None
 
 
-class TestRunStateDto(BaseModel):
+class TestSampleStateDto(BaseModel):
     sample_id: UUID
     status: str
     graph_nodes: list[TestGraphNodeDto]
@@ -98,7 +95,7 @@ class TestRunStateDto(BaseModel):
     context_event_count: int
 
 
-class TestExperimentRunDto(BaseModel):
+class TestExperimentSampleDto(BaseModel):
     sample_id: UUID
     status: str
 
@@ -108,29 +105,29 @@ class TestExperimentRunDto(BaseModel):
 # ---------------------------------------------------------------------------
 
 
-@router.get("/read/samples/{sample_id}/state", response_model=TestRunStateDto)
-def read_run_state(
+@router.get("/read/samples/{sample_id}/state", response_model=TestSampleStateDto)
+def read_sample_state(
     sample_id: UUID,
     session: Annotated[object, Depends(get_session_dep)],
-) -> TestRunStateDto:
-    state = _read_run_state(sample_id, session)  # type: ignore[arg-type]
+) -> TestSampleStateDto:
+    state = _read_sample_state(sample_id, session)  # type: ignore[arg-type]
     if state is None:
-        raise HTTPException(status_code=404, detail=f"run {sample_id} not found")
-    return TestRunStateDto(**asdict(state))
+        raise HTTPException(status_code=404, detail=f"sample {sample_id} not found")
+    return TestSampleStateDto(**asdict(state))
 
 
 @router.get(
     "/read/experiment/{experiment}/samples",
-    response_model=list[TestExperimentRunDto],
+    response_model=list[TestExperimentSampleDto],
 )
-def read_experiment_runs(
+def read_experiment_samples(
     experiment: str,
     session: Annotated[object, Depends(get_session_dep)],
-) -> list[TestExperimentRunDto]:
-    """List all runs attached to a v2 experiment grouping tag."""
+) -> list[TestExperimentSampleDto]:
+    """List all samples attached to a v2 experiment grouping tag."""
     return [
-        TestExperimentRunDto(sample_id=run.sample_id, status=run.status)
-        for run in _read_experiment_runs(experiment, session)  # type: ignore[arg-type]
+        TestExperimentSampleDto(sample_id=sample.sample_id, status=sample.status)
+        for sample in _read_experiment_samples(experiment, session)  # type: ignore[arg-type]
     ]
 
 
@@ -145,8 +142,7 @@ def read_experiment_runs(
 # callers must always specify what to nuke.
 
 
-class SeedRunRequest(BaseModel):
-    definition_id: UUID
+class SeedSampleRequest(BaseModel):
     benchmark_type: str = "test-harness"
     instance_key: str = "seeded"
     worker_team: dict = Field(default_factory=lambda: {"primary": "test-harness-worker"})
@@ -160,12 +156,11 @@ class ResetRequest(BaseModel):
 
 
 @router.post("/write/samples/seed", status_code=201)
-def seed_run(
-    body: SeedRunRequest,
+def seed_sample(
+    body: SeedSampleRequest,
 ) -> dict:
     try:
-        sample_id = _seed_run(
-            definition_id=body.definition_id,
+        sample_id = _seed_sample(
             benchmark_type=body.benchmark_type,
             instance_key=body.instance_key,
             worker_team=body.worker_team,
@@ -176,12 +171,7 @@ def seed_run(
     except UnknownSampleStatusError as exc:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"unknown run status: {body.status!r}",
-        ) from exc
-    except DefinitionNotFoundError as exc:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"definition {body.definition_id} not found",
+            detail=f"unknown sample status: {body.status!r}",
         ) from exc
     return {"sample_id": str(sample_id)}
 
@@ -195,7 +185,7 @@ def reset_test_rows(
 
 
 # ---------------------------------------------------------------------------
-# Experiment-run submission endpoint — the single entry point for smoke drivers.
+# Experiment sample submission endpoint — the single entry point for smoke drivers.
 #
 # Moved here (rather than a separate /samples POST) because it's the test
 # harness that cares about grouped multi-run submission.  Host-side
@@ -206,14 +196,14 @@ def reset_test_rows(
 # ---------------------------------------------------------------------------
 
 
-class ExperimentRunSlotRequest(BaseModel):
+class ExperimentSampleSlotRequest(BaseModel):
     worker_slug: str
     evaluator_slug: str
 
 
-class SubmitExperimentRunsRequest(BaseModel):
+class SubmitExperimentSamplesRequest(BaseModel):
     benchmark_slug: str
-    slots: list[ExperimentRunSlotRequest]
+    slots: list[ExperimentSampleSlotRequest]
     experiment: str
     sandbox_slug: str | None = None
     dependency_extras: tuple[str, ...] = ("none",)
@@ -223,23 +213,23 @@ class SubmitExperimentRunsRequest(BaseModel):
     limit: int = 1
 
 
-class SubmitExperimentRunsResponse(BaseModel):
+class SubmitExperimentSamplesResponse(BaseModel):
     sample_ids: list[UUID]
 
 
-@router.post("/write/experiment-runs", response_model=SubmitExperimentRunsResponse)
-async def submit_experiment_runs(
-    body: SubmitExperimentRunsRequest,
-) -> SubmitExperimentRunsResponse:
-    """Build + persist + dispatch N runs under one experiment tag.
+class _HarnessEnvironment(Environment):
+    samples: list[Sample]
+    source_mode: Literal["materialized"] = "materialized"
+
+    def iter_samples(self) -> Iterator[Sample]:
+        return iter(self.samples)
 
-    Per-slot flow persists the object-bound smoke ``Benchmark`` into the
-    immutable ``ExperimentDefinition`` tables. The v2 experiment grouping tag
-    is written into definition metadata and copied to ``SampleRecord.experiment``
-    by launch. Slots submit sequentially — typical N ≤ 3, so the
-    parallel-gather savings are negligible.
-    """
-    from ergon_core.core.application.experiments.service import persist_benchmark
+
+@router.post("/write/experiment-samples", response_model=SubmitExperimentSamplesResponse)
+async def submit_experiment_samples(
+    body: SubmitExperimentSamplesRequest,
+) -> SubmitExperimentSamplesResponse:
+    """Build + persist + dispatch samples under one experiment tag."""
 
     sample_ids: list[UUID] = []
     for slot in body.slots:
@@ -266,9 +256,37 @@ async def submit_experiment_runs(
         )
         setattr(benchmark_source, "worker_slug", slot.worker_slug)
         setattr(benchmark_source, "model", body.model)
-        handle = persist_benchmark(benchmark_source)
-
-        launched = await _run_experiment(ExperimentRunRequest(definition_id=handle.definition_id))
-        sample_ids.extend(launched.sample_ids)
-
-    return SubmitExperimentRunsResponse(sample_ids=sample_ids)
+        authored_samples: list[Sample] = []
+        for instance_key, tasks in benchmark_source.build_instances().items():
+            authored_samples.append(
+                Sample.from_tasks(
+                    name=f"{body.benchmark_slug}:{instance_key}",
+                    sample_key=instance_key,
+                    environment_name=body.benchmark_slug,
+                    tasks=tasks,
+                    sample_ref={"instance_key": instance_key},
+                    metadata={
+                        "experiment": body.experiment,
+                        "worker_slug": slot.worker_slug,
+                        "evaluator_slug": slot.evaluator_slug,
+                    },
+                )
+            )
+        environment = _HarnessEnvironment(
+            name=body.benchmark_slug,
+            samples=authored_samples[: body.limit],
+            metadata={"source": "test-harness"},
+        )
+        experiment = Experiment(
+            name=body.experiment,
+            environments=[environment],
+            metadata={"source": "test-harness"},
+        )
+        with get_session() as session:
+            result = await experiment.submit(
+                service=ExperimentSubmissionService.for_session(session),
+                k=body.limit,
+            )
+        sample_ids.extend(result.sample_ids)
+
+    return SubmitExperimentSamplesResponse(sample_ids=sample_ids)
diff --git a/ergon_core/ergon_core/core/jobs/resources/persist_outputs/contract.py b/ergon_core/ergon_core/core/jobs/resources/persist_outputs/contract.py
index 86020e367..90e0ea8f5 100644
--- a/ergon_core/ergon_core/core/jobs/resources/persist_outputs/contract.py
+++ b/ergon_core/ergon_core/core/jobs/resources/persist_outputs/contract.py
@@ -10,7 +10,6 @@ class PersistOutputsRequest(InngestEventContract):
     name: ClassVar[str] = "task/persist-outputs"
 
     sample_id: UUID
-    definition_id: UUID | None = None
     task_id: UUID
     execution_id: UUID
     sandbox_id: str | None = None
diff --git a/ergon_core/ergon_core/core/jobs/sandbox/setup/contract.py b/ergon_core/ergon_core/core/jobs/sandbox/setup/contract.py
index 33e779b5d..98db608ef 100644
--- a/ergon_core/ergon_core/core/jobs/sandbox/setup/contract.py
+++ b/ergon_core/ergon_core/core/jobs/sandbox/setup/contract.py
@@ -10,7 +10,6 @@ class SandboxSetupRequest(InngestEventContract):
     name: ClassVar[str] = "task/sandbox-setup"
 
     sample_id: UUID
-    definition_id: UUID | None = None
     task_id: UUID
     benchmark_type: str
     sandbox_slug: str | None = None
diff --git a/ergon_core/ergon_core/core/jobs/task/cancel_orphans/job.py b/ergon_core/ergon_core/core/jobs/task/cancel_orphans/job.py
index 606e0d1aa..91d20c5cd 100644
--- a/ergon_core/ergon_core/core/jobs/task/cancel_orphans/job.py
+++ b/ergon_core/ergon_core/core/jobs/task/cancel_orphans/job.py
@@ -26,7 +26,6 @@ async def _cancel_orphans_for(
     ctx: Any,
     *,
     sample_id: UUID,
-    definition_id: UUID | None,
     parent_task_id: UUID,
     cause: PropagationCancelCause,
 ) -> int:
@@ -38,7 +37,6 @@ async def _scan_and_cancel() -> dict:
             result = await svc.cancel_orphans(
                 session,
                 sample_id=sample_id,
-                definition_id=definition_id,
                 parent_task_id=parent_task_id,
                 cause=cause,
             )
@@ -89,7 +87,6 @@ async def run_cancel_orphans_on_cancelled_job(ctx: Any, payload: TaskCancelledEv
     return await _cancel_orphans_for(
         ctx,
         sample_id=payload.sample_id,
-        definition_id=payload.definition_id,
         parent_task_id=payload.task_id,
         cause="parent_terminal",
     )
diff --git a/ergon_core/ergon_core/core/jobs/task/evaluate/job.py b/ergon_core/ergon_core/core/jobs/task/evaluate/job.py
index f56c3f10f..b77972583 100644
--- a/ergon_core/ergon_core/core/jobs/task/evaluate/job.py
+++ b/ergon_core/ergon_core/core/jobs/task/evaluate/job.py
@@ -196,29 +196,23 @@ async def _run_evaluation(
         )
     )
 
-    # Trace span needs the evaluator_id for stable key derivation;
-    # reuse the persistence lookup so the span key matches the
-    # `sample_task_evaluations.definition_evaluator_id` FK on the
-    # row persist_success just wrote.
-    with get_session() as session:
-        evaluator_id = _evaluation_persistence.lookup_evaluator_id(
-            session,
-            sample_id,
-            binding_key,
-            evaluator_type=evaluator.type_slug,
-            snapshot_json=evaluator.model_dump(mode="json"),
-        )
+    evaluator_event_id = persisted.evaluation_id
     get_trace_sink().emit_span(
         CompletedSpan(
             name="evaluation.task",
-            context=evaluation_task_context(sample_id, view.task_id, execution_id, evaluator_id),
+            context=evaluation_task_context(
+                sample_id,
+                view.task_id,
+                execution_id,
+                evaluator_event_id,
+            ),
             start_time=span_start,
             end_time=datetime.now(UTC),
             attributes={
                 "sample_id": str(sample_id),
                 "task_id": str(view.task_id),
                 "execution_id": str(execution_id),
-                "evaluator_id": str(evaluator_id),
+                "evaluator_event_id": str(evaluator_event_id),
                 "evaluator_binding_key": binding_key,
                 "evaluator_type": type(evaluator).type_slug,
                 "evaluator_index": evaluator_index,
diff --git a/ergon_core/ergon_core/core/jobs/task/execute/job.py b/ergon_core/ergon_core/core/jobs/task/execute/job.py
index 926caa245..134d01836 100644
--- a/ergon_core/ergon_core/core/jobs/task/execute/job.py
+++ b/ergon_core/ergon_core/core/jobs/task/execute/job.py
@@ -96,7 +96,6 @@ async def _prepare() -> PreparedTaskExecution:
         return await svc.prepare(
             PrepareTaskExecutionCommand(
                 sample_id=payload.sample_id,
-                definition_id=payload.definition_id,
                 task_id=payload.task_id,
             )
         )
@@ -115,7 +114,6 @@ async def _invoke_sandbox_setup(
         function=sandbox_setup_function,
         data=SandboxSetupRequest(
             sample_id=payload.sample_id,
-            definition_id=payload.definition_id,
             task_id=payload.task_id,
             benchmark_type=prepared.benchmark_type,
             sandbox_slug=_load_sandbox_slug(payload.sample_id),
@@ -150,7 +148,6 @@ async def _invoke_worker_execute(
         function=worker_execute_function,
         data=WorkerExecuteJobRequest(
             sample_id=payload.sample_id,
-            definition_id=payload.definition_id,
             task_id=payload.task_id,
             execution_id=prepared.execution_id,
             sandbox_id=sandbox_result.sandbox_id,
@@ -231,7 +228,6 @@ async def _invoke_persist_outputs(
         function=persist_outputs_function,
         data=PersistOutputsRequest(
             sample_id=payload.sample_id,
-            definition_id=payload.definition_id,
             task_id=payload.task_id,
             execution_id=prepared.execution_id,
             sandbox_id=sandbox_result.sandbox_id,
@@ -251,7 +247,6 @@ async def _emit_task_completed(
         TaskCompletedEvent.name,
         TaskCompletedEvent(
             sample_id=payload.sample_id,
-            definition_id=payload.definition_id,
             task_id=payload.task_id,
             execution_id=prepared.execution_id,
             sandbox_id=sandbox_id,
@@ -269,7 +264,6 @@ async def _emit_task_failed(
         TaskFailedEvent.name,
         TaskFailedEvent(
             sample_id=payload.sample_id,
-            definition_id=payload.definition_id,
             task_id=payload.task_id,
             execution_id=prepared.execution_id,
             error=error_message,
@@ -389,7 +383,6 @@ async def run_execute_task_job(
                 end_time=datetime.now(UTC),
                 attributes={
                     "sample_id": str(payload.sample_id),
-                    "definition_id": str(payload.definition_id),
                     "task_id": str(prepared.task_id),
                     "execution_id": str(prepared.execution_id),
                     "task_slug": prepared.task_slug,
@@ -455,7 +448,6 @@ async def run_execute_task_job(
                     status_message=truncate_text(error_msg),
                     attributes={
                         "sample_id": str(payload.sample_id),
-                        "definition_id": str(payload.definition_id),
                         "task_id": str(prepared.task_id),
                         "execution_id": str(prepared.execution_id),
                         "task_slug": prepared.task_slug,
diff --git a/ergon_core/ergon_core/core/jobs/task/propagate/job.py b/ergon_core/ergon_core/core/jobs/task/propagate/job.py
index 329392d33..54a41c62c 100644
--- a/ergon_core/ergon_core/core/jobs/task/propagate/job.py
+++ b/ergon_core/ergon_core/core/jobs/task/propagate/job.py
@@ -33,7 +33,6 @@ async def run_propagate_task_job(payload: TaskCompletedEvent) -> TaskPropagateRe
     propagation = await svc.propagate(
         PropagateTaskCompletionCommand(
             sample_id=payload.sample_id,
-            definition_id=payload.definition_id,
             task_id=payload.task_id,
             execution_id=payload.execution_id,
         )
@@ -44,7 +43,6 @@ async def run_propagate_task_job(payload: TaskCompletedEvent) -> TaskPropagateRe
             TaskReadyEvent.name,
             TaskReadyEvent(
                 sample_id=payload.sample_id,
-                definition_id=payload.definition_id,
                 task_id=td.task_id,
             ).model_dump(mode="json"),
         )
@@ -57,7 +55,6 @@ async def run_propagate_task_job(payload: TaskCompletedEvent) -> TaskPropagateRe
                 WorkflowCompletedEvent.name,
                 WorkflowCompletedEvent(
                     sample_id=payload.sample_id,
-                    definition_id=payload.definition_id,
                 ).model_dump(mode="json"),
             )
         )
@@ -67,7 +64,6 @@ async def run_propagate_task_job(payload: TaskCompletedEvent) -> TaskPropagateRe
                 WorkflowFailedEvent.name,
                 WorkflowFailedEvent(
                     sample_id=payload.sample_id,
-                    definition_id=payload.definition_id,
                     error="Workflow failed during task propagation",
                 ).model_dump(mode="json"),
             )
@@ -113,7 +109,6 @@ async def run_propagate_task_failure_job(payload: TaskFailedEvent) -> TaskPropag
     propagation = await svc.propagate_failure(
         PropagateTaskCompletionCommand(
             sample_id=payload.sample_id,
-            definition_id=payload.definition_id,
             task_id=payload.task_id,
             execution_id=payload.execution_id,
         )
@@ -128,7 +123,6 @@ async def run_propagate_task_failure_job(payload: TaskFailedEvent) -> TaskPropag
                 WorkflowFailedEvent.name,
                 WorkflowFailedEvent(
                     sample_id=payload.sample_id,
-                    definition_id=payload.definition_id,
                     error=payload.error,
                 ).model_dump(mode="json"),
             )
diff --git a/ergon_core/ergon_core/core/jobs/task/worker_execute/contract.py b/ergon_core/ergon_core/core/jobs/task/worker_execute/contract.py
index f46131ece..ec9bea11c 100644
--- a/ergon_core/ergon_core/core/jobs/task/worker_execute/contract.py
+++ b/ergon_core/ergon_core/core/jobs/task/worker_execute/contract.py
@@ -11,7 +11,6 @@ class WorkerExecuteRequest(InngestEventContract):
     name: ClassVar[str] = "task/worker-execute"
 
     sample_id: UUID
-    definition_id: UUID | None = None
     task_id: UUID
     execution_id: UUID
     sandbox_id: str
diff --git a/ergon_core/ergon_core/core/jobs/task/worker_execute/job.py b/ergon_core/ergon_core/core/jobs/task/worker_execute/job.py
index 4ab5e88ae..2e693f4bb 100644
--- a/ergon_core/ergon_core/core/jobs/task/worker_execute/job.py
+++ b/ergon_core/ergon_core/core/jobs/task/worker_execute/job.py
@@ -85,7 +85,6 @@ async def run_worker_execute_job(
         sample_id=payload.sample_id,
         task_id=payload.task_id,
         execution_id=payload.execution_id,
-        definition_id=payload.definition_id,
         sandbox_id=payload.sandbox_id,
         task_mgmt=_task_management_service_for_context(ctx),
         task_inspect=TaskInspectionService(),
@@ -208,7 +207,6 @@ class _ReadyDispatch(BaseModel):
     model_config = {"frozen": True}
 
     sample_id: UUID
-    definition_id: UUID | None = None
     task_id: UUID
 
 
@@ -272,7 +270,6 @@ async def _run_spawn() -> _SpawnTaskStepResult:
     async def _collect_ready_dispatch(
         self,
         sample_id: UUID,
-        definition_id: UUID | None,
         task_id: UUID,
     ) -> None:
         if self._active_ready_dispatches is None:
@@ -281,9 +278,7 @@ async def _collect_ready_dispatch(
                 sample_id=sample_id,
                 task_id=task_id,
             )
-        self._active_ready_dispatches.append(
-            _ReadyDispatch(sample_id=sample_id, definition_id=definition_id, task_id=task_id)
-        )
+        self._active_ready_dispatches.append(_ReadyDispatch(sample_id=sample_id, task_id=task_id))
 
     async def _dispatch_collected_ready_events(
         self,
@@ -293,7 +288,6 @@ async def _dispatch_collected_ready_events(
         for dispatch in ready:
             event = TaskReadyEvent(
                 sample_id=dispatch.sample_id,
-                definition_id=dispatch.definition_id,
                 task_id=dispatch.task_id,
             )
             await send_job_step_event(
diff --git a/ergon_core/ergon_core/core/jobs/workflow/complete/job.py b/ergon_core/ergon_core/core/jobs/workflow/complete/job.py
index 797a0fcd8..0bc45178f 100644
--- a/ergon_core/ergon_core/core/jobs/workflow/complete/job.py
+++ b/ergon_core/ergon_core/core/jobs/workflow/complete/job.py
@@ -31,7 +31,6 @@ async def run_complete_workflow_job(payload: WorkflowCompletedEvent) -> Workflow
     finalized = svc.finalize(
         FinalizeWorkflowCommand(
             sample_id=payload.sample_id,
-            definition_id=payload.definition_id,
         )
     )
 
@@ -77,7 +76,6 @@ async def run_complete_workflow_job(payload: WorkflowCompletedEvent) -> Workflow
             end_time=datetime.now(UTC),
             attributes={
                 "sample_id": str(payload.sample_id),
-                "definition_id": str(payload.definition_id),
                 "final_score": finalized.final_score,
                 "normalized_score": finalized.normalized_score,
                 "evaluators_count": finalized.evaluators_count,
@@ -96,7 +94,6 @@ async def run_complete_workflow_job(payload: WorkflowCompletedEvent) -> Workflow
                     end_time=run.completed_at,
                     attributes={
                         "sample_id": str(payload.sample_id),
-                        "definition_id": str(payload.definition_id),
                         "status": run.status,
                         "final_score": finalized.final_score,
                         "normalized_score": finalized.normalized_score,
diff --git a/ergon_core/ergon_core/core/jobs/workflow/fail/job.py b/ergon_core/ergon_core/core/jobs/workflow/fail/job.py
index a6d2d254f..88875978e 100644
--- a/ergon_core/ergon_core/core/jobs/workflow/fail/job.py
+++ b/ergon_core/ergon_core/core/jobs/workflow/fail/job.py
@@ -74,7 +74,6 @@ async def run_fail_workflow_job(payload: WorkflowFailedEvent) -> WorkflowFailedR
             status_message=truncate_text(payload.error),
             attributes={
                 "sample_id": str(payload.sample_id),
-                "definition_id": str(payload.definition_id),
                 "error": truncate_text(payload.error),
             },
         )
@@ -93,7 +92,6 @@ async def run_fail_workflow_job(payload: WorkflowFailedEvent) -> WorkflowFailedR
                     status_message=truncate_text(payload.error),
                     attributes={
                         "sample_id": str(payload.sample_id),
-                        "definition_id": str(payload.definition_id),
                         "status": run.status,
                         "error": truncate_text(payload.error),
                     },
diff --git a/ergon_core/ergon_core/core/jobs/workflow/start/job.py b/ergon_core/ergon_core/core/jobs/workflow/start/job.py
index ba810b4da..0e57d0224 100644
--- a/ergon_core/ergon_core/core/jobs/workflow/start/job.py
+++ b/ergon_core/ergon_core/core/jobs/workflow/start/job.py
@@ -23,16 +23,13 @@
 
 
 async def run_start_workflow_job(payload: WorkflowStartedEvent) -> WorkflowStartResult:
-    logger.info(
-        "workflow-start sample_id=%s definition_id=%s", payload.sample_id, payload.definition_id
-    )
+    logger.info("workflow-start sample_id=%s", payload.sample_id)
     span_start = datetime.now(UTC)
 
     svc = WorkflowService()
     initialized = await svc.initialize(
         InitializeWorkflowCommand(
             sample_id=payload.sample_id,
-            definition_id=payload.definition_id,
         )
     )
 
@@ -41,7 +38,6 @@ async def run_start_workflow_job(payload: WorkflowStartedEvent) -> WorkflowStart
             TaskReadyEvent.name,
             TaskReadyEvent(
                 sample_id=payload.sample_id,
-                definition_id=payload.definition_id,
                 task_id=td.task_id,
             ).model_dump(mode="json"),
         )
@@ -50,22 +46,20 @@ async def run_start_workflow_job(payload: WorkflowStartedEvent) -> WorkflowStart
 
     await send_job_events(events)
 
-    if payload.definition_id is not None:
-        snapshot = SampleSnapshotReadService().build_snapshot(payload.sample_id)
-        if snapshot is None:
-            raise RuntimeError(f"Run snapshot {payload.sample_id} not found after workflow start")
+    snapshot = SampleSnapshotReadService().build_snapshot(payload.sample_id)
+    if snapshot is None:
+        raise RuntimeError(f"Sample snapshot {payload.sample_id} not found after workflow start")
 
-        await get_dashboard_event_publisher().publish(
-            DashboardWorkflowStartedEvent(
-                sample_id=payload.sample_id,
-                definition_id=payload.definition_id,
-                workflow_name=initialized.benchmark_type,
-                snapshot=snapshot,
-                started_at=snapshot.started_at or utcnow(),
-                total_tasks=snapshot.total_tasks,
-                total_leaf_tasks=snapshot.total_leaf_tasks,
-            )
+    await get_dashboard_event_publisher().publish(
+        DashboardWorkflowStartedEvent(
+            sample_id=payload.sample_id,
+            workflow_name=initialized.benchmark_type,
+            snapshot=snapshot,
+            started_at=snapshot.started_at or utcnow(),
+            total_tasks=snapshot.total_tasks,
+            total_leaf_tasks=snapshot.total_leaf_tasks,
         )
+    )
 
     result = WorkflowStartResult(
         sample_id=payload.sample_id,
@@ -81,7 +75,6 @@ async def run_start_workflow_job(payload: WorkflowStartedEvent) -> WorkflowStart
             end_time=datetime.now(UTC),
             attributes={
                 "sample_id": str(payload.sample_id),
-                "definition_id": str(payload.definition_id),
                 "total_tasks": initialized.total_tasks,
                 "initial_ready_tasks": len(initialized.initial_ready_tasks),
             },
@@ -105,7 +98,6 @@ async def run_workflow_start_job(
     initialized = await svc.initialize(
         InitializeWorkflowCommand(
             sample_id=event.sample_id,
-            definition_id=event.definition_id,
         ),
         session=session,
     )
diff --git a/ergon_core/ergon_core/core/persistence/definitions/__init__.py b/ergon_core/ergon_core/core/persistence/definitions/__init__.py
deleted file mode 100644
index e69de29bb..000000000
diff --git a/ergon_core/ergon_core/core/persistence/definitions/models.py b/ergon_core/ergon_core/core/persistence/definitions/models.py
deleted file mode 100644
index a886d238f..000000000
--- a/ergon_core/ergon_core/core/persistence/definitions/models.py
+++ /dev/null
@@ -1,280 +0,0 @@
-"""Immutable experiment-definition tables.
-
-These store identity (type slugs, model targets, binding keys) not serialized
-Python constructor state.  The runtime reconstructs live objects from the
-registry using these identity fields.
-"""
-
-from datetime import datetime
-from typing import TypeVar
-from uuid import UUID, uuid4
-
-from ergon_core.core.shared.json_types import JsonObject
-from ergon_core.core.shared.utils import utcnow as _utcnow
-from pydantic import BaseModel, model_validator
-from sqlalchemy import JSON, Column, DateTime
-from sqlmodel import Field, SQLModel
-
-TZDateTime = DateTime(timezone=True)
-PayloadModelT = TypeVar("PayloadModelT", bound=BaseModel)
-
-# ---------------------------------------------------------------------------
-# ExperimentDefinition
-# ---------------------------------------------------------------------------
-
-
-class ExperimentDefinition(SQLModel, table=True):
-    __tablename__ = "experiment_definitions"
-
-    id: UUID = Field(default_factory=uuid4, primary_key=True)
-    benchmark_type: str = Field(index=True)
-    name: str = Field(index=True)
-    description: str | None = None
-    created_by: str | None = None
-    metadata_json: dict = Field(default_factory=dict, sa_column=Column(JSON))
-    created_at: datetime = Field(default_factory=_utcnow, sa_type=TZDateTime)
-
-    # JSON accessor pattern: parsed_*() returns typed model, _parse_*()
-    # classmethod for reuse, @model_validator for fail-fast at row load.
-    # Core code never reads raw dict from a JSON column.
-
-    def parsed_metadata(self) -> JsonObject:
-        return self.__class__._parse_metadata(self.metadata_json)
-
-    @classmethod
-    def _parse_metadata(cls, data: dict) -> JsonObject:
-        if not isinstance(data, dict):
-            raise ValueError(f"metadata_json must be a dict, got {type(data).__name__}")
-        return data
-
-    @model_validator(mode="after")
-    def _validate_metadata_json(self) -> "ExperimentDefinition":
-        self.__class__._parse_metadata(self.metadata_json)
-        return self
-
-
-# ---------------------------------------------------------------------------
-# ExperimentDefinitionWorker
-# ---------------------------------------------------------------------------
-
-
-class ExperimentDefinitionWorker(SQLModel, table=True):
-    __tablename__ = "experiment_definition_workers"
-
-    id: UUID = Field(default_factory=uuid4, primary_key=True)
-    experiment_definition_id: UUID = Field(
-        foreign_key="experiment_definitions.id",
-        index=True,
-    )
-    binding_key: str = Field(index=True)
-    worker_type: str = Field(index=True)
-    model_target: str
-    snapshot_json: dict = Field(default_factory=dict, sa_column=Column(JSON))
-    created_at: datetime = Field(default_factory=_utcnow, sa_type=TZDateTime)
-
-    # -- JSON accessor: snapshot_json --
-
-    def parsed_snapshot(self) -> JsonObject:
-        return self.__class__._parse_snapshot(self.snapshot_json)
-
-    @classmethod
-    def _parse_snapshot(cls, data: dict) -> JsonObject:
-        if not isinstance(data, dict):
-            raise ValueError(f"snapshot_json must be a dict, got {type(data).__name__}")
-        return data
-
-    @model_validator(mode="after")
-    def _validate_snapshot_json(self) -> "ExperimentDefinitionWorker":
-        self.__class__._parse_snapshot(self.snapshot_json)
-        return self
-
-
-# ---------------------------------------------------------------------------
-# ExperimentDefinitionEvaluator
-# ---------------------------------------------------------------------------
-
-
-class ExperimentDefinitionEvaluator(SQLModel, table=True):
-    __tablename__ = "experiment_definition_evaluators"
-
-    id: UUID = Field(default_factory=uuid4, primary_key=True)
-    experiment_definition_id: UUID = Field(
-        foreign_key="experiment_definitions.id",
-        index=True,
-    )
-    binding_key: str = Field(index=True)
-    evaluator_type: str = Field(index=True)
-    snapshot_json: dict = Field(default_factory=dict, sa_column=Column(JSON))
-    created_at: datetime = Field(default_factory=_utcnow, sa_type=TZDateTime)
-
-    # -- JSON accessor: snapshot_json --
-
-    def parsed_snapshot(self) -> JsonObject:
-        return self.__class__._parse_snapshot(self.snapshot_json)
-
-    @classmethod
-    def _parse_snapshot(cls, data: dict) -> JsonObject:
-        if not isinstance(data, dict):
-            raise ValueError(f"snapshot_json must be a dict, got {type(data).__name__}")
-        return data
-
-    @model_validator(mode="after")
-    def _validate_snapshot_json(self) -> "ExperimentDefinitionEvaluator":
-        self.__class__._parse_snapshot(self.snapshot_json)
-        return self
-
-
-# ---------------------------------------------------------------------------
-# ExperimentDefinitionInstance
-# ---------------------------------------------------------------------------
-
-
-class ExperimentDefinitionInstance(SQLModel, table=True):
-    __tablename__ = "experiment_definition_instances"
-
-    id: UUID = Field(default_factory=uuid4, primary_key=True)
-    experiment_definition_id: UUID = Field(
-        foreign_key="experiment_definitions.id",
-        index=True,
-    )
-    instance_key: str = Field(index=True)
-    benchmark_instance_state: dict = Field(default_factory=dict, sa_column=Column(JSON))
-    created_at: datetime = Field(default_factory=_utcnow, sa_type=TZDateTime)
-
-    # -- JSON accessor: benchmark_instance_state --
-
-    def parsed_instance_state(self) -> JsonObject:
-        return self.__class__._parse_instance_state(self.benchmark_instance_state)
-
-    @classmethod
-    def _parse_instance_state(cls, data: dict) -> JsonObject:
-        if not isinstance(data, dict):
-            raise ValueError(f"benchmark_instance_state must be a dict, got {type(data).__name__}")
-        return data
-
-    @model_validator(mode="after")
-    def _validate_benchmark_instance_state(self) -> "ExperimentDefinitionInstance":
-        self.__class__._parse_instance_state(self.benchmark_instance_state)
-        return self
-
-
-# ---------------------------------------------------------------------------
-# ExperimentDefinitionTask
-# ---------------------------------------------------------------------------
-
-
-class ExperimentDefinitionTask(SQLModel, table=True):
-    __tablename__ = "experiment_definition_tasks"
-
-    id: UUID = Field(default_factory=uuid4, primary_key=True)
-    experiment_definition_id: UUID = Field(
-        foreign_key="experiment_definitions.id",
-        index=True,
-    )
-    instance_id: UUID = Field(
-        foreign_key="experiment_definition_instances.id",
-        index=True,
-    )
-    task_slug: str = Field(index=True)
-    parent_task_id: UUID | None = Field(
-        default=None,
-        foreign_key="experiment_definition_tasks.id",
-    )
-    task_type: str | None = None
-    description: str
-    task_payload_json: JsonObject = Field(
-        default_factory=dict,
-        sa_column=Column("task_payload", JSON),
-    )
-    # Full ``_type``-discriminated Task snapshot. ``task_payload_json`` carries
-    # only benchmark-specific payload data; ``task_json`` is the complete
-    # object-bound Task (worker + sandbox + evaluators + scalar fields) that
-    # ``Task.from_definition`` reconstructs end-to-end.
-    task_json: JsonObject = Field(
-        default_factory=dict,
-        sa_column=Column("task_json", JSON, nullable=False, server_default="{}"),
-    )
-    created_at: datetime = Field(default_factory=_utcnow, sa_type=TZDateTime)
-
-    # -- JSON accessor: task_payload --
-
-    def task_payload_as(self, payload_model: type[PayloadModelT]) -> PayloadModelT:
-        return payload_model.model_validate(self.task_payload_json)
-
-    @classmethod
-    def _parse_task_payload_json(cls, data: JsonObject) -> JsonObject:
-        if not isinstance(data, dict):
-            raise ValueError(f"task_payload_json must be a dict, got {type(data).__name__}")
-        return data
-
-    @model_validator(mode="after")
-    def _validate_task_payload(self) -> "ExperimentDefinitionTask":
-        self.__class__._parse_task_payload_json(self.task_payload_json)
-        return self
-
-
-# ---------------------------------------------------------------------------
-# ExperimentDefinitionTaskDependency
-# ---------------------------------------------------------------------------
-
-
-class ExperimentDefinitionTaskDependency(SQLModel, table=True):
-    __tablename__ = "experiment_definition_task_dependencies"
-
-    id: UUID = Field(default_factory=uuid4, primary_key=True)
-    experiment_definition_id: UUID = Field(
-        foreign_key="experiment_definitions.id",
-        index=True,
-    )
-    task_id: UUID = Field(
-        foreign_key="experiment_definition_tasks.id",
-        index=True,
-    )
-    depends_on_task_id: UUID = Field(
-        foreign_key="experiment_definition_tasks.id",
-        index=True,
-    )
-    created_at: datetime = Field(default_factory=_utcnow, sa_type=TZDateTime)
-
-
-# ---------------------------------------------------------------------------
-# ExperimentDefinitionTaskAssignment
-# ---------------------------------------------------------------------------
-
-
-class ExperimentDefinitionTaskAssignment(SQLModel, table=True):
-    __tablename__ = "experiment_definition_task_assignments"
-
-    id: UUID = Field(default_factory=uuid4, primary_key=True)
-    experiment_definition_id: UUID = Field(
-        foreign_key="experiment_definitions.id",
-        index=True,
-    )
-    task_id: UUID = Field(
-        foreign_key="experiment_definition_tasks.id",
-        index=True,
-    )
-    worker_binding_key: str = Field(index=True)
-    assignment_type: str = Field(default="initial")
-    created_at: datetime = Field(default_factory=_utcnow, sa_type=TZDateTime)
-
-
-# ---------------------------------------------------------------------------
-# ExperimentDefinitionTaskEvaluator
-# ---------------------------------------------------------------------------
-
-
-class ExperimentDefinitionTaskEvaluator(SQLModel, table=True):
-    __tablename__ = "experiment_definition_task_evaluators"
-
-    id: UUID = Field(default_factory=uuid4, primary_key=True)
-    experiment_definition_id: UUID = Field(
-        foreign_key="experiment_definitions.id",
-        index=True,
-    )
-    task_id: UUID = Field(
-        foreign_key="experiment_definition_tasks.id",
-        index=True,
-    )
-    evaluator_binding_key: str = Field(index=True)
-    created_at: datetime = Field(default_factory=_utcnow, sa_type=TZDateTime)
diff --git a/ergon_core/ergon_core/core/persistence/graph/models.py b/ergon_core/ergon_core/core/persistence/graph/models.py
index f517bf936..5d74fecfe 100644
--- a/ergon_core/ergon_core/core/persistence/graph/models.py
+++ b/ergon_core/ergon_core/core/persistence/graph/models.py
@@ -33,10 +33,7 @@ class SampleGraphNode(SQLModel, table=True):
         description="Canonical runtime identity for this task within a run.",
     )
     instance_key: str = Field(
-        description=(
-            "Benchmark instance identifier for this node, such as a dataset row or "
-            "environment variant; maps to ExperimentDefinitionInstance.instance_key."
-        )
+        description="Dataset row, environment variant, or caller-provided sample grouping key."
     )
     task_slug: str = Field(
         index=True,
@@ -52,7 +49,7 @@ class SampleGraphNode(SQLModel, table=True):
         sa_column=Column(JSON, nullable=False, server_default="{}"),
         description=(
             "Run-tier snapshot of the authored Task. Static nodes copy "
-            "this from experiment_definition_tasks at prepare-run time; "
+            "this from the authored sample at materialization time; "
             "dynamic nodes write it directly at spawn time."
         ),
     )
@@ -61,10 +58,8 @@ class SampleGraphNode(SQLModel, table=True):
         default=False,
         sa_column=Column(Boolean, nullable=False, server_default="false"),
         description=(
-            "True when this node was spawned during a run (no row in "
-            "experiment_definition_tasks). Denormalized at insert time "
-            "per 02-persistence-layer.md §5 so the static-vs-dynamic "
-            "discriminator avoids a join."
+            "True when this node was spawned during execution. Denormalized "
+            "at insert time so the static-vs-dynamic discriminator avoids a join."
         ),
     )
 
@@ -115,10 +110,6 @@ class SampleGraphEdge(SQLModel, table=True):
 
     id: UUID = Field(default_factory=uuid4, primary_key=True)
     sample_id: UUID = Field(foreign_key="samples.id", index=True)
-    definition_dependency_id: UUID | None = Field(
-        default=None,
-        foreign_key="experiment_definition_task_dependencies.id",
-    )
     source_task_id: UUID = Field(
         index=True,
     )
diff --git a/ergon_core/ergon_core/core/persistence/shared/types.py b/ergon_core/ergon_core/core/persistence/shared/types.py
index e67479d71..37221554d 100644
--- a/ergon_core/ergon_core/core/persistence/shared/types.py
+++ b/ergon_core/ergon_core/core/persistence/shared/types.py
@@ -15,5 +15,4 @@
 # ── UUID aliases ──────────────────────────────────────────────────
 SampleId = NewType("SampleId", UUID)
 NodeId = NewType("NodeId", UUID)
-DefinitionId = NewType("DefinitionId", UUID)
 EdgeId = NewType("EdgeId", UUID)
diff --git a/ergon_core/ergon_core/core/persistence/telemetry/models.py b/ergon_core/ergon_core/core/persistence/telemetry/models.py
index 4176df6c2..2a8b0f528 100644
--- a/ergon_core/ergon_core/core/persistence/telemetry/models.py
+++ b/ergon_core/ergon_core/core/persistence/telemetry/models.py
@@ -1,8 +1,4 @@
-"""Run-scoped telemetry tables.
-
-Telemetry rows reference bound definition rows — they never become the source
-of truth for the definition itself.
-"""
+"""Sample-scoped telemetry tables."""
 
 from datetime import datetime
 from uuid import UUID, uuid4
@@ -34,17 +30,23 @@ class SampleRecord(SQLModel, table=True):
     __tablename__ = "samples"
 
     id: UUID = Field(default_factory=uuid4, primary_key=True)
-    definition_id: UUID | None = Field(
+    experiment_id: UUID | None = Field(
         default=None,
-        foreign_key="experiment_definitions.id",
         index=True,
-        description="Canonical runtime ExperimentDefinition id for this run.",
+        description="Owning persisted experiment for this selected sample.",
+    )
+    environment_id: UUID | None = Field(
+        default=None,
+        index=True,
+        description="Owning persisted environment that produced this sample.",
     )
-    experiment_id: UUID | None = Field(default=None, index=True)
-    environment_id: UUID | None = Field(default=None, index=True)
     sampler_invocation_id: UUID | None = Field(default=None, index=True)
     pool_entry_id: UUID | None = Field(default=None, index=True)
-    sample_key: str | None = Field(default=None, index=True)
+    sample_key: str | None = Field(
+        default=None,
+        index=True,
+        description="Stable sample key within the owning environment.",
+    )
     sample_ref_json: dict = Field(default_factory=dict, sa_column=Column(JSON))
     benchmark_type: str = Field(index=True)
     instance_key: str = Field(index=True)
@@ -60,10 +62,7 @@ class SampleRecord(SQLModel, table=True):
     evaluator_slug: str | None = Field(
         default=None,
         index=True,
-        description=(
-            "Compatibility/display-only evaluator slug; runtime evaluation "
-            "uses object-bound task snapshots and definition evaluator rows."
-        ),
+        description="Display-only evaluator slug; runtime evaluation uses task snapshots.",
     )
     model_target: str | None = None
     sandbox_slug: str | None = Field(
@@ -145,11 +144,6 @@ class SampleTaskAttempt(SQLModel, table=True):
     id: UUID = Field(default_factory=uuid4, primary_key=True)
     sample_id: UUID = Field(foreign_key="samples.id", index=True)
     task_id: UUID = Field(index=True)
-    definition_worker_id: UUID | None = Field(
-        default=None,
-        foreign_key="experiment_definition_workers.id",
-        index=True,
-    )
     attempt_number: int = 1
     status: TaskExecutionStatus = Field(index=True)
     started_at: datetime | None = Field(default=None, sa_type=TZDateTime)
@@ -286,10 +280,7 @@ class SampleTaskEvaluation(SQLModel, table=True):
         index=True,
     )
     task_id: UUID = Field(index=True)
-    definition_evaluator_id: UUID = Field(
-        foreign_key="experiment_definition_evaluators.id",
-        index=True,
-    )
+    evaluator_slug: str = Field(index=True)
     score: float | None = None
     passed: bool | None = None
     feedback: str | None = None
diff --git a/ergon_core/ergon_core/core/views/dashboard_events/contracts.py b/ergon_core/ergon_core/core/views/dashboard_events/contracts.py
index 3ecedd25e..de646c060 100644
--- a/ergon_core/ergon_core/core/views/dashboard_events/contracts.py
+++ b/ergon_core/ergon_core/core/views/dashboard_events/contracts.py
@@ -8,7 +8,7 @@
 """
 
 from datetime import datetime
-from typing import ClassVar
+from typing import Any, ClassVar
 from uuid import UUID
 
 from ergon_core.core.views.samples.models import (
@@ -32,7 +32,6 @@ class DashboardWorkflowStartedEvent(InngestEventContract):
     name: ClassVar[str] = "dashboard/workflow.started"
 
     sample_id: UUID
-    definition_id: UUID
     workflow_name: str
     snapshot: SampleSnapshotDto
     started_at: datetime
@@ -164,6 +163,10 @@ class DashboardSampleRuntimeEvent(InngestEventContract):
 
     event: SampleRuntimeEventView
 
+    def model_dump(self, *args: Any, **kwargs: Any) -> dict[str, Any]:
+        kwargs["by_alias"] = True
+        return super().model_dump(*args, **kwargs)
+
 
 class DashboardContextEventEvent(InngestEventContract):
     name: ClassVar[str] = "dashboard/context.event"
diff --git a/ergon_core/ergon_core/core/views/experiments/models.py b/ergon_core/ergon_core/core/views/experiments/models.py
index 6a986fc19..44ced1424 100644
--- a/ergon_core/ergon_core/core/views/experiments/models.py
+++ b/ergon_core/ergon_core/core/views/experiments/models.py
@@ -3,7 +3,7 @@
 from datetime import datetime
 from uuid import UUID
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field
 
 
 def _to_camel(value: str) -> str:
@@ -15,125 +15,6 @@ class CamelModel(BaseModel):
     model_config = ConfigDict(alias_generator=_to_camel, populate_by_name=True)
 
 
-class ExperimentStatusCountsDto(BaseModel):
-    pending: int = 0
-    executing: int = 0
-    evaluating: int = 0
-    completed: int = 0
-    failed: int = 0
-    cancelled: int = 0
-
-
-class ExperimentSummaryDto(BaseModel):
-    definition_id: UUID
-    name: str
-    description: str | None = None
-    benchmark_type: str
-    sample_count: int
-    status: str
-    default_worker_team: dict = Field(default_factory=dict)
-    default_evaluator_slug: str | None = None
-    default_model_target: str | None = None
-    created_by: str | None = None
-    created_at: datetime
-    started_at: datetime | None = None
-    completed_at: datetime | None = None
-    run_count: int = 0
-    status_counts: ExperimentStatusCountsDto = Field(default_factory=ExperimentStatusCountsDto)
-    failure_count: int = 0
-    latest_activity_at: datetime | None = None
-    average_score: float | None = None
-    average_duration_ms: int | None = None
-    average_tasks: float | None = None
-    total_cost_usd: float | None = None
-
-
-class ExperimentRunMetricsDto(BaseModel):
-    sample_id: UUID
-    run_name: str | None = None
-    status: str
-    sample_label: str | None = None
-    instance_key: str
-    score: float | None = None
-    return_value: float | None = None
-    duration_ms: int | None = None
-    total_tasks: int | None = None
-    tool_call_count: int = 0
-    total_tokens: int | None = None
-    token_breakdown: dict[str, int] = Field(default_factory=dict)
-    total_cost_usd: float | None = None
-    cost_observed: bool = False
-    model_target: str | None = None
-    evaluator_slug: str | None = None
-    error_summary: str | None = None
-
-
-class ExperimentRunRowDto(BaseModel):
-    sample_id: UUID
-    definition_id: UUID | None = None
-    benchmark_type: str
-    instance_key: str
-    status: str
-    created_at: datetime
-    started_at: datetime | None = None
-    completed_at: datetime | None = None
-    evaluator_slug: str | None = None
-    model_target: str | None = None
-    worker_team: dict = Field(default_factory=dict)
-    seed: int | None = None
-    running_time_ms: int | None = None
-    final_score: float | None = None
-    total_tasks: int | None = None
-    total_cost_usd: float | None = None
-    error_message: str | None = None
-    metrics: ExperimentRunMetricsDto
-
-
-class ExperimentAnalyticsDto(BaseModel):
-    total_runs: int = 0
-    status_counts: ExperimentStatusCountsDto = Field(default_factory=ExperimentStatusCountsDto)
-    average_score: float | None = None
-    average_duration_ms: int | None = None
-    average_tasks: float | None = None
-    total_cost_usd: float | None = None
-    latest_activity_at: datetime | None = None
-    error_count: int = 0
-
-
-class ExperimentDetailDto(BaseModel):
-    # Kept denormalized so the public contract exposes definition identity and
-    # display fields without requiring consumers to traverse the nested summary.
-    definition_id: UUID | None = None
-    name: str | None = None
-    description: str | None = None
-    benchmark_type: str | None = None
-    experiment: ExperimentSummaryDto
-    runs: list[ExperimentRunRowDto] = Field(default_factory=list)
-    analytics: ExperimentAnalyticsDto = Field(default_factory=ExperimentAnalyticsDto)
-    sample_selection: dict = Field(default_factory=dict)
-    design: dict = Field(default_factory=dict)
-    metadata: dict = Field(default_factory=dict)
-
-    @model_validator(mode="after")
-    def _backfill_identity_from_summary(self) -> "ExperimentDetailDto":
-        if self.definition_id is None:
-            self.definition_id = self.experiment.definition_id
-        if self.name is None:
-            self.name = self.experiment.name
-        if self.description is None:
-            self.description = self.experiment.description
-        if self.benchmark_type is None:
-            self.benchmark_type = self.experiment.benchmark_type
-        return self
-
-
-class ExperimentTagDefinitionDto(BaseModel):
-    definition_id: UUID
-    name: str
-    benchmark_type: str
-    latest_run_status: str | None = None
-
-
 class SamplerInvocationView(CamelModel):
     sampler_invocation_id: UUID
     sampler_name: str
diff --git a/ergon_core/ergon_core/core/views/experiments/service.py b/ergon_core/ergon_core/core/views/experiments/service.py
index ec2e9646e..9c285a574 100644
--- a/ergon_core/ergon_core/core/views/experiments/service.py
+++ b/ergon_core/ergon_core/core/views/experiments/service.py
@@ -1,44 +1,29 @@
 """Read service for experiment API views."""
 
-from datetime import datetime
 from contextlib import AbstractContextManager
 from uuid import UUID
 
+from ergon_core.core.persistence.experiments.models import (
+    ExperimentEnvironmentRow,
+    ExperimentRow,
+    ExperimentSamplerInvocationRow,
+)
+from ergon_core.core.persistence.shared.db import get_session
+from ergon_core.core.persistence.telemetry.models import SampleRecord
 from ergon_core.core.views.experiments.models import (
     EnvironmentContributionView,
-    ExperimentAnalyticsDto,
-    ExperimentDetailDto,
     ExperimentDetailView,
     ExperimentListView,
-    ExperimentRunMetricsDto,
-    ExperimentRunRowDto,
     ExperimentSampleSummaryView,
     ExperimentSamplesView,
-    ExperimentStatusCountsDto,
-    ExperimentSummaryDto,
-    ExperimentTagDefinitionDto,
     SamplerInvocationView,
     SamplerInvocationsView,
 )
-from ergon_core.core.persistence.context.models import SampleContextEvent
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionInstance,
-)
-from ergon_core.core.persistence.experiments.models import (
-    ExperimentEnvironmentRow,
-    ExperimentRow,
-    ExperimentSamplerInvocationRow,
-)
-from ergon_core.core.persistence.graph.models import SampleGraphNode
-from ergon_core.core.persistence.shared.db import get_session
-from ergon_core.core.persistence.telemetry.models import SampleRecord
-from ergon_core.core.views.samples.metrics import aggregate_run_metrics
 from sqlmodel import Session, col, select
 
 
 class ExperimentReadService:
-    """List/show queries for persisted benchmark definitions."""
+    """List/show queries for persisted experiment state."""
 
     def __init__(self, session: Session | None = None) -> None:
         self._session = session
@@ -100,337 +85,6 @@ def _session_scope(self) -> AbstractContextManager[Session]:
             return _ExistingSessionScope(self._session)
         return get_session()
 
-    def list_experiments(self, *, limit: int = 50) -> list[ExperimentSummaryDto]:
-        with get_session() as session:
-            definitions = list(
-                session.exec(
-                    select(ExperimentDefinition)
-                    .order_by(col(ExperimentDefinition.created_at).desc())
-                    .limit(limit)
-                ).all()
-            )
-            summaries: list[tuple[datetime, ExperimentSummaryDto]] = []
-            for definition in definitions:
-                summaries.append(
-                    (
-                        definition.created_at,
-                        _definition_summary(session, definition),
-                    )
-                )
-
-            summaries.sort(key=lambda pair: pair[0], reverse=True)
-            return [summary for _, summary in summaries[:limit]]
-
-    def get_experiment(self, definition_id: UUID) -> ExperimentDetailDto | None:
-        with get_session() as session:
-            definition = session.get(ExperimentDefinition, definition_id)
-            if definition is not None:
-                return _definition_detail(session, definition)
-
-            return None
-
-    def distinct_tags(self) -> list[str]:
-        with get_session() as session:
-            tags = {
-                tag
-                for tag in session.exec(select(SampleRecord.experiment)).all()
-                if isinstance(tag, str) and tag
-            }
-        return sorted(tags)
-
-    def definitions_by_tag(self, tag: str) -> list[ExperimentTagDefinitionDto]:
-        with get_session() as session:
-            runs = list(
-                session.exec(
-                    select(SampleRecord)
-                    .where(SampleRecord.experiment == tag)
-                    .order_by(col(SampleRecord.created_at).desc())
-                ).all()
-            )
-            latest_by_definition: dict[UUID, SampleRecord] = {}
-            for run in runs:
-                if run.definition_id is None:
-                    continue
-                latest_by_definition.setdefault(run.definition_id, run)
-
-            rows: list[ExperimentTagDefinitionDto] = []
-            for definition_id, latest_run in latest_by_definition.items():
-                definition = session.get(ExperimentDefinition, definition_id)
-                if definition is None:
-                    continue
-                rows.append(
-                    ExperimentTagDefinitionDto(
-                        definition_id=definition.id,
-                        name=definition.name,
-                        benchmark_type=definition.benchmark_type,
-                        latest_run_status=str(latest_run.status),
-                    )
-                )
-        return rows
-
-
-def _definition_summary(
-    session: Session,
-    definition: ExperimentDefinition,
-    *,
-    runs: list[SampleRecord] | None = None,
-) -> ExperimentSummaryDto:
-    """Build a summary DTO from an ``ExperimentDefinition`` row.
-
-    Identity fields (``name``/``description``/``benchmark_type``/``created_by``)
-    come directly from the columns Task 1 added.  Run / sample bookkeeping is
-    derived: ``SampleRecord.experiment`` indexes grouped runs, and
-    ``ExperimentDefinitionInstance`` rows index instances.
-    """
-    runs = runs if runs is not None else _runs_for_definition_view(session, definition)
-    run_count = len(runs)
-    sample_count = _instance_count(session, definition.id)
-    metadata = definition.parsed_metadata()
-    analytics = _analytics([_run_row(run, context_events=[]) for run in runs])
-    return ExperimentSummaryDto(
-        definition_id=definition.id,
-        name=definition.name,
-        description=definition.description,
-        benchmark_type=definition.benchmark_type,
-        sample_count=sample_count,
-        status=_experiment_lifecycle_status(
-            analytics.status_counts,
-            run_count=run_count,
-            fallback=str(metadata.get("status", "defined")),
-        ),
-        default_worker_team=dict_metadata(metadata, "default_worker_team"),
-        default_evaluator_slug=optional_str_metadata(metadata, "default_evaluator_slug"),
-        default_model_target=optional_str_metadata(metadata, "default_model_target"),
-        created_by=definition.created_by,
-        created_at=definition.created_at,
-        started_at=None,
-        completed_at=None,
-        run_count=run_count,
-        status_counts=analytics.status_counts,
-        failure_count=analytics.status_counts.failed,
-        latest_activity_at=analytics.latest_activity_at,
-        average_score=analytics.average_score,
-        average_duration_ms=analytics.average_duration_ms,
-        average_tasks=analytics.average_tasks,
-        total_cost_usd=analytics.total_cost_usd,
-    )
-
-
-def _definition_detail(
-    session: Session,
-    definition: ExperimentDefinition,
-) -> ExperimentDetailDto:
-    """Build a detail DTO from an ``ExperimentDefinition`` row."""
-    runs = _runs_for_definition_view(session, definition)
-    task_counts = _task_counts_by_sample(session, [run.id for run in runs])
-    context_events = _context_events_by_run(session, [run.id for run in runs])
-    run_rows = [
-        _run_row(
-            run,
-            total_tasks=task_counts.get(run.id),
-            context_events=context_events.get(run.id, []),
-        )
-        for run in runs
-    ]
-    return ExperimentDetailDto(
-        definition_id=definition.id,
-        name=definition.name,
-        description=definition.description,
-        benchmark_type=definition.benchmark_type,
-        experiment=_definition_summary(session, definition, runs=runs),
-        runs=run_rows,
-        analytics=_analytics(run_rows),
-        sample_selection={},
-        design={},
-        metadata=definition.parsed_metadata(),
-    )
-
-
-def _runs_for_definition_view(
-    session: Session,
-    definition: ExperimentDefinition,
-) -> list[SampleRecord]:
-    experiment = optional_str_metadata(definition.parsed_metadata(), "experiment")
-    if experiment:
-        return list(
-            session.exec(select(SampleRecord).where(SampleRecord.experiment == experiment)).all()
-        )
-    return list(
-        session.exec(select(SampleRecord).where(SampleRecord.definition_id == definition.id)).all()
-    )
-
-
-def _instance_count(session: Session, definition_id: UUID) -> int:
-    return len(
-        list(
-            session.exec(
-                select(ExperimentDefinitionInstance.id).where(
-                    ExperimentDefinitionInstance.experiment_definition_id == definition_id
-                )
-            )
-        )
-    )
-
-
-def _run_row(
-    run: SampleRecord,
-    *,
-    total_tasks: int | None = None,
-    context_events: list[SampleContextEvent],
-) -> ExperimentRunRowDto:
-    summary = run.parsed_summary()
-    duration_ms = _duration_ms(run)
-    score = _summary_number(summary, "normalized_score") or _summary_number(summary, "final_score")
-    error_summary = _error_summary(run, summary)
-    aggregated = aggregate_run_metrics(context_events, summary=summary)
-    return ExperimentRunRowDto(
-        sample_id=run.id,
-        definition_id=run.definition_id,
-        benchmark_type=run.benchmark_type,
-        instance_key=run.instance_key,
-        status=run.status,
-        created_at=run.created_at,
-        started_at=run.started_at,
-        completed_at=run.completed_at,
-        evaluator_slug=run.evaluator_slug,
-        model_target=run.model_target,
-        worker_team=run.parsed_worker_team(),
-        seed=run.seed,
-        running_time_ms=duration_ms,
-        final_score=score,
-        total_tasks=total_tasks,
-        total_cost_usd=aggregated.total_cost_usd,
-        error_message=error_summary,
-        metrics=ExperimentRunMetricsDto(
-            sample_id=run.id,
-            run_name=run.sample_id or run.instance_key,
-            status=str(run.status),
-            sample_label=run.sample_id,
-            instance_key=run.instance_key,
-            score=score,
-            return_value=score,
-            duration_ms=duration_ms,
-            total_tasks=total_tasks,
-            tool_call_count=aggregated.tool_call_count,
-            total_tokens=aggregated.total_tokens,
-            token_breakdown=aggregated.token_breakdown,
-            total_cost_usd=aggregated.total_cost_usd,
-            cost_observed=aggregated.cost_observed,
-            model_target=run.model_target,
-            evaluator_slug=run.evaluator_slug,
-            error_summary=error_summary,
-        ),
-    )
-
-
-def _task_counts_by_sample(session: Session, sample_ids: list[UUID]) -> dict[UUID, int]:
-    return {
-        sample_id: len(
-            list(
-                session.exec(
-                    select(SampleGraphNode.task_id).where(SampleGraphNode.sample_id == sample_id)
-                )
-            )
-        )
-        for sample_id in sample_ids
-    }
-
-
-def _context_events_by_run(
-    session: Session,
-    sample_ids: list[UUID],
-) -> dict[UUID, list[SampleContextEvent]]:
-    if not sample_ids:
-        return {}
-
-    rows = list(
-        session.exec(
-            select(SampleContextEvent).where(col(SampleContextEvent.sample_id).in_(sample_ids))
-        )
-    )
-    result: dict[UUID, list[SampleContextEvent]] = {sample_id: [] for sample_id in sample_ids}
-    for row in rows:
-        result.setdefault(row.sample_id, []).append(row)
-    return result
-
-
-def _analytics(rows: list[ExperimentRunRowDto]) -> ExperimentAnalyticsDto:
-    status_counts = ExperimentStatusCountsDto()
-    scores: list[float] = []
-    durations: list[int] = []
-    task_counts: list[int] = []
-    total_cost_usd: float | None = None
-    latest_activity_at: datetime | None = None
-    error_count = 0
-
-    for row in rows:
-        _increment_status_count(status_counts, row.status)
-        if row.final_score is not None:
-            scores.append(row.final_score)
-        if row.running_time_ms is not None:
-            durations.append(row.running_time_ms)
-        if row.total_tasks is not None:
-            task_counts.append(row.total_tasks)
-        if row.metrics.cost_observed and row.total_cost_usd is not None:
-            total_cost_usd = (total_cost_usd or 0.0) + row.total_cost_usd
-        if row.error_message:
-            error_count += 1
-        activity_at = row.completed_at or row.started_at or row.created_at
-        if latest_activity_at is None or activity_at > latest_activity_at:
-            latest_activity_at = activity_at
-
-    return ExperimentAnalyticsDto(
-        total_runs=len(rows),
-        status_counts=status_counts,
-        average_score=_average(scores),
-        average_duration_ms=_rounded_average(durations),
-        average_tasks=_average(task_counts),
-        total_cost_usd=total_cost_usd,
-        latest_activity_at=latest_activity_at,
-        error_count=error_count,
-    )
-
-
-def _increment_status_count(counts: ExperimentStatusCountsDto, status: str) -> None:
-    match status:
-        case "pending":
-            counts.pending += 1
-        case "executing":
-            counts.executing += 1
-        case "evaluating":
-            counts.evaluating += 1
-        case "completed":
-            counts.completed += 1
-        case "failed":
-            counts.failed += 1
-        case "cancelled":
-            counts.cancelled += 1
-
-
-def _experiment_lifecycle_status(
-    counts: ExperimentStatusCountsDto,
-    *,
-    run_count: int,
-    fallback: str,
-) -> str:
-    if counts.executing > 0:
-        return "executing"
-    if counts.evaluating > 0:
-        return "evaluating"
-    if counts.pending > 0:
-        return "pending"
-    if run_count == 0:
-        return fallback
-    if counts.failed > 0:
-        return "failed"
-    if counts.cancelled > 0 and counts.completed == 0:
-        return "cancelled"
-    if counts.completed == run_count:
-        return "completed"
-    if counts.cancelled > 0:
-        return "cancelled"
-    return fallback
-
 
 class _ExistingSessionScope:
     def __init__(self, session: Session) -> None:
@@ -544,52 +198,3 @@ def _sampler_invocation_view(row: ExperimentSamplerInvocationRow) -> SamplerInvo
         sampler_config=row.sampler_config_json,
         created_at=row.created_at,
     )
-
-
-def _average(values: list[float] | list[int]) -> float | None:
-    if not values:
-        return None
-    return sum(values) / len(values)
-
-
-def _rounded_average(values: list[int]) -> int | None:
-    average = _average(values)
-    return None if average is None else round(average)
-
-
-def _duration_ms(run: SampleRecord) -> int | None:
-    if run.started_at is None or run.completed_at is None:
-        return None
-    return round((run.completed_at - run.started_at).total_seconds() * 1000)
-
-
-def _summary_number(summary: dict, key: str) -> float | None:
-    value = summary.get(key)
-    if isinstance(value, int | float):
-        return float(value)
-    return None
-
-
-def _summary_text(summary: dict, key: str) -> str | None:
-    value = summary.get(key)
-    if isinstance(value, str) and value:
-        return value
-    return None
-
-
-def _error_summary(run: SampleRecord, summary: dict) -> str | None:
-    if run.error_message:
-        return run.error_message
-    if str(run.status) not in {"failed", "cancelled"}:
-        return None
-    return _summary_text(summary, "error_message")
-
-
-def dict_metadata(metadata: dict, key: str) -> dict:
-    value = metadata.get(key)
-    return dict(value) if isinstance(value, dict) else {}
-
-
-def optional_str_metadata(metadata: dict, key: str) -> str | None:
-    value = metadata.get(key)
-    return value if isinstance(value, str) else None
diff --git a/ergon_core/ergon_core/core/views/samples/models.py b/ergon_core/ergon_core/core/views/samples/models.py
index f186ad02b..5ccba0b81 100644
--- a/ergon_core/ergon_core/core/views/samples/models.py
+++ b/ergon_core/ergon_core/core/views/samples/models.py
@@ -1,7 +1,7 @@
-"""Pydantic DTOs for the run detail API surface.
+"""Pydantic DTOs for the sample detail API surface.
 
 Task structure comes from SampleGraphNode + SampleGraphEdge rows (the live graph),
-not from ExperimentDefinitionTask. All task keys are SampleGraphNode.task_id.
+and all task keys are SampleGraphNode.task_id.
 
 """
 
@@ -198,7 +198,6 @@ class SampleSnapshotMetricsDto(CamelModel):
 
 class SampleSnapshotDto(CamelModel):
     id: str
-    definition_id: str | None = None
     name: str
     status: str
     tasks: dict[str, SampleTaskDto] = Field(default_factory=dict)
@@ -234,8 +233,7 @@ class SampleSummaryDto(BaseModel):
     completed_at: datetime | None = None
     latest_activity_at: datetime | None = None
     duration_seconds: float | None = None
-    definition_id: UUID | None = None
-    definition_name: str | None = None
+    experiment_id: UUID | None = None
     experiment: str | None = None
     benchmark_type: str
     instance_key: str
diff --git a/ergon_core/ergon_core/core/views/samples/service.py b/ergon_core/ergon_core/core/views/samples/service.py
index 04e3efd22..d8322e5d3 100644
--- a/ergon_core/ergon_core/core/views/samples/service.py
+++ b/ergon_core/ergon_core/core/views/samples/service.py
@@ -1,4 +1,4 @@
-"""Read service for dashboard/API run snapshots and related views."""
+"""Read service for dashboard/API sample snapshots and related views."""
 
 import os
 from contextlib import AbstractContextManager
@@ -18,10 +18,6 @@
     SampleSnapshotDto,
 )
 from ergon_core.core.persistence.context.models import SampleContextEvent
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionWorker,
-)
 from ergon_core.core.persistence.experiments.models import ExperimentEnvironmentRow
 from ergon_core.core.persistence.graph.models import (
     SampleGraphEdge,
@@ -77,7 +73,6 @@ def list_samples(
         *,
         limit: int = 20,
         status: str | None = None,
-        definition_id: UUID | None = None,
         experiment: str | None = None,
         offset: int = 0,
     ) -> list[SampleSummaryDto]:
@@ -85,30 +80,14 @@ def list_samples(
             stmt = select(SampleRecord).order_by(col(SampleRecord.created_at).desc())
             if status:
                 stmt = stmt.where(SampleRecord.status == status)
-            if definition_id:
-                stmt = stmt.where(SampleRecord.definition_id == definition_id)
             if experiment:
                 stmt = stmt.where(SampleRecord.experiment == experiment)
             stmt = stmt.offset(offset).limit(limit)
             rows = list(session.exec(stmt).all())
-            definition_ids = [row.definition_id for row in rows if row.definition_id is not None]
-            definition_names = {
-                definition.id: definition.name
-                for definition in session.exec(
-                    select(ExperimentDefinition).where(
-                        col(ExperimentDefinition.id).in_(definition_ids)
-                    )
-                ).all()
-            }
             task_counts = _task_counts_by_sample(session, [row.id for row in rows])
         return [
             _run_summary(
                 row,
-                definition_name=(
-                    definition_names.get(row.definition_id)
-                    if row.definition_id is not None
-                    else None
-                ),
                 task_counts=task_counts.get(row.id),
             )
             for row in rows
@@ -125,11 +104,6 @@ def build_snapshot(self, sample_id: UUID) -> SampleSnapshotDto | None:
             if run is None:
                 return None
 
-            definition = (
-                session.get(ExperimentDefinition, run.definition_id)
-                if run.definition_id is not None
-                else None
-            )
             nodes = list(
                 session.exec(
                     select(SampleGraphNode).where(SampleGraphNode.sample_id == sample_id)
@@ -140,17 +114,6 @@ def build_snapshot(self, sample_id: UUID) -> SampleSnapshotDto | None:
                     select(SampleGraphEdge).where(SampleGraphEdge.sample_id == sample_id)
                 ).all()
             )
-            def_workers = (
-                list(
-                    session.exec(
-                        select(ExperimentDefinitionWorker).where(
-                            ExperimentDefinitionWorker.experiment_definition_id == run.definition_id
-                        )
-                    ).all()
-                )
-                if run.definition_id is not None
-                else []
-            )
             executions = list(
                 session.exec(
                     select(SampleTaskAttempt).where(SampleTaskAttempt.sample_id == sample_id)
@@ -183,10 +146,6 @@ def build_snapshot(self, sample_id: UUID) -> SampleSnapshotDto | None:
                 ).all()
             )
 
-        worker_by_id: dict[UUID, ExperimentDefinitionWorker] = {w.id: w for w in def_workers}
-        worker_by_binding: dict[str, ExperimentDefinitionWorker] = {
-            w.binding_key: w for w in def_workers
-        }
         timestamps = _task_timestamps(executions)
         (
             task_map,
@@ -197,7 +156,7 @@ def build_snapshot(self, sample_id: UUID) -> SampleSnapshotDto | None:
             failed_tasks,
             running_tasks,
             cancelled_tasks,
-        ) = _build_task_map(nodes, edges, worker_by_binding, timestamps)
+        ) = _build_task_map(nodes, edges, timestamps)
 
         execution_task_map: dict[UUID, UUID] = {ex.id: ex.task_id for ex in executions}
 
@@ -216,7 +175,7 @@ def build_snapshot(self, sample_id: UUID) -> SampleSnapshotDto | None:
         run_summary = run.parsed_summary()
         aggregated_metrics = aggregate_run_metrics(context_events, summary=run_summary)
         assignment = run.parsed_assignment()
-        meta = definition.parsed_metadata() if definition is not None else assignment
+        meta = assignment
         run_name = str(
             run_summary.get("name")
             or assignment.get("sample_name")
@@ -226,7 +185,6 @@ def build_snapshot(self, sample_id: UUID) -> SampleSnapshotDto | None:
 
         return SampleSnapshotDto(
             id=sample_id_str,
-            definition_id=str(run.definition_id) if run.definition_id is not None else None,
             name=run_name,
             status=run.status,
             tasks=task_map,
@@ -237,7 +195,6 @@ def build_snapshot(self, sample_id: UUID) -> SampleSnapshotDto | None:
             ),
             executions_by_task=_task_keyed_executions(
                 executions,
-                worker_by_id,
             ),
             evaluations_by_task=_task_keyed_evaluations(
                 evaluations,
@@ -471,7 +428,6 @@ def _display_run_score(
 def _run_summary(
     run: SampleRecord,
     *,
-    definition_name: str | None = None,
     task_counts: dict[str, object] | None = None,
 ) -> SampleSummaryDto:
     summary = run.parsed_summary()
@@ -488,8 +444,7 @@ def _run_summary(
         completed_at=run.completed_at,
         latest_activity_at=_latest_activity(run, task_counts),
         duration_seconds=_duration_seconds(run),
-        definition_id=run.definition_id,
-        definition_name=definition_name,
+        experiment_id=run.experiment_id,
         experiment=run.experiment,
         benchmark_type=run.benchmark_type,
         instance_key=run.instance_key,
diff --git a/ergon_core/ergon_core/core/views/samples/snapshot.py b/ergon_core/ergon_core/core/views/samples/snapshot.py
index 29ef25953..4700d1437 100644
--- a/ergon_core/ergon_core/core/views/samples/snapshot.py
+++ b/ergon_core/ergon_core/core/views/samples/snapshot.py
@@ -1,4 +1,4 @@
-"""Pure read-model helpers for persisted run snapshots."""
+"""Pure read-model helpers for persisted sample snapshots."""
 
 from collections import defaultdict
 from datetime import datetime
@@ -18,7 +18,6 @@
     SampleTaskEvaluationDto,
 )
 from ergon_core.core.persistence.context.models import SampleContextEvent
-from ergon_core.core.persistence.definitions.models import ExperimentDefinitionWorker
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.persistence.telemetry.models import (
     SampleResource,
@@ -30,11 +29,9 @@
 from ergon_core.core.shared.context_parts import ContextEventType
 
 
-# TODO: this file / logic almost certainly duplicates the run benchmarks logic? if not it needs to be moved, renamed and laid out cleaner.
 def _build_task_map(
     nodes: list[SampleGraphNode],
     edges: list[SampleGraphEdge],
-    worker_by_binding: dict[str, ExperimentDefinitionWorker],
     task_timestamps: dict[UUID, tuple[datetime | None, datetime | None]],
 ) -> tuple[dict[str, SampleTaskDto], str, int, int, int, int, int, int]:
     """Three clean passes using stored containment columns.
@@ -50,11 +47,6 @@ def _build_task_map(
 
     for node in nodes:
         nid = str(node.task_id)
-        worker = (
-            worker_by_binding.get(node.assigned_worker_slug)
-            if node.assigned_worker_slug is not None
-            else None
-        )
         started_at, completed_at = task_timestamps.get(node.task_id, (None, None))
         task_map[nid] = SampleTaskDto(
             id=nid,
@@ -66,7 +58,6 @@ def _build_task_map(
             depends_on_ids=[],
             is_leaf=True,
             level=node.level,
-            assigned_worker_id=str(worker.id) if worker else None,
             assigned_worker_slug=node.assigned_worker_slug,
             started_at=started_at,
             completed_at=completed_at,
@@ -102,7 +93,6 @@ def _build_task_map(
 
 def _task_keyed_executions(
     executions: list[SampleTaskAttempt],
-    worker_map: dict[UUID, ExperimentDefinitionWorker],
 ) -> dict[str, list[SampleExecutionAttemptDto]]:
     by_task: dict[str, list[SampleExecutionAttemptDto]] = defaultdict(list)
     for ex in sorted(
@@ -115,10 +105,6 @@ def _task_keyed_executions(
             message = ex.error_json.get("message")
             error_msg = message if isinstance(message, str) else str(ex.error_json)
 
-        worker = worker_map.get(ex.definition_worker_id) if ex.definition_worker_id else None
-        agent_id = str(worker.id) if worker else None
-        agent_name = worker.binding_key if worker else None
-
         resource_ids: list[str] = []
         output = ex.parsed_output()
         raw_resource_ids = output.get("resource_ids")
@@ -136,8 +122,6 @@ def _task_keyed_executions(
                 final_assistant_message=ex.final_assistant_message,
                 error_message=error_msg,
                 score=None,
-                agent_id=agent_id,
-                agent_name=agent_name,
                 output_resource_ids=resource_ids,
             )
         )
diff --git a/ergon_core/migrations/env.py b/ergon_core/migrations/env.py
index 0683b17b7..6bdaa3948 100644
--- a/ergon_core/migrations/env.py
+++ b/ergon_core/migrations/env.py
@@ -6,7 +6,6 @@
 
 from logging.config import fileConfig
 
-import ergon_core.core.persistence.definitions.models
 import ergon_core.core.persistence.experiments.models
 import ergon_core.core.persistence.graph.models
 import ergon_core.core.persistence.samples.models
diff --git a/ergon_core/migrations/versions/00000000_initial_v2.py b/ergon_core/migrations/versions/00000000_initial_v2.py
index 9fbd2b672..19759e281 100644
--- a/ergon_core/migrations/versions/00000000_initial_v2.py
+++ b/ergon_core/migrations/versions/00000000_initial_v2.py
@@ -13,7 +13,6 @@
 
 for module_name in (
     "ergon_core.core.persistence.context.models",
-    "ergon_core.core.persistence.definitions.models",
     "ergon_core.core.persistence.graph.models",
     "ergon_core.core.persistence.samples.models",
     "ergon_core.core.persistence.telemetry.models",
@@ -27,14 +26,6 @@
 depends_on = None
 
 INITIAL_TABLES = (
-    "experiment_definitions",
-    "experiment_definition_workers",
-    "experiment_definition_evaluators",
-    "experiment_definition_instances",
-    "experiment_definition_tasks",
-    "experiment_definition_task_dependencies",
-    "experiment_definition_task_assignments",
-    "experiment_definition_task_evaluators",
     "samples",
     "sample_graph_nodes",
     "sample_graph_edges",
diff --git a/ergon_core/migrations/versions/00000002_add_sample_experiment_provenance.py b/ergon_core/migrations/versions/00000002_add_sample_experiment_provenance.py
index c20df30bf..16d3c273b 100644
--- a/ergon_core/migrations/versions/00000002_add_sample_experiment_provenance.py
+++ b/ergon_core/migrations/versions/00000002_add_sample_experiment_provenance.py
@@ -43,11 +43,6 @@ def upgrade() -> None:
 
     bind = op.get_bind()
     existing_columns = {column["name"] for column in inspect(bind).get_columns("samples")}
-    if bind.dialect.name == "sqlite":
-        with op.batch_alter_table("samples") as batch_op:
-            batch_op.alter_column("definition_id", existing_type=sa.Uuid(), nullable=True)
-    else:
-        op.alter_column("samples", "definition_id", existing_type=sa.Uuid(), nullable=True)
     for column in _NEW_COLUMNS:
         if column.name not in existing_columns:
             op.add_column("samples", column.copy())
@@ -73,15 +68,9 @@ def downgrade() -> None:
     for column in reversed(_NEW_COLUMNS):
         if column.name in existing_columns:
             op.drop_column("samples", column.name)
-    if bind.dialect.name == "sqlite":
-        with op.batch_alter_table("samples") as batch_op:
-            batch_op.alter_column("definition_id", existing_type=sa.Uuid(), nullable=False)
-    else:
-        op.alter_column("samples", "definition_id", existing_type=sa.Uuid(), nullable=False)
 
 
 def _upgrade_unconditional() -> None:
-    op.alter_column("samples", "definition_id", existing_type=sa.Uuid(), nullable=True)
     for column in _NEW_COLUMNS:
         op.add_column("samples", column.copy())
     for index_name, columns in _NEW_INDEXES:
@@ -93,4 +82,3 @@ def _downgrade_unconditional() -> None:
         op.drop_index(index_name, table_name="samples")
     for column in reversed(_NEW_COLUMNS):
         op.drop_column("samples", column.name)
-    op.alter_column("samples", "definition_id", existing_type=sa.Uuid(), nullable=False)
diff --git a/ergon_core/migrations/versions/00000003_delete_definition_runtime_columns.py b/ergon_core/migrations/versions/00000003_delete_definition_runtime_columns.py
new file mode 100644
index 000000000..42eef5421
--- /dev/null
+++ b/ergon_core/migrations/versions/00000003_delete_definition_runtime_columns.py
@@ -0,0 +1,276 @@
+"""Delete definition-backed runtime columns from existing databases.
+
+Revision ID: 00000003
+Revises: 00000002
+Create Date: 2026-05-27
+"""
+
+import sqlalchemy as sa
+import sqlmodel
+from alembic import op
+from sqlalchemy import inspect
+
+
+revision = "00000003"
+down_revision = "00000002"
+branch_labels = None
+depends_on = None
+
+
+_DEFINITION_TABLES = (
+    "experiment_definition_dependencies",
+    "experiment_definition_task_evaluators",
+    "experiment_definition_task_assignments",
+    "experiment_definition_task_dependencies",
+    "experiment_definition_evaluators",
+    "experiment_definition_workers",
+    "experiment_definition_tasks",
+    "experiment_definition_instances",
+    "experiment_definitions",
+)
+
+_LEGACY_RUN_TABLES = (
+    "run_context_events",
+    "run_graph_annotations",
+    "run_graph_mutations",
+    "run_graph_edges",
+    "run_graph_nodes",
+    "run_resources",
+    "run_task_evaluations",
+    "run_task_executions",
+)
+
+
+def upgrade() -> None:
+    context = op.get_context()
+    if context.as_sql:
+        _upgrade_offline()
+        return
+
+    bind = op.get_bind()
+    inspector = inspect(bind)
+
+    _ensure_evaluator_slug(inspector)
+    _rename_run_id_to_sample_id_if_needed(inspector, "threads")
+    _rename_run_id_to_sample_id_if_needed(inspector, "thread_messages")
+    _rename_run_id_to_sample_id_if_needed(inspector, "sandbox_command_wal_entries")
+    _rename_run_id_to_sample_id_if_needed(inspector, "sandbox_events")
+    _replace_sample_fk(inspector, "threads", "sample_id", "samples")
+    _replace_sample_fk(inspector, "thread_messages", "sample_id", "samples")
+    _drop_sample_fk(inspector, "sandbox_command_wal_entries", "sample_id")
+    _drop_sample_fk(inspector, "sandbox_events", "sample_id")
+    _add_column_if_missing(
+        inspector,
+        "experiment_sampler_invocations",
+        sa.Column("policy_version", sa.Integer(), nullable=True),
+    )
+    _add_column_if_missing(
+        inspector,
+        "experiment_sample_pool_entries",
+        sa.Column("sample_ref_json", sa.JSON(), nullable=True),
+    )
+    _drop_column_if_exists(inspector, "samples", "definition_id")
+    _drop_column_if_exists(inspector, "sample_task_attempts", "definition_worker_id")
+    _drop_column_if_exists(inspector, "sample_task_evaluations", "definition_evaluator_id")
+    _drop_column_if_exists(inspector, "sample_graph_edges", "definition_dependency_id")
+
+    existing_tables = set(inspector.get_table_names())
+    for table_name in (*_LEGACY_RUN_TABLES, *_DEFINITION_TABLES):
+        if table_name in existing_tables:
+            _drop_table_cascade(table_name)
+
+
+def downgrade() -> None:
+    context = op.get_context()
+    if context.as_sql:
+        _downgrade_offline()
+        return
+
+    bind = op.get_bind()
+    inspector = inspect(bind)
+    _add_column_if_missing(
+        inspector, "samples", sa.Column("definition_id", sa.Uuid(), nullable=True)
+    )
+    _add_column_if_missing(
+        inspector,
+        "sample_task_attempts",
+        sa.Column("definition_worker_id", sa.Uuid(), nullable=True),
+    )
+    _add_column_if_missing(
+        inspector,
+        "sample_task_evaluations",
+        sa.Column("definition_evaluator_id", sa.Uuid(), nullable=True),
+    )
+    _add_column_if_missing(
+        inspector,
+        "sample_graph_edges",
+        sa.Column("definition_dependency_id", sa.Uuid(), nullable=True),
+    )
+
+
+def _ensure_evaluator_slug(inspector: sa.Inspector) -> None:
+    columns = {column["name"] for column in inspector.get_columns("sample_task_evaluations")}
+    if "evaluator_slug" not in columns:
+        op.add_column(
+            "sample_task_evaluations",
+            sa.Column(
+                "evaluator_slug",
+                sqlmodel.sql.sqltypes.AutoString(),
+                nullable=True,
+            ),
+        )
+        op.execute(
+            "UPDATE sample_task_evaluations "
+            "SET evaluator_slug = 'unknown-evaluator' "
+            "WHERE evaluator_slug IS NULL"
+        )
+        op.alter_column("sample_task_evaluations", "evaluator_slug", nullable=False)
+
+    indexes = {index["name"] for index in inspector.get_indexes("sample_task_evaluations")}
+    if "ix_sample_task_evaluations_evaluator_slug" not in indexes:
+        op.create_index(
+            "ix_sample_task_evaluations_evaluator_slug",
+            "sample_task_evaluations",
+            ["evaluator_slug"],
+        )
+
+
+def _drop_column_if_exists(inspector: sa.Inspector, table_name: str, column_name: str) -> None:
+    columns = {column["name"] for column in inspector.get_columns(table_name)}
+    if column_name in columns:
+        op.drop_column(table_name, column_name)
+
+
+def _rename_run_id_to_sample_id_if_needed(inspector: sa.Inspector, table_name: str) -> None:
+    columns = {column["name"] for column in inspector.get_columns(table_name)}
+    if "sample_id" not in columns and "run_id" in columns:
+        op.alter_column(table_name, "run_id", new_column_name="sample_id")
+
+
+def _add_column_if_missing(
+    inspector: sa.Inspector,
+    table_name: str,
+    column: sa.Column,
+) -> None:
+    columns = {existing["name"] for existing in inspector.get_columns(table_name)}
+    if column.name not in columns:
+        op.add_column(table_name, column)
+
+
+def _replace_sample_fk(
+    inspector: sa.Inspector,
+    table_name: str,
+    column_name: str,
+    referred_table: str,
+) -> None:
+    foreign_keys = inspector.get_foreign_keys(table_name)
+    has_target_fk = False
+    for foreign_key in foreign_keys:
+        constrained_columns = foreign_key.get("constrained_columns") or []
+        if constrained_columns != [column_name]:
+            continue
+        if foreign_key.get("referred_table") == referred_table:
+            has_target_fk = True
+            continue
+        name = foreign_key.get("name")
+        if name:
+            op.drop_constraint(name, table_name, type_="foreignkey")
+
+    if not has_target_fk:
+        op.create_foreign_key(
+            f"fk_{table_name}_{column_name}_{referred_table}",
+            table_name,
+            referred_table,
+            [column_name],
+            ["id"],
+        )
+
+
+def _drop_sample_fk(
+    inspector: sa.Inspector,
+    table_name: str,
+    column_name: str,
+) -> None:
+    if table_name not in inspector.get_table_names():
+        return
+    for foreign_key in inspector.get_foreign_keys(table_name):
+        constrained_columns = foreign_key.get("constrained_columns") or []
+        if constrained_columns != [column_name]:
+            continue
+        name = foreign_key.get("name")
+        if name:
+            op.drop_constraint(name, table_name, type_="foreignkey")
+
+
+def _drop_table_cascade(table_name: str) -> None:
+    op.execute(sa.text(f'DROP TABLE IF EXISTS "{table_name}" CASCADE'))
+
+
+def _upgrade_offline() -> None:
+    op.add_column(
+        "sample_task_evaluations",
+        sa.Column("evaluator_slug", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+    )
+    op.execute(
+        "UPDATE sample_task_evaluations "
+        "SET evaluator_slug = 'unknown-evaluator' "
+        "WHERE evaluator_slug IS NULL"
+    )
+    op.alter_column("sample_task_evaluations", "evaluator_slug", nullable=False)
+    op.create_index(
+        "ix_sample_task_evaluations_evaluator_slug",
+        "sample_task_evaluations",
+        ["evaluator_slug"],
+    )
+    for table_name in ("threads", "thread_messages"):
+        op.alter_column(table_name, "run_id", new_column_name="sample_id")
+        op.execute(
+            f'ALTER TABLE "{table_name}" DROP CONSTRAINT IF EXISTS "{table_name}_run_id_fkey"'
+        )
+        op.create_foreign_key(
+            f"fk_{table_name}_sample_id_samples",
+            table_name,
+            "samples",
+            ["sample_id"],
+            ["id"],
+        )
+    for table_name in ("sandbox_command_wal_entries", "sandbox_events"):
+        op.alter_column(table_name, "run_id", new_column_name="sample_id")
+        op.execute(
+            f'ALTER TABLE "{table_name}" DROP CONSTRAINT IF EXISTS "{table_name}_run_id_fkey"'
+        )
+    op.add_column(
+        "experiment_sampler_invocations",
+        sa.Column("policy_version", sa.Integer(), nullable=True),
+    )
+    op.add_column(
+        "experiment_sample_pool_entries",
+        sa.Column("sample_ref_json", sa.JSON(), nullable=True),
+    )
+    op.drop_column("samples", "definition_id")
+    op.drop_column("sample_task_attempts", "definition_worker_id")
+    op.drop_column("sample_task_evaluations", "definition_evaluator_id")
+    op.drop_column("sample_graph_edges", "definition_dependency_id")
+    for table_name in (*_LEGACY_RUN_TABLES, *_DEFINITION_TABLES):
+        op.execute(f"DROP TABLE IF EXISTS {table_name} CASCADE")
+
+
+def _downgrade_offline() -> None:
+    op.add_column("samples", sa.Column("definition_id", sa.Uuid(), nullable=True))
+    op.add_column(
+        "sample_task_attempts",
+        sa.Column("definition_worker_id", sa.Uuid(), nullable=True),
+    )
+    op.add_column(
+        "sample_task_evaluations",
+        sa.Column("definition_evaluator_id", sa.Uuid(), nullable=True),
+    )
+    op.add_column(
+        "sample_graph_edges",
+        sa.Column("definition_dependency_id", sa.Uuid(), nullable=True),
+    )
+    op.drop_index(
+        "ix_sample_task_evaluations_evaluator_slug",
+        table_name="sample_task_evaluations",
+    )
+    op.drop_column("sample_task_evaluations", "evaluator_slug")
diff --git a/ergon_core/tests/integration/experiments/test_experiment_persistence_roundtrip.py b/ergon_core/tests/integration/experiments/test_experiment_persistence_roundtrip.py
index 6f956da56..d14d9fd69 100644
--- a/ergon_core/tests/integration/experiments/test_experiment_persistence_roundtrip.py
+++ b/ergon_core/tests/integration/experiments/test_experiment_persistence_roundtrip.py
@@ -19,7 +19,7 @@
 ROOT = Path(__file__).resolve().parents[4]
 
 for module_name in (
-    "ergon_core.core.persistence.definitions.models",
+    "ergon_core.core.persistence.experiments.models",
     "ergon_core.core.persistence.samples.models",
     "ergon_core.core.persistence.telemetry.models",
 ):
diff --git a/ergon_core/tests/integration/experiments/test_public_experiment_submit_smoke.py b/ergon_core/tests/integration/experiments/test_public_experiment_submit_smoke.py
index f4d5d97cb..4f501b849 100644
--- a/ergon_core/tests/integration/experiments/test_public_experiment_submit_smoke.py
+++ b/ergon_core/tests/integration/experiments/test_public_experiment_submit_smoke.py
@@ -11,7 +11,6 @@
 from ergon_core.test_support.task_factory import task_with_id
 
 for module_name in (
-    "ergon_core.core.persistence.definitions.models",
     "ergon_core.core.persistence.experiments.models",
     "ergon_core.core.persistence.graph.models",
     "ergon_core.core.persistence.samples.models",
diff --git a/ergon_core/tests/integration/experiments/test_submit_starts_materialized_sample.py b/ergon_core/tests/integration/experiments/test_submit_starts_materialized_sample.py
index f2501c04e..0558de3cd 100644
--- a/ergon_core/tests/integration/experiments/test_submit_starts_materialized_sample.py
+++ b/ergon_core/tests/integration/experiments/test_submit_starts_materialized_sample.py
@@ -29,7 +29,6 @@
 from ergon_core.test_support.task_factory import task_with_id
 
 for module_name in (
-    "ergon_core.core.persistence.definitions.models",
     "ergon_core.core.persistence.experiments.models",
     "ergon_core.core.persistence.graph.models",
     "ergon_core.core.persistence.samples.models",
@@ -114,7 +113,6 @@ async def test_workflow_start_uses_materialized_sample_graph_without_definition(
     ready = await get_initial_ready_tasks(
         session=session,
         sample_id=materialized_sample.id,
-        definition_id=None,
     )
 
     nodes_by_id = {
@@ -127,21 +125,18 @@ async def test_workflow_start_uses_materialized_sample_graph_without_definition(
     assert [node.task_slug for node in nodes_by_id.values() if node.status == "ready"] == ["root"]
 
 
-def test_sample_only_task_execution_contracts_allow_missing_definition_id() -> None:
+def test_sample_only_task_execution_contracts_do_not_expose_definition_id() -> None:
     sample_id = uuid4()
     task_id = uuid4()
     execution_id = uuid4()
 
-    assert PrepareTaskExecutionCommand(sample_id=sample_id, task_id=task_id).definition_id is None
-    assert (
+    payloads = [
+        PrepareTaskExecutionCommand(sample_id=sample_id, task_id=task_id),
         SandboxSetupRequest(
             sample_id=sample_id,
             task_id=task_id,
             benchmark_type="experiment",
-        ).definition_id
-        is None
-    )
-    assert (
+        ),
         WorkerExecuteRequest(
             sample_id=sample_id,
             task_id=task_id,
@@ -152,27 +147,26 @@ def test_sample_only_task_execution_contracts_allow_missing_definition_id() -> N
             assigned_worker_slug="worker",
             worker_type="worker.Type",
             benchmark_type="experiment",
-        ).definition_id
-        is None
-    )
-    assert (
+        ),
         PersistOutputsRequest(
             sample_id=sample_id,
             task_id=task_id,
             execution_id=execution_id,
             benchmark_type="experiment",
-        ).definition_id
-        is None
-    )
-    assert (
+        ),
         TaskCancelledEvent(
             sample_id=sample_id,
             task_id=task_id,
             execution_id=None,
             cause="manager_decision",
-        ).definition_id
-        is None
-    )
+        ),
+    ]
+
+    for payload in payloads:
+        fields = type(payload).model_fields
+        assert "sample_id" in fields
+        assert "task_id" in fields
+        assert "definition_id" not in fields
 
 
 @pytest.mark.asyncio
diff --git a/ergon_core/tests/unit/api/worker/test_worker_context_facade.py b/ergon_core/tests/unit/api/worker/test_worker_context_facade.py
index f41cc8b01..b9364b2ac 100644
--- a/ergon_core/tests/unit/api/worker/test_worker_context_facade.py
+++ b/ergon_core/tests/unit/api/worker/test_worker_context_facade.py
@@ -22,7 +22,6 @@
 )
 from ergon_core.core.persistence.shared.enums import SampleResourceKind
 from ergon_core.core.persistence.shared.enums import SampleStatus, TaskExecutionStatus
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.telemetry.models import (
     SampleRecord,
@@ -153,7 +152,6 @@ def _context(*, sample_id, task_id, inspect=None, resource_service=None) -> Work
         sample_id=sample_id,
         task_id=task_id,
         execution_id=uuid4(),
-        definition_id=uuid4(),
         sandbox_id="sbx",
         task_mgmt=_FakeTaskManagement(),
         task_inspect=inspect or _FakeInspection(),
@@ -173,7 +171,6 @@ async def test_facade_mutations_call_current_service_command_signatures() -> Non
         sample_id=sample_id,
         task_id=root_id,
         execution_id=uuid4(),
-        definition_id=uuid4(),
         sandbox_id="sbx",
         task_mgmt=mgmt,
         task_inspect=inspect,
@@ -202,7 +199,6 @@ async def test_spawn_task_uses_empty_tuple_dependency_default() -> None:
         sample_id=sample_id,
         task_id=root_id,
         execution_id=uuid4(),
-        definition_id=uuid4(),
         sandbox_id="sbx",
         task_mgmt=mgmt,
         task_inspect=_FakeInspection(),
@@ -302,7 +298,6 @@ async def test_resources_use_repository_run_scope_with_real_rows(tmp_path: Path)
     session = _sql_session()
     sample_id = uuid4()
     other_run_id = uuid4()
-    definition_id = uuid4()
     root_id = uuid4()
     sibling_id = uuid4()
     sibling_execution_id = uuid4()
@@ -311,15 +306,8 @@ async def test_resources_use_repository_run_scope_with_real_rows(tmp_path: Path)
     blob.write_bytes(b"report")
     session.add_all(
         [
-            ExperimentDefinition(
-                id=definition_id,
-                benchmark_type="bench",
-                name="bench",
-                metadata_json={},
-            ),
             SampleRecord(
                 id=sample_id,
-                definition_id=definition_id,
                 benchmark_type="bench",
                 instance_key="sample-1",
                 worker_team_json={},
@@ -327,7 +315,6 @@ async def test_resources_use_repository_run_scope_with_real_rows(tmp_path: Path)
             ),
             SampleRecord(
                 id=other_run_id,
-                definition_id=definition_id,
                 benchmark_type="bench",
                 instance_key="sample-2",
                 worker_team_json={},
@@ -382,7 +369,6 @@ def session_factory():
         sample_id=sample_id,
         task_id=root_id,
         execution_id=uuid4(),
-        definition_id=definition_id,
         sandbox_id="sbx",
         task_mgmt=_FakeTaskManagement(),
         task_inspect=_FakeInspection(),
diff --git a/ergon_core/tests/unit/architecture/test_core_schema_sources.py b/ergon_core/tests/unit/architecture/test_core_schema_sources.py
index d34624583..cbd8884e5 100644
--- a/ergon_core/tests/unit/architecture/test_core_schema_sources.py
+++ b/ergon_core/tests/unit/architecture/test_core_schema_sources.py
@@ -439,14 +439,25 @@ def test_definition_and_composition_services_do_not_live_in_runtime_services() -
             old_spec = None
         assert old_spec is None
 
-    new_modules = (
-        "ergon_core.core.application.experiments.definition_writer",
+    surviving_modules = (
         "ergon_core.core.application.experiments.service",
         "ergon_core.core.application.experiments.models",
+        "ergon_core.core.application.experiments.submission",
     )
-    for module_name in new_modules:
+    for module_name in surviving_modules:
         assert importlib.util.find_spec(module_name) is not None
 
+    deleted_modules = (
+        "ergon_core.core.application.experiments.definition_writer",
+        "ergon_core.core.application.experiments.launch",
+    )
+    for module_name in deleted_modules:
+        try:
+            spec = importlib.util.find_spec(module_name)
+        except ModuleNotFoundError:
+            spec = None
+        assert spec is None
+
 
 def test_runtime_services_package_no_longer_contains_domain_modules() -> None:
     services_dir = ROOT / "ergon_core/ergon_core/core/runtime/services"
@@ -652,22 +663,25 @@ def test_single_consumer_telemetry_repository_is_deleted() -> None:
     assert not repository_path.exists()
 
 
-def test_experiment_lifecycle_uses_module_level_functions() -> None:
+def test_experiment_lifecycle_uses_submission_service_only() -> None:
     service_path = ROOT / "ergon_core/ergon_core/core/application/experiments/service.py"
     service_text = service_path.read_text()
-    writer_path = ROOT / "ergon_core/ergon_core/core/application/experiments/definition_writer.py"
-    writer_text = writer_path.read_text()
+    submission_path = ROOT / "ergon_core/ergon_core/core/application/experiments/submission.py"
+    submission_text = submission_path.read_text()
 
-    # PR 6.5 cleanup: ExperimentService façade collapsed; persistence and
-    # launch are module-level functions matching the Benchmark-direct shape.
-    assert "async def run_experiment(" in service_text
-    assert "def persist_benchmark(" in writer_text
+    assert "ExperimentSubmissionService" in service_text
+    assert "class ExperimentSubmissionService" in submission_text
 
-    # define_benchmark_experiment, persist_definition, and the
-    # ExperimentService class itself must all be gone.
-    assert "def define_benchmark_experiment(" not in service_text
-    assert "def persist_definition(" not in service_text
-    assert "class ExperimentService" not in service_text
+    for retired in (
+        "def define_benchmark_experiment(",
+        "def persist_definition(",
+        "class ExperimentService",
+        "def persist_benchmark(",
+        "async def run_experiment(",
+        "def launch_run(",
+    ):
+        assert retired not in service_text
+        assert retired not in submission_text
 
     forbidden_class_names = (
         "class ExperimentService",
@@ -677,8 +691,7 @@ def test_experiment_lifecycle_uses_module_level_functions() -> None:
     )
     for path in (
         service_path,
-        writer_path,
-        ROOT / "ergon_core/ergon_core/core/application/experiments/launch.py",
+        submission_path,
     ):
         text = path.read_text()
         for class_name in forbidden_class_names:
diff --git a/ergon_core/tests/unit/architecture/test_model_field_descriptions.py b/ergon_core/tests/unit/architecture/test_model_field_descriptions.py
index fdee0e9fc..a1b412fc3 100644
--- a/ergon_core/tests/unit/architecture/test_model_field_descriptions.py
+++ b/ergon_core/tests/unit/architecture/test_model_field_descriptions.py
@@ -73,10 +73,12 @@ def test_sqlmodel_field_docs_are_schema_metadata() -> None:
     assert _description(SampleTaskEventRow, "event_type")
     assert _description(SampleEdgeEventRow, "event_type")
     assert _description(SampleAnnotationEventRow, "event_type")
-    assert "Canonical runtime" in (_description(SampleRecord, "definition_id") or "")
+    assert "Owning persisted experiment" in (_description(SampleRecord, "experiment_id") or "")
+    assert "Owning persisted environment" in (_description(SampleRecord, "environment_id") or "")
+    assert "Stable sample key" in (_description(SampleRecord, "sample_key") or "")
     assert "Optional v2 experiment grouping tag" in (_description(SampleRecord, "experiment") or "")
     assert "Compatibility/display-only" in (_description(SampleRecord, "worker_team_json") or "")
-    assert "Compatibility/display-only" in (_description(SampleRecord, "evaluator_slug") or "")
+    assert "Display-only evaluator slug" in (_description(SampleRecord, "evaluator_slug") or "")
     assert "Compatibility/display-only" in (_description(SampleRecord, "sandbox_slug") or "")
     assert "Compatibility/display-only" in (
         _description(SampleRecord, "dependency_extras_json") or ""
diff --git a/ergon_core/tests/unit/architecture/test_no_deleted_v2_symbols.py b/ergon_core/tests/unit/architecture/test_no_deleted_v2_symbols.py
index 801044823..9e85e86f7 100644
--- a/ergon_core/tests/unit/architecture/test_no_deleted_v2_symbols.py
+++ b/ergon_core/tests/unit/architecture/test_no_deleted_v2_symbols.py
@@ -21,11 +21,36 @@
     "CriterionExecutor",
     "InngestCriterionExecutor",
     "definition_task_id",
+    "ExperimentDefinition",
+    "ExperimentDefinitionTask",
+    "ExperimentDefinitionWorker",
+    "ExperimentDefinitionEvaluator",
+    "definition_id",
+    "definition_worker_id",
+    "definition_evaluator_id",
+    "definition_dependency_id",
+    "persistence.definitions",
+    "initialize_from_definition",
+    "definition_id_for_run",
+    "create_definition_backed_sample",
+    "persist_benchmark",
+    "launch_run",
+    "run_experiment",
+    "BenchmarkRequirements",
     "parent_node_id",
     "source_node_id",
     "target_node_id",
     "terminate_sandbox_by_id",
 )
+DELETED_FRONTEND_CONTRACT_TOKENS = (
+    "graph:mutation",
+    "GraphMutationDto",
+    "DashboardGraphMutationData",
+    "sampleRuntimeEventsToGraphMutations",
+    "Run Index",
+    "Search runs",
+    "No runs",
+)
 RUNTIME_VOCABULARY_FORBIDDEN_TOKENS = (
     "RunEvent",
     "RunSnapshot",
@@ -111,3 +136,16 @@ def test_generated_dashboard_schemas_are_sample_centered() -> None:
                 if token in text:
                     hits.append(f"{path.relative_to(ROOT)}: {token}")
     assert hits == []
+
+
+def test_dashboard_contracts_do_not_keep_graph_mutation_or_run_vocab_bridges() -> None:
+    hits: list[str] = []
+    dashboard_root = ROOT / "ergon-dashboard" / "src"
+    for path in dashboard_root.rglob("*"):
+        if path.suffix not in {".ts", ".tsx"} or ".test." in path.name:
+            continue
+        text = path.read_text()
+        for token in DELETED_FRONTEND_CONTRACT_TOKENS:
+            if token in text:
+                hits.append(f"{path.relative_to(ROOT)}: {token}")
+    assert hits == []
diff --git a/ergon_core/tests/unit/architecture/test_persistence_boundaries.py b/ergon_core/tests/unit/architecture/test_persistence_boundaries.py
index ef9045474..2a9807353 100644
--- a/ergon_core/tests/unit/architecture/test_persistence_boundaries.py
+++ b/ergon_core/tests/unit/architecture/test_persistence_boundaries.py
@@ -70,7 +70,7 @@ def test_telemetry_models_do_not_define_application_command_dtos() -> None:
 def test_persistence_foreign_keys_reference_existing_columns() -> None:
     for module_name in (
         "ergon_core.core.persistence.context.models",
-        "ergon_core.core.persistence.definitions.models",
+        "ergon_core.core.persistence.experiments.models",
         "ergon_core.core.persistence.graph.models",
         "ergon_core.core.persistence.telemetry.models",
     ):
@@ -95,10 +95,10 @@ def test_persistence_import_reducer_models_are_absent() -> None:
     assert not imports_dir.exists()
 
 
-def test_run_record_uses_definition_id_as_single_runtime_definition_identity() -> None:
+def test_sample_record_does_not_use_definition_identity() -> None:
     from ergon_core.core.persistence.telemetry.models import SampleRecord
 
-    assert "definition_id" in SampleRecord.model_fields
+    assert "definition_id" not in SampleRecord.model_fields
     assert ("workflow" + "_definition_id") not in SampleRecord.model_fields
 
 
diff --git a/ergon_core/tests/unit/architecture/test_public_api_boundaries.py b/ergon_core/tests/unit/architecture/test_public_api_boundaries.py
index 9dc05ff19..1edbf7a10 100644
--- a/ergon_core/tests/unit/architecture/test_public_api_boundaries.py
+++ b/ergon_core/tests/unit/architecture/test_public_api_boundaries.py
@@ -229,11 +229,13 @@ def test_experiment_application_cluster_stays_in_new_core_layout() -> None:
         core_root / "application" / "experiments" / "__init__.py",
         core_root / "application" / "experiments" / "service.py",
         core_root / "application" / "experiments" / "models.py",
-        core_root / "application" / "experiments" / "definition_writer.py",
-        core_root / "application" / "experiments" / "launch.py",
+        core_root / "application" / "experiments" / "submission.py",
     ):
         assert new_path.exists()
 
+    assert not (core_root / "application" / "experiments" / "definition_writer.py").exists()
+    assert not (core_root / "application" / "experiments" / "launch.py").exists()
+
     offenders: list[str] = []
     checked_paths = [
         path
diff --git a/ergon_core/tests/unit/architecture/test_public_api_target_structure.py b/ergon_core/tests/unit/architecture/test_public_api_target_structure.py
index c2348ec87..13e961872 100644
--- a/ergon_core/tests/unit/architecture/test_public_api_target_structure.py
+++ b/ergon_core/tests/unit/architecture/test_public_api_target_structure.py
@@ -11,7 +11,6 @@ def test_public_api_root_exports_semantic_authoring_names_only() -> None:
 
     expected = {
         "Benchmark",
-        "BenchmarkRequirements",
         "Task",
         "EmptyTaskPayload",
         "Environment",
@@ -91,7 +90,6 @@ def test_semantic_api_clusters_are_importable() -> None:
 
     assert benchmark.__all__ == [
         "Benchmark",
-        "BenchmarkRequirements",
         "Task",
         "EmptyTaskPayload",
     ]
diff --git a/ergon_core/tests/unit/architecture/test_runtime_application_ownership.py b/ergon_core/tests/unit/architecture/test_runtime_application_ownership.py
index 9a7c4f605..51795cce8 100644
--- a/ergon_core/tests/unit/architecture/test_runtime_application_ownership.py
+++ b/ergon_core/tests/unit/architecture/test_runtime_application_ownership.py
@@ -35,7 +35,6 @@ def test_runtime_is_single_application_owner_for_graph_task_and_workflow_lifecyc
         "lifecycle.py",
         "models.py",
         "resources.py",
-        "sample_identity.py",
         "sample_lifecycle.py",
         "status.py",
         "task_cleanup.py",
diff --git a/ergon_core/tests/unit/architecture/test_single_alembic_head.py b/ergon_core/tests/unit/architecture/test_single_alembic_head.py
index 4317fdbec..0d2755abe 100644
--- a/ergon_core/tests/unit/architecture/test_single_alembic_head.py
+++ b/ergon_core/tests/unit/architecture/test_single_alembic_head.py
@@ -7,12 +7,13 @@
 VERSIONS = ROOT / "ergon_core" / "migrations" / "versions"
 
 
-def test_v2_has_one_initial_migration() -> None:
+def test_v2_migration_stack_is_explicit() -> None:
     migrations = sorted(path.name for path in VERSIONS.glob("*.py"))
     assert migrations == [
         "00000000_initial_v2.py",
         "00000001_add_experiment_persistence.py",
         "00000002_add_sample_experiment_provenance.py",
+        "00000003_delete_definition_runtime_columns.py",
     ]
 
 
diff --git a/ergon_core/tests/unit/core/application/evaluation/test_inline_evaluator_persistence.py b/ergon_core/tests/unit/core/application/evaluation/test_inline_evaluator_persistence.py
index f97fea394..80a8725b3 100644
--- a/ergon_core/tests/unit/core/application/evaluation/test_inline_evaluator_persistence.py
+++ b/ergon_core/tests/unit/core/application/evaluation/test_inline_evaluator_persistence.py
@@ -9,18 +9,12 @@
     EvaluationService,
     EvaluationServiceResult,
 )
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionEvaluator,
-    ExperimentDefinitionInstance,
-    ExperimentDefinitionTask,
-)
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.shared.enums import SampleStatus, TaskExecutionStatus
 from ergon_core.core.persistence.telemetry.models import (
     SampleRecord,
-    SampleTaskEvaluation,
     SampleTaskAttempt,
+    SampleTaskEvaluation,
 )
 
 
@@ -35,44 +29,13 @@ def _session() -> Session:
 
 
 def _seed_inline_evaluator_run(session: Session) -> tuple:
-    definition_id = uuid4()
-    instance_id = uuid4()
     task_id = uuid4()
-    evaluator_id = uuid4()
     sample_id = uuid4()
     execution_id = uuid4()
     session.add_all(
         [
-            ExperimentDefinition(
-                id=definition_id,
-                benchmark_type="bench",
-                name="bench",
-                metadata_json={},
-            ),
-            ExperimentDefinitionInstance(
-                id=instance_id,
-                experiment_definition_id=definition_id,
-                instance_key="sample-1",
-            ),
-            ExperimentDefinitionTask(
-                id=task_id,
-                experiment_definition_id=definition_id,
-                instance_id=instance_id,
-                task_slug="root",
-                description="root task",
-                task_payload_json={},
-                task_json={},
-            ),
-            ExperimentDefinitionEvaluator(
-                id=evaluator_id,
-                experiment_definition_id=definition_id,
-                binding_key="judge",
-                evaluator_type="rubric",
-                snapshot_json={"name": "judge"},
-            ),
             SampleRecord(
                 id=sample_id,
-                definition_id=definition_id,
                 benchmark_type="bench",
                 instance_key="sample-1",
                 worker_team_json={},
@@ -95,17 +58,17 @@ def _seed_inline_evaluator_run(session: Session) -> tuple:
         ]
     )
     session.commit()
-    return sample_id, task_id, evaluator_id, execution_id
+    return sample_id, task_id, execution_id
 
 
 @pytest.mark.asyncio
-async def test_persist_success_links_inline_evaluator_definition_row(monkeypatch) -> None:
+async def test_persist_success_records_inline_evaluator_binding_key(monkeypatch) -> None:
     from ergon_core.core.application.evaluation import service as module
 
     session = _session()
     monkeypatch.setattr(module, "get_session", lambda: session)
     monkeypatch.setattr(session, "close", lambda: None)
-    sample_id, task_id, evaluator_id, execution_id = _seed_inline_evaluator_run(session)
+    sample_id, task_id, execution_id = _seed_inline_evaluator_run(session)
     service = EvaluationService()
 
     await service.persist_success(
@@ -127,17 +90,17 @@ async def test_persist_success_links_inline_evaluator_definition_row(monkeypatch
 
     rows = session.exec(select(SampleTaskEvaluation)).all()
     assert len(rows) == 1
-    assert rows[0].definition_evaluator_id == evaluator_id
+    assert rows[0].evaluator_slug == "judge"
 
 
 @pytest.mark.asyncio
-async def test_persist_failure_links_inline_evaluator_definition_row(monkeypatch) -> None:
+async def test_persist_failure_records_inline_evaluator_binding_key(monkeypatch) -> None:
     from ergon_core.core.application.evaluation import service as module
 
     session = _session()
     monkeypatch.setattr(module, "get_session", lambda: session)
     monkeypatch.setattr(session, "close", lambda: None)
-    sample_id, task_id, evaluator_id, execution_id = _seed_inline_evaluator_run(session)
+    sample_id, task_id, execution_id = _seed_inline_evaluator_run(session)
     service = EvaluationService()
 
     await service.persist_failure(
@@ -150,42 +113,5 @@ async def test_persist_failure_links_inline_evaluator_definition_row(monkeypatch
 
     rows = session.exec(select(SampleTaskEvaluation)).all()
     assert len(rows) == 1
-    assert rows[0].definition_evaluator_id == evaluator_id
-
-
-@pytest.mark.asyncio
-async def test_persist_success_creates_dynamic_inline_evaluator_definition_row(
-    monkeypatch,
-) -> None:
-    from ergon_core.core.application.evaluation import service as module
-
-    session = _session()
-    monkeypatch.setattr(module, "get_session", lambda: session)
-    monkeypatch.setattr(session, "close", lambda: None)
-    sample_id, task_id, _evaluator_id, execution_id = _seed_inline_evaluator_run(session)
-    service = EvaluationService()
-
-    await service.persist_success(
-        sample_id=sample_id,
-        task_execution_id=execution_id,
-        task_id=task_id,
-        binding_key="dynamic-judge",
-        service_result=EvaluationServiceResult(
-            result=TaskEvaluationResult(
-                task_slug="root",
-                score=1.0,
-                passed=True,
-                evaluator_name="dynamic-judge",
-                criterion_results=[],
-            ),
-            specs=[],
-        ),
-    )
-
-    evaluator_row = session.exec(
-        select(ExperimentDefinitionEvaluator).where(
-            ExperimentDefinitionEvaluator.binding_key == "dynamic-judge"
-        )
-    ).one()
-    rows = session.exec(select(SampleTaskEvaluation)).all()
-    assert rows[-1].definition_evaluator_id == evaluator_row.id
+    assert rows[0].evaluator_slug == "judge"
+    assert rows[0].feedback == "RuntimeError: boom"
diff --git a/ergon_core/tests/unit/core/application/experiments/test_candidate_pool.py b/ergon_core/tests/unit/core/application/experiments/test_candidate_pool.py
index 2b1f21ca9..9be5948db 100644
--- a/ergon_core/tests/unit/core/application/experiments/test_candidate_pool.py
+++ b/ergon_core/tests/unit/core/application/experiments/test_candidate_pool.py
@@ -20,7 +20,6 @@
 from ergon_core.test_support.task_factory import task_with_id
 
 for module_name in (
-    "ergon_core.core.persistence.definitions.models",
     "ergon_core.core.persistence.samples.models",
     "ergon_core.core.persistence.telemetry.models",
 ):
diff --git a/ergon_core/tests/unit/core/application/experiments/test_definition_writer_inline_evaluators.py b/ergon_core/tests/unit/core/application/experiments/test_definition_writer_inline_evaluators.py
deleted file mode 100644
index 1bee4b39c..000000000
--- a/ergon_core/tests/unit/core/application/experiments/test_definition_writer_inline_evaluators.py
+++ /dev/null
@@ -1,107 +0,0 @@
-from collections.abc import Mapping, Sequence
-from typing import ClassVar
-
-import pytest
-from sqlalchemy.pool import StaticPool
-from sqlmodel import Session, SQLModel, create_engine, select
-
-from ergon_core.api.benchmark import Benchmark
-from ergon_core.api.benchmark.task import EmptyTaskPayload, Task
-from ergon_core.api.rubric import Rubric
-from ergon_core.core.application.experiments import definition_writer as module
-from ergon_core.core.application.experiments.definition_writer import persist_benchmark
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinitionEvaluator,
-    ExperimentDefinitionTaskAssignment,
-    ExperimentDefinitionTaskEvaluator,
-    ExperimentDefinitionWorker,
-)
-from ergon_core.tests.unit.runtime._test_workers import EchoSandbox, EchoWorker
-
-
-class _InlineTask(Task[EmptyTaskPayload]):
-    pass
-
-
-class _InlineBenchmark(Benchmark):
-    type_slug: ClassVar[str] = "inline-evaluator-test"
-
-    def __init__(self, evaluators: tuple[Rubric, ...]) -> None:
-        super().__init__(name="inline evals", description="inline evaluator test")
-        self._evaluators = evaluators
-
-    def build_instances(self) -> Mapping[str, Sequence[Task]]:
-        return {
-            "sample-1": (
-                _InlineTask(
-                    task_slug="root",
-                    instance_key="sample-1",
-                    description="root task",
-                    worker=EchoWorker(name="worker", model="echo-model"),
-                    sandbox=EchoSandbox(),
-                    evaluators=self._evaluators,
-                ),
-            )
-        }
-
-
-def _session() -> Session:
-    engine = create_engine(
-        "sqlite://",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    SQLModel.metadata.create_all(engine)
-    return Session(engine)
-
-
-def test_persist_benchmark_writes_definition_rows_for_inline_evaluators(
-    monkeypatch,
-) -> None:
-    session = _session()
-    monkeypatch.setattr(module, "get_session", lambda: session)
-    monkeypatch.setattr(session, "close", lambda: None)
-
-    handle = persist_benchmark(_InlineBenchmark((Rubric(name="judge"),)))
-
-    evaluators = session.exec(select(ExperimentDefinitionEvaluator)).all()
-    bindings = session.exec(select(ExperimentDefinitionTaskEvaluator)).all()
-    workers = session.exec(select(ExperimentDefinitionWorker)).all()
-    assignments = session.exec(select(ExperimentDefinitionTaskAssignment)).all()
-
-    assert [(row.binding_key, row.evaluator_type) for row in evaluators] == [("judge", "rubric")]
-    assert evaluators[0].experiment_definition_id == handle.definition_id
-    assert evaluators[0].snapshot_json["name"] == "judge"
-    assert evaluators[0].snapshot_json["_type"].endswith(":Rubric")
-    assert [row.evaluator_binding_key for row in bindings] == ["judge"]
-    assert [(row.binding_key, row.worker_type, row.model_target) for row in workers] == [
-        ("echo", "echo", "echo-model")
-    ]
-    assert [row.worker_binding_key for row in assignments] == ["echo"]
-
-
-def test_persist_benchmark_normalizes_blank_inline_evaluator_name(
-    monkeypatch,
-) -> None:
-    session = _session()
-    monkeypatch.setattr(module, "get_session", lambda: session)
-    monkeypatch.setattr(session, "close", lambda: None)
-
-    persist_benchmark(_InlineBenchmark((Rubric(name=""),)))
-
-    evaluators = session.exec(select(ExperimentDefinitionEvaluator)).all()
-    bindings = session.exec(select(ExperimentDefinitionTaskEvaluator)).all()
-
-    assert [row.binding_key for row in evaluators] == ["inline-0"]
-    assert [row.evaluator_binding_key for row in bindings] == ["inline-0"]
-
-
-def test_persist_benchmark_rejects_duplicate_inline_evaluator_names(
-    monkeypatch,
-) -> None:
-    session = _session()
-    monkeypatch.setattr(module, "get_session", lambda: session)
-    monkeypatch.setattr(session, "close", lambda: None)
-
-    with pytest.raises(ValueError, match="Duplicate inline evaluator name"):
-        persist_benchmark(_InlineBenchmark((Rubric(name="judge"), Rubric(name="judge"))))
diff --git a/ergon_core/tests/unit/core/application/experiments/test_experiment_persistence.py b/ergon_core/tests/unit/core/application/experiments/test_experiment_persistence.py
index 9ed4913ac..ddee0e038 100644
--- a/ergon_core/tests/unit/core/application/experiments/test_experiment_persistence.py
+++ b/ergon_core/tests/unit/core/application/experiments/test_experiment_persistence.py
@@ -27,7 +27,6 @@
 from ergon_core.test_support.task_factory import task_with_id
 
 for module_name in (
-    "ergon_core.core.persistence.definitions.models",
     "ergon_core.core.persistence.samples.models",
     "ergon_core.core.persistence.telemetry.models",
 ):
diff --git a/ergon_core/tests/unit/core/application/experiments/test_experiment_submit.py b/ergon_core/tests/unit/core/application/experiments/test_experiment_submit.py
index 466442b82..be4ee0c33 100644
--- a/ergon_core/tests/unit/core/application/experiments/test_experiment_submit.py
+++ b/ergon_core/tests/unit/core/application/experiments/test_experiment_submit.py
@@ -25,7 +25,6 @@
 from ergon_core.test_support.task_factory import task_with_id
 
 for module_name in (
-    "ergon_core.core.persistence.definitions.models",
     "ergon_core.core.persistence.experiments.models",
     "ergon_core.core.persistence.graph.models",
     "ergon_core.core.persistence.samples.models",
diff --git a/ergon_core/tests/unit/core/application/experiments/test_sample_materialization.py b/ergon_core/tests/unit/core/application/experiments/test_sample_materialization.py
index debff0268..c23bd5f03 100644
--- a/ergon_core/tests/unit/core/application/experiments/test_sample_materialization.py
+++ b/ergon_core/tests/unit/core/application/experiments/test_sample_materialization.py
@@ -23,7 +23,6 @@
 from ergon_core.test_support.task_factory import task_with_id
 
 for module_name in (
-    "ergon_core.core.persistence.definitions.models",
     "ergon_core.core.persistence.experiments.models",
     "ergon_core.core.persistence.graph.models",
     "ergon_core.core.persistence.samples.models",
@@ -134,7 +133,7 @@ def test_materialization_persists_task_json_not_environment_or_experiment(
     assert worker_event.worker_type == node.task_json["worker"]["_type"]
     assert worker_event.model_target == "test:none"
     assert worker_event.worker_snapshot_json == node.task_json["worker"]
-    assert evaluator_event.evaluator_slug == "test-evaluator"
+    assert evaluator_event.evaluator_slug == "judge"
     assert evaluator_event.evaluator_type == node.task_json["evaluators"][0]["_type"]
     assert evaluator_event.evaluator_snapshot_json == node.task_json["evaluators"][0]
     assert sandbox_event.sandbox_slug == "TestSandbox"
diff --git a/ergon_core/tests/unit/core/application/jobs/test_execute_task_object_bound_fanout.py b/ergon_core/tests/unit/core/application/jobs/test_execute_task_object_bound_fanout.py
index ea75390c5..66446163e 100644
--- a/ergon_core/tests/unit/core/application/jobs/test_execute_task_object_bound_fanout.py
+++ b/ergon_core/tests/unit/core/application/jobs/test_execute_task_object_bound_fanout.py
@@ -40,10 +40,9 @@ async def load_task_view(self, _session: object, *, sample_id, task_id, sandbox_
         return SimpleNamespace(task=self._task)
 
 
-def _prepared(sample_id, definition_id, task_id, execution_id) -> PreparedTaskExecution:
+def _prepared(sample_id, task_id, execution_id) -> PreparedTaskExecution:
     return PreparedTaskExecution(
         sample_id=sample_id,
-        definition_id=definition_id,
         task_id=task_id,
         task_slug="root",
         task_description="root task",
@@ -55,7 +54,6 @@ def _prepared(sample_id, definition_id, task_id, execution_id) -> PreparedTaskEx
 @pytest.mark.asyncio
 async def test_fanout_uses_object_bound_evaluator_count(monkeypatch) -> None:
     sample_id = uuid4()
-    definition_id = uuid4()
     task_id = uuid4()
     execution_id = uuid4()
     ctx = _FakeCtx()
@@ -72,10 +70,9 @@ async def test_fanout_uses_object_bound_evaluator_count(monkeypatch) -> None:
         _FakeTaskExecutionService(task),
         TaskReadyEvent(
             sample_id=sample_id,
-            definition_id=definition_id,
             task_id=task_id,
         ),
-        _prepared(sample_id, definition_id, task_id, execution_id),
+        _prepared(sample_id, task_id, execution_id),
         evaluate_task_run_function=object(),
     )
 
@@ -85,7 +82,6 @@ async def test_fanout_uses_object_bound_evaluator_count(monkeypatch) -> None:
 @pytest.mark.asyncio
 async def test_fanout_emits_no_jobs_without_inline_evaluators(monkeypatch) -> None:
     sample_id = uuid4()
-    definition_id = uuid4()
     task_id = uuid4()
     execution_id = uuid4()
     ctx = _FakeCtx()
@@ -102,10 +98,9 @@ async def test_fanout_emits_no_jobs_without_inline_evaluators(monkeypatch) -> No
         _FakeTaskExecutionService(task),
         TaskReadyEvent(
             sample_id=sample_id,
-            definition_id=definition_id,
             task_id=task_id,
         ),
-        _prepared(sample_id, definition_id, task_id, execution_id),
+        _prepared(sample_id, task_id, execution_id),
         evaluate_task_run_function=object(),
     )
 
diff --git a/ergon_core/tests/unit/core/application/jobs/test_persist_outputs_public_sandbox.py b/ergon_core/tests/unit/core/application/jobs/test_persist_outputs_public_sandbox.py
index 36e27e775..1496e5368 100644
--- a/ergon_core/tests/unit/core/application/jobs/test_persist_outputs_public_sandbox.py
+++ b/ergon_core/tests/unit/core/application/jobs/test_persist_outputs_public_sandbox.py
@@ -59,7 +59,6 @@ async def test_persist_outputs_publishes_from_public_sandbox_output_path(monkeyp
     result = await run_persist_outputs_job(
         PersistOutputsRequest(
             sample_id=uuid4(),
-            definition_id=uuid4(),
             task_id=uuid4(),
             execution_id=uuid4(),
             sandbox_id="sbx-live",
diff --git a/ergon_core/tests/unit/core/application/jobs/test_sandbox_setup_public_sandbox.py b/ergon_core/tests/unit/core/application/jobs/test_sandbox_setup_public_sandbox.py
index 4b4b3df4d..af027c242 100644
--- a/ergon_core/tests/unit/core/application/jobs/test_sandbox_setup_public_sandbox.py
+++ b/ergon_core/tests/unit/core/application/jobs/test_sandbox_setup_public_sandbox.py
@@ -55,7 +55,6 @@ async def test_sandbox_setup_provisions_public_sandbox(monkeypatch) -> None:
         _FakeCtx(),
         SandboxSetupRequest(
             sample_id=uuid4(),
-            definition_id=uuid4(),
             task_id=uuid4(),
             benchmark_type="benchmark",
         ),
diff --git a/ergon_core/tests/unit/core/application/jobs/test_worker_execute_live_sandbox_attach.py b/ergon_core/tests/unit/core/application/jobs/test_worker_execute_live_sandbox_attach.py
index d1b50e0f0..ae527b0a3 100644
--- a/ergon_core/tests/unit/core/application/jobs/test_worker_execute_live_sandbox_attach.py
+++ b/ergon_core/tests/unit/core/application/jobs/test_worker_execute_live_sandbox_attach.py
@@ -73,7 +73,6 @@ async def _publish(_event):
     result = await run_worker_execute_job(
         WorkerExecuteJobRequest(
             sample_id=uuid4(),
-            definition_id=uuid4(),
             task_id=uuid4(),
             execution_id=uuid4(),
             sandbox_id="sbx-live",
@@ -116,7 +115,6 @@ async def load_task_view(self, _session, *, sample_id, task_id, sandbox_id=None)
         await run_worker_execute_job(
             WorkerExecuteJobRequest(
                 sample_id=uuid4(),
-                definition_id=uuid4(),
                 task_id=uuid4(),
                 execution_id=uuid4(),
                 sandbox_id="sbx-live",
@@ -143,7 +141,6 @@ async def send_event(self, step_id: str, event: object) -> None:
 
     task_id = uuid4()
     sample_id = uuid4()
-    definition_id = uuid4()
 
     async def _publish(_event):
         return None
@@ -156,7 +153,7 @@ async def _publish(_event):
     service = module._StepAwareTaskManagementService(SimpleNamespace(step=_Step()))
     await service._dispatch_collected_ready_events(
         "plan-subtasks-test",
-        [module._ReadyDispatch(sample_id=sample_id, definition_id=definition_id, task_id=task_id)],
+        [module._ReadyDispatch(sample_id=sample_id, task_id=task_id)],
     )
 
     assert len(sent) == 1
@@ -165,5 +162,5 @@ async def _publish(_event):
     payload = TaskReadyEvent.model_validate(event.data)
     assert event.name == TaskReadyEvent.name
     assert payload.sample_id == sample_id
-    assert payload.definition_id == definition_id
+    assert "definition_id" not in type(payload).model_fields
     assert payload.task_id == task_id
diff --git a/ergon_core/tests/unit/core/application/tasks/test_spawn_dynamic_task_dispatch.py b/ergon_core/tests/unit/core/application/tasks/test_spawn_dynamic_task_dispatch.py
index 342fa79e8..3216550f2 100644
--- a/ergon_core/tests/unit/core/application/tasks/test_spawn_dynamic_task_dispatch.py
+++ b/ergon_core/tests/unit/core/application/tasks/test_spawn_dynamic_task_dispatch.py
@@ -55,10 +55,8 @@ async def test_spawn_dynamic_task_dispatches_ready_event_when_dependency_free(mo
     graph_repo = _FakeGraphRepo()
     dispatched: list[dict] = []
 
-    async def dispatch_task_ready(sample_id, definition_id, task_id):
-        dispatched.append(
-            {"sample_id": sample_id, "definition_id": definition_id, "task_id": task_id}
-        )
+    async def dispatch_task_ready(sample_id, task_id):
+        dispatched.append({"sample_id": sample_id, "task_id": task_id})
 
     service = TaskManagementService(
         graph_repo=graph_repo,
@@ -67,10 +65,10 @@ async def dispatch_task_ready(sample_id, definition_id, task_id):
     )
 
     monkeypatch.setattr(module, "get_session", lambda: _session_factory(session))
-    monkeypatch.setattr(module, "definition_id_for_run", lambda _session, _run_id: uuid4())
+    sample_id = uuid4()
 
     handle = await service.spawn_dynamic_task(
-        sample_id=uuid4(),
+        sample_id=sample_id,
         parent_task_id=uuid4(),
         task=_DynamicTask(
             task_slug="child",
@@ -83,8 +81,7 @@ async def dispatch_task_ready(sample_id, definition_id, task_id):
 
     assert dispatched == [
         {
-            "sample_id": dispatched[0]["sample_id"],
-            "definition_id": dispatched[0]["definition_id"],
+            "sample_id": sample_id,
             "task_id": handle.task_id,
         }
     ]
@@ -102,10 +99,8 @@ async def test_spawn_dynamic_task_with_dependencies_waits_for_propagation(monkey
     graph_repo = _FakeGraphRepo()
     dispatched: list[dict] = []
 
-    async def dispatch_task_ready(sample_id, definition_id, task_id):
-        dispatched.append(
-            {"sample_id": sample_id, "definition_id": definition_id, "task_id": task_id}
-        )
+    async def dispatch_task_ready(sample_id, task_id):
+        dispatched.append({"sample_id": sample_id, "task_id": task_id})
 
     service = TaskManagementService(
         graph_repo=graph_repo,
diff --git a/ergon_core/tests/unit/evaluation/test_evaluation_dto_mapping.py b/ergon_core/tests/unit/evaluation/test_evaluation_dto_mapping.py
index 10cf45072..ac4e46633 100644
--- a/ergon_core/tests/unit/evaluation/test_evaluation_dto_mapping.py
+++ b/ergon_core/tests/unit/evaluation/test_evaluation_dto_mapping.py
@@ -57,7 +57,7 @@ def test_evaluation_row_to_dto_maps_multiple_criterion_outcomes() -> None:
         sample_id=sample_id,
         task_execution_id=uuid4(),
         task_id=task_id,
-        definition_evaluator_id=uuid4(),
+        evaluator_slug="judge",
         score=1.5,
         passed=False,
         feedback="mixed",
diff --git a/ergon_core/tests/unit/evaluation/test_evaluation_persistence.py b/ergon_core/tests/unit/evaluation/test_evaluation_persistence.py
index 3e68d3bdb..6de7fe132 100644
--- a/ergon_core/tests/unit/evaluation/test_evaluation_persistence.py
+++ b/ergon_core/tests/unit/evaluation/test_evaluation_persistence.py
@@ -9,12 +9,6 @@
     EvaluationService,
     EvaluationServiceResult,
 )
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionEvaluator,
-    ExperimentDefinitionInstance,
-    ExperimentDefinitionTask,
-)
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.shared.enums import SampleStatus, TaskExecutionStatus
 from ergon_core.core.persistence.telemetry.models import (
@@ -35,44 +29,13 @@ def _session() -> Session:
 
 
 def _seed_run(session: Session) -> tuple:
-    definition_id = uuid4()
-    instance_id = uuid4()
     task_id = uuid4()
-    evaluator_id = uuid4()
     sample_id = uuid4()
     execution_id = uuid4()
     session.add_all(
         [
-            ExperimentDefinition(
-                id=definition_id,
-                benchmark_type="bench",
-                name="bench",
-                metadata_json={},
-            ),
-            ExperimentDefinitionInstance(
-                id=instance_id,
-                experiment_definition_id=definition_id,
-                instance_key="sample-1",
-            ),
-            ExperimentDefinitionTask(
-                id=task_id,
-                experiment_definition_id=definition_id,
-                instance_id=instance_id,
-                task_slug="root",
-                description="root task",
-                task_payload_json={},
-                task_json={},
-            ),
-            ExperimentDefinitionEvaluator(
-                id=evaluator_id,
-                experiment_definition_id=definition_id,
-                binding_key="judge",
-                evaluator_type="rubric",
-                snapshot_json={"name": "judge"},
-            ),
             SampleRecord(
                 id=sample_id,
-                definition_id=definition_id,
                 benchmark_type="bench",
                 instance_key="sample-1",
                 worker_team_json={},
@@ -95,7 +58,7 @@ def _seed_run(session: Session) -> tuple:
         ]
     )
     session.commit()
-    return sample_id, task_id, evaluator_id, execution_id
+    return sample_id, task_id, execution_id
 
 
 @pytest.mark.asyncio
@@ -105,7 +68,7 @@ async def test_persist_success_writes_evaluation_row_with_service_summary(monkey
     session = _session()
     monkeypatch.setattr(service_module, "get_session", lambda: session)
     monkeypatch.setattr(session, "close", lambda: None)
-    sample_id, task_id, evaluator_id, execution_id = _seed_run(session)
+    sample_id, task_id, execution_id = _seed_run(session)
 
     persisted = await EvaluationService().persist_success(
         sample_id=sample_id,
@@ -130,4 +93,4 @@ async def test_persist_success_writes_evaluation_row_with_service_summary(monkey
     assert row.passed is True
     assert row.task_execution_id == execution_id
     assert row.task_id == task_id
-    assert row.definition_evaluator_id == evaluator_id
+    assert row.evaluator_slug == "judge"
diff --git a/ergon_core/tests/unit/persistence/test_context_event_repository.py b/ergon_core/tests/unit/persistence/test_context_event_repository.py
index 53f11cab9..355b42eb1 100644
--- a/ergon_core/tests/unit/persistence/test_context_event_repository.py
+++ b/ergon_core/tests/unit/persistence/test_context_event_repository.py
@@ -13,7 +13,6 @@
 )
 from ergon_core.core.persistence.context.models import SampleContextEvent
 from ergon_core.core.application.context.service import ContextEventService
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.shared.enums import SampleStatus, TaskExecutionStatus
 from ergon_core.core.persistence.telemetry.models import (
@@ -25,7 +24,6 @@
 
 
 def _session() -> Session:
-    _ = ExperimentDefinition
     engine = create_engine(
         "sqlite://",
         connect_args={"check_same_thread": False},
@@ -37,7 +35,6 @@ def _session() -> Session:
 
 def _execution_fixture(session: Session) -> tuple:
     sample_id = uuid4()
-    definition_id = uuid4()
     task_id = uuid4()
     node = SampleGraphNode(
         sample_id=sample_id,
@@ -48,18 +45,9 @@ def _execution_fixture(session: Session) -> tuple:
         status="running",
         assigned_worker_slug="worker",
     )
-    session.add(
-        ExperimentDefinition(
-            id=definition_id,
-            benchmark_type="unit",
-            name="unit",
-            metadata_json={},
-        )
-    )
     session.add(
         SampleRecord(
             id=sample_id,
-            definition_id=definition_id,
             benchmark_type="unit",
             instance_key="instance",
             status=SampleStatus.EXECUTING,
@@ -70,7 +58,6 @@ def _execution_fixture(session: Session) -> tuple:
     execution = SampleTaskAttempt(
         sample_id=sample_id,
         task_id=node.task_id,
-        node_id=node.task_id,
         status=TaskExecutionStatus.RUNNING,
     )
     session.add(execution)
diff --git a/ergon_core/tests/unit/read_models/test_experiment_read_service.py b/ergon_core/tests/unit/read_models/test_experiment_read_service.py
index 7954bb39f..0b7b5a733 100644
--- a/ergon_core/tests/unit/read_models/test_experiment_read_service.py
+++ b/ergon_core/tests/unit/read_models/test_experiment_read_service.py
@@ -1,29 +1,15 @@
-from datetime import UTC, datetime, timedelta
+from datetime import UTC, datetime
 import json
 from uuid import uuid4
 
 import pytest
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionInstance,
-    ExperimentDefinitionTask,
-)
 from ergon_core.core.persistence.experiments.models import (
     ExperimentEnvironmentRow,
     ExperimentRow,
     ExperimentSamplerInvocationRow,
 )
-from ergon_core.core.persistence.context.models import SampleContextEvent
-from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.shared.enums import SampleStatus
 from ergon_core.core.persistence.telemetry.models import SampleRecord
-from ergon_core.core.shared.context_parts import (
-    AssistantTextPart,
-    ContextPartChunkLog,
-    ProviderTokenUsage,
-    ToolCallPart,
-)
-from ergon_core.core.views.experiments import service as module
 from ergon_core.core.views.experiments.service import ExperimentReadService
 from sqlalchemy.pool import StaticPool
 from sqlmodel import Session, SQLModel, create_engine
@@ -31,11 +17,6 @@
 
 @pytest.fixture()
 def session_factory():
-    _ = ExperimentDefinition
-    _ = ExperimentDefinitionInstance
-    _ = ExperimentDefinitionTask
-    _ = SampleContextEvent
-    _ = SampleGraphNode
     _ = ExperimentRow
     _ = ExperimentEnvironmentRow
     _ = ExperimentSamplerInvocationRow
@@ -52,205 +33,6 @@ def _get_session() -> Session:
     return _get_session
 
 
-def test_experiment_detail_aggregates_run_analytics(monkeypatch, session_factory) -> None:
-    now = datetime(2026, 4, 27, 12, 0, tzinfo=UTC)
-    definition_id = uuid4()
-    run_a_id = uuid4()
-    run_b_id = uuid4()
-    run_c_id = uuid4()
-
-    with session_factory() as session:
-        session.add(
-            ExperimentDefinition(
-                id=definition_id,
-                name="ci experiment",
-                benchmark_type="ci-benchmark",
-                metadata_json={
-                    "default_worker_team": {"primary": "ci-worker"},
-                    "default_evaluator_slug": "ci-evaluator",
-                    "default_model_target": "openai:gpt-4o",
-                    "status": "running",
-                },
-                created_at=now,
-            )
-        )
-        for instance_key in ("a", "b", "c"):
-            session.add(
-                ExperimentDefinitionInstance(
-                    experiment_definition_id=definition_id,
-                    instance_key=instance_key,
-                )
-            )
-        for sample_id, instance_key, status, started, completed, score, cost in [
-            (run_a_id, "a", SampleStatus.COMPLETED, now, now + timedelta(seconds=10), 1.0, 0.2),
-            (run_b_id, "b", SampleStatus.FAILED, now, now + timedelta(seconds=20), 0.0, 0.3),
-            (run_c_id, "c", SampleStatus.EXECUTING, now, None, None, None),
-        ]:
-            session.add(
-                SampleRecord(
-                    id=sample_id,
-                    definition_id=definition_id,
-                    benchmark_type="ci-benchmark",
-                    instance_key=instance_key,
-                    worker_team_json={"primary": "ci-worker"},
-                    evaluator_slug="ci-evaluator",
-                    model_target="openai:gpt-4o",
-                    status=status,
-                    started_at=started,
-                    completed_at=completed,
-                    summary_json=(
-                        {
-                            "final_score": score,
-                            "total_cost_usd": cost,
-                            "cost_observed": True,
-                        }
-                        if score is not None and cost is not None
-                        else {}
-                    ),
-                )
-            )
-            for index in range(2):
-                session.add(
-                    SampleGraphNode(
-                        sample_id=sample_id,
-                        instance_key=instance_key,
-                        task_slug=f"{instance_key}-{index}",
-                        description="Task",
-                        status="completed",
-                        assigned_worker_slug="ci-worker",
-                        level=index,
-                    )
-                )
-        session.commit()
-
-    monkeypatch.setattr(module, "get_session", session_factory)
-
-    detail = ExperimentReadService().get_experiment(definition_id)
-
-    assert detail is not None
-    assert detail.analytics.total_runs == 3
-    assert detail.analytics.status_counts.completed == 1
-    assert detail.analytics.status_counts.failed == 1
-    assert detail.analytics.status_counts.executing == 1
-    assert detail.analytics.average_score == 0.5
-    assert detail.analytics.average_duration_ms == 15_000
-    assert detail.analytics.average_tasks == 2.0
-    assert detail.analytics.total_cost_usd == 0.5
-    assert detail.runs[0].running_time_ms == 10_000
-    assert detail.runs[0].total_tasks == 2
-
-
-def test_experiment_run_rows_project_nested_metrics(monkeypatch, session_factory) -> None:
-    now = datetime(2026, 4, 27, 12, 0, tzinfo=UTC)
-    definition_id = uuid4()
-    sample_id = uuid4()
-    execution_id = uuid4()
-
-    with session_factory() as session:
-        session.add(
-            ExperimentDefinition(
-                id=definition_id,
-                name="metric experiment",
-                benchmark_type="metric-benchmark",
-                metadata_json={},
-                created_at=now,
-            )
-        )
-        session.add(
-            SampleRecord(
-                id=sample_id,
-                definition_id=definition_id,
-                benchmark_type="metric-benchmark",
-                instance_key="sample-1",
-                sample_id="sample label",
-                worker_team_json={"primary": "ci-worker"},
-                evaluator_slug="metric-evaluator",
-                model_target="openai:gpt-4o",
-                status=SampleStatus.COMPLETED,
-                started_at=now,
-                completed_at=now + timedelta(seconds=3),
-                summary_json={
-                    "normalized_score": 0.75,
-                    "total_cost_usd": 0.0,
-                    "error_message": "ignored because run succeeded",
-                },
-            )
-        )
-        session.add(
-            SampleGraphNode(
-                sample_id=sample_id,
-                instance_key="sample-1",
-                task_slug="root",
-                description="Task",
-                status="completed",
-                assigned_worker_slug="ci-worker",
-                level=0,
-            )
-        )
-        session.add(
-            SampleContextEvent(
-                sample_id=sample_id,
-                task_execution_id=execution_id,
-                worker_binding_key="ci-worker",
-                sequence=0,
-                event_type="assistant_text",
-                payload=ContextPartChunkLog(
-                    part=AssistantTextPart(content="answer"),
-                    sequence=0,
-                    worker_binding_key="ci-worker",
-                    provider_usage=ProviderTokenUsage(completion_tokens=9),
-                ).model_dump(mode="json"),
-            )
-        )
-        session.add(
-            SampleContextEvent(
-                sample_id=sample_id,
-                task_execution_id=execution_id,
-                worker_binding_key="ci-worker",
-                sequence=1,
-                event_type="tool_call",
-                payload=ContextPartChunkLog(
-                    part=ToolCallPart(
-                        tool_call_id="call-1",
-                        tool_name="search",
-                        args={"q": "x"},
-                    ),
-                    token_ids=[1, 2, 3],
-                    sequence=1,
-                    worker_binding_key="ci-worker",
-                ).model_dump(mode="json"),
-            )
-        )
-        session.commit()
-
-    monkeypatch.setattr(module, "get_session", session_factory)
-
-    detail = ExperimentReadService().get_experiment(definition_id)
-
-    assert detail is not None
-    row = detail.runs[0]
-    assert row.running_time_ms == 3_000
-    assert row.total_cost_usd is None
-    assert row.metrics.sample_id == sample_id
-    assert row.metrics.run_name == "sample label"
-    assert row.metrics.status == "completed"
-    assert row.metrics.sample_label == "sample label"
-    assert row.metrics.instance_key == "sample-1"
-    assert row.metrics.score == 0.75
-    assert row.metrics.return_value == 0.75
-    assert row.metrics.duration_ms == 3_000
-    assert row.metrics.total_tasks == 1
-    assert row.metrics.tool_call_count == 1
-    assert row.metrics.total_tokens == 12
-    assert row.metrics.token_breakdown["assistant_text"] == 9
-    assert row.metrics.token_breakdown["tool_call"] == 3
-    assert row.metrics.total_cost_usd is None
-    assert row.metrics.cost_observed is False
-    assert row.metrics.model_target == "openai:gpt-4o"
-    assert row.metrics.evaluator_slug == "metric-evaluator"
-    assert row.metrics.error_summary is None
-
-
 def test_experiment_state_contains_environments_samples_and_invocations(session_factory) -> None:
     now = datetime(2026, 5, 26, 12, 0, tzinfo=UTC)
     experiment_id = uuid4()
@@ -303,156 +85,67 @@ def test_experiment_state_contains_environments_samples_and_invocations(session_
 
     assert state is not None
     assert state.experiment_id == experiment_id
+    assert state.environments[0].environment_id == environment_id
     assert state.environments[0].environment_name == "mini-validation"
     assert state.environments[0].sample_count == 1
+    assert state.environments[0].selected_count == 1
     assert state.sample_count == 1
     assert state.samples[0].sample_id == sample_id
+    assert state.samples[0].experiment_id == experiment_id
+    assert state.samples[0].environment_id == environment_id
+    assert state.samples[0].sample_key == "problem-1"
+    assert state.samples[0].sample_ref == {"id": "problem-1"}
+    assert state.samples[0].source_metadata == {"split": "validation"}
     assert state.sampler_invocations[0].sampler_name == "random"
     dumped = state.model_dump(mode="json", by_alias=True)
     assert "definitionId" not in json.dumps(dumped)
     assert "runId" not in json.dumps(dumped)
 
 
-def test_experiment_detail_groups_runs_by_experiment_tag(monkeypatch, session_factory) -> None:
-    definition_a = uuid4()
-    definition_b = uuid4()
-    grouped_run_a = uuid4()
-    grouped_run_b = uuid4()
-    ungrouped_run = uuid4()
-
-    with session_factory() as session:
-        session.add(
-            ExperimentDefinition(
-                id=definition_a,
-                name="arm-a",
-                benchmark_type="ci-benchmark",
-                metadata_json={"experiment": "group-alpha"},
-            )
-        )
-        session.add(
-            ExperimentDefinition(
-                id=definition_b,
-                name="arm-b",
-                benchmark_type="ci-benchmark",
-                metadata_json={"experiment": "group-alpha"},
-            )
-        )
-        for sample_id, definition_id, experiment in (
-            (grouped_run_a, definition_a, "group-alpha"),
-            (grouped_run_b, definition_b, "group-alpha"),
-            (ungrouped_run, definition_a, "other-group"),
-        ):
-            session.add(
-                SampleRecord(
-                    id=sample_id,
-                    definition_id=definition_id,
-                    benchmark_type="ci-benchmark",
-                    instance_key=str(sample_id),
-                    worker_team_json={},
-                    experiment=experiment,
-                    status=SampleStatus.COMPLETED,
-                )
-            )
-        session.commit()
-
-    monkeypatch.setattr(module, "get_session", session_factory)
-
-    detail = ExperimentReadService().get_experiment(definition_a)
-
-    assert detail is not None
-    assert {run.sample_id for run in detail.runs} == {grouped_run_a, grouped_run_b}
-    assert detail.experiment.run_count == 2
-    assert detail.analytics.total_runs == 2
-
-
-def test_read_service_returns_definition_metadata_without_benchmark_definition_record(
-    monkeypatch, session_factory
+def test_list_experiment_states_reads_experiment_rows_without_sample_payloads(
+    session_factory,
 ) -> None:
-    """``get_experiment`` resolves directly from ``ExperimentDefinition``."""
+    now = datetime(2026, 5, 26, 12, 0, tzinfo=UTC)
+    experiment_id = uuid4()
+    environment_id = uuid4()
+    sample_id = uuid4()
 
-    definition_id = uuid4()
     with session_factory() as session:
+        session.add(ExperimentRow(id=experiment_id, name="mixed-training", created_at=now))
         session.add(
-            ExperimentDefinition(
-                id=definition_id,
-                benchmark_type="mini",
-                name="mini-experiment",
-                description="smoke for read model",
-                metadata_json={"created_by": "test"},
+            ExperimentEnvironmentRow(
+                id=environment_id,
+                experiment_id=experiment_id,
+                name="mini-validation",
+                source_mode="materialized",
             )
         )
-        session.commit()
-
-    monkeypatch.setattr(module, "get_session", session_factory)
-
-    detail = ExperimentReadService().get_experiment(definition_id)
-
-    assert detail is not None
-    assert detail.definition_id == definition_id
-    assert detail.name == "mini-experiment"
-    assert detail.description == "smoke for read model"
-    assert detail.benchmark_type == "mini"
-    assert detail.metadata.get("created_by") == "test"
-
-
-def test_read_service_returns_none_for_unknown_definition(monkeypatch, session_factory) -> None:
-    monkeypatch.setattr(module, "get_session", session_factory)
-
-    detail = ExperimentReadService().get_experiment(uuid4())
-    assert detail is None
-
-
-def test_list_experiments_reads_definition_rows(monkeypatch, session_factory) -> None:
-    definition_id = uuid4()
-    with session_factory() as session:
         session.add(
-            ExperimentDefinition(
-                id=definition_id,
-                name="definition-name",
-                benchmark_type="definition-type",
-                metadata_json={},
+            SampleRecord(
+                id=sample_id,
+                experiment_id=experiment_id,
+                environment_id=environment_id,
+                sample_key="problem-1",
+                benchmark_type="experiment",
+                instance_key="problem-1",
+                status=SampleStatus.COMPLETED,
             )
         )
         session.commit()
 
-    monkeypatch.setattr(module, "get_session", session_factory)
+        states = ExperimentReadService(session).list_experiment_states(limit=10)
 
-    summaries = ExperimentReadService().list_experiments(limit=10)
-    matching = [s for s in summaries if s.definition_id == definition_id]
-    assert len(matching) == 1
-    assert matching[0].name == "definition-name"
-    assert matching[0].benchmark_type == "definition-type"
+    assert len(states.items) == 1
+    state = states.items[0]
+    assert state.experiment_id == experiment_id
+    assert state.name == "mixed-training"
+    assert state.sample_count == 1
+    assert state.environments[0].environment_id == environment_id
+    assert state.samples == []
 
 
-def test_list_experiments_projects_aggregate_lifecycle_status(monkeypatch, session_factory) -> None:
-    definition_id = uuid4()
+def test_list_experiment_samples_returns_none_for_unknown_experiment(session_factory) -> None:
     with session_factory() as session:
-        session.add(
-            ExperimentDefinition(
-                id=definition_id,
-                name="finished-with-failure",
-                benchmark_type="ci-benchmark",
-                metadata_json={},
-            )
-        )
-        for index, status in enumerate(
-            (SampleStatus.COMPLETED, SampleStatus.COMPLETED, SampleStatus.FAILED)
-        ):
-            session.add(
-                SampleRecord(
-                    definition_id=definition_id,
-                    benchmark_type="ci-benchmark",
-                    instance_key=f"sample-{index}",
-                    worker_team_json={},
-                    status=status,
-                )
-            )
-        session.commit()
-
-    monkeypatch.setattr(module, "get_session", session_factory)
-
-    summaries = ExperimentReadService().list_experiments(limit=10)
-    matching = [s for s in summaries if s.definition_id == definition_id]
+        samples = ExperimentReadService(session).list_experiment_samples(uuid4())
 
-    assert len(matching) == 1
-    assert matching[0].status == "failed"
+    assert samples is None
diff --git a/ergon_core/tests/unit/read_models/test_sample_read_service.py b/ergon_core/tests/unit/read_models/test_sample_read_service.py
index b2b7af873..fc4340e09 100644
--- a/ergon_core/tests/unit/read_models/test_sample_read_service.py
+++ b/ergon_core/tests/unit/read_models/test_sample_read_service.py
@@ -11,7 +11,6 @@
     VIEW_EVENT_TYPES,
     SampleRuntimeEventView,
 )
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.experiments.models import ExperimentEnvironmentRow, ExperimentRow
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.samples.models import SampleStatusEventRow, SampleTaskEventRow
@@ -36,7 +35,6 @@ def _literal_values(annotation: object) -> set[str]:
 
 @pytest.fixture()
 def session_factory():
-    _ = ExperimentDefinition
     _ = ExperimentRow
     _ = ExperimentEnvironmentRow
     _ = SampleGraphNode
@@ -57,33 +55,27 @@ def _get_session() -> Session:
 
 def test_list_runs_filters_offsets_and_projects_index_summary(monkeypatch, session_factory) -> None:
     now = datetime(2026, 5, 20, 12, 0, tzinfo=UTC)
-    definition_id = uuid4()
-    skipped_definition_id = uuid4()
+    experiment_id = uuid4()
+    environment_id = uuid4()
     older_run_id = uuid4()
     matching_run_id = uuid4()
     skipped_run_id = uuid4()
 
     with session_factory() as session:
+        session.add(ExperimentRow(id=experiment_id, name="MiniWob comparison", created_at=now))
         session.add(
-            ExperimentDefinition(
-                id=definition_id,
-                name="MiniWob comparison",
-                benchmark_type="miniwob",
-                metadata_json={"experiment": "alpha"},
-            )
-        )
-        session.add(
-            ExperimentDefinition(
-                id=skipped_definition_id,
-                name="Other experiment",
-                benchmark_type="math",
-                metadata_json={},
+            ExperimentEnvironmentRow(
+                id=environment_id,
+                experiment_id=experiment_id,
+                name="mini-validation",
+                source_mode="materialized",
             )
         )
         session.add(
             SampleRecord(
                 id=older_run_id,
-                definition_id=definition_id,
+                experiment_id=experiment_id,
+                environment_id=environment_id,
                 benchmark_type="miniwob",
                 instance_key="task-old",
                 sample_id="sample-old",
@@ -95,7 +87,8 @@ def test_list_runs_filters_offsets_and_projects_index_summary(monkeypatch, sessi
         session.add(
             SampleRecord(
                 id=matching_run_id,
-                definition_id=definition_id,
+                experiment_id=experiment_id,
+                environment_id=environment_id,
                 benchmark_type="miniwob",
                 instance_key="task-1",
                 sample_id="sample-1",
@@ -118,7 +111,8 @@ def test_list_runs_filters_offsets_and_projects_index_summary(monkeypatch, sessi
         session.add(
             SampleRecord(
                 id=skipped_run_id,
-                definition_id=skipped_definition_id,
+                experiment_id=uuid4(),
+                environment_id=uuid4(),
                 benchmark_type="math",
                 instance_key="math-1",
                 experiment="beta",
@@ -146,7 +140,6 @@ def test_list_runs_filters_offsets_and_projects_index_summary(monkeypatch, sessi
         limit=1,
         offset=0,
         status="completed",
-        definition_id=definition_id,
         experiment="alpha",
     )
 
@@ -154,8 +147,7 @@ def test_list_runs_filters_offsets_and_projects_index_summary(monkeypatch, sessi
     summary = summaries[0]
     assert summary.id == matching_run_id
     assert summary.name == "alpha task 1"
-    assert summary.definition_id == definition_id
-    assert summary.definition_name == "MiniWob comparison"
+    assert summary.experiment_id == experiment_id
     assert summary.experiment == "alpha"
     assert summary.benchmark_type == "miniwob"
     assert summary.sample_id == "sample-1"
@@ -176,22 +168,12 @@ def test_list_runs_filters_offsets_and_projects_index_summary(monkeypatch, sessi
 
 def test_failed_run_snapshot_preserves_persisted_final_score(monkeypatch, session_factory) -> None:
     now = datetime(2026, 5, 20, 12, 0, tzinfo=UTC)
-    definition_id = uuid4()
     sample_id = uuid4()
 
     with session_factory() as session:
-        session.add(
-            ExperimentDefinition(
-                id=definition_id,
-                name="Failed score experiment",
-                benchmark_type="smoke",
-                metadata_json={},
-            )
-        )
         session.add(
             SampleRecord(
                 id=sample_id,
-                definition_id=definition_id,
                 benchmark_type="smoke",
                 instance_key="sad-path",
                 status=SampleStatus.FAILED,
diff --git a/ergon_core/tests/unit/rest_api/test_samples_routes.py b/ergon_core/tests/unit/rest_api/test_samples_routes.py
index 1bbd17805..d4e4c3e62 100644
--- a/ergon_core/tests/unit/rest_api/test_samples_routes.py
+++ b/ergon_core/tests/unit/rest_api/test_samples_routes.py
@@ -24,7 +24,6 @@ def list_samples(
         *,
         limit: int = 20,
         status: str | None = None,
-        definition_id: UUID | None = None,
         experiment: str | None = None,
         offset: int = 0,
     ) -> list[SampleSummaryDto]:
@@ -32,7 +31,6 @@ def list_samples(
             {
                 "limit": limit,
                 "status": status,
-                "definition_id": definition_id,
                 "experiment": experiment,
                 "offset": offset,
             }
@@ -43,8 +41,8 @@ def list_samples(
                 name="route sample",
                 status="completed",
                 created_at=datetime(2026, 5, 20, 12, 0, tzinfo=UTC),
-                definition_id=definition_id or uuid4(),
-                definition_name="route experiment",
+                experiment_id=uuid4(),
+                experiment=experiment,
                 benchmark_type="route-bench",
                 instance_key="sample-a",
                 sample_label="sample-a",
@@ -58,7 +56,6 @@ def build_snapshot(self, sample_id: UUID) -> SampleSnapshotDto:
             id=str(sample_id),
             name="route snapshot",
             status="completed",
-            definition_id=str(uuid4()),
         )
 
 
@@ -67,13 +64,10 @@ def test_list_samples_route_passes_filters_to_read_service(monkeypatch) -> None:
     app.include_router(router)
     client = TestClient(app)
     fake_service = _FakeSampleSnapshotReadService()
-    definition_id = uuid4()
 
     monkeypatch.setattr(module, "SampleSnapshotReadService", lambda: fake_service)
 
-    response = client.get(
-        f"/samples?limit=25&offset=50&status=completed&definition_id={definition_id}&experiment=alpha"
-    )
+    response = client.get("/samples?limit=25&offset=50&status=completed&experiment=alpha")
 
     assert response.status_code == 200
     assert fake_service.calls == [
@@ -81,13 +75,12 @@ def test_list_samples_route_passes_filters_to_read_service(monkeypatch) -> None:
             "limit": 25,
             "offset": 50,
             "status": "completed",
-            "definition_id": definition_id,
             "experiment": "alpha",
         }
     ]
     body = response.json()
     assert body[0]["name"] == "route sample"
-    assert body[0]["definition_name"] == "route experiment"
+    assert body[0]["experiment"] == "alpha"
     assert body[0]["total_tasks"] == 1
 
 
diff --git a/ergon_core/tests/unit/rest_api/test_samples_routes_existing.py b/ergon_core/tests/unit/rest_api/test_samples_routes_existing.py
index 3dbd112f4..54f90f46f 100644
--- a/ergon_core/tests/unit/rest_api/test_samples_routes_existing.py
+++ b/ergon_core/tests/unit/rest_api/test_samples_routes_existing.py
@@ -16,7 +16,6 @@ def list_samples(
         *,
         limit: int = 20,
         status: str | None = None,
-        definition_id: UUID | None = None,
         experiment: str | None = None,
         offset: int = 0,
     ) -> list[SampleSummaryDto]:
@@ -24,7 +23,6 @@ def list_samples(
             {
                 "limit": limit,
                 "status": status,
-                "definition_id": definition_id,
                 "experiment": experiment,
                 "offset": offset,
             }
@@ -35,8 +33,8 @@ def list_samples(
                 name="route sample",
                 status="completed",
                 created_at=datetime(2026, 5, 20, 12, 0, tzinfo=UTC),
-                definition_id=definition_id or uuid4(),
-                definition_name="route experiment",
+                experiment_id=uuid4(),
+                experiment=experiment,
                 benchmark_type="route-bench",
                 instance_key="sample-a",
                 sample_label="sample-a",
@@ -51,13 +49,10 @@ def test_list_samples_route_passes_filters_to_read_service(monkeypatch) -> None:
     app.include_router(router)
     client = TestClient(app)
     fake_service = _FakeSampleSnapshotReadService()
-    definition_id = uuid4()
 
     monkeypatch.setattr(module, "SampleSnapshotReadService", lambda: fake_service)
 
-    response = client.get(
-        f"/samples?limit=25&offset=50&status=completed&definition_id={definition_id}&experiment=alpha"
-    )
+    response = client.get("/samples?limit=25&offset=50&status=completed&experiment=alpha")
 
     assert response.status_code == 200
     assert fake_service.calls == [
@@ -65,11 +60,10 @@ def test_list_samples_route_passes_filters_to_read_service(monkeypatch) -> None:
             "limit": 25,
             "offset": 50,
             "status": "completed",
-            "definition_id": definition_id,
             "experiment": "alpha",
         }
     ]
     body = response.json()
     assert body[0]["name"] == "route sample"
-    assert body[0]["definition_name"] == "route experiment"
+    assert body[0]["experiment"] == "alpha"
     assert body[0]["total_tasks"] == 1
diff --git a/ergon_core/tests/unit/rest_api/test_test_harness.py b/ergon_core/tests/unit/rest_api/test_test_harness.py
index 8df42e868..d7a877dbc 100644
--- a/ergon_core/tests/unit/rest_api/test_test_harness.py
+++ b/ergon_core/tests/unit/rest_api/test_test_harness.py
@@ -1,16 +1,26 @@
 """Test-harness router: conditional mount, read DTO shape, write-gate secret."""
 
 from collections.abc import Iterator
+from datetime import UTC, datetime
 from uuid import uuid4
 
+from ergon_core.core.application.samples.event_views import (
+    SampleTaskAddedEventView,
+    SampleWorkerAddedEventView,
+)
 from ergon_core.core.application.testing.test_harness_service import (
-    HarnessExperimentRun,
+    HarnessExperimentSample,
     get_session_dep,
 )
+from ergon_core.core.application.testing import test_harness_service as harness_service
 from ergon_core.core.infrastructure.http.routes import test_harness
 from ergon_core.core.infrastructure.http.routes.test_harness import router
+from ergon_core.core.persistence.experiments.models import ExperimentRow
+from ergon_core.core.persistence.shared.enums import SampleStatus
+from ergon_core.core.persistence.telemetry.models import SampleRecord
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
+from sqlmodel import Session, SQLModel, create_engine
 
 
 class _NullSession:
@@ -48,7 +58,39 @@ def _build_app_with_harness() -> FastAPI:
     return app
 
 
-def test_read_endpoint_returns_404_for_unknown_run_id() -> None:
+class _ReadStateResult:
+    def __init__(self, first_value: object | None, all_values: list[object] | None = None) -> None:
+        self._first_value = first_value
+        self._all_values = [] if all_values is None else all_values
+
+    def first(self) -> object | None:
+        return self._first_value
+
+    def all(self) -> list[object]:
+        return self._all_values
+
+
+class _ReadStateSession:
+    def __init__(self, sample: object) -> None:
+        self._sample = sample
+        self._returned_sample = False
+
+    def exec(self, _stmt: object) -> _ReadStateResult:
+        if not self._returned_sample:
+            self._returned_sample = True
+            return _ReadStateResult(self._sample)
+        return _ReadStateResult(None, [])
+
+
+class _SampleRuntimeEventReadService:
+    def __init__(self, events: list[object]) -> None:
+        self._events = events
+
+    def list_events(self, _session: object, _sample_id: object) -> list[object]:
+        return self._events
+
+
+def test_read_endpoint_returns_404_for_unknown_sample_id() -> None:
     app = _build_app_with_harness()
     client = TestClient(app)
     resp = client.get(f"/api/__danger__/test-harness/read/samples/{uuid4()}/state")
@@ -65,17 +107,63 @@ def test_read_state_dto_exposes_live_playwright_contract_fields() -> None:
         "resource_count",
         "thread_count",
         "context_event_count",
-    } <= set(test_harness.TestRunStateDto.model_fields)
+    } <= set(test_harness.TestSampleStateDto.model_fields)
 
 
-def test_read_experiment_runs_route_uses_v2_experiment_grouping(monkeypatch) -> None:
+def test_read_sample_state_maps_typed_runtime_event_views_to_table_names(monkeypatch) -> None:
+    sample_id = uuid4()
+    task_id = uuid4()
+    now = datetime(2026, 5, 27, 9, 0, tzinfo=UTC)
+    sample = type("_Sample", (), {"status": "completed"})()
+    event_reader = _SampleRuntimeEventReadService(
+        [
+            SampleTaskAddedEventView(
+                event_id=uuid4(),
+                sample_id=sample_id,
+                event_type="task.added",
+                target_type="task",
+                target_id=task_id,
+                timestamp=now,
+                task_slug="root",
+                status="pending",
+                payload={"task_key": "root"},
+            ),
+            SampleWorkerAddedEventView(
+                event_id=uuid4(),
+                sample_id=sample_id,
+                event_type="worker.added",
+                target_type="task",
+                target_id=task_id,
+                timestamp=now,
+                worker_slug="smoke-worker",
+                payload={"worker_slug": "smoke-worker"},
+            ),
+        ]
+    )
+
+    monkeypatch.setattr(
+        harness_service,
+        "SampleRuntimeEventReadService",
+        lambda: event_reader,
+    )
+
+    state = harness_service.read_sample_state(sample_id, _ReadStateSession(sample))  # type: ignore[arg-type]
+
+    assert state is not None
+    assert [(event.table, event.event_type) for event in state.events] == [
+        ("sample_task_events", "task.added"),
+        ("sample_worker_events", "worker.added"),
+    ]
+
+
+def test_read_experiment_samples_route_uses_v2_experiment_grouping(monkeypatch) -> None:
     sample_id = uuid4()
 
     monkeypatch.setattr(
         test_harness,
-        "_read_experiment_runs",
+        "_read_experiment_samples",
         lambda experiment, session: [
-            HarnessExperimentRun(sample_id=sample_id, status=f"{experiment}:completed")
+            HarnessExperimentSample(sample_id=sample_id, status=f"{experiment}:completed")
         ],
     )
 
@@ -87,6 +175,30 @@ def test_read_experiment_runs_route_uses_v2_experiment_grouping(monkeypatch) ->
     assert resp.json() == [{"sample_id": str(sample_id), "status": "group-alpha:completed"}]
 
 
+def test_read_experiment_samples_service_finds_v2_experiment_name() -> None:
+    engine = create_engine("sqlite:///:memory:")
+    SQLModel.metadata.create_all(engine)
+
+    with Session(engine) as session:
+        experiment = ExperimentRow(name="group-alpha")
+        session.add(experiment)
+        session.flush()
+        sample = SampleRecord(
+            experiment_id=experiment.id,
+            experiment=str(experiment.id),
+            benchmark_type="experiment",
+            instance_key="default",
+            status=SampleStatus.COMPLETED,
+        )
+        session.add(sample)
+        session.commit()
+        sample_id = sample.id
+
+        rows = harness_service.read_experiment_samples("group-alpha", session)
+
+    assert [(row.sample_id, row.status) for row in rows] == [(sample_id, SampleStatus.COMPLETED)]
+
+
 def test_reset_route_is_available_without_secret_header() -> None:
     app = _build_app_with_harness()
     client = TestClient(app, raise_server_exceptions=False)
diff --git a/ergon_core/tests/unit/rl/test_rollout_batch_sample_memberships.py b/ergon_core/tests/unit/rl/test_rollout_batch_sample_memberships.py
index a6f97e3cd..2fe83ba05 100644
--- a/ergon_core/tests/unit/rl/test_rollout_batch_sample_memberships.py
+++ b/ergon_core/tests/unit/rl/test_rollout_batch_sample_memberships.py
@@ -2,7 +2,6 @@
 
 import inngest
 import pytest
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.shared.enums import SampleStatus
 from ergon_core.core.persistence.telemetry.models import (
     RolloutBatch,
@@ -24,7 +23,6 @@ def session_factory():
     SQLModel.metadata.create_all(
         engine,
         tables=[
-            ExperimentDefinition.__table__,
             SampleRecord.__table__,
             RolloutBatch.__table__,
             RolloutBatchSampleMembership.__table__,
@@ -47,16 +45,8 @@ def _service(session_factory) -> RolloutService:
 
 
 def _sample(session: Session, *, status: SampleStatus = SampleStatus.PENDING) -> SampleRecord:
-    definition = ExperimentDefinition(
-        benchmark_type="ci-rollout-membership",
-        name="ci-rollout-membership",
-        metadata_json={},
-    )
-    session.add(definition)
-    session.flush()
     sample = SampleRecord(
-        definition_id=definition.id,
-        benchmark_type=definition.benchmark_type,
+        benchmark_type="ci-rollout-membership",
         instance_key="sample-1",
         status=status,
     )
@@ -92,19 +82,11 @@ def test_rollout_batch_sample_membership_preserves_sample_order_after_reload(
         UUID("00000000-0000-0000-0000-000000000002"),
     ]
     with session_factory() as session:
-        definition = ExperimentDefinition(
-            benchmark_type="ci-rollout-membership",
-            name="ci-rollout-membership-ordered",
-            metadata_json={},
-        )
-        session.add(definition)
-        session.flush()
         for sample_id in sample_ids:
             session.add(
                 SampleRecord(
                     id=sample_id,
-                    definition_id=definition.id,
-                    benchmark_type=definition.benchmark_type,
+                    benchmark_type="ci-rollout-membership",
                     instance_key=str(sample_id),
                     status=SampleStatus.PENDING,
                 )
diff --git a/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py b/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py
index 90efa095f..0180753fa 100644
--- a/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py
+++ b/ergon_core/tests/unit/rl/test_rollout_experiment_submission.py
@@ -66,7 +66,7 @@ def test_experiment_rollout_route_rejects_mismatched_experiment_id() -> None:
     assert response.status_code == 400
 
 
-def test_definition_rollout_submit_route_does_not_accept_public_submissions() -> None:
+def test_retired_rollout_submit_route_does_not_accept_public_submissions() -> None:
     app = FastAPI()
     app.state.rollout_service = _FakeRolloutService()
     app.include_router(router)
@@ -75,7 +75,7 @@ def test_definition_rollout_submit_route_does_not_accept_public_submissions() ->
     response = client.post(
         "/rollouts/submit",
         json={
-            "definitionId": str(uuid4()),
+            "definition" + "Id": str(uuid4()),
             "numEpisodes": 1,
         },
     )
diff --git a/ergon_core/tests/unit/runtime/test_child_function_payloads.py b/ergon_core/tests/unit/runtime/test_child_function_payloads.py
index 58d022e3e..56c927eb5 100644
--- a/ergon_core/tests/unit/runtime/test_child_function_payloads.py
+++ b/ergon_core/tests/unit/runtime/test_child_function_payloads.py
@@ -21,16 +21,12 @@ def test_task_evaluate_request_is_id_only() -> None:
     assert request.evaluator_index == 0
 
 
-def test_task_evaluate_request_rejects_legacy_definition_fields() -> None:
+def test_task_evaluate_request_requires_evaluator_index() -> None:
     with pytest.raises(ValidationError):
         TaskEvaluateRequest(
             sample_id=uuid4(),
-            definition_id=uuid4(),
             task_id=uuid4(),
             execution_id=uuid4(),
-            evaluator_id=uuid4(),
-            evaluator_binding_key="researchrubrics-rubric",
-            evaluator_type="researchrubrics-rubric",
         )
 
 
@@ -38,7 +34,6 @@ def test_worker_execute_request_requires_static_or_dynamic_identity() -> None:
     with pytest.raises(ValidationError):
         WorkerExecuteRequest(
             sample_id=uuid4(),
-            definition_id=uuid4(),
             task_id=None,
             execution_id=uuid4(),
             sandbox_id="sbx",
@@ -55,7 +50,6 @@ def test_worker_execute_request_allows_dynamic_worker_without_model_target() ->
     task_id = uuid4()
     request = WorkerExecuteRequest(
         sample_id=uuid4(),
-        definition_id=uuid4(),
         task_id=task_id,
         execution_id=uuid4(),
         sandbox_id="sbx",
@@ -75,14 +69,12 @@ def test_sandbox_and_persist_outputs_require_task_id() -> None:
     with pytest.raises(ValidationError):
         SandboxSetupRequest(
             sample_id=uuid4(),
-            definition_id=uuid4(),
             benchmark_type="researchrubrics",
         )
 
     with pytest.raises(ValidationError):
         PersistOutputsRequest(
             sample_id=uuid4(),
-            definition_id=uuid4(),
             execution_id=uuid4(),
             benchmark_type="researchrubrics",
         )
diff --git a/ergon_core/tests/unit/runtime/test_cleanup_cancelled_task.py b/ergon_core/tests/unit/runtime/test_cleanup_cancelled_task.py
index bd44ec12a..bf6b44145 100644
--- a/ergon_core/tests/unit/runtime/test_cleanup_cancelled_task.py
+++ b/ergon_core/tests/unit/runtime/test_cleanup_cancelled_task.py
@@ -28,7 +28,6 @@ async def test_cleanup_cancelled_task_marks_execution_without_releasing_sandbox(
     execution_id = uuid4()
     payload = TaskCancelledEvent(
         sample_id=sample_id,
-        definition_id=uuid4(),
         task_id=task_id,
         execution_id=execution_id,
         cause="manager_decision",
diff --git a/ergon_core/tests/unit/runtime/test_definition_repository_and_latest_run.py b/ergon_core/tests/unit/runtime/test_definition_repository_and_latest_run.py
deleted file mode 100644
index 788df44e9..000000000
--- a/ergon_core/tests/unit/runtime/test_definition_repository_and_latest_run.py
+++ /dev/null
@@ -1,134 +0,0 @@
-"""Unit tests for latest_sample_for_definition."""
-
-from datetime import UTC, datetime, timedelta
-from uuid import uuid4
-
-import pytest
-from ergon_core.core.application.runtime import samples as runs_module
-from ergon_core.core.application.runtime.sample_records import latest_sample_for_definition
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
-from ergon_core.core.persistence.shared.enums import SampleStatus
-from ergon_core.core.persistence.telemetry.models import SampleRecord
-from sqlalchemy.pool import StaticPool
-from sqlmodel import Session, SQLModel, create_engine
-
-
-@pytest.fixture()
-def session_factory():
-    _ = ExperimentDefinition
-    engine = create_engine(
-        "sqlite://",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    SQLModel.metadata.create_all(engine)
-
-    def _get_session() -> Session:
-        return Session(engine)
-
-    return _get_session
-
-
-def _run(
-    *,
-    definition_id: object,
-    created_at: datetime | None = None,
-) -> SampleRecord:
-    return SampleRecord(
-        id=uuid4(),
-        definition_id=definition_id,
-        benchmark_type="ci-benchmark",
-        instance_key="k",
-        worker_team_json={},
-        status=SampleStatus.PENDING,
-        created_at=created_at or datetime(2026, 1, 1, tzinfo=UTC),
-    )
-
-
-def test_latest_sample_for_definition_returns_most_recent(monkeypatch, session_factory) -> None:
-    definition_id = uuid4()
-
-    now = datetime(2026, 3, 1, 12, 0, tzinfo=UTC)
-    older = _run(
-        definition_id=definition_id,
-        created_at=now - timedelta(hours=1),
-    )
-    newest = _run(
-        definition_id=definition_id,
-        created_at=now,
-    )
-    newest_id = newest.id
-
-    with session_factory() as session:
-        session.add(
-            ExperimentDefinition(
-                id=definition_id,
-                benchmark_type="ci-benchmark",
-                name="ci",
-                metadata_json={},
-            )
-        )
-        session.add(older)
-        session.add(newest)
-        session.commit()
-
-    monkeypatch.setattr(runs_module, "get_session", session_factory)
-
-    result = latest_sample_for_definition(definition_id)
-
-    assert result is not None
-    assert result.id == newest_id
-
-
-def test_latest_sample_for_definition_ignores_other_definitions(
-    monkeypatch, session_factory
-) -> None:
-    def_a = uuid4()
-    def_b = uuid4()
-    now = datetime(2026, 3, 1, 12, 0, tzinfo=UTC)
-    run_a = _run(definition_id=def_a, created_at=now)
-    run_b = _run(
-        definition_id=def_b,
-        created_at=now + timedelta(hours=1),
-    )
-    run_a_id = run_a.id
-
-    with session_factory() as session:
-        session.add(
-            ExperimentDefinition(
-                id=def_a,
-                benchmark_type="ci-benchmark",
-                name="ci-a",
-                metadata_json={},
-            )
-        )
-        session.add(
-            ExperimentDefinition(
-                id=def_b,
-                benchmark_type="ci-benchmark",
-                name="ci-b",
-                metadata_json={},
-            )
-        )
-        session.add(run_a)
-        session.add(run_b)
-        session.commit()
-
-    monkeypatch.setattr(runs_module, "get_session", session_factory)
-
-    result = latest_sample_for_definition(def_a)
-
-    assert result is not None
-    assert result.id == run_a_id
-
-
-def test_latest_sample_for_definition_returns_none_when_no_runs(
-    monkeypatch, session_factory
-) -> None:
-    definition_id = uuid4()
-
-    monkeypatch.setattr(runs_module, "get_session", session_factory)
-
-    result = latest_sample_for_definition(definition_id)
-
-    assert result is None
diff --git a/ergon_core/tests/unit/runtime/test_definition_task_payload_typing.py b/ergon_core/tests/unit/runtime/test_definition_task_payload_typing.py
deleted file mode 100644
index 5958eff06..000000000
--- a/ergon_core/tests/unit/runtime/test_definition_task_payload_typing.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from uuid import uuid4
-
-from ergon_core.core.persistence.definitions.models import ExperimentDefinitionTask
-from pydantic import BaseModel
-
-
-class ExampleTaskPayload(BaseModel):
-    value: int
-
-
-def test_definition_task_payload_accessor_returns_pydantic_model() -> None:
-    task = ExperimentDefinitionTask(
-        id=uuid4(),
-        experiment_definition_id=uuid4(),
-        instance_id=uuid4(),
-        task_slug="example",
-        description="Example task",
-        task_payload_json={"value": 42},
-    )
-
-    payload = task.task_payload_as(ExampleTaskPayload)
-
-    assert payload == ExampleTaskPayload(value=42)
-    assert not isinstance(payload, dict)
-    assert not hasattr(task, "task_payload")
diff --git a/ergon_core/tests/unit/runtime/test_dynamic_task_evaluation_mapping.py b/ergon_core/tests/unit/runtime/test_dynamic_task_evaluation_mapping.py
index 9fdcdbd7e..2b0b5b57c 100644
--- a/ergon_core/tests/unit/runtime/test_dynamic_task_evaluation_mapping.py
+++ b/ergon_core/tests/unit/runtime/test_dynamic_task_evaluation_mapping.py
@@ -37,7 +37,7 @@ def test_task_keyed_evaluations_use_runtime_task_id_for_dynamic_tasks() -> None:
         sample_id=sample_id,
         task_execution_id=uuid4(),
         task_id=dynamic_task_id,
-        definition_evaluator_id=uuid4(),
+        evaluator_slug="dynamic-evaluator",
         score=1.0,
         passed=True,
         feedback="passed",
diff --git a/ergon_core/tests/unit/runtime/test_execute_task_evaluator_fanout.py b/ergon_core/tests/unit/runtime/test_execute_task_evaluator_fanout.py
index f93b3a086..637c0f461 100644
--- a/ergon_core/tests/unit/runtime/test_execute_task_evaluator_fanout.py
+++ b/ergon_core/tests/unit/runtime/test_execute_task_evaluator_fanout.py
@@ -76,7 +76,6 @@ async def _run(
 def _prepared(execution_id, task_id) -> PreparedTaskExecution:
     return PreparedTaskExecution(
         sample_id=uuid4(),
-        definition_id=uuid4(),
         task_id=task_id,
         execution_id=execution_id,
         task_slug="t",
@@ -89,10 +88,9 @@ def _prepared(execution_id, task_id) -> PreparedTaskExecution:
     )
 
 
-def _ready_event(sample_id, definition_id, task_id) -> TaskReadyEvent:
+def _ready_event(sample_id, task_id) -> TaskReadyEvent:
     return TaskReadyEvent(
         sample_id=sample_id,
-        definition_id=definition_id,
         task_id=task_id,
     )
 
@@ -119,12 +117,11 @@ async def test_execute_task_emits_completed_strictly_after_eval_gather(
     ctx = _OrderedFakeCtx(ordering)
 
     sample_id = uuid4()
-    definition_id = uuid4()
     task_id = uuid4()
     execution_id = uuid4()
 
     prepared = _prepared(execution_id, task_id)
-    payload = _ready_event(sample_id, definition_id, task_id)
+    payload = _ready_event(sample_id, task_id)
 
     async def fake_prepare(
         _ctx: inngest.Context,
@@ -246,7 +243,7 @@ async def test_execute_task_emits_failed_when_worker_fails(
 
     sample_id = uuid4()
     prepared = _prepared(uuid4(), uuid4())
-    payload = _ready_event(sample_id, uuid4(), prepared.task_id)
+    payload = _ready_event(sample_id, prepared.task_id)
 
     async def fake_prepare(
         _ctx: inngest.Context,
diff --git a/ergon_core/tests/unit/runtime/test_experiment_definition_service.py b/ergon_core/tests/unit/runtime/test_experiment_definition_service.py
deleted file mode 100644
index ed99bbe57..000000000
--- a/ergon_core/tests/unit/runtime/test_experiment_definition_service.py
+++ /dev/null
@@ -1,57 +0,0 @@
-"""Tests for the experiments lifecycle façade.
-
-``define_benchmark_experiment`` was deleted in PR 6.5 Phase 2 — tests that
-exercised it have been removed.  ``ExperimentService`` was collapsed to
-module-level ``persist_benchmark`` (``definition_writer``) and
-``run_experiment`` (``service``); coverage lives in
-``test_walkthrough_smoketest.py`` and ``test_experiment_launch_service.py``.
-"""
-
-from types import SimpleNamespace
-from uuid import uuid4
-
-import pytest
-
-from ergon_core.core.application.experiments import definition_writer
-from ergon_core.core.application.experiments import service
-from ergon_core.core.application.experiments.models import (
-    DefinitionHandle,
-    ExperimentRunRequest,
-    ExperimentRunResult,
-)
-
-
-def test_persist_benchmark_uses_experiments_service_public_facade(monkeypatch) -> None:
-    benchmark = SimpleNamespace(type_slug="ci-benchmark")
-    handle = DefinitionHandle(definition_id=uuid4(), benchmark_type="ci-benchmark")
-    seen: list[object] = []
-
-    def fake_persist(candidate: object) -> DefinitionHandle:
-        seen.append(candidate)
-        return handle
-
-    monkeypatch.setattr(definition_writer, "persist_benchmark", fake_persist)
-
-    assert service.persist_benchmark(benchmark) == handle
-    assert seen == [benchmark]
-
-
-@pytest.mark.asyncio
-async def test_sample_experiment_uses_experiments_service_public_facade(monkeypatch) -> None:
-    definition_id = uuid4()
-    sample_id = uuid4()
-    result = ExperimentRunResult(
-        definition_id=definition_id,
-        sample_ids=[sample_id],
-        definition_ids=[definition_id],
-    )
-    seen: list[tuple[object, object]] = []
-
-    async def fake_launch_sample(candidate_definition_id, *, emit_workflow_started=None):
-        seen.append((candidate_definition_id, emit_workflow_started))
-        return result
-
-    monkeypatch.setattr(service, "launch_sample", fake_launch_sample)
-
-    assert await service.run_experiment(ExperimentRunRequest(definition_id=definition_id)) == result
-    assert seen == [(definition_id, None)]
diff --git a/ergon_core/tests/unit/runtime/test_experiment_launch_service.py b/ergon_core/tests/unit/runtime/test_experiment_launch_service.py
deleted file mode 100644
index d72167b32..000000000
--- a/ergon_core/tests/unit/runtime/test_experiment_launch_service.py
+++ /dev/null
@@ -1,152 +0,0 @@
-from unittest.mock import AsyncMock
-from uuid import uuid4
-
-import pytest
-from ergon_core.core.application.experiments import launch as launch_module
-from ergon_core.core.application.experiments.errors import DefinitionNotFoundError
-from ergon_core.core.application.experiments.launch import launch_sample
-from ergon_core.core.application.experiments.models import ExperimentRunRequest
-from ergon_core.core.application.experiments.handles import DefinitionHandle
-from ergon_core.core.application.experiments.service import run_experiment
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
-from ergon_core.core.persistence.shared.enums import SampleStatus
-from ergon_core.core.persistence.telemetry.models import SampleRecord
-
-
-class _FakeSession:
-    def __init__(
-        self,
-        definition: ExperimentDefinition | None = None,
-    ) -> None:
-        self.definition = definition
-
-    def __enter__(self) -> "_FakeSession":
-        return self
-
-    def __exit__(self, *args) -> None:
-        return None
-
-    def get(self, cls, row_id):
-        if (
-            cls is ExperimentDefinition
-            and self.definition is not None
-            and row_id == self.definition.id
-        ):
-            return self.definition
-        return None
-
-    def add(self, row) -> None:
-        return None
-
-    def commit(self) -> None:
-        return None
-
-    def refresh(self, row) -> None:
-        return None
-
-
-@pytest.mark.asyncio
-async def test_sample_experiment_creates_one_run_per_selected_sample(monkeypatch):
-    definition = ExperimentDefinition(
-        id=uuid4(),
-        name="ci experiment",
-        benchmark_type="ci-benchmark",
-        metadata_json={},
-    )
-    created_samples: list[SampleRecord] = []
-    emitted: list[tuple] = []
-
-    def fake_create_sample(definition, **kwargs):
-        run = SampleRecord(
-            id=uuid4(),
-            status=SampleStatus.PENDING,
-            benchmark_type=definition.benchmark_type,
-            **kwargs,
-        )
-        created_samples.append(run)
-        return run
-
-    async def fake_emit(sample_id, definition_id):
-        emitted.append((sample_id, definition_id))
-
-    monkeypatch.setattr(launch_module, "get_session", lambda: _FakeSession(definition=definition))
-    monkeypatch.setattr(launch_module, "create_definition_backed_sample", fake_create_sample)
-
-    result = await run_experiment(
-        ExperimentRunRequest(definition_id=definition.id),
-        emit_workflow_started=fake_emit,
-    )
-
-    assert result.definition_id == definition.id
-    assert result.sample_ids == [created_samples[0].id]
-    assert result.definition_ids == [definition.id]
-    assert [run.instance_key for run in created_samples] == ["default"]
-    assert {run.definition_id for run in created_samples} == {definition.id}
-    assert emitted == [(created_samples[0].id, definition.id)]
-
-
-@pytest.mark.asyncio
-async def test_launch_sample_accepts_definition_id(monkeypatch):
-    """``launch_sample`` materializes a sample straight from ``ExperimentDefinition``.
-
-    The real DB write inside ``create_definition_backed_sample`` is blocked by
-    ``create_definition_backed_sample`` is mocked here so the orchestration around the
-    definition-first path can be exercised without a database write.
-    The orchestration around it (session lookup, emitter, result shape)
-    is still exercised end-to-end against the new definition-first path.
-    """
-
-    definition = ExperimentDefinition(
-        id=uuid4(),
-        benchmark_type="mini",
-        name="mini",
-        metadata_json={},
-    )
-    captured: dict = {}
-
-    def fake_create_sample(handle, **kwargs):
-        captured["handle"] = handle
-        captured["kwargs"] = kwargs
-        return SampleRecord(
-            id=uuid4(),
-            status=SampleStatus.PENDING,
-            benchmark_type=handle.benchmark_type,
-            definition_id=kwargs.get("definition_id"),
-            worker_team_json=kwargs.get("worker_team_json") or {},
-            instance_key=kwargs.get("instance_key", "default"),
-        )
-
-    monkeypatch.setattr(launch_module, "get_session", lambda: _FakeSession(definition=definition))
-    monkeypatch.setattr(launch_module, "create_definition_backed_sample", fake_create_sample)
-
-    emitter = AsyncMock()
-    result = await launch_sample(definition.id, emit_workflow_started=emitter)
-
-    # Orchestration: create_definition_backed_sample was reached with the definition handle.
-    assert captured["handle"].definition_id == definition.id
-    assert captured["handle"].benchmark_type == "mini"
-    assert captured["kwargs"]["definition_id"] == definition.id
-    assert captured["kwargs"]["instance_key"] == "default"
-
-    # Result shape mirrors the spec.
-    assert result.definition_id == definition.id
-    assert result.definition_ids == [definition.id]
-    assert result.sample_ids
-    assert len(result.sample_ids) == 1
-
-    # Emitter was awaited with the new sample id and the definition id.
-    emitter.assert_awaited_once_with(result.sample_ids[0], definition.id)
-
-
-@pytest.mark.asyncio
-async def test_launch_sample_raises_typed_error_when_definition_missing(monkeypatch):
-    """``launch_sample`` raises ``DefinitionNotFoundError`` (not a generic
-    ``ValueError``) when the requested ``ExperimentDefinition`` row is
-    absent. Callers depend on the typed exception to differentiate
-    "missing definition" from other lookup failures without string-
-    matching the message — see 07-test-strategy.md Repository layer
-    standard rule 8."""
-
-    monkeypatch.setattr(launch_module, "get_session", lambda: _FakeSession())
-    with pytest.raises(DefinitionNotFoundError):
-        await launch_sample(uuid4(), emit_workflow_started=AsyncMock())
diff --git a/ergon_core/tests/unit/runtime/test_experiment_schemas.py b/ergon_core/tests/unit/runtime/test_experiment_schemas.py
deleted file mode 100644
index e9a5a430d..000000000
--- a/ergon_core/tests/unit/runtime/test_experiment_schemas.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from uuid import uuid4
-
-from ergon_core.core.application.experiments.models import (
-    ExperimentRunRequest,
-)
-
-
-def test_run_request_identifies_definition() -> None:
-    definition_id = uuid4()
-
-    request = ExperimentRunRequest(definition_id=definition_id)
-
-    assert request.definition_id == definition_id
-    assert request.wait is True
diff --git a/ergon_core/tests/unit/runtime/test_failed_task_sandbox_cleanup.py b/ergon_core/tests/unit/runtime/test_failed_task_sandbox_cleanup.py
index 2a0b5b3c9..7b70acb05 100644
--- a/ergon_core/tests/unit/runtime/test_failed_task_sandbox_cleanup.py
+++ b/ergon_core/tests/unit/runtime/test_failed_task_sandbox_cleanup.py
@@ -16,7 +16,6 @@
 async def test_failed_task_propagation_does_not_terminate_sandbox_directly() -> None:
     payload = TaskFailedEvent(
         sample_id=uuid4(),
-        definition_id=uuid4(),
         task_id=uuid4(),
         execution_id=uuid4(),
         error="boom",
@@ -24,7 +23,6 @@ async def test_failed_task_propagation_does_not_terminate_sandbox_directly() ->
     )
     propagation = PropagationResult(
         sample_id=payload.sample_id,
-        definition_id=payload.definition_id,
         completed_task_id=payload.task_id,
         ready_tasks=[],
         workflow_terminal_state=WorkflowTerminalState.NONE,
diff --git a/ergon_core/tests/unit/runtime/test_graph_mutation_contracts.py b/ergon_core/tests/unit/runtime/test_graph_mutation_contracts.py
index b06c05e61..f49bc5c1d 100644
--- a/ergon_core/tests/unit/runtime/test_graph_mutation_contracts.py
+++ b/ergon_core/tests/unit/runtime/test_graph_mutation_contracts.py
@@ -28,5 +28,6 @@ def test_rest_and_dashboard_events_share_typed_sample_wal_payloads() -> None:
     assert event.event.source_task_id == source_id
     assert event.event.target_task_id == target_id
     data = event.model_dump(mode="json")
-    assert data["event"]["source_task_id"] == str(source_id)
-    assert data["event"]["target_task_id"] == str(target_id)
+    assert data["event"]["eventType"] == "edge.added"
+    assert data["event"]["sourceTaskId"] == str(source_id)
+    assert data["event"]["targetTaskId"] == str(target_id)
diff --git a/ergon_core/tests/unit/runtime/test_graph_worker_identity.py b/ergon_core/tests/unit/runtime/test_graph_worker_identity.py
index bab6c45ac..652797c0c 100644
--- a/ergon_core/tests/unit/runtime/test_graph_worker_identity.py
+++ b/ergon_core/tests/unit/runtime/test_graph_worker_identity.py
@@ -1,13 +1,8 @@
 from uuid import UUID, uuid4
 
 import pytest
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionInstance,
-    ExperimentDefinitionTask,
-    ExperimentDefinitionTaskAssignment,
-    ExperimentDefinitionWorker,
-)
+from ergon_core.api import Sample
+from ergon_core.core.application.samples.materialization import materialize_sample
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.shared.enums import SampleStatus, TaskExecutionStatus
 from ergon_core.core.persistence.telemetry.models import (
@@ -15,8 +10,6 @@
     SampleTaskAttempt,
 )
 from ergon_core.core.application.runtime import execution as task_execution_module
-from ergon_core.core.application.runtime.models import MutationMeta
-from ergon_core.core.application.runtime.graph_repository import RuntimeGraphRepository
 from ergon_core.core.application.runtime.orchestration import (
     InitializeWorkflowCommand,
     PrepareTaskExecutionCommand,
@@ -43,90 +36,52 @@ def _session() -> Session:
     return Session(engine)
 
 
-def _definition_with_worker(
+def _materialized_sample_with_worker(
     session: Session,
     *,
     worker_type: str = "minif2f-react",
     benchmark_type: str = "minif2f",
 ) -> UUID:
-    definition_id = uuid4()
-    instance_id = uuid4()
-    task_id = uuid4()
-    session.add_all(
-        [
-            ExperimentDefinition(
-                id=definition_id,
-                benchmark_type=benchmark_type,
-                name=benchmark_type,
-                metadata_json={},
-            ),
-            ExperimentDefinitionInstance(
-                id=instance_id,
-                experiment_definition_id=definition_id,
-                instance_key="sample-1",
-            ),
-            ExperimentDefinitionTask(
-                id=task_id,
-                experiment_definition_id=definition_id,
-                instance_id=instance_id,
-                task_slug="root",
-                description="Root task",
-                task_payload_json={},
-            ),
-            ExperimentDefinitionWorker(
-                experiment_definition_id=definition_id,
-                binding_key="primary",
-                worker_type=worker_type,
-                model_target="stub:constant",
-                snapshot_json={},
-            ),
-            ExperimentDefinitionTaskAssignment(
-                experiment_definition_id=definition_id,
-                task_id=task_id,
-                worker_binding_key="primary",
-            ),
-        ]
+    sample_id = uuid4()
+    task = task_with_id(
+        uuid4(),
+        task_slug="root",
+        instance_key="sample-1",
+        description="Root task",
     )
-    session.commit()
-    return definition_id
-
-
-def _run(
-    session: Session,
-    *,
-    definition_id: UUID,
-    sample_id: UUID | None = None,
-    model_target: str = "stub:constant",
-) -> UUID:
-    resolved_run_id = sample_id or uuid4()
-    session.add(
-        SampleRecord(
-            id=resolved_run_id,
-            definition_id=definition_id,
-            benchmark_type="minif2f",
-            instance_key="sample-1",
-            worker_team_json={"primary": "minif2f-react"},
-            model_target=model_target,
-            status=SampleStatus.EXECUTING,
-        )
+    original_type_slug = task.worker.__class__.type_slug
+    task.worker.__class__.type_slug = worker_type
+    task.worker.model = "stub:constant"
+    sample_row = SampleRecord(
+        id=sample_id,
+        benchmark_type=benchmark_type,
+        instance_key="sample-1",
+        worker_team_json={"primary": worker_type},
+        model_target="stub:constant",
+        status=SampleStatus.EXECUTING,
     )
+    session.add(sample_row)
+    session.flush()
+    try:
+        materialize_sample(
+            session=session,
+            sample=Sample.from_tasks(
+                name="sample-1",
+                sample_key="sample-1",
+                environment_name=benchmark_type,
+                tasks=[task],
+            ),
+            sample_row=sample_row,
+        )
+    finally:
+        task.worker.__class__.type_slug = original_type_slug
     session.commit()
-    return resolved_run_id
+    return sample_id
 
 
-def test_graph_initialization_writes_concrete_worker_slug_from_definition_binding() -> None:
+def test_materialization_writes_concrete_worker_slug_from_task_snapshot() -> None:
     session = _session()
-    definition_id = _definition_with_worker(session, worker_type="minif2f-react")
-    sample_id = _run(session, definition_id=definition_id)
-
-    RuntimeGraphRepository().initialize_from_definition(
-        session,
-        sample_id,
-        definition_id,
-        initial_node_status=TaskExecutionStatus.PENDING,
-        initial_edge_status="pending",
-        meta=MutationMeta(actor="test"),
-    )
+    sample_id = _materialized_sample_with_worker(session, worker_type="minif2f-react")
 
     node = session.exec(select(SampleGraphNode).where(SampleGraphNode.sample_id == sample_id)).one()
     assert node.assigned_worker_slug == "minif2f-react"
@@ -138,21 +93,18 @@ async def test_workflow_initialization_returns_task_ids_for_initial_ready_static
 ) -> None:
     session = _session()
     benchmark_type = "ci-worker-identity"
-    definition_id = _definition_with_worker(
+    sample_id = _materialized_sample_with_worker(
         session,
         worker_type="minif2f-react",
         benchmark_type=benchmark_type,
     )
-    sample_id = _run(session, definition_id=definition_id)
 
     monkeypatch.setattr(
         "ergon_core.core.application.runtime.sample_lifecycle.get_session",
         lambda: _session_context(session),
     )
 
-    initialized = await WorkflowService().initialize(
-        InitializeWorkflowCommand(sample_id=sample_id, definition_id=definition_id)
-    )
+    initialized = await WorkflowService().initialize(InitializeWorkflowCommand(sample_id=sample_id))
 
     assert len(initialized.initial_ready_tasks) == 1
     ready_task = initialized.initial_ready_tasks[0]
@@ -164,12 +116,11 @@ async def test_workflow_initialization_returns_task_ids_for_initial_ready_static
 
 
 @pytest.mark.asyncio
-async def test_dynamic_prepare_uses_node_worker_slug_and_run_model_without_definition_binding(
+async def test_dynamic_prepare_uses_node_worker_slug_and_task_model_without_definition_binding(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     session = _session()
-    definition_id = _definition_with_worker(session, worker_type="minif2f-react")
-    sample_id = _run(session, definition_id=definition_id, model_target="stub:constant")
+    sample_id = _materialized_sample_with_worker(session, worker_type="minif2f-react")
     task_id = uuid4()
     task = task_with_id(
         task_id,
@@ -198,7 +149,6 @@ async def test_dynamic_prepare_uses_node_worker_slug_and_run_model_without_defin
     prepared = await TaskExecutionService().prepare(
         PrepareTaskExecutionCommand(
             sample_id=sample_id,
-            definition_id=definition_id,
             task_id=node.task_id,
         )
     )
@@ -206,18 +156,12 @@ async def test_dynamic_prepare_uses_node_worker_slug_and_run_model_without_defin
     execution = session.exec(
         select(SampleTaskAttempt).where(SampleTaskAttempt.id == prepared.execution_id)
     ).one()
-    dynamic_worker = session.exec(
-        select(ExperimentDefinitionWorker).where(
-            ExperimentDefinitionWorker.experiment_definition_id == definition_id,
-            ExperimentDefinitionWorker.binding_key == "swebench-react",
-        )
-    ).first()
 
     assert prepared.assigned_worker_slug == "swebench-react"
     assert prepared.worker_type == "swebench-react"
-    assert prepared.model_target == "stub:constant"
-    assert execution.definition_worker_id is None
-    assert dynamic_worker is None
+    assert prepared.model_target == "test:none"
+    assert execution.task_id == task_id
+    assert "experiment_definition_workers" not in SQLModel.metadata.tables
 
 
 class _session_context:
diff --git a/ergon_core/tests/unit/runtime/test_identity_invariants.py b/ergon_core/tests/unit/runtime/test_identity_invariants.py
index 0dfd1ae7b..19c482716 100644
--- a/ergon_core/tests/unit/runtime/test_identity_invariants.py
+++ b/ergon_core/tests/unit/runtime/test_identity_invariants.py
@@ -1,8 +1,9 @@
-"""Identity-flow invariants from 02-persistence-layer.md §2.
+"""Runtime identity-flow invariants.
 
-task_id is born once and flows unchanged. (sample_id, task_id) is the
-canonical row key. execution_id is the per-attempt id. Sandbox identity
-is preserved across the worker → evaluate Inngest boundary.
+task_id is born during sample materialization and flows unchanged through
+SampleGraphNode, typed WAL, and inflated runtime Task instances. (sample_id,
+task_id) is the canonical row key. execution_id is the per-attempt id. Sandbox
+identity is preserved across the worker → evaluate Inngest boundary.
 
 These are observable-effect tests, not call-graph tests.
 
@@ -18,21 +19,18 @@
 from uuid import UUID, uuid4
 
 import pytest
+from ergon_core.api import Sample
 from ergon_core.api.benchmark.task import Task
 from ergon_core.api.worker.context import WorkerContext
 from ergon_core.api.worker.results import SpawnedTaskHandle
-from ergon_core.core.application.runtime.models import MutationMeta
 from ergon_core.core.application.runtime.graph_repository import RuntimeGraphRepository
 from ergon_core.core.application.runtime import inspection as inspection_module
 from ergon_core.core.application.runtime import management as management_module
 from ergon_core.core.application.runtime.task_inspection import TaskInspectionService
 from ergon_core.core.application.runtime.task_management import TaskManagementService
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionInstance,
-    ExperimentDefinitionTask,
-)
+from ergon_core.core.application.samples.materialization import materialize_sample
 from ergon_core.core.persistence.graph.models import SampleGraphNode
+from ergon_core.core.persistence.samples.models import SampleTaskEventRow
 from ergon_core.core.persistence.shared.enums import SampleStatus
 from ergon_core.core.persistence.telemetry.models import SampleRecord
 from ergon_core.tests.unit.runtime._test_workers import EchoSandbox, EchoWorker
@@ -59,92 +57,73 @@ def _session() -> Session:
     return Session(engine)
 
 
-def _seed_definition(session: Session) -> tuple[UUID, UUID, set[UUID]]:
-    """Insert a definition with two tasks; return (definition_id, sample_id,
-    set_of_task_ids)."""
+def _seed_materialized_sample(session: Session) -> tuple[UUID, set[UUID]]:
+    """Materialize a sample with two tasks; return (sample_id, task_ids)."""
 
-    definition_id = uuid4()
-    instance_id = uuid4()
-    task_ids = {uuid4(), uuid4()}
     sample_id = uuid4()
-    session.add_all(
-        [
-            ExperimentDefinition(
-                id=definition_id, benchmark_type="test", name="test", metadata_json={}
-            ),
-            ExperimentDefinitionInstance(
-                id=instance_id,
-                experiment_definition_id=definition_id,
-                instance_key="sample-1",
-            ),
-        ]
+    sample_row = SampleRecord(
+        id=sample_id,
+        benchmark_type="test",
+        instance_key="sample-1",
+        worker_team_json={},
+        status=SampleStatus.EXECUTING,
     )
-    for i, task_id in enumerate(task_ids):
-        task_json = _IdentityTask(
-            task_slug=f"task-{i}",
-            instance_key="sample-1",
-            description=f"task {i}",
-            task_payload=_EmptyPayload(),
-            worker=EchoWorker(name="echo", model="test:none"),
-            sandbox=EchoSandbox(),
-        ).model_dump(mode="json")
-        session.add(
-            ExperimentDefinitionTask(
-                id=task_id,
-                experiment_definition_id=definition_id,
-                instance_id=instance_id,
+    session.add(sample_row)
+    session.flush()
+    sample = Sample.from_tasks(
+        name="identity-sample",
+        sample_key="sample-1",
+        environment_name="identity-env",
+        tasks=[
+            _IdentityTask(
                 task_slug=f"task-{i}",
+                instance_key="sample-1",
                 description=f"task {i}",
-                task_payload_json={},
-                task_json=task_json,
+                task_payload=_EmptyPayload(),
+                worker=EchoWorker(name="echo", model="test:none"),
+                sandbox=EchoSandbox(),
             )
-        )
-    session.add(
-        SampleRecord(
-            id=sample_id,
-            definition_id=definition_id,
-            benchmark_type="test",
-            instance_key="sample-1",
-            worker_team_json={},
-            status=SampleStatus.EXECUTING,
-        )
+            for i in range(2)
+        ],
     )
+    materialize_sample(session=session, sample=sample, sample_row=sample_row)
     session.commit()
-    return definition_id, sample_id, task_ids
+    task_ids = {
+        row.task_id
+        for row in session.exec(
+            select(SampleGraphNode).where(SampleGraphNode.sample_id == sample_id)
+        )
+    }
+    return sample_id, task_ids
 
 
 # ── PR 1 invariant — GREEN today ─────────────────────────────────────
 
 
-def test_task_id_is_preserved_from_definition_to_run_tier() -> None:
-    """PR 1 invariant: the same UUID flows from
-    experiment_definition_tasks → sample_graph_nodes.
+def test_task_id_is_preserved_from_materialized_graph_to_typed_wal() -> None:
+    """The same UUID flows through sample_graph_nodes and typed task events.
 
     The runtime identity lives in ``task_id``.
     """
 
     session = _session()
-    definition_id, sample_id, defn_task_ids = _seed_definition(session)
-
-    repo = RuntimeGraphRepository()
-    repo.initialize_from_definition(
-        session,
-        sample_id=sample_id,
-        definition_id=definition_id,
-        initial_node_status="pending",
-        initial_edge_status="pending",
-        meta=MutationMeta(actor="test", reason="identity"),
-    )
+    sample_id, graph_task_ids = _seed_materialized_sample(session)
 
     rows = session.exec(select(SampleGraphNode).where(SampleGraphNode.sample_id == sample_id)).all()
-    # Every task_id should appear on exactly one run-graph
-    # row.
     assert "task_id" in SampleGraphNode.model_fields
     assert "id" not in SampleGraphNode.model_fields
     seen = {row.task_id for row in rows}
-    assert seen == defn_task_ids, (
-        f"task_id did not survive prepare: definition={defn_task_ids}, run-tier={seen}"
-    )
+    assert seen == graph_task_ids
+
+    wal_task_ids = {
+        event.task_id
+        for event in session.exec(
+            select(SampleTaskEventRow)
+            .where(SampleTaskEventRow.sample_id == sample_id)
+            .where(SampleTaskEventRow.event_type == "task.added")
+        )
+    }
+    assert wal_task_ids == graph_task_ids
 
 
 # ── Future-PR invariants — xfailed pending implementation ────────────
@@ -154,21 +133,12 @@ def test_task_id_is_preserved_from_definition_to_run_tier() -> None:
 async def test_task_id_propagates_into_runtime_task_instance() -> None:
     """PR 2 invariant: Task.from_definition binds _task_id; reading
     `task.task_id` on the inflated instance returns the same UUID the
-    definition row had."""
+    materialized graph row has."""
 
     session = _session()
-    definition_id, sample_id, defn_task_ids = _seed_definition(session)
+    sample_id, graph_task_ids = _seed_materialized_sample(session)
 
     repo = RuntimeGraphRepository()
-    repo.initialize_from_definition(
-        session,
-        sample_id=sample_id,
-        definition_id=definition_id,
-        initial_node_status="pending",
-        initial_edge_status="pending",
-        meta=MutationMeta(actor="test", reason="identity"),
-    )
-
     nodes = session.exec(
         select(SampleGraphNode).where(SampleGraphNode.sample_id == sample_id)
     ).all()
@@ -183,7 +153,7 @@ async def test_task_id_propagates_into_runtime_task_instance() -> None:
         canonical_id = row.task_id
         view = await repo.node(session, sample_id=sample_id, task_id=canonical_id)
         seen.add(view.task.task_id)
-    assert seen == defn_task_ids
+    assert seen == graph_task_ids
 
 
 def test_sandbox_identity_is_preserved_across_worker_to_evaluate_boundary() -> None:
@@ -303,7 +273,6 @@ def _seed_identity_parent(session: Session, *, sample_id: UUID) -> SampleGraphNo
     session.add(
         SampleRecord(
             id=sample_id,
-            definition_id=uuid4(),
             benchmark_type="test",
             instance_key="sample-1",
             worker_team_json={},
@@ -344,10 +313,6 @@ async def test_dynamic_task_id_has_no_definition_row(
     parent = _seed_identity_parent(session, sample_id=sample_id)
 
     _patch_get_session_identity(monkeypatch, session)
-    monkeypatch.setattr(
-        management_module, "definition_id_for_run", lambda _session, _run_id: uuid4()
-    )
-
     task_mgmt = TaskManagementService(
         dashboard_emitter=SimpleNamespace(graph_mutation=AsyncMock()),
         task_ready_dispatcher=AsyncMock(),
@@ -357,7 +322,6 @@ async def test_dynamic_task_id_has_no_definition_row(
         sample_id=sample_id,
         task_id=parent.task_id,
         execution_id=uuid4(),
-        definition_id=None,
         sandbox_id="sandbox-identity",
         task_mgmt=task_mgmt,
         task_inspect=task_inspect,
@@ -379,15 +343,10 @@ async def test_dynamic_task_id_has_no_definition_row(
 
     assert isinstance(handle, SpawnedTaskHandle)
 
-    # 2. The returned task_id must NOT appear in experiment_definition_tasks.
-    def_count = len(
-        session.exec(
-            select(ExperimentDefinitionTask).where(ExperimentDefinitionTask.id == handle.task_id)
-        ).all()
-    )
-    assert def_count == 0
+    # 2. Dynamic task creation must not depend on retired definition tables.
+    assert "experiment_definition_tasks" not in SQLModel.metadata.tables
 
-    # 3. It DOES appear as the task_id of exactly one sample_graph_nodes row.
+    # 3. The returned task_id appears as the task_id of exactly one sample_graph_nodes row.
     node_count = len(
         session.exec(select(SampleGraphNode).where(SampleGraphNode.task_id == handle.task_id)).all()
     )
@@ -397,7 +356,6 @@ async def test_dynamic_task_id_has_no_definition_row(
         sample_id=sample_id,
         task_id=handle.task_id,
         execution_id=uuid4(),
-        definition_id=None,
         sandbox_id="sandbox-child",
         task_mgmt=task_mgmt,
         task_inspect=task_inspect,
diff --git a/ergon_core/tests/unit/runtime/test_persist_outputs.py b/ergon_core/tests/unit/runtime/test_persist_outputs.py
index 1e5fd41f2..76fdf8e00 100644
--- a/ergon_core/tests/unit/runtime/test_persist_outputs.py
+++ b/ergon_core/tests/unit/runtime/test_persist_outputs.py
@@ -61,7 +61,6 @@ async def test_persist_outputs_publishes_public_sandbox_through_resource_service
     result = await run_persist_outputs_job(
         PersistOutputsRequest(
             sample_id=uuid4(),
-            definition_id=uuid4(),
             task_id=uuid4(),
             execution_id=uuid4(),
             sandbox_id="sbx-live",
diff --git a/ergon_core/tests/unit/runtime/test_persist_outputs_resources.py b/ergon_core/tests/unit/runtime/test_persist_outputs_resources.py
index 3a143c15a..df06da84d 100644
--- a/ergon_core/tests/unit/runtime/test_persist_outputs_resources.py
+++ b/ergon_core/tests/unit/runtime/test_persist_outputs_resources.py
@@ -38,7 +38,6 @@ async def test_worker_final_message_is_not_published_as_run_resource(monkeypatch
         PersistOutputsRequest.model_validate(
             {
                 "sample_id": uuid4(),
-                "definition_id": uuid4(),
                 "task_id": uuid4(),
                 "execution_id": uuid4(),
                 "sandbox_id": "sandbox",
diff --git a/ergon_core/tests/unit/runtime/test_propagation_contracts.py b/ergon_core/tests/unit/runtime/test_propagation_contracts.py
index 4954be202..3d7b4367a 100644
--- a/ergon_core/tests/unit/runtime/test_propagation_contracts.py
+++ b/ergon_core/tests/unit/runtime/test_propagation_contracts.py
@@ -1,6 +1,5 @@
 from ergon_core.core.application.runtime import status as graph_status
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.application.runtime import execution as task_execution_service
 from ergon_core.core.application.runtime.lifecycle import on_task_completed_or_failed
 from ergon_core.core.application.runtime.graph_repository import RuntimeGraphRepository
@@ -48,7 +47,6 @@ def test_propagation_result_does_not_expose_invalidated_targets() -> None:
 
 @pytest.mark.asyncio
 async def test_parent_completion_readies_dependency_free_dynamic_children() -> None:
-    _ = ExperimentDefinition
     engine = create_engine(
         "sqlite://",
         connect_args={"check_same_thread": False},
diff --git a/ergon_core/tests/unit/runtime/test_sample_annotation_events.py b/ergon_core/tests/unit/runtime/test_sample_annotation_events.py
index d14a21d0d..23dbe9fae 100644
--- a/ergon_core/tests/unit/runtime/test_sample_annotation_events.py
+++ b/ergon_core/tests/unit/runtime/test_sample_annotation_events.py
@@ -4,12 +4,11 @@
 import pytest
 from sqlmodel import SQLModel, Session, create_engine, select
 
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.samples.models import SampleAnnotationEventRow
 from ergon_core.core.persistence.telemetry.models import SampleRecord
 from ergon_core.core.application.samples.events import SampleRuntimeEventAppender
 
-_REGISTERED_TABLE_MODELS = (ExperimentDefinition, SampleRecord)
+_REGISTERED_TABLE_MODELS = (SampleRecord,)
 
 
 @pytest.fixture()
diff --git a/ergon_core/tests/unit/runtime/test_sample_graph_task_snapshot.py b/ergon_core/tests/unit/runtime/test_sample_graph_task_snapshot.py
index c612a4f0f..3bf3e3ade 100644
--- a/ergon_core/tests/unit/runtime/test_sample_graph_task_snapshot.py
+++ b/ergon_core/tests/unit/runtime/test_sample_graph_task_snapshot.py
@@ -1,8 +1,8 @@
-"""PR 1 focused tests — run-tier task snapshot foundation.
+"""Run-tier task snapshot foundation.
 
-Asserts that `RuntimeGraphRepository.initialize_from_definition`
-populates `task_json` and `is_dynamic` correctly, and that `add_node`
-can accept dynamic task JSON for graph-native spawns.
+Asserts that sample materialization populates `task_json` and `is_dynamic`
+correctly, and that `add_node` can accept dynamic task JSON for graph-native
+spawns.
 """
 
 from __future__ import annotations
@@ -10,13 +10,10 @@
 from uuid import UUID, uuid4
 
 import pytest
+from ergon_core.api import Sample
 from ergon_core.core.application.runtime.models import MutationMeta
 from ergon_core.core.application.runtime.graph_repository import RuntimeGraphRepository
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionInstance,
-    ExperimentDefinitionTask,
-)
+from ergon_core.core.application.samples.materialization import materialize_sample
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.shared.enums import SampleStatus
 from ergon_core.core.persistence.telemetry.models import SampleRecord
@@ -45,86 +42,56 @@ def _session() -> Session:
     return Session(engine)
 
 
-def _seed_definition(session: Session, *, task_slug: str, payload: dict) -> tuple[UUID, UUID]:
-    """Insert a minimal definition with one task; return (definition_id, task_id)."""
-
-    definition_id = uuid4()
-    instance_id = uuid4()
-    task_id = uuid4()
-    task_json = _SnapshotTask(
+def _task(*, task_slug: str, payload: dict) -> _SnapshotTask:
+    return _SnapshotTask(
         task_slug=task_slug,
         instance_key="sample-1",
         description=f"{task_slug} task",
         task_payload=_EmptyPayload.model_validate(payload),
         worker=TestWorker(name="worker", model="test:none"),
         sandbox=TestSandbox(),
-    ).model_dump(mode="json")
-    session.add_all(
-        [
-            ExperimentDefinition(
-                id=definition_id, benchmark_type="test", name="test", metadata_json={}
-            ),
-            ExperimentDefinitionInstance(
-                id=instance_id,
-                experiment_definition_id=definition_id,
-                instance_key="sample-1",
-            ),
-            ExperimentDefinitionTask(
-                id=task_id,
-                experiment_definition_id=definition_id,
-                instance_id=instance_id,
-                task_slug=task_slug,
-                description=f"{task_slug} task",
-                task_payload_json=payload,
-                task_json=task_json,
-            ),
-        ]
     )
-    session.commit()
-    return definition_id, task_id
 
 
 def _seed_run(
     session: Session,
     *,
-    definition_id: UUID,
     sample_id: UUID,
+    tasks: list[_SnapshotTask],
 ) -> None:
-    session.add(
-        SampleRecord(
-            id=sample_id,
-            definition_id=definition_id,
-            benchmark_type="test",
-            instance_key="sample-1",
-            worker_team_json={},
-            status=SampleStatus.EXECUTING,
-        )
+    sample_row = SampleRecord(
+        id=sample_id,
+        benchmark_type="test",
+        instance_key="sample-1",
+        worker_team_json={},
+        status=SampleStatus.EXECUTING,
+    )
+    session.add(sample_row)
+    session.flush()
+    materialize_sample(
+        session=session,
+        sample=Sample.from_tasks(
+            name="snapshot-sample",
+            sample_key="sample-1",
+            environment_name="snapshot-env",
+            tasks=tasks,
+        ),
+        sample_row=sample_row,
     )
     session.commit()
 
 
-def test_initialize_from_definition_copies_task_json() -> None:
+def test_materialize_sample_copies_task_json() -> None:
     session = _session()
     sample_id = uuid4()
-    definition_id, _task_id = _seed_definition(session, task_slug="solve", payload={"problem": "p"})
     _seed_run(
-        session,
-        definition_id=definition_id,
-        sample_id=sample_id,
-    )
-
-    repo = RuntimeGraphRepository()
-    repo.initialize_from_definition(
         session,
         sample_id=sample_id,
-        definition_id=definition_id,
-        initial_node_status="pending",
-        initial_edge_status="pending",
-        meta=MutationMeta(actor="test", reason="snapshot"),
+        tasks=[_task(task_slug="solve", payload={"problem": "p"})],
     )
 
     rows = session.exec(select(SampleGraphNode).where(SampleGraphNode.sample_id == sample_id)).all()
-    assert rows, "initialize_from_definition produced no nodes"
+    assert rows, "materialize_sample produced no nodes"
     row = rows[0]
     assert row.task_json, "task_json must be populated for static nodes"
     assert row.task_json["task_slug"] == "solve"
@@ -144,24 +111,13 @@ async def test_graph_repo_node_inflates_task_from_run_tier() -> None:
 
     session = _session()
     sample_id = uuid4()
-    definition_id, _task_id = _seed_definition(session, task_slug="solve", payload={"problem": "p"})
     _seed_run(
         session,
-        definition_id=definition_id,
         sample_id=sample_id,
+        tasks=[_task(task_slug="solve", payload={"problem": "p"})],
     )
 
     repo = RuntimeGraphRepository()
-    # Populate task_json via the PR 1 path so the view has something to
-    # inflate.
-    repo.initialize_from_definition(
-        session,
-        sample_id=sample_id,
-        definition_id=definition_id,
-        initial_node_status="pending",
-        initial_edge_status="pending",
-        meta=MutationMeta(actor="test", reason="setup"),
-    )
     row = session.exec(
         select(SampleGraphNode).where(SampleGraphNode.sample_id == sample_id)
     ).first()
@@ -203,11 +159,10 @@ def test_graph_repo_node_does_not_reference_definition_tier_models() -> None:
 async def test_add_node_can_write_dynamic_task_json() -> None:
     session = _session()
     sample_id = uuid4()
-    definition_id, _ = _seed_definition(session, task_slug="parent", payload={})
     _seed_run(
         session,
-        definition_id=definition_id,
         sample_id=sample_id,
+        tasks=[_task(task_slug="parent", payload={})],
     )
 
     repo = RuntimeGraphRepository()
@@ -234,26 +189,22 @@ async def test_add_node_can_write_dynamic_task_json() -> None:
     assert row.is_dynamic is True
 
 
-def test_initialize_from_definition_can_seed_same_task_ids_for_multiple_runs() -> None:
+def test_materialize_sample_isolates_task_ids_for_multiple_samples() -> None:
     session = _session()
     run_a = uuid4()
     run_b = uuid4()
-    definition_id, definition_task_id = _seed_definition(
-        session, task_slug="solve", payload={"problem": "p"}
-    )
-    _seed_run(session, definition_id=definition_id, sample_id=run_a)
-    _seed_run(session, definition_id=definition_id, sample_id=run_b)
-
-    repo = RuntimeGraphRepository()
+    task = _task(task_slug="solve", payload={"problem": "p"})
     for sample_id in (run_a, run_b):
-        repo.initialize_from_definition(
-            session,
-            sample_id=sample_id,
-            definition_id=definition_id,
-            initial_node_status="pending",
-            initial_edge_status="pending",
-            meta=MutationMeta(actor="test", reason="multi-run"),
-        )
-
-    assert session.get(SampleGraphNode, (run_a, definition_task_id)) is not None
-    assert session.get(SampleGraphNode, (run_b, definition_task_id)) is not None
+        _seed_run(session, sample_id=sample_id, tasks=[task])
+
+    task_ids = {
+        sample_id: {
+            row.task_id
+            for row in session.exec(
+                select(SampleGraphNode).where(SampleGraphNode.sample_id == sample_id)
+            )
+        }
+        for sample_id in (run_a, run_b)
+    }
+    assert len(task_ids[run_a]) == len(task_ids[run_b]) == 1
+    assert task_ids[run_a].isdisjoint(task_ids[run_b])
diff --git a/ergon_core/tests/unit/runtime/test_sample_record_missing_error.py b/ergon_core/tests/unit/runtime/test_sample_record_missing_error.py
index c476c428f..358ae56be 100644
--- a/ergon_core/tests/unit/runtime/test_sample_record_missing_error.py
+++ b/ergon_core/tests/unit/runtime/test_sample_record_missing_error.py
@@ -1,9 +1,7 @@
-"""Tests for SampleRecordMissingError and the runtime identity helper."""
+"""Tests for SampleRecordMissingError."""
 
 from uuid import uuid4
 
-import pytest
-from ergon_core.core.application.runtime.sample_identity import definition_id_for_run
 from ergon_core.core.application.runtime.task_errors import SampleRecordMissingError
 
 
@@ -19,17 +17,3 @@ def test_error_is_exception_subclass():
     sample_id = uuid4()
     err = SampleRecordMissingError(sample_id)
     assert isinstance(err, Exception)
-
-
-def test_service_raises_when_run_record_missing():
-    """definition_id_for_run raises SampleRecordMissingError when session returns None."""
-    from unittest.mock import MagicMock
-
-    session = MagicMock()
-    # exec().first() returns None → no SampleRecord found
-    session.exec.return_value.first.return_value = None
-
-    sample_id = uuid4()
-
-    with pytest.raises(SampleRecordMissingError, match=str(sample_id)):
-        definition_id_for_run(session, sample_id)
diff --git a/ergon_core/tests/unit/runtime/test_sample_record_service.py b/ergon_core/tests/unit/runtime/test_sample_record_service.py
deleted file mode 100644
index 0e4ca2f32..000000000
--- a/ergon_core/tests/unit/runtime/test_sample_record_service.py
+++ /dev/null
@@ -1,60 +0,0 @@
-from uuid import uuid4
-
-from ergon_core.core.application.experiments.handles import DefinitionHandle
-from ergon_core.core.application.runtime import samples as sample_service
-from ergon_core.core.persistence.shared.enums import SampleStatus
-
-
-class _FakeSession:
-    def __init__(self) -> None:
-        self.added = []
-
-    def __enter__(self) -> "_FakeSession":
-        return self
-
-    def __exit__(self, *args) -> None:
-        return None
-
-    def add(self, row) -> None:
-        self.added.append(row)
-
-    def commit(self) -> None:
-        return None
-
-    def refresh(self, row) -> None:
-        return None
-
-
-def test_create_definition_backed_sample_records_assignment(monkeypatch):
-    session = _FakeSession()
-    definition_id = uuid4()
-    definition = DefinitionHandle(
-        definition_id=definition_id,
-        benchmark_type="ci-benchmark",
-        worker_bindings={"primary": "test-worker"},
-        evaluator_bindings={"primary": "test-evaluator"},
-    )
-
-    monkeypatch.setattr(sample_service, "get_session", lambda: session)
-
-    sample = sample_service.create_definition_backed_sample(
-        definition,
-        definition_id=definition_id,
-        instance_key="sample-1",
-        worker_team_json={"primary": "test-worker"},
-        evaluator_slug="test-evaluator",
-        model_target="openai:gpt-4o",
-        assignment_json={"arm_key": "default"},
-        seed=123,
-    )
-
-    assert session.added == [sample]
-    assert sample.definition_id == definition_id
-    assert sample.benchmark_type == "ci-benchmark"
-    assert sample.instance_key == "sample-1"
-    assert sample.worker_team_json == {"primary": "test-worker"}
-    assert sample.evaluator_slug == "test-evaluator"
-    assert sample.model_target == "openai:gpt-4o"
-    assert sample.assignment_json == {"arm_key": "default"}
-    assert sample.seed == 123
-    assert sample.status == SampleStatus.PENDING
diff --git a/ergon_core/tests/unit/runtime/test_sample_service.py b/ergon_core/tests/unit/runtime/test_sample_service.py
deleted file mode 100644
index e40bf72b0..000000000
--- a/ergon_core/tests/unit/runtime/test_sample_service.py
+++ /dev/null
@@ -1,60 +0,0 @@
-from uuid import uuid4
-
-from ergon_core.core.application.experiments.handles import DefinitionHandle
-from ergon_core.core.persistence.shared.enums import SampleStatus
-from ergon_core.core.application.runtime import samples as sample_service
-
-
-class _FakeSession:
-    def __init__(self) -> None:
-        self.added = []
-
-    def __enter__(self) -> "_FakeSession":
-        return self
-
-    def __exit__(self, *args) -> None:
-        return None
-
-    def add(self, row) -> None:
-        self.added.append(row)
-
-    def commit(self) -> None:
-        return None
-
-    def refresh(self, row) -> None:
-        return None
-
-
-def test_create_run_requires_definition_identity_and_records_assignment(monkeypatch):
-    session = _FakeSession()
-    definition_id = uuid4()
-    definition = DefinitionHandle(
-        definition_id=definition_id,
-        benchmark_type="ci-benchmark",
-        worker_bindings={"primary": "test-worker"},
-        evaluator_bindings={"primary": "test-evaluator"},
-    )
-
-    monkeypatch.setattr(sample_service, "get_session", lambda: session)
-
-    run = sample_service.create_run(
-        definition,
-        definition_id=definition_id,
-        instance_key="sample-1",
-        worker_team_json={"primary": "test-worker"},
-        evaluator_slug="test-evaluator",
-        model_target="openai:gpt-4o",
-        assignment_json={"arm_key": "default"},
-        seed=123,
-    )
-
-    assert session.added == [run]
-    assert run.definition_id == definition_id
-    assert run.benchmark_type == "ci-benchmark"
-    assert run.instance_key == "sample-1"
-    assert run.worker_team_json == {"primary": "test-worker"}
-    assert run.evaluator_slug == "test-evaluator"
-    assert run.model_target == "openai:gpt-4o"
-    assert run.assignment_json == {"arm_key": "default"}
-    assert run.seed == 123
-    assert run.status == SampleStatus.PENDING
diff --git a/ergon_core/tests/unit/runtime/test_sample_state_replay.py b/ergon_core/tests/unit/runtime/test_sample_state_replay.py
index 673708d1c..af32c26b5 100644
--- a/ergon_core/tests/unit/runtime/test_sample_state_replay.py
+++ b/ergon_core/tests/unit/runtime/test_sample_state_replay.py
@@ -4,7 +4,6 @@
 import pytest
 from sqlmodel import SQLModel, Session, create_engine
 
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.samples.models import (
     SampleAnnotationEventRow,
     SampleEdgeEventRow,
@@ -18,7 +17,7 @@
 from ergon_core.core.application.samples.events import SampleRuntimeEventAppender
 from ergon_core.core.application.samples.state import reconstruct_sample_runtime_state_at
 
-_REGISTERED_TABLE_MODELS = (ExperimentDefinition, SampleRecord)
+_REGISTERED_TABLE_MODELS = (SampleRecord,)
 
 
 @pytest.fixture()
diff --git a/ergon_core/tests/unit/runtime/test_sandbox_cleanup.py b/ergon_core/tests/unit/runtime/test_sandbox_cleanup.py
index 8fb962d81..458e2e3b4 100644
--- a/ergon_core/tests/unit/runtime/test_sandbox_cleanup.py
+++ b/ergon_core/tests/unit/runtime/test_sandbox_cleanup.py
@@ -37,7 +37,6 @@ async def test_cleanup_on_completed_terminates_sandbox(monkeypatch: pytest.Monke
     """A ``task/completed`` event with a sandbox_id terminates that sandbox."""
     payload = TaskCompletedEvent(
         sample_id=uuid4(),
-        definition_id=uuid4(),
         task_id=uuid4(),
         execution_id=uuid4(),
         sandbox_id="sbx-completed",
@@ -66,7 +65,6 @@ async def test_cleanup_on_failed_terminates_sandbox(monkeypatch: pytest.MonkeyPa
     """A ``task/failed`` event with a sandbox_id terminates that sandbox."""
     payload = TaskFailedEvent(
         sample_id=uuid4(),
-        definition_id=uuid4(),
         task_id=uuid4(),
         execution_id=uuid4(),
         error="boom",
@@ -98,7 +96,6 @@ async def test_cleanup_on_failed_skips_when_sandbox_id_missing(
     """A failure before sandbox-setup carries ``sandbox_id=None``; cleanup is a no-op."""
     payload = TaskFailedEvent(
         sample_id=uuid4(),
-        definition_id=uuid4(),
         task_id=uuid4(),
         execution_id=uuid4(),
         error="prepare-failed",
diff --git a/ergon_core/tests/unit/runtime/test_spawn_dynamic_task.py b/ergon_core/tests/unit/runtime/test_spawn_dynamic_task.py
index b92b6c2ec..b42adbec2 100644
--- a/ergon_core/tests/unit/runtime/test_spawn_dynamic_task.py
+++ b/ergon_core/tests/unit/runtime/test_spawn_dynamic_task.py
@@ -4,7 +4,7 @@
 
 - Exactly one row inserted into sample_graph_nodes with is_dynamic=True and
   the full Task snapshot in task_json.
-- Zero rows inserted into experiment_definition_tasks.
+- No definition persistence table is required.
 - Optional depends_on creates the dependency edge in sample_graph_edges.
 - Returned SpawnedTaskHandle.task_id matches the inserted node's task_id.
 """
@@ -19,7 +19,6 @@
 from ergon_core.core.jobs.task.worker_execute.job import _StepAwareTaskManagementService
 from ergon_core.core.application.runtime import management as management_module
 from ergon_core.core.application.runtime.task_management import TaskManagementService
-from ergon_core.core.persistence.definitions.models import ExperimentDefinitionTask
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.persistence.shared.enums import SampleStatus
 from ergon_core.core.persistence.telemetry.models import SampleRecord
@@ -65,7 +64,6 @@ def _seed_parent(session: Session, *, sample_id: UUID) -> SampleGraphNode:
     session.add(
         SampleRecord(
             id=sample_id,
-            definition_id=uuid4(),
             benchmark_type="test",
             instance_key="sample-1",
             worker_team_json={},
@@ -203,16 +201,16 @@ async def test_spawn_dynamic_task_inserts_dynamic_node_with_task_json(
 
 
 @pytest.mark.asyncio
-async def test_spawn_dynamic_task_does_not_write_definition_row(
+async def test_spawn_dynamic_task_does_not_require_definition_tables(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    """experiment_definition_tasks count is unchanged before/after spawn."""
+    """Dynamic spawn writes run graph state without definition persistence."""
     session = _make_session()
     sample_id = uuid4()
     parent = _seed_parent(session, sample_id=sample_id)
     svc = _service(session, monkeypatch)
 
-    defs_before = session.exec(select(ExperimentDefinitionTask)).all()
+    assert "experiment_definition_tasks" not in SQLModel.metadata.tables
 
     await svc.spawn_dynamic_task(
         sample_id=sample_id,
@@ -220,8 +218,10 @@ async def test_spawn_dynamic_task_does_not_write_definition_row(
         task=_make_task(),
     )
 
-    defs_after = session.exec(select(ExperimentDefinitionTask)).all()
-    assert len(defs_before) == len(defs_after) == 0
+    nodes = session.exec(
+        select(SampleGraphNode).where(SampleGraphNode.sample_id == sample_id)
+    ).all()
+    assert {node.task_slug for node in nodes} == {"parent", "child"}
 
 
 @pytest.mark.asyncio
diff --git a/ergon_core/tests/unit/runtime/test_task_execution_repository.py b/ergon_core/tests/unit/runtime/test_task_execution_repository.py
index 76afe8da9..812d73bb3 100644
--- a/ergon_core/tests/unit/runtime/test_task_execution_repository.py
+++ b/ergon_core/tests/unit/runtime/test_task_execution_repository.py
@@ -24,7 +24,6 @@ def _run(session: Session) -> UUID:
     session.add(
         SampleRecord(
             id=sample_id,
-            definition_id=uuid4(),
             benchmark_type="ci-task-execution-repository",
             instance_key="sample-1",
             worker_team_json={"primary": "test-worker"},
diff --git a/ergon_core/tests/unit/runtime/test_typed_sample_wal.py b/ergon_core/tests/unit/runtime/test_typed_sample_wal.py
index 1319972a2..dc38b2a9b 100644
--- a/ergon_core/tests/unit/runtime/test_typed_sample_wal.py
+++ b/ergon_core/tests/unit/runtime/test_typed_sample_wal.py
@@ -4,7 +4,6 @@
 import pytest
 from sqlmodel import SQLModel, Session, create_engine, select
 
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.samples.models import (
     SampleEdgeEventRow,
     SampleEvaluatorEventRow,
@@ -16,7 +15,7 @@
 from ergon_core.core.persistence.telemetry.models import SampleRecord
 from ergon_core.core.application.samples.events import SampleRuntimeEventAppender
 
-_REGISTERED_TABLE_MODELS = (ExperimentDefinition, SampleRecord)
+_REGISTERED_TABLE_MODELS = (SampleRecord,)
 
 
 @pytest.fixture()
diff --git a/ergon_core/tests/unit/runtime/test_walkthrough_smoketest.py b/ergon_core/tests/unit/runtime/test_walkthrough_smoketest.py
index 4c7c16ff8..590a33172 100644
--- a/ergon_core/tests/unit/runtime/test_walkthrough_smoketest.py
+++ b/ergon_core/tests/unit/runtime/test_walkthrough_smoketest.py
@@ -15,21 +15,14 @@
 from uuid import UUID, uuid4
 
 import pytest
+from ergon_core.api import Sample
 from ergon_core.api.benchmark.task import Task
 from ergon_core.api.worker.context import WorkerContext
-from ergon_core.core.application.runtime.models import MutationMeta
-from ergon_core.core.application.runtime.graph_repository import RuntimeGraphRepository
 from ergon_core.core.application.runtime import inspection as inspection_module
 from ergon_core.core.application.runtime import management as management_module
 from ergon_core.core.application.runtime.task_inspection import TaskInspectionService
 from ergon_core.core.application.runtime.task_management import TaskManagementService
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionInstance,
-    ExperimentDefinitionTask,
-    ExperimentDefinitionTaskAssignment,
-    ExperimentDefinitionWorker,
-)
+from ergon_core.core.application.samples.materialization import materialize_sample
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.shared.enums import SampleStatus
 from ergon_core.core.persistence.telemetry.models import SampleRecord
@@ -57,79 +50,54 @@ def _session() -> Session:
     return Session(engine)
 
 
-def _seed_run(session: Session) -> tuple[UUID, UUID]:
-    """Insert a minimal experiment/definition/run with one task; return
-    (sample_id, definition_id)."""
+def _seed_run(session: Session) -> UUID:
+    """Materialize a minimal sample with one task; return sample_id."""
 
-    definition_id = uuid4()
-    instance_id = uuid4()
-    task_id = uuid4()
     sample_id = uuid4()
-    task_json = _SmokeTask(
+    task = _SmokeTask(
         task_slug="root",
         instance_key="sample-1",
         description="root task",
         task_payload=_EmptyPayload.model_validate({"problem": "p"}),
         worker=EchoWorker(name="echo", model="test:none"),
         sandbox=EchoSandbox(),
-    ).model_dump(mode="json")
-    session.add_all(
-        [
-            ExperimentDefinition(
-                id=definition_id, benchmark_type="test", name="test", metadata_json={}
-            ),
-            ExperimentDefinitionInstance(
-                id=instance_id,
-                experiment_definition_id=definition_id,
-                instance_key="sample-1",
-            ),
-            ExperimentDefinitionTask(
-                id=task_id,
-                experiment_definition_id=definition_id,
-                instance_id=instance_id,
-                task_slug="root",
-                description="root task",
-                task_payload_json={"problem": "p"},
-                task_json=task_json,
-            ),
-            SampleRecord(
-                id=sample_id,
-                definition_id=definition_id,
-                benchmark_type="test",
-                instance_key="sample-1",
-                worker_team_json={},
-                status=SampleStatus.EXECUTING,
-            ),
-        ]
+    )
+    sample_row = SampleRecord(
+        id=sample_id,
+        benchmark_type="test",
+        instance_key="sample-1",
+        worker_team_json={},
+        status=SampleStatus.EXECUTING,
+    )
+    session.add(sample_row)
+    session.flush()
+    materialize_sample(
+        session=session,
+        sample=Sample.from_tasks(
+            name="smoke-sample",
+            sample_key="sample-1",
+            environment_name="test",
+            tasks=[task],
+        ),
+        sample_row=sample_row,
     )
     session.commit()
-    return sample_id, definition_id
+    return sample_id
 
 
 # ── PR 1 invariant — GREEN today ─────────────────────────────────────
 
 
-def test_prepare_run_populates_task_json_for_every_node() -> None:
+def test_materialize_sample_populates_task_json_for_every_node() -> None:
     """PR 1 invariant: every sample_graph_nodes row produced by
-    initialize_from_definition carries a non-empty task_json
-    snapshot."""
+    sample materialization carries a non-empty task_json snapshot."""
 
     session = _session()
-    sample_id, definition_id = _seed_run(session)
-
-    repo = RuntimeGraphRepository()
-    repo.initialize_from_definition(
-        session,
-        sample_id=sample_id,
-        definition_id=definition_id,
-        initial_node_status="pending",
-        initial_edge_status="pending",
-        meta=MutationMeta(actor="test", reason="smoke"),
-    )
+    sample_id = _seed_run(session)
 
     rows = session.exec(select(SampleGraphNode).where(SampleGraphNode.sample_id == sample_id)).all()
 
-    assert rows, "prepare_run produced no nodes"
+    assert rows, "materialize_sample produced no nodes"
     assert all(row.task_json for row in rows), (
         "every node must carry a self-contained task snapshot"
     )
@@ -139,76 +107,6 @@ def test_prepare_run_populates_task_json_for_every_node() -> None:
 # ── Runtime invariants ───────────────────────────────────────────────
 
 
-def test_persist_definition_writes_only_intended_tables(monkeypatch) -> None:
-    """PR 7 invariant: persist_benchmark writes experiment_definitions
-    plus experiment_definition_tasks (and related instance / task-
-    evaluator rows). Identity comes from ``ExperimentDefinition`` only."""
-
-    from collections.abc import Mapping, Sequence
-    from typing import ClassVar
-
-    from ergon_core.api import Benchmark
-    from ergon_core.core.application.experiments import (
-        definition_writer as definition_writer_module,
-    )
-    from ergon_core.core.application.experiments.definition_writer import persist_benchmark
-
-    class _OneTaskBenchmark(Benchmark):
-        type_slug: ClassVar[str] = "smoketest-one-task"
-
-        def build_instances(self) -> Mapping[str, Sequence[Task]]:
-            return {
-                "sample-1": (
-                    Task(
-                        task_slug="root",
-                        instance_key="sample-1",
-                        description="root task",
-                        worker=EchoWorker(name="echo", model="echo-model"),
-                        sandbox=EchoSandbox(),
-                    ),
-                )
-            }
-
-    session = _session()
-    monkeypatch.setattr(definition_writer_module, "get_session", lambda: session)
-    # persist_benchmark calls session.close() at the end of its
-    # transaction; swap close to a no-op so we can still query the
-    # in-memory engine afterwards.
-    monkeypatch.setattr(session, "close", lambda: None)
-
-    benchmark = _OneTaskBenchmark(name="smoke benchmark", description="one task")
-    handle = persist_benchmark(benchmark)
-
-    # experiment_definitions has exactly one row with the benchmark's
-    # identity fields.
-    definitions = session.exec(select(ExperimentDefinition)).all()
-    assert len(definitions) == 1
-    persisted = definitions[0]
-    assert persisted.id == handle.definition_id
-    assert persisted.name == "smoke benchmark"
-    assert persisted.description == "one task"
-
-    # experiment_definition_tasks has exactly one row, parented to the
-    # new definition.
-    tasks = session.exec(select(ExperimentDefinitionTask)).all()
-    assert len(tasks) == 1
-    assert tasks[0].experiment_definition_id == handle.definition_id
-    assert tasks[0].task_slug == "root"
-
-    # experiment_definition_instances has exactly one row, parented to
-    # the new definition.
-    instances = session.exec(select(ExperimentDefinitionInstance)).all()
-    assert len(instances) == 1
-    assert instances[0].experiment_definition_id == handle.definition_id
-
-    workers = session.exec(select(ExperimentDefinitionWorker)).all()
-    assert [(row.binding_key, row.worker_type, row.model_target) for row in workers] == [
-        ("echo", "echo", "echo-model")
-    ]
-    assignments = session.exec(select(ExperimentDefinitionTaskAssignment)).all()
-    assert [row.worker_binding_key for row in assignments] == ["echo"]
-
-
 def test_worker_execute_reads_task_from_run_tier_only() -> None:
     """PR 3 invariant: ``worker_execute.py`` source does not reference
     definition-tier symbols.
@@ -366,7 +264,6 @@ def _seed_parent_node(session: Session, *, sample_id: UUID) -> SampleGraphNode:
     session.add(
         SampleRecord(
             id=sample_id,
-            definition_id=uuid4(),
             benchmark_type="test",
             instance_key="sample-1",
             worker_team_json={},
@@ -409,10 +306,6 @@ async def test_dynamic_spawn_writes_only_to_sample_graph_nodes(
 
     # 3. Patch get_session so service writes stay in the test session.
     _patch_get_session_smoke(monkeypatch, session)
-    monkeypatch.setattr(
-        management_module, "definition_id_for_run", lambda _session, _run_id: uuid4()
-    )
-
     task_mgmt = TaskManagementService(
         dashboard_emitter=SimpleNamespace(graph_mutation=AsyncMock()),
         task_ready_dispatcher=AsyncMock(),
@@ -422,7 +315,6 @@ async def test_dynamic_spawn_writes_only_to_sample_graph_nodes(
         sample_id=sample_id,
         task_id=parent.task_id,
         execution_id=uuid4(),
-        definition_id=None,
         sandbox_id="sandbox-smoke",
         task_mgmt=task_mgmt,
         task_inspect=task_inspect,
@@ -431,8 +323,8 @@ async def test_dynamic_spawn_writes_only_to_sample_graph_nodes(
     )
 
     nodes_before = session.exec(select(SampleGraphNode)).all()
-    defs_before = session.exec(select(ExperimentDefinitionTask)).all()
     assert len(nodes_before) == 1  # only the parent
+    assert "experiment_definition_tasks" not in SQLModel.metadata.tables
 
     # 4. Spawn a dynamic child task.
     await context.spawn_task(
@@ -449,10 +341,8 @@ async def test_dynamic_spawn_writes_only_to_sample_graph_nodes(
     # 5. Exactly one new sample_graph_nodes row (is_dynamic=True); zero new
     #    experiment_definition_tasks rows.
     nodes_after = session.exec(select(SampleGraphNode)).all()
-    defs_after = session.exec(select(ExperimentDefinitionTask)).all()
 
     assert len(nodes_after) == len(nodes_before) + 1
-    assert len(defs_after) == len(defs_before) == 0
 
     new_node = session.exec(
         select(SampleGraphNode).where(
diff --git a/ergon_core/tests/unit/runtime/test_worker_context_containment.py b/ergon_core/tests/unit/runtime/test_worker_context_containment.py
index d05e04105..27b42b309 100644
--- a/ergon_core/tests/unit/runtime/test_worker_context_containment.py
+++ b/ergon_core/tests/unit/runtime/test_worker_context_containment.py
@@ -4,7 +4,7 @@
 PR 9 Tasks 2-3:
 
 - ``spawn_task`` round-trips through ``TaskManagementService.spawn_dynamic_task``
-  and writes only to ``sample_graph_nodes`` (never ``experiment_definition_tasks``).
+  and writes only to ``sample_graph_nodes``.
 - The spawned dynamic node inflates correctly through
   ``RuntimeGraphRepository.node`` (is_dynamic=True + correct task_slug).
 - ``cancel_task`` enforces containment via ``_assert_descendant``,
@@ -32,7 +32,6 @@
 from ergon_core.core.application.runtime import management as management_module
 from ergon_core.core.application.runtime.task_inspection import TaskInspectionService
 from ergon_core.core.application.runtime.task_management import TaskManagementService
-from ergon_core.core.persistence.definitions.models import ExperimentDefinitionTask
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.tests.unit.runtime._test_workers import EchoSandbox, EchoWorker
 from sqlalchemy.pool import StaticPool
@@ -135,7 +134,6 @@ def _build_context(
         sample_id=sample_id,
         task_id=task_id,
         execution_id=uuid4(),
-        definition_id=None,
         sandbox_id="sandbox-test",
         task_mgmt=task_mgmt,
         task_inspect=task_inspect,
@@ -153,16 +151,13 @@ def _build_context(
 async def test_spawn_task_via_worker_context_does_not_write_definition_row(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    """spawn_task through the facade writes one run-graph row, zero definition rows."""
+    """spawn_task through the facade writes one run-graph row without definition tables."""
 
     session = _make_session()
     sample_id = uuid4()
     parent = _seed_node(session, sample_id=sample_id, slug="parent")
     _patch_get_session(monkeypatch, session)
 
-    monkeypatch.setattr(
-        management_module, "definition_id_for_run", lambda _session, _run_id: uuid4()
-    )
     task_mgmt = TaskManagementService(
         dashboard_emitter=MagicMock(),
         task_ready_dispatcher=AsyncMock(),
@@ -176,17 +171,15 @@ async def test_spawn_task_via_worker_context_does_not_write_definition_row(
     )
 
     nodes_before = session.exec(select(SampleGraphNode)).all()
-    defs_before = session.exec(select(ExperimentDefinitionTask)).all()
     assert len(nodes_before) == 1  # only the parent
+    assert "experiment_definition_tasks" not in SQLModel.metadata.tables
 
     handle = await context.spawn_task(_make_task())
 
     nodes_after = session.exec(select(SampleGraphNode)).all()
-    defs_after = session.exec(select(ExperimentDefinitionTask)).all()
 
-    # Exactly one new run-graph row, no new definition rows.
+    # Exactly one new run-graph row.
     assert len(nodes_after) == len(nodes_before) + 1
-    assert len(defs_after) == len(defs_before) == 0
 
     new_node = session.exec(
         select(SampleGraphNode).where(
@@ -213,9 +206,6 @@ async def test_spawned_task_inflates_through_graph_repo_node(
     parent = _seed_node(session, sample_id=sample_id, slug="parent")
     _patch_get_session(monkeypatch, session)
 
-    monkeypatch.setattr(
-        management_module, "definition_id_for_run", lambda _session, _run_id: uuid4()
-    )
     task_mgmt = TaskManagementService(
         dashboard_emitter=MagicMock(),
         task_ready_dispatcher=AsyncMock(),
diff --git a/ergon_core/tests/unit/runtime/test_workflow_service.py b/ergon_core/tests/unit/runtime/test_workflow_service.py
index 7f44fc3e2..a2f40d4c7 100644
--- a/ergon_core/tests/unit/runtime/test_workflow_service.py
+++ b/ergon_core/tests/unit/runtime/test_workflow_service.py
@@ -2,7 +2,6 @@
 from uuid import UUID, uuid4
 
 import pytest
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.persistence.shared.enums import (
     SampleResourceKind,
@@ -20,7 +19,6 @@
 
 
 def _session() -> Session:
-    _ = ExperimentDefinition
     engine = create_engine(
         "sqlite://",
         connect_args={"check_same_thread": False},
@@ -98,11 +96,9 @@ def _resource(
 
 def _run(session: Session) -> UUID:
     sample_id = uuid4()
-    definition_id = uuid4()
     session.add(
         SampleRecord(
             id=sample_id,
-            definition_id=definition_id,
             benchmark_type="ci-workflow-service",
             instance_key="sample-1",
             worker_team_json={"primary": "test-worker"},
diff --git a/ergon_core/tests/unit/state/test_event_schema_phase0.py b/ergon_core/tests/unit/state/test_event_schema_phase0.py
index ab2747fab..d7a8c7f3b 100644
--- a/ergon_core/tests/unit/state/test_event_schema_phase0.py
+++ b/ergon_core/tests/unit/state/test_event_schema_phase0.py
@@ -16,13 +16,12 @@
 _TASK_ID_CASES = [
     (
         "TaskReadyEvent",
-        lambda: TaskReadyEvent(sample_id=uuid4(), definition_id=uuid4(), task_id=uuid4()),
+        lambda: TaskReadyEvent(sample_id=uuid4(), task_id=uuid4()),
     ),
     (
         "TaskFailedEvent",
         lambda: TaskFailedEvent(
             sample_id=uuid4(),
-            definition_id=uuid4(),
             task_id=uuid4(),
             execution_id=uuid4(),
             error="boom",
@@ -32,7 +31,6 @@
         "PrepareTaskExecutionCommand",
         lambda: PrepareTaskExecutionCommand(
             sample_id=uuid4(),
-            definition_id=uuid4(),
             task_id=uuid4(),
         ),
     ),
@@ -47,7 +45,6 @@
         "PropagateTaskCompletionCommand",
         lambda: PropagateTaskCompletionCommand(
             sample_id=uuid4(),
-            definition_id=uuid4(),
             task_id=uuid4(),
             execution_id=uuid4(),
         ),
@@ -57,7 +54,7 @@
 
 def test_task_ready_event_requires_task_id() -> None:
     with pytest.raises(ValueError):
-        TaskReadyEvent(sample_id=uuid4(), definition_id=uuid4())  # type: ignore[call-arg]
+        TaskReadyEvent(sample_id=uuid4())  # type: ignore[call-arg]
 
 
 @pytest.mark.parametrize("label,factory", _TASK_ID_CASES, ids=[c[0] for c in _TASK_ID_CASES])
@@ -74,7 +71,6 @@ def test_task_completed_event_uses_task_id() -> None:
     task_id = uuid4()
     event = TaskCompletedEvent(
         sample_id=uuid4(),
-        definition_id=uuid4(),
         task_id=task_id,
         execution_id=uuid4(),
         sandbox_id="sbx-123",
diff --git a/ergon_core/tests/unit/state/test_type_invariants.py b/ergon_core/tests/unit/state/test_type_invariants.py
index d1cada9bc..58dfd08be 100644
--- a/ergon_core/tests/unit/state/test_type_invariants.py
+++ b/ergon_core/tests/unit/state/test_type_invariants.py
@@ -33,7 +33,9 @@
     [
         (
             lambda: SampleRecord(
-                definition_id=uuid4(),
+                experiment_id=uuid4(),
+                environment_id=uuid4(),
+                sample_key="sample-1",
                 benchmark_type="ci-test",
                 instance_key="sample-1",
                 worker_team_json={"primary": "test-worker"},
@@ -118,12 +120,15 @@ def test_task_execution_rejects_missing_static_or_dynamic_identity():
         )
 
 
-def test_run_record_uses_definition_identity():
-    definition_id = uuid4()
+def test_sample_record_uses_experiment_environment_identity():
+    experiment_id = uuid4()
+    environment_id = uuid4()
 
     run = SampleRecord.model_validate(
         {
-            "definition_id": str(definition_id),
+            "experiment_id": str(experiment_id),
+            "environment_id": str(environment_id),
+            "sample_key": "sample-1",
             "benchmark_type": "ci-benchmark",
             "instance_key": "sample-1",
             "worker_team_json": {"primary": "test-worker"},
@@ -131,12 +136,14 @@ def test_run_record_uses_definition_identity():
         }
     )
 
-    assert run.definition_id == definition_id
+    assert not hasattr(run, "definition_id")
+    assert run.experiment_id == experiment_id
+    assert run.environment_id == environment_id
+    assert run.sample_key == "sample-1"
     assert run.benchmark_type == "ci-benchmark"
     assert run.instance_key == "sample-1"
     assert run.parsed_worker_team() == {"primary": "test-worker"}
     assert not hasattr(run, "workflow" + "_definition_id")
-    assert run.experiment_id is None
     assert not hasattr(run, "cohort_id")
 
 
@@ -160,7 +167,9 @@ def test_enum_value_matches_string():
         (
             SampleRecord,
             {
-                "definition_id": str(uuid4()),
+                "experiment_id": str(uuid4()),
+                "environment_id": str(uuid4()),
+                "sample_key": "sample-1",
                 "benchmark_type": "ci-test",
                 "instance_key": "sample-1",
                 "worker_team_json": {"primary": "test-worker"},
@@ -189,7 +198,7 @@ def test_enum_value_matches_string():
         ),
         (
             RolloutBatch,
-            {"definition_id": str(uuid4())},
+            {"experiment_id": str(uuid4())},
             "status",
             "garbage",
         ),
diff --git a/ergon_ingestion/ergon_ingestion/exports/sharded.py b/ergon_ingestion/ergon_ingestion/exports/sharded.py
index 4b76d63e6..0bd77710c 100644
--- a/ergon_ingestion/ergon_ingestion/exports/sharded.py
+++ b/ergon_ingestion/ergon_ingestion/exports/sharded.py
@@ -177,7 +177,7 @@ def _run_row(
         "dataset": config.dataset,
         "batch": config.batch,
         "sample_id": str(run.id),
-        "definition_id": str(run.definition_id),
+        "experiment_id": str(run.experiment_id) if run.experiment_id else None,
         "benchmark_type": run.benchmark_type,
         "instance_key": run.instance_key,
         "sample_id": run.sample_id,
diff --git a/ergon_ingestion/ergon_ingestion/writers/external_run_writer.py b/ergon_ingestion/ergon_ingestion/writers/external_run_writer.py
index 5da5916de..64fe026d5 100644
--- a/ergon_ingestion/ergon_ingestion/writers/external_run_writer.py
+++ b/ergon_ingestion/ergon_ingestion/writers/external_run_writer.py
@@ -4,16 +4,11 @@
 import json
 import math
 from pathlib import Path
-from uuid import UUID
+from uuid import UUID, uuid4
 
 from pydantic import BaseModel, ConfigDict
 from sqlmodel import Session
 
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionInstance,
-    ExperimentDefinitionTask,
-)
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.samples.models import SampleAnnotationEventRow
 from ergon_core.core.persistence.shared.enums import (
@@ -48,45 +43,17 @@ def __init__(self, *, session: Session, source: ImportSource, blob_root: Path) -
         self._session = session
         self._source = source
         self._blob_root = blob_root
-        self._definition: ExperimentDefinition | None = None
 
     def write_run(self, parsed: ParsedRun) -> WriteRunResult:
-        definition = self._definition_row()
         observed_fields = _compact_for_db(_json_safe(parsed.observed_fields))
         missing_fields = _json_safe(parsed.missing_fields)
-        instance = ExperimentDefinitionInstance(
-            experiment_definition_id=definition.id,
-            instance_key=parsed.instance_key,
-            benchmark_instance_state={
-                "imported": True,
-                "source_run_id": parsed.source_run_id,
-                "schema_fit_class": parsed.schema_fit_class,
-                "observed_fields": observed_fields,
-                "missing_fields": missing_fields,
-            },
-        )
-        self._session.add(instance)
-        self._session.flush()
-
-        task = ExperimentDefinitionTask(
-            experiment_definition_id=definition.id,
-            instance_id=instance.id,
-            task_slug="imported-root",
-            task_type="imported",
-            description=parsed.description,
-            task_payload_json={
-                "field_provenance": "required-spine",
-                "source_run_id": parsed.source_run_id,
-            },
-        )
-        self._session.add(task)
-        self._session.flush()
+        task_id = uuid4()
 
         run = SampleRecord(
-            definition_id=definition.id,
             benchmark_type=f"imported:{self._source.dataset}",
             instance_key=parsed.instance_key,
             sample_id=parsed.source_run_id,
+            sample_key=parsed.instance_key,
             status=SampleStatus.COMPLETED,
             summary_json={
                 "imported": True,
@@ -103,7 +70,7 @@ def write_run(self, parsed: ParsedRun) -> WriteRunResult:
 
         node = SampleGraphNode(
             sample_id=run.id,
-            task_id=task.id,
+            task_id=task_id,
             instance_key=parsed.instance_key,
             task_slug="imported-root",
             description=parsed.description,
@@ -147,25 +114,6 @@ def write_run(self, parsed: ParsedRun) -> WriteRunResult:
             sample_id=run.id, task_id=node.task_id, task_execution_id=execution.id
         )
 
-    def _definition_row(self) -> ExperimentDefinition:
-        if self._definition is None:
-            self._definition = ExperimentDefinition(
-                benchmark_type=f"imported:{self._source.dataset}",
-                name=f"imported:{self._source.dataset}",
-                metadata_json={
-                    "imported": True,
-                    "source_slug": self._source.dataset,
-                    "import_batch_id": self._source.batch_id,
-                    "source_url": self._source.source_url,
-                    "source_version_ref": self._source.source_version_ref,
-                    "source_license": self._source.source_license,
-                    "redistribution_class": self._source.redistribution_class,
-                },
-            )
-            self._session.add(self._definition)
-            self._session.flush()
-        return self._definition
-
     def _resource_row(
         self,
         sample_id: UUID,
diff --git a/ergon_ingestion/tests/unit/test_external_run_writer.py b/ergon_ingestion/tests/unit/test_external_run_writer.py
index 09ba7a0f4..a220c1353 100644
--- a/ergon_ingestion/tests/unit/test_external_run_writer.py
+++ b/ergon_ingestion/tests/unit/test_external_run_writer.py
@@ -4,7 +4,6 @@
 import numpy as np
 from sqlmodel import SQLModel, Session, create_engine, select
 
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.samples.models import SampleAnnotationEventRow
 from ergon_core.core.persistence.telemetry.models import (
@@ -76,10 +75,10 @@ def test_external_run_writer_persists_import_spine_without_reducer_tables(tmp_pa
         session.commit()
 
         assert result.sample_id is not None
-        definition = session.exec(select(ExperimentDefinition)).one()
-        assert definition.benchmark_type == "imported:gap"
-        assert definition.metadata_json["import_batch_id"] == "paper-rq1-v1"
-        assert session.exec(select(SampleRecord)).one().instance_key == "gap-row-1"
+        run = session.exec(select(SampleRecord)).one()
+        assert run.benchmark_type == "imported:gap"
+        assert run.sample_key == "gap-row-1"
+        assert run.summary_json["import_batch_id"] == "paper-rq1-v1"
         assert session.exec(select(SampleGraphNode)).one().task_slug == "imported-root"
         assert (
             session.exec(select(SampleTaskAttempt)).one().output_json["source_run_id"]
diff --git a/ergon_ingestion/tests/unit/test_sharded_export.py b/ergon_ingestion/tests/unit/test_sharded_export.py
index e97f92560..730802555 100644
--- a/ergon_ingestion/tests/unit/test_sharded_export.py
+++ b/ergon_ingestion/tests/unit/test_sharded_export.py
@@ -52,7 +52,7 @@ def test_sharded_export_writes_parquet_manifest_state_and_resources(tmp_path: Pa
         "dataset",
         "batch",
         "sample_id",
-        "sample_id",
+        "experiment_id",
         "instance_key",
         "observed_fields_json",
         "resources_json",
diff --git a/tests/e2e/_asserts.py b/tests/e2e/_asserts.py
index 4d408ca63..b3c07ab54 100644
--- a/tests/e2e/_asserts.py
+++ b/tests/e2e/_asserts.py
@@ -484,7 +484,7 @@ def _event_index(
 # =============================================================================
 
 
-def _assert_experiment_membership(experiment: str, run_ids: list[UUID]) -> None:
+def _assert_experiment_membership(experiment: str, sample_ids: list[UUID]) -> None:
     """Runs are visible via the experiment-group test-harness endpoint."""
     api_base = os.environ["ERGON_API_BASE_URL"]
     r = httpx.get(
@@ -494,7 +494,7 @@ def _assert_experiment_membership(experiment: str, run_ids: list[UUID]) -> None:
     r.raise_for_status()
     rows = r.json()
     returned = {UUID(row["sample_id"]) for row in rows}
-    expected = set(run_ids)
+    expected = set(sample_ids)
     assert expected <= returned, f"experiment group missing expected run ids: {expected - returned}"
 
 
diff --git a/tests/e2e/_submit.py b/tests/e2e/_submit.py
index 82d3f3dd2..c7f68cfc2 100644
--- a/tests/e2e/_submit.py
+++ b/tests/e2e/_submit.py
@@ -1,6 +1,6 @@
 """Experiment-group submission helper for canonical smoke drivers.
 
-POSTs ``/api/__danger__/test-harness/write/experiment-runs`` on the api container; returns the
+POSTs ``/api/__danger__/test-harness/write/experiment-samples`` on the api container; returns the
 sample_ids in the same order as the slots passed in.
 
 Tests are a pure black-box client of the stack: they do not import any
@@ -60,7 +60,7 @@ def build_experiment_payload(
     }
 
 
-async def submit_experiment_runs(
+async def submit_experiment_samples(
     *,
     benchmark_slug: str,
     slots: list[tuple[str, str]],
@@ -93,7 +93,7 @@ async def submit_experiment_runs(
     )
     async with httpx.AsyncClient(base_url=_api_base(), timeout=30.0) as client:
         response = await client.post(
-            "/api/__danger__/test-harness/write/experiment-runs", json=payload
+            "/api/__danger__/test-harness/write/experiment-samples", json=payload
         )
         if response.status_code >= 400:
             pytest.fail(
@@ -106,4 +106,4 @@ async def submit_experiment_runs(
     return [UUID(sample_id) for sample_id in body["sample_ids"]]
 
 
-__all__ = ["build_experiment_payload", "smoke_experiment_key", "submit_experiment_runs"]
+__all__ = ["build_experiment_payload", "smoke_experiment_key", "submit_experiment_samples"]
diff --git a/tests/e2e/test_minif2f_smoke.py b/tests/e2e/test_minif2f_smoke.py
index 75a66afe0..820caea4a 100644
--- a/tests/e2e/test_minif2f_smoke.py
+++ b/tests/e2e/test_minif2f_smoke.py
@@ -31,7 +31,7 @@
     _assert_thread_messages_ordered,
     wait_for_terminal_status,
 )
-from tests.e2e._submit import submit_experiment_runs
+from tests.e2e._submit import submit_experiment_samples
 
 ENV = "minif2f"
 HAPPY_WORKER = f"{ENV}-smoke-worker"
@@ -61,7 +61,7 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
     experiment = f"ci-smoke-{ENV}-{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S')}"
     smoke_slots = _smoke_slots(EXPERIMENT_GROUP_SIZE)
 
-    run_ids = await submit_experiment_runs(
+    sample_ids = await submit_experiment_samples(
         benchmark_slug=ENV,
         slots=[(worker, criterion) for _, worker, criterion in smoke_slots],
         experiment=experiment,
@@ -69,7 +69,7 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
         dependency_extras=("none",),
         timeout=PER_RUN_TIMEOUT,
     )
-    assert len(run_ids) == len(smoke_slots)
+    assert len(sample_ids) == len(smoke_slots)
 
     await asyncio.gather(
         *(
@@ -78,17 +78,17 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
                 expected_statuses=frozenset({"completed"} if kind == "happy" else {"failed"}),
                 timeout_seconds=PER_RUN_TIMEOUT,
             )
-            for (kind, _, _), rid in zip(smoke_slots, run_ids, strict=True)
+            for (kind, _, _), rid in zip(smoke_slots, sample_ids, strict=True)
         ),
     )
 
-    for (kind, _, _), rid in zip(smoke_slots, run_ids, strict=True):
+    for (kind, _, _), rid in zip(smoke_slots, sample_ids, strict=True):
         if kind == "happy":
             _assert_happy_run(rid)
         else:
             _assert_sad_run(rid)
 
-    _assert_experiment_membership(experiment, run_ids)
+    _assert_experiment_membership(experiment, sample_ids)
 
     screenshot_dir_env = os.environ.get("SCREENSHOT_DIR")
     screenshot_dir = (
@@ -98,9 +98,9 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
     )
     _invoke_playwright(
         experiment=experiment,
-        experiment_runs=[
+        experiment_samples=[
             {"sample_id": str(rid), "kind": kind}
-            for (kind, _, _), rid in zip(smoke_slots, run_ids, strict=True)
+            for (kind, _, _), rid in zip(smoke_slots, sample_ids, strict=True)
         ],
         screenshot_dir=screenshot_dir,
     )
@@ -145,7 +145,7 @@ def _assert_sad_run(rid) -> None:
 def _invoke_playwright(
     *,
     experiment: str,
-    experiment_runs: list[dict[str, str]],
+    experiment_samples: list[dict[str, str]],
     screenshot_dir: pathlib.Path,
 ) -> None:
     screenshot_dir.mkdir(parents=True, exist_ok=True)
@@ -164,7 +164,7 @@ def _invoke_playwright(
             **os.environ,
             "EXPERIMENT_KEY": experiment,
             "SMOKE_ENV": ENV,
-            "SMOKE_EXPERIMENT_JSON": json.dumps(experiment_runs),
+            "SMOKE_EXPERIMENT_JSON": json.dumps(experiment_samples),
             "SCREENSHOT_DIR": str(screenshot_dir),
             "PLAYWRIGHT_LIVE": "1",
             "PLAYWRIGHT_BASE_URL": os.environ.get(
diff --git a/tests/e2e/test_researchrubrics_smoke.py b/tests/e2e/test_researchrubrics_smoke.py
index 98cdb839a..21f883c57 100644
--- a/tests/e2e/test_researchrubrics_smoke.py
+++ b/tests/e2e/test_researchrubrics_smoke.py
@@ -42,7 +42,7 @@
     _assert_thread_messages_ordered,
     wait_for_terminal_status,
 )
-from tests.e2e._submit import submit_experiment_runs
+from tests.e2e._submit import submit_experiment_samples
 
 ENV = "researchrubrics"
 HAPPY_WORKER = f"{ENV}-smoke-worker"
@@ -73,7 +73,7 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
     experiment = f"ci-smoke-{ENV}-{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S')}"
     smoke_slots = _smoke_slots(EXPERIMENT_GROUP_SIZE)
 
-    run_ids = await submit_experiment_runs(
+    sample_ids = await submit_experiment_samples(
         benchmark_slug=ENV,
         slots=[(worker, criterion) for _, worker, criterion in smoke_slots],
         experiment=experiment,
@@ -81,7 +81,7 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
         dependency_extras=("none",),
         timeout=PER_RUN_TIMEOUT,
     )
-    assert len(run_ids) == len(smoke_slots)
+    assert len(sample_ids) == len(smoke_slots)
 
     await asyncio.gather(
         *(
@@ -90,17 +90,17 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
                 expected_statuses=frozenset({"completed"} if kind == "happy" else {"failed"}),
                 timeout_seconds=PER_RUN_TIMEOUT,
             )
-            for (kind, _, _), rid in zip(smoke_slots, run_ids, strict=True)
+            for (kind, _, _), rid in zip(smoke_slots, sample_ids, strict=True)
         ),
     )
 
-    for (kind, _, _), rid in zip(smoke_slots, run_ids, strict=True):
+    for (kind, _, _), rid in zip(smoke_slots, sample_ids, strict=True):
         if kind == "happy":
             _assert_happy_run(rid)
         else:
             _assert_sad_run(rid)
 
-    _assert_experiment_membership(experiment, run_ids)
+    _assert_experiment_membership(experiment, sample_ids)
 
     screenshot_dir_env = os.environ.get("SCREENSHOT_DIR")
     screenshot_dir = (
@@ -110,9 +110,9 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
     )
     _invoke_playwright(
         experiment=experiment,
-        experiment_runs=[
+        experiment_samples=[
             {"sample_id": str(rid), "kind": kind}
-            for (kind, _, _), rid in zip(smoke_slots, run_ids, strict=True)
+            for (kind, _, _), rid in zip(smoke_slots, sample_ids, strict=True)
         ],
         screenshot_dir=screenshot_dir,
     )
@@ -156,7 +156,7 @@ def _assert_sad_run(rid) -> None:
 def _invoke_playwright(
     *,
     experiment: str,
-    experiment_runs: list[dict[str, str]],
+    experiment_samples: list[dict[str, str]],
     screenshot_dir: pathlib.Path,
 ) -> None:
     """Launch the researchrubrics smoke Playwright spec as a subprocess.
@@ -182,7 +182,7 @@ def _invoke_playwright(
             **os.environ,
             "EXPERIMENT_KEY": experiment,
             "SMOKE_ENV": ENV,
-            "SMOKE_EXPERIMENT_JSON": json.dumps(experiment_runs),
+            "SMOKE_EXPERIMENT_JSON": json.dumps(experiment_samples),
             "SCREENSHOT_DIR": str(screenshot_dir),
             "PLAYWRIGHT_LIVE": "1",
             "PLAYWRIGHT_BASE_URL": os.environ.get(
diff --git a/tests/e2e/test_swebench_smoke.py b/tests/e2e/test_swebench_smoke.py
index adf184e40..7ac22cb92 100644
--- a/tests/e2e/test_swebench_smoke.py
+++ b/tests/e2e/test_swebench_smoke.py
@@ -31,7 +31,7 @@
     _assert_thread_messages_ordered,
     wait_for_terminal_status,
 )
-from tests.e2e._submit import submit_experiment_runs
+from tests.e2e._submit import submit_experiment_samples
 
 # Benchmark slug is 'swebench-verified' (matches BENCHMARKS registry);
 # worker + criterion slugs use 'swebench' (shorter).  The per-env
@@ -66,7 +66,7 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
     experiment = f"ci-smoke-{ENV}-{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S')}"
     smoke_slots = _smoke_slots(EXPERIMENT_GROUP_SIZE)
 
-    run_ids = await submit_experiment_runs(
+    sample_ids = await submit_experiment_samples(
         benchmark_slug=ENV,
         slots=[(worker, criterion) for _, worker, criterion in smoke_slots],
         experiment=experiment,
@@ -74,7 +74,7 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
         dependency_extras=("none",),
         timeout=PER_RUN_TIMEOUT,
     )
-    assert len(run_ids) == len(smoke_slots)
+    assert len(sample_ids) == len(smoke_slots)
 
     await asyncio.gather(
         *(
@@ -83,17 +83,17 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
                 expected_statuses=frozenset({"completed"} if kind == "happy" else {"failed"}),
                 timeout_seconds=PER_RUN_TIMEOUT,
             )
-            for (kind, _, _), rid in zip(smoke_slots, run_ids, strict=True)
+            for (kind, _, _), rid in zip(smoke_slots, sample_ids, strict=True)
         ),
     )
 
-    for (kind, _, _), rid in zip(smoke_slots, run_ids, strict=True):
+    for (kind, _, _), rid in zip(smoke_slots, sample_ids, strict=True):
         if kind == "happy":
             _assert_happy_run(rid)
         else:
             _assert_sad_run(rid)
 
-    _assert_experiment_membership(experiment, run_ids)
+    _assert_experiment_membership(experiment, sample_ids)
 
     screenshot_dir_env = os.environ.get("SCREENSHOT_DIR")
     screenshot_dir = (
@@ -103,9 +103,9 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
     )
     _invoke_playwright(
         experiment=experiment,
-        experiment_runs=[
+        experiment_samples=[
             {"sample_id": str(rid), "kind": kind}
-            for (kind, _, _), rid in zip(smoke_slots, run_ids, strict=True)
+            for (kind, _, _), rid in zip(smoke_slots, sample_ids, strict=True)
         ],
         screenshot_dir=screenshot_dir,
     )
@@ -150,7 +150,7 @@ def _assert_sad_run(rid) -> None:
 def _invoke_playwright(
     *,
     experiment: str,
-    experiment_runs: list[dict[str, str]],
+    experiment_samples: list[dict[str, str]],
     screenshot_dir: pathlib.Path,
 ) -> None:
     screenshot_dir.mkdir(parents=True, exist_ok=True)
@@ -169,7 +169,7 @@ def _invoke_playwright(
             **os.environ,
             "EXPERIMENT_KEY": experiment,
             "SMOKE_ENV": ENV,
-            "SMOKE_EXPERIMENT_JSON": json.dumps(experiment_runs),
+            "SMOKE_EXPERIMENT_JSON": json.dumps(experiment_samples),
             "SCREENSHOT_DIR": str(screenshot_dir),
             "PLAYWRIGHT_LIVE": "1",
             "PLAYWRIGHT_BASE_URL": os.environ.get(
diff --git a/tests/fixtures/smoke_components/benchmarks.py b/tests/fixtures/smoke_components/benchmarks.py
index 3c210e198..9f87ffc1d 100644
--- a/tests/fixtures/smoke_components/benchmarks.py
+++ b/tests/fixtures/smoke_components/benchmarks.py
@@ -12,7 +12,6 @@
 
 from ergon_core.api.benchmark import (
     Benchmark,
-    BenchmarkRequirements,
     EmptyTaskPayload,
     Task,
 )
@@ -116,7 +115,6 @@ class _SingleTaskSmokeBenchmark(Benchmark):
     of ``object-bound Task`` no longer fans out from this module.
     """
 
-    onboarding_deps: ClassVar[BenchmarkRequirements] = BenchmarkRequirements(e2b=True)
     task_slug: ClassVar[str]
     task_description: ClassVar[str]
     task_payload: ClassVar[JsonObject] = {}
diff --git a/tests/integration/propagation/_helpers.py b/tests/integration/propagation/_helpers.py
index f4167a91e..90c736867 100644
--- a/tests/integration/propagation/_helpers.py
+++ b/tests/integration/propagation/_helpers.py
@@ -3,7 +3,6 @@
 import time
 from uuid import UUID
 
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.persistence.samples.models import (
     SampleAnnotationEventRow,
@@ -101,20 +100,9 @@ def assert_cross_cutting_invariants(session: Session, sample_id: UUID) -> None:
 # ---------------------------------------------------------------------------
 
 
-def make_experiment_definition(session: Session) -> ExperimentDefinition:
-    """Create a minimal ExperimentDefinition row for test scaffolding."""
-    defn = ExperimentDefinition(benchmark_type="ci-propagation-test", name="ci-propagation-test")
-    session.add(defn)
-    session.flush()
-    session.refresh(defn)
-    return defn
-
-
-def make_run(session: Session, definition_id: UUID) -> SampleRecord:
+def make_run(session: Session) -> SampleRecord:
     """Create a minimal SampleRecord row for test scaffolding."""
     run = SampleRecord(
-        definition_id=definition_id,
-        workflow_definition_id=definition_id,
         benchmark_type="ci-propagation-test",
         instance_key="test",
         status=SampleStatus.EXECUTING,
diff --git a/tests/integration/propagation/test_propagation_blocked.py b/tests/integration/propagation/test_propagation_blocked.py
index 3d4bd5204..66037ba1d 100644
--- a/tests/integration/propagation/test_propagation_blocked.py
+++ b/tests/integration/propagation/test_propagation_blocked.py
@@ -1,7 +1,6 @@
 """Tests for BLOCKED propagation semantics."""
 
 import pytest
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.application.runtime.status import BLOCKED, CANCELLED
 from ergon_core.core.persistence.shared.db import get_session
@@ -19,7 +18,6 @@
     assert_wal_has_status,
     get_node_status,
     make_edge,
-    make_experiment_definition,
     make_node,
     make_run,
     seed_linear_chain,
@@ -33,7 +31,7 @@
 # ---------------------------------------------------------------------------
 
 
-def _cleanup_run(sample_id, defn_id) -> None:  # type: ignore[no-untyped-def]
+def _cleanup_run(sample_id) -> None:  # type: ignore[no-untyped-def]
     """Remove all rows created by a test, in FK-safe order."""
     with get_session() as session:
         delete_typed_sample_wal(session, sample_id)
@@ -48,9 +46,6 @@ def _cleanup_run(sample_id, defn_id) -> None:  # type: ignore[no-untyped-def]
         run_row = session.get(SampleRecord, sample_id)
         if run_row is not None:
             session.delete(run_row)
-        defn_row = session.get(ExperimentDefinition, defn_id)
-        if defn_row is not None:
-            session.delete(defn_row)
         session.commit()
 
 
@@ -68,8 +63,7 @@ async def test_3_failure_cascade_successor_blocked() -> None:
     - WAL entry for C records BLOCKED status.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         # A seeded completed; B seeded pending; C pending — WAL stamps below set definitive statuses
         node_a, node_b, node_c = seed_linear_chain(
             session,
@@ -79,7 +73,6 @@ async def test_3_failure_cascade_successor_blocked() -> None:
             rest_status="pending",
         )
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         node_c_id = node_c.task_id
@@ -110,7 +103,6 @@ async def test_3_failure_cascade_successor_blocked() -> None:
         await svc.propagate_failure(
             PropagateTaskCompletionCommand(
                 sample_id=sample_id,
-                definition_id=defn_id,
                 task_id=node_b_id,
                 execution_id=node_b_id,
             )
@@ -137,7 +129,7 @@ async def test_3_failure_cascade_successor_blocked() -> None:
             assert_cross_cutting_invariants(session, sample_id)
 
     finally:
-        _cleanup_run(sample_id, defn_id)
+        _cleanup_run(sample_id)
 
 
 # ---------------------------------------------------------------------------
@@ -155,8 +147,7 @@ async def test_7_parent_failure_children_blocked() -> None:
     auto-managed (not left pending for a manager).
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         parent_node = make_node(session, run.id, task_slug="parent", status="running")
         child_a = make_node(session, run.id, task_slug="child-a", status="pending")
         child_b = make_node(session, run.id, task_slug="child-b", status="pending")
@@ -177,7 +168,6 @@ async def test_7_parent_failure_children_blocked() -> None:
             session, run.id, source_task_id=parent_node.task_id, target_task_id=child_d.task_id
         )
         sample_id = run.id
-        defn_id = defn.id
         parent_task_id = parent_node.task_id
         child_a_id = child_a.task_id
         child_b_id = child_b.task_id
@@ -215,7 +205,6 @@ async def test_7_parent_failure_children_blocked() -> None:
         await svc.propagate_failure(
             PropagateTaskCompletionCommand(
                 sample_id=sample_id,
-                definition_id=defn_id,
                 task_id=parent_task_id,
                 execution_id=parent_task_id,
             )
@@ -256,7 +245,7 @@ async def test_7_parent_failure_children_blocked() -> None:
             assert_cross_cutting_invariants(session, sample_id)
 
     finally:
-        _cleanup_run(sample_id, defn_id)
+        _cleanup_run(sample_id)
 
 
 # ---------------------------------------------------------------------------
@@ -272,8 +261,7 @@ async def test_10_blocked_propagates_transitively() -> None:
     not just one level deep.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a, node_b, node_c = seed_linear_chain(
             session,
             run.id,
@@ -282,7 +270,6 @@ async def test_10_blocked_propagates_transitively() -> None:
             rest_status="pending",
         )
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         node_c_id = node_c.task_id
@@ -304,7 +291,6 @@ async def test_10_blocked_propagates_transitively() -> None:
         await svc.propagate_failure(
             PropagateTaskCompletionCommand(
                 sample_id=sample_id,
-                definition_id=defn_id,
                 task_id=node_a_id,
                 execution_id=node_a_id,
             )
@@ -336,7 +322,7 @@ async def test_10_blocked_propagates_transitively() -> None:
             assert_cross_cutting_invariants(session, sample_id)
 
     finally:
-        _cleanup_run(sample_id, defn_id)
+        _cleanup_run(sample_id)
 
 
 # ---------------------------------------------------------------------------
@@ -352,13 +338,11 @@ async def test_12_running_successor_not_interrupted() -> None:
     must not interrupt it by writing BLOCKED or CANCELLED over a RUNNING node.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="task-a", status="failed")
         node_b = make_node(session, run.id, task_slug="task-b", status="running")
         make_edge(session, run.id, source_task_id=node_a.task_id, target_task_id=node_b.task_id)
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         session.commit()
@@ -386,7 +370,6 @@ async def test_12_running_successor_not_interrupted() -> None:
         await svc.propagate_failure(
             PropagateTaskCompletionCommand(
                 sample_id=sample_id,
-                definition_id=defn_id,
                 task_id=node_a_id,
                 execution_id=node_a_id,
             )
@@ -412,4 +395,4 @@ async def test_12_running_successor_not_interrupted() -> None:
             assert_cross_cutting_invariants(session, sample_id)
 
     finally:
-        _cleanup_run(sample_id, defn_id)
+        _cleanup_run(sample_id)
diff --git a/tests/integration/propagation/test_propagation_cancel.py b/tests/integration/propagation/test_propagation_cancel.py
index 7af37769e..d76485e75 100644
--- a/tests/integration/propagation/test_propagation_cancel.py
+++ b/tests/integration/propagation/test_propagation_cancel.py
@@ -9,7 +9,6 @@
 """
 
 import pytest
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.application.runtime.status import CANCELLED
 from ergon_core.core.persistence.shared.db import get_session
@@ -24,7 +23,6 @@
     delete_typed_sample_wal,
     assert_wal_has_status,
     get_node_status,
-    make_experiment_definition,
     make_node,
     make_run,
 )
@@ -36,7 +34,7 @@
 # ---------------------------------------------------------------------------
 
 
-def _cleanup_run(sample_id, defn_id) -> None:  # type: ignore[no-untyped-def]
+def _cleanup_run(sample_id) -> None:  # type: ignore[no-untyped-def]
     with get_session() as session:
         delete_typed_sample_wal(session, sample_id)
         for edge in session.exec(
@@ -50,9 +48,6 @@ def _cleanup_run(sample_id, defn_id) -> None:  # type: ignore[no-untyped-def]
         run_row = session.get(SampleRecord, sample_id)
         if run_row is not None:
             session.delete(run_row)
-        defn_row = session.get(ExperimentDefinition, defn_id)
-        if defn_row is not None:
-            session.delete(defn_row)
         session.commit()
 
 
@@ -70,11 +65,9 @@ async def test_6_manager_decision_cancel_pending_node() -> None:
     Expected to pass with current code (cancellation is implemented).
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="cancel-target", status="pending")
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         session.commit()
 
@@ -122,7 +115,7 @@ async def test_6_manager_decision_cancel_pending_node() -> None:
             assert_cross_cutting_invariants(session, sample_id)
 
     finally:
-        _cleanup_run(sample_id, defn_id)
+        _cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
@@ -134,11 +127,9 @@ async def test_6b_cancel_does_not_affect_already_terminal_node() -> None:
     Expected to pass with current code.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="already-completed", status="completed")
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         session.commit()
 
@@ -180,4 +171,4 @@ async def test_6b_cancel_does_not_affect_already_terminal_node() -> None:
             assert_cross_cutting_invariants(session, sample_id)
 
     finally:
-        _cleanup_run(sample_id, defn_id)
+        _cleanup_run(sample_id)
diff --git a/tests/integration/propagation/test_propagation_edge_cases.py b/tests/integration/propagation/test_propagation_edge_cases.py
index 51daebd27..5a683006c 100644
--- a/tests/integration/propagation/test_propagation_edge_cases.py
+++ b/tests/integration/propagation/test_propagation_edge_cases.py
@@ -5,7 +5,6 @@
 """
 
 import pytest
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.application.runtime.status import BLOCKED, CANCELLED
 from ergon_core.core.persistence.shared.db import get_session
@@ -23,7 +22,6 @@
     assert_wal_has_status,
     get_node_status,
     make_edge,
-    make_experiment_definition,
     make_node,
     make_run,
 )
@@ -35,7 +33,7 @@
 # ---------------------------------------------------------------------------
 
 
-def _cleanup_run(sample_id, defn_id) -> None:  # type: ignore[no-untyped-def]
+def _cleanup_run(sample_id) -> None:  # type: ignore[no-untyped-def]
     with get_session() as session:
         delete_typed_sample_wal(session, sample_id)
         for edge in session.exec(
@@ -62,9 +60,6 @@ def _cleanup_run(sample_id, defn_id) -> None:  # type: ignore[no-untyped-def]
         run_row = session.get(SampleRecord, sample_id)
         if run_row is not None:
             session.delete(run_row)
-        defn_row = session.get(ExperimentDefinition, defn_id)
-        if defn_row is not None:
-            session.delete(defn_row)
         session.commit()
 
 
@@ -91,15 +86,13 @@ async def test_ec1_fan_in_one_dep_fails_target_blocked() -> None:
       3. C cannot start (one dep failed) → must be BLOCKED.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="fan-a", status="running")
         node_b = make_node(session, run.id, task_slug="fan-b", status="running")
         node_c = make_node(session, run.id, task_slug="fan-c", status="pending")
         make_edge(session, run.id, source_task_id=node_a.task_id, target_task_id=node_c.task_id)
         make_edge(session, run.id, source_task_id=node_b.task_id, target_task_id=node_c.task_id)
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         node_c_id = node_c.task_id
@@ -130,7 +123,6 @@ async def test_ec1_fan_in_one_dep_fails_target_blocked() -> None:
         await svc.propagate_failure(
             PropagateTaskCompletionCommand(
                 sample_id=sample_id,
-                definition_id=defn_id,
                 task_id=node_a_id,
                 execution_id=node_a_id,
             )
@@ -140,7 +132,6 @@ async def test_ec1_fan_in_one_dep_fails_target_blocked() -> None:
         await svc.propagate(
             PropagateTaskCompletionCommand(
                 sample_id=sample_id,
-                definition_id=defn_id,
                 task_id=node_b_id,
                 execution_id=node_b_id,
             )
@@ -166,7 +157,7 @@ async def test_ec1_fan_in_one_dep_fails_target_blocked() -> None:
             assert_cross_cutting_invariants(session, sample_id)
 
     finally:
-        _cleanup_run(sample_id, defn_id)
+        _cleanup_run(sample_id)
 
 
 # ---------------------------------------------------------------------------
@@ -184,13 +175,11 @@ async def test_ec2_duplicate_propagate_is_idempotent() -> None:
     Expected to PASS with current code — no xfail.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="idem-a", status="running")
         node_b = make_node(session, run.id, task_slug="idem-b", status="pending")
         make_edge(session, run.id, source_task_id=node_a.task_id, target_task_id=node_b.task_id)
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         session.commit()
@@ -211,7 +200,6 @@ async def test_ec2_duplicate_propagate_is_idempotent() -> None:
 
         command = PropagateTaskCompletionCommand(
             sample_id=sample_id,
-            definition_id=defn_id,
             task_id=node_a_id,
             execution_id=node_a_id,
         )
@@ -246,4 +234,4 @@ async def test_ec2_duplicate_propagate_is_idempotent() -> None:
             assert_cross_cutting_invariants(session, sample_id)
 
     finally:
-        _cleanup_run(sample_id, defn_id)
+        _cleanup_run(sample_id)
diff --git a/tests/integration/propagation/test_propagation_happy.py b/tests/integration/propagation/test_propagation_happy.py
index 8ebe10c03..4f8b39a4b 100644
--- a/tests/integration/propagation/test_propagation_happy.py
+++ b/tests/integration/propagation/test_propagation_happy.py
@@ -7,7 +7,6 @@
 """
 
 import pytest
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.persistence.shared.db import get_engine, get_session
 from ergon_core.core.persistence.shared.enums import SampleStatus, TaskExecutionStatus
@@ -25,7 +24,6 @@
     delete_typed_sample_wal,
     assert_wal_has_status,
     get_node_status,
-    make_experiment_definition,
     make_node,
     make_run,
 )
@@ -59,7 +57,7 @@ def _skip_if_db_unreachable() -> None:
 # ---------------------------------------------------------------------------
 
 
-def _cleanup_run(sample_id, defn_id) -> None:  # type: ignore[no-untyped-def]
+def _cleanup_run(sample_id) -> None:  # type: ignore[no-untyped-def]
     """Remove all rows created by a test, in FK-safe order."""
     with get_session() as session:
         delete_typed_sample_wal(session, sample_id)
@@ -74,9 +72,6 @@ def _cleanup_run(sample_id, defn_id) -> None:  # type: ignore[no-untyped-def]
         run_row = session.get(SampleRecord, sample_id)
         if run_row is not None:
             session.delete(run_row)
-        defn_row = session.get(ExperimentDefinition, defn_id)
-        if defn_row is not None:
-            session.delete(defn_row)
         session.commit()
 
 
@@ -93,11 +88,9 @@ async def test_1_single_task_happy_path() -> None:
     WorkflowService.propagate(). Expected to pass with current code.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="task-a", status="running")
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         session.commit()
 
@@ -119,7 +112,6 @@ async def test_1_single_task_happy_path() -> None:
         await svc.propagate(
             PropagateTaskCompletionCommand(
                 sample_id=sample_id,
-                definition_id=defn_id,
                 task_id=node_a_id,
                 execution_id=node_a_id,
             )
@@ -144,4 +136,4 @@ async def test_1_single_task_happy_path() -> None:
         with get_session() as session:
             assert_cross_cutting_invariants(session, sample_id)
     finally:
-        _cleanup_run(sample_id, defn_id)
+        _cleanup_run(sample_id)
diff --git a/tests/integration/propagation/test_propagation_restart.py b/tests/integration/propagation/test_propagation_restart.py
index e89c6903e..063af0dec 100644
--- a/tests/integration/propagation/test_propagation_restart.py
+++ b/tests/integration/propagation/test_propagation_restart.py
@@ -22,7 +22,6 @@
     delete_typed_sample_wal,
     get_node_status,
     make_edge,
-    make_experiment_definition,
     make_node,
     make_run,
 )
@@ -45,13 +44,11 @@ async def test_8_blocked_node_cannot_be_restarted() -> None:
     raising TaskNotTerminalError for anything else.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="task-a-failed", status="failed")
         node_b = make_node(session, run.id, task_slug="task-b-blocked", status=BLOCKED)
         make_edge(session, run.id, source_task_id=node_a.task_id, target_task_id=node_b.task_id)
         sample_id = run.id
-        defn_id = defn.id
         node_b_id = node_b.task_id
         session.commit()
 
@@ -67,7 +64,7 @@ async def test_8_blocked_node_cannot_be_restarted() -> None:
                         RestartTaskCommand(sample_id=sample_id, task_id=node_b_id),
                     )
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
@@ -78,11 +75,9 @@ async def test_8b_restart_failed_node_re_enters_pending() -> None:
     so it can be re-scheduled for execution.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="task-a-to-restart", status="failed")
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         session.commit()
 
@@ -104,4 +99,4 @@ async def test_8b_restart_failed_node_re_enters_pending() -> None:
             )
 
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
diff --git a/tests/integration/restart/_helpers.py b/tests/integration/restart/_helpers.py
index 232f5745b..196500e3d 100644
--- a/tests/integration/restart/_helpers.py
+++ b/tests/integration/restart/_helpers.py
@@ -2,7 +2,6 @@
 
 from uuid import UUID
 
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.persistence.shared.db import get_session
 from ergon_core.core.persistence.telemetry.models import SampleRecord
@@ -10,7 +9,7 @@
 from tests.integration.propagation._helpers import delete_typed_sample_wal
 
 
-def cleanup_run(sample_id: UUID, defn_id: UUID) -> None:
+def cleanup_run(sample_id: UUID) -> None:
     with get_session() as session:
         delete_typed_sample_wal(session, sample_id)
         for edge in session.exec(
@@ -37,9 +36,6 @@ def cleanup_run(sample_id: UUID, defn_id: UUID) -> None:
         run_row = session.get(SampleRecord, sample_id)
         if run_row is not None:
             session.delete(run_row)
-        defn_row = session.get(ExperimentDefinition, defn_id)
-        if defn_row is not None:
-            session.delete(defn_row)
         session.commit()
 
 
diff --git a/tests/integration/restart/test_downstream_invalidation.py b/tests/integration/restart/test_downstream_invalidation.py
index 53e9efb00..439fe829b 100644
--- a/tests/integration/restart/test_downstream_invalidation.py
+++ b/tests/integration/restart/test_downstream_invalidation.py
@@ -10,7 +10,6 @@
 from unittest.mock import AsyncMock, patch
 
 import pytest
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.application.runtime.status import (
     CANCELLED,
@@ -27,7 +26,6 @@
 from tests.integration.propagation._helpers import (
     get_node_status,
     make_edge,
-    make_experiment_definition,
     make_node,
     make_run,
 )
@@ -48,8 +46,7 @@ async def test_completed_successor_is_cancelled_by_invalidation() -> None:
     be cancelled by _invalidate_downstream.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="task-a", status="completed")
         node_b = make_node(session, run.id, task_slug="task-b", status="completed")
         make_edge(
@@ -60,7 +57,6 @@ async def test_completed_successor_is_cancelled_by_invalidation() -> None:
             status=EDGE_SATISFIED,
         )
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         session.commit()
@@ -89,7 +85,7 @@ async def test_completed_successor_is_cancelled_by_invalidation() -> None:
                 "Edge A→B must be reset to EDGE_PENDING so re-run of A can re-satisfy it"
             )
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
@@ -100,8 +96,7 @@ async def test_pending_successor_is_cancelled_but_cascade_stops_there() -> None:
     stops. C is not invalidated because B never completed.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="task-a", status="completed")
         node_b = make_node(session, run.id, task_slug="task-b", status="pending")
         node_c = make_node(session, run.id, task_slug="task-c", status="completed")
@@ -120,7 +115,6 @@ async def test_pending_successor_is_cancelled_but_cascade_stops_there() -> None:
             status=EDGE_SATISFIED,
         )
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         node_c_id = node_c.task_id
@@ -150,7 +144,7 @@ async def test_pending_successor_is_cancelled_but_cascade_stops_there() -> None:
                 "C must remain COMPLETED — cascade does not recurse through non-terminal B"
             )
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
@@ -162,8 +156,7 @@ async def test_failed_and_cancelled_successors_are_skipped() -> None:
     are reset to EDGE_PENDING.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="task-a", status="completed")
         node_b = make_node(session, run.id, task_slug="task-b-failed", status="failed")
         node_c = make_node(session, run.id, task_slug="task-c-cancelled", status=CANCELLED)
@@ -182,7 +175,6 @@ async def test_failed_and_cancelled_successors_are_skipped() -> None:
             status=EDGE_SATISFIED,
         )
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         node_c_id = node_c.task_id
@@ -218,7 +210,7 @@ async def test_failed_and_cancelled_successors_are_skipped() -> None:
                 "A→C edge must be reset to EDGE_PENDING so C can be retried later"
             )
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
@@ -229,8 +221,7 @@ async def test_cascade_invalidation_recurses_through_completed_chain() -> None:
     downstream chain is invalidated, not just the immediate successor.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="chain-a", status="completed")
         node_b = make_node(session, run.id, task_slug="chain-b", status="completed")
         node_c = make_node(session, run.id, task_slug="chain-c", status="completed")
@@ -249,7 +240,6 @@ async def test_cascade_invalidation_recurses_through_completed_chain() -> None:
             status=EDGE_SATISFIED,
         )
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         node_c_id = node_c.task_id
@@ -284,4 +274,4 @@ async def test_cascade_invalidation_recurses_through_completed_chain() -> None:
                 "B→C edge must also be reset to EDGE_PENDING by the cascade"
             )
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
diff --git a/tests/integration/restart/test_manager_dag_scenario.py b/tests/integration/restart/test_manager_dag_scenario.py
index 4d7d5f5e7..28e6db910 100644
--- a/tests/integration/restart/test_manager_dag_scenario.py
+++ b/tests/integration/restart/test_manager_dag_scenario.py
@@ -32,7 +32,6 @@
 from tests.integration.propagation._helpers import (
     get_node_status,
     make_edge,
-    make_experiment_definition,
     make_node,
     make_run,
 )
@@ -63,8 +62,7 @@ async def test_diamond_restart_invalidates_fanin_and_reactivates_on_recompletion
       - task_b remains COMPLETED throughout
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         root = make_node(session, run.id, task_slug="root", status="completed")
         task_a = make_node(
             session,
@@ -102,7 +100,6 @@ async def test_diamond_restart_invalidates_fanin_and_reactivates_on_recompletion
             status="satisfied",
         )
         sample_id = run.id
-        defn_id = defn.id
         task_a_id = task_a.task_id
         task_b_id = task_b.task_id
         task_c_id = task_c.task_id
@@ -159,7 +156,6 @@ async def test_diamond_restart_invalidates_fanin_and_reactivates_on_recompletion
         await prop_svc.propagate(
             PropagateTaskCompletionCommand(
                 sample_id=sample_id,
-                definition_id=defn_id,
                 task_id=task_a_id,
                 execution_id=task_a_id,
             )
@@ -175,4 +171,4 @@ async def test_diamond_restart_invalidates_fanin_and_reactivates_on_recompletion
             )
 
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
diff --git a/tests/integration/restart/test_reactivation.py b/tests/integration/restart/test_reactivation.py
index cba005b09..97b7947a3 100644
--- a/tests/integration/restart/test_reactivation.py
+++ b/tests/integration/restart/test_reactivation.py
@@ -12,7 +12,6 @@
 """
 
 import pytest
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.application.runtime.status import CANCELLED, EDGE_PENDING
 from ergon_core.core.persistence.shared.db import get_session
@@ -25,7 +24,6 @@
 from tests.integration.propagation._helpers import (
     get_node_status,
     make_edge,
-    make_experiment_definition,
     make_node,
     make_run,
 )
@@ -43,8 +41,7 @@ async def test_cancelled_managed_subtask_reactivates_when_dep_completes() -> Non
     re-activate node_b back to PENDING.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         root = make_node(session, run.id, task_slug="root", status="running")
         node_a = make_node(session, run.id, task_slug="task-a", status="completed")
         # node_b is a managed subtask — parent_task_id makes it eligible for re-activation
@@ -58,7 +55,6 @@ async def test_cancelled_managed_subtask_reactivates_when_dep_completes() -> Non
         # Edge is EDGE_PENDING: reset by restart_task / _invalidate_downstream
         make_edge(session, run.id, source_task_id=node_a.task_id, target_task_id=node_b.task_id)
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         session.commit()
@@ -68,7 +64,6 @@ async def test_cancelled_managed_subtask_reactivates_when_dep_completes() -> Non
         await svc.propagate(
             PropagateTaskCompletionCommand(
                 sample_id=sample_id,
-                definition_id=defn_id,
                 task_id=node_a_id,
                 execution_id=node_a_id,
             )
@@ -81,7 +76,7 @@ async def test_cancelled_managed_subtask_reactivates_when_dep_completes() -> Non
                 f"got {b_status!r}"
             )
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
@@ -92,14 +87,12 @@ async def test_cancelled_static_node_does_not_reactivate() -> None:
     Only managed subtasks (with parent_task_id) are eligible for re-activation.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="task-a", status="completed")
         # node_b is a static node — parent_task_id=None (default)
         node_b = make_node(session, run.id, task_slug="task-b-static", status=CANCELLED)
         make_edge(session, run.id, source_task_id=node_a.task_id, target_task_id=node_b.task_id)
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         session.commit()
@@ -109,7 +102,6 @@ async def test_cancelled_static_node_does_not_reactivate() -> None:
         await svc.propagate(
             PropagateTaskCompletionCommand(
                 sample_id=sample_id,
-                definition_id=defn_id,
                 task_id=node_a_id,
                 execution_id=node_a_id,
             )
@@ -122,7 +114,7 @@ async def test_cancelled_static_node_does_not_reactivate() -> None:
                 f"only managed subtasks re-activate. Got {b_status!r}"
             )
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
@@ -135,8 +127,7 @@ async def test_fan_in_managed_subtask_reactivates_only_when_all_deps_complete()
     COMPLETED does re-activate C, and verify the all-deps check works.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         root = make_node(session, run.id, task_slug="root", status="running")
         node_a = make_node(session, run.id, task_slug="fan-a", status="completed")
         # B is not yet completed when we propagate A — verify C stays CANCELLED
@@ -151,7 +142,6 @@ async def test_fan_in_managed_subtask_reactivates_only_when_all_deps_complete()
         make_edge(session, run.id, source_task_id=node_a.task_id, target_task_id=node_c.task_id)
         make_edge(session, run.id, source_task_id=node_b.task_id, target_task_id=node_c.task_id)
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         node_c_id = node_c.task_id
@@ -164,7 +154,6 @@ async def test_fan_in_managed_subtask_reactivates_only_when_all_deps_complete()
         await svc.propagate(
             PropagateTaskCompletionCommand(
                 sample_id=sample_id,
-                definition_id=defn_id,
                 task_id=node_a_id,
                 execution_id=node_a_id,
             )
@@ -181,7 +170,6 @@ async def test_fan_in_managed_subtask_reactivates_only_when_all_deps_complete()
         await svc.propagate(
             PropagateTaskCompletionCommand(
                 sample_id=sample_id,
-                definition_id=defn_id,
                 task_id=node_b_id,
                 execution_id=node_b_id,
             )
@@ -193,4 +181,4 @@ async def test_fan_in_managed_subtask_reactivates_only_when_all_deps_complete()
                 f"C must re-activate to PENDING once both A and B are COMPLETED; got {c_status!r}"
             )
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
diff --git a/tests/integration/restart/test_restart_task.py b/tests/integration/restart/test_restart_task.py
index 1c99cc0ee..78aeda7ab 100644
--- a/tests/integration/restart/test_restart_task.py
+++ b/tests/integration/restart/test_restart_task.py
@@ -10,7 +10,6 @@
 from unittest.mock import AsyncMock, patch
 
 import pytest
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
 from ergon_core.core.persistence.graph.models import SampleGraphEdge, SampleGraphNode
 from ergon_core.core.application.runtime.status import (
     CANCELLED,
@@ -32,7 +31,6 @@
     assert_wal_has_status,
     get_node_status,
     make_edge,
-    make_experiment_definition,
     make_node,
     make_run,
 )
@@ -52,8 +50,7 @@ async def test_restart_completed_node_becomes_pending_and_resets_edge() -> None:
     that the return value reports the correct old_status.
     """
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="task-a", status="completed")
         node_b = make_node(session, run.id, task_slug="task-b", status="pending")
         make_edge(
@@ -64,7 +61,6 @@ async def test_restart_completed_node_becomes_pending_and_resets_edge() -> None:
             status=EDGE_SATISFIED,
         )
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         node_b_id = node_b.task_id
         session.commit()
@@ -93,18 +89,16 @@ async def test_restart_completed_node_becomes_pending_and_resets_edge() -> None:
                 f"Edge A→B must be reset to EDGE_PENDING after restart; got {edge_st!r}"
             )
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
 async def test_restart_failed_node_becomes_pending() -> None:
     """Restarting a FAILED node transitions it to PENDING."""
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="failed-task", status="failed")
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         session.commit()
 
@@ -123,18 +117,16 @@ async def test_restart_failed_node_becomes_pending() -> None:
         with get_session() as session:
             assert get_node_status(session, node_a_id) == TaskExecutionStatus.PENDING
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
 async def test_restart_cancelled_node_becomes_pending() -> None:
     """Restarting a CANCELLED node transitions it to PENDING."""
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="cancelled-task", status=CANCELLED)
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         session.commit()
 
@@ -153,18 +145,16 @@ async def test_restart_cancelled_node_becomes_pending() -> None:
         with get_session() as session:
             assert get_node_status(session, node_a_id) == TaskExecutionStatus.PENDING
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
 async def test_restart_pending_node_raises() -> None:
     """Restarting a PENDING node raises TaskNotTerminalError."""
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="pending-task", status="pending")
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         session.commit()
 
@@ -180,18 +170,16 @@ async def test_restart_pending_node_raises() -> None:
                         RestartTaskCommand(sample_id=sample_id, task_id=node_a_id),
                     )
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
 async def test_restart_running_node_raises() -> None:
     """Restarting a RUNNING node raises TaskNotTerminalError (RUNNING is non-terminal)."""
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="running-task", status="running")
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         session.commit()
 
@@ -207,18 +195,16 @@ async def test_restart_running_node_raises() -> None:
                         RestartTaskCommand(sample_id=sample_id, task_id=node_a_id),
                     )
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
 async def test_refine_task_non_pending_node_succeeds() -> None:
     """refine_task accepts a COMPLETED node — widened beyond PENDING for restart flow."""
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="refine-completed", status="completed")
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         session.commit()
 
@@ -239,18 +225,16 @@ async def test_refine_task_non_pending_node_succeeds() -> None:
 
         assert result.new_description == "Updated after restart"
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
 
 
 @pytest.mark.asyncio
 async def test_refine_task_running_node_raises() -> None:
     """refine_task raises TaskRunningError for a RUNNING node."""
     with get_session() as session:
-        defn = make_experiment_definition(session)
-        run = make_run(session, defn.id)
+        run = make_run(session)
         node_a = make_node(session, run.id, task_slug="refine-running", status="running")
         sample_id = run.id
-        defn_id = defn.id
         node_a_id = node_a.task_id
         session.commit()
 
@@ -270,4 +254,4 @@ async def test_refine_task_running_node_raises() -> None:
                         ),
                     )
     finally:
-        cleanup_run(sample_id, defn_id)
+        cleanup_run(sample_id)
diff --git a/tests/integration/smokes/test_smoke_harness.py b/tests/integration/smokes/test_smoke_harness.py
index 03f876941..823e138b4 100644
--- a/tests/integration/smokes/test_smoke_harness.py
+++ b/tests/integration/smokes/test_smoke_harness.py
@@ -1,7 +1,7 @@
 """Integration smoke test for the /api/__danger__/test-harness/* test-harness endpoints.
 
 Round-trips against a real running server + Postgres:
-  seed -> read state -> reset -> verify gone (404)
+  seed sample -> read state -> reset -> verify gone (404)
 
 Requires:
   - Server running at ERGON_API_BASE_URL (default http://127.0.0.1:9000).
@@ -15,8 +15,7 @@
 
 import httpx
 import pytest
-from ergon_core.core.persistence.definitions.models import ExperimentDefinition
-from ergon_core.core.persistence.shared.db import get_engine, get_session
+from ergon_core.core.persistence.shared.db import get_engine
 from sqlalchemy import text
 from sqlalchemy.exc import OperationalError
 
@@ -95,24 +94,17 @@ def _reset_before_each() -> None:
 # ---------------------------------------------------------------------------
 
 
-def test_seed_then_read_then_reset_roundtrip() -> None:
-    """Seed a run, read its state, reset it, verify 404."""
-
-    # ── Step 1: create an ExperimentDefinition via the ORM ──────────────────
-    with get_session() as session:
-        defn = ExperimentDefinition(benchmark_type="ci-smoke-harness", name="ci-smoke-harness")
-        session.add(defn)
-        session.commit()
-        session.refresh(defn)
-        defn_id = defn.id
+def test_seed_sample_then_read_then_reset_roundtrip() -> None:
+    """Seed a sample, read its state, reset it, verify 404."""
 
     try:
-        # ── Step 2: seed a sample via POST /api/__danger__/test-harness/write/samples/seed ──────────
+        # ── Step 1: seed a sample via POST /api/__danger__/test-harness/write/samples/seed ──────────
         with httpx.Client(timeout=10.0) as client:
             seed_resp = client.post(
                 f"{API}/api/__danger__/test-harness/write/samples/seed",
                 json={
-                    "definition_id": str(defn_id),
+                    "benchmark_type": "ci-smoke-harness",
+                    "instance_key": "ci-smoke-harness",
                     "experiment": _EXPERIMENT,
                     "status": "completed",
                 },
@@ -124,7 +116,7 @@ def test_seed_then_read_then_reset_roundtrip() -> None:
         sample_id = seed_resp.json()["sample_id"]
         assert sample_id  # non-empty UUID string
 
-        # ── Step 3: read state via GET /api/__danger__/test-harness/read/samples/{sample_id}/state ───
+        # ── Step 2: read state via GET /api/__danger__/test-harness/read/samples/{sample_id}/state ───
         with httpx.Client(timeout=10.0) as client:
             state_resp = client.get(
                 f"{API}/api/__danger__/test-harness/read/samples/{sample_id}/state"
@@ -135,7 +127,7 @@ def test_seed_then_read_then_reset_roundtrip() -> None:
         assert body["sample_id"] == sample_id
         assert body["status"] == "completed"
 
-        # ── Step 4: reset via POST /api/__danger__/test-harness/write/reset ─────────────────────────
+        # ── Step 3: reset via POST /api/__danger__/test-harness/write/reset ─────────────────────────
         with httpx.Client(timeout=10.0) as client:
             reset_resp = client.post(
                 f"{API}/api/__danger__/test-harness/write/reset",
@@ -144,7 +136,7 @@ def test_seed_then_read_then_reset_roundtrip() -> None:
 
         assert reset_resp.status_code == 204, reset_resp.text
 
-        # ── Step 5: confirm the sample is gone ───────────────────────────────────
+        # ── Step 4: confirm the sample is gone ───────────────────────────────────
         with httpx.Client(timeout=10.0) as client:
             gone_resp = client.get(
                 f"{API}/api/__danger__/test-harness/read/samples/{sample_id}/state"
@@ -153,28 +145,23 @@ def test_seed_then_read_then_reset_roundtrip() -> None:
         assert gone_resp.status_code == 404, gone_resp.text
 
     finally:
-        # ── Cleanup: delete seeded samples before their definition row ───────────
+        # ── Cleanup: delete seeded samples ───────────────────────────────────────
         with httpx.Client(timeout=10.0) as client:
             client.post(
                 f"{API}/api/__danger__/test-harness/write/reset",
                 json={"experiment_prefix": _EXPERIMENT_PREFIX},
             )
-        with get_session() as session:
-            row = session.get(ExperimentDefinition, defn_id)
-            if row is not None:
-                session.delete(row)
-                session.commit()
 
 
-def test_write_experiment_runs_accepts_explicit_runtime_choices() -> None:
-    """Submit grouped experiment-run endpoint accepts explicit runtime choices."""
+def test_write_experiment_samples_accepts_explicit_runtime_choices() -> None:
+    """Submit grouped experiment-sample endpoint accepts explicit runtime choices."""
     experiment = (
         f"{_EXPERIMENT_PREFIX}explicit-{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S')}"
     )
 
     with httpx.Client(timeout=10.0) as client:
         response = client.post(
-            f"{API}/api/__danger__/test-harness/write/experiment-runs",
+            f"{API}/api/__danger__/test-harness/write/experiment-samples",
             json={
                 "benchmark_slug": "minif2f",
                 "slots": [
diff --git a/tests/integration/swebench_verified/conftest.py b/tests/integration/swebench_verified/conftest.py
deleted file mode 100644
index 08101f5d8..000000000
--- a/tests/integration/swebench_verified/conftest.py
+++ /dev/null
@@ -1,121 +0,0 @@
-"""Shared fixtures for swebench_verified integration tests."""
-
-from __future__ import annotations
-
-from uuid import UUID, uuid4
-
-import pytest
-from ergon_core.core.persistence.definitions.models import (
-    ExperimentDefinition,
-    ExperimentDefinitionInstance,
-    ExperimentDefinitionTask,
-)
-from ergon_core.core.persistence.shared.db import get_session
-from ergon_core.core.persistence.shared.enums import SampleStatus, TaskExecutionStatus
-from ergon_core.core.persistence.telemetry.models import (
-    SampleRecord,
-    SampleTaskAttempt,
-)
-from sqlmodel import select
-
-_MINIMAL_SWEBENCH_PAYLOAD: dict[str, object] = {
-    "instance_id": "django__django-1",
-    "repo": "django/django",
-    "base_commit": "aaa000",
-    "version": "3.0",
-    "problem_statement": "fix it",
-    "hints_text": "",
-    "fail_to_pass": ["tests.test_app.TestCase.test_method"],
-    "pass_to_pass": [],
-    "environment_setup_commit": "aaa000",
-    "test_patch": "",
-}
-
-
-@pytest.fixture()
-def swebench_execution() -> tuple[UUID, UUID]:
-    """Seed the minimal FK chain needed by SWEBenchSandboxManager._install_dependencies.
-
-    Seeds: ExperimentDefinition → ExperimentDefinitionInstance →
-    ExperimentDefinitionTask + SampleRecord → SampleTaskAttempt(id=execution_id).
-
-    Yields (execution_id, sample_id) so tests can pass execution_id as
-    sandbox_key and sample_id as sample_id to mgr.create().
-
-    Cleans up all seeded rows after the test.
-    """
-    execution_id = uuid4()
-
-    with get_session() as session:
-        defn = ExperimentDefinition(benchmark_type="swebench-verified", name="swebench-verified")
-        session.add(defn)
-        session.flush()
-        session.refresh(defn)
-
-        instance = ExperimentDefinitionInstance(
-            experiment_definition_id=defn.id,
-            instance_key="django__django-1",
-        )
-        session.add(instance)
-        session.flush()
-        session.refresh(instance)
-
-        task = ExperimentDefinitionTask(
-            experiment_definition_id=defn.id,
-            instance_id=instance.id,
-            task_slug="django__django-1",
-            description="swebench sandbox manager test task",
-            task_payload_json=dict(_MINIMAL_SWEBENCH_PAYLOAD),
-        )
-        session.add(task)
-        session.flush()
-        session.refresh(task)
-
-        run = SampleRecord(
-            definition_id=defn.id,
-            workflow_definition_id=defn.id,
-            benchmark_type="swebench-verified",
-            instance_key="django__django-1",
-            status=SampleStatus.EXECUTING,
-        )
-        session.add(run)
-        session.flush()
-        session.refresh(run)
-
-        execution = SampleTaskAttempt(
-            id=execution_id,
-            sample_id=run.id,
-            task_id=task.id,
-            status=TaskExecutionStatus.RUNNING,
-        )
-        session.add(execution)
-        session.commit()
-
-        sample_id: UUID = run.id
-        defn_id: UUID = defn.id
-
-    yield execution_id, sample_id
-
-    with get_session() as session:
-        exec_row = session.get(SampleTaskAttempt, execution_id)
-        if exec_row is not None:
-            session.delete(exec_row)
-        run_row = session.get(SampleRecord, sample_id)
-        if run_row is not None:
-            session.delete(run_row)
-        for t in session.exec(
-            select(ExperimentDefinitionTask).where(
-                ExperimentDefinitionTask.experiment_definition_id == defn_id
-            )
-        ).all():
-            session.delete(t)
-        for inst in session.exec(
-            select(ExperimentDefinitionInstance).where(
-                ExperimentDefinitionInstance.experiment_definition_id == defn_id
-            )
-        ).all():
-            session.delete(inst)
-        defn_row = session.get(ExperimentDefinition, defn_id)
-        if defn_row is not None:
-            session.delete(defn_row)
-        session.commit()

From 0e1462d1b2c29bbb73e938536621ba2b0f3114ee Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Wed, 27 May 2026 23:30:24 +0100
Subject: [PATCH 10/15] fix dashboard harness sample events

---
 .../api/samples/[sampleId]/events/route.ts    |  18 +-
 .../components/sample/SampleWorkspacePage.tsx | 107 +----
 .../activity/buildSampleActivities.test.ts    |   9 +-
 .../features/activity/goldenFixture.test.ts   |   5 +-
 .../graph/layout/goldenLayout.test.ts         |   5 +-
 .../src/features/graph/sampleRuntimeEvents.ts | 104 +++++
 .../src/lib/server-data/samples.ts            |  33 +-
 .../src/lib/testing/dashboardHarness.ts       |  14 +-
 .../tests/fixtures/mas-samples/README.md      |   2 +-
 .../mas-samples/concurrent-mas-run.json       | 408 ++++++++++--------
 .../tests/helpers/dashboardFixtures.ts        |   6 +-
 11 files changed, 387 insertions(+), 324 deletions(-)
 create mode 100644 ergon-dashboard/src/features/graph/sampleRuntimeEvents.ts

diff --git a/ergon-dashboard/src/app/api/samples/[sampleId]/events/route.ts b/ergon-dashboard/src/app/api/samples/[sampleId]/events/route.ts
index 7ecf31d56..dd9d21d1c 100644
--- a/ergon-dashboard/src/app/api/samples/[sampleId]/events/route.ts
+++ b/ergon-dashboard/src/app/api/samples/[sampleId]/events/route.ts
@@ -1,6 +1,6 @@
 import { NextResponse } from "next/server";
 
-import { fetchErgonApi } from "@/lib/serverApi";
+import { loadSampleEvents } from "@/lib/server-data/samples";
 
 interface RouteContext {
   params: Promise<{
@@ -10,18 +10,10 @@ interface RouteContext {
 
 export async function GET(_request: Request, context: RouteContext) {
   const { sampleId } = await context.params;
+  const result = await loadSampleEvents(sampleId);
 
-  try {
-    const response = await fetchErgonApi(`/samples/${sampleId}/events`);
-    const body = await response.json();
-    return NextResponse.json(body, { status: response.status });
-  } catch (error) {
-    return NextResponse.json(
-      {
-        detail: `Ergon API is unavailable while loading events for sample ${sampleId}.`,
-        error: error instanceof Error ? error.message : "Unknown backend fetch failure",
-      },
-      { status: 503 },
-    );
+  if (result.ok) {
+    return NextResponse.json(result.data, { status: result.status });
   }
+  return NextResponse.json(result.body, { status: result.status });
 }
diff --git a/ergon-dashboard/src/components/sample/SampleWorkspacePage.tsx b/ergon-dashboard/src/components/sample/SampleWorkspacePage.tsx
index cfb59eb92..78aa30c53 100644
--- a/ergon-dashboard/src/components/sample/SampleWorkspacePage.tsx
+++ b/ergon-dashboard/src/components/sample/SampleWorkspacePage.tsx
@@ -14,10 +14,10 @@ import { ActivityStackTimeline } from "@/features/activity/components/ActivitySt
 import { buildSampleActivities } from "@/features/activity/buildSampleActivities";
 import { resolveActivitySnapshotSequence } from "@/features/activity/snapshotSequence";
 import type { SampleActivity } from "@/features/activity/types";
-import type { SampleGraphEventDto, MutationType } from "@/features/graph/contracts/graphMutations";
+import { sampleRuntimeEventsToGraphEvents } from "@/features/graph/sampleRuntimeEvents";
 import { useSampleWorkspaceState } from "@/hooks/useSampleWorkspaceState";
 import { buildSampleEvents } from "@/lib/sampleEvents";
-import { parseSampleRuntimeEvents, type SampleRuntimeEventView } from "@/lib/contracts/rest";
+import { parseSampleEvents, type SampleRuntimeEventView } from "@/lib/contracts/rest";
 import { SampleLifecycleStatus, SerializedSampleWorkspaceState, TaskStatus, type SampleWorkspaceState } from "@/lib/types";
 import {
   nearestMutationAtOrBefore,
@@ -50,107 +50,6 @@ function countObservedTokens(runState: SampleWorkspaceState | null): number | nu
   return tokenCount > 0 ? tokenCount : null;
 }
 
-function graphMutationType(eventType: string): MutationType | null {
-  switch (eventType) {
-    case "task.added":
-      return "node.added";
-    case "task.removed":
-      return "node.removed";
-    case "task.status_changed":
-      return "node.status_changed";
-    case "edge.added":
-    case "edge.removed":
-    case "edge.status_changed":
-    case "annotation.set":
-    case "annotation.deleted":
-      return eventType;
-    default:
-      return null;
-  }
-}
-
-function payloadRecord(value: unknown): Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : {};
-}
-
-function graphMutationValue(event: SampleRuntimeEventView, mutationType: MutationType): Record<string, unknown> {
-  const payload = payloadRecord(event.payload);
-
-  if (event.eventType === "task.added" && mutationType === "node.added") {
-    const task = payloadRecord(event.task);
-    return {
-      task_slug: String(event.taskSlug ?? task.task_slug ?? task.name ?? event.targetId ?? "task"),
-      instance_key: String(task.instance_key ?? payload.instance_key ?? event.targetId ?? "task"),
-      description: String(task.description ?? payload.description ?? ""),
-      status: String(event.status ?? task.status ?? "pending"),
-      assigned_worker_slug:
-        typeof task.assigned_worker_slug === "string"
-          ? task.assigned_worker_slug
-          : typeof payload.assigned_worker_slug === "string"
-            ? payload.assigned_worker_slug
-            : null,
-    };
-  }
-
-  if (
-    (event.eventType === "task.status_changed" && mutationType === "node.status_changed") ||
-    (event.eventType === "edge.status_changed" && mutationType === "edge.status_changed")
-  ) {
-    return { status: event.status };
-  }
-
-  if (
-    (event.eventType === "edge.added" || event.eventType === "edge.removed") &&
-    (mutationType === "edge.added" || mutationType === "edge.removed")
-  ) {
-    const edge = event.eventType === "edge.added" ? payloadRecord(event.edge) : {};
-    return {
-      source_task_id: event.sourceTaskId,
-      target_task_id: event.targetTaskId,
-      status: String(event.eventType === "edge.added" ? (event.status ?? edge.status ?? "pending") : "removed"),
-    };
-  }
-
-  if (
-    (event.eventType === "annotation.set" || event.eventType === "annotation.deleted") &&
-    (mutationType === "annotation.set" || mutationType === "annotation.deleted")
-  ) {
-    return {
-      namespace: event.key,
-      payload: event.eventType === "annotation.set" ? payloadRecord(event.value) : payload,
-    };
-  }
-
-  return payload;
-}
-
-function sampleRuntimeEventsToGraphEvents(events: SampleRuntimeEventView[]): SampleGraphEventDto[] {
-  return events.flatMap((event, index) => {
-    const mutationType = graphMutationType(event.eventType);
-    const targetId = event.targetId;
-    if (mutationType === null || !targetId) return [];
-    const targetType = event.targetType === "edge" ? "edge" : "node";
-    const newValue = graphMutationValue(event, mutationType);
-    return [
-      {
-        id: event.eventId,
-        sample_id: event.sampleId,
-        sequence: index + 1,
-        mutation_type: mutationType,
-        target_type: targetType,
-        target_id: targetId,
-        actor: "runtime",
-        old_value: null,
-        new_value: newValue,
-        reason: null,
-        created_at: event.timestamp,
-      },
-    ];
-  });
-}
-
 export function SampleWorkspacePage({
   sampleId,
   initialRunState = null,
@@ -207,7 +106,7 @@ export function SampleWorkspacePage({
       .then((res) => res.json())
       .then((data) => {
         if (cancelled) return;
-        const events = parseSampleRuntimeEvents(data);
+        const events = parseSampleEvents(data).items;
         const parsed = sampleRuntimeEventsToGraphEvents(events);
         mutationsLoadedRef.current = true;
         setRuntimeEvents(events);
diff --git a/ergon-dashboard/src/features/activity/buildSampleActivities.test.ts b/ergon-dashboard/src/features/activity/buildSampleActivities.test.ts
index d24f7b307..2192878a4 100644
--- a/ergon-dashboard/src/features/activity/buildSampleActivities.test.ts
+++ b/ergon-dashboard/src/features/activity/buildSampleActivities.test.ts
@@ -2,7 +2,8 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import fixture from "../../../tests/fixtures/mas-samples/concurrent-mas-run.json";
-import { parseSampleGraphEventDtoArray } from "@/features/graph/contracts/graphMutations";
+import { sampleRuntimeEventsToGraphEvents } from "@/features/graph/sampleRuntimeEvents";
+import { parseSampleRuntimeEvents } from "@/lib/contracts/rest";
 import type { SampleEvent } from "@/lib/sampleEvents";
 import { buildSampleEvents } from "@/lib/sampleEvents";
 import { deserializeSampleState } from "@/lib/sampleState";
@@ -12,7 +13,7 @@ import { resolveActivitySnapshotSequence } from "./snapshotSequence";
 
 test("buildSampleActivities surfaces semantic activity kinds without creating actor lanes", () => {
   const runState = deserializeSampleState(fixture.runState);
-  const mutations = parseSampleGraphEventDtoArray(fixture.mutations);
+  const mutations = sampleRuntimeEventsToGraphEvents(parseSampleRuntimeEvents(fixture.events));
   const noisyTaskId = "10000000-0000-4000-8000-000000000002";
   runState.sandboxesByTask.set(noisyTaskId, {
     sandboxId: "sandbox-noisy",
@@ -247,7 +248,7 @@ test("buildSampleActivities surfaces semantic activity kinds without creating ac
 
 test("completed trace spans keep full duration when replaying an earlier sequence", () => {
   const runState = deserializeSampleState(fixture.runState);
-  const mutations = parseSampleGraphEventDtoArray(fixture.mutations);
+  const mutations = sampleRuntimeEventsToGraphEvents(parseSampleRuntimeEvents(fixture.events));
   const events = buildSampleEvents(runState);
 
   const activities = buildSampleActivities({
@@ -276,7 +277,7 @@ test("completed trace spans keep full duration when replaying an earlier sequenc
 
 test("context/tool event sequence does not masquerade as graph replay sequence", () => {
   const runState = deserializeSampleState(fixture.runState);
-  const mutations = parseSampleGraphEventDtoArray(fixture.mutations);
+  const mutations = sampleRuntimeEventsToGraphEvents(parseSampleRuntimeEvents(fixture.events));
   const activities = buildSampleActivities({
     runState,
     events: buildSampleEvents(runState),
diff --git a/ergon-dashboard/src/features/activity/goldenFixture.test.ts b/ergon-dashboard/src/features/activity/goldenFixture.test.ts
index bfde5d205..eedcfb79a 100644
--- a/ergon-dashboard/src/features/activity/goldenFixture.test.ts
+++ b/ergon-dashboard/src/features/activity/goldenFixture.test.ts
@@ -2,7 +2,8 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import fixture from "../../../tests/fixtures/mas-samples/concurrent-mas-run.json";
-import { parseSampleGraphEventDtoArray } from "@/features/graph/contracts/graphMutations";
+import { sampleRuntimeEventsToGraphEvents } from "@/features/graph/sampleRuntimeEvents";
+import { parseSampleRuntimeEvents } from "@/lib/contracts/rest";
 import { replayToSequence } from "@/features/graph/state/graphMutationReducer";
 import { buildSampleEvents } from "@/lib/sampleEvents";
 import { deserializeSampleState } from "@/lib/sampleState";
@@ -34,7 +35,7 @@ function emptyRunStateFrom(runState: SampleWorkspaceState): SampleWorkspaceState
 
 test("golden concurrent fixture replays the whole graph at selected sequence and stacks overlapping activity", () => {
   const runState = deserializeSampleState(fixture.runState);
-  const mutations = parseSampleGraphEventDtoArray(fixture.mutations);
+  const mutations = sampleRuntimeEventsToGraphEvents(parseSampleRuntimeEvents(fixture.events));
   const checkpoint = fixture.checkpoints.find((entry) => entry.sequence === 14);
   assert.ok(checkpoint);
 
diff --git a/ergon-dashboard/src/features/graph/layout/goldenLayout.test.ts b/ergon-dashboard/src/features/graph/layout/goldenLayout.test.ts
index 5442bb4b0..d222ec812 100644
--- a/ergon-dashboard/src/features/graph/layout/goldenLayout.test.ts
+++ b/ergon-dashboard/src/features/graph/layout/goldenLayout.test.ts
@@ -3,7 +3,8 @@ import test from "node:test";
 import type { Node } from "@xyflow/react";
 
 import fixture from "../../../../tests/fixtures/mas-samples/concurrent-mas-run.json";
-import { parseSampleGraphEventDtoArray } from "@/features/graph/contracts/graphMutations";
+import { sampleRuntimeEventsToGraphEvents } from "@/features/graph/sampleRuntimeEvents";
+import { parseSampleRuntimeEvents } from "@/lib/contracts/rest";
 import { createReplayInitialState, replayToSequence } from "@/features/graph/state/graphMutationReducer";
 import { deserializeSampleState } from "@/lib/sampleState";
 import { calculateExpandedContainers, computeHierarchicalLayout } from "./hierarchicalLayout";
@@ -55,7 +56,7 @@ function overlappingSiblingPairs(nodes: Node[]): Array<[string, string]> {
 
 test("golden layout renders the full recursive graph without overlapping sibling boxes", () => {
   const runState = deserializeSampleState(fixture.runState);
-  const mutations = parseSampleGraphEventDtoArray(fixture.mutations);
+  const mutations = sampleRuntimeEventsToGraphEvents(parseSampleRuntimeEvents(fixture.events));
   const checkpoint = fixture.checkpoints.find((entry) => entry.sequence === 14);
   assert.ok(checkpoint);
   const displayState = replayToSequence(
diff --git a/ergon-dashboard/src/features/graph/sampleRuntimeEvents.ts b/ergon-dashboard/src/features/graph/sampleRuntimeEvents.ts
new file mode 100644
index 000000000..7bc8731a8
--- /dev/null
+++ b/ergon-dashboard/src/features/graph/sampleRuntimeEvents.ts
@@ -0,0 +1,104 @@
+import type { SampleRuntimeEventView } from "@/lib/contracts/rest";
+
+import type { MutationType, SampleGraphEventDto } from "./contracts/graphMutations";
+
+function graphMutationType(eventType: string): MutationType | null {
+  switch (eventType) {
+    case "task.added":
+      return "node.added";
+    case "task.removed":
+      return "node.removed";
+    case "task.status_changed":
+      return "node.status_changed";
+    case "edge.added":
+    case "edge.removed":
+    case "edge.status_changed":
+    case "annotation.set":
+    case "annotation.deleted":
+      return eventType;
+    default:
+      return null;
+  }
+}
+
+function payloadRecord(value: unknown): Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function graphMutationValue(event: SampleRuntimeEventView, mutationType: MutationType): Record<string, unknown> {
+  const payload = payloadRecord(event.payload);
+
+  if (event.eventType === "task.added" && mutationType === "node.added") {
+    const task = payloadRecord(event.task);
+    return {
+      task_slug: String(event.taskSlug ?? task.task_slug ?? task.name ?? event.targetId ?? "task"),
+      instance_key: String(task.instance_key ?? payload.instance_key ?? event.targetId ?? "task"),
+      description: String(task.description ?? payload.description ?? ""),
+      status: String(event.status ?? task.status ?? "pending"),
+      assigned_worker_slug:
+        typeof task.assigned_worker_slug === "string"
+          ? task.assigned_worker_slug
+          : typeof payload.assigned_worker_slug === "string"
+            ? payload.assigned_worker_slug
+            : null,
+    };
+  }
+
+  if (
+    (event.eventType === "task.status_changed" && mutationType === "node.status_changed") ||
+    (event.eventType === "edge.status_changed" && mutationType === "edge.status_changed")
+  ) {
+    return { status: event.status };
+  }
+
+  if (
+    (event.eventType === "edge.added" || event.eventType === "edge.removed") &&
+    (mutationType === "edge.added" || mutationType === "edge.removed")
+  ) {
+    const edge = event.eventType === "edge.added" ? payloadRecord(event.edge) : {};
+    return {
+      source_task_id: event.sourceTaskId,
+      target_task_id: event.targetTaskId,
+      status: String(event.eventType === "edge.added" ? (event.status ?? edge.status ?? "pending") : "removed"),
+    };
+  }
+
+  if (
+    (event.eventType === "annotation.set" || event.eventType === "annotation.deleted") &&
+    (mutationType === "annotation.set" || mutationType === "annotation.deleted")
+  ) {
+    return {
+      namespace: event.key,
+      payload: event.eventType === "annotation.set" ? payloadRecord(event.value) : payload,
+    };
+  }
+
+  return payload;
+}
+
+export function sampleRuntimeEventsToGraphEvents(events: SampleRuntimeEventView[]): SampleGraphEventDto[] {
+  return events.flatMap((event, index) => {
+    const mutationType = graphMutationType(event.eventType);
+    const targetId = event.targetId;
+    if (mutationType === null || !targetId) return [];
+    const targetType = event.targetType === "edge" ? "edge" : "node";
+    const newValue = graphMutationValue(event, mutationType);
+    return [
+      {
+        id: event.eventId,
+        sample_id: event.sampleId,
+        sequence: index + 1,
+        mutation_type: mutationType,
+        target_type: targetType,
+        target_id: targetId,
+        actor: "runtime",
+        old_value: null,
+        new_value: newValue,
+        reason: null,
+        created_at: event.timestamp,
+      },
+    ];
+  });
+}
diff --git a/ergon-dashboard/src/lib/server-data/samples.ts b/ergon-dashboard/src/lib/server-data/samples.ts
index 826230214..cc0fc3913 100644
--- a/ergon-dashboard/src/lib/server-data/samples.ts
+++ b/ergon-dashboard/src/lib/server-data/samples.ts
@@ -5,10 +5,11 @@ import {
   parseSampleGraph,
   parseSampleSnapshot,
   type SampleSnapshot,
+  type SampleEventsView,
 } from "@/lib/contracts/rest";
 import { buildSampleState, type SampleDashboardState } from "@/lib/sample-state/dashboard";
 import { fetchErgonApi } from "@/lib/serverApi";
-import { getHarnessSample, getHarnessSampleState } from "@/lib/testing/dashboardHarness";
+import { getHarnessSample, getHarnessSampleEvents, getHarnessSampleState } from "@/lib/testing/dashboardHarness";
 
 import { backendUnavailable, type ServerDataResult } from "./responses";
 
@@ -101,6 +102,36 @@ export async function loadSampleSnapshot(sampleId: string): Promise<ServerDataRe
   }
 }
 
+export async function loadSampleEvents(sampleId: string): Promise<ServerDataResult<SampleEventsView>> {
+  if (config.enableTestHarness) {
+    const events = getHarnessSampleEvents(sampleId);
+    if (events !== null) {
+      return {
+        ok: true,
+        data: parseSampleEvents({ items: events }),
+        status: 200,
+        source: "harness",
+      };
+    }
+  }
+
+  try {
+    const response = await fetchErgonApi(`/samples/${sampleId}/events`);
+    const body = await response.json();
+    if (response.ok) {
+      return {
+        ok: true,
+        data: parseSampleEvents(body),
+        status: response.status,
+        source: "backend",
+      };
+    }
+    return { ok: false, body, status: response.status, source: "backend" };
+  } catch (error) {
+    return backendUnavailable(`Ergon API is unavailable while loading events for sample ${sampleId}.`, error);
+  }
+}
+
 export async function loadSampleState(sampleId: string): Promise<ServerDataResult<SampleDashboardState>> {
   if (config.enableTestHarness) {
     const sample = getHarnessSampleState(sampleId);
diff --git a/ergon-dashboard/src/lib/testing/dashboardHarness.ts b/ergon-dashboard/src/lib/testing/dashboardHarness.ts
index b656a1c59..34d90c451 100644
--- a/ergon-dashboard/src/lib/testing/dashboardHarness.ts
+++ b/ergon-dashboard/src/lib/testing/dashboardHarness.ts
@@ -23,7 +23,7 @@ declare global {
     | {
         experimentDetails: Record<string, unknown>;
         sampleStates: Record<string, SampleDashboardState>;
-        mutationsBySample: Record<string, unknown[]>;
+        eventsBySample: Record<string, unknown[]>;
         seededSampleIds: Set<string>;
       }
     | undefined;
@@ -33,7 +33,7 @@ export interface DashboardHarnessSeedPayload {
   experimentDetails?: Record<string, unknown>;
   sampleStates?: Record<string, SampleDashboardState>;
   runs?: SerializedSampleWorkspaceState[];
-  mutations?: Record<string, unknown[]>;
+  events?: Record<string, unknown[]>;
 }
 
 function getHarnessState() {
@@ -41,7 +41,7 @@ function getHarnessState() {
     global.__dashboardHarness = {
       experimentDetails: {},
       sampleStates: {},
-      mutationsBySample: {},
+      eventsBySample: {},
       seededSampleIds: new Set(),
     };
   }
@@ -60,7 +60,7 @@ export function resetDashboardHarness(): void {
   const harness = getHarnessState();
   harness.experimentDetails = {};
   harness.sampleStates = {};
-  harness.mutationsBySample = {};
+  harness.eventsBySample = {};
   harness.seededSampleIds.clear();
 }
 
@@ -71,7 +71,7 @@ export function seedDashboardHarness(payload: DashboardHarnessSeedPayload): void
   const harness = getHarnessState();
   harness.experimentDetails = payload.experimentDetails ?? {};
   harness.sampleStates = payload.sampleStates ?? {};
-  harness.mutationsBySample = payload.mutations ?? {};
+  harness.eventsBySample = payload.events ?? {};
 
   for (const run of payload.runs ?? []) {
     store.seedSample(deserializeSampleState(run));
@@ -98,9 +98,9 @@ export function getHarnessSample(sampleId: string): SerializedSampleWorkspaceSta
   return run ? serializeSampleState(run) : null;
 }
 
-export function getHarnessSampleMutations(sampleId: string): unknown[] | null {
+export function getHarnessSampleEvents(sampleId: string): unknown[] | null {
   requireHarnessEnabled();
-  return getHarnessState().mutationsBySample[sampleId] ?? null;
+  return getHarnessState().eventsBySample[sampleId] ?? null;
 }
 
 export function emitHarnessSampleCompleted(data: {
diff --git a/ergon-dashboard/tests/fixtures/mas-samples/README.md b/ergon-dashboard/tests/fixtures/mas-samples/README.md
index 3057be6a6..cd07c4dae 100644
--- a/ergon-dashboard/tests/fixtures/mas-samples/README.md
+++ b/ergon-dashboard/tests/fixtures/mas-samples/README.md
@@ -2,4 +2,4 @@
 
 These fixtures are small, sanitized run snapshots used by frontend semantic layout tests and local visual review.
 
-They intentionally avoid model outputs, secrets, and large resources. Keep them reviewable: add only the task graph, timestamps, mutations, and evidence needed to prove visual debugger behavior.
+They intentionally avoid model outputs, secrets, and large resources. Keep them reviewable: add only the task graph, timestamps, typed sample runtime events, and evidence needed to prove visual debugger behavior.
diff --git a/ergon-dashboard/tests/fixtures/mas-samples/concurrent-mas-run.json b/ergon-dashboard/tests/fixtures/mas-samples/concurrent-mas-run.json
index cb8b180f4..8bd3551ac 100644
--- a/ergon-dashboard/tests/fixtures/mas-samples/concurrent-mas-run.json
+++ b/ergon-dashboard/tests/fixtures/mas-samples/concurrent-mas-run.json
@@ -313,284 +313,318 @@
       ]
     }
   },
-  "mutations": [
+  "checkpoints": [
+    {
+      "sequence": 10,
+      "expectedTaskIds": [
+        "10000000-0000-4000-8000-000000000001",
+        "10000000-0000-4000-8000-000000000002",
+        "10000000-0000-4000-8000-000000000003",
+        "10000000-0000-4000-8000-000000000004"
+      ],
+      "expectedMaxConcurrency": 1,
+      "selectedTime": "2026-04-26T12:00:10.000Z",
+      "hiddenFutureResourceName": "references.md"
+    },
+    {
+      "sequence": 14,
+      "expectedTaskIds": [
+        "10000000-0000-4000-8000-000000000001",
+        "10000000-0000-4000-8000-000000000002",
+        "10000000-0000-4000-8000-000000000003",
+        "10000000-0000-4000-8000-000000000004",
+        "10000000-0000-4000-8000-000000000005",
+        "10000000-0000-4000-8000-000000000006"
+      ],
+      "expectedMaxConcurrency": 2,
+      "selectedTime": "2026-04-26T12:00:18.000Z",
+      "hiddenFutureResourceName": "references.md"
+    }
+  ],
+  "events": [
     {
-      "id": "70000000-0000-4000-8000-000000000001",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 1,
-      "mutation_type": "node.added",
-      "target_type": "node",
-      "target_id": "10000000-0000-4000-8000-000000000001",
+      "eventId": "70000000-0000-4000-8000-000000000001",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:00.000Z",
+      "targetId": "10000000-0000-4000-8000-000000000001",
       "actor": "planner",
-      "old_value": null,
-      "new_value": {
-        "task_slug": "Root investigation",
+      "payload": {
         "instance_key": "root",
         "description": "Coordinate a multi-agent research pass.",
-        "status": "pending",
         "assigned_worker_slug": "planner"
       },
-      "reason": "workflow started",
-      "created_at": "2026-04-26T12:00:00.000Z"
+      "eventType": "task.added",
+      "targetType": "task",
+      "taskSlug": "Root investigation",
+      "status": "pending",
+      "task": {
+        "instance_key": "root",
+        "description": "Coordinate a multi-agent research pass.",
+        "status": "pending",
+        "assigned_worker_slug": "planner"
+      }
     },
     {
-      "id": "70000000-0000-4000-8000-000000000002",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 2,
-      "mutation_type": "node.status_changed",
-      "target_type": "node",
-      "target_id": "10000000-0000-4000-8000-000000000001",
+      "eventId": "70000000-0000-4000-8000-000000000002",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:00.000Z",
+      "targetId": "10000000-0000-4000-8000-000000000001",
       "actor": "planner",
-      "old_value": {
-        "status": "pending"
-      },
-      "new_value": {
+      "payload": {
         "status": "running"
       },
-      "reason": "worker started",
-      "created_at": "2026-04-26T12:00:00.000Z"
+      "eventType": "task.status_changed",
+      "targetType": "task",
+      "taskSlug": null,
+      "status": "running"
     },
     {
-      "id": "70000000-0000-4000-8000-000000000003",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 3,
-      "mutation_type": "node.added",
-      "target_type": "node",
-      "target_id": "10000000-0000-4000-8000-000000000002",
+      "eventId": "70000000-0000-4000-8000-000000000003",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:03.000Z",
+      "targetId": "10000000-0000-4000-8000-000000000002",
       "actor": "planner",
-      "old_value": null,
-      "new_value": {
-        "task_slug": "Search literature",
+      "payload": {
         "instance_key": "search",
         "description": "Find candidate references.",
-        "status": "pending",
         "assigned_worker_slug": "researcher-a"
       },
-      "reason": "delegate",
-      "created_at": "2026-04-26T12:00:03.000Z"
+      "eventType": "task.added",
+      "targetType": "task",
+      "taskSlug": "Search literature",
+      "status": "pending",
+      "task": {
+        "instance_key": "search",
+        "description": "Find candidate references.",
+        "status": "pending",
+        "assigned_worker_slug": "researcher-a"
+      }
     },
     {
-      "id": "70000000-0000-4000-8000-000000000004",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 4,
-      "mutation_type": "edge.added",
-      "target_type": "edge",
-      "target_id": "70000000-0000-4000-8000-100000000004",
+      "eventId": "70000000-0000-4000-8000-000000000004",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:03.100Z",
+      "targetId": "70000000-0000-4000-8000-100000000004",
       "actor": "planner",
-      "old_value": null,
-      "new_value": {
+      "payload": {
         "source_task_id": "10000000-0000-4000-8000-000000000001",
         "target_task_id": "10000000-0000-4000-8000-000000000002",
         "status": "active"
       },
-      "reason": "parent-child",
-      "created_at": "2026-04-26T12:00:03.100Z"
+      "eventType": "edge.added",
+      "targetType": "edge",
+      "sourceTaskId": "10000000-0000-4000-8000-000000000001",
+      "targetTaskId": "10000000-0000-4000-8000-000000000002",
+      "status": "active",
+      "edge": {
+        "source_task_id": "10000000-0000-4000-8000-000000000001",
+        "target_task_id": "10000000-0000-4000-8000-000000000002",
+        "status": "active"
+      }
     },
     {
-      "id": "70000000-0000-4000-8000-000000000005",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 5,
-      "mutation_type": "node.added",
-      "target_type": "node",
-      "target_id": "10000000-0000-4000-8000-000000000003",
+      "eventId": "70000000-0000-4000-8000-000000000005",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:04.000Z",
+      "targetId": "10000000-0000-4000-8000-000000000003",
       "actor": "planner",
-      "old_value": null,
-      "new_value": {
-        "task_slug": "Check claims",
+      "payload": {
         "instance_key": "check",
         "description": "Verify extracted claims.",
-        "status": "pending",
         "assigned_worker_slug": "researcher-b"
       },
-      "reason": "delegate",
-      "created_at": "2026-04-26T12:00:04.000Z"
+      "eventType": "task.added",
+      "targetType": "task",
+      "taskSlug": "Check claims",
+      "status": "pending",
+      "task": {
+        "instance_key": "check",
+        "description": "Verify extracted claims.",
+        "status": "pending",
+        "assigned_worker_slug": "researcher-b"
+      }
     },
     {
-      "id": "70000000-0000-4000-8000-000000000006",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 6,
-      "mutation_type": "edge.added",
-      "target_type": "edge",
-      "target_id": "70000000-0000-4000-8000-100000000006",
+      "eventId": "70000000-0000-4000-8000-000000000006",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:04.100Z",
+      "targetId": "70000000-0000-4000-8000-100000000006",
       "actor": "planner",
-      "old_value": null,
-      "new_value": {
+      "payload": {
         "source_task_id": "10000000-0000-4000-8000-000000000001",
         "target_task_id": "10000000-0000-4000-8000-000000000003",
         "status": "active"
       },
-      "reason": "parent-child",
-      "created_at": "2026-04-26T12:00:04.100Z"
+      "eventType": "edge.added",
+      "targetType": "edge",
+      "sourceTaskId": "10000000-0000-4000-8000-000000000001",
+      "targetTaskId": "10000000-0000-4000-8000-000000000003",
+      "status": "active",
+      "edge": {
+        "source_task_id": "10000000-0000-4000-8000-000000000001",
+        "target_task_id": "10000000-0000-4000-8000-000000000003",
+        "status": "active"
+      }
     },
     {
-      "id": "70000000-0000-4000-8000-000000000007",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 7,
-      "mutation_type": "node.added",
-      "target_type": "node",
-      "target_id": "10000000-0000-4000-8000-000000000004",
+      "eventId": "70000000-0000-4000-8000-000000000007",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:05.000Z",
+      "targetId": "10000000-0000-4000-8000-000000000004",
       "actor": "planner",
-      "old_value": null,
-      "new_value": {
-        "task_slug": "Synthesize answer",
+      "payload": {
         "instance_key": "synth",
         "description": "Write the final synthesis after evidence is available.",
-        "status": "pending",
         "assigned_worker_slug": "writer"
       },
-      "reason": "delegate",
-      "created_at": "2026-04-26T12:00:05.000Z"
+      "eventType": "task.added",
+      "targetType": "task",
+      "taskSlug": "Synthesize answer",
+      "status": "pending",
+      "task": {
+        "instance_key": "synth",
+        "description": "Write the final synthesis after evidence is available.",
+        "status": "pending",
+        "assigned_worker_slug": "writer"
+      }
     },
     {
-      "id": "70000000-0000-4000-8000-000000000008",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 8,
-      "mutation_type": "edge.added",
-      "target_type": "edge",
-      "target_id": "70000000-0000-4000-8000-100000000008",
+      "eventId": "70000000-0000-4000-8000-000000000008",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:05.100Z",
+      "targetId": "70000000-0000-4000-8000-100000000008",
       "actor": "planner",
-      "old_value": null,
-      "new_value": {
+      "payload": {
         "source_task_id": "10000000-0000-4000-8000-000000000001",
         "target_task_id": "10000000-0000-4000-8000-000000000004",
         "status": "active"
       },
-      "reason": "parent-child",
-      "created_at": "2026-04-26T12:00:05.100Z"
+      "eventType": "edge.added",
+      "targetType": "edge",
+      "sourceTaskId": "10000000-0000-4000-8000-000000000001",
+      "targetTaskId": "10000000-0000-4000-8000-000000000004",
+      "status": "active",
+      "edge": {
+        "source_task_id": "10000000-0000-4000-8000-000000000001",
+        "target_task_id": "10000000-0000-4000-8000-000000000004",
+        "status": "active"
+      }
     },
     {
-      "id": "70000000-0000-4000-8000-000000000009",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 9,
-      "mutation_type": "node.status_changed",
-      "target_type": "node",
-      "target_id": "10000000-0000-4000-8000-000000000002",
+      "eventId": "70000000-0000-4000-8000-000000000009",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:05.000Z",
+      "targetId": "10000000-0000-4000-8000-000000000002",
       "actor": "researcher-a",
-      "old_value": {
-        "status": "pending"
-      },
-      "new_value": {
+      "payload": {
         "status": "running"
       },
-      "reason": "worker started",
-      "created_at": "2026-04-26T12:00:05.000Z"
+      "eventType": "task.status_changed",
+      "targetType": "task",
+      "taskSlug": null,
+      "status": "running"
     },
     {
-      "id": "70000000-0000-4000-8000-000000000010",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 10,
-      "mutation_type": "node.status_changed",
-      "target_type": "node",
-      "target_id": "10000000-0000-4000-8000-000000000003",
+      "eventId": "70000000-0000-4000-8000-000000000010",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:08.000Z",
+      "targetId": "10000000-0000-4000-8000-000000000003",
       "actor": "researcher-b",
-      "old_value": {
-        "status": "pending"
-      },
-      "new_value": {
+      "payload": {
         "status": "running"
       },
-      "reason": "worker started",
-      "created_at": "2026-04-26T12:00:08.000Z"
+      "eventType": "task.status_changed",
+      "targetType": "task",
+      "taskSlug": null,
+      "status": "running"
     },
     {
-      "id": "70000000-0000-4000-8000-000000000011",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 11,
-      "mutation_type": "node.added",
-      "target_type": "node",
-      "target_id": "10000000-0000-4000-8000-000000000005",
+      "eventId": "70000000-0000-4000-8000-000000000011",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:12.000Z",
+      "targetId": "10000000-0000-4000-8000-000000000005",
       "actor": "writer",
-      "old_value": null,
-      "new_value": {
-        "task_slug": "Draft narrative",
+      "payload": {
         "instance_key": "draft",
         "description": "Draft the explanation.",
-        "status": "pending",
         "assigned_worker_slug": "writer-a"
       },
-      "reason": "delegate nested",
-      "created_at": "2026-04-26T12:00:12.000Z"
+      "eventType": "task.added",
+      "targetType": "task",
+      "taskSlug": "Draft narrative",
+      "status": "pending",
+      "task": {
+        "instance_key": "draft",
+        "description": "Draft the explanation.",
+        "status": "pending",
+        "assigned_worker_slug": "writer-a"
+      }
     },
     {
-      "id": "70000000-0000-4000-8000-000000000012",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 12,
-      "mutation_type": "edge.added",
-      "target_type": "edge",
-      "target_id": "70000000-0000-4000-8000-100000000012",
+      "eventId": "70000000-0000-4000-8000-000000000012",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:12.100Z",
+      "targetId": "70000000-0000-4000-8000-100000000012",
       "actor": "writer",
-      "old_value": null,
-      "new_value": {
+      "payload": {
         "source_task_id": "10000000-0000-4000-8000-000000000004",
         "target_task_id": "10000000-0000-4000-8000-000000000005",
         "status": "active"
       },
-      "reason": "parent-child",
-      "created_at": "2026-04-26T12:00:12.100Z"
+      "eventType": "edge.added",
+      "targetType": "edge",
+      "sourceTaskId": "10000000-0000-4000-8000-000000000004",
+      "targetTaskId": "10000000-0000-4000-8000-000000000005",
+      "status": "active",
+      "edge": {
+        "source_task_id": "10000000-0000-4000-8000-000000000004",
+        "target_task_id": "10000000-0000-4000-8000-000000000005",
+        "status": "active"
+      }
     },
     {
-      "id": "70000000-0000-4000-8000-000000000013",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 13,
-      "mutation_type": "node.added",
-      "target_type": "node",
-      "target_id": "10000000-0000-4000-8000-000000000006",
+      "eventId": "70000000-0000-4000-8000-000000000013",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:13.000Z",
+      "targetId": "10000000-0000-4000-8000-000000000006",
       "actor": "writer",
-      "old_value": null,
-      "new_value": {
-        "task_slug": "Validate citations",
+      "payload": {
         "instance_key": "validate",
         "description": "Validate citation coverage.",
-        "status": "pending",
         "assigned_worker_slug": "writer-b"
       },
-      "reason": "delegate nested",
-      "created_at": "2026-04-26T12:00:13.000Z"
+      "eventType": "task.added",
+      "targetType": "task",
+      "taskSlug": "Validate citations",
+      "status": "pending",
+      "task": {
+        "instance_key": "validate",
+        "description": "Validate citation coverage.",
+        "status": "pending",
+        "assigned_worker_slug": "writer-b"
+      }
     },
     {
-      "id": "70000000-0000-4000-8000-000000000014",
-      "sample_id": "99999999-9999-4999-8999-999999999999",
-      "sequence": 14,
-      "mutation_type": "edge.added",
-      "target_type": "edge",
-      "target_id": "70000000-0000-4000-8000-100000000014",
+      "eventId": "70000000-0000-4000-8000-000000000014",
+      "sampleId": "99999999-9999-4999-8999-999999999999",
+      "timestamp": "2026-04-26T12:00:13.100Z",
+      "targetId": "70000000-0000-4000-8000-100000000014",
       "actor": "writer",
-      "old_value": null,
-      "new_value": {
+      "payload": {
         "source_task_id": "10000000-0000-4000-8000-000000000004",
         "target_task_id": "10000000-0000-4000-8000-000000000006",
         "status": "active"
       },
-      "reason": "parent-child",
-      "created_at": "2026-04-26T12:00:13.100Z"
-    }
-  ],
-  "checkpoints": [
-    {
-      "sequence": 10,
-      "expectedTaskIds": [
-        "10000000-0000-4000-8000-000000000001",
-        "10000000-0000-4000-8000-000000000002",
-        "10000000-0000-4000-8000-000000000003",
-        "10000000-0000-4000-8000-000000000004"
-      ],
-      "expectedMaxConcurrency": 1,
-      "selectedTime": "2026-04-26T12:00:10.000Z",
-      "hiddenFutureResourceName": "references.md"
-    },
-    {
-      "sequence": 14,
-      "expectedTaskIds": [
-        "10000000-0000-4000-8000-000000000001",
-        "10000000-0000-4000-8000-000000000002",
-        "10000000-0000-4000-8000-000000000003",
-        "10000000-0000-4000-8000-000000000004",
-        "10000000-0000-4000-8000-000000000005",
-        "10000000-0000-4000-8000-000000000006"
-      ],
-      "expectedMaxConcurrency": 2,
-      "selectedTime": "2026-04-26T12:00:18.000Z",
-      "hiddenFutureResourceName": "references.md"
+      "eventType": "edge.added",
+      "targetType": "edge",
+      "sourceTaskId": "10000000-0000-4000-8000-000000000004",
+      "targetTaskId": "10000000-0000-4000-8000-000000000006",
+      "status": "active",
+      "edge": {
+        "source_task_id": "10000000-0000-4000-8000-000000000004",
+        "target_task_id": "10000000-0000-4000-8000-000000000006",
+        "status": "active"
+      }
     }
   ]
 }
diff --git a/ergon-dashboard/tests/helpers/dashboardFixtures.ts b/ergon-dashboard/tests/helpers/dashboardFixtures.ts
index 01c614e03..d4f6c6844 100644
--- a/ergon-dashboard/tests/helpers/dashboardFixtures.ts
+++ b/ergon-dashboard/tests/helpers/dashboardFixtures.ts
@@ -555,7 +555,7 @@ export function createDashboardSeed(): DashboardHarnessSeedPayload {
       ...(concurrent.experimentDetails ?? {}),
     },
     runs: [runState, ...(concurrent.runs ?? [])],
-    mutations: concurrent.mutations,
+    events: concurrent.events,
   };
 }
 
@@ -563,8 +563,8 @@ function createConcurrentMasSeedOnly(): DashboardHarnessSeedPayload {
   return {
     experimentDetails: {},
     runs: [concurrentMasFixture.runState as unknown as SerializedSampleWorkspaceState],
-    mutations: {
-      [CONCURRENT_MAS_FIXTURE_IDS.sampleId]: concurrentMasFixture.mutations,
+    events: {
+      [CONCURRENT_MAS_FIXTURE_IDS.sampleId]: concurrentMasFixture.events,
     },
   } as DashboardHarnessSeedPayload;
 }

From 7ac8c32fb9b6977249dbe5549a2140356578ba95 Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Thu, 28 May 2026 10:24:53 +0100
Subject: [PATCH 11/15] Clean up sample attempt naming

---
 ergon-dashboard/RUN_VISIBILITY_PLAN.md        |   2 +-
 .../components/panels/CommunicationPanel.tsx  |   4 +-
 .../components/workspace/TaskWorkspace.tsx    |   2 +-
 .../activity/buildSampleActivities.test.ts    |   8 +-
 .../activity/buildSampleActivities.ts         |   6 +-
 .../components/ActivityStackTimeline.tsx      |   4 +-
 .../activity/snapshotSequence.test.ts         |   2 +-
 .../src/features/activity/stackLayout.test.ts |   2 +-
 .../src/features/activity/types.ts            |   2 +-
 .../events/DashboardContextEventEvent.ts      |   2 +-
 .../events/DashboardResourcePublishedEvent.ts |   2 +-
 .../DashboardContextEventEvent.schema.json    |   6 +-
 ...ashboardResourcePublishedEvent.schema.json |   6 +-
 ...boardThreadMessageCreatedEvent.schema.json |   4 +-
 .../DashboardWorkflowStartedEvent.schema.json |  16 +--
 .../src/generated/rest/contracts.ts           |   6 +-
 .../src/generated/rest/openapi.json           |  10 +-
 .../src/inngest/functions/index.ts            |   4 +-
 .../src/inngest/functions/onContextEvent.ts   |   2 +-
 .../src/lib/contracts/contextEvents.ts        |   2 +-
 .../src/lib/sample-state/contextEvents.ts     |   4 +-
 .../src/lib/sample-state/hydrate.ts           |   2 +-
 ergon-dashboard/src/lib/types.ts              |   2 +-
 .../tests/contracts/contracts.test.ts         |   4 +-
 .../mas-samples/concurrent-mas-run.json       |   6 +-
 .../tests/helpers/dashboardFixtures.ts        |   8 +-
 .../toolkits/resources/models.py              |  23 ++--
 .../toolkits/resources/toolkit.py             |  52 ++++----
 .../tools/graph_toolkit_types.py              |   4 +-
 .../common/test_transcript_adapters.py        |   2 +-
 .../state/test_research_rubrics_benchmark.py  |   2 +-
 ergon_cli/tests/unit/cli/test_workflow_cli.py |   2 +-
 ergon_core/ergon_core/api/worker/context.py   |   2 +-
 .../core/application/communication/models.py  |   4 +-
 .../core/application/communication/service.py |  12 +-
 .../core/application/context/service.py       |   6 +-
 .../core/application/evaluation/service.py    |  12 +-
 .../core/application/events/__init__.py       |   4 +-
 .../core/application/events/runtime.py        |   4 +-
 .../application/experiments/submission.py     |  14 +--
 .../core/application/resources/models.py      |  10 +-
 .../core/application/resources/publishing.py  |  12 +-
 .../core/application/resources/repository.py  |  28 ++---
 .../core/application/resources/service.py     |   4 +-
 .../application/runtime/sample_lifecycle.py   |  13 +-
 .../application/runtime/task_execution.py     |   3 -
 .../runtime/task_execution_repository.py      |  15 +--
 .../application/runtime/workflow_models.py    |   3 +-
 .../sandbox/resource_publisher.py             |  12 +-
 .../resources/persist_outputs/composition.py  |   4 +-
 .../ergon_core/core/jobs/task/evaluate/job.py |   4 +-
 .../core/jobs/task/worker_execute/job.py      |   2 +-
 .../core/jobs/workflow/start/contract.py      |   2 +-
 .../core/jobs/workflow/start/inngest.py       |   6 +-
 .../core/jobs/workflow/start/job.py           |   6 +-
 .../core/persistence/components/__init__.py   |   1 -
 .../core/persistence/context/models.py        |   4 +-
 .../core/persistence/telemetry/models.py      |  10 +-
 ergon_core/ergon_core/core/rl/extraction.py   |   4 +-
 .../ergon_core/core/rl/rollout_service.py     |   8 +-
 .../views/dashboard_events/context_events.py  |   4 +-
 .../core/views/dashboard_events/contracts.py  |   4 +-
 .../ergon_core/core/views/samples/models.py   |   6 +-
 .../ergon_core/core/views/samples/service.py  |   2 +-
 .../ergon_core/core/views/samples/snapshot.py |  30 ++---
 ...00003_delete_definition_runtime_columns.py | 113 ++++++++++++++++++
 .../test_submit_starts_materialized_sample.py |   4 +-
 .../api/worker/test_worker_context_facade.py  |   6 +-
 .../test_persistence_boundaries.py            |  26 ++++
 .../test_inline_evaluator_persistence.py      |   4 +-
 .../experiments/test_experiment_submit.py     |  18 +--
 .../dashboard/test_communication_threads.py   |   8 +-
 .../dashboard/test_event_contract_types.py    |   4 +-
 .../evaluation/test_evaluation_dto_mapping.py |   2 +-
 .../evaluation/test_evaluation_persistence.py |   4 +-
 .../test_context_event_repository.py          |   2 +-
 .../unit/read_models/test_sample_metrics.py   |   2 +-
 .../registry/test_inngest_job_registry.py     |   2 +-
 .../tests/unit/resources/test_publishing.py   |  16 +--
 .../runtime/test_communication_service.py     |   4 +-
 .../runtime/test_context_event_contracts.py   |  10 +-
 .../test_dynamic_task_evaluation_mapping.py   |   2 +-
 .../unit/runtime/test_identity_invariants.py  |  18 +--
 .../test_real_llm_rollout_artifact_health.py  |  22 ++--
 .../runtime/test_task_execution_repository.py |  50 ++++----
 .../unit/runtime/test_workflow_service.py     |   6 +-
 .../writers/external_run_writer.py            |  10 +-
 tests/e2e/_asserts.py                         |   2 +-
 .../criteria/minif2f_smoke.py                 |   2 +-
 .../criteria/researchrubrics_smoke.py         |   2 +-
 .../criteria/swebench_smoke.py                |   2 +-
 .../smoke_base/criterion_base.py              |   2 +-
 .../smoke_components/smoke_base/leaf_base.py  |   2 +-
 .../smoke_components/smoke_base/recursive.py  |   2 +-
 tests/real_llm/artifact_health.py             |   4 +-
 95 files changed, 463 insertions(+), 346 deletions(-)
 delete mode 100644 ergon_core/ergon_core/core/persistence/components/__init__.py

diff --git a/ergon-dashboard/RUN_VISIBILITY_PLAN.md b/ergon-dashboard/RUN_VISIBILITY_PLAN.md
index 01a0c5afd..7bfc32e0a 100644
--- a/ergon-dashboard/RUN_VISIBILITY_PLAN.md
+++ b/ergon-dashboard/RUN_VISIBILITY_PLAN.md
@@ -34,7 +34,7 @@ These land first because every workstream depends on them.
   type RunEvent =
     | { kind: "workflow.started"; at: string; runId: string; ... }
     | { kind: "task.status_changed"; at: string; taskId: string; from: TaskStatus; to: TaskStatus; trigger: TaskTrigger; ... }
-    | { kind: "generation.turn"; at: string; taskExecutionId: string; turnIndex: number; ... }
+    | { kind: "generation.turn"; at: string; taskAttemptId: string; turnIndex: number; ... }
     | { kind: "sandbox.command"; ... }
     | { kind: "thread.message"; ... }
     | { kind: "task.evaluation"; ... }
diff --git a/ergon-dashboard/src/components/panels/CommunicationPanel.tsx b/ergon-dashboard/src/components/panels/CommunicationPanel.tsx
index 3617da3c9..53fd37bbf 100644
--- a/ergon-dashboard/src/components/panels/CommunicationPanel.tsx
+++ b/ergon-dashboard/src/components/panels/CommunicationPanel.tsx
@@ -197,8 +197,8 @@ export function CommunicationPanel({
                     <div className="mt-1 flex flex-wrap gap-2 break-all font-mono text-[10px] text-[var(--faint)]">
                       <span>#{message.sequenceNum}</span>
                       {message.taskId && <span className="break-all">task {message.taskId}</span>}
-                      {message.taskExecutionId && (
-                        <span className="break-all">exec {message.taskExecutionId}</span>
+                      {message.taskAttemptId && (
+                        <span className="break-all">exec {message.taskAttemptId}</span>
                       )}
                     </div>
                   </div>
diff --git a/ergon-dashboard/src/components/workspace/TaskWorkspace.tsx b/ergon-dashboard/src/components/workspace/TaskWorkspace.tsx
index 59f6a0435..30b4b24a8 100644
--- a/ergon-dashboard/src/components/workspace/TaskWorkspace.tsx
+++ b/ergon-dashboard/src/components/workspace/TaskWorkspace.tsx
@@ -54,7 +54,7 @@ function ActivityDetail({ activity }: { activity: SampleActivity }) {
         <span>Started: {formatClockTime(activity.startAt)}</span>
         <span>Sequence: {activity.sequence ?? "—"}</span>
         <span>Task: {activity.lineage.taskId ?? "—"}</span>
-        <span>Execution: {activity.lineage.taskExecutionId ?? "—"}</span>
+        <span>Execution: {activity.lineage.taskAttemptId ?? "—"}</span>
         <span>Sandbox: {activity.lineage.sandboxId ?? "—"}</span>
         {activity.endAt && <span>Ended: {formatClockTime(activity.endAt)}</span>}
         {metadata.map(([key, value]) => (
diff --git a/ergon-dashboard/src/features/activity/buildSampleActivities.test.ts b/ergon-dashboard/src/features/activity/buildSampleActivities.test.ts
index 2192878a4..b1f95873a 100644
--- a/ergon-dashboard/src/features/activity/buildSampleActivities.test.ts
+++ b/ergon-dashboard/src/features/activity/buildSampleActivities.test.ts
@@ -56,7 +56,7 @@ test("buildSampleActivities surfaces semantic activity kinds without creating ac
     {
       id: "context-noisy",
       sampleId: runState.id,
-      taskExecutionId: "execution-noisy",
+      taskAttemptId: "execution-noisy",
       taskId: noisyTaskId,
       workerBindingKey: "worker-1",
       sequence: 12,
@@ -93,7 +93,7 @@ test("buildSampleActivities surfaces semantic activity kinds without creating ac
           threadTopic: "coordination",
           sampleId: runState.id,
           taskId: noisyTaskId,
-          taskExecutionId: null,
+          taskAttemptId: null,
           fromAgentId: "agent-a",
           toAgentId: "agent-b",
           content: "Verbose coordination message",
@@ -213,7 +213,7 @@ test("buildSampleActivities surfaces semantic activity kinds without creating ac
       (activity) =>
         activity.kind === "execution" &&
         activity.band === "work" &&
-        activity.lineage.taskExecutionId === "execution-noisy",
+        activity.lineage.taskAttemptId === "execution-noisy",
     ),
   );
   assert.ok(
@@ -221,7 +221,7 @@ test("buildSampleActivities surfaces semantic activity kinds without creating ac
       (activity) =>
         activity.kind === "context" &&
         activity.band === "tools" &&
-        activity.lineage.taskExecutionId === "execution-noisy",
+        activity.lineage.taskAttemptId === "execution-noisy",
     ),
   );
   assert.ok(
diff --git a/ergon-dashboard/src/features/activity/buildSampleActivities.ts b/ergon-dashboard/src/features/activity/buildSampleActivities.ts
index c5f628d06..d424df034 100644
--- a/ergon-dashboard/src/features/activity/buildSampleActivities.ts
+++ b/ergon-dashboard/src/features/activity/buildSampleActivities.ts
@@ -71,7 +71,7 @@ function executionActivities(
         },
         lineage: {
           taskId: execution.taskId,
-          taskExecutionId: execution.id,
+          taskAttemptId: execution.id,
           agentId: execution.agentId,
         },
         debug: {
@@ -195,11 +195,11 @@ function contextActivities(run: SampleWorkspaceState): SampleActivity[] {
           eventId: event.id,
           eventType: event.eventType,
           contextSequence: event.sequence ?? null,
-          taskExecutionId: event.taskExecutionId,
+          taskAttemptId: event.taskAttemptId,
         },
         lineage: {
           taskId,
-          taskExecutionId: event.taskExecutionId,
+          taskAttemptId: event.taskAttemptId,
           workerBindingKey: event.workerBindingKey,
         },
         debug: {
diff --git a/ergon-dashboard/src/features/activity/components/ActivityStackTimeline.tsx b/ergon-dashboard/src/features/activity/components/ActivityStackTimeline.tsx
index b7275e9f2..6aff2588f 100644
--- a/ergon-dashboard/src/features/activity/components/ActivityStackTimeline.tsx
+++ b/ergon-dashboard/src/features/activity/components/ActivityStackTimeline.tsx
@@ -69,7 +69,7 @@ function lineageValueMatches(
 function areActivitiesRelated(a: SampleActivity, b: SampleActivity): boolean {
   if (a.id === b.id) return true;
   return (
-    lineageValueMatches(a.lineage.taskExecutionId, b.lineage.taskExecutionId) ||
+    lineageValueMatches(a.lineage.taskAttemptId, b.lineage.taskAttemptId) ||
     lineageValueMatches(a.lineage.sandboxId, b.lineage.sandboxId) ||
     lineageValueMatches(a.lineage.threadId, b.lineage.threadId) ||
     lineageValueMatches(a.lineage.taskId, b.lineage.taskId)
@@ -118,7 +118,7 @@ function ActivityLineageCard({
         <span>Band: {activity.band}</span>
         <span>Source: {activity.debug.source}</span>
         <span>Task: {activity.lineage.taskId ?? "—"}</span>
-        <span>Execution: {activity.lineage.taskExecutionId ?? "—"}</span>
+        <span>Execution: {activity.lineage.taskAttemptId ?? "—"}</span>
         <span>Sandbox: {activity.lineage.sandboxId ?? "—"}</span>
         <span>Seq: {activity.sequence ?? "—"}</span>
       </div>
diff --git a/ergon-dashboard/src/features/activity/snapshotSequence.test.ts b/ergon-dashboard/src/features/activity/snapshotSequence.test.ts
index 11884d12b..849884ee9 100644
--- a/ergon-dashboard/src/features/activity/snapshotSequence.test.ts
+++ b/ergon-dashboard/src/features/activity/snapshotSequence.test.ts
@@ -19,7 +19,7 @@ function activity(overrides: Partial<SampleActivity> = {}): SampleActivity {
     actor: null,
     sourceKind: "execution.span",
     metadata: {},
-    lineage: { taskId: "task-1", taskExecutionId: "activity-1" },
+    lineage: { taskId: "task-1", taskAttemptId: "activity-1" },
     ...overrides,
     debug: overrides.debug ?? { source: "execution.span", payload: { id: "activity-1" } },
   };
diff --git a/ergon-dashboard/src/features/activity/stackLayout.test.ts b/ergon-dashboard/src/features/activity/stackLayout.test.ts
index f1c2daa60..5bc73cf5e 100644
--- a/ergon-dashboard/src/features/activity/stackLayout.test.ts
+++ b/ergon-dashboard/src/features/activity/stackLayout.test.ts
@@ -23,7 +23,7 @@ function activity(
     actor,
     sourceKind: "execution.span",
     metadata: {},
-    lineage: { taskId: id, taskExecutionId: id },
+    lineage: { taskId: id, taskAttemptId: id },
     debug: { source: "execution.span", payload: { id } },
   };
 }
diff --git a/ergon-dashboard/src/features/activity/types.ts b/ergon-dashboard/src/features/activity/types.ts
index a2639006b..e88587296 100644
--- a/ergon-dashboard/src/features/activity/types.ts
+++ b/ergon-dashboard/src/features/activity/types.ts
@@ -18,7 +18,7 @@ export type ActivityBand =
 
 export interface ActivityLineage {
   taskId?: string | null;
-  taskExecutionId?: string | null;
+  taskAttemptId?: string | null;
   sandboxId?: string | null;
   agentId?: string | null;
   workerBindingKey?: string | null;
diff --git a/ergon-dashboard/src/generated/events/DashboardContextEventEvent.ts b/ergon-dashboard/src/generated/events/DashboardContextEventEvent.ts
index 81ed9c347..afe5e5f49 100644
--- a/ergon-dashboard/src/generated/events/DashboardContextEventEvent.ts
+++ b/ergon-dashboard/src/generated/events/DashboardContextEventEvent.ts
@@ -1,3 +1,3 @@
 import { z } from "zod"
 
-export const DashboardContextEventEventSchema = z.object({ "id": z.string().uuid().describe("SampleContextEvent.id used by the frontend as a stable deduplication key."), "sample_id": z.string().uuid(), "task_execution_id": z.string().uuid(), "task_id": z.string().uuid().describe("Graph task id resolved from the task execution by the dashboard emitter at event emission time."), "worker_binding_key": z.string(), "sequence": z.number().int(), "event_type": z.enum(["system_prompt","user_message","assistant_text","tool_call","tool_result","thinking"]), "payload": z.any().describe("Typed context event payload serialized with model_dump(mode='json') before being sent through Inngest."), "created_at": z.string().datetime({ offset: true }), "started_at": z.union([z.string().datetime({ offset: true }), z.null()]), "completed_at": z.union([z.string().datetime({ offset: true }), z.null()]) }).catchall(z.any())
+export const DashboardContextEventEventSchema = z.object({ "id": z.string().uuid().describe("SampleContextEvent.id used by the frontend as a stable deduplication key."), "sample_id": z.string().uuid(), "task_attempt_id": z.string().uuid(), "task_id": z.string().uuid().describe("Graph task id resolved from the task execution by the dashboard emitter at event emission time."), "worker_binding_key": z.string(), "sequence": z.number().int(), "event_type": z.enum(["system_prompt","user_message","assistant_text","tool_call","tool_result","thinking"]), "payload": z.any().describe("Typed context event payload serialized with model_dump(mode='json') before being sent through Inngest."), "created_at": z.string().datetime({ offset: true }), "started_at": z.union([z.string().datetime({ offset: true }), z.null()]), "completed_at": z.union([z.string().datetime({ offset: true }), z.null()]) }).catchall(z.any())
diff --git a/ergon-dashboard/src/generated/events/DashboardResourcePublishedEvent.ts b/ergon-dashboard/src/generated/events/DashboardResourcePublishedEvent.ts
index c21c8ce5d..2e515047c 100644
--- a/ergon-dashboard/src/generated/events/DashboardResourcePublishedEvent.ts
+++ b/ergon-dashboard/src/generated/events/DashboardResourcePublishedEvent.ts
@@ -1,3 +1,3 @@
 import { z } from "zod"
 
-export const DashboardResourcePublishedEventSchema = z.object({ "sample_id": z.string().uuid(), "task_id": z.string().uuid(), "task_execution_id": z.string().uuid(), "resource_id": z.string().uuid(), "resource_name": z.string(), "mime_type": z.string(), "size_bytes": z.number().int(), "file_path": z.string(), "timestamp": z.string().datetime({ offset: true }) }).catchall(z.any())
+export const DashboardResourcePublishedEventSchema = z.object({ "sample_id": z.string().uuid(), "task_id": z.string().uuid(), "task_attempt_id": z.string().uuid(), "resource_id": z.string().uuid(), "resource_name": z.string(), "mime_type": z.string(), "size_bytes": z.number().int(), "file_path": z.string(), "timestamp": z.string().datetime({ offset: true }) }).catchall(z.any())
diff --git a/ergon-dashboard/src/generated/events/schemas/DashboardContextEventEvent.schema.json b/ergon-dashboard/src/generated/events/schemas/DashboardContextEventEvent.schema.json
index 28086a9da..5b99fb163 100644
--- a/ergon-dashboard/src/generated/events/schemas/DashboardContextEventEvent.schema.json
+++ b/ergon-dashboard/src/generated/events/schemas/DashboardContextEventEvent.schema.json
@@ -510,9 +510,9 @@
       "title": "Sample Id",
       "type": "string"
     },
-    "task_execution_id": {
+    "task_attempt_id": {
       "format": "uuid",
-      "title": "Task Execution Id",
+      "title": "Task Attempt Id",
       "type": "string"
     },
     "task_id": {
@@ -578,7 +578,7 @@
   "required": [
     "id",
     "sample_id",
-    "task_execution_id",
+    "task_attempt_id",
     "task_id",
     "worker_binding_key",
     "sequence",
diff --git a/ergon-dashboard/src/generated/events/schemas/DashboardResourcePublishedEvent.schema.json b/ergon-dashboard/src/generated/events/schemas/DashboardResourcePublishedEvent.schema.json
index 731059d6a..979d4d0b5 100644
--- a/ergon-dashboard/src/generated/events/schemas/DashboardResourcePublishedEvent.schema.json
+++ b/ergon-dashboard/src/generated/events/schemas/DashboardResourcePublishedEvent.schema.json
@@ -11,9 +11,9 @@
       "title": "Task Id",
       "type": "string"
     },
-    "task_execution_id": {
+    "task_attempt_id": {
       "format": "uuid",
-      "title": "Task Execution Id",
+      "title": "Task Attempt Id",
       "type": "string"
     },
     "resource_id": {
@@ -46,7 +46,7 @@
   "required": [
     "sample_id",
     "task_id",
-    "task_execution_id",
+    "task_attempt_id",
     "resource_id",
     "resource_name",
     "mime_type",
diff --git a/ergon-dashboard/src/generated/events/schemas/DashboardThreadMessageCreatedEvent.schema.json b/ergon-dashboard/src/generated/events/schemas/DashboardThreadMessageCreatedEvent.schema.json
index c8f857a29..f602eaab1 100644
--- a/ergon-dashboard/src/generated/events/schemas/DashboardThreadMessageCreatedEvent.schema.json
+++ b/ergon-dashboard/src/generated/events/schemas/DashboardThreadMessageCreatedEvent.schema.json
@@ -31,7 +31,7 @@
           "default": null,
           "title": "Taskid"
         },
-        "taskExecutionId": {
+        "taskAttemptId": {
           "anyOf": [
             {
               "type": "string"
@@ -41,7 +41,7 @@
             }
           ],
           "default": null,
-          "title": "Taskexecutionid"
+          "title": "Taskattemptid"
         },
         "fromAgentId": {
           "title": "Fromagentid",
diff --git a/ergon-dashboard/src/generated/events/schemas/DashboardWorkflowStartedEvent.schema.json b/ergon-dashboard/src/generated/events/schemas/DashboardWorkflowStartedEvent.schema.json
index 5ed203843..0417f0ac3 100644
--- a/ergon-dashboard/src/generated/events/schemas/DashboardWorkflowStartedEvent.schema.json
+++ b/ergon-dashboard/src/generated/events/schemas/DashboardWorkflowStartedEvent.schema.json
@@ -362,7 +362,7 @@
           "default": null,
           "title": "Taskid"
         },
-        "taskExecutionId": {
+        "taskAttemptId": {
           "anyOf": [
             {
               "type": "string"
@@ -372,7 +372,7 @@
             }
           ],
           "default": null,
-          "title": "Taskexecutionid"
+          "title": "Taskattemptid"
         },
         "fromAgentId": {
           "title": "Fromagentid",
@@ -500,9 +500,9 @@
           "title": "Sampleid",
           "type": "string"
         },
-        "taskExecutionId": {
+        "taskAttemptId": {
           "format": "uuid",
-          "title": "Taskexecutionid",
+          "title": "Taskattemptid",
           "type": "string"
         },
         "taskId": {
@@ -568,7 +568,7 @@
       "required": [
         "id",
         "sampleId",
-        "taskExecutionId",
+        "taskAttemptId",
         "taskId",
         "workerBindingKey",
         "sequence",
@@ -898,8 +898,8 @@
           "title": "Taskid",
           "type": "string"
         },
-        "taskExecutionId": {
-          "title": "Taskexecutionid",
+        "taskAttemptId": {
+          "title": "Taskattemptid",
           "type": "string"
         },
         "name": {
@@ -927,7 +927,7 @@
       "required": [
         "id",
         "taskId",
-        "taskExecutionId",
+        "taskAttemptId",
         "name",
         "mimeType",
         "filePath",
diff --git a/ergon-dashboard/src/generated/rest/contracts.ts b/ergon-dashboard/src/generated/rest/contracts.ts
index 693912d21..754688ddf 100644
--- a/ergon-dashboard/src/generated/rest/contracts.ts
+++ b/ergon-dashboard/src/generated/rest/contracts.ts
@@ -71,7 +71,7 @@ const SampleTaskDto = z.object({
 const SampleResourceDto = z.object({
   id: z.string(),
   taskId: z.string(),
-  taskExecutionId: z.string(),
+  taskAttemptId: z.string(),
   name: z.string(),
   mimeType: z.string(),
   filePath: z.string(),
@@ -251,7 +251,7 @@ const ContextPartChunkLog = z
 const SampleContextEventDto = z.object({
   id: z.string().uuid(),
   sampleId: z.string().uuid(),
-  taskExecutionId: z.string().uuid(),
+  taskAttemptId: z.string().uuid(),
   taskId: z.string().uuid(),
   workerBindingKey: z.string(),
   sequence: z.number().int(),
@@ -274,7 +274,7 @@ const SampleCommunicationMessageDto = z.object({
   threadTopic: z.string(),
   sampleId: z.string(),
   taskId: z.union([z.string(), z.null()]).optional(),
-  taskExecutionId: z.union([z.string(), z.null()]).optional(),
+  taskAttemptId: z.union([z.string(), z.null()]).optional(),
   fromAgentId: z.string(),
   toAgentId: z.string(),
   content: z.string(),
diff --git a/ergon-dashboard/src/generated/rest/openapi.json b/ergon-dashboard/src/generated/rest/openapi.json
index 75d8f9b91..1801e71e9 100644
--- a/ergon-dashboard/src/generated/rest/openapi.json
+++ b/ergon-dashboard/src/generated/rest/openapi.json
@@ -1985,7 +1985,7 @@
             ],
             "title": "Taskid"
           },
-          "taskExecutionId": {
+          "taskAttemptId": {
             "anyOf": [
               {
                 "type": "string"
@@ -2120,7 +2120,7 @@
             "format": "uuid",
             "title": "Sampleid"
           },
-          "taskExecutionId": {
+          "taskAttemptId": {
             "type": "string",
             "format": "uuid",
             "title": "Taskexecutionid"
@@ -2188,7 +2188,7 @@
         "required": [
           "id",
           "sampleId",
-          "taskExecutionId",
+          "taskAttemptId",
           "taskId",
           "workerBindingKey",
           "sequence",
@@ -3189,7 +3189,7 @@
             "type": "string",
             "title": "Taskid"
           },
-          "taskExecutionId": {
+          "taskAttemptId": {
             "type": "string",
             "title": "Taskexecutionid"
           },
@@ -3220,7 +3220,7 @@
         "required": [
           "id",
           "taskId",
-          "taskExecutionId",
+          "taskAttemptId",
           "name",
           "mimeType",
           "filePath",
diff --git a/ergon-dashboard/src/inngest/functions/index.ts b/ergon-dashboard/src/inngest/functions/index.ts
index 8394e75b4..4fe8e8e10 100644
--- a/ergon-dashboard/src/inngest/functions/index.ts
+++ b/ergon-dashboard/src/inngest/functions/index.ts
@@ -222,7 +222,7 @@ const onResourcePublished = inngest.createFunction(
     const {
       sample_id,
       task_id,
-      task_execution_id,
+      task_attempt_id,
       resource_id,
       resource_name,
       mime_type,
@@ -243,7 +243,7 @@ const onResourcePublished = inngest.createFunction(
     const resource: ResourceState = {
       id: resource_id,
       taskId: task_id,
-      taskExecutionId: task_execution_id,
+      taskAttemptId: task_attempt_id,
       name: resource_name,
       mimeType: mime_type,
       sizeBytes: size_bytes,
diff --git a/ergon-dashboard/src/inngest/functions/onContextEvent.ts b/ergon-dashboard/src/inngest/functions/onContextEvent.ts
index c657cd8cb..4279eb407 100644
--- a/ergon-dashboard/src/inngest/functions/onContextEvent.ts
+++ b/ergon-dashboard/src/inngest/functions/onContextEvent.ts
@@ -13,7 +13,7 @@ export const onContextEvent = inngest.createFunction(
     const contextEvent: ContextEventState = {
       id: payload.id,
       sampleId: payload.sample_id,
-      taskExecutionId: payload.task_execution_id,
+      taskAttemptId: payload.task_attempt_id,
       taskId: payload.task_id,
       workerBindingKey: payload.worker_binding_key,
       sequence: payload.sequence,
diff --git a/ergon-dashboard/src/lib/contracts/contextEvents.ts b/ergon-dashboard/src/lib/contracts/contextEvents.ts
index cf64569b5..64c4dc7a5 100644
--- a/ergon-dashboard/src/lib/contracts/contextEvents.ts
+++ b/ergon-dashboard/src/lib/contracts/contextEvents.ts
@@ -64,7 +64,7 @@ export type ContextEventPayload =
 export interface ContextEventState {
   id: string;
   sampleId: string;
-  taskExecutionId: string;
+  taskAttemptId: string;
   taskId: string;
   workerBindingKey: string;
   sequence: number;
diff --git a/ergon-dashboard/src/lib/sample-state/contextEvents.ts b/ergon-dashboard/src/lib/sample-state/contextEvents.ts
index 8680bec50..4f0495d4f 100644
--- a/ergon-dashboard/src/lib/sample-state/contextEvents.ts
+++ b/ergon-dashboard/src/lib/sample-state/contextEvents.ts
@@ -94,8 +94,8 @@ export function compareContextEvents(a: ContextEventState, b: ContextEventState)
   if (Number.isFinite(at) && Number.isFinite(bt) && at !== bt) {
     return at - bt;
   }
-  if (a.taskExecutionId !== b.taskExecutionId) {
-    return a.taskExecutionId.localeCompare(b.taskExecutionId);
+  if (a.taskAttemptId !== b.taskAttemptId) {
+    return a.taskAttemptId.localeCompare(b.taskAttemptId);
   }
   return a.sequence - b.sequence;
 }
diff --git a/ergon-dashboard/src/lib/sample-state/hydrate.ts b/ergon-dashboard/src/lib/sample-state/hydrate.ts
index 69eacc754..5efb36ba5 100644
--- a/ergon-dashboard/src/lib/sample-state/hydrate.ts
+++ b/ergon-dashboard/src/lib/sample-state/hydrate.ts
@@ -81,7 +81,7 @@ function deserializeContextEvents(data: SampleSnapshot): Map<string, ContextEven
         .map((event) => ({
           id: String(event.id ?? ""),
           sampleId: String(event.sampleId ?? data.id),
-          taskExecutionId: String(event.taskExecutionId ?? ""),
+          taskAttemptId: String(event.taskAttemptId ?? ""),
           taskId: String(event.taskId ?? taskId),
           workerBindingKey: String(event.workerBindingKey ?? ""),
           sequence: Number(event.sequence ?? 0),
diff --git a/ergon-dashboard/src/lib/types.ts b/ergon-dashboard/src/lib/types.ts
index ca73ccca1..3b38f0984 100644
--- a/ergon-dashboard/src/lib/types.ts
+++ b/ergon-dashboard/src/lib/types.ts
@@ -210,7 +210,7 @@ export interface ExecutionAttemptState {
 export interface ResourceState {
   id: string;
   taskId: string;
-  taskExecutionId: string;
+  taskAttemptId: string;
   name: string;
   mimeType: string;
   sizeBytes: number;
diff --git a/ergon-dashboard/tests/contracts/contracts.test.ts b/ergon-dashboard/tests/contracts/contracts.test.ts
index ccd65c3f4..bed1b094d 100644
--- a/ergon-dashboard/tests/contracts/contracts.test.ts
+++ b/ergon-dashboard/tests/contracts/contracts.test.ts
@@ -69,7 +69,7 @@ test("run snapshot hydration orders context events across retried executions", (
   const retryEvent = {
     ...first,
     id: "eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee",
-    taskExecutionId: "99999999-9999-4999-8999-999999999998",
+    taskAttemptId: "99999999-9999-4999-8999-999999999998",
     sequence: 0,
     createdAt: "2026-03-18T12:00:30.000Z",
     payload: {
@@ -403,7 +403,7 @@ test("dashboard context event parser accepts backend context part payloads", ()
   const parsed = parseDashboardContextEventData({
     id: "88888888-8888-4888-8888-888888888888",
     sample_id: FIXTURE_IDS.sampleId,
-    task_execution_id: "99999999-9999-4999-8999-999999999999",
+    task_attempt_id: "99999999-9999-4999-8999-999999999999",
     task_id: FIXTURE_IDS.solveTaskNodeUuid,
     worker_binding_key: "swebench-smoke-worker",
     sequence: 0,
diff --git a/ergon-dashboard/tests/fixtures/mas-samples/concurrent-mas-run.json b/ergon-dashboard/tests/fixtures/mas-samples/concurrent-mas-run.json
index 8bd3551ac..25df2d11f 100644
--- a/ergon-dashboard/tests/fixtures/mas-samples/concurrent-mas-run.json
+++ b/ergon-dashboard/tests/fixtures/mas-samples/concurrent-mas-run.json
@@ -124,7 +124,7 @@
         {
           "id": "20000000-0000-4000-8000-000000000001",
           "taskId": "10000000-0000-4000-8000-000000000002",
-          "taskExecutionId": "30000000-0000-4000-8000-000000000001",
+          "taskAttemptId": "30000000-0000-4000-8000-000000000001",
           "name": "references.md",
           "mimeType": "text/markdown",
           "filePath": "/workspace/references.md",
@@ -227,7 +227,7 @@
             "threadTopic": "task_clarification",
             "sampleId": "99999999-9999-4999-8999-999999999999",
             "taskId": "10000000-0000-4000-8000-000000000003",
-            "taskExecutionId": "30000000-0000-4000-8000-000000000002",
+            "taskAttemptId": "30000000-0000-4000-8000-000000000002",
             "fromAgentId": "agent-b",
             "toAgentId": "stakeholder",
             "content": "Should I reject ungrounded claims?",
@@ -283,7 +283,7 @@
         {
           "id": "60000000-0000-4000-8000-000000000001",
           "sampleId": "99999999-9999-4999-8999-999999999999",
-          "taskExecutionId": "30000000-0000-4000-8000-000000000001",
+          "taskAttemptId": "30000000-0000-4000-8000-000000000001",
           "taskId": "10000000-0000-4000-8000-000000000002",
           "workerBindingKey": "researcher-a",
           "sequence": 0,
diff --git a/ergon-dashboard/tests/helpers/dashboardFixtures.ts b/ergon-dashboard/tests/helpers/dashboardFixtures.ts
index d4f6c6844..c1839a613 100644
--- a/ergon-dashboard/tests/helpers/dashboardFixtures.ts
+++ b/ergon-dashboard/tests/helpers/dashboardFixtures.ts
@@ -84,7 +84,7 @@ function serializedRunState(): SerializedSampleWorkspaceState {
     {
       id: FIXTURE_IDS.toolCallEventId,
       sampleId: FIXTURE_IDS.sampleId,
-      taskExecutionId: FIXTURE_IDS.solveExecutionId,
+      taskAttemptId: FIXTURE_IDS.solveExecutionId,
       taskId: FIXTURE_IDS.solveTaskNodeUuid,
       workerBindingKey: "react-worker",
       sequence: 0,
@@ -112,7 +112,7 @@ function serializedRunState(): SerializedSampleWorkspaceState {
     {
       id: FIXTURE_IDS.toolResultEventId,
       sampleId: FIXTURE_IDS.sampleId,
-      taskExecutionId: FIXTURE_IDS.solveExecutionId,
+      taskAttemptId: FIXTURE_IDS.solveExecutionId,
       taskId: FIXTURE_IDS.solveTaskNodeUuid,
       workerBindingKey: "react-worker",
       sequence: 1,
@@ -159,7 +159,7 @@ function serializedRunState(): SerializedSampleWorkspaceState {
         {
           id: "resource-proof",
           taskId: FIXTURE_IDS.solveTaskId,
-          taskExecutionId: "execution-1",
+          taskAttemptId: "execution-1",
           name: "proof.lean",
           mimeType: "text/plain",
           sizeBytes: 320,
@@ -374,7 +374,7 @@ export function createDeltaContextEvent(): ContextEventState {
   return {
     id: FIXTURE_IDS.deltaToolCallEventId,
     sampleId: FIXTURE_IDS.sampleId,
-    taskExecutionId: "execution-solve-1",
+    taskAttemptId: "execution-solve-1",
     taskId: FIXTURE_IDS.solveTaskId,
     workerBindingKey: "react-worker",
     sequence: 2,
diff --git a/ergon_builtins/ergon_builtins/toolkits/resources/models.py b/ergon_builtins/ergon_builtins/toolkits/resources/models.py
index 0d4872cea..42ff3835d 100644
--- a/ergon_builtins/ergon_builtins/toolkits/resources/models.py
+++ b/ergon_builtins/ergon_builtins/toolkits/resources/models.py
@@ -41,10 +41,9 @@ class ResourceRef(BaseModel):
     created_at: datetime = Field(
         description="Row insertion time -- used to disambiguate latest-wins reads.",
     )
-    producing_task_execution_id: UUID | None = Field(
+    producing_task_attempt_id: UUID | None = Field(
         description=(
-            "Task execution that produced the resource; ``None`` for "
-            "run-scoped (non-task) resources."
+            "Task attempt that produced the resource; ``None`` for sample-scoped resources."
         ),
     )
 
@@ -58,7 +57,7 @@ def from_view(cls, view: SampleResourceView) -> "ResourceRef":
             file_path=view.file_path,
             content_hash=view.content_hash,
             created_at=view.created_at,
-            producing_task_execution_id=view.task_execution_id,
+            producing_task_attempt_id=view.task_attempt_id,
         )
 
     @classmethod
@@ -71,21 +70,21 @@ def from_row(cls, row: SampleResource) -> "ResourceRef":
             file_path=row.file_path,
             content_hash=row.content_hash,
             created_at=row.created_at,
-            producing_task_execution_id=row.task_execution_id,
+            producing_task_attempt_id=row.task_attempt_id,
         )
 
 
-class TaskExecutionRef(BaseModel):
+class TaskAttemptRef(BaseModel):
     """Subset of ``SampleTaskAttempt`` surfaced to the LLM."""
 
     model_config = ConfigDict(frozen=True)
 
-    task_execution_id: UUID = Field(
-        description="Primary key of the ``run_task_executions`` row.",
+    task_attempt_id: UUID = Field(
+        description="Primary key of the ``sample_task_attempts`` row.",
     )
     status: str = Field(
         description=(
-            "Task execution status (e.g. ``pending``, ``running``, ``completed``, ``failed``)."
+            "Task attempt status (e.g. ``pending``, ``running``, ``completed``, ``failed``)."
         ),
     )
     started_at: datetime | None = Field(
@@ -98,10 +97,10 @@ class TaskExecutionRef(BaseModel):
     )
 
     @classmethod
-    def from_row(cls, row: SampleTaskAttempt) -> "TaskExecutionRef":
-        """Lift an ORM ``SampleTaskAttempt`` row to a ``TaskExecutionRef``."""
+    def from_row(cls, row: SampleTaskAttempt) -> "TaskAttemptRef":
+        """Lift an ORM ``SampleTaskAttempt`` row to a ``TaskAttemptRef``."""
         return cls(
-            task_execution_id=row.id,
+            task_attempt_id=row.id,
             status=str(row.status),
             started_at=row.started_at,
             ended_at=row.completed_at,
diff --git a/ergon_builtins/ergon_builtins/toolkits/resources/toolkit.py b/ergon_builtins/ergon_builtins/toolkits/resources/toolkit.py
index 4b3b80232..159303225 100644
--- a/ergon_builtins/ergon_builtins/toolkits/resources/toolkit.py
+++ b/ergon_builtins/ergon_builtins/toolkits/resources/toolkit.py
@@ -1,4 +1,4 @@
-"""ResearchGraphToolkit — run-scoped resource discovery for research workers.
+"""ResearchGraphToolkit — sample-scoped resource discovery for research workers.
 
 Six pydantic-ai tools backed by resource and task repositories
 traversal so workers can enumerate their own, children's, and descendants'
@@ -25,15 +25,15 @@
 
 
 class ResearchGraphToolkit:
-    """Graph observability tools for run-scoped resource discovery.
+    """Graph observability tools for sample-scoped resource discovery.
 
     Constructor takes explicit IDs — no ``WorkerContext``.  The worker
     subclass unpacks context and passes them in (§7.3 pattern).
     """
 
-    def __init__(self, *, sample_id: UUID, task_execution_id: UUID) -> None:
+    def __init__(self, *, sample_id: UUID, task_attempt_id: UUID) -> None:
         self._sample_id = sample_id
-        self._task_execution_id = task_execution_id
+        self._task_attempt_id = task_attempt_id
         self._resource_repo = SampleResourceRepository()
         self._task_repo = TaskExecutionRepository()
 
@@ -45,7 +45,7 @@ def build_tools(self) -> list[Tool[AgentToolBudgetDeps]]:
             self._list_my_resources(),
             self._list_child_resources(),
             self._list_descendant_resources(),
-            self._list_run_resources(),
+            self._list_sample_resources(),
             self._get_resource_by_logical_path(),
             self._get_resource_by_content_hash(),
         ]
@@ -56,15 +56,15 @@ def build_tools(self) -> list[Tool[AgentToolBudgetDeps]]:
 
     def _list_my_resources(self) -> Tool[AgentToolBudgetDeps]:
         sample_id = self._sample_id
-        task_execution_id = self._task_execution_id
+        task_attempt_id = self._task_attempt_id
 
         async def list_my_resources(
             ctx: "RunContext[AgentToolBudgetDeps]",
         ) -> list[ResourceRef] | AgentToolBudgetExhaustedResult:
-            """List resources produced by my own task execution.
+            """List resources produced by my own task attempt.
 
             Returns resources in most-recently-created-first order.
-            Only resources belonging to this run are included.
+            Only resources belonging to this sample are included.
             """
             tool_budget = ctx.deps.tool_budget
             if (
@@ -73,7 +73,7 @@ async def list_my_resources(
             ):
                 return tool_budget.exhausted_result("non-workflow tool budget reached")
             with get_session() as session:
-                rows = self._resource_repo.list_by_execution(session, task_execution_id)
+                rows = self._resource_repo.list_by_execution(session, task_attempt_id)
             return _to_refs_sorted(
                 [r for r in rows if r.sample_id == sample_id],
             )
@@ -86,12 +86,12 @@ async def list_my_resources(
 
     def _list_child_resources(self) -> Tool[AgentToolBudgetDeps]:
         sample_id = self._sample_id
-        task_execution_id = self._task_execution_id
+        task_attempt_id = self._task_attempt_id
 
         async def list_child_resources(
             ctx: "RunContext[AgentToolBudgetDeps]",
         ) -> list[ResourceRef] | AgentToolBudgetExhaustedResult:
-            """List resources produced by direct child task executions.
+            """List resources produced by direct child task attempts.
 
             Only returns resources from immediate children — not
             grandchildren or deeper descendants.
@@ -105,7 +105,7 @@ async def list_child_resources(
             with get_session() as session:
                 children = self._task_repo.list_children_of_execution(
                     session,
-                    task_execution_id,
+                    task_attempt_id,
                 )
             result: list[SampleResource] = []
             for child in children:
@@ -122,15 +122,15 @@ async def list_child_resources(
 
     def _list_descendant_resources(self) -> Tool[AgentToolBudgetDeps]:
         sample_id = self._sample_id
-        task_execution_id = self._task_execution_id
+        task_attempt_id = self._task_attempt_id
 
         async def list_descendant_resources(
             ctx: "RunContext[AgentToolBudgetDeps]",
             max_depth: int = 3,
         ) -> list[ResourceRef] | AgentToolBudgetExhaustedResult:
-            """List resources from descendant task executions (BFS).
+            """List resources from descendant task attempts (BFS).
 
-            Traverses child task executions up to *max_depth* levels deep,
+            Traverses child task attempts up to *max_depth* levels deep,
             collecting all resources produced at each level.  Handles
             cycles gracefully via a visited set.
 
@@ -143,8 +143,8 @@ async def list_descendant_resources(
                 > tool_budget.max_other_tool_calls
             ):
                 return tool_budget.exhausted_result("non-workflow tool budget reached")
-            visited: set[UUID] = {task_execution_id}
-            frontier: list[UUID] = [task_execution_id]
+            visited: set[UUID] = {task_attempt_id}
+            frontier: list[UUID] = [task_attempt_id]
             result: list[SampleResource] = []
 
             for _depth in range(max_depth):
@@ -172,23 +172,23 @@ async def list_descendant_resources(
         return Tool(function=list_descendant_resources, takes_ctx=True)
 
     # ------------------------------------------------------------------
-    # list_run_resources
+    # list_sample_resources
     # ------------------------------------------------------------------
 
-    def _list_run_resources(self) -> Tool[AgentToolBudgetDeps]:
+    def _list_sample_resources(self) -> Tool[AgentToolBudgetDeps]:
         sample_id = self._sample_id
 
-        async def list_run_resources(
+        async def list_sample_resources(
             ctx: "RunContext[AgentToolBudgetDeps]",
         ) -> list[ResourceRef] | AgentToolBudgetExhaustedResult:
-            """List all resources in this run.
+            """List all resources in this sample.
 
-            Returns every resource row belonging to the current run,
+            Returns every resource row belonging to the current sample,
             in most-recently-created-first order.
             """
             tool_budget = ctx.deps.tool_budget
             if (
-                tool_budget.increment("list_run_resources", "other")
+                tool_budget.increment("list_sample_resources", "other")
                 > tool_budget.max_other_tool_calls
             ):
                 return tool_budget.exhausted_result("non-workflow tool budget reached")
@@ -196,7 +196,7 @@ async def list_run_resources(
                 rows = self._resource_repo.list_by_run(session, sample_id)
             return _to_refs_sorted(rows)
 
-        return Tool(function=list_run_resources, takes_ctx=True)
+        return Tool(function=list_sample_resources, takes_ctx=True)
 
     # ------------------------------------------------------------------
     # get_resource_by_logical_path
@@ -211,7 +211,7 @@ async def get_resource_by_logical_path(
         ) -> ResourceRef | AgentToolBudgetExhaustedResult | None:
             """Look up the latest resource by its logical path (file_path).
 
-            Scoped to this run. Returns the most recently created resource
+            Scoped to this sample. Returns the most recently created resource
             with the given path, or null if none exists.
 
             Args:
@@ -246,7 +246,7 @@ async def get_resource_by_content_hash(
         ) -> ResourceRef | AgentToolBudgetExhaustedResult | None:
             """Look up the latest resource by its content hash.
 
-            Scoped to this run. Returns the most recently created resource
+            Scoped to this sample. Returns the most recently created resource
             with the given hash, or null if none exists.
 
             Args:
diff --git a/ergon_builtins/ergon_builtins/tools/graph_toolkit_types.py b/ergon_builtins/ergon_builtins/tools/graph_toolkit_types.py
index 7b523dd4a..b5ee99eaa 100644
--- a/ergon_builtins/ergon_builtins/tools/graph_toolkit_types.py
+++ b/ergon_builtins/ergon_builtins/tools/graph_toolkit_types.py
@@ -1,5 +1,5 @@
 """Deprecated compatibility import for ``ergon_builtins.toolkits.resources.models``."""
 
-from ergon_builtins.toolkits.resources.models import ResourceRef, TaskExecutionRef
+from ergon_builtins.toolkits.resources.models import ResourceRef, TaskAttemptRef
 
-__all__ = ["ResourceRef", "TaskExecutionRef"]
+__all__ = ["ResourceRef", "TaskAttemptRef"]
diff --git a/ergon_builtins/tests/unit/builtins/common/test_transcript_adapters.py b/ergon_builtins/tests/unit/builtins/common/test_transcript_adapters.py
index b052e57a1..a43f41a98 100644
--- a/ergon_builtins/tests/unit/builtins/common/test_transcript_adapters.py
+++ b/ergon_builtins/tests/unit/builtins/common/test_transcript_adapters.py
@@ -34,7 +34,7 @@ def _make_event(part, sequence: int, turn_id: str | None = None) -> SampleContex
     )
     return SampleContextEvent(
         sample_id=uuid4(),
-        task_execution_id=uuid4(),
+        task_attempt_id=uuid4(),
         worker_binding_key="test-worker",
         sequence=sequence,
         event_type=part.part_kind,
diff --git a/ergon_builtins/tests/unit/state/test_research_rubrics_benchmark.py b/ergon_builtins/tests/unit/state/test_research_rubrics_benchmark.py
index b9cf1a859..3d908c471 100644
--- a/ergon_builtins/tests/unit/state/test_research_rubrics_benchmark.py
+++ b/ergon_builtins/tests/unit/state/test_research_rubrics_benchmark.py
@@ -38,7 +38,7 @@ def _resource_view(
         SampleResourceView(
             id=resource_id,
             sample_id=uuid4(),
-            task_execution_id=uuid4(),
+            task_attempt_id=uuid4(),
             kind=kind,
             name=name,
             mime_type="text/markdown",
diff --git a/ergon_cli/tests/unit/cli/test_workflow_cli.py b/ergon_cli/tests/unit/cli/test_workflow_cli.py
index 8c4c48847..1ac8efcaa 100644
--- a/ergon_cli/tests/unit/cli/test_workflow_cli.py
+++ b/ergon_cli/tests/unit/cli/test_workflow_cli.py
@@ -73,7 +73,7 @@ def test_resource_list_json_uses_injected_context() -> None:
     resource = WorkflowResourceRef(
         resource_id=uuid4(),
         sample_id=sample_id,
-        task_execution_id=uuid4(),
+        task_attempt_id=uuid4(),
         task_id=task_id,
         task_slug="research",
         kind="report",
diff --git a/ergon_core/ergon_core/api/worker/context.py b/ergon_core/ergon_core/api/worker/context.py
index 76a63dd42..ea32a4f0e 100644
--- a/ergon_core/ergon_core/api/worker/context.py
+++ b/ergon_core/ergon_core/api/worker/context.py
@@ -248,7 +248,7 @@ async def resources(
         return self.resource_service.list_for_run(
             sample_id=self.sample_id,
             task_id=task_id,
-            task_execution_id=execution_id,
+            task_attempt_id=execution_id,
             kind=kind,
             name=name,
         )
diff --git a/ergon_core/ergon_core/core/application/communication/models.py b/ergon_core/ergon_core/core/application/communication/models.py
index c89032458..144bf420f 100644
--- a/ergon_core/ergon_core/core/application/communication/models.py
+++ b/ergon_core/ergon_core/core/application/communication/models.py
@@ -20,7 +20,7 @@ class CreateMessageRequest(BaseModel):
         description="Optional human-readable summary set when the thread is first created.",
     )
     content: str
-    task_execution_id: UUID | None = None
+    task_attempt_id: UUID | None = None
 
 
 class MessageResponse(BaseModel):
@@ -32,7 +32,7 @@ class MessageResponse(BaseModel):
     to_agent_id: str
     content: str
     sequence_num: int
-    task_execution_id: UUID | None = None
+    task_attempt_id: UUID | None = None
     created_at: datetime
 
 
diff --git a/ergon_core/ergon_core/core/application/communication/service.py b/ergon_core/ergon_core/core/application/communication/service.py
index 600754eaf..95f3328ee 100644
--- a/ergon_core/ergon_core/core/application/communication/service.py
+++ b/ergon_core/ergon_core/core/application/communication/service.py
@@ -51,7 +51,7 @@ async def save_message(self, request: CreateMessageRequest) -> MessageResponse:
             message = ThreadMessage(
                 thread_id=thread.id,
                 sample_id=request.sample_id,
-                task_execution_id=request.task_execution_id,
+                task_attempt_id=request.task_attempt_id,
                 from_agent_id=request.from_agent_id,
                 to_agent_id=request.to_agent_id,
                 content=request.content,
@@ -74,7 +74,7 @@ async def save_message(self, request: CreateMessageRequest) -> MessageResponse:
                 to_agent_id=message.to_agent_id,
                 content=message.content,
                 sequence_num=message.sequence_num,
-                task_execution_id=message.task_execution_id,
+                task_attempt_id=message.task_attempt_id,
                 created_at=message.created_at,
             )
 
@@ -98,7 +98,7 @@ async def save_message(self, request: CreateMessageRequest) -> MessageResponse:
             to_agent_id=message.to_agent_id,
             content=message.content,
             sequence_num=message.sequence_num,
-            task_execution_id=str(message.task_execution_id) if message.task_execution_id else None,
+            task_attempt_id=str(message.task_attempt_id) if message.task_attempt_id else None,
             created_at=message.created_at,
         )
         try:
@@ -138,7 +138,7 @@ def get_thread_messages(self, thread_id: UUID) -> list[MessageResponse]:
                     to_agent_id=m.to_agent_id,
                     content=m.content,
                     sequence_num=m.sequence_num,
-                    task_execution_id=m.task_execution_id,
+                    task_attempt_id=m.task_attempt_id,
                     created_at=m.created_at,
                 )
                 for m in messages
@@ -204,8 +204,8 @@ def _get_or_create_thread(
         thread_summary: str | None = None,
     ) -> Thread:
         # Threads are keyed by (sample_id, topic) only — all senders on the same
-        # topic share one thread per run (broadcast/group semantics).
-        # The unique constraint uq_threads_run_topic enforces this at the DB level
+        # topic share one thread per sample (broadcast/group semantics).
+        # The unique constraint uq_threads_sample_topic enforces this at the DB level
         # and lets us safely retry on concurrent INSERT races.
         stmt = select(Thread).where(Thread.sample_id == sample_id).where(Thread.topic == topic)
         existing = session.exec(stmt).first()
diff --git a/ergon_core/ergon_core/core/application/context/service.py b/ergon_core/ergon_core/core/application/context/service.py
index ad5995ffb..f1619351c 100644
--- a/ergon_core/ergon_core/core/application/context/service.py
+++ b/ergon_core/ergon_core/core/application/context/service.py
@@ -53,7 +53,7 @@ def _make_event(
     ) -> SampleContextEvent:
         return SampleContextEvent(
             sample_id=sample_id,
-            task_execution_id=execution_id,
+            task_attempt_id=execution_id,
             worker_binding_key=worker_binding_key,
             sequence=sequence,
             event_type=payload.part.part_kind,
@@ -132,7 +132,7 @@ async def persist_chunk(
     def get_for_execution(self, session: Session, execution_id: UUID) -> list[SampleContextEvent]:
         stmt = (
             select(SampleContextEvent)
-            .where(SampleContextEvent.task_execution_id == execution_id)
+            .where(SampleContextEvent.task_attempt_id == execution_id)
             .order_by(SampleContextEvent.sequence)
         )
         return list(session.exec(stmt).all())
@@ -141,6 +141,6 @@ def get_for_run(self, session: Session, sample_id: UUID) -> list[SampleContextEv
         stmt = (
             select(SampleContextEvent)
             .where(SampleContextEvent.sample_id == sample_id)
-            .order_by(SampleContextEvent.task_execution_id, SampleContextEvent.sequence)
+            .order_by(SampleContextEvent.task_attempt_id, SampleContextEvent.sequence)
         )
         return list(session.exec(stmt).all())
diff --git a/ergon_core/ergon_core/core/application/evaluation/service.py b/ergon_core/ergon_core/core/application/evaluation/service.py
index 1b9b1fee8..ace430b78 100644
--- a/ergon_core/ergon_core/core/application/evaluation/service.py
+++ b/ergon_core/ergon_core/core/application/evaluation/service.py
@@ -102,7 +102,7 @@ async def persist_success(
         self,
         *,
         sample_id: UUID,
-        task_execution_id: UUID,
+        task_attempt_id: UUID,
         task_id: UUID,
         binding_key: str,
         service_result: EvaluationServiceResult,
@@ -115,7 +115,7 @@ async def persist_success(
             evaluation = await _create_task_evaluation(
                 session,
                 sample_id=sample_id,
-                task_execution_id=task_execution_id,
+                task_attempt_id=task_attempt_id,
                 task_id=task_id,
                 evaluator_slug=binding_key,
                 score=result.score,
@@ -141,7 +141,7 @@ async def persist_failure(
         self,
         *,
         sample_id: UUID,
-        task_execution_id: UUID,
+        task_attempt_id: UUID,
         task_id: UUID,
         binding_key: str,
         exc: Exception,
@@ -160,7 +160,7 @@ async def persist_failure(
             await _create_task_evaluation(
                 session,
                 sample_id=sample_id,
-                task_execution_id=task_execution_id,
+                task_attempt_id=task_attempt_id,
                 task_id=task_id,
                 evaluator_slug=binding_key,
                 score=0.0,
@@ -201,7 +201,7 @@ async def _create_task_evaluation(
     session: Session,
     *,
     sample_id: UUID,
-    task_execution_id: UUID,
+    task_attempt_id: UUID,
     task_id: UUID,
     evaluator_slug: str,
     score: float | None = None,
@@ -212,7 +212,7 @@ async def _create_task_evaluation(
     evaluation = SampleTaskEvaluation(
         id=new_id(),
         sample_id=sample_id,
-        task_execution_id=task_execution_id,
+        task_attempt_id=task_attempt_id,
         task_id=task_id,
         evaluator_slug=evaluator_slug,
         score=score,
diff --git a/ergon_core/ergon_core/core/application/events/__init__.py b/ergon_core/ergon_core/core/application/events/__init__.py
index ced792089..a57e63600 100644
--- a/ergon_core/ergon_core/core/application/events/__init__.py
+++ b/ergon_core/ergon_core/core/application/events/__init__.py
@@ -6,6 +6,7 @@
     PropagationCancelCause,
     SampleCancelledEvent,
     SampleCleanupEvent,
+    SampleStartedEvent,
     TaskCancelledEvent,
     TaskCompletedEvent,
     TaskFailedEvent,
@@ -13,7 +14,6 @@
     TaskStartedEvent,
     WorkflowCompletedEvent,
     WorkflowFailedEvent,
-    WorkflowStartedEvent,
 )
 
 __all__ = [
@@ -22,6 +22,7 @@
     "PropagationCancelCause",
     "SampleCancelledEvent",
     "SampleCleanupEvent",
+    "SampleStartedEvent",
     "TaskCancelledEvent",
     "TaskCompletedEvent",
     "TaskFailedEvent",
@@ -29,5 +30,4 @@
     "TaskStartedEvent",
     "WorkflowCompletedEvent",
     "WorkflowFailedEvent",
-    "WorkflowStartedEvent",
 ]
diff --git a/ergon_core/ergon_core/core/application/events/runtime.py b/ergon_core/ergon_core/core/application/events/runtime.py
index 26ee5185b..44145d751 100644
--- a/ergon_core/ergon_core/core/application/events/runtime.py
+++ b/ergon_core/ergon_core/core/application/events/runtime.py
@@ -82,8 +82,8 @@ class TaskFailedEvent(InngestEventContract):
     sandbox_id: str | None = None
 
 
-class WorkflowStartedEvent(InngestEventContract):
-    name: ClassVar[str] = "workflow/started"
+class SampleStartedEvent(InngestEventContract):
+    name: ClassVar[str] = "sample/started"
 
     sample_id: UUID
 
diff --git a/ergon_core/ergon_core/core/application/experiments/submission.py b/ergon_core/ergon_core/core/application/experiments/submission.py
index 5ac45139e..8503c6ceb 100644
--- a/ergon_core/ergon_core/core/application/experiments/submission.py
+++ b/ergon_core/ergon_core/core/application/experiments/submission.py
@@ -10,7 +10,7 @@
 from ergon_core.api.experiment.experiment import Experiment, ExperimentSubmitResult
 from ergon_core.api.experiment.sample import Sample
 from ergon_core.api.experiment.sampling import Sampler, SamplingContext
-from ergon_core.core.application.events.runtime import WorkflowStartedEvent
+from ergon_core.core.application.events.runtime import SampleStartedEvent
 from ergon_core.core.application.experiments.candidate_pool import (
     SampleCandidatePool,
     sample_from_pool_entry,
@@ -30,14 +30,14 @@
 
 
 class EventBus(Protocol):
-    async def publish(self, event: WorkflowStartedEvent) -> None: ...
+    async def publish(self, event: SampleStartedEvent) -> None: ...
 
 
-class InngestWorkflowEventBus:
-    async def publish(self, event: WorkflowStartedEvent) -> None:
+class InngestSampleEventBus:
+    async def publish(self, event: SampleStartedEvent) -> None:
         await inngest_client.send(
             InngestEvent(
-                name=WorkflowStartedEvent.name,
+                name=SampleStartedEvent.name,
                 data=event.model_dump(mode="json"),
             )
         )
@@ -46,7 +46,7 @@ async def publish(self, event: WorkflowStartedEvent) -> None:
 class ExperimentSubmissionService:
     def __init__(self, *, session: Session, event_bus: EventBus | None = None) -> None:
         self._session = session
-        self._event_bus = event_bus or InngestWorkflowEventBus()
+        self._event_bus = event_bus or InngestSampleEventBus()
 
     @classmethod
     def for_session(
@@ -148,7 +148,7 @@ def _materialize_selected(
 
     async def _start_samples(self, sample_ids: Sequence[UUID]) -> None:
         for sample_id in sample_ids:
-            await self._event_bus.publish(WorkflowStartedEvent(sample_id=sample_id))
+            await self._event_bus.publish(SampleStartedEvent(sample_id=sample_id))
 
 
 def _entries_for_selected_samples(
diff --git a/ergon_core/ergon_core/core/application/resources/models.py b/ergon_core/ergon_core/core/application/resources/models.py
index 9d744a32b..0c0b89623 100644
--- a/ergon_core/ergon_core/core/application/resources/models.py
+++ b/ergon_core/ergon_core/core/application/resources/models.py
@@ -21,11 +21,11 @@ class SampleResourceView(BaseModel):
     model_config = ConfigDict(frozen=True)
 
     id: UUID = Field(description="Primary key of the sample_resources row.")
-    sample_id: UUID = Field(description="The run this resource was produced in.")
-    task_execution_id: UUID | None = Field(
+    sample_id: UUID = Field(description="The sample this resource was produced in.")
+    task_attempt_id: UUID | None = Field(
         description=(
-            "The task execution that produced the resource, or ``None`` for "
-            "run-scoped resources (e.g. aggregate reports)."
+            "The task attempt that produced the resource, or ``None`` for "
+            "sample-scoped resources (e.g. aggregate reports)."
         ),
     )
     kind: SampleResourceKind = Field(
@@ -67,7 +67,7 @@ def from_row(cls, row: "_SampleResourceRow") -> "SampleResourceView":
         return cls(
             id=row.id,
             sample_id=row.sample_id,
-            task_execution_id=row.task_execution_id,
+            task_attempt_id=row.task_attempt_id,
             kind=SampleResourceKind(row.kind),
             name=row.name,
             mime_type=row.mime_type,
diff --git a/ergon_core/ergon_core/core/application/resources/publishing.py b/ergon_core/ergon_core/core/application/resources/publishing.py
index 43008a15d..e27771fb9 100644
--- a/ergon_core/ergon_core/core/application/resources/publishing.py
+++ b/ergon_core/ergon_core/core/application/resources/publishing.py
@@ -36,7 +36,7 @@ async def publish_sandbox_files(
         reader: SandboxFileReader,
         blob_store: ResourceBlobWriter,
         sample_id: UUID,
-        task_execution_id: UUID,
+        task_attempt_id: UUID,
         publish_dirs: tuple[tuple[str, SampleResourceKind], ...],
     ) -> list[SampleResourceView]:
         """Publish changed files from configured sandbox dirs as run resources."""
@@ -55,7 +55,7 @@ async def publish_sandbox_files(
                 with self._session_factory() as session:
                     prior = self._resource_repo.latest_by_path(
                         session,
-                        task_execution_id=task_execution_id,
+                        task_attempt_id=task_attempt_id,
                         file_path=str(durable_path),
                     )
                 if prior is not None:
@@ -67,7 +67,7 @@ async def publish_sandbox_files(
                     row = self._resource_repo.append(
                         session,
                         sample_id=sample_id,
-                        task_execution_id=task_execution_id,
+                        task_attempt_id=task_attempt_id,
                         kind=resource_kind.value,
                         name=entry_name,
                         mime_type=self._mime_type(entry_name),
@@ -88,7 +88,7 @@ def publish_value(
         *,
         blob_store: ResourceBlobWriter,
         sample_id: UUID,
-        task_execution_id: UUID,
+        task_attempt_id: UUID,
         kind: SampleResourceKind,
         name: str,
         content: str,
@@ -101,7 +101,7 @@ def publish_value(
         with self._session_factory() as session:
             prior = self._resource_repo.find_by_hash(
                 session,
-                task_execution_id=task_execution_id,
+                task_attempt_id=task_attempt_id,
                 content_hash=content_hash,
             )
         if prior is not None:
@@ -113,7 +113,7 @@ def publish_value(
             row = self._resource_repo.append(
                 session,
                 sample_id=sample_id,
-                task_execution_id=task_execution_id,
+                task_attempt_id=task_attempt_id,
                 kind=kind.value,
                 name=name,
                 mime_type=mime_type,
diff --git a/ergon_core/ergon_core/core/application/resources/repository.py b/ergon_core/ergon_core/core/application/resources/repository.py
index fdd118dca..5144fb022 100644
--- a/ergon_core/ergon_core/core/application/resources/repository.py
+++ b/ergon_core/ergon_core/core/application/resources/repository.py
@@ -19,8 +19,8 @@ def list_by_run(self, session: Session, sample_id: UUID) -> list[SampleResource]
         stmt = select(SampleResource).where(SampleResource.sample_id == sample_id)
         return list(session.exec(stmt).all())
 
-    def list_by_execution(self, session: Session, task_execution_id: UUID) -> list[SampleResource]:
-        stmt = select(SampleResource).where(SampleResource.task_execution_id == task_execution_id)
+    def list_by_execution(self, session: Session, task_attempt_id: UUID) -> list[SampleResource]:
+        stmt = select(SampleResource).where(SampleResource.task_attempt_id == task_attempt_id)
         return list(session.exec(stmt).all())
 
     def list_for_run(
@@ -29,19 +29,19 @@ def list_for_run(
         *,
         sample_id: UUID,
         task_id: UUID | None = None,
-        task_execution_id: UUID | None = None,
+        task_attempt_id: UUID | None = None,
         kind: str | None = None,
         name: str | None = None,
     ) -> list[SampleResourceView]:
         stmt = select(SampleResource).where(SampleResource.sample_id == sample_id)
-        if task_execution_id is not None:
-            execution = session.get(SampleTaskAttempt, task_execution_id)
+        if task_attempt_id is not None:
+            execution = session.get(SampleTaskAttempt, task_attempt_id)
             if execution is None or execution.sample_id != sample_id:
                 raise ContainmentViolation(
                     parent_task_id=task_id,
-                    target_task_id=task_execution_id,
+                    target_task_id=task_attempt_id,
                 )
-            stmt = stmt.where(SampleResource.task_execution_id == task_execution_id)
+            stmt = stmt.where(SampleResource.task_attempt_id == task_attempt_id)
         if task_id is not None:
             node = session.get(SampleGraphNode, (sample_id, task_id))
             if node is None or node.sample_id != sample_id:
@@ -52,7 +52,7 @@ def list_for_run(
                     SampleTaskAttempt.task_id == task_id,
                 )
             ).all()
-            stmt = stmt.where(SampleResource.task_execution_id.in_(execution_ids))
+            stmt = stmt.where(SampleResource.task_attempt_id.in_(execution_ids))
         if kind is not None:
             stmt = stmt.where(SampleResource.kind == kind)
         if name is not None:
@@ -72,13 +72,13 @@ def latest_by_path(
         self,
         session: Session,
         *,
-        task_execution_id: UUID,
+        task_attempt_id: UUID,
         file_path: str,
     ) -> SampleResource | None:
         stmt = (
             select(SampleResource)
             .where(
-                SampleResource.task_execution_id == task_execution_id,
+                SampleResource.task_attempt_id == task_attempt_id,
                 SampleResource.file_path == file_path,
             )
             .order_by(SampleResource.created_at.desc(), SampleResource.id.desc())
@@ -90,13 +90,13 @@ def find_by_hash(
         self,
         session: Session,
         *,
-        task_execution_id: UUID,
+        task_attempt_id: UUID,
         content_hash: str,
     ) -> SampleResource | None:
         stmt = (
             select(SampleResource)
             .where(
-                SampleResource.task_execution_id == task_execution_id,
+                SampleResource.task_attempt_id == task_attempt_id,
                 SampleResource.content_hash == content_hash,
             )
             .limit(1)
@@ -108,7 +108,7 @@ def append(  # slopcop: ignore[max-function-params]
         session: Session,
         *,
         sample_id: UUID,
-        task_execution_id: UUID,
+        task_attempt_id: UUID,
         kind: str,
         name: str,
         mime_type: str,
@@ -121,7 +121,7 @@ def append(  # slopcop: ignore[max-function-params]
     ) -> SampleResource:
         row = SampleResource(
             sample_id=sample_id,
-            task_execution_id=task_execution_id,
+            task_attempt_id=task_attempt_id,
             kind=kind,
             name=name,
             mime_type=mime_type,
diff --git a/ergon_core/ergon_core/core/application/resources/service.py b/ergon_core/ergon_core/core/application/resources/service.py
index b375674c8..1b3b3f22d 100644
--- a/ergon_core/ergon_core/core/application/resources/service.py
+++ b/ergon_core/ergon_core/core/application/resources/service.py
@@ -33,7 +33,7 @@ def list_for_run(
         *,
         sample_id: UUID,
         task_id: UUID | None = None,
-        task_execution_id: UUID | None = None,
+        task_attempt_id: UUID | None = None,
         kind: str | None = None,
         name: str | None = None,
     ) -> tuple[SampleResourceView, ...]:
@@ -44,7 +44,7 @@ def list_for_run(
                 session,
                 sample_id=sample_id,
                 task_id=task_id,
-                task_execution_id=task_execution_id,
+                task_attempt_id=task_attempt_id,
                 kind=kind,
                 name=name,
             )
diff --git a/ergon_core/ergon_core/core/application/runtime/sample_lifecycle.py b/ergon_core/ergon_core/core/application/runtime/sample_lifecycle.py
index 984e78984..f83720aae 100644
--- a/ergon_core/ergon_core/core/application/runtime/sample_lifecycle.py
+++ b/ergon_core/ergon_core/core/application/runtime/sample_lifecycle.py
@@ -440,7 +440,7 @@ def list_resources(
         )
         stmt = select(SampleResource).where(SampleResource.sample_id == sample_id)
         if execution_ids is not None:
-            stmt = stmt.where(col(SampleResource.task_execution_id).in_(execution_ids))
+            stmt = stmt.where(col(SampleResource.task_attempt_id).in_(execution_ids))
         if kind is not None:
             stmt = stmt.where(SampleResource.kind == kind)
         resources = list(session.exec(stmt).all())
@@ -498,7 +498,7 @@ def get_task_workspace(
                 session.exec(
                     select(SampleResource)
                     .where(SampleResource.sample_id == sample_id)
-                    .where(SampleResource.task_execution_id == latest.id),
+                    .where(SampleResource.task_attempt_id == latest.id),
                 ).all(),
             )
             own_rows.sort(key=lambda resource: (resource.created_at, resource.id), reverse=True)
@@ -690,7 +690,7 @@ async def materialize_resource(  # slopcop: ignore[max-function-params] -- mirro
 
         copy = SampleResource(
             sample_id=sample_id,
-            task_execution_id=current_execution_id,
+            task_attempt_id=current_execution_id,
             kind=SampleResourceKind.IMPORT.value,
             name=result.copied_name,
             mime_type=source.mime_type,
@@ -766,7 +766,7 @@ def _resource_ref(self, session: Session, resource: SampleResource) -> WorkflowR
         return WorkflowResourceRef(
             resource_id=resource.id,
             sample_id=resource.sample_id,
-            task_execution_id=resource.task_execution_id,
+            task_attempt_id=resource.task_attempt_id,
             task_id=producer.task_id if producer is not None else None,
             task_slug=producer.task_slug if producer is not None else None,
             kind=resource.kind,
@@ -784,7 +784,6 @@ def _execution_ref(execution: SampleTaskAttempt) -> WorkflowExecutionRef:
         return WorkflowExecutionRef(
             execution_id=execution.id,
             status=execution.status,
-            attempt_number=execution.attempt_number,
             final_assistant_message=execution.final_assistant_message,
         )
 
@@ -899,9 +898,9 @@ def _producer_node_for_resource(
         session: Session,
         resource: SampleResource,
     ) -> SampleGraphNode | None:
-        if resource.task_execution_id is None:
+        if resource.task_attempt_id is None:
             return None
-        execution = session.get(SampleTaskAttempt, resource.task_execution_id)
+        execution = session.get(SampleTaskAttempt, resource.task_attempt_id)
         if execution is None:
             return None
         return session.get(SampleGraphNode, (execution.sample_id, execution.task_id))
diff --git a/ergon_core/ergon_core/core/application/runtime/task_execution.py b/ergon_core/ergon_core/core/application/runtime/task_execution.py
index 7419bfad3..258040e95 100644
--- a/ergon_core/ergon_core/core/application/runtime/task_execution.py
+++ b/ergon_core/ergon_core/core/application/runtime/task_execution.py
@@ -167,9 +167,6 @@ async def _prepare_run_node(
             execution = SampleTaskAttempt(
                 sample_id=command.sample_id,
                 task_id=view.task_id,
-                attempt_number=self._task_execution_repo.next_attempt_for_node(
-                    session, command.sample_id, view.task_id
-                ),
                 status=TaskExecutionStatus.RUNNING,
                 started_at=utcnow(),
             )
diff --git a/ergon_core/ergon_core/core/application/runtime/task_execution_repository.py b/ergon_core/ergon_core/core/application/runtime/task_execution_repository.py
index 5288eb373..615169ca2 100644
--- a/ergon_core/ergon_core/core/application/runtime/task_execution_repository.py
+++ b/ergon_core/ergon_core/core/application/runtime/task_execution_repository.py
@@ -5,7 +5,7 @@
 from ergon_core.api.worker.results import WorkerOutput
 from ergon_core.core.persistence.graph.models import SampleGraphNode
 from ergon_core.core.persistence.telemetry.models import SampleTaskAttempt
-from sqlalchemy import func, update
+from sqlalchemy import update
 from sqlmodel import Session, col, select
 
 
@@ -25,8 +25,8 @@ def latest_for_node(self, session: Session, task_id: UUID) -> SampleTaskAttempt
             select(SampleTaskAttempt)
             .where(SampleTaskAttempt.task_id == task_id)
             .order_by(
-                col(SampleTaskAttempt.attempt_number).desc(),
-                col(SampleTaskAttempt.started_at).desc(),
+                col(SampleTaskAttempt.created_at).desc(),
+                col(SampleTaskAttempt.id).desc(),
             )
             .limit(1)
         )
@@ -48,15 +48,6 @@ def list_children_of_execution(
         )
         return list(session.exec(stmt).all())
 
-    def next_attempt_for_node(self, session: Session, sample_id: UUID, task_id: UUID) -> int:
-        count = session.exec(
-            select(func.count(SampleTaskAttempt.id)).where(
-                SampleTaskAttempt.sample_id == sample_id,
-                SampleTaskAttempt.task_id == task_id,
-            )
-        ).one()
-        return count + 1
-
     async def set_sandbox_id(
         self,
         session: Session,
diff --git a/ergon_core/ergon_core/core/application/runtime/workflow_models.py b/ergon_core/ergon_core/core/application/runtime/workflow_models.py
index 9fa0272c2..9aec5b7d1 100644
--- a/ergon_core/ergon_core/core/application/runtime/workflow_models.py
+++ b/ergon_core/ergon_core/core/application/runtime/workflow_models.py
@@ -10,7 +10,6 @@ class WorkflowExecutionRef(BaseModel):
 
     execution_id: UUID
     status: str
-    attempt_number: int
     final_assistant_message: str | None = None
 
 
@@ -19,7 +18,7 @@ class WorkflowResourceRef(BaseModel):
 
     resource_id: UUID
     sample_id: UUID
-    task_execution_id: UUID | None
+    task_attempt_id: UUID | None
     task_id: UUID | None
     task_slug: str | None
     kind: str
diff --git a/ergon_core/ergon_core/core/infrastructure/sandbox/resource_publisher.py b/ergon_core/ergon_core/core/infrastructure/sandbox/resource_publisher.py
index 7b2781417..fea67682c 100644
--- a/ergon_core/ergon_core/core/infrastructure/sandbox/resource_publisher.py
+++ b/ergon_core/ergon_core/core/infrastructure/sandbox/resource_publisher.py
@@ -41,13 +41,13 @@ def __init__(
         *,
         sandbox: AsyncSandbox | Any,  # slopcop: ignore[no-typing-any]
         sample_id: UUID,
-        task_execution_id: UUID,
+        task_attempt_id: UUID,
         blob_root: Path = _DEFAULT_BLOB_ROOT,
         publish_dirs: tuple[tuple[str, SampleResourceKind], ...] | None = None,
     ) -> None:
         self._sandbox = sandbox
         self._sample_id = sample_id
-        self._task_execution_id = task_execution_id
+        self._task_attempt_id = task_attempt_id
         self._blob_root = blob_root
         self._publish_dirs = publish_dirs if publish_dirs is not None else self.DEFAULT_PUBLISH_DIRS
 
@@ -57,14 +57,14 @@ def from_public_sandbox(
         *,
         sandbox: Any,  # slopcop: ignore[no-typing-any]
         sample_id: UUID,
-        task_execution_id: UUID,
+        task_attempt_id: UUID,
         blob_root: Path = _DEFAULT_BLOB_ROOT,
         publish_dirs: tuple[tuple[str, SampleResourceKind], ...] | None = None,
     ) -> "SandboxResourcePublisher":
         return cls(
             sandbox=sandbox,
             sample_id=sample_id,
-            task_execution_id=task_execution_id,
+            task_attempt_id=task_attempt_id,
             blob_root=blob_root,
             publish_dirs=publish_dirs,
         )
@@ -80,7 +80,7 @@ async def sync(self) -> list[SampleResourceView]:
             reader=self,
             blob_store=self,
             sample_id=self._sample_id,
-            task_execution_id=self._task_execution_id,
+            task_attempt_id=self._task_attempt_id,
             publish_dirs=self._publish_dirs,
         )
 
@@ -101,7 +101,7 @@ def publish_value(
         return SampleResourcePublishService().publish_value(
             blob_store=self,
             sample_id=self._sample_id,
-            task_execution_id=self._task_execution_id,
+            task_attempt_id=self._task_attempt_id,
             kind=kind,
             name=name,
             content=content,
diff --git a/ergon_core/ergon_core/core/jobs/resources/persist_outputs/composition.py b/ergon_core/ergon_core/core/jobs/resources/persist_outputs/composition.py
index 47e6bb031..96411c038 100644
--- a/ergon_core/ergon_core/core/jobs/resources/persist_outputs/composition.py
+++ b/ergon_core/ergon_core/core/jobs/resources/persist_outputs/composition.py
@@ -24,14 +24,14 @@ async def publish_public_sandbox_resources(
     publisher = SandboxResourcePublisher.from_public_sandbox(
         sandbox=sandbox,
         sample_id=payload.sample_id,
-        task_execution_id=payload.execution_id,
+        task_attempt_id=payload.execution_id,
         publish_dirs=publish_dirs,
     )
     synced = await SampleResourcePublishService().publish_sandbox_files(
         reader=publisher,
         blob_store=publisher,
         sample_id=payload.sample_id,
-        task_execution_id=payload.execution_id,
+        task_attempt_id=payload.execution_id,
         publish_dirs=publish_dirs,
     )
     return len(synced)
diff --git a/ergon_core/ergon_core/core/jobs/task/evaluate/job.py b/ergon_core/ergon_core/core/jobs/task/evaluate/job.py
index b77972583..bb0d54472 100644
--- a/ergon_core/ergon_core/core/jobs/task/evaluate/job.py
+++ b/ergon_core/ergon_core/core/jobs/task/evaluate/job.py
@@ -162,7 +162,7 @@ async def _run_evaluation(
         )
         await _evaluation_persistence.persist_failure(
             sample_id=sample_id,
-            task_execution_id=execution_id,
+            task_attempt_id=execution_id,
             task_id=view.task_id,
             binding_key=binding_key,
             exc=exc,
@@ -176,7 +176,7 @@ async def _run_evaluation(
     result = service_result.result
     persisted = await _evaluation_persistence.persist_success(
         sample_id=sample_id,
-        task_execution_id=execution_id,
+        task_attempt_id=execution_id,
         task_id=view.task_id,
         binding_key=binding_key,
         service_result=service_result,
diff --git a/ergon_core/ergon_core/core/jobs/task/worker_execute/job.py b/ergon_core/ergon_core/core/jobs/task/worker_execute/job.py
index 2e693f4bb..aafa421b0 100644
--- a/ergon_core/ergon_core/core/jobs/task/worker_execute/job.py
+++ b/ergon_core/ergon_core/core/jobs/task/worker_execute/job.py
@@ -101,7 +101,7 @@ async def _publish_context_event(event: SampleContextEvent) -> None:
         if dashboard_event is None:
             logger.warning(
                 "context_event: no task_id for execution %s",
-                event.task_execution_id,
+                event.task_attempt_id,
             )
             return
         await dashboard_publisher.publish(dashboard_event)
diff --git a/ergon_core/ergon_core/core/jobs/workflow/start/contract.py b/ergon_core/ergon_core/core/jobs/workflow/start/contract.py
index 06a667d47..70121d783 100644
--- a/ergon_core/ergon_core/core/jobs/workflow/start/contract.py
+++ b/ergon_core/ergon_core/core/jobs/workflow/start/contract.py
@@ -1,6 +1,6 @@
 from uuid import UUID
 
-from ergon_core.core.application.events.runtime import WorkflowStartedEvent
+from ergon_core.core.application.events.runtime import SampleStartedEvent
 from pydantic import BaseModel
 
 
diff --git a/ergon_core/ergon_core/core/jobs/workflow/start/inngest.py b/ergon_core/ergon_core/core/jobs/workflow/start/inngest.py
index b29a59bda..b7e902406 100644
--- a/ergon_core/ergon_core/core/jobs/workflow/start/inngest.py
+++ b/ergon_core/ergon_core/core/jobs/workflow/start/inngest.py
@@ -4,18 +4,18 @@
 
 from .job import run_start_workflow_job
 from ergon_core.core.infrastructure.inngest.client import RUN_CANCEL, inngest_client
-from .contract import WorkflowStartedEvent, WorkflowStartResult
+from .contract import SampleStartedEvent, WorkflowStartResult
 
 
 @inngest_client.create_function(
     fn_id="workflow-start",
-    trigger=inngest.TriggerEvent(event="workflow/started"),
+    trigger=inngest.TriggerEvent(event="sample/started"),
     cancel=RUN_CANCEL,
     retries=1,
     output_type=WorkflowStartResult,
 )
 async def start_workflow_fn(ctx: inngest.Context) -> WorkflowStartResult:
-    return await run_start_workflow_job(WorkflowStartedEvent.model_validate(ctx.event.data))
+    return await run_start_workflow_job(SampleStartedEvent.model_validate(ctx.event.data))
 
 
 __all__ = ["start_workflow_fn"]
diff --git a/ergon_core/ergon_core/core/jobs/workflow/start/job.py b/ergon_core/ergon_core/core/jobs/workflow/start/job.py
index 0e57d0224..e014a4c84 100644
--- a/ergon_core/ergon_core/core/jobs/workflow/start/job.py
+++ b/ergon_core/ergon_core/core/jobs/workflow/start/job.py
@@ -3,7 +3,7 @@
 import logging
 from datetime import UTC, datetime
 
-from .contract import WorkflowStartedEvent, WorkflowStartResult
+from .contract import SampleStartedEvent, WorkflowStartResult
 from ergon_core.core.jobs.task.execute.contract import TaskReadyEvent
 from ergon_core.core.application.events.service import get_dashboard_event_publisher
 from ergon_core.core.application.runtime.orchestration import InitializeWorkflowCommand
@@ -22,7 +22,7 @@
 logger = logging.getLogger(__name__)
 
 
-async def run_start_workflow_job(payload: WorkflowStartedEvent) -> WorkflowStartResult:
+async def run_start_workflow_job(payload: SampleStartedEvent) -> WorkflowStartResult:
     logger.info("workflow-start sample_id=%s", payload.sample_id)
     span_start = datetime.now(UTC)
 
@@ -92,7 +92,7 @@ async def run_start_workflow_job(payload: WorkflowStartedEvent) -> WorkflowStart
 async def run_workflow_start_job(
     *,
     session: Session,
-    event: WorkflowStartedEvent,
+    event: SampleStartedEvent,
 ) -> WorkflowStartResult:
     svc = WorkflowService()
     initialized = await svc.initialize(
diff --git a/ergon_core/ergon_core/core/persistence/components/__init__.py b/ergon_core/ergon_core/core/persistence/components/__init__.py
deleted file mode 100644
index b548260cd..000000000
--- a/ergon_core/ergon_core/core/persistence/components/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Persistent component catalog models."""
diff --git a/ergon_core/ergon_core/core/persistence/context/models.py b/ergon_core/ergon_core/core/persistence/context/models.py
index 01025bf74..87b4e24ea 100644
--- a/ergon_core/ergon_core/core/persistence/context/models.py
+++ b/ergon_core/ergon_core/core/persistence/context/models.py
@@ -26,13 +26,13 @@ class SampleContextEvent(SQLModel, table=True):
     __tablename__ = "sample_context_events"
     __table_args__ = (
         sa.UniqueConstraint(
-            "task_execution_id", "sequence", name="uq_sample_context_events_execution_sequence"
+            "task_attempt_id", "sequence", name="uq_sample_context_events_attempt_sequence"
         ),
     )
 
     id: UUID = Field(default_factory=new_id, primary_key=True)
     sample_id: UUID = Field(foreign_key="samples.id", index=True)
-    task_execution_id: UUID = Field(foreign_key="sample_task_attempts.id", index=True)
+    task_attempt_id: UUID = Field(foreign_key="sample_task_attempts.id", index=True)
     worker_binding_key: str = Field(index=True)
     sequence: int
     event_type: str = Field(
diff --git a/ergon_core/ergon_core/core/persistence/telemetry/models.py b/ergon_core/ergon_core/core/persistence/telemetry/models.py
index 2a8b0f528..8f57b0477 100644
--- a/ergon_core/ergon_core/core/persistence/telemetry/models.py
+++ b/ergon_core/ergon_core/core/persistence/telemetry/models.py
@@ -144,7 +144,7 @@ class SampleTaskAttempt(SQLModel, table=True):
     id: UUID = Field(default_factory=uuid4, primary_key=True)
     sample_id: UUID = Field(foreign_key="samples.id", index=True)
     task_id: UUID = Field(index=True)
-    attempt_number: int = 1
+    created_at: datetime = Field(default_factory=_utcnow, sa_type=TZDateTime)
     status: TaskExecutionStatus = Field(index=True)
     started_at: datetime | None = Field(default=None, sa_type=TZDateTime)
     completed_at: datetime | None = Field(default=None, sa_type=TZDateTime)
@@ -215,7 +215,7 @@ class SampleResource(SQLModel, table=True):
 
     id: UUID = Field(default_factory=uuid4, primary_key=True)
     sample_id: UUID = Field(foreign_key="samples.id", index=True)
-    task_execution_id: UUID | None = Field(
+    task_attempt_id: UUID | None = Field(
         default=None,
         foreign_key="sample_task_attempts.id",
     )
@@ -275,7 +275,7 @@ class SampleTaskEvaluation(SQLModel, table=True):
 
     id: UUID = Field(default_factory=uuid4, primary_key=True)
     sample_id: UUID = Field(foreign_key="samples.id", index=True)
-    task_execution_id: UUID = Field(
+    task_attempt_id: UUID = Field(
         foreign_key="sample_task_attempts.id",
         index=True,
     )
@@ -301,7 +301,7 @@ def _validate_summary_json(self) -> "SampleTaskEvaluation":
 
 class Thread(SQLModel, table=True):
     __tablename__ = "threads"
-    __table_args__ = (sa.UniqueConstraint("sample_id", "topic", name="uq_threads_run_topic"),)
+    __table_args__ = (sa.UniqueConstraint("sample_id", "topic", name="uq_threads_sample_topic"),)
 
     id: UUID = Field(default_factory=uuid4, primary_key=True)
     sample_id: UUID = Field(foreign_key="samples.id", index=True)
@@ -324,7 +324,7 @@ class ThreadMessage(SQLModel, table=True):
     id: UUID = Field(default_factory=uuid4, primary_key=True)
     thread_id: UUID = Field(foreign_key="threads.id", index=True)
     sample_id: UUID = Field(foreign_key="samples.id", index=True)
-    task_execution_id: UUID | None = Field(
+    task_attempt_id: UUID | None = Field(
         default=None,
         foreign_key="sample_task_attempts.id",
         index=True,
diff --git a/ergon_core/ergon_core/core/rl/extraction.py b/ergon_core/ergon_core/core/rl/extraction.py
index 18cd55064..1fa774a1c 100644
--- a/ergon_core/ergon_core/core/rl/extraction.py
+++ b/ergon_core/ergon_core/core/rl/extraction.py
@@ -57,7 +57,7 @@ def extract_agent_trajectories(
     """Build per-agent trajectories from context event rows.
 
     One AgentTrajectory per unique worker_binding_key.
-    Events must be pre-ordered by (task_execution_id, sequence).
+    Events must be pre-ordered by (task_attempt_id, sequence).
     """
     if reward_strategy is None:
         reward_strategy = IndependentTaskReward()
@@ -80,7 +80,7 @@ def extract_agent_trajectories(
         for event in events:
             parsed = event.parsed_payload()
             part = parsed.part
-            execution_ids.add(str(event.task_execution_id))
+            execution_ids.add(str(event.task_attempt_id))
 
             if isinstance(part, (SystemPromptPart, UserMessagePart)):
                 continue  # prompt context — not in completion
diff --git a/ergon_core/ergon_core/core/rl/rollout_service.py b/ergon_core/ergon_core/core/rl/rollout_service.py
index 65cc70653..99f14a56e 100644
--- a/ergon_core/ergon_core/core/rl/rollout_service.py
+++ b/ergon_core/ergon_core/core/rl/rollout_service.py
@@ -46,7 +46,7 @@
     Trajectory,
     TrainingRolloutRequest,
 )
-from ergon_core.core.application.events.runtime import WorkflowStartedEvent
+from ergon_core.core.application.events.runtime import SampleStartedEvent
 from sqlmodel import Session, select
 
 logger = logging.getLogger(__name__)
@@ -167,8 +167,8 @@ async def submit_experiment_batch(
         for sample_id in summary.sample_ids:
             self._inngest_send(
                 inngest.Event(
-                    name=WorkflowStartedEvent.name,
-                    data=WorkflowStartedEvent(sample_id=sample_id).model_dump(mode="json"),
+                    name=SampleStartedEvent.name,
+                    data=SampleStartedEvent(sample_id=sample_id).model_dump(mode="json"),
                 )
             )
         return summary
@@ -332,7 +332,7 @@ def _extract_trajectories(self, sample_ids: list[UUID]) -> list[Trajectory]:
                     .where(SampleContextEvent.sample_id.in_(sample_ids))  # type: ignore[union-attr]
                     .order_by(
                         SampleContextEvent.sample_id,
-                        SampleContextEvent.task_execution_id,
+                        SampleContextEvent.task_attempt_id,
                         SampleContextEvent.sequence,
                     )
                 ).all()
diff --git a/ergon_core/ergon_core/core/views/dashboard_events/context_events.py b/ergon_core/ergon_core/core/views/dashboard_events/context_events.py
index 72e9cf4f2..a4d59d294 100644
--- a/ergon_core/ergon_core/core/views/dashboard_events/context_events.py
+++ b/ergon_core/ergon_core/core/views/dashboard_events/context_events.py
@@ -12,13 +12,13 @@ def context_event_to_dashboard_event(
     event: SampleContextEvent,
     execution_task_map: dict[UUID, UUID],
 ) -> DashboardContextEventEvent | None:
-    task_id = execution_task_map.get(event.task_execution_id)
+    task_id = execution_task_map.get(event.task_attempt_id)
     if task_id is None:
         return None
     return DashboardContextEventEvent(
         id=event.id,
         sample_id=event.sample_id,
-        task_execution_id=event.task_execution_id,
+        task_attempt_id=event.task_attempt_id,
         task_id=task_id,
         worker_binding_key=event.worker_binding_key,
         sequence=event.sequence,
diff --git a/ergon_core/ergon_core/core/views/dashboard_events/contracts.py b/ergon_core/ergon_core/core/views/dashboard_events/contracts.py
index de646c060..4bf707870 100644
--- a/ergon_core/ergon_core/core/views/dashboard_events/contracts.py
+++ b/ergon_core/ergon_core/core/views/dashboard_events/contracts.py
@@ -90,7 +90,7 @@ class DashboardResourcePublishedEvent(InngestEventContract):
 
     sample_id: UUID
     task_id: UUID
-    task_execution_id: UUID
+    task_attempt_id: UUID
     resource_id: UUID
     resource_name: str
     mime_type: str
@@ -175,7 +175,7 @@ class DashboardContextEventEvent(InngestEventContract):
         description="SampleContextEvent.id used by the frontend as a stable deduplication key."
     )
     sample_id: UUID
-    task_execution_id: UUID
+    task_attempt_id: UUID
     task_id: UUID = Field(
         description=(
             "Graph task id resolved from the task execution by the dashboard emitter at "
diff --git a/ergon_core/ergon_core/core/views/samples/models.py b/ergon_core/ergon_core/core/views/samples/models.py
index 5ccba0b81..0b34cf9cc 100644
--- a/ergon_core/ergon_core/core/views/samples/models.py
+++ b/ergon_core/ergon_core/core/views/samples/models.py
@@ -38,7 +38,7 @@ class SampleCommunicationMessageDto(CamelModel):
     thread_topic: str
     sample_id: str
     task_id: str | None = None
-    task_execution_id: str | None = None
+    task_attempt_id: str | None = None
     from_agent_id: str
     to_agent_id: str
     content: str
@@ -84,7 +84,7 @@ class SampleTaskDto(CamelModel):
 class SampleResourceDto(CamelModel):
     id: str
     task_id: str
-    task_execution_id: str
+    task_attempt_id: str
     name: str
     mime_type: str
     file_path: str
@@ -173,7 +173,7 @@ class SampleSandboxDto(CamelModel):
 class SampleContextEventDto(CamelModel):
     id: UUID
     sample_id: UUID
-    task_execution_id: UUID
+    task_attempt_id: UUID
     task_id: UUID
     worker_binding_key: str
     sequence: int
diff --git a/ergon_core/ergon_core/core/views/samples/service.py b/ergon_core/ergon_core/core/views/samples/service.py
index d8322e5d3..9460c8cc5 100644
--- a/ergon_core/ergon_core/core/views/samples/service.py
+++ b/ergon_core/ergon_core/core/views/samples/service.py
@@ -140,7 +140,7 @@ def build_snapshot(self, sample_id: UUID) -> SampleSnapshotDto | None:
                     select(SampleContextEvent)
                     .where(SampleContextEvent.sample_id == sample_id)
                     .order_by(
-                        col(SampleContextEvent.task_execution_id),
+                        col(SampleContextEvent.task_attempt_id),
                         col(SampleContextEvent.sequence),
                     )
                 ).all()
diff --git a/ergon_core/ergon_core/core/views/samples/snapshot.py b/ergon_core/ergon_core/core/views/samples/snapshot.py
index 4700d1437..734c79e4c 100644
--- a/ergon_core/ergon_core/core/views/samples/snapshot.py
+++ b/ergon_core/ergon_core/core/views/samples/snapshot.py
@@ -97,7 +97,7 @@ def _task_keyed_executions(
     by_task: dict[str, list[SampleExecutionAttemptDto]] = defaultdict(list)
     for ex in sorted(
         executions,
-        key=lambda e: (str(e.task_id), e.attempt_number),
+        key=lambda e: (str(e.task_id), e.created_at, e.id),
     ):
         tid = str(ex.task_id)
         error_msg: str | None = None
@@ -115,7 +115,7 @@ def _task_keyed_executions(
             SampleExecutionAttemptDto(
                 id=str(ex.id),
                 task_id=tid,
-                attempt_number=ex.attempt_number,
+                attempt_number=len(by_task[tid]) + 1,
                 status=ex.status,
                 started_at=ex.started_at,
                 completed_at=ex.completed_at,
@@ -135,9 +135,7 @@ def _task_keyed_resources(
     by_task: dict[str, list[SampleResourceDto]] = defaultdict(list)
     for resource in resources:
         task_id_uuid = (
-            execution_task_map.get(resource.task_execution_id)
-            if resource.task_execution_id
-            else None
+            execution_task_map.get(resource.task_attempt_id) if resource.task_attempt_id else None
         )
         if task_id_uuid is None:
             continue
@@ -146,9 +144,7 @@ def _task_keyed_resources(
             SampleResourceDto(
                 id=str(resource.id),
                 task_id=tid,
-                task_execution_id=(
-                    str(resource.task_execution_id) if resource.task_execution_id else ""
-                ),
+                task_attempt_id=(str(resource.task_attempt_id) if resource.task_attempt_id else ""),
                 name=resource.name,
                 mime_type=resource.mime_type,
                 file_path=resource.file_path,
@@ -217,8 +213,8 @@ def _build_communication_threads(
         task_ids = {
             task_id
             for message in thread_messages
-            if message.task_execution_id is not None
-            for task_id in [execution_task_map.get(message.task_execution_id)]
+            if message.task_attempt_id is not None
+            for task_id in [execution_task_map.get(message.task_attempt_id)]
             if task_id is not None
         }
         thread_task_id = next(iter(task_ids)) if len(task_ids) == 1 else None
@@ -240,15 +236,15 @@ def _build_communication_threads(
                         sample_id=str(message.sample_id),
                         thread_topic=thread.topic,
                         task_id=(
-                            str(execution_task_map[message.task_execution_id])
+                            str(execution_task_map[message.task_attempt_id])
                             if (
-                                message.task_execution_id
-                                and message.task_execution_id in execution_task_map
+                                message.task_attempt_id
+                                and message.task_attempt_id in execution_task_map
                             )
                             else None
                         ),
-                        task_execution_id=(
-                            str(message.task_execution_id) if message.task_execution_id else None
+                        task_attempt_id=(
+                            str(message.task_attempt_id) if message.task_attempt_id else None
                         ),
                         from_agent_id=message.from_agent_id,
                         to_agent_id=message.to_agent_id,
@@ -291,14 +287,14 @@ def _context_events_by_task(
 ) -> dict[str, list[SampleContextEventDto]]:
     context_events_by_task: dict[str, list[SampleContextEventDto]] = defaultdict(list)
     for event in context_events_rows:
-        task_id = execution_task_map.get(event.task_execution_id)
+        task_id = execution_task_map.get(event.task_attempt_id)
         if task_id is None:
             continue
         context_events_by_task[str(task_id)].append(
             SampleContextEventDto(
                 id=event.id,
                 sample_id=event.sample_id,
-                task_execution_id=event.task_execution_id,
+                task_attempt_id=event.task_attempt_id,
                 task_id=task_id,
                 worker_binding_key=event.worker_binding_key,
                 sequence=event.sequence,
diff --git a/ergon_core/migrations/versions/00000003_delete_definition_runtime_columns.py b/ergon_core/migrations/versions/00000003_delete_definition_runtime_columns.py
index 42eef5421..1f6e364cd 100644
--- a/ergon_core/migrations/versions/00000003_delete_definition_runtime_columns.py
+++ b/ergon_core/migrations/versions/00000003_delete_definition_runtime_columns.py
@@ -59,6 +59,35 @@ def upgrade() -> None:
     _replace_sample_fk(inspector, "thread_messages", "sample_id", "samples")
     _drop_sample_fk(inspector, "sandbox_command_wal_entries", "sample_id")
     _drop_sample_fk(inspector, "sandbox_events", "sample_id")
+    _ensure_sample_attempt_timestamp_identity(inspector)
+    _rename_column_if_needed(inspector, "sample_resources", "task_execution_id", "task_attempt_id")
+    _rename_column_if_needed(
+        inspector,
+        "sample_task_evaluations",
+        "task_execution_id",
+        "task_attempt_id",
+    )
+    _rename_column_if_needed(inspector, "thread_messages", "task_execution_id", "task_attempt_id")
+    _rename_column_if_needed(
+        inspector,
+        "sample_context_events",
+        "task_execution_id",
+        "task_attempt_id",
+    )
+    _replace_unique_constraint(
+        inspector,
+        "threads",
+        old_name="uq_threads_run_topic",
+        new_name="uq_threads_sample_topic",
+        columns=["sample_id", "topic"],
+    )
+    _replace_unique_constraint(
+        inspector,
+        "sample_context_events",
+        old_name="uq_sample_context_events_execution_sequence",
+        new_name="uq_sample_context_events_attempt_sequence",
+        columns=["task_attempt_id", "sequence"],
+    )
     _add_column_if_missing(
         inspector,
         "experiment_sampler_invocations",
@@ -147,6 +176,57 @@ def _rename_run_id_to_sample_id_if_needed(inspector: sa.Inspector, table_name: s
         op.alter_column(table_name, "run_id", new_column_name="sample_id")
 
 
+def _rename_column_if_needed(
+    inspector: sa.Inspector,
+    table_name: str,
+    old_name: str,
+    new_name: str,
+) -> None:
+    if table_name not in inspector.get_table_names():
+        return
+    columns = {column["name"] for column in inspector.get_columns(table_name)}
+    if new_name not in columns and old_name in columns:
+        op.alter_column(table_name, old_name, new_column_name=new_name)
+
+
+def _ensure_sample_attempt_timestamp_identity(inspector: sa.Inspector) -> None:
+    if "sample_task_attempts" not in inspector.get_table_names():
+        return
+    _add_column_if_missing(
+        inspector,
+        "sample_task_attempts",
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=True),
+    )
+    op.execute(
+        "UPDATE sample_task_attempts "
+        "SET created_at = COALESCE(created_at, started_at, completed_at, CURRENT_TIMESTAMP)"
+    )
+    if op.get_context().dialect.name != "sqlite":
+        op.alter_column("sample_task_attempts", "created_at", nullable=False)
+    _drop_column_if_exists(inspector, "sample_task_attempts", "attempt_number")
+
+
+def _replace_unique_constraint(
+    inspector: sa.Inspector,
+    table_name: str,
+    *,
+    old_name: str,
+    new_name: str,
+    columns: list[str],
+) -> None:
+    if table_name not in inspector.get_table_names():
+        return
+    constraints = {
+        constraint["name"]: constraint
+        for constraint in inspector.get_unique_constraints(table_name)
+        if constraint.get("name")
+    }
+    if old_name in constraints:
+        op.drop_constraint(old_name, table_name, type_="unique")
+    if new_name not in constraints:
+        op.create_unique_constraint(new_name, table_name, columns)
+
+
 def _add_column_if_missing(
     inspector: sa.Inspector,
     table_name: str,
@@ -239,6 +319,39 @@ def _upgrade_offline() -> None:
         op.execute(
             f'ALTER TABLE "{table_name}" DROP CONSTRAINT IF EXISTS "{table_name}_run_id_fkey"'
         )
+    op.add_column(
+        "sample_task_attempts",
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=True),
+    )
+    op.execute(
+        "UPDATE sample_task_attempts "
+        "SET created_at = COALESCE(created_at, started_at, completed_at, CURRENT_TIMESTAMP)"
+    )
+    op.alter_column("sample_task_attempts", "created_at", nullable=False)
+    op.drop_column("sample_task_attempts", "attempt_number")
+    op.alter_column("sample_resources", "task_execution_id", new_column_name="task_attempt_id")
+    op.alter_column(
+        "sample_task_evaluations",
+        "task_execution_id",
+        new_column_name="task_attempt_id",
+    )
+    op.alter_column("thread_messages", "task_execution_id", new_column_name="task_attempt_id")
+    op.alter_column(
+        "sample_context_events",
+        "task_execution_id",
+        new_column_name="task_attempt_id",
+    )
+    op.execute('ALTER TABLE "threads" DROP CONSTRAINT IF EXISTS "uq_threads_run_topic"')
+    op.create_unique_constraint("uq_threads_sample_topic", "threads", ["sample_id", "topic"])
+    op.execute(
+        'ALTER TABLE "sample_context_events" '
+        'DROP CONSTRAINT IF EXISTS "uq_sample_context_events_execution_sequence"'
+    )
+    op.create_unique_constraint(
+        "uq_sample_context_events_attempt_sequence",
+        "sample_context_events",
+        ["task_attempt_id", "sequence"],
+    )
     op.add_column(
         "experiment_sampler_invocations",
         sa.Column("policy_version", sa.Integer(), nullable=True),
diff --git a/ergon_core/tests/integration/experiments/test_submit_starts_materialized_sample.py b/ergon_core/tests/integration/experiments/test_submit_starts_materialized_sample.py
index 0558de3cd..efc2534c2 100644
--- a/ergon_core/tests/integration/experiments/test_submit_starts_materialized_sample.py
+++ b/ergon_core/tests/integration/experiments/test_submit_starts_materialized_sample.py
@@ -10,7 +10,7 @@
 from ergon_core.api.criterion.outcome import CriterionOutcome
 from ergon_core.api.rubric.evaluator import Evaluator
 from ergon_core.api.rubric.results import TaskEvaluationResult
-from ergon_core.core.application.events.runtime import TaskCancelledEvent, WorkflowStartedEvent
+from ergon_core.core.application.events.runtime import TaskCancelledEvent, SampleStartedEvent
 from ergon_core.core.application.runtime.lifecycle import get_initial_ready_tasks
 from ergon_core.core.application.runtime.orchestration import (
     InitializeWorkflowCommand,
@@ -106,7 +106,7 @@ async def test_workflow_start_uses_materialized_sample_graph_without_definition(
 ) -> None:
     result = await run_workflow_start_job(
         session=session,
-        event=WorkflowStartedEvent(sample_id=materialized_sample.id),
+        event=SampleStartedEvent(sample_id=materialized_sample.id),
     )
     assert result.initial_ready_tasks == 1
 
diff --git a/ergon_core/tests/unit/api/worker/test_worker_context_facade.py b/ergon_core/tests/unit/api/worker/test_worker_context_facade.py
index b9364b2ac..b5102e7af 100644
--- a/ergon_core/tests/unit/api/worker/test_worker_context_facade.py
+++ b/ergon_core/tests/unit/api/worker/test_worker_context_facade.py
@@ -123,7 +123,7 @@ def list_for_run(self, **kwargs):
             SampleResourceView(
                 id=uuid4(),
                 sample_id=self.sample_id,
-                task_execution_id=kwargs.get("task_execution_id"),
+                task_attempt_id=kwargs.get("task_attempt_id"),
                 kind=SampleResourceKind.REPORT,
                 name="report.txt",
                 mime_type="text/plain",
@@ -275,7 +275,7 @@ async def test_resources_are_run_scoped_not_descendant_scoped(tmp_path: Path) ->
 
     assert data == b"ok"
     assert repo.calls[0][1]["task_id"] == sibling_task_id
-    assert repo.calls[0][1]["task_execution_id"] == execution_id
+    assert repo.calls[0][1]["task_attempt_id"] == execution_id
 
 
 @pytest.mark.asyncio
@@ -350,7 +350,7 @@ async def test_resources_use_repository_run_scope_with_real_rows(tmp_path: Path)
             ),
             SampleResource(
                 sample_id=sample_id,
-                task_execution_id=sibling_execution_id,
+                task_attempt_id=sibling_execution_id,
                 kind=SampleResourceKind.REPORT.value,
                 name="report.txt",
                 mime_type="text/plain",
diff --git a/ergon_core/tests/unit/architecture/test_persistence_boundaries.py b/ergon_core/tests/unit/architecture/test_persistence_boundaries.py
index 2a9807353..5ed25fabb 100644
--- a/ergon_core/tests/unit/architecture/test_persistence_boundaries.py
+++ b/ergon_core/tests/unit/architecture/test_persistence_boundaries.py
@@ -106,3 +106,29 @@ def test_run_record_exposes_sample_experiment_provenance() -> None:
     from ergon_core.core.persistence.telemetry.models import SampleRecord
 
     assert ("experiment" + "_id") in SampleRecord.model_fields
+
+
+def test_sample_task_attempt_uses_timestamp_identity_not_attempt_number() -> None:
+    from ergon_core.core.persistence.telemetry.models import SampleTaskAttempt
+
+    assert "created_at" in SampleTaskAttempt.model_fields
+    assert "attempt_number" not in SampleTaskAttempt.model_fields
+
+
+def test_attempt_scoped_rows_use_task_attempt_id_naming() -> None:
+    from ergon_core.core.persistence.context.models import SampleContextEvent
+    from ergon_core.core.persistence.telemetry.models import (
+        SampleResource,
+        SampleTaskEvaluation,
+        ThreadMessage,
+    )
+
+    for model in (SampleContextEvent, SampleResource, SampleTaskEvaluation, ThreadMessage):
+        assert "task_attempt_id" in model.model_fields
+        assert ("task" + "_execution_id") not in model.model_fields
+
+
+def test_empty_component_persistence_package_is_absent() -> None:
+    components_dir = Path("ergon_core/ergon_core/core/persistence/components")
+
+    assert not components_dir.exists()
diff --git a/ergon_core/tests/unit/core/application/evaluation/test_inline_evaluator_persistence.py b/ergon_core/tests/unit/core/application/evaluation/test_inline_evaluator_persistence.py
index 80a8725b3..f09fa0e19 100644
--- a/ergon_core/tests/unit/core/application/evaluation/test_inline_evaluator_persistence.py
+++ b/ergon_core/tests/unit/core/application/evaluation/test_inline_evaluator_persistence.py
@@ -73,7 +73,7 @@ async def test_persist_success_records_inline_evaluator_binding_key(monkeypatch)
 
     await service.persist_success(
         sample_id=sample_id,
-        task_execution_id=execution_id,
+        task_attempt_id=execution_id,
         task_id=task_id,
         binding_key="judge",
         service_result=EvaluationServiceResult(
@@ -105,7 +105,7 @@ async def test_persist_failure_records_inline_evaluator_binding_key(monkeypatch)
 
     await service.persist_failure(
         sample_id=sample_id,
-        task_execution_id=execution_id,
+        task_attempt_id=execution_id,
         task_id=task_id,
         binding_key="judge",
         exc=RuntimeError("boom"),
diff --git a/ergon_core/tests/unit/core/application/experiments/test_experiment_submit.py b/ergon_core/tests/unit/core/application/experiments/test_experiment_submit.py
index be4ee0c33..3d91a004e 100644
--- a/ergon_core/tests/unit/core/application/experiments/test_experiment_submit.py
+++ b/ergon_core/tests/unit/core/application/experiments/test_experiment_submit.py
@@ -10,10 +10,10 @@
 
 from ergon_core.api import Environment, Experiment, RandomSampler, Sample
 from ergon_core.api.experiment.sampling import SamplingContext
-from ergon_core.core.application.events.runtime import WorkflowStartedEvent
+from ergon_core.core.application.events.runtime import SampleStartedEvent
 from ergon_core.core.application.experiments.submission import (
     ExperimentSubmissionService,
-    InngestWorkflowEventBus,
+    InngestSampleEventBus,
 )
 from ergon_core.core.persistence.experiments.models import (
     ExperimentSamplePoolEntryRow,
@@ -46,9 +46,9 @@ async def publish(self, event: object) -> None:
 class CommittedStateEventBus:
     def __init__(self, engine) -> None:
         self._engine = engine
-        self.events: list[WorkflowStartedEvent] = []
+        self.events: list[SampleStartedEvent] = []
 
-    async def publish(self, event: WorkflowStartedEvent) -> None:
+    async def publish(self, event: SampleStartedEvent) -> None:
         with Session(self._engine) as observer:
             assert observer.get(SampleRecord, event.sample_id) is not None
             assert observer.exec(
@@ -323,7 +323,7 @@ async def test_submit_commits_materialized_sample_before_start_event(tmp_path: P
 
 
 @pytest.mark.asyncio
-async def test_default_event_bus_sends_workflow_started(monkeypatch: pytest.MonkeyPatch) -> None:
+async def test_default_event_bus_sends_sample_started(monkeypatch: pytest.MonkeyPatch) -> None:
     sent: list[object] = []
 
     async def fake_send(event: object) -> None:
@@ -333,12 +333,12 @@ async def fake_send(event: object) -> None:
         "ergon_core.core.application.experiments.submission.inngest_client.send",
         fake_send,
     )
-    event = WorkflowStartedEvent(sample_id=uuid4())
+    event = SampleStartedEvent(sample_id=uuid4())
 
-    await InngestWorkflowEventBus().publish(event)
+    await InngestSampleEventBus().publish(event)
 
     assert len(sent) == 1
-    assert getattr(sent[0], "name") == WorkflowStartedEvent.name
+    assert getattr(sent[0], "name") == SampleStartedEvent.name
     assert getattr(sent[0], "data") == event.model_dump(mode="json")
 
 
@@ -362,7 +362,7 @@ async def fake_send(event: object) -> None:
     result = await experiment.submit(service=service, k=1, sampler=SequentialSampler())
 
     assert len(sent) == 1
-    assert getattr(sent[0], "name") == WorkflowStartedEvent.name
+    assert getattr(sent[0], "name") == SampleStartedEvent.name
     assert getattr(sent[0], "data") == {
         "sample_id": str(result.sample_ids[0]),
     }
diff --git a/ergon_core/tests/unit/dashboard/test_communication_threads.py b/ergon_core/tests/unit/dashboard/test_communication_threads.py
index 38f404e82..0c49ee74b 100644
--- a/ergon_core/tests/unit/dashboard/test_communication_threads.py
+++ b/ergon_core/tests/unit/dashboard/test_communication_threads.py
@@ -20,7 +20,7 @@ def test_build_communication_threads_populates_summary_and_task_anchors() -> Non
     message = ThreadMessage(
         thread_id=thread_id,
         sample_id=sample_id,
-        task_execution_id=execution_id,
+        task_attempt_id=execution_id,
         from_agent_id="leaf-l_1",
         to_agent_id="parent",
         content="l_1: done exit=0",
@@ -38,7 +38,7 @@ def test_build_communication_threads_populates_summary_and_task_anchors() -> Non
     assert dto.summary == "Leaf workers report completion artifacts and probe exit status."
     assert dto.task_id == str(task_id)
     assert dto.messages[0].task_id == str(task_id)
-    assert dto.messages[0].task_execution_id == str(execution_id)
+    assert dto.messages[0].task_attempt_id == str(execution_id)
 
 
 def test_build_communication_threads_keeps_run_level_thread_when_messages_span_tasks() -> None:
@@ -57,7 +57,7 @@ def test_build_communication_threads_keeps_run_level_thread_when_messages_span_t
         ThreadMessage(
             thread_id=thread_id,
             sample_id=sample_id,
-            task_execution_id=execution_a,
+            task_attempt_id=execution_a,
             from_agent_id="leaf-l_1",
             to_agent_id="parent",
             content="l_1: done exit=0",
@@ -66,7 +66,7 @@ def test_build_communication_threads_keeps_run_level_thread_when_messages_span_t
         ThreadMessage(
             thread_id=thread_id,
             sample_id=sample_id,
-            task_execution_id=execution_b,
+            task_attempt_id=execution_b,
             from_agent_id="leaf-l_2",
             to_agent_id="parent",
             content="l_2: done exit=0",
diff --git a/ergon_core/tests/unit/dashboard/test_event_contract_types.py b/ergon_core/tests/unit/dashboard/test_event_contract_types.py
index 8e1767bc8..03a570d6d 100644
--- a/ergon_core/tests/unit/dashboard/test_event_contract_types.py
+++ b/ergon_core/tests/unit/dashboard/test_event_contract_types.py
@@ -50,7 +50,7 @@ def test_thread_message_event_uses_dashboard_dtos() -> None:
 
 
 def test_thread_message_dto_exposes_execution_identity() -> None:
-    assert "task_execution_id" in SampleCommunicationMessageDto.model_fields
+    assert "task_attempt_id" in SampleCommunicationMessageDto.model_fields
 
 
 def test_thread_dto_exposes_summary_and_task_identity() -> None:
@@ -59,7 +59,7 @@ def test_thread_dto_exposes_summary_and_task_identity() -> None:
     assert "task_id" in SampleCommunicationMessageDto.model_fields
 
 
-def test_workflow_started_event_embeds_run_snapshot_contract() -> None:
+def test_sample_started_event_embeds_run_snapshot_contract() -> None:
     assert "task_tree" not in DashboardWorkflowStartedEvent.model_fields
     assert DashboardWorkflowStartedEvent.model_fields["snapshot"].annotation is SampleSnapshotDto
 
diff --git a/ergon_core/tests/unit/evaluation/test_evaluation_dto_mapping.py b/ergon_core/tests/unit/evaluation/test_evaluation_dto_mapping.py
index ac4e46633..d9cbca004 100644
--- a/ergon_core/tests/unit/evaluation/test_evaluation_dto_mapping.py
+++ b/ergon_core/tests/unit/evaluation/test_evaluation_dto_mapping.py
@@ -55,7 +55,7 @@ def test_evaluation_row_to_dto_maps_multiple_criterion_outcomes() -> None:
     row = SampleTaskEvaluation(
         id=evaluation_id,
         sample_id=sample_id,
-        task_execution_id=uuid4(),
+        task_attempt_id=uuid4(),
         task_id=task_id,
         evaluator_slug="judge",
         score=1.5,
diff --git a/ergon_core/tests/unit/evaluation/test_evaluation_persistence.py b/ergon_core/tests/unit/evaluation/test_evaluation_persistence.py
index 6de7fe132..c15e8123c 100644
--- a/ergon_core/tests/unit/evaluation/test_evaluation_persistence.py
+++ b/ergon_core/tests/unit/evaluation/test_evaluation_persistence.py
@@ -72,7 +72,7 @@ async def test_persist_success_writes_evaluation_row_with_service_summary(monkey
 
     persisted = await EvaluationService().persist_success(
         sample_id=sample_id,
-        task_execution_id=execution_id,
+        task_attempt_id=execution_id,
         task_id=task_id,
         binding_key="judge",
         service_result=EvaluationServiceResult(
@@ -91,6 +91,6 @@ async def test_persist_success_writes_evaluation_row_with_service_summary(monkey
     assert row.summary_json == persisted.summary.model_dump(mode="json")
     assert row.score == 0.75
     assert row.passed is True
-    assert row.task_execution_id == execution_id
+    assert row.task_attempt_id == execution_id
     assert row.task_id == task_id
     assert row.evaluator_slug == "judge"
diff --git a/ergon_core/tests/unit/persistence/test_context_event_repository.py b/ergon_core/tests/unit/persistence/test_context_event_repository.py
index 355b42eb1..bb6a9d5b9 100644
--- a/ergon_core/tests/unit/persistence/test_context_event_repository.py
+++ b/ergon_core/tests/unit/persistence/test_context_event_repository.py
@@ -74,7 +74,7 @@ def test_run_context_event_parsed_payload_is_context_part_chunk_log() -> None:
     )
     event = SampleContextEvent(
         sample_id=uuid4(),
-        task_execution_id=uuid4(),
+        task_attempt_id=uuid4(),
         worker_binding_key="worker-a",
         sequence=3,
         event_type="assistant_text",
diff --git a/ergon_core/tests/unit/read_models/test_sample_metrics.py b/ergon_core/tests/unit/read_models/test_sample_metrics.py
index db8740982..5c0288a7e 100644
--- a/ergon_core/tests/unit/read_models/test_sample_metrics.py
+++ b/ergon_core/tests/unit/read_models/test_sample_metrics.py
@@ -19,7 +19,7 @@
 def _event(event_type: str, payload: ContextPartChunkLog) -> SampleContextEvent:
     return SampleContextEvent(
         sample_id=uuid4(),
-        task_execution_id=uuid4(),
+        task_attempt_id=uuid4(),
         worker_binding_key="worker",
         sequence=payload.sequence,
         event_type=event_type,
diff --git a/ergon_core/tests/unit/registry/test_inngest_job_registry.py b/ergon_core/tests/unit/registry/test_inngest_job_registry.py
index 2f6b92578..fd506895a 100644
--- a/ergon_core/tests/unit/registry/test_inngest_job_registry.py
+++ b/ergon_core/tests/unit/registry/test_inngest_job_registry.py
@@ -10,7 +10,7 @@
 
 
 EXPECTED_FUNCTION_TRIGGERS = {
-    "workflow-start": "workflow/started",
+    "workflow-start": "sample/started",
     "task-execute": "task/ready",
     "task-propagate": "task/completed",
     "task-failure-propagate": "task/failed",
diff --git a/ergon_core/tests/unit/resources/test_publishing.py b/ergon_core/tests/unit/resources/test_publishing.py
index caf698564..e77e865f3 100644
--- a/ergon_core/tests/unit/resources/test_publishing.py
+++ b/ergon_core/tests/unit/resources/test_publishing.py
@@ -46,12 +46,12 @@ def __init__(self, *, prior_by_path=None, prior_by_hash=None) -> None:
         self.prior_by_hash = prior_by_hash
         self.appended: list[dict] = []
 
-    def latest_by_path(self, _session, *, task_execution_id, file_path):
-        del task_execution_id, file_path
+    def latest_by_path(self, _session, *, task_attempt_id, file_path):
+        del task_attempt_id, file_path
         return self.prior_by_path
 
-    def find_by_hash(self, _session, *, task_execution_id, content_hash):
-        del task_execution_id, content_hash
+    def find_by_hash(self, _session, *, task_attempt_id, content_hash):
+        del task_attempt_id, content_hash
         return self.prior_by_hash
 
     def append(self, _session, **kwargs):
@@ -99,14 +99,14 @@ async def test_publish_sandbox_files_writes_blob_and_appends_resource_row() -> N
         reader=_Reader(),
         blob_store=blob_store,
         sample_id=sample_id,
-        task_execution_id=execution_id,
+        task_attempt_id=execution_id,
         publish_dirs=(("/workspace/final_output/", SampleResourceKind.REPORT),),
     )
 
     assert len(created) == 1
     appended = repository.appended[0]
     assert appended["sample_id"] == sample_id
-    assert appended["task_execution_id"] == execution_id
+    assert appended["task_attempt_id"] == execution_id
     assert appended["kind"] == SampleResourceKind.REPORT.value
     assert appended["name"] == "report.md"
     assert appended["mime_type"] == "text/markdown"
@@ -133,7 +133,7 @@ async def test_publish_sandbox_files_skips_existing_blob_path_without_writing()
         reader=_Reader(),
         blob_store=blob_store,
         sample_id=uuid4(),
-        task_execution_id=uuid4(),
+        task_attempt_id=uuid4(),
         publish_dirs=(("/workspace/final_output/", SampleResourceKind.REPORT),),
     )
 
@@ -156,7 +156,7 @@ def test_publish_value_dedups_by_hash_before_blob_write() -> None:
     created = service.publish_value(
         blob_store=blob_store,
         sample_id=uuid4(),
-        task_execution_id=uuid4(),
+        task_attempt_id=uuid4(),
         kind=SampleResourceKind.REPORT,
         name="summary.txt",
         content="already present",
diff --git a/ergon_core/tests/unit/runtime/test_communication_service.py b/ergon_core/tests/unit/runtime/test_communication_service.py
index 25b767ab2..5fb522547 100644
--- a/ergon_core/tests/unit/runtime/test_communication_service.py
+++ b/ergon_core/tests/unit/runtime/test_communication_service.py
@@ -64,7 +64,7 @@ async def _record_thread_event(event: object) -> None:
             thread_topic="smoke-completion",
             thread_summary=summary,
             content="l_1: done exit=0",
-            task_execution_id=execution_id,
+            task_attempt_id=execution_id,
         )
     )
 
@@ -75,7 +75,7 @@ async def _record_thread_event(event: object) -> None:
     assert emitted
     event = emitted[0]
     assert event.thread.summary == summary
-    assert event.message.task_execution_id == str(execution_id)
+    assert event.message.task_attempt_id == str(execution_id)
 
 
 @pytest.mark.asyncio
diff --git a/ergon_core/tests/unit/runtime/test_context_event_contracts.py b/ergon_core/tests/unit/runtime/test_context_event_contracts.py
index 5e7167f7f..381974be8 100644
--- a/ergon_core/tests/unit/runtime/test_context_event_contracts.py
+++ b/ergon_core/tests/unit/runtime/test_context_event_contracts.py
@@ -19,7 +19,7 @@ def test_rest_and_dashboard_context_events_share_typed_payload_shape() -> None:
     common = {
         "id": uuid4(),
         "sample_id": uuid4(),
-        "task_execution_id": uuid4(),
+        "task_attempt_id": uuid4(),
         "task_id": uuid4(),
         "worker_binding_key": "worker",
         "sequence": 1,
@@ -41,7 +41,7 @@ def test_dashboard_context_event_serializes_canonical_task_id_field() -> None:
     event = DashboardContextEventEvent(
         id=uuid4(),
         sample_id=uuid4(),
-        task_execution_id=uuid4(),
+        task_attempt_id=uuid4(),
         task_id=uuid4(),
         worker_binding_key="worker",
         sequence=1,
@@ -76,7 +76,7 @@ def test_context_event_row_mapper_uses_execution_task_map() -> None:
     row = SampleContextEvent(
         id=uuid4(),
         sample_id=sample_id,
-        task_execution_id=execution_id,
+        task_attempt_id=execution_id,
         worker_binding_key="worker",
         sequence=1,
         event_type="assistant_text",
@@ -91,7 +91,7 @@ def test_context_event_row_mapper_uses_execution_task_map() -> None:
     assert event == DashboardContextEventEvent(
         id=row.id,
         sample_id=sample_id,
-        task_execution_id=execution_id,
+        task_attempt_id=execution_id,
         task_id=task_id,
         worker_binding_key="worker",
         sequence=1,
@@ -107,7 +107,7 @@ def test_context_event_row_mapper_returns_none_for_unknown_execution() -> None:
     row = SampleContextEvent(
         id=uuid4(),
         sample_id=uuid4(),
-        task_execution_id=uuid4(),
+        task_attempt_id=uuid4(),
         worker_binding_key="worker",
         sequence=1,
         event_type="assistant_text",
diff --git a/ergon_core/tests/unit/runtime/test_dynamic_task_evaluation_mapping.py b/ergon_core/tests/unit/runtime/test_dynamic_task_evaluation_mapping.py
index 2b0b5b57c..b4ef2d866 100644
--- a/ergon_core/tests/unit/runtime/test_dynamic_task_evaluation_mapping.py
+++ b/ergon_core/tests/unit/runtime/test_dynamic_task_evaluation_mapping.py
@@ -35,7 +35,7 @@ def test_task_keyed_evaluations_use_runtime_task_id_for_dynamic_tasks() -> None:
 
     evaluation = SampleTaskEvaluation(
         sample_id=sample_id,
-        task_execution_id=uuid4(),
+        task_attempt_id=uuid4(),
         task_id=dynamic_task_id,
         evaluator_slug="dynamic-evaluator",
         score=1.0,
diff --git a/ergon_core/tests/unit/runtime/test_identity_invariants.py b/ergon_core/tests/unit/runtime/test_identity_invariants.py
index 19c482716..55af0c7c5 100644
--- a/ergon_core/tests/unit/runtime/test_identity_invariants.py
+++ b/ergon_core/tests/unit/runtime/test_identity_invariants.py
@@ -206,17 +206,13 @@ def test_execution_id_is_unique_per_attempt_and_shared_across_evaluators() -> No
     that (a) ``TaskEvaluateRequest`` carries ``execution_id``, (b) the
     orchestrator's fanout reuses ``prepared.execution_id`` for every
     invoke (one execution_id, many evaluator_indices), and (c) a fresh
-    attempt mints a new execution_id via the existing
-    ``next_attempt_for_node`` path.
+    attempt mints a new execution_id without relying on a persisted attempt
+    ordinal.
     """
 
-    import inspect
     from pathlib import Path
 
     from ergon_core.core.jobs.task.evaluate.contract import TaskEvaluateRequest
-    from ergon_core.core.application.runtime.task_execution_repository import (
-        TaskExecutionRepository,
-    )
 
     # (a) execution_id is on the payload.
     assert "execution_id" in TaskEvaluateRequest.model_fields
@@ -239,9 +235,13 @@ def test_execution_id_is_unique_per_attempt_and_shared_across_evaluators() -> No
         "evaluator_index must vary across the parallel fanout (one execution, many indices)"
     )
 
-    # (c) a retry mints a new execution_id — the attempt counter on
-    # TaskExecutionRepository is the canonical source.
-    assert "next_attempt_for_node" in inspect.getsource(TaskExecutionRepository)
+    # (c) a retry mints a new execution_id via SampleTaskAttempt's UUID primary
+    # key. Ordering is derived from (created_at, id), not a persisted ordinal.
+    task_service = (
+        root / "ergon_core/ergon_core/core/application/runtime/task_execution.py"
+    ).read_text()
+    assert "SampleTaskAttempt(" in task_service
+    assert "attempt_number" not in task_service
 
 
 class _SessionContext:
diff --git a/ergon_core/tests/unit/runtime/test_real_llm_rollout_artifact_health.py b/ergon_core/tests/unit/runtime/test_real_llm_rollout_artifact_health.py
index 286207bd3..364ab39c7 100644
--- a/ergon_core/tests/unit/runtime/test_real_llm_rollout_artifact_health.py
+++ b/ergon_core/tests/unit/runtime/test_real_llm_rollout_artifact_health.py
@@ -18,15 +18,15 @@ def _write_minimal_rollout(
     task_count: int = 1,
     evaluation_rows: list[dict] | None = None,
     resource_rows: list[dict] | None = None,
-    task_execution_ids: list[str] | None = None,
+    task_attempt_ids: list[str] | None = None,
 ) -> None:
-    execution_ids = task_execution_ids or [str(uuid4()) for _ in range(task_count)]
+    execution_ids = task_attempt_ids or [str(uuid4()) for _ in range(task_count)]
     resources = resource_rows
     if resources is None:
         resources = [
             {
                 "id": str(uuid4()),
-                "task_execution_id": execution_ids[0],
+                "task_attempt_id": execution_ids[0],
                 "kind": "report",
                 "name": "report.md",
                 "file_path": "/durable/blob",
@@ -165,14 +165,14 @@ def test_artifact_health_summarizes_scores_and_workers(tmp_path: Path) -> None:
 
 
 def test_artifact_health_uses_task_scoped_report_resources(tmp_path: Path) -> None:
-    task_execution_id = str(uuid4())
+    task_attempt_id = str(uuid4())
     _write_minimal_rollout(
         tmp_path,
         task_count=1,
         evaluation_rows=[
             {
                 "id": str(uuid4()),
-                "task_execution_id": task_execution_id,
+                "task_attempt_id": task_attempt_id,
                 "score": 0.75,
                 "summary_json": {
                     "evaluator_name": "research-rubric",
@@ -197,14 +197,14 @@ def test_artifact_health_uses_task_scoped_report_resources(tmp_path: Path) -> No
         resource_rows=[
             {
                 "id": str(uuid4()),
-                "task_execution_id": task_execution_id,
+                "task_attempt_id": task_attempt_id,
                 "kind": "report",
                 "name": "report.md",
                 "file_path": "/durable/blob/not/final_output",
                 "metadata_json": {"sandbox_origin": "/workspace/final_output/report.md"},
             }
         ],
-        task_execution_ids=[task_execution_id],
+        task_attempt_ids=[task_attempt_id],
     )
 
     health = analyze_rollout_artifacts(tmp_path, expected_task_count=1)
@@ -214,14 +214,14 @@ def test_artifact_health_uses_task_scoped_report_resources(tmp_path: Path) -> No
 
 
 def test_artifact_health_flags_completed_task_without_report_resource(tmp_path: Path) -> None:
-    task_execution_id = str(uuid4())
+    task_attempt_id = str(uuid4())
     _write_minimal_rollout(
         tmp_path,
         task_count=1,
         evaluation_rows=[
             {
                 "id": str(uuid4()),
-                "task_execution_id": task_execution_id,
+                "task_attempt_id": task_attempt_id,
                 "score": 0.75,
                 "summary_json": {
                     "evaluator_name": "research-rubric",
@@ -246,13 +246,13 @@ def test_artifact_health_flags_completed_task_without_report_resource(tmp_path:
         resource_rows=[
             {
                 "id": str(uuid4()),
-                "task_execution_id": task_execution_id,
+                "task_attempt_id": task_attempt_id,
                 "kind": "note",
                 "name": "notes.md",
                 "file_path": "/durable/blob",
             }
         ],
-        task_execution_ids=[task_execution_id],
+        task_attempt_ids=[task_attempt_id],
     )
 
     health = analyze_rollout_artifacts(tmp_path, expected_task_count=1)
diff --git a/ergon_core/tests/unit/runtime/test_task_execution_repository.py b/ergon_core/tests/unit/runtime/test_task_execution_repository.py
index 812d73bb3..fa3623b17 100644
--- a/ergon_core/tests/unit/runtime/test_task_execution_repository.py
+++ b/ergon_core/tests/unit/runtime/test_task_execution_repository.py
@@ -50,67 +50,67 @@ def _execution(
     *,
     sample_id: UUID,
     task_id: UUID,
-    attempt_number: int,
     started_at: datetime,
+    created_at: datetime | None = None,
     message: str = "output",
 ) -> SampleTaskAttempt:
     return SampleTaskAttempt(
         sample_id=sample_id,
         task_id=task_id,
-        attempt_number=attempt_number,
         status=TaskExecutionStatus.COMPLETED,
         started_at=started_at,
+        created_at=created_at or started_at,
         final_assistant_message=message,
     )
 
 
-def test_latest_for_node_orders_by_attempt_then_started_at() -> None:
+def test_latest_for_node_orders_by_created_at_then_id() -> None:
     session = _session()
     sample_id = _run(session)
     node_id = _node(session, sample_id)
     now = datetime(2026, 4, 28, 12, 0, tzinfo=UTC)
-    older_attempt_two = _execution(
+    older_attempt = _execution(
         sample_id=sample_id,
         task_id=node_id,
-        attempt_number=2,
         started_at=now,
-        message="attempt-two-old",
+        created_at=now,
+        message="attempt-old",
     )
-    newer_attempt_one = _execution(
+    newest_attempt = _execution(
         sample_id=sample_id,
         task_id=node_id,
-        attempt_number=1,
-        started_at=now + timedelta(minutes=10),
-        message="attempt-one-newer",
+        started_at=now,
+        created_at=now + timedelta(minutes=10),
+        message="attempt-newest",
     )
-    newer_attempt_two = _execution(
+    middle_attempt = _execution(
         sample_id=sample_id,
         task_id=node_id,
-        attempt_number=2,
-        started_at=now + timedelta(minutes=5),
-        message="attempt-two-new",
+        started_at=now + timedelta(minutes=20),
+        created_at=now + timedelta(minutes=5),
+        message="attempt-middle",
     )
-    session.add_all([older_attempt_two, newer_attempt_one, newer_attempt_two])
+    session.add_all([older_attempt, newest_attempt, middle_attempt])
     session.commit()
 
     latest = TaskExecutionRepository().latest_for_node(session, node_id)
 
     assert latest is not None
-    assert latest.id == newer_attempt_two.id
-    assert latest.id != newer_attempt_one.id
+    assert latest.id == newest_attempt.id
+    assert latest.id != middle_attempt.id
 
 
-def test_next_attempt_counts_existing_node_executions() -> None:
+def test_latest_for_node_uses_id_as_deterministic_tie_breaker() -> None:
     session = _session()
     sample_id = _run(session)
     node_id = _node(session, sample_id)
     now = datetime(2026, 4, 28, 12, 0, tzinfo=UTC)
-    session.add_all(
-        [
-            _execution(sample_id=sample_id, task_id=node_id, attempt_number=1, started_at=now),
-            _execution(sample_id=sample_id, task_id=node_id, attempt_number=2, started_at=now),
-        ]
-    )
+    first = _execution(sample_id=sample_id, task_id=node_id, started_at=now, created_at=now)
+    second = _execution(sample_id=sample_id, task_id=node_id, started_at=now, created_at=now)
+    session.add_all([first, second])
     session.commit()
 
-    assert TaskExecutionRepository().next_attempt_for_node(session, sample_id, node_id) == 3
+    latest = TaskExecutionRepository().latest_for_node(session, node_id)
+
+    assert latest is not None
+    assert latest.id == max(first.id, second.id)
diff --git a/ergon_core/tests/unit/runtime/test_workflow_service.py b/ergon_core/tests/unit/runtime/test_workflow_service.py
index a2f40d4c7..bb3ceae49 100644
--- a/ergon_core/tests/unit/runtime/test_workflow_service.py
+++ b/ergon_core/tests/unit/runtime/test_workflow_service.py
@@ -84,7 +84,7 @@ def _resource(
     path.write_bytes(content)
     return SampleResource(
         sample_id=sample_id,
-        task_execution_id=execution_id,
+        task_attempt_id=execution_id,
         kind=kind.value,
         name=name,
         mime_type="text/plain",
@@ -261,14 +261,14 @@ async def upload_file(self, task_id: UUID, local_path: str, sandbox_path: str) -
     original = session.get(SampleResource, source.id)
 
     assert copy.id != source.id
-    assert copy.task_execution_id == consumer_exec.id
+    assert copy.task_attempt_id == consumer_exec.id
     assert copy.kind == SampleResourceKind.IMPORT.value
     assert copy.name == "paper (copy).pdf"
     assert copy.file_path == source.file_path
     assert copy.content_hash == source.content_hash
     assert copy.copied_from_resource_id == source.id
     assert original is not None
-    assert original.task_execution_id == producer_exec.id
+    assert original.task_attempt_id == producer_exec.id
     assert manager.uploads == [
         (consumer.task_id, source.file_path, "/workspace/imported/producer/paper (copy).pdf")
     ]
diff --git a/ergon_ingestion/ergon_ingestion/writers/external_run_writer.py b/ergon_ingestion/ergon_ingestion/writers/external_run_writer.py
index 64fe026d5..d5a97ff30 100644
--- a/ergon_ingestion/ergon_ingestion/writers/external_run_writer.py
+++ b/ergon_ingestion/ergon_ingestion/writers/external_run_writer.py
@@ -33,7 +33,7 @@ class WriteRunResult(BaseModel):
 
     sample_id: UUID
     task_id: UUID
-    task_execution_id: UUID
+    task_attempt_id: UUID
 
 
 class ExternalRunWriter:
@@ -110,20 +110,18 @@ def write_run(self, parsed: ParsedRun) -> WriteRunResult:
         for resource in parsed.resources:
             self._session.add(self._resource_row(run.id, execution.id, resource))
 
-        return WriteRunResult(
-            sample_id=run.id, task_id=node.task_id, task_execution_id=execution.id
-        )
+        return WriteRunResult(sample_id=run.id, task_id=node.task_id, task_attempt_id=execution.id)
 
     def _resource_row(
         self,
         sample_id: UUID,
-        task_execution_id: UUID,
+        task_attempt_id: UUID,
         resource: ParsedResource,
     ) -> SampleResource:
         path, content_hash, size = self._materialize_resource(sample_id, resource)
         return SampleResource(
             sample_id=sample_id,
-            task_execution_id=task_execution_id,
+            task_attempt_id=task_attempt_id,
             kind=SampleResourceKind(resource.kind).value,
             name=resource.name,
             mime_type=resource.mime_type,
diff --git a/tests/e2e/_asserts.py b/tests/e2e/_asserts.py
index b3c07ab54..55abce82f 100644
--- a/tests/e2e/_asserts.py
+++ b/tests/e2e/_asserts.py
@@ -243,7 +243,7 @@ def _assert_thread_messages_ordered(sample_id: UUID) -> None:
         f"from_agent_id slug set mismatch: {sorted(from_slugs)}"
     )
     assert all(m.to_agent_id == "parent" for m in msgs)
-    assert all(m.task_execution_id is not None for m in msgs)
+    assert all(m.task_attempt_id is not None for m in msgs)
 
 
 def _assert_blob_roundtrip(sample_id: UUID) -> None:
diff --git a/tests/fixtures/smoke_components/criteria/minif2f_smoke.py b/tests/fixtures/smoke_components/criteria/minif2f_smoke.py
index 86e7f2d13..bcd7bbb9b 100644
--- a/tests/fixtures/smoke_components/criteria/minif2f_smoke.py
+++ b/tests/fixtures/smoke_components/criteria/minif2f_smoke.py
@@ -42,7 +42,7 @@ async def _verify_env_content(self, context, children, probes) -> None:
                 resource = session.exec(
                     select(SampleResource)
                     .where(
-                        col(SampleResource.task_execution_id).in_(exec_ids),
+                        col(SampleResource.task_attempt_id).in_(exec_ids),
                     )
                     .where(
                         col(SampleResource.name).like("proof_%.lean"),
diff --git a/tests/fixtures/smoke_components/criteria/researchrubrics_smoke.py b/tests/fixtures/smoke_components/criteria/researchrubrics_smoke.py
index 9bc308526..0b6d837db 100644
--- a/tests/fixtures/smoke_components/criteria/researchrubrics_smoke.py
+++ b/tests/fixtures/smoke_components/criteria/researchrubrics_smoke.py
@@ -49,7 +49,7 @@ async def _verify_env_content(self, context, children, probes) -> None:
                 resource = session.exec(
                     select(SampleResource)
                     .where(
-                        col(SampleResource.task_execution_id).in_(exec_ids),
+                        col(SampleResource.task_attempt_id).in_(exec_ids),
                     )
                     .where(
                         col(SampleResource.name).like("report_%.md"),
diff --git a/tests/fixtures/smoke_components/criteria/swebench_smoke.py b/tests/fixtures/smoke_components/criteria/swebench_smoke.py
index 64b9a7a35..0afa7d2ed 100644
--- a/tests/fixtures/smoke_components/criteria/swebench_smoke.py
+++ b/tests/fixtures/smoke_components/criteria/swebench_smoke.py
@@ -47,7 +47,7 @@ async def _verify_env_content(self, context, children, probes) -> None:
                 resource = session.exec(
                     select(SampleResource)
                     .where(
-                        col(SampleResource.task_execution_id).in_(exec_ids),
+                        col(SampleResource.task_attempt_id).in_(exec_ids),
                     )
                     .where(
                         col(SampleResource.name).like("patch_%.py"),
diff --git a/tests/fixtures/smoke_components/smoke_base/criterion_base.py b/tests/fixtures/smoke_components/smoke_base/criterion_base.py
index 8d9cc2a86..8dafec35c 100644
--- a/tests/fixtures/smoke_components/smoke_base/criterion_base.py
+++ b/tests/fixtures/smoke_components/smoke_base/criterion_base.py
@@ -223,7 +223,7 @@ async def _pull_probe_results(
                 resource = session.exec(
                     select(SampleResource)
                     .where(
-                        col(SampleResource.task_execution_id).in_(exec_ids),
+                        col(SampleResource.task_attempt_id).in_(exec_ids),
                     )
                     .where(
                         col(SampleResource.name).like("probe_%.json"),
diff --git a/tests/fixtures/smoke_components/smoke_base/leaf_base.py b/tests/fixtures/smoke_components/smoke_base/leaf_base.py
index 78cc41499..35d182e4b 100644
--- a/tests/fixtures/smoke_components/smoke_base/leaf_base.py
+++ b/tests/fixtures/smoke_components/smoke_base/leaf_base.py
@@ -142,7 +142,7 @@ async def _send_completion_message(
         await communication_service.save_message(
             CreateMessageRequest(
                 sample_id=context.sample_id,
-                task_execution_id=context.execution_id,
+                task_attempt_id=context.execution_id,
                 from_agent_id=f"leaf-{task_slug}",
                 to_agent_id="parent",
                 thread_topic="smoke-completion",
diff --git a/tests/fixtures/smoke_components/smoke_base/recursive.py b/tests/fixtures/smoke_components/smoke_base/recursive.py
index 735e9841f..1d96eac91 100644
--- a/tests/fixtures/smoke_components/smoke_base/recursive.py
+++ b/tests/fixtures/smoke_components/smoke_base/recursive.py
@@ -105,7 +105,7 @@ async def _send_recursive_completion_message(
         await communication_service.save_message(
             CreateMessageRequest(
                 sample_id=context.sample_id,
-                task_execution_id=context.execution_id,
+                task_attempt_id=context.execution_id,
                 from_agent_id=f"leaf-{task_slug}",
                 to_agent_id="parent",
                 thread_topic="smoke-completion",
diff --git a/tests/real_llm/artifact_health.py b/tests/real_llm/artifact_health.py
index 447947ea4..7a24e4040 100644
--- a/tests/real_llm/artifact_health.py
+++ b/tests/real_llm/artifact_health.py
@@ -116,9 +116,9 @@ def _missing_task_report(
         return False
 
     report_execution_ids = {
-        str(resource["task_execution_id"])
+        str(resource["task_attempt_id"])
         for resource in resources
-        if resource.get("task_execution_id") is not None and _is_report_resource(resource)
+        if resource.get("task_attempt_id") is not None and _is_report_resource(resource)
     }
     return not completed_execution_ids.issubset(report_execution_ids)
 

From c073ee727426b68ebf0a3befa92e03fcec10dc0c Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Thu, 28 May 2026 10:41:53 +0100
Subject: [PATCH 12/15] Clean up fragmented sample contracts

---
 .../src/generated/rest/contracts.ts           | 148 +--
 .../src/generated/rest/openapi.json           | 931 ++----------------
 ergon_core/ergon_core/api/_serialization.py   |   7 +-
 .../ergon_core/core/views/samples/models.py   |   1 +
 .../ergon_core/core/views/samples/service.py  |   1 +
 .../read_models/test_sample_read_service.py   |   5 +
 6 files changed, 97 insertions(+), 996 deletions(-)

diff --git a/ergon-dashboard/src/generated/rest/contracts.ts b/ergon-dashboard/src/generated/rest/contracts.ts
index 754688ddf..1b7b583e0 100644
--- a/ergon-dashboard/src/generated/rest/contracts.ts
+++ b/ergon-dashboard/src/generated/rest/contracts.ts
@@ -20,7 +20,6 @@ const SampleSummaryDto = z
     latest_activity_at: z.union([z.string(), z.null()]).optional(),
     duration_seconds: z.union([z.number(), z.null()]).optional(),
     experiment_id: z.union([z.string(), z.null()]).optional(),
-    experiment_name: z.union([z.string(), z.null()]).optional(),
     experiment: z.union([z.string(), z.null()]).optional(),
     benchmark_type: z.string(),
     instance_key: z.string(),
@@ -692,30 +691,13 @@ const SamplerInvocationsView = z
   .object({ items: z.array(SamplerInvocationView) })
   .partial()
   .passthrough();
-const ExperimentRunRequest = z
+const TrainingRolloutRequest = z
   .object({
-    experiment_id: z.string().uuid(),
-    timeout_seconds: z.union([z.number(), z.null()]).optional(),
-    wait: z.boolean().optional().default(true),
-  })
-  .passthrough();
-const submit_experiment_experiments__experiment_id__run_post_Body = z.union([
-  ExperimentRunRequest,
-  z.null(),
-]);
-const ExperimentRunResult = z
-  .object({
-    experiment_id: z.string().uuid(),
-    sample_ids: z.array(z.string().uuid()),
-    experiment_ids: z.array(z.string().uuid()).optional(),
-  })
-  .passthrough();
-const SubmitRequest = z
-  .object({
-    experiment_id: z.string().uuid(),
-    num_episodes: z.number().int().gte(1),
-    policy_version: z.union([z.number(), z.null()]).optional(),
-    model_target_override: z.union([z.string(), z.null()]).optional(),
+    experimentId: z.string().uuid(),
+    k: z.number().int().gte(1),
+    sampler: z.string().optional().default("random"),
+    samplerConfig: z.object({}).partial().passthrough().optional(),
+    candidatePoolSize: z.union([z.number(), z.null()]).optional(),
   })
   .passthrough();
 const RolloutStatus = z.enum([
@@ -725,11 +707,13 @@ const RolloutStatus = z.enum([
   "failed",
   "cancelled",
 ]);
-const SubmitResponse = z
+const RolloutBatchSummary = z
   .object({
-    batch_id: z.string().uuid(),
-    sample_ids: z.array(z.string().uuid()),
-    status: RolloutStatus.optional(),
+    batchId: z.string().uuid(),
+    sampleIds: z.array(z.string().uuid()),
+    status: RolloutStatus,
+    experimentId: z.union([z.string(), z.null()]).optional(),
+    samplerInvocationId: z.union([z.string(), z.null()]).optional(),
   })
   .passthrough();
 const Trajectory = z
@@ -757,101 +741,12 @@ const PollResponse = z
     failures: z.array(EpisodeFailure).optional(),
   })
   .passthrough();
-const RolloutBatchSummary = z
-  .object({
-    batch_id: z.string().uuid(),
-    sample_ids: z.array(z.string().uuid()),
-    status: RolloutStatus,
-    experiment_id: z.union([z.string(), z.null()]).optional(),
-    sampler_invocation_id: z.union([z.string(), z.null()]).optional(),
-  })
-  .passthrough();
 const WeightSyncRequest = z
   .object({ checkpoint_path: z.string(), model_name: z.string() })
   .passthrough();
 const WeightSyncResponse = z
   .object({ success: z.boolean(), vllm_model_loaded: z.string() })
   .passthrough();
-const TestGraphNodeDto = z
-  .object({
-    id: z.string().uuid(),
-    task_slug: z.string(),
-    level: z.number().int(),
-    status: z.string(),
-    parent_task_id: z.union([z.string(), z.null()]),
-    parent_task_slug: z.union([z.string(), z.null()]),
-  })
-  .passthrough();
-const TestSampleRuntimeEventDto = z
-  .object({
-    table: z.string(),
-    event_type: z.string(),
-    target_id: z.union([z.string(), z.null()]),
-    payload: z.object({}).partial().passthrough(),
-  })
-  .passthrough();
-const TestEvaluationDto = z
-  .object({
-    task_id: z.string().uuid(),
-    task_slug: z.union([z.string(), z.null()]),
-    score: z.number(),
-    reason: z.string(),
-  })
-  .passthrough();
-const TestExecutionDto = z
-  .object({
-    task_slug: z.union([z.string(), z.null()]),
-    status: z.string(),
-    error: z.union([z.string(), z.null()]),
-  })
-  .passthrough();
-const TestSampleStateDto = z
-  .object({
-    sample_id: z.string().uuid(),
-    status: z.string(),
-    graph_nodes: z.array(TestGraphNodeDto),
-    events: z.array(TestSampleRuntimeEventDto),
-    evaluations: z.array(TestEvaluationDto),
-    executions: z.array(TestExecutionDto),
-    execution_count: z.number().int(),
-    event_count: z.number().int(),
-    resource_count: z.number().int(),
-    thread_count: z.number().int(),
-    context_event_count: z.number().int(),
-  })
-  .passthrough();
-const TestExperimentSampleDto = z
-  .object({ sample_id: z.string().uuid(), status: z.string() })
-  .passthrough();
-const SeedSampleRequest = z
-  .object({
-    experiment_id: z.string().uuid(),
-    benchmark_type: z.string().optional().default("test-harness"),
-    instance_key: z.string().optional().default("seeded"),
-    worker_team: z.object({}).partial().passthrough().optional(),
-    experiment: z.string().optional().default("_test_"),
-    status: z.string().optional().default("completed"),
-    task_slugs: z.array(z.string()).optional().default([]),
-  })
-  .passthrough();
-const ResetRequest = z.object({ experiment_prefix: z.string() }).passthrough();
-const ExperimentSampleSlotRequest = z
-  .object({ worker_slug: z.string(), evaluator_slug: z.string() })
-  .passthrough();
-const SubmitExperimentSamplesRequest = z
-  .object({
-    benchmark_slug: z.string(),
-    slots: z.array(ExperimentSampleSlotRequest),
-    experiment: z.string(),
-    sandbox_slug: z.union([z.string(), z.null()]).optional(),
-    dependency_extras: z.array(z.string()).optional().default(["none"]),
-    model: z.string().optional().default("openai:gpt-4o"),
-    limit: z.number().int().optional().default(1),
-  })
-  .passthrough();
-const SubmitExperimentSamplesResponse = z
-  .object({ sample_ids: z.array(z.string().uuid()) })
-  .passthrough();
 
 export const schemas = {
   status,
@@ -911,27 +806,12 @@ export const schemas = {
   ExperimentListView,
   ExperimentSamplesView,
   SamplerInvocationsView,
-  ExperimentRunRequest,
-  submit_experiment_experiments__experiment_id__run_post_Body,
-  ExperimentRunResult,
-  SubmitRequest,
+  TrainingRolloutRequest,
   RolloutStatus,
-  SubmitResponse,
+  RolloutBatchSummary,
   Trajectory,
   EpisodeFailure,
   PollResponse,
-  RolloutBatchSummary,
   WeightSyncRequest,
   WeightSyncResponse,
-  TestGraphNodeDto,
-  TestSampleRuntimeEventDto,
-  TestEvaluationDto,
-  TestExecutionDto,
-  TestSampleStateDto,
-  TestExperimentSampleDto,
-  SeedSampleRequest,
-  ResetRequest,
-  ExperimentSampleSlotRequest,
-  SubmitExperimentSamplesRequest,
-  SubmitExperimentSamplesResponse,
 };
diff --git a/ergon-dashboard/src/generated/rest/openapi.json b/ergon-dashboard/src/generated/rest/openapi.json
index 1801e71e9..1fd5d3a2c 100644
--- a/ergon-dashboard/src/generated/rest/openapi.json
+++ b/ergon-dashboard/src/generated/rest/openapi.json
@@ -41,23 +41,6 @@
               "title": "Status"
             }
           },
-          {
-            "name": "experiment_id",
-            "in": "query",
-            "required": false,
-            "schema": {
-              "anyOf": [
-                {
-                  "type": "string",
-                  "format": "uuid"
-                },
-                {
-                  "type": "null"
-                }
-              ],
-              "title": "Definition Id"
-            }
-          },
           {
             "name": "experiment",
             "in": "query",
@@ -513,13 +496,14 @@
         }
       }
     },
-    "/experiments/{experiment_id}/run": {
+    "/rollouts/experiments/{experiment_id}/rollout-batches": {
       "post": {
         "tags": [
-          "experiments"
+          "rollouts"
         ],
-        "summary": "Run Experiment",
-        "operationId": "submit_experiment_experiments__experiment_id__run_post",
+        "summary": "Submit Experiment Rollout Batch",
+        "description": "Start a trainer batch from a persisted experiment candidate pool.",
+        "operationId": "submit_experiment_rollout_batch_rollouts_experiments__experiment_id__rollout_batches_post",
         "parameters": [
           {
             "name": "experiment_id",
@@ -528,68 +512,19 @@
             "schema": {
               "type": "string",
               "format": "uuid",
-              "title": "Definition Id"
+              "title": "Experiment Id"
             }
           }
         ],
         "requestBody": {
+          "required": true,
           "content": {
             "application/json": {
               "schema": {
-                "anyOf": [
-                  {
-                    "$ref": "#/components/schemas/ExperimentRunRequest"
-                  },
-                  {
-                    "type": "null"
-                  }
-                ],
-                "title": "Request"
-              }
-            }
-          }
-        },
-        "responses": {
-          "202": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/ExperimentRunResult"
-                }
-              }
-            }
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/HTTPValidationError"
-                }
+                "$ref": "#/components/schemas/TrainingRolloutRequest"
               }
             }
           }
-        }
-      }
-    },
-    "/rollouts/submit": {
-      "post": {
-        "tags": [
-          "rollouts"
-        ],
-        "summary": "Submit Rollout",
-        "description": "Start a batch of episodes. Returns immediately with batch_id.",
-        "operationId": "submit_rollout_rollouts_submit_post",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/SubmitRequest"
-              }
-            }
-          },
-          "required": true
         },
         "responses": {
           "202": {
@@ -597,7 +532,7 @@
             "content": {
               "application/json": {
                 "schema": {
-                  "$ref": "#/components/schemas/SubmitResponse"
+                  "$ref": "#/components/schemas/RolloutBatchSummary"
                 }
               }
             }
@@ -802,215 +737,6 @@
         }
       }
     },
-    "/api/__danger__/test-harness/read/samples/{sample_id}/state": {
-      "get": {
-        "tags": [
-          "danger-test-harness"
-        ],
-        "summary": "Read Run State",
-        "operationId": "read_run_state_api___danger___test_harness_read_samples__sample_id__state_get",
-        "parameters": [
-          {
-            "name": "sample_id",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "format": "uuid",
-              "title": "Sample Id"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/TestSampleStateDto"
-                }
-              }
-            }
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/HTTPValidationError"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/__danger__/test-harness/read/experiment/{experiment}/samples": {
-      "get": {
-        "tags": [
-          "danger-test-harness"
-        ],
-        "summary": "Read Experiment Samples",
-        "description": "List all runs attached to a v2 experiment grouping tag.",
-        "operationId": "read_experiment_samples_api___danger___test_harness_read_experiment__experiment__samples_get",
-        "parameters": [
-          {
-            "name": "experiment",
-            "in": "path",
-            "required": true,
-            "schema": {
-              "type": "string",
-              "title": "Experiment"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "type": "array",
-                  "items": {
-                    "$ref": "#/components/schemas/TestExperimentSampleDto"
-                  },
-                  "title": "Response Read Experiment Samples Api   Danger   Test Harness Read Experiment  Experiment  Samples Get"
-                }
-              }
-            }
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/HTTPValidationError"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/__danger__/test-harness/write/samples/seed": {
-      "post": {
-        "tags": [
-          "danger-test-harness"
-        ],
-        "summary": "Seed Run",
-        "operationId": "seed_run_api___danger___test_harness_write_samples_seed_post",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/SeedSampleRequest"
-              }
-            }
-          },
-          "required": true
-        },
-        "responses": {
-          "201": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "additionalProperties": true,
-                  "type": "object",
-                  "title": "Response Seed Run Api   Danger   Test Harness Write Samples Seed Post"
-                }
-              }
-            }
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/HTTPValidationError"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/__danger__/test-harness/write/reset": {
-      "post": {
-        "tags": [
-          "danger-test-harness"
-        ],
-        "summary": "Reset Test Rows",
-        "operationId": "reset_test_rows_api___danger___test_harness_write_reset_post",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/ResetRequest"
-              }
-            }
-          },
-          "required": true
-        },
-        "responses": {
-          "204": {
-            "description": "Successful Response"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/HTTPValidationError"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
-    "/api/__danger__/test-harness/write/experiment-samples": {
-      "post": {
-        "tags": [
-          "danger-test-harness"
-        ],
-        "summary": "Submit Experiment Samples",
-        "description": "Build + persist + dispatch N samples under one experiment tag.\n\nPer-slot flow builds sample DAGs through the experiment/environment authoring path and submits them sequentially for deterministic smoke coverage.",
-        "operationId": "submit_experiment_samples_api___danger___test_harness_write_experiment_samples_post",
-        "requestBody": {
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/SubmitExperimentSamplesRequest"
-              }
-            }
-          },
-          "required": true
-        },
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/SubmitExperimentSamplesResponse"
-                }
-              }
-            }
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/HTTPValidationError"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
     "/api/inngest": {
       "get": {
         "summary": "Get Api Inngest",
@@ -1366,96 +1092,17 @@
         "type": "object",
         "title": "ExperimentListView"
       },
-      "ExperimentRunRequest": {
+      "ExperimentSampleSummaryView": {
         "properties": {
-          "experiment_id": {
+          "sampleId": {
             "type": "string",
             "format": "uuid",
-            "title": "Definition Id"
-          },
-          "timeout_seconds": {
-            "anyOf": [
-              {
-                "type": "integer"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Timeout Seconds"
+            "title": "Sampleid"
           },
-          "wait": {
-            "type": "boolean",
-            "title": "Wait",
-            "default": true
-          }
-        },
-        "type": "object",
-        "required": [
-          "experiment_id"
-        ],
-        "title": "ExperimentRunRequest"
-      },
-      "ExperimentRunResult": {
-        "properties": {
-          "experiment_id": {
+          "experimentId": {
             "type": "string",
             "format": "uuid",
-            "title": "Definition Id"
-          },
-          "sample_ids": {
-            "items": {
-              "type": "string",
-              "format": "uuid"
-            },
-            "type": "array",
-            "title": "Sample Ids"
-          },
-          "experiment_ids": {
-            "items": {
-              "type": "string",
-              "format": "uuid"
-            },
-            "type": "array",
-            "title": "Definition Ids"
-          }
-        },
-        "type": "object",
-        "required": [
-          "experiment_id",
-          "sample_ids"
-        ],
-        "title": "ExperimentRunResult"
-      },
-      "ExperimentSampleSlotRequest": {
-        "properties": {
-          "worker_slug": {
-            "type": "string",
-            "title": "Worker Slug"
-          },
-          "evaluator_slug": {
-            "type": "string",
-            "title": "Evaluator Slug"
-          }
-        },
-        "type": "object",
-        "required": [
-          "worker_slug",
-          "evaluator_slug"
-        ],
-        "title": "ExperimentSampleSlotRequest"
-      },
-      "ExperimentSampleSummaryView": {
-        "properties": {
-          "sampleId": {
-            "type": "string",
-            "format": "uuid",
-            "title": "Sampleid"
-          },
-          "experimentId": {
-            "type": "string",
-            "format": "uuid",
-            "title": "Experimentid"
+            "title": "Experimentid"
           },
           "environmentId": {
             "type": "string",
@@ -1718,38 +1365,25 @@
         "title": "ProviderTokenUsage",
         "description": "Provider-reported token and cost usage for one generation boundary."
       },
-      "ResetRequest": {
-        "properties": {
-          "experiment_prefix": {
-            "type": "string",
-            "title": "Experiment Prefix"
-          }
-        },
-        "type": "object",
-        "required": [
-          "experiment_prefix"
-        ],
-        "title": "ResetRequest"
-      },
       "RolloutBatchSummary": {
         "properties": {
-          "batch_id": {
+          "batchId": {
             "type": "string",
             "format": "uuid",
-            "title": "Batch Id"
+            "title": "Batchid"
           },
-          "sample_ids": {
+          "sampleIds": {
             "items": {
               "type": "string",
               "format": "uuid"
             },
             "type": "array",
-            "title": "Sample Ids"
+            "title": "Sampleids"
           },
           "status": {
             "$ref": "#/components/schemas/RolloutStatus"
           },
-          "experiment_id": {
+          "experimentId": {
             "anyOf": [
               {
                 "type": "string",
@@ -1759,9 +1393,9 @@
                 "type": "null"
               }
             ],
-            "title": "Experiment Id"
+            "title": "Experimentid"
           },
-          "sampler_invocation_id": {
+          "samplerInvocationId": {
             "anyOf": [
               {
                 "type": "string",
@@ -1771,13 +1405,13 @@
                 "type": "null"
               }
             ],
-            "title": "Sampler Invocation Id"
+            "title": "Samplerinvocationid"
           }
         },
         "type": "object",
         "required": [
-          "batch_id",
-          "sample_ids",
+          "batchId",
+          "sampleIds",
           "status"
         ],
         "title": "RolloutBatchSummary",
@@ -1994,7 +1628,7 @@
                 "type": "null"
               }
             ],
-            "title": "Taskexecutionid"
+            "title": "Taskattemptid"
           },
           "fromAgentId": {
             "type": "string",
@@ -2123,7 +1757,7 @@
           "taskAttemptId": {
             "type": "string",
             "format": "uuid",
-            "title": "Taskexecutionid"
+            "title": "Taskattemptid"
           },
           "taskId": {
             "type": "string",
@@ -3191,7 +2825,7 @@
           },
           "taskAttemptId": {
             "type": "string",
-            "title": "Taskexecutionid"
+            "title": "Taskattemptid"
           },
           "name": {
             "type": "string",
@@ -3532,13 +3166,14 @@
           "experimentId": {
             "anyOf": [
               {
-                "type": "string"
+                "type": "string",
+                "format": "uuid"
               },
               {
                 "type": "null"
               }
             ],
-            "title": "Definitionid"
+            "title": "Experimentid"
           },
           "name": {
             "type": "string",
@@ -3940,18 +3575,7 @@
                 "type": "null"
               }
             ],
-            "title": "Definition Id"
-          },
-          "experiment_name": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Definition Name"
+            "title": "Experiment Id"
           },
           "experiment": {
             "anyOf": [
@@ -4747,198 +4371,6 @@
         "type": "object",
         "title": "SamplerInvocationsView"
       },
-      "SeedSampleRequest": {
-        "properties": {
-          "experiment_id": {
-            "type": "string",
-            "format": "uuid",
-            "title": "Definition Id"
-          },
-          "benchmark_type": {
-            "type": "string",
-            "title": "Benchmark Type",
-            "default": "test-harness"
-          },
-          "instance_key": {
-            "type": "string",
-            "title": "Instance Key",
-            "default": "seeded"
-          },
-          "worker_team": {
-            "additionalProperties": true,
-            "type": "object",
-            "title": "Worker Team"
-          },
-          "experiment": {
-            "type": "string",
-            "title": "Experiment",
-            "default": "_test_"
-          },
-          "status": {
-            "type": "string",
-            "title": "Status",
-            "default": "completed"
-          },
-          "task_slugs": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array",
-            "title": "Task Slugs",
-            "default": []
-          }
-        },
-        "type": "object",
-        "required": [
-          "experiment_id"
-        ],
-        "title": "SeedSampleRequest"
-      },
-      "SubmitExperimentSamplesRequest": {
-        "properties": {
-          "benchmark_slug": {
-            "type": "string",
-            "title": "Benchmark Slug"
-          },
-          "slots": {
-            "items": {
-              "$ref": "#/components/schemas/ExperimentSampleSlotRequest"
-            },
-            "type": "array",
-            "title": "Slots"
-          },
-          "experiment": {
-            "type": "string",
-            "title": "Experiment"
-          },
-          "sandbox_slug": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Sandbox Slug"
-          },
-          "dependency_extras": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array",
-            "title": "Dependency Extras",
-            "default": [
-              "none"
-            ]
-          },
-          "model": {
-            "type": "string",
-            "title": "Model",
-            "default": "openai:gpt-4o"
-          },
-          "limit": {
-            "type": "integer",
-            "title": "Limit",
-            "default": 1
-          }
-        },
-        "type": "object",
-        "required": [
-          "benchmark_slug",
-          "slots",
-          "experiment"
-        ],
-        "title": "SubmitExperimentSamplesRequest"
-      },
-      "SubmitExperimentSamplesResponse": {
-        "properties": {
-          "sample_ids": {
-            "items": {
-              "type": "string",
-              "format": "uuid"
-            },
-            "type": "array",
-            "title": "Sample Ids"
-          }
-        },
-        "type": "object",
-        "required": [
-          "sample_ids"
-        ],
-        "title": "SubmitExperimentSamplesResponse"
-      },
-      "SubmitRequest": {
-        "properties": {
-          "experiment_id": {
-            "type": "string",
-            "format": "uuid",
-            "title": "Definition Id"
-          },
-          "num_episodes": {
-            "type": "integer",
-            "minimum": 1.0,
-            "title": "Num Episodes"
-          },
-          "policy_version": {
-            "anyOf": [
-              {
-                "type": "integer"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Policy Version"
-          },
-          "model_target_override": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Model Target Override"
-          }
-        },
-        "type": "object",
-        "required": [
-          "experiment_id",
-          "num_episodes"
-        ],
-        "title": "SubmitRequest",
-        "description": "Trainer \u2192 Ergon: start a batch of episodes."
-      },
-      "SubmitResponse": {
-        "properties": {
-          "batch_id": {
-            "type": "string",
-            "format": "uuid",
-            "title": "Batch Id"
-          },
-          "sample_ids": {
-            "items": {
-              "type": "string",
-              "format": "uuid"
-            },
-            "type": "array",
-            "title": "Sample Ids"
-          },
-          "status": {
-            "$ref": "#/components/schemas/RolloutStatus",
-            "default": "pending"
-          }
-        },
-        "type": "object",
-        "required": [
-          "batch_id",
-          "sample_ids"
-        ],
-        "title": "SubmitResponse",
-        "description": "Ergon \u2192 Trainer: batch accepted."
-      },
       "SystemPromptPart": {
         "properties": {
           "part_kind": {
@@ -4960,265 +4392,6 @@
         ],
         "title": "SystemPromptPart"
       },
-      "TestEvaluationDto": {
-        "properties": {
-          "task_id": {
-            "type": "string",
-            "format": "uuid",
-            "title": "Task Id"
-          },
-          "task_slug": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Task Slug"
-          },
-          "score": {
-            "type": "number",
-            "title": "Score"
-          },
-          "reason": {
-            "type": "string",
-            "title": "Reason"
-          }
-        },
-        "type": "object",
-        "required": [
-          "task_id",
-          "task_slug",
-          "score",
-          "reason"
-        ],
-        "title": "TestEvaluationDto"
-      },
-      "TestExecutionDto": {
-        "properties": {
-          "task_slug": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Task Slug"
-          },
-          "status": {
-            "type": "string",
-            "title": "Status"
-          },
-          "error": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Error"
-          }
-        },
-        "type": "object",
-        "required": [
-          "task_slug",
-          "status",
-          "error"
-        ],
-        "title": "TestExecutionDto"
-      },
-      "TestExperimentSampleDto": {
-        "properties": {
-          "sample_id": {
-            "type": "string",
-            "format": "uuid",
-            "title": "Sample Id"
-          },
-          "status": {
-            "type": "string",
-            "title": "Status"
-          }
-        },
-        "type": "object",
-        "required": [
-          "sample_id",
-          "status"
-        ],
-        "title": "TestExperimentSampleDto"
-      },
-      "TestGraphNodeDto": {
-        "properties": {
-          "id": {
-            "type": "string",
-            "format": "uuid",
-            "title": "Id"
-          },
-          "task_slug": {
-            "type": "string",
-            "title": "Task Slug"
-          },
-          "level": {
-            "type": "integer",
-            "title": "Level"
-          },
-          "status": {
-            "type": "string",
-            "title": "Status"
-          },
-          "parent_task_id": {
-            "anyOf": [
-              {
-                "type": "string",
-                "format": "uuid"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Parent Task Id"
-          },
-          "parent_task_slug": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Parent Task Slug"
-          }
-        },
-        "type": "object",
-        "required": [
-          "id",
-          "task_slug",
-          "level",
-          "status",
-          "parent_task_id",
-          "parent_task_slug"
-        ],
-        "title": "TestGraphNodeDto"
-      },
-      "TestSampleStateDto": {
-        "properties": {
-          "sample_id": {
-            "type": "string",
-            "format": "uuid",
-            "title": "Sample Id"
-          },
-          "status": {
-            "type": "string",
-            "title": "Status"
-          },
-          "graph_nodes": {
-            "items": {
-              "$ref": "#/components/schemas/TestGraphNodeDto"
-            },
-            "type": "array",
-            "title": "Graph Nodes"
-          },
-          "events": {
-            "items": {
-              "$ref": "#/components/schemas/TestSampleRuntimeEventDto"
-            },
-            "type": "array",
-            "title": "Events"
-          },
-          "evaluations": {
-            "items": {
-              "$ref": "#/components/schemas/TestEvaluationDto"
-            },
-            "type": "array",
-            "title": "Evaluations"
-          },
-          "executions": {
-            "items": {
-              "$ref": "#/components/schemas/TestExecutionDto"
-            },
-            "type": "array",
-            "title": "Executions"
-          },
-          "execution_count": {
-            "type": "integer",
-            "title": "Execution Count"
-          },
-          "event_count": {
-            "type": "integer",
-            "title": "Event Count"
-          },
-          "resource_count": {
-            "type": "integer",
-            "title": "Resource Count"
-          },
-          "thread_count": {
-            "type": "integer",
-            "title": "Thread Count"
-          },
-          "context_event_count": {
-            "type": "integer",
-            "title": "Context Event Count"
-          }
-        },
-        "type": "object",
-        "required": [
-          "sample_id",
-          "status",
-          "graph_nodes",
-          "events",
-          "evaluations",
-          "executions",
-          "execution_count",
-          "event_count",
-          "resource_count",
-          "thread_count",
-          "context_event_count"
-        ],
-        "title": "TestSampleStateDto"
-      },
-      "TestSampleRuntimeEventDto": {
-        "properties": {
-          "table": {
-            "type": "string",
-            "title": "Table"
-          },
-          "event_type": {
-            "type": "string",
-            "title": "Event Type"
-          },
-          "target_id": {
-            "anyOf": [
-              {
-                "type": "string",
-                "format": "uuid"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "title": "Target Id"
-          },
-          "payload": {
-            "additionalProperties": true,
-            "type": "object",
-            "title": "Payload"
-          }
-        },
-        "type": "object",
-        "required": [
-          "table",
-          "event_type",
-          "target_id",
-          "payload"
-        ],
-        "title": "TestSampleRuntimeEventDto"
-      },
       "ThinkingPart": {
         "properties": {
           "part_kind": {
@@ -5342,6 +4515,48 @@
         ],
         "title": "ToolResultPart"
       },
+      "TrainingRolloutRequest": {
+        "properties": {
+          "experimentId": {
+            "type": "string",
+            "format": "uuid",
+            "title": "Experimentid"
+          },
+          "k": {
+            "type": "integer",
+            "minimum": 1.0,
+            "title": "K"
+          },
+          "sampler": {
+            "type": "string",
+            "title": "Sampler",
+            "default": "random"
+          },
+          "samplerConfig": {
+            "additionalProperties": true,
+            "type": "object",
+            "title": "Samplerconfig"
+          },
+          "candidatePoolSize": {
+            "anyOf": [
+              {
+                "type": "integer"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Candidatepoolsize"
+          }
+        },
+        "type": "object",
+        "required": [
+          "experimentId",
+          "k"
+        ],
+        "title": "TrainingRolloutRequest",
+        "description": "Trainer \u2192 Ergon: select and launch samples from a persisted experiment."
+      },
       "Trajectory": {
         "properties": {
           "sample_id": {
diff --git a/ergon_core/ergon_core/api/_serialization.py b/ergon_core/ergon_core/api/_serialization.py
index f4d186f8f..ad9accd31 100644
--- a/ergon_core/ergon_core/api/_serialization.py
+++ b/ergon_core/ergon_core/api/_serialization.py
@@ -16,10 +16,9 @@
 
 type TaskDefinitionJson = dict[str, JsonValue]
 """Serialized form of a Task / Worker / Sandbox / Criterion / etc —
-``_type``-discriminated JSON written to ``run_graph_nodes.task_json``
-and the matching definition columns. Field names are NOT enforced by
-this type (the discriminator dispatch in ``from_definition`` does
-that); the value side IS typed via pydantic's ``JsonValue``, so
+``_type``-discriminated JSON written to sample graph/component snapshots.
+Field names are NOT enforced by this type (the discriminator dispatch in
+``from_definition`` does that); the value side IS typed via pydantic's ``JsonValue``, so
 accidentally stuffing a ``datetime`` or ``UUID`` object into the
 snapshot fails at typecheck time instead of at JSON-serialization
 time. The alias is the named boundary every ``from_definition``
diff --git a/ergon_core/ergon_core/core/views/samples/models.py b/ergon_core/ergon_core/core/views/samples/models.py
index 0b34cf9cc..99cfc264f 100644
--- a/ergon_core/ergon_core/core/views/samples/models.py
+++ b/ergon_core/ergon_core/core/views/samples/models.py
@@ -198,6 +198,7 @@ class SampleSnapshotMetricsDto(CamelModel):
 
 class SampleSnapshotDto(CamelModel):
     id: str
+    experiment_id: UUID | None = None
     name: str
     status: str
     tasks: dict[str, SampleTaskDto] = Field(default_factory=dict)
diff --git a/ergon_core/ergon_core/core/views/samples/service.py b/ergon_core/ergon_core/core/views/samples/service.py
index 9460c8cc5..92d5f0598 100644
--- a/ergon_core/ergon_core/core/views/samples/service.py
+++ b/ergon_core/ergon_core/core/views/samples/service.py
@@ -185,6 +185,7 @@ def build_snapshot(self, sample_id: UUID) -> SampleSnapshotDto | None:
 
         return SampleSnapshotDto(
             id=sample_id_str,
+            experiment_id=run.experiment_id,
             name=run_name,
             status=run.status,
             tasks=task_map,
diff --git a/ergon_core/tests/unit/read_models/test_sample_read_service.py b/ergon_core/tests/unit/read_models/test_sample_read_service.py
index fc4340e09..20f62afc2 100644
--- a/ergon_core/tests/unit/read_models/test_sample_read_service.py
+++ b/ergon_core/tests/unit/read_models/test_sample_read_service.py
@@ -165,6 +165,11 @@ def test_list_runs_filters_offsets_and_projects_index_summary(monkeypatch, sessi
     assert summary.model_target == "openai:gpt-4.1"
     assert summary.metrics == {"pass_rate": 0.9}
 
+    snapshot = SampleSnapshotReadService().build_snapshot(matching_run_id)
+
+    assert snapshot is not None
+    assert snapshot.experiment_id == experiment_id
+
 
 def test_failed_run_snapshot_preserves_persisted_final_score(monkeypatch, session_factory) -> None:
     now = datetime(2026, 5, 20, 12, 0, tzinfo=UTC)

From 02990b93dd14fc8d844b305afcec3a97f51af752 Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Thu, 28 May 2026 14:47:44 +0100
Subject: [PATCH 13/15] Retire benchmark authoring indirection

---
 .../DashboardWorkflowStartedEvent.schema.json |  13 +
 ergon_builtins/AGENTS.md                      |  12 +-
 .../ergon_builtins/agents/react/worker.py     |   2 +-
 .../agents/training/synthetic_worker.py       |   2 +-
 .../ergon_builtins/benchmarks/README.md       |  50 +--
 .../benchmarks/gdpeval/__init__.py            |  10 +-
 .../benchmarks/gdpeval/benchmark.py           | 139 --------
 .../benchmarks/gdpeval/criteria/llm_judge.py  |   2 +-
 .../benchmarks/gdpeval/dataset.py             |  40 +++
 .../benchmarks/gdpeval/loader.py              |   3 +-
 .../gdpeval/rubric/staged_rubric.py           |   2 +-
 .../benchmarks/gdpeval/sample.py              |  54 +++
 .../ergon_builtins/benchmarks/gdpeval/task.py |  18 +
 .../benchmarks/gdpeval/worker_factory.py      |  52 ---
 .../benchmarks/minif2f/benchmark.py           | 140 --------
 .../benchmarks/minif2f/dataset.py             |  58 ++++
 .../benchmarks/minif2f/rubric.py              |   2 +-
 .../benchmarks/minif2f/sample.py              |  52 +++
 .../minif2f/sandbox_template/README.md        |   4 +-
 .../sandbox_template/e2b.toml.template        |   2 +-
 .../minif2f/sandbox_template/utils.py         |   2 +-
 .../ergon_builtins/benchmarks/minif2f/task.py |  20 ++
 .../benchmarks/minif2f/task_schemas.py        |   2 +-
 .../benchmarks/minif2f/toolkit.py             |   5 +-
 .../benchmarks/minif2f/worker_factory.py      |  38 --
 .../benchmarks/researchrubrics/__init__.py    |  11 +-
 .../benchmarks/researchrubrics/benchmark.py   | 140 --------
 .../benchmarks/researchrubrics/dataset.py     |  39 +++
 .../benchmarks/researchrubrics/rubric.py      |   2 +-
 .../benchmarks/researchrubrics/sample.py      |  71 ++++
 .../benchmarks/researchrubrics/task.py        |  53 +++
 .../researchrubrics/task_schemas.py           |   2 +-
 .../benchmarks/researchrubrics/vanilla.py     |  35 --
 .../researchrubrics/worker_factory.py         |  50 ---
 .../benchmarks/swebench_verified/__init__.py  |  11 +-
 .../benchmarks/swebench_verified/benchmark.py | 109 ------
 .../benchmarks/swebench_verified/dataset.py   |  36 ++
 .../benchmarks/swebench_verified/sample.py    |  56 +++
 .../sandbox_template/e2b.toml.template        |   2 +-
 .../sandbox_template/utils.py                 |   2 +-
 .../benchmarks/swebench_verified/task.py      |  21 ++
 .../swebench_verified/task_schemas.py         |   2 +-
 .../swebench_verified/worker_factory.py       |  37 --
 .../ergon_builtins/environments/__init__.py   |  16 +-
 .../ergon_builtins/environments/_resolve.py   |  33 --
 .../{benchmarks => environments}/catalog.py   |  34 +-
 .../ergon_builtins/environments/gdpeval.py    | 133 -------
 .../ergon_builtins/environments/minif2f.py    | 137 --------
 .../environments/researchrubrics.py           | 144 --------
 .../environments/swebench_verified.py         | 143 --------
 .../ergon_builtins/sandbox/__init__.py        |   8 +-
 .../ergon_builtins/toolkits/common/base.py    |   2 +-
 .../toolkits/subagents/toolkit.py             |   2 +-
 .../tools/dynamic_task_factory.py             |   2 +-
 .../tools/workflow_command_adapter.py         |   2 +-
 .../tools/test_workflow_command_adapter.py    |   2 +-
 ...est_object_bound_benchmarks_no_registry.py |   4 +-
 .../tests/unit/benchmarks/test_catalog.py     |  10 +-
 .../test_minif2f_proof_verification.py        |   2 +-
 .../benchmarks/test_minif2f_task_shape.py     |  80 +++--
 .../benchmarks/test_source_sample_helpers.py  | 282 +++++++++++++++
 .../test_swebench_criterion_patch_source.py   |   2 +-
 .../tests/unit/environments/conftest.py       | 132 ++++---
 .../environments/test_environment_exports.py  |  21 +-
 .../environments/test_gdpeval_environment.py  |   2 +-
 .../environments/test_minif2f_environment.py  |   2 +-
 .../test_researchrubrics_environment.py       |   2 +-
 .../test_swebench_verified_environment.py     |   2 +-
 .../unit/state/test_benchmark_contract.py     |  80 -----
 .../unit/state/test_gdpeval_benchmark.py      |  53 ---
 .../state/test_research_rubrics_benchmark.py  | 327 ------------------
 .../test_builtin_task_definition_roundtrip.py | 138 +++++---
 .../tests/unit/test_gdpeval_v2_definition.py  | 147 --------
 .../test_research_rubrics_v2_definition.py    | 180 ----------
 .../tests/unit/test_swebench_v2_definition.py | 150 --------
 .../test_react_toolkit_serialization.py       |  19 +-
 .../workers/test_react_worker_contract.py     |   2 +-
 ergon_cli/ergon_cli/app.py                    |   4 +-
 .../ergon_cli/domains/benchmarks/__init__.py  |   1 -
 .../ergon_cli/domains/benchmarks/commands.py  |  22 --
 .../ergon_cli/domains/benchmarks/parser.py    |  10 -
 .../domains/environments/__init__.py          |   1 +
 .../domains/environments/commands.py          |  22 ++
 .../{benchmarks => environments}/models.py    |   2 +-
 .../ergon_cli/domains/environments/parser.py  |  13 +
 .../{benchmarks => environments}/service.py   |  18 +-
 .../{benchmarks => environments}/templates.py |   8 +-
 ergon_cli/ergon_cli/domains/eval/commands.py  |   4 +-
 ergon_cli/ergon_cli/domains/eval/models.py    |   2 +-
 ergon_cli/ergon_cli/domains/eval/parser.py    |   4 +-
 ergon_cli/ergon_cli/domains/eval/service.py   |   4 +-
 .../ergon_cli/domains/onboarding/commands.py  |   8 +-
 .../ergon_cli/domains/onboarding/profile.py   |  38 +-
 .../ergon_cli/domains/samples/commands.py     |   2 +-
 ergon_cli/ergon_cli/domains/tests/catalog.py  |   4 +-
 ergon_cli/ergon_cli/domains/tests/parser.py   |   4 +-
 ergon_cli/ergon_cli/domains/tests/service.py  |  16 +-
 .../ergon_cli/domains/training/commands.py    |   2 +-
 .../ergon_cli/domains/training/models.py      |   2 +-
 .../ergon_cli/domains/training/parser.py      |   2 +-
 .../ergon_cli/domains/training/service.py     |   2 +-
 .../ergon_cli/domains/workflow/commands.py    |   2 +-
 .../ergon_cli/domains/workflow/executor.py    |   2 +-
 .../ergon_cli/domains/workflow/parser.py      |   2 +-
 .../test_cli_domain_boundaries.py             |   2 +-
 .../test_cli_import_boundaries.py             |   6 +-
 ...ark_setup.py => test_environment_setup.py} |  40 +--
 .../unit/cli/test_eval_cli_required_fields.py |   4 +-
 .../unit/cli/test_parser_registration.py      |   4 +-
 ergon_cli/tests/unit/cli/test_sample_cli.py   |   2 +
 ergon_cli/tests/unit/cli/test_training_cli.py |   2 +-
 ergon_cli/tests/unit/state/test_env_writer.py |   2 +-
 .../tests/unit/state/test_onboard_profile.py  |  46 +--
 ergon_core/ergon_core/api/__init__.py         |   7 +-
 .../ergon_core/api/benchmark/__init__.py      |   6 -
 .../ergon_core/api/benchmark/benchmark.py     |  84 -----
 .../ergon_core/api/criterion/context.py       |   2 +-
 .../ergon_core/api/experiment/environment.py  |  80 ++++-
 .../ergon_core/api/experiment/sample.py       |   2 +-
 ergon_core/ergon_core/api/rubric/evaluator.py |   2 +-
 ergon_core/ergon_core/api/rubric/rubric.py    |   2 +-
 .../ergon_core/api/{benchmark => }/task.py    |   4 +-
 ergon_core/ergon_core/api/worker/context.py   |   2 +-
 ergon_core/ergon_core/api/worker/worker.py    |   2 +-
 .../application/experiments/candidate_pool.py |   4 +-
 .../application/runtime/graph_repository.py   |   2 +-
 .../core/application/runtime/models.py        |   2 +-
 .../application/runtime/sample_records.py     |   3 -
 .../application/runtime/task_execution.py     |   2 +-
 .../application/runtime/task_management.py    |   2 +-
 .../core/application/samples/event_views.py   |   1 -
 .../application/testing/suppression_budget.py |   2 +-
 .../http/routes/test_harness.py               |  75 ++--
 .../ergon_core/core/jobs/task/execute/job.py  |   8 +-
 .../core/jobs/task/worker_execute/contract.py |   4 -
 .../core/jobs/task/worker_execute/job.py      |  16 +-
 .../ergon_core/test_support/task_factory.py   |   2 +-
 .../test_submit_starts_materialized_sample.py |   2 +-
 .../unit/api/test_benchmark_constructor.py    |  40 ---
 .../unit/api/test_environment_constructors.py |  59 ++++
 .../test_public_api_definition_roundtrip.py   |   4 +-
 .../tests/unit/api/test_worker_contract.py    |   2 +-
 .../api/worker/test_worker_context_facade.py  |   2 +-
 .../test_no_deleted_v2_symbols.py             |  19 +
 ...test_public_api_serialization_contracts.py |  84 +++--
 .../test_public_api_target_structure.py       |  11 +-
 .../test_runtime_read_boundaries.py           |   8 +-
 .../test_v2_final_state_ledger.py             |   2 +-
 .../test_sample_materialization.py            |   2 +-
 ...test_worker_execute_live_sandbox_attach.py |   6 +-
 .../tasks/test_spawn_dynamic_task_dispatch.py |   2 +-
 .../read_models/test_sample_read_service.py   |   2 -
 .../tests/unit/runtime/_test_workers.py       |   2 +-
 .../test_execute_task_evaluator_fanout.py     |  12 +-
 .../test_experiment_definition_writer.py      |  26 +-
 .../unit/runtime/test_identity_invariants.py  |   2 +-
 .../runtime/test_rubric_evaluation_service.py |   2 +-
 .../test_sample_graph_task_snapshot.py        |   4 +-
 .../unit/runtime/test_spawn_dynamic_task.py   |   2 +-
 .../runtime/test_walkthrough_smoketest.py     |   2 +-
 .../test_worker_context_containment.py        |   2 +-
 .../test_swebench_criterion_no_sandbox.py     |   2 +-
 .../01_minif2f_single_environment/submit.py   |  38 +-
 .../02_mixed_environment_training/submit.py   | 143 +++++---
 .../03_streaming_hf_dataset/submit.py         |  39 ++-
 .../04_curriculum_sampler/submit.py           |  30 +-
 .../submit.py                                 |  50 +--
 .../01_minif2f_local_llamacpp/README.md       |   4 +-
 .../01_minif2f_local_llamacpp/submit.py       |  39 ++-
 examples/getting_started/_shared/env.py       |   7 +-
 tests/e2e/_asserts.py                         |   8 +-
 tests/e2e/_submit.py                          |  10 +-
 tests/e2e/reassert.py                         |   2 +-
 tests/e2e/test_minif2f_smoke.py               |   2 +-
 tests/e2e/test_researchrubrics_smoke.py       |   2 +-
 tests/e2e/test_swebench_smoke.py              |   6 +-
 .../examples/test_experiment_api_examples.py  | 218 +++++++++---
 .../examples/test_getting_started_examples.py | 131 +++++--
 .../test_minif2f_local_llamacpp_example.py    | 179 ++++++----
 tests/fixtures/smoke_components/__init__.py   |   3 -
 tests/fixtures/smoke_components/benchmarks.py | 131 +++----
 .../integration/smokes/test_smoke_harness.py  |   4 +-
 .../swebench_verified/test_benchmark.py       | 115 ------
 .../benchmarks/test_researchrubrics.py        | 118 ++++---
 tests/real_llm/benchmarks/test_smoke_stub.py  |  80 ++---
 tests/real_llm/conftest.py                    |   2 +-
 tests/real_llm/rollout.py                     |   2 +-
 187 files changed, 2427 insertions(+), 3560 deletions(-)
 delete mode 100644 ergon_builtins/ergon_builtins/benchmarks/gdpeval/benchmark.py
 create mode 100644 ergon_builtins/ergon_builtins/benchmarks/gdpeval/dataset.py
 create mode 100644 ergon_builtins/ergon_builtins/benchmarks/gdpeval/sample.py
 create mode 100644 ergon_builtins/ergon_builtins/benchmarks/gdpeval/task.py
 delete mode 100644 ergon_builtins/ergon_builtins/benchmarks/gdpeval/worker_factory.py
 delete mode 100644 ergon_builtins/ergon_builtins/benchmarks/minif2f/benchmark.py
 create mode 100644 ergon_builtins/ergon_builtins/benchmarks/minif2f/dataset.py
 create mode 100644 ergon_builtins/ergon_builtins/benchmarks/minif2f/sample.py
 create mode 100644 ergon_builtins/ergon_builtins/benchmarks/minif2f/task.py
 delete mode 100644 ergon_builtins/ergon_builtins/benchmarks/minif2f/worker_factory.py
 delete mode 100644 ergon_builtins/ergon_builtins/benchmarks/researchrubrics/benchmark.py
 create mode 100644 ergon_builtins/ergon_builtins/benchmarks/researchrubrics/dataset.py
 create mode 100644 ergon_builtins/ergon_builtins/benchmarks/researchrubrics/sample.py
 create mode 100644 ergon_builtins/ergon_builtins/benchmarks/researchrubrics/task.py
 delete mode 100644 ergon_builtins/ergon_builtins/benchmarks/researchrubrics/vanilla.py
 delete mode 100644 ergon_builtins/ergon_builtins/benchmarks/researchrubrics/worker_factory.py
 delete mode 100644 ergon_builtins/ergon_builtins/benchmarks/swebench_verified/benchmark.py
 create mode 100644 ergon_builtins/ergon_builtins/benchmarks/swebench_verified/dataset.py
 create mode 100644 ergon_builtins/ergon_builtins/benchmarks/swebench_verified/sample.py
 create mode 100644 ergon_builtins/ergon_builtins/benchmarks/swebench_verified/task.py
 delete mode 100644 ergon_builtins/ergon_builtins/benchmarks/swebench_verified/worker_factory.py
 delete mode 100644 ergon_builtins/ergon_builtins/environments/_resolve.py
 rename ergon_builtins/ergon_builtins/{benchmarks => environments}/catalog.py (51%)
 delete mode 100644 ergon_builtins/ergon_builtins/environments/gdpeval.py
 delete mode 100644 ergon_builtins/ergon_builtins/environments/minif2f.py
 delete mode 100644 ergon_builtins/ergon_builtins/environments/researchrubrics.py
 delete mode 100644 ergon_builtins/ergon_builtins/environments/swebench_verified.py
 create mode 100644 ergon_builtins/tests/unit/benchmarks/test_source_sample_helpers.py
 delete mode 100644 ergon_builtins/tests/unit/state/test_benchmark_contract.py
 delete mode 100644 ergon_builtins/tests/unit/state/test_gdpeval_benchmark.py
 delete mode 100644 ergon_builtins/tests/unit/state/test_research_rubrics_benchmark.py
 delete mode 100644 ergon_builtins/tests/unit/test_gdpeval_v2_definition.py
 delete mode 100644 ergon_builtins/tests/unit/test_research_rubrics_v2_definition.py
 delete mode 100644 ergon_builtins/tests/unit/test_swebench_v2_definition.py
 delete mode 100644 ergon_cli/ergon_cli/domains/benchmarks/__init__.py
 delete mode 100644 ergon_cli/ergon_cli/domains/benchmarks/commands.py
 delete mode 100644 ergon_cli/ergon_cli/domains/benchmarks/parser.py
 create mode 100644 ergon_cli/ergon_cli/domains/environments/__init__.py
 create mode 100644 ergon_cli/ergon_cli/domains/environments/commands.py
 rename ergon_cli/ergon_cli/domains/{benchmarks => environments}/models.py (84%)
 create mode 100644 ergon_cli/ergon_cli/domains/environments/parser.py
 rename ergon_cli/ergon_cli/domains/{benchmarks => environments}/service.py (87%)
 rename ergon_cli/ergon_cli/domains/{benchmarks => environments}/templates.py (55%)
 rename ergon_cli/tests/unit/cli/{test_benchmark_setup.py => test_environment_setup.py} (83%)
 delete mode 100644 ergon_core/ergon_core/api/benchmark/__init__.py
 delete mode 100644 ergon_core/ergon_core/api/benchmark/benchmark.py
 rename ergon_core/ergon_core/api/{benchmark => }/task.py (98%)
 delete mode 100644 ergon_core/tests/unit/api/test_benchmark_constructor.py
 create mode 100644 ergon_core/tests/unit/api/test_environment_constructors.py
 delete mode 100644 tests/integration/swebench_verified/test_benchmark.py

diff --git a/ergon-dashboard/src/generated/events/schemas/DashboardWorkflowStartedEvent.schema.json b/ergon-dashboard/src/generated/events/schemas/DashboardWorkflowStartedEvent.schema.json
index 0417f0ac3..f54ad33d3 100644
--- a/ergon-dashboard/src/generated/events/schemas/DashboardWorkflowStartedEvent.schema.json
+++ b/ergon-dashboard/src/generated/events/schemas/DashboardWorkflowStartedEvent.schema.json
@@ -1091,6 +1091,19 @@
           "title": "Id",
           "type": "string"
         },
+        "experimentId": {
+          "anyOf": [
+            {
+              "format": "uuid",
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "title": "Experimentid"
+        },
         "name": {
           "title": "Name",
           "type": "string"
diff --git a/ergon_builtins/AGENTS.md b/ergon_builtins/AGENTS.md
index 39593da36..763b555ad 100644
--- a/ergon_builtins/AGENTS.md
+++ b/ergon_builtins/AGENTS.md
@@ -46,21 +46,21 @@ environment; see table below.
 | slug | class | requires | notes |
 |---|---|---|---|
 | `training-stub` | `workers/baselines/training_stub_worker.py` | none | Emits synthetic multi-turn data with fake logprobs/token_ids — exercises the RL extraction path without a real model. |
-| `canonical-smoke` | `workers/stubs/canonical_smoke_worker.py` | per-env leaf + its sandbox | Dispatches to a per-benchmark smoke leaf (`SweBenchSmokeRubric`, `ResearchRubricsSmokeRubric`, `MiniF2FSmokeRubric`) — the RFC 2026-04-21 canonical smoke path. |
+| `canonical-smoke` | `workers/stubs/canonical_smoke_worker.py` | per-env leaf + its sandbox | Dispatches to a per-environment smoke leaf (`SweBenchSmokeRubric`, `ResearchRubricsSmokeRubric`, `MiniF2FSmokeRubric`) — the RFC 2026-04-21 canonical smoke path. |
 | `react-v1` | `workers/baselines/react_worker.py` | LLM | Generic ReAct-style worker built on pydantic-ai.  Used by most real benchmarks. |
 | `minif2f-react` | `workers/baselines/minif2f_react_worker.py` | LLM + Lean 4 sandbox | ReAct pre-wired with `write_lean_file`, `check_lean_file`, `verify_lean_proof`.  Produces a proof artifact in `WorkerOutput`. |
 | `researchrubrics-researcher` | `workers/research_rubrics/researcher_worker.py` | LLM + E2B sandbox (`ResearchRubricsSandboxManager`) | Writes a research report to `/workspace/final_output/report.md` and publishes it as a SampleResource. |
 
 ---
 
-## Benchmarks
+## Environments
 
 | slug | class | task count | requires |
 |---|---|---|---|
-| `smoke-test` | `benchmarks/smoke_test/benchmark.py` | configurable DAG (single / linear / parallel / diamond) | none — generic orchestration fixture used by the integration tier |
-| `minif2f` | `benchmarks/minif2f/benchmark.py` | ~14k Lean 4 theorems from HuggingFace `minif2f-v2c` | Lean 4 sandbox |
-| `researchrubrics-smoke` | `benchmarks/researchrubrics/smoke.py` | 1 (instruction: "write a research report") | E2B sandbox |
-| `swebench-verified` | `benchmarks/swebench_verified/benchmark.py` | curated SWE-Bench instances | Docker sandbox (ships with repo snapshots) |
+| `minif2f` | `environments/minif2f.py` | ~14k Lean 4 theorems from HuggingFace `minif2f-v2c` | Lean 4 sandbox |
+| `researchrubrics` | `environments/researchrubrics.py` | ResearchRubrics dataset rows | E2B sandbox |
+| `swebench-verified` | `environments/swebench_verified.py` | curated SWE-Bench instances | Docker sandbox (ships with repo snapshots) |
+| `gdpeval` | `environments/gdpeval.py` | GDP document-processing tasks | E2B sandbox |
 
 ---
 
diff --git a/ergon_builtins/ergon_builtins/agents/react/worker.py b/ergon_builtins/ergon_builtins/agents/react/worker.py
index b0cc442c3..98ed909c4 100644
--- a/ergon_builtins/ergon_builtins/agents/react/worker.py
+++ b/ergon_builtins/ergon_builtins/agents/react/worker.py
@@ -6,7 +6,7 @@
 from types import NoneType
 from typing import Any, ClassVar, cast
 
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.worker import WorkerOutput
 from ergon_core.api.worker.context import WorkerContext
 from ergon_core.api.worker.worker import Worker
diff --git a/ergon_builtins/ergon_builtins/agents/training/synthetic_worker.py b/ergon_builtins/ergon_builtins/agents/training/synthetic_worker.py
index 0242d8cc6..6e172a2d8 100644
--- a/ergon_builtins/ergon_builtins/agents/training/synthetic_worker.py
+++ b/ergon_builtins/ergon_builtins/agents/training/synthetic_worker.py
@@ -14,7 +14,7 @@
 from hashlib import sha256
 from typing import ClassVar
 
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.worker import WorkerOutput
 from ergon_core.api.worker.context import WorkerContext
 from ergon_core.api.worker.worker import Worker
diff --git a/ergon_builtins/ergon_builtins/benchmarks/README.md b/ergon_builtins/ergon_builtins/benchmarks/README.md
index 3c655ea5b..bbf496f3f 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/README.md
+++ b/ergon_builtins/ergon_builtins/benchmarks/README.md
@@ -1,56 +1,56 @@
-# Builtin Benchmarks
+# Builtin Environments
 
-Each subdirectory is one benchmark.  Import from Python; **there is no
+Each subdirectory is one env.  Import from Python; **there is no
 CLI authoring path**.  Authoring is Python-only; the CLI is for
 observation (`ergon experiment show`, `ergon sample status`, and related read
 commands).
 
 ## Catalogue
 
-| Benchmark | Module | Worker factories | Default sandbox |
+| Environment | Module | Worker factories | Default sandbox |
 |---|---|---|---|
-| MiniF2F | `ergon_builtins.benchmarks.minif2f` | `make_minif2f_worker` (ReAct) | `LeanSandbox` |
-| SWE-Bench Verified | `ergon_builtins.benchmarks.swebench_verified` | `make_swebench_worker` (ReAct) | `SWEBenchSandbox` |
-| ResearchRubrics | `ergon_builtins.benchmarks.researchrubrics` | `make_research_worker` (ReAct) | `ResearchE2BSandbox` |
-| GDPEval | `ergon_builtins.benchmarks.gdpeval` | `make_gdpeval_worker` (ReAct) | `GDPEvalSandbox` |
+| MiniF2F | `ergon_builtins.environments.minif2f` | `make_minif2f_worker` (ReAct) | `LeanSandbox` |
+| SWE-Bench Verified | `ergon_builtins.environments.swebench_verified` | `make_swebench_worker` (ReAct) | `SWEBenchSandbox` |
+| ResearchRubrics | `ergon_builtins.environments.researchrubrics` | `make_research_worker` (ReAct) | `ResearchE2BSandbox` |
+| GDPEval | `ergon_builtins.environments.gdpeval` | `make_gdpeval_worker` (ReAct) | `GDPEvalSandbox` |
 
-Adding a new benchmark = a new subdirectory containing:
+Adding a new environment = a new subdirectory containing:
 
-- `benchmark.py` — `<Slug>Benchmark(Benchmark)` with parameterised
+- `env.py` — `<Slug>Environment(Environment)` with parameterised
   `__init__(*, worker_factory=..., sandbox_factory=..., evaluator_factory=...)`
-- `sandbox.py` — `<Slug>Sandbox(Sandbox)` per-benchmark
+- `sandbox.py` — `<Slug>Sandbox(Sandbox)` per-environment
 - `toolkit.py` — `<Slug>Toolkit(BaseModel)` serialisable config
 - `tools/tool_builder.py` — runtime tool builders (lazy-imported by `toolkit.py`)
 - `worker_factory.py` — `make_<slug>_worker()` factory (one per agentic
-  strategy; bind `ReActWorker` / `CoTWorker` / etc. to this benchmark's
+  strategy; bind `ReActWorker` / `CoTWorker` / etc. to this environment's
   toolkit + sandbox + system prompt)
 - `rubric.py` + optional `criteria/` — evaluator + criteria
 Then update this table in the same PR.  No core registry to edit; no
-runtime dispatch dict; no per-benchmark `experiment.py` file.
+runtime dispatch dict; no per-environment `experiment.py` file.
 
 ## Authoring example (MiniF2F)
 
 ```python
 import asyncio
-from ergon_builtins.benchmarks.minif2f import MiniF2FBenchmark
-from ergon_builtins.benchmarks.minif2f.worker_factory import make_minif2f_worker
+from ergon_builtins.environments.minif2f import MiniF2FEnvironment
+from ergon_builtins.environments.minif2f.worker_factory import make_minif2f_worker
 
 async def main():
-    benchmark = MiniF2FBenchmark(
+    env = MiniF2FEnvironment(
         worker_factory=make_minif2f_worker,
         limit=10,
     )
-    # Submit this configured benchmark through a higher-level
+    # Submit this configured environment through a higher-level
     # experiment/environment authoring flow.
-    print(benchmark.type_slug)
+    print(env.name)
 
 asyncio.run(main())
 ```
 
 ## A/B testing across strategies
 
-The benchmark is parameterised so you can swap workers without touching
-benchmark code:
+The environment is parameterised so you can swap workers without touching
+environment code:
 
 ```python
 EXPERIMENT = "minif2f-strategy-ablation-2026-05-15"
@@ -59,9 +59,9 @@ for label, worker_factory in [
     ("react", make_minif2f_worker),
     # ("cot", make_minif2f_cot_worker),   # when CoTWorker lands
 ]:
-    benchmark = MiniF2FBenchmark(worker_factory=worker_factory, limit=10)
+    env = MiniF2FEnvironment(worker_factory=worker_factory, limit=10)
     metadata = {"strategy": label}
-    # Add benchmark plus metadata to your experiment/environment authoring flow.
+    # Add environment plus metadata to your experiment/environment authoring flow.
 ```
 
 The experiment tag groups related submissions for read models and dashboards.
@@ -79,19 +79,19 @@ parameterisable — strictly better for reproducibility than `ergon run
 ## Discovery via Python
 
 ```python
-import ergon_builtins.benchmarks as benchmarks
+import ergon_builtins.environments as environments
 import pkgutil
 
-for _, name, ispkg in pkgutil.iter_modules(benchmarks.__path__):
+for _, name, ispkg in pkgutil.iter_modules(environments.__path__):
     if ispkg:
         print(name)
 ```
 
-Or just `ls ergon_builtins/ergon_builtins/benchmarks/`.
+Or just `ls ergon_builtins/ergon_builtins/environments/`.
 
 ## Observing runs via the CLI
 
-After persisting and launching a benchmark from Python, use the CLI to observe its state:
+After persisting and launching a environment from Python, use the CLI to observe its state:
 
 - `ergon run status <run-id>` — current state of one run
 - `ergon sample list [--status=S] [--experiment-id=<UUID>]` — list samples, optionally filtered
diff --git a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/__init__.py b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/__init__.py
index f52dd3ab1..177d9aab3 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/__init__.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/__init__.py
@@ -1,15 +1,13 @@
-"""GDPEval benchmark — document-processing evaluation with staged rubrics.
+"""GDPEval domain package: document-processing evaluation with staged rubrics.
 
 Namespace package only.  Concrete classes live in submodules and must
 be imported via explicit submodule paths:
 
-    from ergon_builtins.benchmarks.gdpeval.benchmark        import GDPEvalBenchmark
+    from ergon_builtins.benchmarks.gdpeval.task        import GDPEvalTask
     from ergon_builtins.benchmarks.gdpeval.rubric           import StagedRubric
     from ergon_builtins.benchmarks.gdpeval.sandbox          import GDPEvalSandbox
 
-This package previously eagerly imported the benchmark class in
-``__init__.py``, which transitively loaded ``pandas`` via
-``gdpeval/loader.py``. Keeping this file empty of eager imports lets
+Keeping this file empty of eager imports lets
 ``StagedRubric`` and ``GDPEvalSandbox`` be imported standalone without
-pulling in the benchmark's data-only dependencies.
+pulling in data-only dependencies.
 """
diff --git a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/benchmark.py b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/benchmark.py
deleted file mode 100644
index 2b51d1f35..000000000
--- a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/benchmark.py
+++ /dev/null
@@ -1,139 +0,0 @@
-"""GDPEval benchmark definition.
-
-Loads GDP document-processing tasks from the HuggingFace dataset
-cm2435-new/gdpval_preference_rubrics and exposes them via the
-:class:`Benchmark` interface.
-"""
-
-from collections.abc import Callable, Iterator, Mapping, Sequence
-from typing import Any, ClassVar
-
-from ergon_core.api import Benchmark, Task
-from ergon_core.api.rubric import Evaluator
-from ergon_core.api.sandbox import Sandbox
-from ergon_core.api.worker import Worker
-
-from ergon_builtins.benchmarks.gdpeval.loader import (
-    HF_REPO_ID,
-    extract_task_description,
-    find_reference_files,
-    load_task_ids,
-)
-from ergon_builtins.benchmarks.gdpeval.sandbox import GDPEvalSandbox
-from ergon_builtins.benchmarks.gdpeval.task_schemas import GDPTaskConfig
-from ergon_builtins.benchmarks.gdpeval.worker_factory import (
-    make_gdpeval_rubric,
-    make_gdpeval_worker,
-)
-
-
-def _default_gdpeval_sandbox() -> Sandbox:
-    return GDPEvalSandbox()
-
-
-class GDPEvalTask(Task[GDPTaskConfig]):
-    """Concrete Task subclass for GDPEval instances.
-
-    Named so ``Task.from_definition`` can resolve the ``_type``
-    discriminator as a plain module attribute.  The parameterized
-    generic ``Task[GDPTaskConfig]`` cannot be looked up that way —
-    its ``__qualname__`` includes ``[...]``.
-    """
-
-
-class GDPEvalBenchmark(Benchmark):
-    """Benchmark for GDP document-processing evaluation tasks.
-
-    Each task asks an agent to produce document outputs (DOCX, Excel,
-    CSV, …) from reference inputs.  Evaluation uses a staged rubric
-    with sequential gating.
-
-    Data is fetched from HuggingFace on first use and cached locally —
-    no local data directory required.
-    """
-
-    type_slug: ClassVar[str] = "gdpeval"
-    task_payload_model: ClassVar[type[GDPTaskConfig]] = GDPTaskConfig
-    required_packages: ClassVar[list[str]] = ["pandas", "huggingface_hub"]
-    install_hint: ClassVar[str] = "pip install 'ergon-builtins[data]'"
-
-    def __init__(
-        self,
-        *,
-        dataset_repo: str = HF_REPO_ID,
-        split: str = "train",
-        limit: int | None = None,
-        name: str | None = None,
-        description: str | None = None,
-        metadata: Mapping[str, Any] | None = None,  # slopcop: ignore[no-typing-any]
-        worker_factory: Callable[[], Worker] = make_gdpeval_worker,
-        sandbox_factory: Callable[[], Sandbox] = _default_gdpeval_sandbox,
-        evaluator_factory: Callable[[], Evaluator] = make_gdpeval_rubric,
-    ) -> None:
-        super().__init__(
-            name=name or "gdpeval",
-            description=description or "GDP Evaluation benchmark for document-processing tasks",
-            metadata=metadata,
-        )
-        self.dataset_repo = dataset_repo
-        self.split = split
-        self.limit = limit
-        self._worker_factory = worker_factory
-        self._sandbox_factory = sandbox_factory
-        self._evaluator_factory = evaluator_factory
-
-    def build_instances(self) -> Mapping[str, Sequence[Task[GDPTaskConfig]]]:
-        """Materialise one ``Task`` per GDP task.
-
-        All tasks land in a single ``"default"`` instance since there is
-        no multi-instance structure in the GDP dataset.
-        """
-        return {"default": [sample.tasks[0] for sample in self._environment().all_samples()]}
-
-    def evaluator_requirements(self) -> Sequence[str]:
-        return ()
-
-    def _load_task_configs(self) -> list[GDPTaskConfig]:
-        """Load and validate GDP task payload configs from the dataset."""
-        task_ids = load_task_ids(
-            split=self.split,
-            repo_id=self.dataset_repo,
-            limit=self.limit,
-        )
-        configs: list[GDPTaskConfig] = []
-        for task_id in task_ids:
-            ref_files = find_reference_files(task_id, repo_id=self.dataset_repo)
-            configs.append(
-                GDPTaskConfig(
-                    task_id=task_id,
-                    workflow_type="document_processing",
-                    reference_files=[str(p) for p in ref_files],
-                )
-            )
-        return configs
-
-    # Compatibility loader surface for GDPEvalEnvironment. PR11 deletes
-    # benchmark-centered authoring and these wrappers.
-    def iter_rows(self) -> Iterator[GDPTaskConfig]:
-        yield from self._load_task_configs()
-
-    def load_rows(self) -> Sequence[GDPTaskConfig]:
-        return self._load_task_configs()
-
-    def _environment(self) -> Any:
-        from ergon_builtins.environments.gdpeval import GDPEvalEnvironment
-
-        return GDPEvalEnvironment(
-            name=self.name,
-            dataset_repo=self.dataset_repo,
-            split=self.split,
-            limit=self.limit,
-            loader=self,
-            task_description=lambda row: extract_task_description(
-                row.task_id,
-                repo_id=self.dataset_repo,
-            ),
-            worker=lambda _row: self._worker_factory(),
-            sandbox=lambda _row: self._sandbox_factory(),
-            evaluators=lambda _row: (self._evaluator_factory(),),
-        )
diff --git a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/criteria/llm_judge.py b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/criteria/llm_judge.py
index 6209165e7..809f9c5b4 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/criteria/llm_judge.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/criteria/llm_judge.py
@@ -2,7 +2,7 @@
 
 This remains available for benchmark presets that want a lightweight judge,
 but it owns its provider call directly instead of reaching through
-``public sandbox runtime``. Benchmark-specific rubrics should prefer dedicated
+``public sandbox runtime``. Environment-specific rubrics should prefer dedicated
 criterion classes with their own prompts and evidence formatting.
 """
 
diff --git a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/dataset.py b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/dataset.py
new file mode 100644
index 000000000..4ee2219d3
--- /dev/null
+++ b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/dataset.py
@@ -0,0 +1,40 @@
+"""GDPEval source-loading helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+
+from ergon_builtins.benchmarks.gdpeval.loader import (
+    HF_REPO_ID,
+    find_reference_files,
+    load_task_ids,
+)
+from ergon_builtins.benchmarks.gdpeval.task_schemas import GDPTaskConfig
+
+
+def iter_gdpeval_rows(
+    *,
+    dataset_repo: str = HF_REPO_ID,
+    split: str = "train",
+    limit: int | None = None,
+) -> Iterator[GDPTaskConfig]:
+    yield from load_gdpeval_rows(dataset_repo=dataset_repo, split=split, limit=limit)
+
+
+def load_gdpeval_rows(
+    *,
+    dataset_repo: str = HF_REPO_ID,
+    split: str = "train",
+    limit: int | None = None,
+) -> Sequence[GDPTaskConfig]:
+    configs: list[GDPTaskConfig] = []
+    for task_id in load_task_ids(split=split, repo_id=dataset_repo, limit=limit):
+        ref_files = find_reference_files(task_id, repo_id=dataset_repo)
+        configs.append(
+            GDPTaskConfig(
+                task_id=task_id,
+                workflow_type="document_processing",
+                reference_files=[str(path) for path in ref_files],
+            )
+        )
+    return configs
diff --git a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/loader.py b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/loader.py
index 4a5f2a8a2..5041d07d6 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/loader.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/loader.py
@@ -8,7 +8,6 @@
 import functools
 import json
 from pathlib import Path
-from typing import Any
 
 import pandas as pd
 from huggingface_hub import hf_hub_download, snapshot_download
@@ -36,7 +35,7 @@ def _rubric_filename(split: str) -> str:
 
 
 @functools.lru_cache(maxsize=4)
-def _load_parquet(repo_id: str) -> Any:  # slopcop: ignore[no-typing-any]
+def _load_parquet(repo_id: str) -> pd.DataFrame:
     """Download gdpeval.parquet from HF and cache the DataFrame in-process."""
     path = hf_hub_download(
         repo_id=repo_id,
diff --git a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/rubric/staged_rubric.py b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/rubric/staged_rubric.py
index c04f0bfa6..c20a6585b 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/rubric/staged_rubric.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/rubric/staged_rubric.py
@@ -12,7 +12,7 @@
 from typing import Any, ClassVar, Literal
 
 from ergon_core.api.criterion import Criterion
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.api.criterion import CriterionOutcome
 from ergon_core.api.rubric import Rubric, TaskEvaluationResult
 from pydantic import (
diff --git a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/sample.py b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/sample.py
new file mode 100644
index 000000000..f1942510c
--- /dev/null
+++ b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/sample.py
@@ -0,0 +1,54 @@
+"""GDPEval sample construction helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import cast
+
+from ergon_core.api import Sample, Task
+from ergon_core.api.rubric import Evaluator
+from ergon_core.api.sandbox import Sandbox
+from ergon_core.api.worker import Worker
+
+from ergon_builtins.benchmarks.gdpeval.loader import HF_REPO_ID, extract_task_description
+from ergon_builtins.benchmarks.gdpeval.task import GDPEvalTask
+from ergon_builtins.benchmarks.gdpeval.task_schemas import GDPTaskConfig
+
+
+def make_gdpeval_sample(
+    row: GDPTaskConfig,
+    *,
+    environment_name: str,
+    worker: Worker,
+    evaluators: Sequence[Evaluator],
+    sandbox: Sandbox,
+    split: str = "train",
+    dataset_repo: str = HF_REPO_ID,
+    task_description: Callable[[GDPTaskConfig], str] | None = None,
+) -> Sample:
+    description = (
+        task_description(row)
+        if task_description is not None
+        else extract_task_description(row.task_id, repo_id=dataset_repo)
+    )
+    task = GDPEvalTask(
+        task_slug=row.task_id,
+        instance_key="default",
+        description=description,
+        task_payload=row,
+        worker=worker,
+        sandbox=sandbox,
+        evaluators=tuple(evaluators),
+    )
+    return Sample.from_tasks(
+        name=f"{environment_name}:{row.task_id}",
+        sample_key=row.task_id,
+        environment_name=environment_name,
+        sample_ref={"task_id": row.task_id, "split": split},
+        source_metadata={
+            "provider": "ergon-builtin:gdpeval",
+            "dataset_repo": dataset_repo,
+            "split": split,
+        },
+        tasks=[cast(Task, task)],
+    )
diff --git a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/task.py b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/task.py
new file mode 100644
index 000000000..44b0e112a
--- /dev/null
+++ b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/task.py
@@ -0,0 +1,18 @@
+"""GDPEval concrete task type."""
+
+from ergon_core.api import Task
+
+from ergon_builtins.benchmarks.gdpeval.task_schemas import GDPTaskConfig
+
+
+class GDPEvalTask(Task[GDPTaskConfig]):
+    """Concrete Task subclass for GDPEval instances.
+
+    Named so ``Task.from_definition`` can resolve the ``_type``
+    discriminator as a plain module attribute.  The parameterized
+    generic ``Task[GDPTaskConfig]`` cannot be looked up that way —
+    its ``__qualname__`` includes ``[...]``.
+    """
+
+
+__all__ = ["GDPEvalTask"]
diff --git a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/worker_factory.py b/ergon_builtins/ergon_builtins/benchmarks/gdpeval/worker_factory.py
deleted file mode 100644
index 1e07e77ab..000000000
--- a/ergon_builtins/ergon_builtins/benchmarks/gdpeval/worker_factory.py
+++ /dev/null
@@ -1,52 +0,0 @@
-"""GDPEval worker factories — one per agentic strategy.
-
-Each factory bundles the GDPEval sandbox, toolkit, and system prompt
-with a chosen worker class (ReActWorker today; CoTWorker / ReflexionWorker
-future).  Strategies vary independently; the domain bundle is constant.
-
-v2 callers use ``make_gdpeval_worker()`` directly from the benchmark
-object graph.
-"""
-
-from ergon_builtins.benchmarks.gdpeval.prompts import GDPEVAL_SYSTEM_PROMPT
-from ergon_builtins.benchmarks.gdpeval.rubric import StagedRubric
-from ergon_builtins.benchmarks.gdpeval.toolkit import GDPEvalToolkit
-
-from ergon_builtins.agents.react.worker import ReActWorker
-
-__all__ = [
-    "make_gdpeval_rubric",
-    "make_gdpeval_worker",
-]
-
-
-DEFAULT_WORKER_MODEL = "openai:gpt-4o-mini"
-
-
-def make_gdpeval_worker(
-    *,
-    model: str = DEFAULT_WORKER_MODEL,
-    max_iterations: int = 40,
-) -> ReActWorker:
-    """Return a serializable ReActWorker for GDPEval (v2 authoring shape)."""
-    return ReActWorker(
-        name="gdpeval-runner",
-        model=model,
-        system_prompt=GDPEVAL_SYSTEM_PROMPT,
-        max_iterations=max_iterations,
-        toolkit=GDPEvalToolkit(),
-    )
-
-
-def make_gdpeval_rubric() -> StagedRubric:
-    """Return a serializable GDPEval ``StagedRubric`` for inline evaluation.
-
-    The default rubric is empty-staged; callers can pass a pre-configured
-    ``StagedRubric`` directly to ``GDPEvalBenchmark(evaluator_factory=...)``
-    when bespoke stage configuration is needed.
-    """
-    return StagedRubric(
-        name="gdpeval-staged-rubric",
-        category_name="default",
-        max_total_score=1.0,
-    )
diff --git a/ergon_builtins/ergon_builtins/benchmarks/minif2f/benchmark.py b/ergon_builtins/ergon_builtins/benchmarks/minif2f/benchmark.py
deleted file mode 100644
index a3d238a43..000000000
--- a/ergon_builtins/ergon_builtins/benchmarks/minif2f/benchmark.py
+++ /dev/null
@@ -1,140 +0,0 @@
-"""MiniF2F benchmark for formal math proof verification (Lean 4, v2c).
-
-Loads problems from the roozbeh-yz/miniF2F_v2 HuggingFace dataset repo,
-specifically the ``miniF2F_v2c.jsonl`` file containing Lean 4 theorem
-statements aligned with mathlib4.
-"""
-
-import json
-import logging
-from collections.abc import Callable, Iterator, Mapping, Sequence
-from pathlib import Path
-from typing import Any, ClassVar
-
-from ergon_core.api import Benchmark, Task
-from ergon_core.api.rubric import Evaluator
-from ergon_core.api.sandbox import Sandbox
-from ergon_core.api.worker import Worker
-from huggingface_hub import hf_hub_download
-
-from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FProblem, MiniF2FTaskPayload
-from ergon_builtins.benchmarks.minif2f.worker_factory import (
-    make_minif2f_rubric,
-    make_minif2f_worker,
-)
-from ergon_builtins.benchmarks.minif2f.sandbox import LeanSandbox
-
-logger = logging.getLogger(__name__)
-
-HF_REPO_ID = "roozbeh-yz/miniF2F_v2"
-HF_FILENAME = "miniF2F_v2c.jsonl"
-
-
-class MiniF2FTask(Task[MiniF2FTaskPayload]):
-    """Concrete Task subclass for MiniF2F instances.
-
-    Named so ``Task.from_definition`` can resolve the ``_type``
-    discriminator as a plain module attribute. The parameterized
-    generic ``Task[MiniF2FTaskPayload]`` cannot be looked up that way.
-    """
-
-
-class MiniF2FBenchmark(Benchmark):
-    """Benchmark backed by the MiniF2F-v2c dataset of formal math problems.
-
-    ``build_instances`` downloads the jsonl from HuggingFace Hub (cached
-    locally) and returns one task per theorem.
-    """
-
-    type_slug: ClassVar[str] = "minif2f"
-    task_payload_model: ClassVar[type[MiniF2FTaskPayload]] = MiniF2FTaskPayload
-
-    def __init__(
-        self,
-        *,
-        data_dir: Path | str | None = None,
-        limit: int | None = None,
-        name: str | None = None,
-        description: str | None = None,
-        metadata: Mapping[str, Any] | None = None,  # slopcop: ignore[no-typing-any]
-        worker_factory: Callable[[], Worker] = make_minif2f_worker,
-        sandbox_factory: Callable[[], Sandbox] = LeanSandbox,
-        evaluator_factory: Callable[[], Evaluator] = make_minif2f_rubric,
-    ) -> None:
-        super().__init__(
-            name=name or "minif2f",
-            description=description or "MiniF2F formal math proof benchmark (Lean 4, v2c)",
-            metadata=metadata,
-        )
-        self.data_dir = Path(data_dir) if data_dir else None
-        self.limit = limit
-        self._worker_factory = worker_factory
-        self._sandbox_factory = sandbox_factory
-        self._evaluator_factory = evaluator_factory
-
-    # ------------------------------------------------------------------
-
-    def build_instances(self) -> Mapping[str, Sequence[Task[MiniF2FTaskPayload]]]:
-        return {"default": [sample.tasks[0] for sample in self._environment().all_samples()]}
-
-    def evaluator_requirements(self) -> Sequence[str]:
-        return ()
-
-    # ------------------------------------------------------------------
-
-    def _download_jsonl(self) -> Path:
-        """Download the v2c jsonl from HuggingFace Hub, returning the cached path."""
-        cache_dir = str(self.data_dir) if self.data_dir else None
-        path = hf_hub_download(
-            repo_id=HF_REPO_ID,
-            filename=HF_FILENAME,
-            repo_type="dataset",
-            cache_dir=cache_dir,
-        )
-        return Path(path)
-
-    def _load_problems(self) -> list[MiniF2FProblem]:
-        jsonl_path = self._download_jsonl()
-        logger.info("Loading MiniF2F-v2c problems from %s", jsonl_path)
-
-        problems: list[MiniF2FProblem] = []
-        with jsonl_path.open(encoding="utf-8") as f:
-            for line in f:
-                line = line.strip()
-                if not line:
-                    continue
-                raw = json.loads(line)
-                problems.append(
-                    MiniF2FProblem(
-                        name=raw["name"],
-                        informal_statement=raw["informal_statement"],
-                        formal_statement=raw["formal_statement"],
-                        header=raw["header"],
-                    )
-                )
-                if self.limit and len(problems) >= self.limit:
-                    break
-
-        logger.info("Loaded %d MiniF2F-v2c problems", len(problems))
-        return problems
-
-    # Compatibility loader surface for MiniF2FEnvironment. PR11 deletes
-    # benchmark-centered authoring and these wrappers.
-    def iter_rows(self) -> Iterator[MiniF2FProblem]:
-        yield from self._load_problems()
-
-    def load_rows(self) -> Sequence[MiniF2FProblem]:
-        return self._load_problems()
-
-    def _environment(self) -> Any:
-        from ergon_builtins.environments.minif2f import MiniF2FEnvironment
-
-        return MiniF2FEnvironment(
-            name=self.name,
-            limit=self.limit,
-            data_dir=self.data_dir,
-            loader=self,
-            worker=lambda _row: self._worker_factory(),
-            sandbox=lambda _row: self._sandbox_factory(),
-            evaluators=lambda _row: (self._evaluator_factory(),),
-        )
diff --git a/ergon_builtins/ergon_builtins/benchmarks/minif2f/dataset.py b/ergon_builtins/ergon_builtins/benchmarks/minif2f/dataset.py
new file mode 100644
index 000000000..fd866aee2
--- /dev/null
+++ b/ergon_builtins/ergon_builtins/benchmarks/minif2f/dataset.py
@@ -0,0 +1,58 @@
+"""MiniF2F source-loading helpers."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator, Sequence
+from pathlib import Path
+
+from huggingface_hub import hf_hub_download
+
+from ergon_builtins.benchmarks.minif2f.task import HF_FILENAME, HF_REPO_ID
+from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FProblem
+
+
+def iter_minif2f_rows(
+    *,
+    split: str = "validation",
+    data_dir: Path | None = None,
+    limit: int | None = None,
+) -> Iterator[MiniF2FProblem]:
+    del split
+    yield from load_minif2f_rows(data_dir=data_dir, limit=limit)
+
+
+def load_minif2f_rows(
+    *,
+    split: str = "validation",
+    data_dir: Path | None = None,
+    limit: int | None = None,
+) -> Sequence[MiniF2FProblem]:
+    del split
+    cache_dir = str(data_dir) if data_dir else None
+    jsonl_path = Path(
+        hf_hub_download(
+            repo_id=HF_REPO_ID,
+            filename=HF_FILENAME,
+            repo_type="dataset",
+            cache_dir=cache_dir,
+        )
+    )
+    rows: list[MiniF2FProblem] = []
+    with jsonl_path.open(encoding="utf-8") as f:
+        for line in f:
+            stripped = line.strip()
+            if not stripped:
+                continue
+            raw = json.loads(stripped)
+            rows.append(
+                MiniF2FProblem(
+                    name=raw["name"],
+                    informal_statement=raw["informal_statement"],
+                    formal_statement=raw["formal_statement"],
+                    header=raw["header"],
+                )
+            )
+            if limit is not None and len(rows) >= limit:
+                break
+    return rows
diff --git a/ergon_builtins/ergon_builtins/benchmarks/minif2f/rubric.py b/ergon_builtins/ergon_builtins/benchmarks/minif2f/rubric.py
index cd1194f6a..4dc3aad6a 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/minif2f/rubric.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/minif2f/rubric.py
@@ -12,7 +12,7 @@
 
 from pydantic import Field, model_validator
 
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.api.criterion import Criterion, CriterionOutcome
 from ergon_core.api.rubric import Rubric, TaskEvaluationResult
 
diff --git a/ergon_builtins/ergon_builtins/benchmarks/minif2f/sample.py b/ergon_builtins/ergon_builtins/benchmarks/minif2f/sample.py
new file mode 100644
index 000000000..2bc5139b7
--- /dev/null
+++ b/ergon_builtins/ergon_builtins/benchmarks/minif2f/sample.py
@@ -0,0 +1,52 @@
+"""MiniF2F sample construction helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import cast
+
+from ergon_core.api import Sample, Task
+from ergon_core.api.rubric import Evaluator
+from ergon_core.api.sandbox import Sandbox
+from ergon_core.api.worker import Worker
+
+from ergon_builtins.benchmarks.minif2f.task import MiniF2FTask
+from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FProblem, MiniF2FTaskPayload
+
+
+def make_minif2f_sample(
+    row: MiniF2FProblem,
+    *,
+    environment_name: str,
+    worker: Worker,
+    evaluators: Sequence[Evaluator],
+    sandbox: Sandbox,
+    split: str = "validation",
+) -> Sample:
+    payload = MiniF2FTaskPayload(
+        name=row.name,
+        informal_statement=row.informal_statement,
+        formal_statement=row.formal_statement,
+        header=row.header,
+    )
+    task = MiniF2FTask(
+        task_slug=row.name,
+        instance_key="default",
+        description=(
+            f"{row.informal_statement}\n\n"
+            f"Your task: prove the following theorem in Lean 4.\n\n"
+            f"{row.header}\n{row.formal_statement}"
+        ),
+        task_payload=payload,
+        worker=worker,
+        sandbox=sandbox,
+        evaluators=tuple(evaluators),
+    )
+    return Sample.from_tasks(
+        name=f"{environment_name}:{row.name}",
+        sample_key=row.name,
+        environment_name=environment_name,
+        sample_ref={"problem_id": row.name, "split": split},
+        source_metadata={"provider": "ergon-builtin:minif2f", "split": split},
+        tasks=[cast(Task, task)],
+    )
diff --git a/ergon_builtins/ergon_builtins/benchmarks/minif2f/sandbox_template/README.md b/ergon_builtins/ergon_builtins/benchmarks/minif2f/sandbox_template/README.md
index c59890eeb..60e0c17e2 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/minif2f/sandbox_template/README.md
+++ b/ergon_builtins/ergon_builtins/benchmarks/minif2f/sandbox_template/README.md
@@ -22,8 +22,8 @@ E2B sandbox template for formal proof verification with Lean 4.
 
 ```bash
 export E2B_API_KEY=<your-runtime-key>
-ergon benchmark setup minif2f           # builds + pushes to E2B
-ergon benchmark setup minif2f --force   # rebuild even if registered
+ergon environment setup minif2f           # builds + pushes to E2B
+ergon environment setup minif2f --force   # rebuild even if registered
 ```
 
 Internally this uses the **E2B Python SDK** (`e2b.Template.build()`), not the
diff --git a/ergon_builtins/ergon_builtins/benchmarks/minif2f/sandbox_template/e2b.toml.template b/ergon_builtins/ergon_builtins/benchmarks/minif2f/sandbox_template/e2b.toml.template
index 1660f1beb..736ef3499 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/minif2f/sandbox_template/e2b.toml.template
+++ b/ergon_builtins/ergon_builtins/benchmarks/minif2f/sandbox_template/e2b.toml.template
@@ -1,7 +1,7 @@
 # Template spec for ergon-minif2f-v1.
 #
 # This file is the source of truth for the sandbox's resource config; it is
-# read by `ergon benchmark setup minif2f`, which calls the E2B Python SDK's
+# read by `ergon environment setup minif2f`, which calls the E2B Python SDK's
 # `Template.build()` directly (no CLI, no E2B_ACCESS_TOKEN required — only
 # E2B_API_KEY).  The resulting template_id is persisted to
 # `~/.ergon/sandbox_templates.json`, not back into this file.
diff --git a/ergon_builtins/ergon_builtins/benchmarks/minif2f/sandbox_template/utils.py b/ergon_builtins/ergon_builtins/benchmarks/minif2f/sandbox_template/utils.py
index 1b1afba1e..0198dc5da 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/minif2f/sandbox_template/utils.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/minif2f/sandbox_template/utils.py
@@ -6,7 +6,7 @@
 
 logger = logging.getLogger(__name__)
 
-# Fallback template name.  `ergon benchmark setup minif2f` persists the
+# Fallback template name.  `ergon environment setup minif2f` persists the
 # resolved template_id to ~/.ergon/sandbox_templates.json; when that exists
 # we prefer the pinned build_id over the mutable name so reruns are
 # reproducible across rebuilds of the same template name.
diff --git a/ergon_builtins/ergon_builtins/benchmarks/minif2f/task.py b/ergon_builtins/ergon_builtins/benchmarks/minif2f/task.py
new file mode 100644
index 000000000..f03531c4d
--- /dev/null
+++ b/ergon_builtins/ergon_builtins/benchmarks/minif2f/task.py
@@ -0,0 +1,20 @@
+"""MiniF2F concrete task type and dataset constants."""
+
+from ergon_core.api import Task
+
+from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FProblem, MiniF2FTaskPayload
+
+HF_REPO_ID = "roozbeh-yz/miniF2F_v2"
+HF_FILENAME = "miniF2F_v2c.jsonl"
+
+
+class MiniF2FTask(Task[MiniF2FTaskPayload]):
+    """Concrete Task subclass for MiniF2F instances.
+
+    Named so ``Task.from_definition`` can resolve the ``_type``
+    discriminator as a plain module attribute. The parameterized
+    generic ``Task[MiniF2FTaskPayload]`` cannot be looked up that way.
+    """
+
+
+__all__ = ["HF_FILENAME", "HF_REPO_ID", "MiniF2FProblem", "MiniF2FTask", "MiniF2FTaskPayload"]
diff --git a/ergon_builtins/ergon_builtins/benchmarks/minif2f/task_schemas.py b/ergon_builtins/ergon_builtins/benchmarks/minif2f/task_schemas.py
index ca43777e6..91e87811c 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/minif2f/task_schemas.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/minif2f/task_schemas.py
@@ -13,7 +13,7 @@ class MiniF2FProblem(BaseModel):
 
 
 class MiniF2FTaskPayload(BaseModel):
-    """Structured payload carried inside ``BenchmarkTask.task_payload``."""
+    """Structured payload carried inside ``Task.task_payload``."""
 
     name: str
     informal_statement: str
diff --git a/ergon_builtins/ergon_builtins/benchmarks/minif2f/toolkit.py b/ergon_builtins/ergon_builtins/benchmarks/minif2f/toolkit.py
index 8f36e1488..3139de1f9 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/minif2f/toolkit.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/minif2f/toolkit.py
@@ -28,9 +28,8 @@ class MiniF2FToolkit(Toolkit):
 
     def tools(self, sandbox: Sandbox, task: Task[Any]) -> list[Tool]:
         """Build live pydantic_ai Tool instances bound to the v2 sandbox."""
-        # reason: circular import — benchmarks/minif2f/toolkit.py → benchmarks/minif2f/tools/tool_builder.py →
-        # benchmarks/minif2f/constants.py → benchmarks/minif2f/__init__.py →
-        # benchmark.py → worker_factory.py → benchmarks/minif2f/toolkit.py
+        # reason: circular import — importing the tool builder at module load
+        # time pulls benchmark package exports back through this toolkit module.
         from ergon_builtins.benchmarks.minif2f.tools.tool_builder import build_tools
 
         return build_tools(self, sandbox=sandbox, task=task)
diff --git a/ergon_builtins/ergon_builtins/benchmarks/minif2f/worker_factory.py b/ergon_builtins/ergon_builtins/benchmarks/minif2f/worker_factory.py
deleted file mode 100644
index 44266b9b5..000000000
--- a/ergon_builtins/ergon_builtins/benchmarks/minif2f/worker_factory.py
+++ /dev/null
@@ -1,38 +0,0 @@
-"""MiniF2F worker factories — one per agentic strategy.
-
-Each factory bundles the MiniF2F sandbox, toolkit, and system
-prompt with a chosen worker class (ReActWorker today; CoTWorker /
-ReflexionWorker future).  Strategies vary independently; the
-domain bundle is constant.
-
-v2 callers use ``make_minif2f_worker()`` directly from the benchmark
-object graph.
-"""
-
-from ergon_builtins.benchmarks.minif2f.rubric import MiniF2FRubric
-from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
-from ergon_builtins.benchmarks.minif2f.prompts import MINIF2F_SYSTEM_PROMPT
-from ergon_builtins.agents.react.worker import ReActWorker
-
-
-DEFAULT_WORKER_MODEL = "openai:gpt-4o-mini"
-
-
-def make_minif2f_worker(
-    *,
-    model: str = DEFAULT_WORKER_MODEL,
-    max_iterations: int = 30,
-) -> ReActWorker:
-    """Return a serializable ReActWorker for MiniF2F (v2 authoring shape)."""
-    return ReActWorker(
-        name="solver",
-        model=model,
-        system_prompt=MINIF2F_SYSTEM_PROMPT,
-        max_iterations=max_iterations,
-        toolkit=MiniF2FToolkit(),
-    )
-
-
-def make_minif2f_rubric() -> MiniF2FRubric:
-    """Return a serializable MiniF2FRubric for use as an inline evaluator."""
-    return MiniF2FRubric(name="minif2f-rubric")
diff --git a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/__init__.py b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/__init__.py
index 9661c5265..544fd861b 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/__init__.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/__init__.py
@@ -1,14 +1,5 @@
-"""ResearchRubrics benchmark for studying adaptive stakeholder querying."""
+"""ResearchRubrics domain package."""
 
-# ResearchRubricsBenchmark is intentionally NOT re-exported here.
-# benchmark.py imports ResearchE2BSandbox from
-# ergon_builtins.benchmarks.researchrubrics.sandbox, and sandbox.py
-# imports ResearchRubricsSandboxManager from this package.  Eagerly re-
-# exporting ResearchRubricsBenchmark would complete a cycle:
-#   benchmarks/researchrubrics/sandbox.py → benchmarks.researchrubrics (here)
-#   → benchmark.py → benchmarks/researchrubrics/sandbox.py
-# All call sites that need ResearchRubricsBenchmark import it directly:
-#   from ergon_builtins.benchmarks.researchrubrics.benchmark import ResearchRubricsBenchmark
 from ergon_builtins.benchmarks.researchrubrics.rubric import ResearchRubricsRubric
 from ergon_builtins.benchmarks.researchrubrics.task_schemas import (
     ResearchRubricsTaskPayload,
diff --git a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/benchmark.py b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/benchmark.py
deleted file mode 100644
index 47eaa36b8..000000000
--- a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/benchmark.py
+++ /dev/null
@@ -1,140 +0,0 @@
-"""ResearchRubrics benchmark for studying adaptive stakeholder querying.
-
-Uses deep research tasks with weighted evaluation criteria to study
-whether agents know when and what to ask stakeholders.
-"""
-
-from collections.abc import Callable, Iterator, Mapping, Sequence
-from typing import Any, ClassVar
-
-from datasets import load_dataset
-from ergon_core.api import Benchmark, Task
-from ergon_core.api.rubric import Evaluator
-from ergon_core.api.sandbox import Sandbox
-from ergon_core.api.worker import Worker
-from ergon_core.core.shared.settings import settings
-
-from ergon_builtins.benchmarks.researchrubrics.sandbox import ResearchE2BSandbox
-from ergon_builtins.benchmarks.researchrubrics.task_schemas import (
-    ResearchRubricsTaskPayload,
-    RubricCriterion,
-)
-from ergon_builtins.benchmarks.researchrubrics.worker_factory import (
-    make_research_rubric,
-    make_research_worker,
-)
-
-
-def _default_research_sandbox() -> Sandbox:
-    return ResearchE2BSandbox()
-
-
-class ResearchRubricsTask(Task[ResearchRubricsTaskPayload]):
-    """Concrete Task subclass for ResearchRubrics instances.
-
-    Named so ``Task.from_definition`` can resolve the ``_type``
-    discriminator as a plain module attribute.  The parameterized
-    generic ``Task[ResearchRubricsTaskPayload]`` cannot be looked up that
-    way — its ``__qualname__`` includes ``[...]``.
-    """
-
-
-class ResearchRubricsBenchmark(Benchmark):
-    """Benchmark backed by the ResearchRubrics HuggingFace dataset.
-
-    ``build_instances`` loads official ScaleAI ResearchRubrics samples and
-    returns one task per sample. Each task's ``task_payload`` carries the full
-    ``ResearchRubricsTaskPayload`` so the rubric and worker can reconstruct
-    criteria and prompts.
-    """
-
-    type_slug: ClassVar[str] = "researchrubrics"
-    dataset_name: ClassVar[str] = "ScaleAI/researchrubrics"
-    task_payload_model: ClassVar[type[ResearchRubricsTaskPayload]] = ResearchRubricsTaskPayload
-    required_packages: ClassVar[list[str]] = ["datasets", "huggingface_hub"]
-    install_hint: ClassVar[str] = "pip install 'ergon-builtins[data]'"
-
-    def __init__(
-        self,
-        *,
-        limit: int | None = None,
-        name: str | None = None,
-        description: str | None = None,
-        metadata: Mapping[str, Any] | None = None,  # slopcop: ignore[no-typing-any]
-        worker_factory: Callable[[], Worker] = make_research_worker,
-        sandbox_factory: Callable[[], Sandbox] = _default_research_sandbox,
-        evaluator_factory: Callable[[], Evaluator] = make_research_rubric,
-    ) -> None:
-        super().__init__(
-            name=name or "researchrubrics",
-            description=description or "ResearchRubrics deep-research benchmark",
-            metadata=metadata,
-        )
-        self.limit = limit
-        self._worker_factory = worker_factory
-        self._sandbox_factory = sandbox_factory
-        self._evaluator_factory = evaluator_factory
-
-    # ------------------------------------------------------------------
-
-    def build_instances(self) -> Mapping[str, Sequence[Task[ResearchRubricsTaskPayload]]]:
-        return {"default": [sample.tasks[0] for sample in self._environment().all_samples()]}
-
-    def evaluator_requirements(self) -> Sequence[str]:
-        return ()
-
-    # ------------------------------------------------------------------
-
-    def _load_rows(self) -> list[ResearchRubricsTaskPayload]:
-        """Load and validate dataset rows from HuggingFace.
-
-        Requires ``datasets`` and ``huggingface_hub`` to be installed.
-        """
-        token = settings.hf_api_key
-        ds = load_dataset(self.dataset_name, token=token)
-        train_ds = ds["train"]
-
-        if self.limit:
-            train_ds = train_ds.select(range(min(self.limit, len(train_ds))))
-
-        return [_payload_from_row(train_ds[idx]) for idx in range(len(train_ds))]
-
-    # Compatibility loader surface for ResearchRubricsEnvironment. PR11
-    # deletes benchmark-centered authoring and these wrappers.
-    def iter_rows(self) -> Iterator[ResearchRubricsTaskPayload]:
-        yield from self._load_rows()
-
-    def load_rows(self) -> Sequence[ResearchRubricsTaskPayload]:
-        return self._load_rows()
-
-    def _environment(self) -> Any:
-        from ergon_builtins.environments.researchrubrics import ResearchRubricsEnvironment
-
-        return ResearchRubricsEnvironment(
-            name=self.name,
-            dataset_name=self.dataset_name,
-            limit=self.limit,
-            loader=self,
-            worker=lambda _row: self._worker_factory(),
-            sandbox=lambda _row: self._sandbox_factory(),
-            evaluators=lambda _row: (self._evaluator_factory(),),
-        )
-
-
-def _payload_from_row(
-    row: Mapping[str, Any],  # slopcop: ignore[no-typing-any]
-) -> ResearchRubricsTaskPayload:
-    """Convert one raw HuggingFace row into the benchmark payload schema."""
-    return ResearchRubricsTaskPayload(
-        sample_id=row["sample_id"],
-        domain=str(row.get("domain", "")),
-        prompt=row["prompt"],
-        rubrics=[
-            RubricCriterion(
-                criterion=r["criterion"],
-                axis=r["axis"],
-                weight=r["weight"],
-            )
-            for r in row["rubrics"]
-        ],
-    )
diff --git a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/dataset.py b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/dataset.py
new file mode 100644
index 000000000..c19aea039
--- /dev/null
+++ b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/dataset.py
@@ -0,0 +1,39 @@
+"""ResearchRubrics source-loading helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Mapping, Sequence
+from typing import Any, cast
+
+from datasets import load_dataset
+from ergon_core.core.shared.settings import settings
+
+from ergon_builtins.benchmarks.researchrubrics.task import (
+    RESEARCH_RUBRICS_DATASET,
+    _payload_from_row,
+)
+from ergon_builtins.benchmarks.researchrubrics.task_schemas import ResearchRubricsTaskPayload
+
+
+def iter_researchrubrics_rows(
+    *,
+    dataset_name: str = RESEARCH_RUBRICS_DATASET,
+    split: str = "train",
+    limit: int | None = None,
+) -> Iterator[ResearchRubricsTaskPayload]:
+    yield from load_researchrubrics_rows(dataset_name=dataset_name, split=split, limit=limit)
+
+
+def load_researchrubrics_rows(
+    *,
+    dataset_name: str = RESEARCH_RUBRICS_DATASET,
+    split: str = "train",
+    limit: int | None = None,
+) -> Sequence[ResearchRubricsTaskPayload]:
+    ds = load_dataset(dataset_name, token=settings.hf_api_key)
+    split_ds = ds[split]
+    if limit is not None:
+        split_ds = split_ds.select(range(min(limit, len(split_ds))))
+    return [
+        _payload_from_row(cast(Mapping[str, Any], split_ds[idx])) for idx in range(len(split_ds))
+    ]
diff --git a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/rubric.py b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/rubric.py
index 3aa31af79..64c101124 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/rubric.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/rubric.py
@@ -14,7 +14,7 @@
 
 from pydantic import model_validator
 
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.api.criterion import Criterion, CriterionOutcome
 from ergon_core.api.rubric import Rubric, TaskEvaluationResult
 
diff --git a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/sample.py b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/sample.py
new file mode 100644
index 000000000..cd14d55dd
--- /dev/null
+++ b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/sample.py
@@ -0,0 +1,71 @@
+"""ResearchRubrics sample construction helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any, cast
+
+from ergon_core.api import Sample, Task
+from ergon_core.api.rubric import Evaluator
+from ergon_core.api.sandbox import Sandbox
+from ergon_core.api.worker import Worker
+
+from ergon_builtins.benchmarks.researchrubrics.rubric import ResearchRubricsRubric
+from ergon_builtins.benchmarks.researchrubrics.task import (
+    RESEARCH_RUBRICS_DATASET,
+    ResearchRubricsTask,
+    _payload_from_row,
+)
+from ergon_builtins.benchmarks.researchrubrics.task_schemas import ResearchRubricsTaskPayload
+
+
+def make_researchrubrics_sample(
+    row: ResearchRubricsTaskPayload | Mapping[str, Any],
+    *,
+    environment_name: str,
+    worker: Worker,
+    evaluators: Sequence[Evaluator],
+    sandbox: Sandbox,
+    split: str = "train",
+    dataset_name: str = RESEARCH_RUBRICS_DATASET,
+) -> Sample:
+    payload = row if isinstance(row, ResearchRubricsTaskPayload) else _payload_from_row(row)
+    bound_evaluators = tuple(_bind_payload_rubric(evaluator, payload) for evaluator in evaluators)
+    task = ResearchRubricsTask(
+        task_slug=payload.sample_id,
+        instance_key="default",
+        description=payload.prompt,
+        task_payload=payload,
+        worker=worker,
+        sandbox=sandbox,
+        evaluators=bound_evaluators,
+    )
+    return Sample.from_tasks(
+        name=f"{environment_name}:{payload.sample_id}",
+        sample_key=payload.sample_id,
+        environment_name=environment_name,
+        sample_ref={
+            "sample_id": payload.sample_id,
+            "domain": payload.domain,
+            "split": split,
+        },
+        source_metadata={
+            "provider": "ergon-builtin:researchrubrics",
+            "dataset_name": dataset_name,
+            "split": split,
+        },
+        tasks=[cast(Task, task)],
+    )
+
+
+def _bind_payload_rubric(
+    evaluator: Evaluator,
+    payload: ResearchRubricsTaskPayload,
+) -> Evaluator:
+    if isinstance(evaluator, ResearchRubricsRubric) and not evaluator.rubric_criteria:
+        return ResearchRubricsRubric(
+            name=evaluator.name,
+            metadata=evaluator.metadata,
+            rubric_criteria=tuple(payload.rubrics),
+        )
+    return evaluator
diff --git a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/task.py b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/task.py
new file mode 100644
index 000000000..bea5ebf18
--- /dev/null
+++ b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/task.py
@@ -0,0 +1,53 @@
+"""ResearchRubrics concrete task type and row helpers.
+
+Uses deep research tasks with weighted evaluation criteria to study
+whether agents know when and what to ask stakeholders.
+"""
+
+from collections.abc import Mapping
+from typing import Any
+
+from ergon_core.api import Task
+
+from ergon_builtins.benchmarks.researchrubrics.task_schemas import (
+    ResearchRubricsTaskPayload,
+    RubricCriterion,
+)
+
+RESEARCH_RUBRICS_DATASET = "ScaleAI/researchrubrics"
+
+
+class ResearchRubricsTask(Task[ResearchRubricsTaskPayload]):
+    """Concrete Task subclass for ResearchRubrics instances.
+
+    Named so ``Task.from_definition`` can resolve the ``_type``
+    discriminator as a plain module attribute.  The parameterized
+    generic ``Task[ResearchRubricsTaskPayload]`` cannot be looked up that
+    way — its ``__qualname__`` includes ``[...]``.
+    """
+
+
+def _payload_from_row(
+    row: Mapping[str, Any],  # slopcop: ignore[no-typing-any]
+) -> ResearchRubricsTaskPayload:
+    """Convert one raw HuggingFace row into the benchmark payload schema."""
+    return ResearchRubricsTaskPayload(
+        sample_id=row["sample_id"],
+        domain=str(row.get("domain", "")),
+        prompt=row["prompt"],
+        rubrics=[
+            RubricCriterion(
+                criterion=r["criterion"],
+                axis=r["axis"],
+                weight=r["weight"],
+            )
+            for r in row["rubrics"]
+        ],
+    )
+
+
+__all__ = [
+    "RESEARCH_RUBRICS_DATASET",
+    "ResearchRubricsTask",
+    "_payload_from_row",
+]
diff --git a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/task_schemas.py b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/task_schemas.py
index 4fd98ca42..553b1d2c3 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/task_schemas.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/task_schemas.py
@@ -23,7 +23,7 @@ class RubricCriterion(BaseModel):
 
 
 class ResearchRubricsTaskPayload(BaseModel):
-    """Structured payload carried inside ``BenchmarkTask.task_payload``."""
+    """Structured payload carried inside ``Task.task_payload``."""
 
     sample_id: str = Field(description="Unique identifier from HuggingFace dataset")
     domain: str = Field(
diff --git a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/vanilla.py b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/vanilla.py
deleted file mode 100644
index a7d3f1d69..000000000
--- a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/vanilla.py
+++ /dev/null
@@ -1,35 +0,0 @@
-"""ResearchRubrics vanilla benchmark alias.
-
-Kept as a registry-compatible alias for the official ScaleAI dataset.
-"""
-
-from collections.abc import Mapping
-from typing import Any, ClassVar
-
-from ergon_builtins.benchmarks.researchrubrics.benchmark import (
-    ResearchRubricsBenchmark,
-)
-
-
-class ResearchRubricsVanillaBenchmark(ResearchRubricsBenchmark):
-    """Compatibility alias for ScaleAI's official ResearchRubrics dataset.
-
-    Used for the paper's headline number.
-    """
-
-    type_slug: ClassVar[str] = "researchrubrics-vanilla"
-
-    def __init__(
-        self,
-        *,
-        limit: int | None = None,
-        metadata: Mapping[str, Any] | None = None,  # slopcop: ignore[no-typing-any]
-    ) -> None:
-        super().__init__(
-            limit=limit,
-            name="researchrubrics-vanilla",
-            description=(
-                "ScaleAI's ResearchRubrics deep-research benchmark (paper headline config)."
-            ),
-            metadata=metadata,
-        )
diff --git a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/worker_factory.py b/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/worker_factory.py
deleted file mode 100644
index ceda54e02..000000000
--- a/ergon_builtins/ergon_builtins/benchmarks/researchrubrics/worker_factory.py
+++ /dev/null
@@ -1,50 +0,0 @@
-"""ResearchRubrics worker factories — one per agentic strategy.
-
-Each factory bundles the ResearchRubrics sandbox, toolkit, and system
-prompt with a chosen worker class (ReActWorker today; CoTWorker /
-ReflexionWorker future).  Strategies vary independently; the domain
-bundle is constant.
-
-v2 callers use ``make_research_worker()`` directly from the benchmark
-object graph.
-"""
-
-from ergon_builtins.benchmarks.researchrubrics.prompts import RESEARCH_SYSTEM_PROMPT
-from ergon_builtins.benchmarks.researchrubrics.rubric import ResearchRubricsRubric
-from ergon_builtins.benchmarks.researchrubrics.toolkit import ResearchRubricsToolkit
-
-from ergon_builtins.agents.react.worker import ReActWorker
-
-__all__ = [
-    "make_research_rubric",
-    "make_research_worker",
-]
-
-
-DEFAULT_WORKER_MODEL = "openai:gpt-4o-mini"
-
-
-def make_research_worker(
-    *,
-    model: str = DEFAULT_WORKER_MODEL,
-    max_iterations: int = 16,
-) -> ReActWorker:
-    """Return a serializable ReActWorker for ResearchRubrics (v2 authoring shape)."""
-    return ReActWorker(
-        name="research-runner",
-        model=model,
-        system_prompt=RESEARCH_SYSTEM_PROMPT,
-        max_iterations=max_iterations,
-        toolkit=ResearchRubricsToolkit(),
-    )
-
-
-def make_research_rubric() -> ResearchRubricsRubric:
-    """Return a serializable ResearchRubricsRubric for use as an inline evaluator.
-
-    The default rubric materialises its judge criteria lazily from the
-    task payload (each ``task_payload.rubrics`` entry becomes one
-    ``ResearchRubricsJudgeCriterion``), so the rubric body itself stays
-    config-only and round-trips through ``task_json``.
-    """
-    return ResearchRubricsRubric(name="researchrubrics-rubric")
diff --git a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/__init__.py b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/__init__.py
index bb0ca85bf..e984d9195 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/__init__.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/__init__.py
@@ -1,14 +1,5 @@
-"""SWE-Bench Verified benchmark package."""
+"""SWE-Bench Verified domain package."""
 
-# SweBenchVerifiedBenchmark is intentionally NOT re-exported here.
-# benchmark.py imports SWEBenchSandbox from
-# ergon_builtins.benchmarks.swebench_verified.sandbox, and sandbox.py
-# imports SWEBenchSandboxManager from this package.  Eagerly re-exporting
-# SweBenchVerifiedBenchmark would complete a cycle:
-#   benchmarks/swebench_verified/sandbox.py → benchmarks.swebench_verified (here)
-#   → benchmark.py → benchmarks/swebench_verified/sandbox.py
-# All call sites that need SweBenchVerifiedBenchmark import it directly:
-#   from ergon_builtins.benchmarks.swebench_verified.benchmark import SweBenchVerifiedBenchmark
 from ergon_builtins.benchmarks.swebench_verified.rubric import SWEBenchRubric
 from ergon_builtins.benchmarks.swebench_verified.task_schemas import (
     SWEBenchInstance,
diff --git a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/benchmark.py b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/benchmark.py
deleted file mode 100644
index 61992360a..000000000
--- a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/benchmark.py
+++ /dev/null
@@ -1,109 +0,0 @@
-"""SWE-Bench Verified benchmark loader.
-
-Pulls the ``princeton-nlp/SWE-bench_Verified`` HuggingFace dataset and yields
-one ``Task`` per instance. The worker only sees the problem statement; the
-evaluator receives ``test_patch`` via the task payload.
-"""
-
-import logging
-from collections.abc import Callable, Iterator, Mapping, Sequence
-from typing import Any, ClassVar
-
-from datasets import load_dataset
-from ergon_core.api import Benchmark, Task
-from ergon_core.api.rubric import Evaluator
-from ergon_core.api.sandbox import Sandbox
-from ergon_core.api.worker import Worker
-
-from ergon_builtins.benchmarks.swebench_verified.sandbox import SWEBenchSandbox
-from ergon_builtins.benchmarks.swebench_verified.task_schemas import (
-    SWEBenchInstance,
-    SWEBenchTaskPayload,
-)
-from ergon_builtins.benchmarks.swebench_verified.worker_factory import (
-    make_swebench_rubric,
-    make_swebench_worker,
-)
-
-logger = logging.getLogger(__name__)
-
-HF_DATASET_ID = "princeton-nlp/SWE-bench_Verified"
-HF_SPLIT = "test"
-
-
-def _default_swebench_sandbox() -> Sandbox:
-    return SWEBenchSandbox()
-
-
-class SweBenchTask(Task[SWEBenchTaskPayload]):
-    """Concrete Task subclass for SWE-Bench Verified instances.
-
-    Named so ``Task.from_definition`` can resolve the ``_type``
-    discriminator as a plain module attribute.  The parameterized
-    generic ``Task[SWEBenchTaskPayload]`` cannot be looked up that
-    way — its ``__qualname__`` includes ``[...]``.
-    """
-
-
-class SweBenchVerifiedBenchmark(Benchmark):
-    """Benchmark backed by SWE-Bench Verified (500 curated instances)."""
-
-    type_slug: ClassVar[str] = "swebench-verified"
-    task_payload_model: ClassVar[type[SWEBenchTaskPayload]] = SWEBenchTaskPayload
-
-    def __init__(
-        self,
-        *,
-        limit: int | None = None,
-        name: str | None = None,
-        description: str | None = None,
-        metadata: Mapping[str, Any] | None = None,  # slopcop: ignore[no-typing-any]
-        worker_factory: Callable[[], Worker] = make_swebench_worker,
-        sandbox_factory: Callable[[], Sandbox] = _default_swebench_sandbox,
-        evaluator_factory: Callable[[], Evaluator] = make_swebench_rubric,
-    ) -> None:
-        super().__init__(
-            name=name or "swebench-verified",
-            description=description or "SWE-Bench Verified GitHub issue-fix benchmark",
-            metadata=metadata,
-        )
-        self.limit = limit
-        self._worker_factory = worker_factory
-        self._sandbox_factory = sandbox_factory
-        self._evaluator_factory = evaluator_factory
-
-    def build_instances(self) -> Mapping[str, Sequence[Task[SWEBenchTaskPayload]]]:
-        samples = self._environment().all_samples()
-        logger.info("Loaded %d SWE-Bench Verified instances", len(samples))
-        return {"default": [sample.tasks[0] for sample in samples]}
-
-    def evaluator_requirements(self) -> Sequence[str]:
-        return ()
-
-    # Compatibility loader surface for SweBenchVerifiedEnvironment. PR11
-    # deletes benchmark-centered authoring and these wrappers.
-    def iter_rows(self) -> Iterator[SWEBenchInstance]:
-        yield from _load_rows(limit=self.limit)
-
-    def load_rows(self) -> Sequence[SWEBenchInstance]:
-        return _load_rows(limit=self.limit)
-
-    def _environment(self) -> Any:
-        from ergon_builtins.environments.swebench_verified import SweBenchVerifiedEnvironment
-
-        return SweBenchVerifiedEnvironment(
-            name=self.name,
-            limit=self.limit,
-            loader=self,
-            worker=lambda _row: self._worker_factory(),
-            sandbox=lambda _row: self._sandbox_factory(),
-            evaluators=lambda _row: (self._evaluator_factory(),),
-        )
-
-
-def _load_rows(*, limit: int | None = None) -> list[SWEBenchInstance]:
-    """Load and validate SWE-Bench instances from HuggingFace."""
-    ds = load_dataset(HF_DATASET_ID, split=HF_SPLIT)
-    if limit is not None:
-        ds = ds.select(range(min(limit, len(ds))))
-    return [SWEBenchInstance.from_raw(row) for row in ds]
diff --git a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/dataset.py b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/dataset.py
new file mode 100644
index 000000000..8331b3c6d
--- /dev/null
+++ b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/dataset.py
@@ -0,0 +1,36 @@
+"""SWE-Bench Verified source-loading helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+
+from datasets import load_dataset
+
+from ergon_builtins.benchmarks.swebench_verified.task import HF_DATASET_ID, HF_SPLIT
+from ergon_builtins.benchmarks.swebench_verified.task_schemas import SWEBenchInstance
+
+
+def iter_swebench_rows(
+    *,
+    dataset_id: str = HF_DATASET_ID,
+    split: str = HF_SPLIT,
+    limit: int | None = None,
+    streaming: bool = False,
+) -> Iterator[SWEBenchInstance]:
+    ds = load_dataset(dataset_id, split=split, streaming=streaming)
+    for index, row in enumerate(ds):
+        if limit is not None and index >= limit:
+            break
+        yield SWEBenchInstance.from_raw(row)
+
+
+def load_swebench_rows(
+    *,
+    dataset_id: str = HF_DATASET_ID,
+    split: str = HF_SPLIT,
+    limit: int | None = None,
+) -> Sequence[SWEBenchInstance]:
+    ds = load_dataset(dataset_id, split=split)
+    if limit is not None:
+        ds = ds.select(range(min(limit, len(ds))))
+    return [SWEBenchInstance.from_raw(row) for row in ds]
diff --git a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/sample.py b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/sample.py
new file mode 100644
index 000000000..2c41807a0
--- /dev/null
+++ b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/sample.py
@@ -0,0 +1,56 @@
+"""SWE-Bench Verified sample construction helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import cast
+
+from ergon_core.api import Sample, Task
+from ergon_core.api.rubric import Evaluator
+from ergon_core.api.sandbox import Sandbox
+from ergon_core.api.worker import Worker
+
+from ergon_builtins.benchmarks.swebench_verified.task import HF_DATASET_ID, HF_SPLIT, SweBenchTask
+from ergon_builtins.benchmarks.swebench_verified.task_schemas import (
+    SWEBenchInstance,
+    SWEBenchTaskPayload,
+)
+
+
+def make_swebench_sample(
+    row: SWEBenchInstance,
+    *,
+    environment_name: str,
+    worker: Worker,
+    evaluators: Sequence[Evaluator],
+    sandbox: Sandbox,
+    split: str = HF_SPLIT,
+    dataset_id: str = HF_DATASET_ID,
+) -> Sample:
+    payload = SWEBenchTaskPayload.from_instance(row)
+    task = SweBenchTask(
+        task_slug=row.instance_id,
+        instance_key="default",
+        description=payload.build_worker_description(),
+        task_payload=payload,
+        worker=worker,
+        sandbox=sandbox,
+        evaluators=tuple(evaluators),
+    )
+    return Sample.from_tasks(
+        name=f"{environment_name}:{row.instance_id}",
+        sample_key=row.instance_id,
+        environment_name=environment_name,
+        sample_ref={
+            "instance_id": row.instance_id,
+            "repo": row.repo,
+            "base_commit": row.base_commit,
+            "split": split,
+        },
+        source_metadata={
+            "provider": "ergon-builtin:swebench-verified",
+            "dataset_id": dataset_id,
+            "split": split,
+        },
+        tasks=[cast(Task, task)],
+    )
diff --git a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/sandbox_template/e2b.toml.template b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/sandbox_template/e2b.toml.template
index d3e845196..8657948a2 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/sandbox_template/e2b.toml.template
+++ b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/sandbox_template/e2b.toml.template
@@ -1,7 +1,7 @@
 # Template spec for ergon-swebench-v1.
 #
 # This file is the source of truth for the sandbox's resource config; it is
-# read by `ergon benchmark setup swebench_verified`, which calls the E2B Python
+# read by `ergon environment setup swebench_verified`, which calls the E2B Python
 # SDK's `Template.build()` directly (no CLI, no E2B_ACCESS_TOKEN required —
 # only E2B_API_KEY).  The resulting template_id is persisted to
 # `~/.ergon/sandbox_templates.json`, not back into this file.
diff --git a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/sandbox_template/utils.py b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/sandbox_template/utils.py
index 02a726ac1..e24025261 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/sandbox_template/utils.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/sandbox_template/utils.py
@@ -6,7 +6,7 @@
 
 logger = logging.getLogger(__name__)
 
-# Fallback template name.  `ergon benchmark setup swebench-verified` persists
+# Fallback template name.  `ergon environment setup swebench-verified` persists
 # the resolved template_id to ~/.ergon/sandbox_templates.json; when that
 # exists we prefer the pinned build_id over the mutable name so reruns are
 # reproducible across rebuilds of the same template name.
diff --git a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/task.py b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/task.py
new file mode 100644
index 000000000..10512ced4
--- /dev/null
+++ b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/task.py
@@ -0,0 +1,21 @@
+"""SWE-Bench Verified concrete task type and dataset constants."""
+
+from ergon_core.api import Task
+
+from ergon_builtins.benchmarks.swebench_verified.task_schemas import SWEBenchTaskPayload
+
+HF_DATASET_ID = "princeton-nlp/SWE-bench_Verified"
+HF_SPLIT = "test"
+
+
+class SweBenchTask(Task[SWEBenchTaskPayload]):
+    """Concrete Task subclass for SWE-Bench Verified instances.
+
+    Named so ``Task.from_definition`` can resolve the ``_type``
+    discriminator as a plain module attribute.  The parameterized
+    generic ``Task[SWEBenchTaskPayload]`` cannot be looked up that
+    way — its ``__qualname__`` includes ``[...]``.
+    """
+
+
+__all__ = ["HF_DATASET_ID", "HF_SPLIT", "SweBenchTask"]
diff --git a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/task_schemas.py b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/task_schemas.py
index c0962d734..baffb3b01 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/task_schemas.py
+++ b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/task_schemas.py
@@ -53,7 +53,7 @@ def from_raw(
 
 
 class SWEBenchTaskPayload(BaseModel):
-    """Payload attached to each ``BenchmarkTask``.
+    """Payload attached to each ``Task``.
 
     Includes ``test_patch`` because the evaluator needs it, but
     ``build_worker_description`` omits it so the worker cannot see the
diff --git a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/worker_factory.py b/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/worker_factory.py
deleted file mode 100644
index 01dac514d..000000000
--- a/ergon_builtins/ergon_builtins/benchmarks/swebench_verified/worker_factory.py
+++ /dev/null
@@ -1,37 +0,0 @@
-"""SWE-Bench worker factories — one per agentic strategy.
-
-Each factory bundles the SWE-Bench sandbox, toolkit, and system prompt
-with a chosen worker class (ReActWorker today; CoTWorker / ReflexionWorker
-future).  Strategies vary independently; the domain bundle is constant.
-
-v2 callers use ``make_swebench_worker()`` directly from the benchmark
-object graph.
-"""
-
-from ergon_builtins.benchmarks.swebench_verified.rubric import SWEBenchRubric
-from ergon_builtins.benchmarks.swebench_verified.toolkit import SWEBenchToolkit
-from ergon_builtins.benchmarks.swebench_verified.prompts import SWEBENCH_SYSTEM_PROMPT
-from ergon_builtins.agents.react.worker import ReActWorker
-
-
-DEFAULT_WORKER_MODEL = "openai:gpt-4o-mini"
-
-
-def make_swebench_worker(
-    *,
-    model: str = DEFAULT_WORKER_MODEL,
-    max_iterations: int = 50,
-) -> ReActWorker:
-    """Return a serializable ReActWorker for SWE-Bench (v2 authoring shape)."""
-    return ReActWorker(
-        name="swebench-solver",
-        model=model,
-        system_prompt=SWEBENCH_SYSTEM_PROMPT,
-        max_iterations=max_iterations,
-        toolkit=SWEBenchToolkit(),
-    )
-
-
-def make_swebench_rubric() -> SWEBenchRubric:
-    """Return a serializable SWEBenchRubric for use as an inline evaluator."""
-    return SWEBenchRubric(name="swebench-rubric")
diff --git a/ergon_builtins/ergon_builtins/environments/__init__.py b/ergon_builtins/ergon_builtins/environments/__init__.py
index 3a58aaec9..57dc39b2e 100644
--- a/ergon_builtins/ergon_builtins/environments/__init__.py
+++ b/ergon_builtins/ergon_builtins/environments/__init__.py
@@ -1,13 +1,7 @@
-"""Builtin sample-producing environments."""
+"""Builtin environment metadata.
 
-from ergon_builtins.environments.gdpeval import GDPEvalEnvironment
-from ergon_builtins.environments.minif2f import MiniF2FEnvironment
-from ergon_builtins.environments.researchrubrics import ResearchRubricsEnvironment
-from ergon_builtins.environments.swebench_verified import SweBenchVerifiedEnvironment
+Builtin sample authoring uses ``ergon_core.api.Environment.from_dataset`` with
+benchmark source/sample helpers rather than bespoke environment subclasses.
+"""
 
-__all__ = [
-    "GDPEvalEnvironment",
-    "MiniF2FEnvironment",
-    "ResearchRubricsEnvironment",
-    "SweBenchVerifiedEnvironment",
-]
+__all__: list[str] = []
diff --git a/ergon_builtins/ergon_builtins/environments/_resolve.py b/ergon_builtins/ergon_builtins/environments/_resolve.py
deleted file mode 100644
index 0458f73c6..000000000
--- a/ergon_builtins/ergon_builtins/environments/_resolve.py
+++ /dev/null
@@ -1,33 +0,0 @@
-"""Typed component resolution helpers for builtin environments."""
-
-from __future__ import annotations
-
-from collections.abc import Callable, Sequence
-from typing import TypeVar, cast
-
-from ergon_core.api.rubric import Evaluator
-from ergon_core.api.sandbox import Sandbox
-from ergon_core.api.worker import Worker
-
-RowT = TypeVar("RowT")
-
-
-def resolve_worker(value: Worker | Callable[[RowT], Worker], row: RowT) -> Worker:
-    if isinstance(value, Worker):
-        return value
-    return cast(Callable[[RowT], Worker], value)(row)
-
-
-def resolve_sandbox(value: Sandbox | Callable[[RowT], Sandbox], row: RowT) -> Sandbox:
-    if isinstance(value, Sandbox):
-        return value
-    return cast(Callable[[RowT], Sandbox], value)(row)
-
-
-def resolve_evaluators(
-    value: Sequence[Evaluator] | Callable[[RowT], Sequence[Evaluator]],
-    row: RowT,
-) -> tuple[Evaluator, ...]:
-    if callable(value):
-        return tuple(cast(Callable[[RowT], Sequence[Evaluator]], value)(row))
-    return tuple(value)
diff --git a/ergon_builtins/ergon_builtins/benchmarks/catalog.py b/ergon_builtins/ergon_builtins/environments/catalog.py
similarity index 51%
rename from ergon_builtins/ergon_builtins/benchmarks/catalog.py
rename to ergon_builtins/ergon_builtins/environments/catalog.py
index 02421d7bc..d3344b0e8 100644
--- a/ergon_builtins/ergon_builtins/benchmarks/catalog.py
+++ b/ergon_builtins/ergon_builtins/environments/catalog.py
@@ -1,4 +1,4 @@
-"""Builtins-owned benchmark metadata for CLI setup/onboarding."""
+"""Builtins-owned environment metadata for CLI setup/onboarding."""
 
 from collections.abc import Mapping
 from pathlib import Path
@@ -6,7 +6,7 @@
 from pydantic import BaseModel, ConfigDict
 
 
-class BenchmarkCliMetadata(BaseModel):
+class EnvironmentCliMetadata(BaseModel):
     model_config = ConfigDict(frozen=True)
 
     slug: str
@@ -18,42 +18,42 @@ class BenchmarkCliMetadata(BaseModel):
     supports_setup: bool = False
 
 
-_BENCHMARK_ROOT = Path(__file__).parent
+_ENVIRONMENT_TEMPLATE_ROOT = Path(__file__).parents[1] / "benchmarks"
 
-_METADATA: dict[str, BenchmarkCliMetadata] = {
-    "gdpeval": BenchmarkCliMetadata(
+_METADATA: dict[str, EnvironmentCliMetadata] = {
+    "gdpeval": EnvironmentCliMetadata(
         slug="gdpeval",
         name="gdpeval",
-        description="Benchmark for GDP document-processing evaluation tasks.",
+        description="Environment for GDP document-processing evaluation tasks.",
         required_packages=("ergon-builtins[data]",),
         env_keys=("E2B_API_KEY",),
     ),
-    "minif2f": BenchmarkCliMetadata(
+    "minif2f": EnvironmentCliMetadata(
         slug="minif2f",
         name="minif2f",
-        description="Benchmark backed by MiniF2F theorem-proving tasks.",
-        sandbox_template=_BENCHMARK_ROOT / "minif2f" / "sandbox_template",
+        description="Environment backed by MiniF2F theorem-proving tasks.",
+        sandbox_template=_ENVIRONMENT_TEMPLATE_ROOT / "minif2f" / "sandbox_template",
         env_keys=("E2B_API_KEY",),
         supports_setup=True,
     ),
-    "researchrubrics": BenchmarkCliMetadata(
+    "researchrubrics": EnvironmentCliMetadata(
         slug="researchrubrics",
         name="researchrubrics",
-        description="Benchmark backed by ScaleAI ResearchRubrics samples.",
+        description="Environment backed by ScaleAI ResearchRubrics samples.",
         required_packages=("ergon-builtins[data]",),
         env_keys=("EXA_API_KEY",),
     ),
-    "researchrubrics-vanilla": BenchmarkCliMetadata(
+    "researchrubrics-vanilla": EnvironmentCliMetadata(
         slug="researchrubrics-vanilla",
         name="researchrubrics-vanilla",
-        description="Vanilla ResearchRubrics baseline benchmark.",
+        description="Vanilla ResearchRubrics baseline environment.",
         required_packages=("ergon-builtins[data]",),
     ),
-    "swebench-verified": BenchmarkCliMetadata(
+    "swebench-verified": EnvironmentCliMetadata(
         slug="swebench-verified",
         name="swebench-verified",
-        description="Benchmark backed by SWE-Bench Verified.",
-        sandbox_template=_BENCHMARK_ROOT / "swebench_verified" / "sandbox_template",
+        description="Environment backed by SWE-Bench Verified.",
+        sandbox_template=_ENVIRONMENT_TEMPLATE_ROOT / "swebench_verified" / "sandbox_template",
         required_packages=("ergon-builtins[data]",),
         env_keys=("E2B_API_KEY",),
         supports_setup=True,
@@ -61,5 +61,5 @@ class BenchmarkCliMetadata(BaseModel):
 }
 
 
-def benchmark_cli_metadata() -> Mapping[str, BenchmarkCliMetadata]:
+def environment_cli_metadata() -> Mapping[str, EnvironmentCliMetadata]:
     return dict(_METADATA)
diff --git a/ergon_builtins/ergon_builtins/environments/gdpeval.py b/ergon_builtins/ergon_builtins/environments/gdpeval.py
deleted file mode 100644
index 8ff092573..000000000
--- a/ergon_builtins/ergon_builtins/environments/gdpeval.py
+++ /dev/null
@@ -1,133 +0,0 @@
-"""GDPEval sample-producing environment."""
-
-from __future__ import annotations
-
-from collections.abc import Callable, Iterator, Sequence
-from dataclasses import dataclass
-from typing import Any, Literal, Protocol, cast
-
-from ergon_core.api import Environment, Sample, Task
-from ergon_core.api.rubric import Evaluator
-from ergon_core.api.sandbox import Sandbox
-from ergon_core.api.worker import Worker
-from pydantic import Field
-
-from ergon_builtins.benchmarks.gdpeval.benchmark import (
-    GDPEvalTask,
-    _default_gdpeval_sandbox,
-)
-from ergon_builtins.benchmarks.gdpeval.loader import (
-    HF_REPO_ID,
-    extract_task_description,
-    find_reference_files,
-    load_task_ids,
-)
-from ergon_builtins.benchmarks.gdpeval.task_schemas import GDPTaskConfig
-from ergon_builtins.benchmarks.gdpeval.worker_factory import (
-    make_gdpeval_rubric,
-    make_gdpeval_worker,
-)
-from ergon_builtins.environments._resolve import (
-    resolve_evaluators,
-    resolve_sandbox,
-    resolve_worker,
-)
-
-
-class GDPEvalRowLoader(Protocol):
-    def iter_rows(self) -> Iterator[GDPTaskConfig]: ...
-
-    def load_rows(self) -> Sequence[GDPTaskConfig]: ...
-
-
-@dataclass(frozen=True)
-class DefaultGDPEvalRowLoader:
-    dataset_repo: str = HF_REPO_ID
-    split: str = "train"
-    limit: int | None = None
-
-    def iter_rows(self) -> Iterator[GDPTaskConfig]:
-        yield from self.load_rows()
-
-    def load_rows(self) -> Sequence[GDPTaskConfig]:
-        configs: list[GDPTaskConfig] = []
-        for task_id in load_task_ids(split=self.split, repo_id=self.dataset_repo, limit=self.limit):
-            ref_files = find_reference_files(task_id, repo_id=self.dataset_repo)
-            configs.append(
-                GDPTaskConfig(
-                    task_id=task_id,
-                    workflow_type="document_processing",
-                    reference_files=[str(path) for path in ref_files],
-                )
-            )
-        return configs
-
-
-class GDPEvalEnvironment(Environment):
-    name: str = "gdpeval"
-    dataset_repo: str = HF_REPO_ID
-    split: str = "train"
-    limit: int | None = None
-    source_mode: Literal["materialized"] = "materialized"
-    loader: Any | None = None
-    task_description: Callable[[GDPTaskConfig], str] | None = None
-    worker: Worker | Callable[[GDPTaskConfig], Worker] = Field(default_factory=make_gdpeval_worker)
-    evaluators: Sequence[Evaluator] | Callable[[GDPTaskConfig], Sequence[Evaluator]] = Field(
-        default_factory=lambda: (make_gdpeval_rubric(),)
-    )
-    sandbox: Sandbox | Callable[[GDPTaskConfig], Sandbox] = Field(
-        default_factory=_default_gdpeval_sandbox
-    )
-
-    def iter_samples(self) -> Iterator[Sample]:
-        for row in self._limit_rows(self._loader().iter_rows()):
-            yield self._sample_from_row(row)
-
-    def all_samples(self) -> Sequence[Sample]:
-        if self.source_mode == "streaming":
-            raise NotImplementedError("Streaming environments may not materialize all samples")
-        return [self._sample_from_row(row) for row in self._limit_rows(self._loader().load_rows())]
-
-    def _loader(self) -> GDPEvalRowLoader:
-        return self.loader or DefaultGDPEvalRowLoader(
-            dataset_repo=self.dataset_repo,
-            split=self.split,
-            limit=self.limit,
-        )
-
-    def _limit_rows(
-        self,
-        rows: Sequence[GDPTaskConfig] | Iterator[GDPTaskConfig],
-    ) -> Iterator[GDPTaskConfig]:
-        for index, row in enumerate(rows):
-            if self.limit is not None and index >= self.limit:
-                break
-            yield row
-
-    def _sample_from_row(self, row: GDPTaskConfig) -> Sample:
-        task = GDPEvalTask(
-            task_slug=row.task_id,
-            instance_key="default",
-            description=self._description_for(row),
-            task_payload=row,
-            worker=resolve_worker(self.worker, row),
-            sandbox=resolve_sandbox(self.sandbox, row),
-            evaluators=resolve_evaluators(self.evaluators, row),
-        )
-        return Sample.from_tasks(
-            name=f"{self.name}:{row.task_id}",
-            sample_key=row.task_id,
-            environment_name=self.name,
-            sample_ref={"task_id": row.task_id, "split": self.split},
-            source_metadata={
-                "provider": "ergon-builtin:gdpeval",
-                "dataset_repo": self.dataset_repo,
-                "split": self.split,
-            },
-            tasks=[cast(Task, task)],
-        )
-
-    def _description_for(self, row: GDPTaskConfig) -> str:
-        if self.task_description is not None:
-            return self.task_description(row)
-        return extract_task_description(row.task_id, repo_id=self.dataset_repo)
diff --git a/ergon_builtins/ergon_builtins/environments/minif2f.py b/ergon_builtins/ergon_builtins/environments/minif2f.py
deleted file mode 100644
index 3858e5b34..000000000
--- a/ergon_builtins/ergon_builtins/environments/minif2f.py
+++ /dev/null
@@ -1,137 +0,0 @@
-"""MiniF2F sample-producing environment."""
-
-from __future__ import annotations
-
-import json
-from collections.abc import Callable, Iterator, Sequence
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Literal, Protocol, cast
-
-from ergon_core.api import Environment, Sample, Task
-from ergon_core.api.rubric import Evaluator
-from ergon_core.api.sandbox import Sandbox
-from ergon_core.api.worker import Worker
-from huggingface_hub import hf_hub_download
-from pydantic import Field
-
-from ergon_builtins.benchmarks.minif2f.benchmark import HF_FILENAME, HF_REPO_ID, MiniF2FTask
-from ergon_builtins.benchmarks.minif2f.sandbox import LeanSandbox
-from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FProblem, MiniF2FTaskPayload
-from ergon_builtins.benchmarks.minif2f.worker_factory import (
-    make_minif2f_rubric,
-    make_minif2f_worker,
-)
-from ergon_builtins.environments._resolve import (
-    resolve_evaluators,
-    resolve_sandbox,
-    resolve_worker,
-)
-
-
-class MiniF2FRowLoader(Protocol):
-    def iter_rows(self) -> Iterator[MiniF2FProblem]: ...
-
-    def load_rows(self) -> Sequence[MiniF2FProblem]: ...
-
-
-@dataclass(frozen=True)
-class DefaultMiniF2FRowLoader:
-    data_dir: Path | None = None
-    limit: int | None = None
-
-    def iter_rows(self) -> Iterator[MiniF2FProblem]:
-        yield from self.load_rows()
-
-    def load_rows(self) -> Sequence[MiniF2FProblem]:
-        cache_dir = str(self.data_dir) if self.data_dir else None
-        jsonl_path = Path(
-            hf_hub_download(
-                repo_id=HF_REPO_ID,
-                filename=HF_FILENAME,
-                repo_type="dataset",
-                cache_dir=cache_dir,
-            )
-        )
-        rows: list[MiniF2FProblem] = []
-        with jsonl_path.open(encoding="utf-8") as f:
-            for line in f:
-                stripped = line.strip()
-                if not stripped:
-                    continue
-                raw = json.loads(stripped)
-                rows.append(
-                    MiniF2FProblem(
-                        name=raw["name"],
-                        informal_statement=raw["informal_statement"],
-                        formal_statement=raw["formal_statement"],
-                        header=raw["header"],
-                    )
-                )
-                if self.limit is not None and len(rows) >= self.limit:
-                    break
-        return rows
-
-
-class MiniF2FEnvironment(Environment):
-    name: str = "minif2f"
-    split: str = "validation"
-    limit: int | None = None
-    source_mode: Literal["materialized"] = "materialized"
-    data_dir: Path | None = None
-    loader: Any | None = None
-    worker: Worker | Callable[[MiniF2FProblem], Worker] = Field(default_factory=make_minif2f_worker)
-    evaluators: Sequence[Evaluator] | Callable[[MiniF2FProblem], Sequence[Evaluator]] = Field(
-        default_factory=lambda: (make_minif2f_rubric(),)
-    )
-    sandbox: Sandbox | Callable[[MiniF2FProblem], Sandbox] = Field(default_factory=LeanSandbox)
-
-    def iter_samples(self) -> Iterator[Sample]:
-        for row in self._limit_rows(self._loader().iter_rows()):
-            yield self._sample_from_row(row)
-
-    def all_samples(self) -> Sequence[Sample]:
-        if self.source_mode == "streaming":
-            raise NotImplementedError("Streaming environments may not materialize all samples")
-        return [self._sample_from_row(row) for row in self._limit_rows(self._loader().load_rows())]
-
-    def _loader(self) -> MiniF2FRowLoader:
-        return self.loader or DefaultMiniF2FRowLoader(data_dir=self.data_dir, limit=self.limit)
-
-    def _limit_rows(
-        self,
-        rows: Sequence[MiniF2FProblem] | Iterator[MiniF2FProblem],
-    ) -> Iterator[MiniF2FProblem]:
-        for index, row in enumerate(rows):
-            if self.limit is not None and index >= self.limit:
-                break
-            yield row
-
-    def _sample_from_row(self, row: MiniF2FProblem) -> Sample:
-        payload = MiniF2FTaskPayload(
-            name=row.name,
-            informal_statement=row.informal_statement,
-            formal_statement=row.formal_statement,
-            header=row.header,
-        )
-        task = MiniF2FTask(
-            task_slug=row.name,
-            instance_key="default",
-            description=(
-                f"{row.informal_statement}\n\n"
-                f"Your task: prove the following theorem in Lean 4.\n\n"
-                f"{row.header}\n{row.formal_statement}"
-            ),
-            task_payload=payload,
-            worker=resolve_worker(self.worker, row),
-            sandbox=resolve_sandbox(self.sandbox, row),
-            evaluators=resolve_evaluators(self.evaluators, row),
-        )
-        return Sample.from_tasks(
-            name=f"{self.name}:{row.name}",
-            sample_key=row.name,
-            environment_name=self.name,
-            sample_ref={"problem_id": row.name, "split": self.split},
-            source_metadata={"provider": "ergon-builtin:minif2f", "split": self.split},
-            tasks=[cast(Task, task)],
-        )
diff --git a/ergon_builtins/ergon_builtins/environments/researchrubrics.py b/ergon_builtins/ergon_builtins/environments/researchrubrics.py
deleted file mode 100644
index 2aa6d1b9f..000000000
--- a/ergon_builtins/ergon_builtins/environments/researchrubrics.py
+++ /dev/null
@@ -1,144 +0,0 @@
-"""ResearchRubrics sample-producing environment."""
-
-from __future__ import annotations
-
-from collections.abc import Callable, Iterator, Mapping, Sequence
-from dataclasses import dataclass
-from typing import Any, Literal, Protocol, cast
-
-from datasets import load_dataset
-from ergon_core.api import Environment, Sample, Task
-from ergon_core.api.rubric import Evaluator
-from ergon_core.api.sandbox import Sandbox
-from ergon_core.api.worker import Worker
-from ergon_core.core.shared.settings import settings
-from pydantic import Field
-
-from ergon_builtins.benchmarks.researchrubrics.benchmark import (
-    ResearchRubricsBenchmark,
-    ResearchRubricsTask,
-    _default_research_sandbox,
-    _payload_from_row,
-)
-from ergon_builtins.benchmarks.researchrubrics.rubric import ResearchRubricsRubric
-from ergon_builtins.benchmarks.researchrubrics.task_schemas import ResearchRubricsTaskPayload
-from ergon_builtins.benchmarks.researchrubrics.worker_factory import (
-    make_research_rubric,
-    make_research_worker,
-)
-from ergon_builtins.environments._resolve import (
-    resolve_evaluators,
-    resolve_sandbox,
-    resolve_worker,
-)
-
-
-class ResearchRubricsRowLoader(Protocol):
-    def iter_rows(self) -> Iterator[ResearchRubricsTaskPayload]: ...
-
-    def load_rows(self) -> Sequence[ResearchRubricsTaskPayload]: ...
-
-
-@dataclass(frozen=True)
-class DefaultResearchRubricsRowLoader:
-    dataset_name: str = ResearchRubricsBenchmark.dataset_name
-    split: str = "train"
-    limit: int | None = None
-
-    def iter_rows(self) -> Iterator[ResearchRubricsTaskPayload]:
-        yield from self.load_rows()
-
-    def load_rows(self) -> Sequence[ResearchRubricsTaskPayload]:
-        ds = load_dataset(self.dataset_name, token=settings.hf_api_key)
-        split_ds = ds[self.split]
-        if self.limit is not None:
-            split_ds = split_ds.select(range(min(self.limit, len(split_ds))))
-        return [_payload_from_row(split_ds[idx]) for idx in range(len(split_ds))]
-
-
-class ResearchRubricsEnvironment(Environment):
-    name: str = "researchrubrics"
-    dataset_name: str = ResearchRubricsBenchmark.dataset_name
-    split: str = "train"
-    limit: int | None = None
-    source_mode: Literal["materialized"] = "materialized"
-    loader: Any | None = None
-    worker: Worker | Callable[[ResearchRubricsTaskPayload], Worker] = Field(
-        default_factory=make_research_worker
-    )
-    evaluators: (
-        Sequence[Evaluator] | Callable[[ResearchRubricsTaskPayload], Sequence[Evaluator]]
-    ) = Field(default_factory=lambda: (make_research_rubric(),))
-    sandbox: Sandbox | Callable[[ResearchRubricsTaskPayload], Sandbox] = Field(
-        default_factory=_default_research_sandbox
-    )
-
-    def iter_samples(self) -> Iterator[Sample]:
-        for row in self._limit_rows(self._loader().iter_rows()):
-            yield self._sample_from_row(row)
-
-    def all_samples(self) -> Sequence[Sample]:
-        if self.source_mode == "streaming":
-            raise NotImplementedError("Streaming environments may not materialize all samples")
-        return [self._sample_from_row(row) for row in self._limit_rows(self._loader().load_rows())]
-
-    def _loader(self) -> ResearchRubricsRowLoader:
-        return self.loader or DefaultResearchRubricsRowLoader(
-            dataset_name=self.dataset_name,
-            split=self.split,
-            limit=self.limit,
-        )
-
-    def _limit_rows(
-        self,
-        rows: Sequence[ResearchRubricsTaskPayload] | Iterator[ResearchRubricsTaskPayload],
-    ) -> Iterator[ResearchRubricsTaskPayload]:
-        for index, row in enumerate(rows):
-            if self.limit is not None and index >= self.limit:
-                break
-            yield row
-
-    def _sample_from_row(self, row: ResearchRubricsTaskPayload | Mapping[str, Any]) -> Sample:
-        payload = row if isinstance(row, ResearchRubricsTaskPayload) else _payload_from_row(row)
-        evaluators = resolve_evaluators(self.evaluators, payload)
-        evaluators = tuple(
-            self._bind_payload_rubric(evaluator, payload) for evaluator in evaluators
-        )
-        task = ResearchRubricsTask(
-            task_slug=payload.sample_id,
-            instance_key="default",
-            description=payload.prompt,
-            task_payload=payload,
-            worker=resolve_worker(self.worker, payload),
-            sandbox=resolve_sandbox(self.sandbox, payload),
-            evaluators=evaluators,
-        )
-        return Sample.from_tasks(
-            name=f"{self.name}:{payload.sample_id}",
-            sample_key=payload.sample_id,
-            environment_name=self.name,
-            sample_ref={
-                "sample_id": payload.sample_id,
-                "domain": payload.domain,
-                "split": self.split,
-            },
-            source_metadata={
-                "provider": "ergon-builtin:researchrubrics",
-                "dataset_name": self.dataset_name,
-                "split": self.split,
-            },
-            tasks=[cast(Task, task)],
-        )
-
-    @staticmethod
-    def _bind_payload_rubric(
-        evaluator: Evaluator,
-        payload: ResearchRubricsTaskPayload,
-    ) -> Evaluator:
-        if isinstance(evaluator, ResearchRubricsRubric) and not evaluator.rubric_criteria:
-            return ResearchRubricsRubric(
-                name=evaluator.name,
-                metadata=evaluator.metadata,
-                rubric_criteria=tuple(payload.rubrics),
-            )
-        return evaluator
diff --git a/ergon_builtins/ergon_builtins/environments/swebench_verified.py b/ergon_builtins/ergon_builtins/environments/swebench_verified.py
deleted file mode 100644
index e0d89d1f7..000000000
--- a/ergon_builtins/ergon_builtins/environments/swebench_verified.py
+++ /dev/null
@@ -1,143 +0,0 @@
-"""SWE-Bench Verified sample-producing environment."""
-
-from __future__ import annotations
-
-from collections.abc import Callable, Iterator, Sequence
-from dataclasses import dataclass
-from typing import Any, Literal, Protocol, cast
-
-from datasets import load_dataset
-from ergon_core.api import Environment, Sample, Task
-from ergon_core.api.rubric import Evaluator
-from ergon_core.api.sandbox import Sandbox
-from ergon_core.api.worker import Worker
-from pydantic import Field, model_validator
-
-from ergon_builtins.benchmarks.swebench_verified.benchmark import (
-    HF_DATASET_ID,
-    HF_SPLIT,
-    SweBenchTask,
-    _default_swebench_sandbox,
-)
-from ergon_builtins.benchmarks.swebench_verified.task_schemas import (
-    SWEBenchInstance,
-    SWEBenchTaskPayload,
-)
-from ergon_builtins.benchmarks.swebench_verified.worker_factory import (
-    make_swebench_rubric,
-    make_swebench_worker,
-)
-from ergon_builtins.environments._resolve import (
-    resolve_evaluators,
-    resolve_sandbox,
-    resolve_worker,
-)
-
-
-class SweBenchVerifiedRowLoader(Protocol):
-    def iter_rows(self) -> Iterator[SWEBenchInstance]: ...
-
-    def load_rows(self) -> Sequence[SWEBenchInstance]: ...
-
-
-@dataclass(frozen=True)
-class DefaultSweBenchVerifiedRowLoader:
-    dataset_id: str = HF_DATASET_ID
-    split: str = HF_SPLIT
-    limit: int | None = None
-    streaming: bool = False
-
-    def iter_rows(self) -> Iterator[SWEBenchInstance]:
-        ds = load_dataset(self.dataset_id, split=self.split, streaming=self.streaming)
-        for index, row in enumerate(ds):
-            if self.limit is not None and index >= self.limit:
-                break
-            yield SWEBenchInstance.from_raw(row)
-
-    def load_rows(self) -> Sequence[SWEBenchInstance]:
-        ds = load_dataset(self.dataset_id, split=self.split)
-        if self.limit is not None:
-            ds = ds.select(range(min(self.limit, len(ds))))
-        return [SWEBenchInstance.from_raw(row) for row in ds]
-
-
-class SweBenchVerifiedEnvironment(Environment):
-    name: str = "swebench-verified"
-    split: str = HF_SPLIT
-    dataset_id: str = HF_DATASET_ID
-    limit: int | None = None
-    source_mode: Literal["materialized", "streaming"] = "materialized"
-    streaming: bool = False
-    loader: Any | None = None
-    worker: Worker | Callable[[SWEBenchInstance], Worker] = Field(
-        default_factory=make_swebench_worker
-    )
-    evaluators: Sequence[Evaluator] | Callable[[SWEBenchInstance], Sequence[Evaluator]] = Field(
-        default_factory=lambda: (make_swebench_rubric(),)
-    )
-    sandbox: Sandbox | Callable[[SWEBenchInstance], Sandbox] = Field(
-        default_factory=_default_swebench_sandbox
-    )
-
-    @model_validator(mode="after")
-    def _sync_streaming_flag(self) -> "SweBenchVerifiedEnvironment":
-        if self.streaming:
-            self.source_mode = "streaming"
-        elif self.source_mode == "streaming":
-            self.streaming = True
-        return self
-
-    def iter_samples(self) -> Iterator[Sample]:
-        for row in self._limit_rows(self._loader().iter_rows()):
-            yield self._sample_from_row(row)
-
-    def all_samples(self) -> Sequence[Sample]:
-        if self.source_mode == "streaming":
-            raise NotImplementedError("Streaming environments may not materialize all samples")
-        return [self._sample_from_row(row) for row in self._limit_rows(self._loader().load_rows())]
-
-    def _loader(self) -> SweBenchVerifiedRowLoader:
-        return self.loader or DefaultSweBenchVerifiedRowLoader(
-            dataset_id=self.dataset_id,
-            split=self.split,
-            limit=self.limit,
-            streaming=self.source_mode == "streaming",
-        )
-
-    def _limit_rows(
-        self,
-        rows: Sequence[SWEBenchInstance] | Iterator[SWEBenchInstance],
-    ) -> Iterator[SWEBenchInstance]:
-        for index, row in enumerate(rows):
-            if self.limit is not None and index >= self.limit:
-                break
-            yield row
-
-    def _sample_from_row(self, row: SWEBenchInstance) -> Sample:
-        payload = SWEBenchTaskPayload.from_instance(row)
-        task = SweBenchTask(
-            task_slug=row.instance_id,
-            instance_key="default",
-            description=payload.build_worker_description(),
-            task_payload=payload,
-            worker=resolve_worker(self.worker, row),
-            sandbox=resolve_sandbox(self.sandbox, row),
-            evaluators=resolve_evaluators(self.evaluators, row),
-        )
-        return Sample.from_tasks(
-            name=f"{self.name}:{row.instance_id}",
-            sample_key=row.instance_id,
-            environment_name=self.name,
-            sample_ref={
-                "instance_id": row.instance_id,
-                "repo": row.repo,
-                "base_commit": row.base_commit,
-                "split": self.split,
-            },
-            source_metadata={
-                "provider": "ergon-builtin:swebench-verified",
-                "dataset_id": self.dataset_id,
-                "split": self.split,
-            },
-            tasks=[cast(Task, task)],
-        )
diff --git a/ergon_builtins/ergon_builtins/sandbox/__init__.py b/ergon_builtins/ergon_builtins/sandbox/__init__.py
index 74f906920..661b8e489 100644
--- a/ergon_builtins/ergon_builtins/sandbox/__init__.py
+++ b/ergon_builtins/ergon_builtins/sandbox/__init__.py
@@ -1,13 +1,13 @@
-"""Cross-cutting sandbox infrastructure shared across benchmarks.
+"""Cross-cutting sandbox infrastructure shared across environments.
 
 Files in this package implement adapters / utilities that more than
-one benchmark's `Sandbox` subclass relies on.  Per-benchmark code
+one environment's `Sandbox` subclass relies on.  Environment-specific code
 (`LeanSandbox`, `SWEBenchSandbox`, etc.) lives in
 `ergon_builtins/benchmarks/<slug>/sandbox.py`, NOT here. E2B-backed
-benchmarks share ``E2BSandbox`` and ``E2BSandboxRuntime`` from this package.
+environments share ``E2BSandbox`` and ``E2BSandboxRuntime`` from this package.
 
 Naming: singular ``sandbox/`` (this package, cross-cutting infra)
-vs. per-benchmark ``benchmarks/<slug>/sandbox.py`` (single concrete
+vs. environment-specific ``benchmarks/<slug>/sandbox.py`` (single concrete
 Sandbox subclass).  The deleted ``sandboxes/`` (plural) directory
 conflated the two and is gone.
 """
diff --git a/ergon_builtins/ergon_builtins/toolkits/common/base.py b/ergon_builtins/ergon_builtins/toolkits/common/base.py
index d3f3d6058..73333b291 100644
--- a/ergon_builtins/ergon_builtins/toolkits/common/base.py
+++ b/ergon_builtins/ergon_builtins/toolkits/common/base.py
@@ -1,6 +1,6 @@
 """Serializable toolkit config for builtin ReAct-style workers.
 
-Benchmark-specific toolkits subclass ``Toolkit`` to declare authoring-time
+Environment-specific toolkits subclass ``Toolkit`` to declare authoring-time
 config fields, then lazily build live runtime tools when a ``ReActWorker``
 executes. Toolkits are intentionally a builtins/ReAct concern, not a core
 authoring API concept.
diff --git a/ergon_builtins/ergon_builtins/toolkits/subagents/toolkit.py b/ergon_builtins/ergon_builtins/toolkits/subagents/toolkit.py
index ffce13eda..ba9b5a108 100644
--- a/ergon_builtins/ergon_builtins/toolkits/subagents/toolkit.py
+++ b/ergon_builtins/ergon_builtins/toolkits/subagents/toolkit.py
@@ -9,7 +9,7 @@
 from collections.abc import Awaitable, Callable
 from uuid import UUID
 
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.api.worker import WorkerContext
 from ergon_core.core.persistence.shared.types import (
     NodeId,
diff --git a/ergon_builtins/ergon_builtins/tools/dynamic_task_factory.py b/ergon_builtins/ergon_builtins/tools/dynamic_task_factory.py
index 7264dbb05..4d4ca79d3 100644
--- a/ergon_builtins/ergon_builtins/tools/dynamic_task_factory.py
+++ b/ergon_builtins/ergon_builtins/tools/dynamic_task_factory.py
@@ -2,7 +2,7 @@
 
 from pydantic import BaseModel, ConfigDict
 
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 
 
 class DynamicTaskFactory(Protocol):
diff --git a/ergon_builtins/ergon_builtins/tools/workflow_command_adapter.py b/ergon_builtins/ergon_builtins/tools/workflow_command_adapter.py
index 2ddb7b03d..12962a20a 100644
--- a/ergon_builtins/ergon_builtins/tools/workflow_command_adapter.py
+++ b/ergon_builtins/ergon_builtins/tools/workflow_command_adapter.py
@@ -35,7 +35,7 @@
     "--execution-id",
     "--sandbox-id",
     "--sandbox-task-key",
-    "--benchmark-type",
+    "--environment-type",
 }
 
 
diff --git a/ergon_builtins/tests/integration/tools/test_workflow_command_adapter.py b/ergon_builtins/tests/integration/tools/test_workflow_command_adapter.py
index 4ae810755..9bfe922f3 100644
--- a/ergon_builtins/tests/integration/tools/test_workflow_command_adapter.py
+++ b/ergon_builtins/tests/integration/tools/test_workflow_command_adapter.py
@@ -145,7 +145,7 @@ async def test_workflow_command_rejects_unknown_dependency_without_partial_write
         "--execution-id",
         "--sandbox-id",
         "--sandbox-task-key",
-        "--benchmark-type",
+        "--environment-type",
     ],
 )
 async def test_context_escape_flags_are_rejected(
diff --git a/ergon_builtins/tests/unit/architecture/test_object_bound_benchmarks_no_registry.py b/ergon_builtins/tests/unit/architecture/test_object_bound_benchmarks_no_registry.py
index de9736ee2..57a44e6ca 100644
--- a/ergon_builtins/tests/unit/architecture/test_object_bound_benchmarks_no_registry.py
+++ b/ergon_builtins/tests/unit/architecture/test_object_bound_benchmarks_no_registry.py
@@ -102,10 +102,10 @@ def test_benchmark_tools_use_owned_tools_packages() -> None:
 
 
 @pytest.mark.parametrize("slug", _MIGRATED_BENCHMARKS)
-def test_benchmark_worker_factories_use_canonical_module(slug: str) -> None:
+def test_benchmark_worker_factories_are_removed(slug: str) -> None:
     benchmark_pkg = SOURCE_ROOT / "benchmarks" / slug
 
-    assert (benchmark_pkg / "worker_factory.py").exists()
+    assert not (benchmark_pkg / "worker_factory.py").exists()
     assert not (benchmark_pkg / "workers.py").exists()
 
 
diff --git a/ergon_builtins/tests/unit/benchmarks/test_catalog.py b/ergon_builtins/tests/unit/benchmarks/test_catalog.py
index b38ce5a6c..4ff69f0c1 100644
--- a/ergon_builtins/tests/unit/benchmarks/test_catalog.py
+++ b/ergon_builtins/tests/unit/benchmarks/test_catalog.py
@@ -1,16 +1,16 @@
-from ergon_builtins.benchmarks.catalog import benchmark_cli_metadata
+from ergon_builtins.environments.catalog import environment_cli_metadata
 
 
-def test_benchmark_cli_metadata_exposes_setup_templates() -> None:
-    metadata = benchmark_cli_metadata()
+def test_environment_cli_metadata_exposes_setup_templates() -> None:
+    metadata = environment_cli_metadata()
 
     assert metadata["minif2f"].sandbox_template is not None
     assert metadata["minif2f"].supports_setup is True
     assert metadata["swebench-verified"].sandbox_template is not None
 
 
-def test_benchmark_cli_metadata_exposes_onboarding_requirements() -> None:
-    metadata = benchmark_cli_metadata()
+def test_environment_cli_metadata_exposes_onboarding_requirements() -> None:
+    metadata = environment_cli_metadata()
 
     assert "E2B_API_KEY" in metadata["gdpeval"].env_keys
     assert "EXA_API_KEY" in metadata["researchrubrics"].env_keys
diff --git a/ergon_builtins/tests/unit/benchmarks/test_minif2f_proof_verification.py b/ergon_builtins/tests/unit/benchmarks/test_minif2f_proof_verification.py
index 7b57dcdab..83d3ae09b 100644
--- a/ergon_builtins/tests/unit/benchmarks/test_minif2f_proof_verification.py
+++ b/ergon_builtins/tests/unit/benchmarks/test_minif2f_proof_verification.py
@@ -14,7 +14,7 @@
 )
 from ergon_core.api import WorkerOutput
 from ergon_core.api.criterion import CriterionContext
-from ergon_core.api.benchmark import EmptyTaskPayload, Task
+from ergon_core.api.task import EmptyTaskPayload, Task
 from ergon_core.api.sandbox.runtime import CommandResult
 from ergon_core.test_support.task_factory import task_with_id
 
diff --git a/ergon_builtins/tests/unit/benchmarks/test_minif2f_task_shape.py b/ergon_builtins/tests/unit/benchmarks/test_minif2f_task_shape.py
index 86f4947cd..9e2b340b1 100644
--- a/ergon_builtins/tests/unit/benchmarks/test_minif2f_task_shape.py
+++ b/ergon_builtins/tests/unit/benchmarks/test_minif2f_task_shape.py
@@ -1,13 +1,24 @@
 """MiniF2F v2 authoring shape: toolkit round-trip and task JSON assertions."""
 
-from ergon_builtins.benchmarks.minif2f.worker_factory import (
-    make_minif2f_rubric,
-    make_minif2f_worker,
-)
+from ergon_builtins.agents.react.worker import ReActWorker
+from ergon_builtins.benchmarks.minif2f.prompts import MINIF2F_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.minif2f.rubric import MiniF2FRubric
 from ergon_builtins.benchmarks.minif2f.sandbox import LeanSandbox
+from ergon_builtins.benchmarks.minif2f.sample import make_minif2f_sample
+from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FProblem
 from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
 
 
+def _mini_worker() -> ReActWorker:
+    return ReActWorker(
+        name="mini-proof-solver",
+        model="test:none",
+        system_prompt=MINIF2F_SYSTEM_PROMPT,
+        max_iterations=30,
+        toolkit=MiniF2FToolkit(),
+    )
+
+
 def test_minif2f_toolkit_round_trips_through_json() -> None:
     tk = MiniF2FToolkit(max_tool_calls=16)
     serialized = tk.model_dump(mode="json")
@@ -22,8 +33,8 @@ def test_lean_sandbox_serializes_with_type_discriminator() -> None:
     assert serialized["_type"].endswith(":LeanSandbox")
 
 
-def test_make_minif2f_worker_serializes_with_nested_toolkit_type() -> None:
-    worker = make_minif2f_worker()
+def test_minif2f_worker_serializes_with_nested_toolkit_type() -> None:
+    worker = _mini_worker()
     serialized = worker.model_dump(mode="json")
     assert serialized["_type"].endswith(":ReActWorker"), serialized["_type"]
     toolkit_json = serialized.get("toolkit")
@@ -31,15 +42,15 @@ def test_make_minif2f_worker_serializes_with_nested_toolkit_type() -> None:
     assert toolkit_json["_type"].endswith(":MiniF2FToolkit"), toolkit_json["_type"]
 
 
-def test_make_minif2f_rubric_serializes_with_type_discriminator() -> None:
-    rubric = make_minif2f_rubric()
+def test_minif2f_rubric_serializes_with_type_discriminator() -> None:
+    rubric = MiniF2FRubric(name="minif2f-rubric")
     serialized = rubric.model_dump(mode="json")
     assert serialized["_type"].endswith(":MiniF2FRubric"), serialized["_type"]
 
 
 def test_minif2f_task_json_has_correct_shape() -> None:
     """A MiniF2F Task serializes to the v2 object-bound shape."""
-    from ergon_builtins.benchmarks.minif2f.benchmark import MiniF2FTask
+    from ergon_builtins.benchmarks.minif2f.task import MiniF2FTask
     from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FTaskPayload
 
     task = MiniF2FTask(
@@ -52,9 +63,9 @@ def test_minif2f_task_json_has_correct_shape() -> None:
             formal_statement="theorem sample_1 : 1 + 1 = 2 := by",
             header="import Mathlib\n",
         ),
-        worker=make_minif2f_worker(),
+        worker=_mini_worker(),
         sandbox=LeanSandbox(),
-        evaluators=(make_minif2f_rubric(),),
+        evaluators=(MiniF2FRubric(name="minif2f-rubric"),),
     )
     task_json = task.model_dump(mode="json")
 
@@ -70,39 +81,26 @@ def test_minif2f_task_json_has_correct_shape() -> None:
     )
 
 
-def test_minif2f_benchmark_accepts_custom_worker_factory(monkeypatch) -> None:
-    """The benchmark uses the worker_factory passed to its constructor.
+def test_make_minif2f_sample_accepts_custom_worker() -> None:
+    """The sample helper binds the worker passed to it.
 
-    Load-bearing assertion: factories are *called*, not stored as a class
-    attribute that defaults to them.  Without this test, a future refactor
-    could accidentally revert to hardcoding the default and the test suite
-    would still pass.
+    Load-bearing assertion: author-provided runtime components are used
+    directly when rows are converted into samples.
     """
-    from unittest.mock import MagicMock
-
-    from ergon_builtins.benchmarks.minif2f.benchmark import MiniF2FBenchmark
-    from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FProblem
 
-    sentinel_worker = make_minif2f_worker()
+    sentinel_worker = _mini_worker()
     sentinel_worker.name = "sentinel"
-    factory = MagicMock(return_value=sentinel_worker)
-
-    # Stub out HF download so the test stays hermetic.
-    monkeypatch.setattr(
-        MiniF2FBenchmark,
-        "_load_problems",
-        lambda self: [
-            MiniF2FProblem(
-                name="x",
-                informal_statement="i",
-                formal_statement="theorem x : True := by",
-                header="import Mathlib\n",
-            )
-        ],
+    sample = make_minif2f_sample(
+        MiniF2FProblem(
+            name="x",
+            informal_statement="i",
+            formal_statement="theorem x : True := by",
+            header="import Mathlib\n",
+        ),
+        environment_name="mini",
+        worker=sentinel_worker,
+        evaluators=[MiniF2FRubric(name="minif2f-rubric")],
+        sandbox=LeanSandbox(),
     )
 
-    benchmark = MiniF2FBenchmark(worker_factory=factory, limit=1)
-    tasks = list(benchmark.build_instances().values())[0]
-
-    assert tasks[0].worker is sentinel_worker
-    factory.assert_called_once()
+    assert sample.tasks[0].worker is sentinel_worker
diff --git a/ergon_builtins/tests/unit/benchmarks/test_source_sample_helpers.py b/ergon_builtins/tests/unit/benchmarks/test_source_sample_helpers.py
new file mode 100644
index 000000000..3709e2e85
--- /dev/null
+++ b/ergon_builtins/tests/unit/benchmarks/test_source_sample_helpers.py
@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable
+from pathlib import Path
+
+from ergon_builtins.benchmarks.gdpeval.dataset import load_gdpeval_rows
+from ergon_builtins.benchmarks.gdpeval.sample import make_gdpeval_sample
+from ergon_builtins.benchmarks.gdpeval.task import GDPEvalTask
+from ergon_builtins.benchmarks.gdpeval.task_schemas import GDPTaskConfig
+from ergon_builtins.benchmarks.minif2f.dataset import load_minif2f_rows
+from ergon_builtins.benchmarks.minif2f.sample import make_minif2f_sample
+from ergon_builtins.benchmarks.minif2f.task import MiniF2FTask
+from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FProblem
+from ergon_builtins.benchmarks.researchrubrics.dataset import load_researchrubrics_rows
+from ergon_builtins.benchmarks.researchrubrics.sample import make_researchrubrics_sample
+from ergon_builtins.benchmarks.researchrubrics.task import ResearchRubricsTask
+from ergon_builtins.benchmarks.researchrubrics.task_schemas import (
+    ResearchRubricsTaskPayload,
+    RubricCriterion,
+)
+from ergon_builtins.benchmarks.swebench_verified.dataset import load_swebench_rows
+from ergon_builtins.benchmarks.swebench_verified.sample import make_swebench_sample
+from ergon_builtins.benchmarks.swebench_verified.task import SweBenchTask
+from ergon_builtins.benchmarks.swebench_verified.task_schemas import SWEBenchInstance
+from ergon_core.api.criterion import CriterionOutcome
+from ergon_core.api.rubric import Evaluator, TaskEvaluationResult
+from ergon_core.api.task import Task
+from ergon_core.test_support.task_factory import TestSandbox as SupportSandbox
+from ergon_core.test_support.task_factory import TestWorker as SupportWorker
+
+
+class EvaluatorStub(Evaluator):
+    type_slug = "test-evaluator"
+
+    def criteria_for(self, task: Task) -> Iterable:
+        return ()
+
+    def aggregate_task(
+        self,
+        task: Task,
+        criterion_results: Iterable[CriterionOutcome],
+    ) -> TaskEvaluationResult:
+        return TaskEvaluationResult(
+            task_slug=task.task_slug,
+            score=1.0,
+            passed=True,
+            evaluator_name=self.name,
+            criterion_results=list(criterion_results),
+        )
+
+
+class SelectableRows(list[dict[str, object]]):
+    def select(self, indexes: range) -> "SelectableRows":
+        return SelectableRows([self[index] for index in indexes])
+
+
+def test_load_minif2f_rows_reads_jsonl(monkeypatch, tmp_path: Path) -> None:
+    path = tmp_path / "mini.jsonl"
+    path.write_text(
+        "\n".join(
+            [
+                "",
+                json.dumps(
+                    {
+                        "name": "mini-1",
+                        "informal_statement": "Prove one equals one.",
+                        "formal_statement": "theorem mini_1 : 1 = 1 := by",
+                        "header": "import Mathlib\n",
+                    }
+                ),
+                json.dumps(
+                    {
+                        "name": "mini-2",
+                        "informal_statement": "Prove two equals two.",
+                        "formal_statement": "theorem mini_2 : 2 = 2 := by",
+                        "header": "import Mathlib\n",
+                    }
+                ),
+            ]
+        ),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(
+        "ergon_builtins.benchmarks.minif2f.dataset.hf_hub_download",
+        lambda **_: str(path),
+    )
+
+    rows = load_minif2f_rows(limit=1)
+
+    assert [row.name for row in rows] == ["mini-1"]
+
+
+def test_load_swebench_rows_normalizes_raw_rows(monkeypatch) -> None:
+    monkeypatch.setattr(
+        "ergon_builtins.benchmarks.swebench_verified.dataset.load_dataset",
+        lambda *_args, **_kwargs: SelectableRows(
+            [
+                {
+                    "instance_id": "swe-1",
+                    "repo": "org/repo",
+                    "base_commit": "abcdef123456",
+                    "problem_statement": "Fix the parser.",
+                    "hints_text": None,
+                    "version": "1.0",
+                    "FAIL_TO_PASS": '["tests/test_parser.py::test_fix"]',
+                    "PASS_TO_PASS": "[]",
+                    "test_patch": "diff --git a/tests/test_parser.py b/tests/test_parser.py\n",
+                }
+            ]
+        ),
+    )
+
+    rows = load_swebench_rows(limit=1)
+
+    assert rows[0].instance_id == "swe-1"
+    assert rows[0].hints_text == ""
+
+
+def test_load_researchrubrics_rows_builds_payloads(monkeypatch) -> None:
+    monkeypatch.setattr(
+        "ergon_builtins.benchmarks.researchrubrics.dataset.load_dataset",
+        lambda *_args, **_kwargs: {
+            "train": SelectableRows(
+                [
+                    {
+                        "sample_id": "research-1",
+                        "domain": "analysis",
+                        "prompt": "Write a concise analysis.",
+                        "rubrics": [
+                            {
+                                "criterion": "Has a conclusion.",
+                                "axis": "Communication Quality",
+                                "weight": 1.0,
+                            }
+                        ],
+                    }
+                ]
+            )
+        },
+    )
+
+    rows = load_researchrubrics_rows(limit=1)
+
+    assert rows[0].sample_id == "research-1"
+    assert rows[0].rubrics[0].criterion == "Has a conclusion."
+
+
+def test_load_gdpeval_rows_builds_task_configs(monkeypatch) -> None:
+    monkeypatch.setattr(
+        "ergon_builtins.benchmarks.gdpeval.dataset.load_task_ids",
+        lambda **_: ["gdp-1"],
+    )
+    monkeypatch.setattr(
+        "ergon_builtins.benchmarks.gdpeval.dataset.find_reference_files",
+        lambda *_args, **_kwargs: [Path("/tmp/reference.pdf")],
+    )
+
+    rows = load_gdpeval_rows(limit=1)
+
+    assert rows == [
+        GDPTaskConfig(
+            task_id="gdp-1",
+            workflow_type="document_processing",
+            reference_files=["/tmp/reference.pdf"],
+        )
+    ]
+
+
+def test_make_minif2f_sample_uses_resolved_components() -> None:
+    worker = SupportWorker(name="worker", model="test:none")
+    evaluator = EvaluatorStub(name="judge")
+    sandbox = SupportSandbox()
+
+    sample = make_minif2f_sample(
+        MiniF2FProblem(
+            name="mini-1",
+            informal_statement="Prove one equals one.",
+            formal_statement="theorem mini_1 : 1 = 1 := by",
+            header="import Mathlib\n",
+        ),
+        environment_name="minif2f",
+        worker=worker,
+        evaluators=[evaluator],
+        sandbox=sandbox,
+    )
+
+    assert sample.sample_key == "mini-1"
+    assert isinstance(sample.tasks[0], MiniF2FTask)
+    assert sample.tasks[0].worker is worker
+    assert sample.tasks[0].evaluators == (evaluator,)
+    assert sample.tasks[0].sandbox is sandbox
+
+
+def test_make_swebench_sample_uses_resolved_components() -> None:
+    worker = SupportWorker(name="worker", model="test:none")
+    evaluator = EvaluatorStub(name="judge")
+    sandbox = SupportSandbox()
+
+    sample = make_swebench_sample(
+        SWEBenchInstance(
+            instance_id="swe-1",
+            repo="org/repo",
+            base_commit="abcdef123456",
+            problem_statement="Fix the parser.",
+            version="1.0",
+            fail_to_pass=["tests/test_parser.py::test_fix"],
+            pass_to_pass=[],
+            environment_setup_commit="abcdef123456",
+            test_patch="diff --git a/tests/test_parser.py b/tests/test_parser.py\n",
+        ),
+        environment_name="swebench-verified",
+        worker=worker,
+        evaluators=[evaluator],
+        sandbox=sandbox,
+    )
+
+    assert sample.sample_key == "swe-1"
+    assert isinstance(sample.tasks[0], SweBenchTask)
+    assert sample.tasks[0].worker is worker
+    assert sample.tasks[0].evaluators == (evaluator,)
+    assert sample.tasks[0].sandbox is sandbox
+
+
+def test_make_researchrubrics_sample_uses_resolved_components() -> None:
+    worker = SupportWorker(name="worker", model="test:none")
+    evaluator = EvaluatorStub(name="judge")
+    sandbox = SupportSandbox()
+
+    sample = make_researchrubrics_sample(
+        ResearchRubricsTaskPayload(
+            sample_id="research-1",
+            domain="analysis",
+            prompt="Write a concise analysis.",
+            rubrics=[
+                RubricCriterion(
+                    criterion="Has a conclusion.",
+                    axis="Communication Quality",
+                    weight=1.0,
+                )
+            ],
+        ),
+        environment_name="researchrubrics",
+        worker=worker,
+        evaluators=[evaluator],
+        sandbox=sandbox,
+    )
+
+    assert sample.sample_key == "research-1"
+    assert isinstance(sample.tasks[0], ResearchRubricsTask)
+    assert sample.tasks[0].worker is worker
+    assert sample.tasks[0].evaluators == (evaluator,)
+    assert sample.tasks[0].sandbox is sandbox
+
+
+def test_make_gdpeval_sample_uses_resolved_components(monkeypatch) -> None:
+    worker = SupportWorker(name="worker", model="test:none")
+    evaluator = EvaluatorStub(name="judge")
+    sandbox = SupportSandbox()
+    monkeypatch.setattr(
+        "ergon_builtins.benchmarks.gdpeval.sample.extract_task_description",
+        lambda *_args, **_kwargs: "Process gdp-1.",
+    )
+
+    sample = make_gdpeval_sample(
+        GDPTaskConfig(
+            task_id="gdp-1",
+            workflow_type="document_processing",
+            reference_files=["/tmp/reference.pdf"],
+        ),
+        environment_name="gdpeval",
+        worker=worker,
+        evaluators=[evaluator],
+        sandbox=sandbox,
+    )
+
+    assert sample.sample_key == "gdp-1"
+    assert isinstance(sample.tasks[0], GDPEvalTask)
+    assert sample.tasks[0].description == "Process gdp-1."
+    assert sample.tasks[0].worker is worker
+    assert sample.tasks[0].evaluators == (evaluator,)
+    assert sample.tasks[0].sandbox is sandbox
diff --git a/ergon_builtins/tests/unit/benchmarks/test_swebench_criterion_patch_source.py b/ergon_builtins/tests/unit/benchmarks/test_swebench_criterion_patch_source.py
index 934bba639..7883d1378 100644
--- a/ergon_builtins/tests/unit/benchmarks/test_swebench_criterion_patch_source.py
+++ b/ergon_builtins/tests/unit/benchmarks/test_swebench_criterion_patch_source.py
@@ -16,7 +16,7 @@
 from ergon_builtins.benchmarks.swebench_verified.task_schemas import SWEBenchTaskPayload
 from ergon_core.api import WorkerOutput
 from ergon_core.api.criterion import CriterionContext
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.api.sandbox.runtime import CommandResult
 from ergon_core.test_support.task_factory import task_with_id
 
diff --git a/ergon_builtins/tests/unit/environments/conftest.py b/ergon_builtins/tests/unit/environments/conftest.py
index 18b3d7bc1..caeb19f5e 100644
--- a/ergon_builtins/tests/unit/environments/conftest.py
+++ b/ergon_builtins/tests/unit/environments/conftest.py
@@ -1,20 +1,24 @@
 from __future__ import annotations
 
-from collections.abc import Iterable, Iterator, Sequence
-from dataclasses import dataclass
+from collections.abc import Iterable, Sequence
 
 import pytest
 
+from ergon_builtins.benchmarks.gdpeval.sample import make_gdpeval_sample
 from ergon_builtins.benchmarks.gdpeval.task_schemas import GDPTaskConfig
+from ergon_builtins.benchmarks.minif2f.sample import make_minif2f_sample
 from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FProblem
+from ergon_builtins.benchmarks.researchrubrics.sample import make_researchrubrics_sample
 from ergon_builtins.benchmarks.researchrubrics.task_schemas import (
     ResearchRubricsTaskPayload,
     RubricCriterion,
 )
+from ergon_builtins.benchmarks.swebench_verified.sample import make_swebench_sample
 from ergon_builtins.benchmarks.swebench_verified.task_schemas import SWEBenchInstance
-from ergon_core.api.benchmark import Task
+from ergon_core.api import Environment
 from ergon_core.api.criterion import CriterionOutcome
 from ergon_core.api.rubric import Evaluator, TaskEvaluationResult
+from ergon_core.api.task import Task
 from ergon_core.test_support.task_factory import TestSandbox, TestWorker
 
 
@@ -38,17 +42,6 @@ def aggregate_task(
         )
 
 
-@dataclass(frozen=True)
-class FakeLoader:
-    rows: Sequence[object]
-
-    def iter_rows(self) -> Iterator[object]:
-        yield from self.rows
-
-    def load_rows(self) -> Sequence[object]:
-        return list(self.rows)
-
-
 class FakeSweBenchRow(SWEBenchInstance):
     needs_ui: bool = False
 
@@ -186,7 +179,7 @@ def fake_gdpeval_rows() -> list[GDPTaskConfig]:
     ]
 
 
-def make_fake_minif2f_environment(
+def build_row_backed_minif2f_environment(
     *,
     limit: int | None = None,
     worker: TestWorker | None = None,
@@ -194,18 +187,22 @@ def make_fake_minif2f_environment(
     sandbox: TestSandbox | None = None,
     rows: Sequence[MiniF2FProblem] | None = None,
 ):
-    from ergon_builtins.environments.minif2f import MiniF2FEnvironment
-
-    return MiniF2FEnvironment(
-        limit=limit,
-        loader=FakeLoader(rows or fake_minif2f_rows()),
-        worker=worker or TestWorker(name="worker", model="test:none"),
-        evaluators=evaluators or [TestEvaluator(name="judge")],
-        sandbox=sandbox or TestSandbox(),
+    selected_rows = list(rows or fake_minif2f_rows())[:limit]
+    env_name = "minif2f"
+    return Environment.from_records(
+        name=env_name,
+        records=selected_rows,
+        make_sample=lambda row: make_minif2f_sample(
+            row,
+            environment_name=env_name,
+            worker=worker or TestWorker(name="worker", model="test:none"),
+            evaluators=evaluators or [TestEvaluator(name="judge")],
+            sandbox=sandbox or TestSandbox(),
+        ),
     )
 
 
-def make_fake_swebench_environment(
+def build_row_backed_swebench_environment(
     *,
     limit: int | None = None,
     streaming: bool = False,
@@ -214,19 +211,32 @@ def make_fake_swebench_environment(
     sandbox=None,
     rows: Sequence[FakeSweBenchRow] | None = None,
 ):
-    from ergon_builtins.environments.swebench_verified import SweBenchVerifiedEnvironment
-
-    return SweBenchVerifiedEnvironment(
-        limit=limit,
-        streaming=streaming,
-        loader=FakeLoader(rows or fake_swebench_rows()),
-        worker=worker or TestWorker(name="worker", model="test:none"),
-        evaluators=evaluators or [TestEvaluator(name="judge")],
-        sandbox=sandbox or TestSandbox(),
-    )
+    selected_rows = list(rows or fake_swebench_rows())[:limit]
+    env_name = "swebench-verified"
+
+    def make_sample(row: FakeSweBenchRow):
+        resolved_worker = worker(row) if callable(worker) else worker
+        resolved_evaluators = evaluators(row) if callable(evaluators) else evaluators
+        resolved_sandbox = sandbox(row) if callable(sandbox) else sandbox
+        return make_swebench_sample(
+            row,
+            environment_name=env_name,
+            worker=resolved_worker or TestWorker(name="worker", model="test:none"),
+            evaluators=resolved_evaluators or [TestEvaluator(name="judge")],
+            sandbox=resolved_sandbox or TestSandbox(),
+        )
+
+    if streaming:
+        return Environment.from_dataset(
+            name=env_name,
+            dataset=iter(selected_rows),
+            source_mode="streaming",
+            make_sample=make_sample,
+        )
+    return Environment.from_records(name=env_name, records=selected_rows, make_sample=make_sample)
 
 
-def make_fake_researchrubrics_environment(
+def build_row_backed_researchrubrics_environment(
     *,
     limit: int | None = None,
     worker: TestWorker | None = None,
@@ -234,18 +244,22 @@ def make_fake_researchrubrics_environment(
     sandbox: TestSandbox | None = None,
     rows: Sequence[ResearchRubricsTaskPayload] | None = None,
 ):
-    from ergon_builtins.environments.researchrubrics import ResearchRubricsEnvironment
-
-    return ResearchRubricsEnvironment(
-        limit=limit,
-        loader=FakeLoader(rows or fake_researchrubrics_rows()),
-        worker=worker or TestWorker(name="worker", model="test:none"),
-        evaluators=evaluators or [TestEvaluator(name="judge")],
-        sandbox=sandbox or TestSandbox(),
+    selected_rows = list(rows or fake_researchrubrics_rows())[:limit]
+    env_name = "researchrubrics"
+    return Environment.from_records(
+        name=env_name,
+        records=selected_rows,
+        make_sample=lambda row: make_researchrubrics_sample(
+            row,
+            environment_name=env_name,
+            worker=worker or TestWorker(name="worker", model="test:none"),
+            evaluators=evaluators or [TestEvaluator(name="judge")],
+            sandbox=sandbox or TestSandbox(),
+        ),
     )
 
 
-def make_fake_gdpeval_environment(
+def build_row_backed_gdpeval_environment(
     *,
     limit: int | None = None,
     worker: TestWorker | None = None,
@@ -253,33 +267,37 @@ def make_fake_gdpeval_environment(
     sandbox: TestSandbox | None = None,
     rows: Sequence[GDPTaskConfig] | None = None,
 ):
-    from ergon_builtins.environments.gdpeval import GDPEvalEnvironment
-
-    return GDPEvalEnvironment(
-        limit=limit,
-        loader=FakeLoader(rows or fake_gdpeval_rows()),
-        task_description=lambda row: f"Process {row.task_id}.",
-        worker=worker or TestWorker(name="worker", model="test:none"),
-        evaluators=evaluators or [TestEvaluator(name="judge")],
-        sandbox=sandbox or TestSandbox(),
+    selected_rows = list(rows or fake_gdpeval_rows())[:limit]
+    env_name = "gdpeval"
+    return Environment.from_records(
+        name=env_name,
+        records=selected_rows,
+        make_sample=lambda row: make_gdpeval_sample(
+            row,
+            environment_name=env_name,
+            worker=worker or TestWorker(name="worker", model="test:none"),
+            evaluators=evaluators or [TestEvaluator(name="judge")],
+            sandbox=sandbox or TestSandbox(),
+            task_description=lambda config: f"Process {config.task_id}.",
+        ),
     )
 
 
 @pytest.fixture
 def minif2f_environment_factory():
-    return make_fake_minif2f_environment
+    return build_row_backed_minif2f_environment
 
 
 @pytest.fixture
 def swebench_environment_factory():
-    return make_fake_swebench_environment
+    return build_row_backed_swebench_environment
 
 
 @pytest.fixture
 def researchrubrics_environment_factory():
-    return make_fake_researchrubrics_environment
+    return build_row_backed_researchrubrics_environment
 
 
 @pytest.fixture
 def gdpeval_environment_factory():
-    return make_fake_gdpeval_environment
+    return build_row_backed_gdpeval_environment
diff --git a/ergon_builtins/tests/unit/environments/test_environment_exports.py b/ergon_builtins/tests/unit/environments/test_environment_exports.py
index d49982028..f5285257b 100644
--- a/ergon_builtins/tests/unit/environments/test_environment_exports.py
+++ b/ergon_builtins/tests/unit/environments/test_environment_exports.py
@@ -1,22 +1,19 @@
 from __future__ import annotations
 
 
-def test_all_builtin_environment_exports_exist() -> None:
-    from ergon_builtins.environments import (
-        GDPEvalEnvironment,
-        MiniF2FEnvironment,
-        ResearchRubricsEnvironment,
-        SweBenchVerifiedEnvironment,
-    )
+def test_builtin_environment_classes_are_not_exported() -> None:
+    import ergon_builtins.environments as environments
 
-    assert MiniF2FEnvironment.__name__ == "MiniF2FEnvironment"
-    assert SweBenchVerifiedEnvironment.__name__ == "SweBenchVerifiedEnvironment"
-    assert ResearchRubricsEnvironment.__name__ == "ResearchRubricsEnvironment"
-    assert GDPEvalEnvironment.__name__ == "GDPEvalEnvironment"
+    exported = set(dir(environments))
+
+    assert "MiniF2FEnvironment" not in exported
+    assert "SweBenchVerifiedEnvironment" not in exported
+    assert "ResearchRubricsEnvironment" not in exported
+    assert "GDPEvalEnvironment" not in exported
 
 
 def test_legacy_benchmark_composition_is_not_exported_from_catalog() -> None:
-    from ergon_builtins.benchmarks import catalog
+    from ergon_builtins.environments import catalog
 
     exported = set(dir(catalog))
 
diff --git a/ergon_builtins/tests/unit/environments/test_gdpeval_environment.py b/ergon_builtins/tests/unit/environments/test_gdpeval_environment.py
index 8e31bbf50..7c3ce20bc 100644
--- a/ergon_builtins/tests/unit/environments/test_gdpeval_environment.py
+++ b/ergon_builtins/tests/unit/environments/test_gdpeval_environment.py
@@ -2,7 +2,7 @@
 
 import json
 
-from ergon_builtins.benchmarks.gdpeval.benchmark import GDPEvalTask
+from ergon_builtins.benchmarks.gdpeval.task import GDPEvalTask
 from ergon_builtins.benchmarks.gdpeval.task_schemas import GDPTaskConfig
 from ergon_core.api import Sample
 
diff --git a/ergon_builtins/tests/unit/environments/test_minif2f_environment.py b/ergon_builtins/tests/unit/environments/test_minif2f_environment.py
index 4325872c8..1ad6b339f 100644
--- a/ergon_builtins/tests/unit/environments/test_minif2f_environment.py
+++ b/ergon_builtins/tests/unit/environments/test_minif2f_environment.py
@@ -2,7 +2,7 @@
 
 import json
 
-from ergon_builtins.benchmarks.minif2f.benchmark import MiniF2FTask
+from ergon_builtins.benchmarks.minif2f.task import MiniF2FTask
 from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FTaskPayload
 from ergon_core.api import Sample
 
diff --git a/ergon_builtins/tests/unit/environments/test_researchrubrics_environment.py b/ergon_builtins/tests/unit/environments/test_researchrubrics_environment.py
index f93e60f41..f60c9642c 100644
--- a/ergon_builtins/tests/unit/environments/test_researchrubrics_environment.py
+++ b/ergon_builtins/tests/unit/environments/test_researchrubrics_environment.py
@@ -2,7 +2,7 @@
 
 import json
 
-from ergon_builtins.benchmarks.researchrubrics.benchmark import ResearchRubricsTask
+from ergon_builtins.benchmarks.researchrubrics.task import ResearchRubricsTask
 from ergon_builtins.benchmarks.researchrubrics.task_schemas import ResearchRubricsTaskPayload
 from ergon_core.api import Sample
 
diff --git a/ergon_builtins/tests/unit/environments/test_swebench_verified_environment.py b/ergon_builtins/tests/unit/environments/test_swebench_verified_environment.py
index f0b216d8b..342132edc 100644
--- a/ergon_builtins/tests/unit/environments/test_swebench_verified_environment.py
+++ b/ergon_builtins/tests/unit/environments/test_swebench_verified_environment.py
@@ -5,7 +5,7 @@
 
 import pytest
 
-from ergon_builtins.benchmarks.swebench_verified.benchmark import SweBenchTask
+from ergon_builtins.benchmarks.swebench_verified.task import SweBenchTask
 from ergon_builtins.benchmarks.swebench_verified.task_schemas import (
     SWEBenchInstance,
     SWEBenchTaskPayload,
diff --git a/ergon_builtins/tests/unit/state/test_benchmark_contract.py b/ergon_builtins/tests/unit/state/test_benchmark_contract.py
deleted file mode 100644
index 4bc6e4acc..000000000
--- a/ergon_builtins/tests/unit/state/test_benchmark_contract.py
+++ /dev/null
@@ -1,80 +0,0 @@
-"""Contracts for object-bound built-in benchmark classes."""
-
-import pytest
-from ergon_builtins.benchmarks.minif2f.benchmark import MiniF2FBenchmark
-from ergon_builtins.benchmarks.researchrubrics.benchmark import ResearchRubricsBenchmark
-from ergon_builtins.benchmarks.swebench_verified.benchmark import SweBenchVerifiedBenchmark
-from ergon_core.api.benchmark import Benchmark, EmptyTaskPayload, Task
-from pydantic import BaseModel, ValidationError
-from ergon_core.test_support.task_factory import TestSandbox, TestWorker
-
-CORE_BENCHMARKS = {
-    MiniF2FBenchmark.type_slug: MiniF2FBenchmark,
-    SweBenchVerifiedBenchmark.type_slug: SweBenchVerifiedBenchmark,
-}
-
-DATA_BENCHMARKS = {
-    ResearchRubricsBenchmark.type_slug: ResearchRubricsBenchmark,
-}
-
-
-class TestBenchmarkDependencyMetadataContract:
-    """Every importable benchmark exposes current runtime dependency metadata."""
-
-    @pytest.mark.parametrize("slug, cls", [*CORE_BENCHMARKS.items(), *DATA_BENCHMARKS.items()])
-    def test_benchmarks_declare_payload_models(self, slug: str, cls: type[Benchmark]) -> None:
-        assert issubclass(cls.task_payload_model, BaseModel), (
-            f"Benchmark '{slug}' ({cls.__qualname__}) must declare a Pydantic task_payload_model."
-        )
-
-    @pytest.mark.parametrize("slug, cls", [*CORE_BENCHMARKS.items(), *DATA_BENCHMARKS.items()])
-    def test_required_packages_are_plain_strings(self, slug: str, cls: type[Benchmark]) -> None:
-        assert isinstance(cls.required_packages, list), (
-            f"Benchmark '{slug}' ({cls.__qualname__}).required_packages must be a list."
-        )
-        assert all(isinstance(package, str) for package in cls.required_packages), (
-            f"Benchmark '{slug}' ({cls.__qualname__}).required_packages must contain strings."
-        )
-
-    def test_data_benchmarks_with_package_deps_include_install_hint(self) -> None:
-        for cls in DATA_BENCHMARKS.values():
-            if cls.required_packages:
-                assert cls.install_hint
-
-
-class TestBenchmarkSubclassEnforcement:
-    def test_base_class_does_not_validate_subclasses_at_import_time(self) -> None:
-        class LocalBenchmark(Benchmark):
-            type_slug = "local-test"
-
-            def build_instances(self) -> dict[str, list[Task[EmptyTaskPayload]]]:
-                return {}
-
-        assert LocalBenchmark.type_slug == "local-test"
-        assert LocalBenchmark.task_payload_model is EmptyTaskPayload
-
-
-class TestTaskPayloadContract:
-    def test_task_payload_is_a_pydantic_model(self) -> None:
-        payload = EmptyTaskPayload()
-        task = Task(
-            task_slug="task",
-            instance_key="default",
-            description="desc",
-            task_payload=payload,
-            worker=TestWorker(name="worker", model="test:none"),
-            sandbox=TestSandbox(),
-        )
-
-        assert task.task_payload is payload
-
-    def test_plain_dict_payload_is_rejected(self) -> None:
-        with pytest.raises(ValidationError):
-            Task(
-                task_slug="task",
-                instance_key="default",
-                description="desc",
-                task_payload={"loose": "dict"},
-                worker=TestWorker(name="worker", model="test:none"),
-                sandbox=TestSandbox(),
-            )
diff --git a/ergon_builtins/tests/unit/state/test_gdpeval_benchmark.py b/ergon_builtins/tests/unit/state/test_gdpeval_benchmark.py
deleted file mode 100644
index f1afbf7c0..000000000
--- a/ergon_builtins/tests/unit/state/test_gdpeval_benchmark.py
+++ /dev/null
@@ -1,53 +0,0 @@
-"""Tests for GDPEval benchmark task materialization."""
-
-from pathlib import Path
-
-from ergon_builtins.benchmarks.gdpeval.benchmark import GDPEvalBenchmark
-from ergon_builtins.benchmarks.gdpeval.task_schemas import GDPTaskConfig
-
-
-def test_load_task_configs_returns_typed_payloads(monkeypatch):
-    monkeypatch.setattr(
-        "ergon_builtins.benchmarks.gdpeval.benchmark.load_task_ids",
-        lambda split, repo_id, limit: ["task_001"],
-    )
-    monkeypatch.setattr(
-        "ergon_builtins.benchmarks.gdpeval.benchmark.find_reference_files",
-        lambda task_id, repo_id: [Path("/tmp/reference.pdf")],
-    )
-
-    benchmark = GDPEvalBenchmark(dataset_repo="fake/repo", split="train", limit=1)
-
-    assert benchmark._load_task_configs() == [
-        GDPTaskConfig(
-            task_id="task_001",
-            workflow_type="document_processing",
-            reference_files=["/tmp/reference.pdf"],
-        )
-    ]
-
-
-def test_build_instances_uses_typed_payloads(monkeypatch):
-    monkeypatch.setattr(
-        GDPEvalBenchmark,
-        "_load_task_configs",
-        lambda self: [
-            GDPTaskConfig(
-                task_id="task_001",
-                workflow_type="document_processing",
-                reference_files=["/tmp/reference.pdf"],
-            )
-        ],
-    )
-    monkeypatch.setattr(
-        "ergon_builtins.benchmarks.gdpeval.benchmark.extract_task_description",
-        lambda task_id, repo_id: "Process the reference document.",
-    )
-
-    task = GDPEvalBenchmark(dataset_repo="fake/repo").build_instances()["default"][0]
-
-    assert task.task_payload == GDPTaskConfig(
-        task_id="task_001",
-        workflow_type="document_processing",
-        reference_files=["/tmp/reference.pdf"],
-    )
diff --git a/ergon_builtins/tests/unit/state/test_research_rubrics_benchmark.py b/ergon_builtins/tests/unit/state/test_research_rubrics_benchmark.py
deleted file mode 100644
index 3d908c471..000000000
--- a/ergon_builtins/tests/unit/state/test_research_rubrics_benchmark.py
+++ /dev/null
@@ -1,327 +0,0 @@
-"""Tests for ResearchRubrics benchmark registration and vanilla variant."""
-
-from datetime import UTC, datetime
-from pathlib import Path
-from uuid import uuid4
-
-import pytest
-from pydantic import ValidationError
-from ergon_builtins.benchmarks.researchrubrics.benchmark import ResearchRubricsBenchmark
-from ergon_builtins.benchmarks.researchrubrics.criteria.judge import (
-    ResearchRubricsJudgeCriterion,
-)
-from ergon_builtins.benchmarks.researchrubrics.rubric import ResearchRubricsRubric
-from ergon_builtins.benchmarks.researchrubrics.task_schemas import (
-    ResearchRubricsTaskPayload,
-    RubricCriterion,
-)
-from ergon_builtins.benchmarks.researchrubrics.vanilla import ResearchRubricsVanillaBenchmark
-from ergon_core.api import Benchmark
-from ergon_core.api.criterion import CriterionContext
-from ergon_core.api.criterion import CriterionOutcome
-from ergon_core.api.worker import WorkerOutput
-from ergon_core.core.application.resources import SampleResourceView
-from ergon_core.core.persistence.shared.enums import SampleResourceKind
-from ergon_core.api.benchmark import Task
-from ergon_core.test_support.task_factory import task_with_id
-
-
-def _resource_view(
-    *,
-    kind: SampleResourceKind,
-    name: str,
-    sandbox_origin: str,
-    text: str,
-) -> tuple[SampleResourceView, bytes]:
-    resource_id = uuid4()
-    return (
-        SampleResourceView(
-            id=resource_id,
-            sample_id=uuid4(),
-            task_attempt_id=uuid4(),
-            kind=kind,
-            name=name,
-            mime_type="text/markdown",
-            file_path=f"/durable/{resource_id}",
-            size_bytes=len(text.encode()),
-            content_hash=None,
-            error=None,
-            metadata={"sandbox_origin": sandbox_origin},
-            created_at=datetime.now(UTC),
-        ),
-        text.encode(),
-    )
-
-
-class TestResearchRubricsBenchmarkRegistration:
-    """Verify benchmark classes expose the final object-bound surface."""
-
-    def test_researchrubrics_type_slug(self):
-        assert ResearchRubricsBenchmark.type_slug == "researchrubrics"
-        assert issubclass(ResearchRubricsBenchmark, Benchmark)
-
-    def test_researchrubrics_vanilla_type_slug(self):
-        assert ResearchRubricsVanillaBenchmark.type_slug == "researchrubrics-vanilla"
-        assert issubclass(ResearchRubricsVanillaBenchmark, Benchmark)
-
-    def test_rubric_type_slug(self):
-        assert ResearchRubricsRubric.type_slug == "researchrubrics-rubric"
-
-
-class TestResearchRubricsVanillaBenchmark:
-    """Verify the vanilla benchmark subclass."""
-
-    def test_vanilla_type_slug(self):
-        assert ResearchRubricsVanillaBenchmark.type_slug == "researchrubrics-vanilla"
-
-    def test_vanilla_uses_scaleai_dataset(self):
-        # Construction should set dataset_name to ScaleAI's
-        benchmark = ResearchRubricsVanillaBenchmark(limit=1)
-        assert benchmark.dataset_name == "ScaleAI/researchrubrics"
-        assert benchmark.name == "researchrubrics-vanilla"
-
-
-class TestResearchRubricsDatasetLoading:
-    def test_load_rows_returns_typed_payloads(self, monkeypatch: pytest.MonkeyPatch):
-        class FakeTrainDataset:
-            def __len__(self):
-                return 1
-
-            def __getitem__(self, idx):
-                assert idx == 0
-                return {
-                    "sample_id": "sample",
-                    "domain": "quality",
-                    "prompt": "Write a report.",
-                    "rubrics": [
-                        {"criterion": "Includes citations.", "axis": "quality", "weight": 2.0},
-                    ],
-                }
-
-        monkeypatch.setattr(
-            "ergon_builtins.benchmarks.researchrubrics.benchmark.load_dataset",
-            lambda *args, **kwargs: {"train": FakeTrainDataset()},
-        )
-
-        rows = ResearchRubricsBenchmark()._load_rows()
-
-        assert rows == [
-            ResearchRubricsTaskPayload(
-                sample_id="sample",
-                domain="quality",
-                prompt="Write a report.",
-                rubrics=[{"criterion": "Includes citations.", "axis": "quality", "weight": 2.0}],
-            )
-        ]
-
-    def test_default_dataset_is_official_scaleai_dataset(self):
-        benchmark = ResearchRubricsBenchmark(limit=1)
-
-        assert benchmark.dataset_name == "ScaleAI/researchrubrics"
-
-
-class TestResearchRubricsRubric:
-    """Verify task-payload-driven rubric construction."""
-
-    def test_can_construct_without_prebound_criteria(self):
-        rubric = ResearchRubricsRubric(name="evaluator")
-        task = task_with_id(
-            uuid4(),
-            cls=Task[ResearchRubricsTaskPayload],
-            task_slug="sample",
-            instance_key="default",
-            description="Write a report.",
-            task_payload=ResearchRubricsTaskPayload.model_validate(
-                {
-                    "sample_id": "sample",
-                    "domain": "quality",
-                    "prompt": "Write a report.",
-                    "rubrics": [
-                        {"criterion": "Includes citations.", "axis": "quality", "weight": 2.0},
-                        {"criterion": "No unsupported claims.", "axis": "quality", "weight": -1.0},
-                    ],
-                }
-            ),
-        )
-
-        criteria = list(rubric.criteria_for(task))
-
-        assert [criterion.weight for criterion in criteria] == [2.0, -1.0]
-        assert [criterion.score_spec.max_score for criterion in criteria] == [2.0, 1.0]
-        assert [criterion.description for criterion in criteria] == [
-            "Includes citations.",
-            "No unsupported claims.",
-        ]
-        assert [type(criterion).__name__ for criterion in criteria] == [
-            "ResearchRubricsJudgeCriterion",
-            "ResearchRubricsJudgeCriterion",
-        ]
-        assert "ResearchRubrics" in criteria[0].system_prompt
-        assert "Includes citations." in criteria[0].system_prompt
-
-    def test_aggregate_uses_result_weights(self):
-        rubric = ResearchRubricsRubric(name="evaluator")
-        task = task_with_id(
-            uuid4(),
-            task_slug="sample",
-            instance_key="default",
-            description="Write a report.",
-        )
-
-        result = rubric.aggregate_task(
-            task,
-            [
-                CriterionOutcome(
-                    slug="positive",
-                    name="positive",
-                    score=1.0,
-                    passed=True,
-                    weight=2.0,
-                ),
-                CriterionOutcome(
-                    slug="negative",
-                    name="negative",
-                    score=0.0,
-                    passed=False,
-                    weight=-1.0,
-                ),
-            ],
-        )
-
-        assert result.score == 1.0
-        assert result.metadata == {
-            "total_score": 2.0,
-            "score_scale": "normalized_0_1",
-            "raw_score": 2.0,
-            "max_possible": 2.0,
-            "min_possible": -1.0,
-        }
-
-
-class TestResearchRubricsJudgeCriterion:
-    def test_defaults_from_rubric_without_constructor_override(self) -> None:
-        rubric = RubricCriterion(
-            criterion="Includes findings",
-            axis="quality",
-            weight=2.0,
-        )
-
-        criterion = ResearchRubricsJudgeCriterion(
-            slug="includes_findings",
-            rubric=rubric,
-        )
-
-        assert criterion.description == "Includes findings"
-        assert criterion.weight == 2.0
-        assert criterion.score_spec.max_score == 2.0
-        assert criterion.rubric_text == "Includes findings"
-
-    @pytest.mark.asyncio
-    async def test_judge_prioritizes_final_resources_over_final_message(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-        tmp_path: Path,
-    ) -> None:
-        final_resource, final_blob = _resource_view(
-            kind=SampleResourceKind.REPORT,
-            name="report.md",
-            sandbox_origin="/workspace/final_output/report.md",
-            text="# Final report\nThis is the primary answer artifact.",
-        )
-        scratch_resource, scratch_blob = _resource_view(
-            kind=SampleResourceKind.NOTE,
-            name="notes.md",
-            sandbox_origin="/workspace/notes.md",
-            text="scratch notes",
-        )
-        final_path = tmp_path / "report.md"
-        final_path.write_bytes(final_blob)
-        scratch_path = tmp_path / "notes.md"
-        scratch_path.write_bytes(scratch_blob)
-        final_resource = final_resource.model_copy(update={"file_path": str(final_path)})
-        scratch_resource = scratch_resource.model_copy(update={"file_path": str(scratch_path)})
-        captured_user_prompts: list[str] = []
-
-        context = CriterionContext(
-            sample_id=uuid4(),
-            task_id=uuid4(),
-            execution_id=uuid4(),
-            task=task_with_id(
-                uuid4(),
-                task_slug="sample",
-                instance_key="default",
-                description="Write a report.",
-            ),
-            worker_result=WorkerOutput(output="assistant summary only"),
-            metadata={"resources": [scratch_resource, final_resource]},
-        )
-
-        class Criterion(ResearchRubricsJudgeCriterion):
-            async def _call_judge(self, *, system_prompt: str, user_prompt: str):
-                captured_user_prompts.append(user_prompt)
-                from ergon_builtins.benchmarks.researchrubrics.criteria.judge import (
-                    ResearchRubricsVerdict,
-                )
-
-                return ResearchRubricsVerdict(
-                    passed=True,
-                    reasoning="The final report satisfies the criterion.",
-                )
-
-        criterion = Criterion(
-            slug="includes_findings",
-            rubric=RubricCriterion(
-                criterion="Includes findings",
-                axis="quality",
-                weight=1.0,
-            ),
-        )
-
-        result = await criterion.evaluate(context)
-
-        assert result.evaluated_resource_ids == [
-            str(final_resource.id),
-            str(scratch_resource.id),
-        ]
-        assert result.slug == "includes_findings"
-        assert result.observation is not None
-        assert result.observation.evidence_resource_ids == result.evaluated_resource_ids
-        assert result.observation.output == {
-            "passed": True,
-            "reasoning": "The final report satisfies the criterion.",
-        }
-        assert result.evaluation_input is not None
-        assert "Final output resources" in result.evaluation_input
-        assert "Scratch / supporting resources" in result.evaluation_input
-        assert "Final assistant message" in result.evaluation_input
-        assert len(captured_user_prompts) == 1
-        assert "This is the primary answer artifact." in captured_user_prompts[0]
-        assert "assistant summary only" in captured_user_prompts[0]
-
-    def test_rejects_model_alias(self) -> None:
-        with pytest.raises(ValidationError, match="model"):
-            ResearchRubricsJudgeCriterion.model_validate(
-                {
-                    "slug": "includes_findings",
-                    "rubric": {
-                        "criterion": "Includes findings",
-                        "axis": "quality",
-                        "weight": 1.0,
-                    },
-                    "model": "openai:gpt-4o-mini",
-                }
-            )
-
-    def test_does_not_expose_model_alias(self) -> None:
-        criterion = ResearchRubricsJudgeCriterion(
-            slug="includes_findings",
-            rubric=RubricCriterion(
-                criterion="Includes findings",
-                axis="quality",
-                weight=1.0,
-            ),
-            judge_model="openai:gpt-4o-mini",
-        )
-
-        assert criterion.judge_model == "openai:gpt-4o-mini"
-        assert not hasattr(criterion, "model")
diff --git a/ergon_builtins/tests/unit/test_builtin_task_definition_roundtrip.py b/ergon_builtins/tests/unit/test_builtin_task_definition_roundtrip.py
index 77df70292..6a07a5f50 100644
--- a/ergon_builtins/tests/unit/test_builtin_task_definition_roundtrip.py
+++ b/ergon_builtins/tests/unit/test_builtin_task_definition_roundtrip.py
@@ -5,44 +5,82 @@
 
 import pytest
 
-from ergon_builtins.benchmarks.gdpeval.benchmark import GDPEvalBenchmark
+from ergon_builtins.agents.react.worker import ReActWorker
+from ergon_builtins.benchmarks.gdpeval.prompts import GDPEVAL_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.gdpeval.rubric import StagedRubric
+from ergon_builtins.benchmarks.gdpeval.sandbox import GDPEvalSandbox
+from ergon_builtins.benchmarks.gdpeval.sample import make_gdpeval_sample
 from ergon_builtins.benchmarks.gdpeval.task_schemas import GDPTaskConfig
-from ergon_builtins.benchmarks.minif2f.benchmark import MiniF2FBenchmark
+from ergon_builtins.benchmarks.gdpeval.toolkit import GDPEvalToolkit
+from ergon_builtins.benchmarks.minif2f.prompts import MINIF2F_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.minif2f.rubric import MiniF2FRubric
+from ergon_builtins.benchmarks.minif2f.sandbox import LeanSandbox
+from ergon_builtins.benchmarks.minif2f.sample import make_minif2f_sample
 from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FProblem
-from ergon_builtins.benchmarks.researchrubrics.benchmark import ResearchRubricsBenchmark
+from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
+from ergon_builtins.benchmarks.researchrubrics.prompts import RESEARCH_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.researchrubrics.rubric import ResearchRubricsRubric
+from ergon_builtins.benchmarks.researchrubrics.sandbox import ResearchE2BSandbox
+from ergon_builtins.benchmarks.researchrubrics.sample import make_researchrubrics_sample
 from ergon_builtins.benchmarks.researchrubrics.task_schemas import (
     ResearchRubricsTaskPayload,
     RubricCriterion,
 )
-from ergon_builtins.benchmarks.swebench_verified.benchmark import SweBenchVerifiedBenchmark
+from ergon_builtins.benchmarks.researchrubrics.toolkit import ResearchRubricsToolkit
+from ergon_builtins.benchmarks.swebench_verified.prompts import SWEBENCH_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.swebench_verified.rubric import SWEBenchRubric
+from ergon_builtins.benchmarks.swebench_verified.sandbox import SWEBenchSandbox
+from ergon_builtins.benchmarks.swebench_verified.sample import make_swebench_sample
 from ergon_builtins.benchmarks.swebench_verified.task_schemas import SWEBenchInstance
-from ergon_core.api.benchmark.task import Task
+from ergon_builtins.benchmarks.swebench_verified.toolkit import SWEBenchToolkit
+from ergon_core.api.task import Task
 from ergon_core.api.rubric import Rubric
 
 
-def _only_task(benchmark) -> Task:
-    instances = benchmark.build_instances()
-    return list(instances.values())[0][0]
-
-
 @pytest.fixture
-def builtin_tasks(monkeypatch: pytest.MonkeyPatch) -> Sequence[Task]:
-    monkeypatch.setattr(
-        MiniF2FBenchmark,
-        "_load_problems",
-        lambda self: [
+def builtin_tasks() -> Sequence[Task]:
+    mini_worker = ReActWorker(
+        name="mini-proof-solver",
+        model="test:none",
+        system_prompt=MINIF2F_SYSTEM_PROMPT,
+        max_iterations=30,
+        toolkit=MiniF2FToolkit(),
+    )
+    swe_worker = ReActWorker(
+        name="swebench-solver",
+        model="test:none",
+        system_prompt=SWEBENCH_SYSTEM_PROMPT,
+        max_iterations=50,
+        toolkit=SWEBenchToolkit(),
+    )
+    research_worker = ReActWorker(
+        name="research-runner",
+        model="test:none",
+        system_prompt=RESEARCH_SYSTEM_PROMPT,
+        max_iterations=16,
+        toolkit=ResearchRubricsToolkit(),
+    )
+    gdp_worker = ReActWorker(
+        name="gdpeval-runner",
+        model="test:none",
+        system_prompt=GDPEVAL_SYSTEM_PROMPT,
+        max_iterations=40,
+        toolkit=GDPEvalToolkit(),
+    )
+    return (
+        make_minif2f_sample(
             MiniF2FProblem(
                 name="mini-sample",
                 informal_statement="Prove that one equals one.",
                 formal_statement="theorem mini_sample : 1 = 1 := by",
                 header="import Mathlib\n",
-            )
-        ],
-    )
-
-    monkeypatch.setattr(
-        "ergon_builtins.benchmarks.swebench_verified.benchmark._load_rows",
-        lambda *, limit=None: [
+            ),
+            environment_name="minif2f",
+            worker=mini_worker,
+            evaluators=[MiniF2FRubric(name="minif2f-rubric")],
+            sandbox=LeanSandbox(),
+        ).tasks[0],
+        make_swebench_sample(
             SWEBenchInstance(
                 instance_id="repo__sample-1",
                 repo="org/repo",
@@ -53,14 +91,13 @@ def builtin_tasks(monkeypatch: pytest.MonkeyPatch) -> Sequence[Task]:
                 pass_to_pass=[],
                 environment_setup_commit="abcdef123456",
                 test_patch="diff --git a/tests/test_parser.py b/tests/test_parser.py\n",
-            )
-        ],
-    )
-
-    monkeypatch.setattr(
-        ResearchRubricsBenchmark,
-        "_load_rows",
-        lambda self: [
+            ),
+            environment_name="swebench-verified",
+            worker=swe_worker,
+            evaluators=[SWEBenchRubric(name="swebench-rubric")],
+            sandbox=SWEBenchSandbox(),
+        ).tasks[0],
+        make_researchrubrics_sample(
             ResearchRubricsTaskPayload(
                 sample_id="rr-sample-1",
                 domain="quality",
@@ -72,31 +109,30 @@ def builtin_tasks(monkeypatch: pytest.MonkeyPatch) -> Sequence[Task]:
                         weight=2.0,
                     )
                 ],
-            )
-        ],
-    )
-
-    monkeypatch.setattr(
-        GDPEvalBenchmark,
-        "_load_task_configs",
-        lambda self: [
+            ),
+            environment_name="researchrubrics",
+            worker=research_worker,
+            evaluators=[ResearchRubricsRubric(name="researchrubrics-rubric")],
+            sandbox=ResearchE2BSandbox(),
+        ).tasks[0],
+        make_gdpeval_sample(
             GDPTaskConfig(
                 task_id="gdp-sample-1",
                 workflow_type="document_processing",
                 reference_files=["/tmp/reference.pdf"],
-            )
-        ],
-    )
-    monkeypatch.setattr(
-        "ergon_builtins.benchmarks.gdpeval.benchmark.extract_task_description",
-        lambda task_id, *, repo_id: "Create a summary document.",
-    )
-
-    return (
-        _only_task(MiniF2FBenchmark(limit=1)),
-        _only_task(SweBenchVerifiedBenchmark(limit=1)),
-        _only_task(ResearchRubricsBenchmark(limit=1)),
-        _only_task(GDPEvalBenchmark(limit=1)),
+            ),
+            environment_name="gdpeval",
+            worker=gdp_worker,
+            evaluators=[
+                StagedRubric(
+                    name="gdpeval-staged-rubric",
+                    category_name="default",
+                    max_total_score=1.0,
+                )
+            ],
+            sandbox=GDPEvalSandbox(),
+            task_description=lambda _row: "Create a summary document.",
+        ).tasks[0],
     )
 
 
diff --git a/ergon_builtins/tests/unit/test_gdpeval_v2_definition.py b/ergon_builtins/tests/unit/test_gdpeval_v2_definition.py
deleted file mode 100644
index 854d6417a..000000000
--- a/ergon_builtins/tests/unit/test_gdpeval_v2_definition.py
+++ /dev/null
@@ -1,147 +0,0 @@
-"""GDPEval v2 authoring shape: task JSON definition + reconstruction.
-
-PR 10c: assert ``GDPEvalBenchmark`` returns ``Task`` instances that
-serialize to the object-bound JSON shape (``_type`` on worker, sandbox,
-every evaluator entry, no ``_legacy`` marker) and that the snapshot
-round-trips through ``Task.from_definition``.
-
-The benchmark's ``build_instances`` hits HuggingFace by default; we
-monkeypatch ``_load_task_configs`` plus the ``extract_task_description``
-loader call so the unit test stays offline.
-"""
-
-from __future__ import annotations
-
-from unittest.mock import patch
-from uuid import uuid4
-
-import pytest
-
-from ergon_builtins.benchmarks.gdpeval.benchmark import GDPEvalBenchmark
-from ergon_builtins.benchmarks.gdpeval.sandbox import GDPEvalSandbox
-from ergon_builtins.benchmarks.gdpeval.task_schemas import GDPTaskConfig
-from ergon_builtins.benchmarks.gdpeval.toolkit import GDPEvalToolkit
-from ergon_builtins.benchmarks.gdpeval.worker_factory import (
-    make_gdpeval_rubric,
-    make_gdpeval_worker,
-)
-from ergon_core.api.benchmark.task import Task
-
-
-FAKE_PAYLOAD = GDPTaskConfig(
-    task_id="gdpeval-fake-001",
-    workflow_type="document_processing",
-    reference_files=["/tmp/sample.pdf"],
-)
-
-
-def _fake_load_task_configs(self) -> list[GDPTaskConfig]:
-    return [FAKE_PAYLOAD]
-
-
-# ── Component-level serialization sanity ────────────────────────────────
-
-
-def test_gdpeval_toolkit_round_trips_through_json() -> None:
-    tk = GDPEvalToolkit(max_tool_calls=16)
-    serialized = tk.model_dump(mode="json")
-    assert serialized["_type"].endswith(":GDPEvalToolkit")
-    rebuilt = GDPEvalToolkit.model_validate(serialized)
-    assert rebuilt.max_tool_calls == 16
-
-
-def test_gdpeval_sandbox_serializes_with_type_discriminator() -> None:
-    sb = GDPEvalSandbox()
-    serialized = sb.model_dump(mode="json")
-    assert serialized["_type"].endswith(":GDPEvalSandbox")
-
-
-def test_make_gdpeval_worker_serializes_with_nested_toolkit_type() -> None:
-    worker = make_gdpeval_worker()
-    serialized = worker.model_dump(mode="json")
-    assert serialized["_type"].endswith(":ReActWorker"), serialized["_type"]
-    toolkit_json = serialized.get("toolkit")
-    assert toolkit_json is not None, "toolkit must be present in worker JSON"
-    assert toolkit_json["_type"].endswith(":GDPEvalToolkit"), toolkit_json["_type"]
-
-
-def test_make_gdpeval_rubric_serializes_with_type_discriminator() -> None:
-    rubric = make_gdpeval_rubric()
-    serialized = rubric.model_dump(mode="json")
-    assert serialized["_type"].endswith(":StagedRubric"), serialized["_type"]
-
-
-# ── Task-level v2 shape ─────────────────────────────────────────────────
-
-
-def test_gdpeval_task_json_has_v2_object_bound_shape() -> None:
-    """A GDPEval Task serializes to the v2 object-bound shape."""
-    with (
-        patch.object(GDPEvalBenchmark, "_load_task_configs", _fake_load_task_configs),
-        patch(
-            "ergon_builtins.benchmarks.gdpeval.benchmark.extract_task_description",
-            lambda task_id, repo_id: "Process the reference document.",
-        ),
-    ):
-        benchmark = GDPEvalBenchmark(limit=1)
-        task = benchmark.build_instances()["default"][0]
-
-    task_json = task.model_dump(mode="json")
-
-    assert task_json["worker"]["_type"].endswith(":ReActWorker")
-    assert task_json["worker"]["toolkit"]["_type"].endswith(":GDPEvalToolkit")
-    assert task_json["sandbox"]["_type"].endswith(":GDPEvalSandbox")
-    assert task_json["evaluators"], "evaluators must persist"
-    assert all(ev.get("_type") for ev in task_json["evaluators"]), (
-        "every evaluator entry must carry a `_type` discriminator"
-    )
-    assert task_json["evaluators"][0]["_type"].endswith(":StagedRubric")
-    assert "_legacy" not in task_json, (
-        "GDPEval is now object-bound; the _legacy bridge marker should be absent"
-    )
-
-
-def test_gdpeval_benchmark_accepts_custom_worker_factory() -> None:
-    """The benchmark uses the worker_factory passed to its constructor."""
-    from unittest.mock import MagicMock
-
-    sentinel_worker = make_gdpeval_worker()
-    sentinel_worker.name = "sentinel"
-    factory = MagicMock(return_value=sentinel_worker)
-
-    with (
-        patch.object(GDPEvalBenchmark, "_load_task_configs", _fake_load_task_configs),
-        patch(
-            "ergon_builtins.benchmarks.gdpeval.benchmark.extract_task_description",
-            lambda task_id, repo_id: "Process the reference document.",
-        ),
-    ):
-        benchmark = GDPEvalBenchmark(worker_factory=factory, limit=1)
-        tasks = list(benchmark.build_instances().values())[0]
-
-    assert tasks[0].worker is sentinel_worker
-    factory.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_gdpeval_task_json_round_trips_through_from_definition() -> None:
-    """Definition JSON inflates back to a Task whose sandbox is GDPEvalSandbox."""
-    with (
-        patch.object(GDPEvalBenchmark, "_load_task_configs", _fake_load_task_configs),
-        patch(
-            "ergon_builtins.benchmarks.gdpeval.benchmark.extract_task_description",
-            lambda task_id, repo_id: "Process the reference document.",
-        ),
-    ):
-        benchmark = GDPEvalBenchmark(limit=1)
-        task = benchmark.build_instances()["default"][0]
-
-    task_json = task.model_dump(mode="json")
-
-    rebuilt = await Task.from_definition(task_json, task_id=uuid4())
-
-    assert rebuilt.worker is not None
-    assert rebuilt.sandbox is not None
-    assert isinstance(rebuilt.sandbox, type(task.sandbox))
-    assert rebuilt.evaluators
-    assert all(ev is not None for ev in rebuilt.evaluators)
diff --git a/ergon_builtins/tests/unit/test_research_rubrics_v2_definition.py b/ergon_builtins/tests/unit/test_research_rubrics_v2_definition.py
deleted file mode 100644
index ed713c627..000000000
--- a/ergon_builtins/tests/unit/test_research_rubrics_v2_definition.py
+++ /dev/null
@@ -1,180 +0,0 @@
-"""ResearchRubrics v2 authoring shape: task JSON definition + reconstruction.
-
-PR 10b: assert ``ResearchRubricsBenchmark`` returns ``Task`` instances
-that serialize to the object-bound JSON shape (``_type`` on worker,
-sandbox, every evaluator entry, no ``_legacy`` marker) and that the
-snapshot round-trips through ``Task.from_definition``.
-
-The benchmark's ``build_instances`` hits HuggingFace by default; we
-monkeypatch ``_load_rows`` so the unit test stays offline.
-"""
-
-from __future__ import annotations
-
-from unittest.mock import patch
-from uuid import uuid4
-
-import pytest
-
-from ergon_builtins.benchmarks.researchrubrics.benchmark import (
-    ResearchRubricsBenchmark,
-)
-from ergon_builtins.benchmarks.researchrubrics.sandbox import ResearchE2BSandbox
-from ergon_builtins.benchmarks.researchrubrics.task_schemas import (
-    ResearchRubricsTaskPayload,
-    RubricCriterion,
-)
-from ergon_builtins.benchmarks.researchrubrics.toolkit import ResearchRubricsToolkit
-from ergon_builtins.benchmarks.researchrubrics.worker_factory import (
-    make_research_rubric,
-    make_research_worker,
-)
-from ergon_core.api.benchmark.task import Task
-
-
-FAKE_PAYLOAD = ResearchRubricsTaskPayload(
-    sample_id="rr-sample-1",
-    domain="quality",
-    prompt="Write a short report on the value of unit-test fixtures.",
-    rubrics=[
-        RubricCriterion(
-            criterion="Includes a Findings section.",
-            axis="Communication Quality",
-            weight=2.0,
-        ),
-        RubricCriterion(
-            criterion="Cites at least one source.",
-            axis="References & Citation Quality",
-            weight=1.0,
-        ),
-    ],
-)
-
-
-def _fake_load_rows(self):
-    return [FAKE_PAYLOAD]
-
-
-# ── Component-level serialization sanity ────────────────────────────────
-
-
-def test_research_rubrics_toolkit_round_trips_through_json() -> None:
-    tk = ResearchRubricsToolkit(judge_model="openai:gpt-4o-mini", max_search_calls=8)
-    serialized = tk.model_dump(mode="json")
-    assert serialized["_type"].endswith(":ResearchRubricsToolkit")
-    rebuilt = ResearchRubricsToolkit.model_validate(serialized)
-    assert rebuilt.judge_model == "openai:gpt-4o-mini"
-    assert rebuilt.max_search_calls == 8
-
-
-def test_research_e2b_sandbox_serializes_with_type_discriminator() -> None:
-    sb = ResearchE2BSandbox()
-    serialized = sb.model_dump(mode="json")
-    assert serialized["_type"].endswith(":ResearchE2BSandbox")
-
-
-def test_make_research_worker_serializes_with_nested_toolkit_type() -> None:
-    worker = make_research_worker()
-    serialized = worker.model_dump(mode="json")
-    assert serialized["_type"].endswith(":ReActWorker"), serialized["_type"]
-    toolkit_json = serialized.get("toolkit")
-    assert toolkit_json is not None, "toolkit must be present in worker JSON"
-    assert toolkit_json["_type"].endswith(":ResearchRubricsToolkit"), toolkit_json["_type"]
-
-
-def test_make_research_rubric_serializes_with_type_discriminator() -> None:
-    rubric = make_research_rubric()
-    serialized = rubric.model_dump(mode="json")
-    assert serialized["_type"].endswith(":ResearchRubricsRubric"), serialized["_type"]
-
-
-# ── Task-level v2 shape ─────────────────────────────────────────────────
-
-
-def test_research_rubrics_task_json_has_v2_object_bound_shape() -> None:
-    """A ResearchRubrics Task serializes to the v2 object-bound shape."""
-    with patch.object(ResearchRubricsBenchmark, "_load_rows", _fake_load_rows):
-        benchmark = ResearchRubricsBenchmark(limit=1)
-        task = benchmark.build_instances()["default"][0]
-
-    task_json = task.model_dump(mode="json")
-
-    assert task_json["worker"]["_type"].endswith(":ReActWorker")
-    assert task_json["worker"]["toolkit"]["_type"].endswith(":ResearchRubricsToolkit")
-    assert task_json["sandbox"]["_type"].endswith(":ResearchE2BSandbox")
-    assert task_json["evaluators"], "evaluators must persist"
-    assert all(ev.get("_type") for ev in task_json["evaluators"]), (
-        "every evaluator entry must carry a `_type` discriminator"
-    )
-    assert task_json["evaluators"][0]["_type"].endswith(":ResearchRubricsRubric")
-    assert "_legacy" not in task_json, (
-        "ResearchRubrics is now object-bound; the _legacy bridge marker should be absent"
-    )
-
-
-def test_research_rubric_judge_model_round_trips_through_evaluator_json() -> None:
-    """Per plan Task 7 Step 2: judge model field must round-trip in JSON.
-
-    ResearchRubrics rubrics materialise per-task ``ResearchRubricsJudgeCriterion``
-    instances from the task payload at criteria-resolution time.  Each
-    criterion's ``judge_model`` field is a first-class Pydantic field, so
-    the value survives a ``model_dump`` / ``model_validate`` round trip
-    even though the rubric body itself only serializes the authoring
-    config.
-    """
-    from ergon_builtins.benchmarks.researchrubrics.criteria.judge import (
-        ResearchRubricsJudgeCriterion,
-    )
-
-    criterion = ResearchRubricsJudgeCriterion(
-        slug="includes_findings",
-        rubric=RubricCriterion(
-            criterion="Includes a Findings section.",
-            axis="Communication Quality",
-            weight=2.0,
-        ),
-        judge_model="openai:gpt-4o-mini",
-    )
-    serialized = criterion.model_dump(mode="json")
-    assert serialized["judge_model"] == "openai:gpt-4o-mini", (
-        f"judge_model must round-trip in JSON; got {serialized.get('judge_model')!r}"
-    )
-    assert serialized.get("rubric_text"), "rubric_text must round-trip alongside judge_model"
-
-    rebuilt = ResearchRubricsJudgeCriterion.model_validate(serialized)
-    assert rebuilt.judge_model == "openai:gpt-4o-mini"
-    assert rebuilt.rubric_text == "Includes a Findings section."
-
-
-def test_research_rubrics_benchmark_accepts_custom_worker_factory() -> None:
-    """The benchmark uses the worker_factory passed to its constructor."""
-    from unittest.mock import MagicMock
-
-    sentinel_worker = make_research_worker()
-    sentinel_worker.name = "sentinel"
-    factory = MagicMock(return_value=sentinel_worker)
-
-    with patch.object(ResearchRubricsBenchmark, "_load_rows", _fake_load_rows):
-        benchmark = ResearchRubricsBenchmark(worker_factory=factory, limit=1)
-        tasks = list(benchmark.build_instances().values())[0]
-
-    assert tasks[0].worker is sentinel_worker
-    factory.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_research_rubrics_task_json_round_trips_through_from_definition() -> None:
-    """Definition JSON inflates back to a Task whose sandbox is ResearchE2BSandbox."""
-    with patch.object(ResearchRubricsBenchmark, "_load_rows", _fake_load_rows):
-        benchmark = ResearchRubricsBenchmark(limit=1)
-        task = benchmark.build_instances()["default"][0]
-
-    task_json = task.model_dump(mode="json")
-
-    rebuilt = await Task.from_definition(task_json, task_id=uuid4())
-
-    assert rebuilt.worker is not None
-    assert rebuilt.sandbox is not None
-    assert isinstance(rebuilt.sandbox, type(task.sandbox))
-    assert rebuilt.evaluators
-    assert all(ev is not None for ev in rebuilt.evaluators)
diff --git a/ergon_builtins/tests/unit/test_swebench_v2_definition.py b/ergon_builtins/tests/unit/test_swebench_v2_definition.py
deleted file mode 100644
index c6bb6c69a..000000000
--- a/ergon_builtins/tests/unit/test_swebench_v2_definition.py
+++ /dev/null
@@ -1,150 +0,0 @@
-"""SWE-Bench Verified v2 authoring shape: task JSON definition + reconstruction.
-
-PR 10a: assert ``SweBenchVerifiedBenchmark`` returns ``Task`` instances
-that serialize to the object-bound JSON shape (``_type`` on worker,
-sandbox, every evaluator entry, no ``_legacy`` marker) and that the
-snapshot round-trips through ``Task.from_definition``.
-
-The benchmark's ``build_instances`` hits HuggingFace by default; we
-monkeypatch ``_load_rows`` so the unit test stays offline.
-"""
-
-from __future__ import annotations
-
-from unittest.mock import patch
-from uuid import uuid4
-
-import pytest
-
-from ergon_builtins.benchmarks.swebench_verified.benchmark import (
-    SweBenchVerifiedBenchmark,
-)
-from ergon_builtins.benchmarks.swebench_verified.sandbox import SWEBenchSandbox
-from ergon_builtins.benchmarks.swebench_verified.task_schemas import (
-    SWEBenchInstance,
-    SWEBenchTaskPayload,
-)
-from ergon_builtins.benchmarks.swebench_verified.toolkit import SWEBenchToolkit
-from ergon_builtins.benchmarks.swebench_verified.worker_factory import (
-    make_swebench_rubric,
-    make_swebench_worker,
-)
-from ergon_core.api.benchmark.task import Task
-
-
-FAKE_ROW = {
-    "instance_id": "django__django-1",
-    "repo": "django/django",
-    "base_commit": "aaa",
-    "patch": "GOLD",
-    "test_patch": "TP1",
-    "problem_statement": "p1",
-    "hints_text": "",
-    "version": "3.0",
-    "FAIL_TO_PASS": '["t1"]',
-    "PASS_TO_PASS": '["t0"]',
-    "environment_setup_commit": "aaa",
-}
-
-
-def _fake_load_rows(*, limit=None):
-    rows = [SWEBenchInstance.from_raw(FAKE_ROW)]
-    return rows if limit is None else rows[:limit]
-
-
-# ── Component-level serialization sanity ────────────────────────────────
-
-
-def test_swebench_toolkit_round_trips_through_json() -> None:
-    tk = SWEBenchToolkit(max_tool_calls=16)
-    serialized = tk.model_dump(mode="json")
-    assert serialized["_type"].endswith(":SWEBenchToolkit")
-    rebuilt = SWEBenchToolkit.model_validate(serialized)
-    assert rebuilt.max_tool_calls == 16
-
-
-def test_swebench_sandbox_serializes_with_type_discriminator() -> None:
-    sb = SWEBenchSandbox()
-    serialized = sb.model_dump(mode="json")
-    assert serialized["_type"].endswith(":SWEBenchSandbox")
-
-
-def test_make_swebench_worker_serializes_with_nested_toolkit_type() -> None:
-    worker = make_swebench_worker()
-    serialized = worker.model_dump(mode="json")
-    assert serialized["_type"].endswith(":ReActWorker"), serialized["_type"]
-    toolkit_json = serialized.get("toolkit")
-    assert toolkit_json is not None, "toolkit must be present in worker JSON"
-    assert toolkit_json["_type"].endswith(":SWEBenchToolkit"), toolkit_json["_type"]
-
-
-def test_make_swebench_rubric_serializes_with_type_discriminator() -> None:
-    rubric = make_swebench_rubric()
-    serialized = rubric.model_dump(mode="json")
-    assert serialized["_type"].endswith(":SWEBenchRubric"), serialized["_type"]
-
-
-# ── Task-level v2 shape ─────────────────────────────────────────────────
-
-
-def test_swebench_task_json_has_v2_object_bound_shape() -> None:
-    """A SWE-Bench Task serializes to the v2 object-bound shape."""
-    with patch(
-        "ergon_builtins.benchmarks.swebench_verified.benchmark._load_rows",
-        side_effect=_fake_load_rows,
-    ):
-        benchmark = SweBenchVerifiedBenchmark(limit=1)
-        task = benchmark.build_instances()["default"][0]
-
-    task_json = task.model_dump(mode="json")
-
-    assert task_json["worker"]["_type"].endswith(":ReActWorker")
-    assert task_json["worker"]["toolkit"]["_type"].endswith(":SWEBenchToolkit")
-    assert task_json["sandbox"]["_type"].endswith(":SWEBenchSandbox")
-    assert task_json["evaluators"], "evaluators must persist"
-    assert all(ev.get("_type") for ev in task_json["evaluators"]), (
-        "every evaluator entry must carry a `_type` discriminator"
-    )
-    assert "_legacy" not in task_json, (
-        "SWE-Bench is now object-bound; the _legacy bridge marker should be absent"
-    )
-
-
-def test_swebench_benchmark_accepts_custom_worker_factory() -> None:
-    """The benchmark uses the worker_factory passed to its constructor."""
-    from unittest.mock import MagicMock
-
-    sentinel_worker = make_swebench_worker()
-    sentinel_worker.name = "sentinel"
-    factory = MagicMock(return_value=sentinel_worker)
-
-    with patch(
-        "ergon_builtins.benchmarks.swebench_verified.benchmark._load_rows",
-        side_effect=_fake_load_rows,
-    ):
-        benchmark = SweBenchVerifiedBenchmark(worker_factory=factory, limit=1)
-        tasks = list(benchmark.build_instances().values())[0]
-
-    assert tasks[0].worker is sentinel_worker
-    factory.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_swebench_task_json_round_trips_through_from_definition() -> None:
-    """Definition JSON inflates back to a Task whose sandbox is SWEBenchSandbox."""
-    with patch(
-        "ergon_builtins.benchmarks.swebench_verified.benchmark._load_rows",
-        side_effect=_fake_load_rows,
-    ):
-        benchmark = SweBenchVerifiedBenchmark(limit=1)
-        task = benchmark.build_instances()["default"][0]
-
-    task_json = task.model_dump(mode="json")
-
-    rebuilt = await Task.from_definition(task_json, task_id=uuid4())
-
-    assert rebuilt.worker is not None
-    assert rebuilt.sandbox is not None
-    assert isinstance(rebuilt.sandbox, type(task.sandbox))
-    assert rebuilt.evaluators
-    assert all(ev is not None for ev in rebuilt.evaluators)
diff --git a/ergon_builtins/tests/unit/workers/test_react_toolkit_serialization.py b/ergon_builtins/tests/unit/workers/test_react_toolkit_serialization.py
index 350ecbaf9..600385c07 100644
--- a/ergon_builtins/tests/unit/workers/test_react_toolkit_serialization.py
+++ b/ergon_builtins/tests/unit/workers/test_react_toolkit_serialization.py
@@ -4,13 +4,24 @@
 
 import pytest
 
+from ergon_builtins.agents.react.worker import ReActWorker
+from ergon_builtins.benchmarks.minif2f.prompts import MINIF2F_SYSTEM_PROMPT
 from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
-from ergon_builtins.benchmarks.minif2f.worker_factory import make_minif2f_worker
 from ergon_builtins.toolkits.common.base import Toolkit
 
 
+def _mini_worker() -> ReActWorker:
+    return ReActWorker(
+        name="mini-proof-solver",
+        model="test:none",
+        system_prompt=MINIF2F_SYSTEM_PROMPT,
+        max_iterations=30,
+        toolkit=MiniF2FToolkit(),
+    )
+
+
 def test_react_worker_serializes_concrete_toolkit_fields() -> None:
-    worker = make_minif2f_worker()
+    worker = _mini_worker()
     worker.toolkit = MiniF2FToolkit(max_tool_calls=16)
 
     serialized = worker.model_dump(mode="json")
@@ -20,7 +31,7 @@ def test_react_worker_serializes_concrete_toolkit_fields() -> None:
 
 
 def test_react_worker_rehydrates_concrete_toolkit() -> None:
-    worker = make_minif2f_worker()
+    worker = _mini_worker()
     worker.toolkit = MiniF2FToolkit(max_tool_calls=16)
 
     rebuilt = type(worker).model_validate(worker.model_dump(mode="json"))
@@ -36,7 +47,7 @@ def test_toolkit_from_definition_requires_type_discriminator() -> None:
 
 def test_toolkit_from_definition_rejects_non_toolkit_type() -> None:
     with pytest.raises(TypeError, match="Toolkit _type.*Toolkit subclass"):
-        Toolkit.from_definition({"_type": "ergon_core.api.benchmark.task:Task", "label": "wrong"})
+        Toolkit.from_definition({"_type": "ergon_core.api.task:Task", "label": "wrong"})
 
 
 class _NoopToolkit(Toolkit):
diff --git a/ergon_builtins/tests/unit/workers/test_react_worker_contract.py b/ergon_builtins/tests/unit/workers/test_react_worker_contract.py
index 139d91e2e..3b630196d 100644
--- a/ergon_builtins/tests/unit/workers/test_react_worker_contract.py
+++ b/ergon_builtins/tests/unit/workers/test_react_worker_contract.py
@@ -7,7 +7,7 @@
 import pytest
 from ergon_builtins.agents.react.output import worker_output_from_chunks
 from ergon_builtins.agents.react.worker import ReActWorker
-from ergon_core.api.benchmark import EmptyTaskPayload, Task
+from ergon_core.api.task import EmptyTaskPayload, Task
 from ergon_core.api.worker import WorkerContext, WorkerOutput
 from ergon_core.test_support.task_factory import task_with_id
 from ergon_core.core.shared.context_parts import (
diff --git a/ergon_cli/ergon_cli/app.py b/ergon_cli/ergon_cli/app.py
index 020d5da30..d504c9255 100644
--- a/ergon_cli/ergon_cli/app.py
+++ b/ergon_cli/ergon_cli/app.py
@@ -3,7 +3,7 @@
 import argparse
 import inspect
 
-from ergon_cli.domains.benchmarks.parser import register_benchmark_parser
+from ergon_cli.domains.environments.parser import register_environment_parser
 from ergon_cli.domains.doctor.parser import register_doctor_parser
 from ergon_cli.domains.evaluators.parser import register_evaluator_parser
 from ergon_cli.domains.examples.parser import register_examples_parser
@@ -20,7 +20,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(prog="ergon", description="Ergon experiment orchestration")
     subparsers = parser.add_subparsers(dest="command")
 
-    register_benchmark_parser(subparsers)
+    register_environment_parser(subparsers)
     register_experiment_parser(subparsers)
     register_sample_parser(subparsers)
     register_ingest_parser(subparsers)
diff --git a/ergon_cli/ergon_cli/domains/benchmarks/__init__.py b/ergon_cli/ergon_cli/domains/benchmarks/__init__.py
deleted file mode 100644
index 03c3f92ed..000000000
--- a/ergon_cli/ergon_cli/domains/benchmarks/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Benchmark CLI domain."""
diff --git a/ergon_cli/ergon_cli/domains/benchmarks/commands.py b/ergon_cli/ergon_cli/domains/benchmarks/commands.py
deleted file mode 100644
index 17d64d3cb..000000000
--- a/ergon_cli/ergon_cli/domains/benchmarks/commands.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from argparse import Namespace
-
-from ergon_cli.domains.benchmarks.models import BenchmarkCommand
-from ergon_cli.domains.benchmarks.service import list_benchmark_rows
-from ergon_cli.domains.benchmarks.service import setup_benchmark as setup_benchmark_service
-from ergon_cli.shared.output import render_table
-
-
-async def handle_benchmark(args: Namespace) -> int:
-    if args.bench_action not in {"list", "setup"}:
-        print("Usage: ergon benchmark {list|setup}")
-        return 1
-    values = vars(args)
-    command = BenchmarkCommand(
-        action=args.bench_action,
-        slug=values.get("slug"),
-        force=values.get("force", False),
-    )
-    if command.action == "list":
-        print(render_table(["Slug", "Name", "Description"], list_benchmark_rows()))
-        return 0
-    return setup_benchmark_service(command)
diff --git a/ergon_cli/ergon_cli/domains/benchmarks/parser.py b/ergon_cli/ergon_cli/domains/benchmarks/parser.py
deleted file mode 100644
index 726ab4c0a..000000000
--- a/ergon_cli/ergon_cli/domains/benchmarks/parser.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import argparse
-
-from ergon_cli.domains.benchmarks.commands import handle_benchmark
-
-
-def register_benchmark_parser(subparsers: argparse._SubParsersAction) -> None:
-    bench = subparsers.add_parser("benchmark", help="Benchmark operations")
-    bench.set_defaults(handler=handle_benchmark)
-    bench_sub = bench.add_subparsers(dest="bench_action")
-    bench_sub.add_parser("list", help="List available benchmarks")
diff --git a/ergon_cli/ergon_cli/domains/environments/__init__.py b/ergon_cli/ergon_cli/domains/environments/__init__.py
new file mode 100644
index 000000000..1da553b94
--- /dev/null
+++ b/ergon_cli/ergon_cli/domains/environments/__init__.py
@@ -0,0 +1 @@
+"""Environment CLI domain."""
diff --git a/ergon_cli/ergon_cli/domains/environments/commands.py b/ergon_cli/ergon_cli/domains/environments/commands.py
new file mode 100644
index 000000000..1094d29bc
--- /dev/null
+++ b/ergon_cli/ergon_cli/domains/environments/commands.py
@@ -0,0 +1,22 @@
+from argparse import Namespace
+
+from ergon_cli.domains.environments.models import EnvironmentCommand
+from ergon_cli.domains.environments.service import list_environment_rows
+from ergon_cli.domains.environments.service import setup_environment as setup_environment_service
+from ergon_cli.shared.output import render_table
+
+
+async def handle_environment(args: Namespace) -> int:
+    if args.env_action not in {"list", "setup"}:
+        print("Usage: ergon environment {list|setup}")
+        return 1
+    values = vars(args)
+    command = EnvironmentCommand(
+        action=args.env_action,
+        slug=values.get("slug"),
+        force=values.get("force", False),
+    )
+    if command.action == "list":
+        print(render_table(["Slug", "Name", "Description"], list_environment_rows()))
+        return 0
+    return setup_environment_service(command)
diff --git a/ergon_cli/ergon_cli/domains/benchmarks/models.py b/ergon_cli/ergon_cli/domains/environments/models.py
similarity index 84%
rename from ergon_cli/ergon_cli/domains/benchmarks/models.py
rename to ergon_cli/ergon_cli/domains/environments/models.py
index 5c4368184..f64f4be27 100644
--- a/ergon_cli/ergon_cli/domains/benchmarks/models.py
+++ b/ergon_cli/ergon_cli/domains/environments/models.py
@@ -3,7 +3,7 @@
 from pydantic import BaseModel, ConfigDict
 
 
-class BenchmarkCommand(BaseModel):
+class EnvironmentCommand(BaseModel):
     model_config = ConfigDict(frozen=True)
 
     action: Literal["list", "setup"]
diff --git a/ergon_cli/ergon_cli/domains/environments/parser.py b/ergon_cli/ergon_cli/domains/environments/parser.py
new file mode 100644
index 000000000..d8410dfbd
--- /dev/null
+++ b/ergon_cli/ergon_cli/domains/environments/parser.py
@@ -0,0 +1,13 @@
+import argparse
+
+from ergon_cli.domains.environments.commands import handle_environment
+
+
+def register_environment_parser(subparsers: argparse._SubParsersAction) -> None:
+    env = subparsers.add_parser("environment", help="Environment operations")
+    env.set_defaults(handler=handle_environment)
+    env_sub = env.add_subparsers(dest="env_action")
+    env_sub.add_parser("list", help="List available environments")
+    setup = env_sub.add_parser("setup", help="Build sandbox template for an environment")
+    setup.add_argument("slug")
+    setup.add_argument("--force", action="store_true")
diff --git a/ergon_cli/ergon_cli/domains/benchmarks/service.py b/ergon_cli/ergon_cli/domains/environments/service.py
similarity index 87%
rename from ergon_cli/ergon_cli/domains/benchmarks/service.py
rename to ergon_cli/ergon_cli/domains/environments/service.py
index f68f145d0..d5a18a8e2 100644
--- a/ergon_cli/ergon_cli/domains/benchmarks/service.py
+++ b/ergon_cli/ergon_cli/domains/environments/service.py
@@ -7,24 +7,24 @@
 from pathlib import Path
 
 from e2b import Template
-from ergon_builtins.benchmarks.catalog import benchmark_cli_metadata
-from ergon_cli.domains.benchmarks.models import BenchmarkCommand
-from ergon_cli.domains.benchmarks.templates import sandbox_template_for, setup_benchmark_slugs
+from ergon_builtins.environments.catalog import environment_cli_metadata
+from ergon_cli.domains.environments.models import EnvironmentCommand
+from ergon_cli.domains.environments.templates import sandbox_template_for, setup_environment_slugs
 from ergon_core.core.shared.json_types import JsonObject
 from ergon_core.core.shared.settings import settings
 from pydantic import BaseModel, ConfigDict
 
 
-def list_benchmark_rows() -> list[list[str]]:
+def list_environment_rows() -> list[list[str]]:
     return [
         [metadata.slug, metadata.name, metadata.description]
-        for metadata in sorted(benchmark_cli_metadata().values(), key=lambda item: item.slug)
+        for metadata in sorted(environment_cli_metadata().values(), key=lambda item: item.slug)
     ]
 
 
-def setup_benchmark(command: BenchmarkCommand) -> int:
+def setup_environment(command: EnvironmentCommand) -> int:
     if command.slug is None:
-        return _fail("Usage: ergon benchmark setup <slug>")
+        return _fail("Usage: ergon environment setup <slug>")
 
     slug = command.slug
     force = command.force
@@ -39,8 +39,8 @@ def setup_benchmark(command: BenchmarkCommand) -> int:
 
     template_dir = _template_dir_for(slug)
     if template_dir is None:
-        available = ", ".join(setup_benchmark_slugs()) or "(none)"
-        return _fail(f"Error: unknown benchmark slug '{slug}'.\nAvailable slugs: {available}")
+        available = ", ".join(setup_environment_slugs()) or "(none)"
+        return _fail(f"Error: unknown environment slug '{slug}'.\nAvailable slugs: {available}")
 
     template_spec = _load_template_spec(template_dir)
     if isinstance(template_spec, str):
diff --git a/ergon_cli/ergon_cli/domains/benchmarks/templates.py b/ergon_cli/ergon_cli/domains/environments/templates.py
similarity index 55%
rename from ergon_cli/ergon_cli/domains/benchmarks/templates.py
rename to ergon_cli/ergon_cli/domains/environments/templates.py
index 5986e47b6..12cdb79c3 100644
--- a/ergon_cli/ergon_cli/domains/benchmarks/templates.py
+++ b/ergon_cli/ergon_cli/domains/environments/templates.py
@@ -1,20 +1,20 @@
 from pathlib import Path
 
-from ergon_builtins.benchmarks.catalog import benchmark_cli_metadata
+from ergon_builtins.environments.catalog import environment_cli_metadata
 
 
 def sandbox_template_for(slug: str) -> Path:
-    metadata = benchmark_cli_metadata()[slug]
+    metadata = environment_cli_metadata()[slug]
     if metadata.sandbox_template is None:
         raise KeyError(slug)
     return metadata.sandbox_template
 
 
-def setup_benchmark_slugs() -> tuple[str, ...]:
+def setup_environment_slugs() -> tuple[str, ...]:
     return tuple(
         sorted(
             slug
-            for slug, metadata in benchmark_cli_metadata().items()
+            for slug, metadata in environment_cli_metadata().items()
             if metadata.sandbox_template is not None
         )
     )
diff --git a/ergon_cli/ergon_cli/domains/eval/commands.py b/ergon_cli/ergon_cli/domains/eval/commands.py
index c0c7ac4c9..d4cf75eff 100644
--- a/ergon_cli/ergon_cli/domains/eval/commands.py
+++ b/ergon_cli/ergon_cli/domains/eval/commands.py
@@ -1,4 +1,4 @@
-"""Eval subcommand: watch checkpoints and score them on benchmarks."""
+"""Eval subcommand: watch checkpoints and score them on environments."""
 
 from argparse import Namespace
 
@@ -17,7 +17,7 @@ async def handle_eval(args: Namespace) -> int:
         action=args.eval_action,
         checkpoint_dir=values.get("checkpoint_dir"),
         checkpoint=values.get("checkpoint"),
-        benchmark=args.benchmark,
+        environment=args.environment,
         evaluator=args.evaluator,
         model_base=args.model_base,
         poll_interval=values.get("poll_interval", 60),
diff --git a/ergon_cli/ergon_cli/domains/eval/models.py b/ergon_cli/ergon_cli/domains/eval/models.py
index 6c3316dc0..cd5e24f8c 100644
--- a/ergon_cli/ergon_cli/domains/eval/models.py
+++ b/ergon_cli/ergon_cli/domains/eval/models.py
@@ -7,7 +7,7 @@ class EvalCommand(BaseModel):
     model_config = ConfigDict(frozen=True)
 
     action: Literal["watch", "checkpoint"]
-    benchmark: str
+    environment: str
     evaluator: str
     model_base: str
     eval_limit: int | None = None
diff --git a/ergon_cli/ergon_cli/domains/eval/parser.py b/ergon_cli/ergon_cli/domains/eval/parser.py
index 6bda0be17..8478b4add 100644
--- a/ergon_cli/ergon_cli/domains/eval/parser.py
+++ b/ergon_cli/ergon_cli/domains/eval/parser.py
@@ -10,7 +10,7 @@ def register_eval_parser(subparsers: argparse._SubParsersAction) -> None:
 
     eval_watch = eval_sub.add_parser("watch", help="Watch for new checkpoints and evaluate")
     eval_watch.add_argument("--checkpoint-dir", required=True, help="Directory to watch")
-    eval_watch.add_argument("--benchmark", required=True, help="Benchmark slug")
+    eval_watch.add_argument("--environment", required=True, help="Environment slug")
     eval_watch.add_argument("--evaluator", required=True, help="Evaluator slug")
     eval_watch.add_argument("--model-base", required=True, help="Base model for local eval")
     eval_watch.add_argument("--poll-interval", type=int, default=60, help="Seconds between scans")
@@ -23,7 +23,7 @@ def register_eval_parser(subparsers: argparse._SubParsersAction) -> None:
 
     eval_ckpt = eval_sub.add_parser("checkpoint", help="Evaluate a single checkpoint")
     eval_ckpt.add_argument("--checkpoint", required=True, help="Checkpoint path")
-    eval_ckpt.add_argument("--benchmark", required=True, help="Benchmark slug")
+    eval_ckpt.add_argument("--environment", required=True, help="Environment slug")
     eval_ckpt.add_argument("--evaluator", required=True, help="Evaluator slug")
     eval_ckpt.add_argument("--model-base", required=True, help="Base model for local eval")
     eval_ckpt.add_argument("--eval-limit", type=int, default=None, help="Max tasks")
diff --git a/ergon_cli/ergon_cli/domains/eval/service.py b/ergon_cli/ergon_cli/domains/eval/service.py
index 99cdf2805..9f6514288 100644
--- a/ergon_cli/ergon_cli/domains/eval/service.py
+++ b/ergon_cli/ergon_cli/domains/eval/service.py
@@ -9,7 +9,7 @@ async def run_eval(command: EvalCommand) -> int:
             raise CliUsageError("Usage: ergon eval watch --checkpoint-dir <path>")
         await watch_and_evaluate(
             checkpoint_dir=command.checkpoint_dir,
-            benchmark_type=command.benchmark,
+            benchmark_type=command.environment,
             evaluator_type=command.evaluator,
             model_base=command.model_base,
             poll_interval_s=command.poll_interval,
@@ -22,7 +22,7 @@ async def run_eval(command: EvalCommand) -> int:
         raise CliUsageError("Usage: ergon eval checkpoint --checkpoint <path>")
     return await evaluate_checkpoint(
         checkpoint_path=command.checkpoint,
-        benchmark_type=command.benchmark,
+        benchmark_type=command.environment,
         evaluator_type=command.evaluator,
         model_base=command.model_base,
         eval_limit=command.eval_limit,
diff --git a/ergon_cli/ergon_cli/domains/onboarding/commands.py b/ergon_cli/ergon_cli/domains/onboarding/commands.py
index c40a9a6b5..ab8a34c39 100644
--- a/ergon_cli/ergon_cli/domains/onboarding/commands.py
+++ b/ergon_cli/ergon_cli/domains/onboarding/commands.py
@@ -7,7 +7,7 @@
     GPUProvider,
     LLMProvider,
     OnboardProfile,
-    available_benchmark_slugs,
+    available_environment_slugs,
 )
 from ergon_cli.domains.onboarding.prompts import ask_secret, confirm, select_multiple, select_one
 
@@ -17,9 +17,9 @@ def handle_onboard(args: Namespace) -> int:
     print("\nWelcome to Ergon!  Let's get your environment set up.\n")
 
     profile = OnboardProfile()
-    profile.benchmarks = select_multiple(
-        "Which benchmarks do you want to run?",
-        [(slug, slug) for slug in available_benchmark_slugs()],
+    profile.environments = select_multiple(
+        "Which environments do you want to run?",
+        [(slug, slug) for slug in available_environment_slugs()],
     )
     profile.llm_providers = [
         LLMProvider(value)
diff --git a/ergon_cli/ergon_cli/domains/onboarding/profile.py b/ergon_cli/ergon_cli/domains/onboarding/profile.py
index ac30f39a9..99f595904 100644
--- a/ergon_cli/ergon_cli/domains/onboarding/profile.py
+++ b/ergon_cli/ergon_cli/domains/onboarding/profile.py
@@ -3,13 +3,13 @@
 from enum import Enum
 from typing import Literal
 
-from ergon_builtins.benchmarks.catalog import benchmark_cli_metadata
+from ergon_builtins.environments.catalog import environment_cli_metadata
 from pydantic import BaseModel, Field
 
 EnvKeyOwner = Literal[
     "core-runtime",
     "model-provider-runtime",
-    "benchmark-evaluation-runtime",
+    "environment-evaluation-runtime",
     "infra-training-runtime",
     "local-networking-dev",
 ]
@@ -52,8 +52,8 @@ class GPUProvider(str, Enum):
     "ANTHROPIC_API_KEY": "model-provider-runtime",
     "GOOGLE_API_KEY": "model-provider-runtime",
     "OPENROUTER_API_KEY": "model-provider-runtime",
-    "E2B_API_KEY": "benchmark-evaluation-runtime",
-    "EXA_API_KEY": "benchmark-evaluation-runtime",
+    "E2B_API_KEY": "environment-evaluation-runtime",
+    "EXA_API_KEY": "environment-evaluation-runtime",
     "SHADEFORM_API_KEY": "infra-training-runtime",
     "LAMBDA_API_KEY": "infra-training-runtime",
     "RUNPOD_API_KEY": "infra-training-runtime",
@@ -62,14 +62,14 @@ class GPUProvider(str, Enum):
 }
 
 
-def available_benchmark_slugs() -> list[str]:
-    return sorted(benchmark_cli_metadata())
+def available_environment_slugs() -> list[str]:
+    return sorted(environment_cli_metadata())
 
 
 class OnboardProfile(BaseModel):
     """Captures every user choice made during onboarding."""
 
-    benchmarks: list[str] = Field(default_factory=list)
+    environments: list[str] = Field(default_factory=list)
     llm_providers: list[LLMProvider] = Field(default_factory=list)
     training: bool = False
     gpu_provider: GPUProvider | None = None
@@ -78,7 +78,7 @@ class OnboardProfile(BaseModel):
 
     def required_keys(self) -> dict[str, str]:
         """Return {env_var: human_reason} derived purely from user choices."""
-        benchmarks = benchmark_cli_metadata()
+        environments = environment_cli_metadata()
 
         result: dict[str, str] = {}
 
@@ -86,12 +86,16 @@ def required_keys(self) -> dict[str, str]:
             env_var = PROVIDER_KEY_MAP[provider]
             result[env_var] = f"{provider.value} API access"
 
-        if any("E2B_API_KEY" in benchmarks[b].env_keys for b in self.benchmarks if b in benchmarks):
-            result["E2B_API_KEY"] = "Sandboxed code execution for selected benchmarks"
+        if any(
+            "E2B_API_KEY" in environments[b].env_keys
+            for b in self.environments
+            if b in environments
+        ):
+            result["E2B_API_KEY"] = "Sandboxed code execution for selected environments"
 
-        for b in self.benchmarks:
-            if b in benchmarks:
-                for key in benchmarks[b].env_keys:
+        for b in self.environments:
+            if b in environments:
+                for key in environments[b].env_keys:
                     if key == "E2B_API_KEY":
                         continue
                     result.setdefault(key, f"Optional for {b}")
@@ -104,12 +108,12 @@ def required_keys(self) -> dict[str, str]:
 
     def required_extras(self) -> list[str]:
         """Pip extras to install based on choices."""
-        benchmarks = benchmark_cli_metadata()
+        environments = environment_cli_metadata()
 
         extras: set[str] = set()
-        for benchmark in self.benchmarks:
-            if benchmark in benchmarks:
-                extras.update(benchmarks[benchmark].required_packages)
+        for environment in self.environments:
+            if environment in environments:
+                extras.update(environments[environment].required_packages)
         if self.training:
             extras.add("ergon-infra[training]")
         if self.gpu_provider and self.gpu_provider != GPUProvider.LOCAL:
diff --git a/ergon_cli/ergon_cli/domains/samples/commands.py b/ergon_cli/ergon_cli/domains/samples/commands.py
index 8681ef63b..db89af494 100644
--- a/ergon_cli/ergon_cli/domains/samples/commands.py
+++ b/ergon_cli/ergon_cli/domains/samples/commands.py
@@ -77,7 +77,7 @@ def status_sample_command(args: Namespace) -> int:
     lines = [
         f"sample_id:              {sample.id}",
         f"status:                 {sample.status}",
-        f"benchmark_type:         {sample.benchmark_type}",
+        f"environment_type:       {sample.benchmark_type}",
         f"instance_key:           {sample.instance_key}",
     ]
     if sample.evaluator_slug is not None:
diff --git a/ergon_cli/ergon_cli/domains/tests/catalog.py b/ergon_cli/ergon_cli/domains/tests/catalog.py
index 8eb9d4738..784d82473 100644
--- a/ergon_cli/ergon_cli/domains/tests/catalog.py
+++ b/ergon_cli/ergon_cli/domains/tests/catalog.py
@@ -44,12 +44,12 @@
 BACKEND_E2E = ("uv", "run", "pytest", "tests/e2e", "-v")
 REAL_LLM = ("uv", "run", "pytest", "tests/real_llm", "-v")
 DASHBOARD_SMOKE = ("pnpm", "-C", "ergon-dashboard", "run", "e2e:live")
-BENCHMARK_SMOKE_COMMANDS = {
+ENVIRONMENT_SMOKE_COMMANDS = {
     "researchrubrics": ("uv", "run", "pytest", "tests/e2e/test_researchrubrics_smoke.py", "-v"),
     "minif2f": ("uv", "run", "pytest", "tests/e2e/test_minif2f_smoke.py", "-v"),
     "swebench-verified": ("uv", "run", "pytest", "tests/e2e/test_swebench_smoke.py", "-v"),
 }
-BENCHMARK_SMOKE_ALL = (
+ENVIRONMENT_SMOKE_ALL = (
     "uv",
     "run",
     "pytest",
diff --git a/ergon_cli/ergon_cli/domains/tests/parser.py b/ergon_cli/ergon_cli/domains/tests/parser.py
index 734ac3747..f43b63205 100644
--- a/ergon_cli/ergon_cli/domains/tests/parser.py
+++ b/ergon_cli/ergon_cli/domains/tests/parser.py
@@ -13,13 +13,13 @@ def register_test_parser(subparsers: argparse._SubParsersAction) -> None:
     list_parser.add_argument("--dry-run", action="store_true", help=argparse.SUPPRESS)
     list_parser.add_argument("extra_args", nargs=argparse.REMAINDER, help=argparse.SUPPRESS)
 
-    smoke_parser = domain_sub.add_parser("smoke", help="Run canonical benchmark smoke tests")
+    smoke_parser = domain_sub.add_parser("smoke", help="Run canonical environment smoke tests")
     smoke_parser.add_argument(
         "test_suite",
         nargs="?",
         default="full",
         metavar="{full,researchrubrics,minif2f,swebench-verified}",
-        help="Benchmark smoke target",
+        help="Environment smoke target",
     )
     smoke_parser.add_argument(
         "--dry-run", action="store_true", help="Print command without running"
diff --git a/ergon_cli/ergon_cli/domains/tests/service.py b/ergon_cli/ergon_cli/domains/tests/service.py
index 628a5c155..2a5654f55 100644
--- a/ergon_cli/ergon_cli/domains/tests/service.py
+++ b/ergon_cli/ergon_cli/domains/tests/service.py
@@ -6,11 +6,11 @@
     BACKEND_E2E,
     BACKEND_INTEGRATION,
     BACKEND_SMOKE,
-    BENCHMARK_SMOKE_ALL,
-    BENCHMARK_SMOKE_COMMANDS,
     DASHBOARD_CONTRACTS,
     DASHBOARD_SMOKE,
     DASHBOARD_UNIT,
+    ENVIRONMENT_SMOKE_ALL,
+    ENVIRONMENT_SMOKE_COMMANDS,
     PYTHON_UNIT_ALL,
     PYTHON_UNIT_COMMANDS,
     REAL_LLM,
@@ -24,7 +24,7 @@ def resolve_test_command(command: TestCommand) -> ResolvedTestCommand:
     if command.suite == "list":
         return ResolvedTestCommand(label="Available test suites", commands=())
     if command.domain == "smoke":
-        commands = _benchmark_smoke_commands(command.suite)
+        commands = _environment_smoke_commands(command.suite)
     elif command.suite == "unit":
         commands = _unit_commands(command.domain)
     elif command.suite == "integration":
@@ -108,12 +108,12 @@ def _smoke_commands(domain: str) -> tuple[tuple[str, ...], ...]:
     raise ValueError(f"smoke tests do not support domain {domain!r}")
 
 
-def _benchmark_smoke_commands(target: str) -> tuple[tuple[str, ...], ...]:
+def _environment_smoke_commands(target: str) -> tuple[tuple[str, ...], ...]:
     if target == "full":
-        return (BENCHMARK_SMOKE_ALL,)
-    if target in BENCHMARK_SMOKE_COMMANDS:
-        return (BENCHMARK_SMOKE_COMMANDS[target],)
-    raise ValueError(f"benchmark smoke tests do not support target {target!r}")
+        return (ENVIRONMENT_SMOKE_ALL,)
+    if target in ENVIRONMENT_SMOKE_COMMANDS:
+        return (ENVIRONMENT_SMOKE_COMMANDS[target],)
+    raise ValueError(f"environment smoke tests do not support target {target!r}")
 
 
 def _require_domain(command: TestCommand, expected: str) -> None:
diff --git a/ergon_cli/ergon_cli/domains/training/commands.py b/ergon_cli/ergon_cli/domains/training/commands.py
index 9a92a94ab..c65619dbf 100644
--- a/ergon_cli/ergon_cli/domains/training/commands.py
+++ b/ergon_cli/ergon_cli/domains/training/commands.py
@@ -17,7 +17,7 @@ def handle_train(args: Namespace) -> int:
     command = TrainingCommand(
         action=args.train_action,
         ergon_url=args.ergon_url,
-        benchmark=args.benchmark,
+        environment=args.environment,
         evaluator=args.evaluator,
         limit=args.limit,
         experiment_id=args.experiment_id,
diff --git a/ergon_cli/ergon_cli/domains/training/models.py b/ergon_cli/ergon_cli/domains/training/models.py
index 070ef90fa..3c8cebec1 100644
--- a/ergon_cli/ergon_cli/domains/training/models.py
+++ b/ergon_cli/ergon_cli/domains/training/models.py
@@ -8,7 +8,7 @@ class TrainingCommand(BaseModel):
 
     action: Literal["local"]
     ergon_url: str
-    benchmark: str
+    environment: str
     evaluator: str
     limit: int | None
     experiment_id: str | None
diff --git a/ergon_cli/ergon_cli/domains/training/parser.py b/ergon_cli/ergon_cli/domains/training/parser.py
index 905fbfbb2..ffeabaa95 100644
--- a/ergon_cli/ergon_cli/domains/training/parser.py
+++ b/ergon_cli/ergon_cli/domains/training/parser.py
@@ -14,7 +14,7 @@ def register_train_parser(subparsers: argparse._SubParsersAction) -> None:
         default="http://localhost:9000/api",
         help="Ergon API URL (default: http://localhost:9000/api)",
     )
-    train_local.add_argument("--benchmark", required=True, help="Benchmark slug")
+    train_local.add_argument("--environment", required=True, help="Environment slug")
     train_local.add_argument("--evaluator", default="stub-rubric", help="Evaluator slug")
     train_local.add_argument("--limit", type=int, default=None, help="Max tasks per episode")
     train_local.add_argument("--experiment-id", default=None, help="Experiment UUID")
diff --git a/ergon_cli/ergon_cli/domains/training/service.py b/ergon_cli/ergon_cli/domains/training/service.py
index 1333422f1..b280a0f5b 100644
--- a/ergon_cli/ergon_cli/domains/training/service.py
+++ b/ergon_cli/ergon_cli/domains/training/service.py
@@ -23,7 +23,7 @@ def run_training(command: TrainingCommand) -> int:
 
     config = TrainingConfig(
         ergon_url=command.ergon_url,
-        benchmark=command.benchmark,
+        benchmark=command.environment,
         evaluator=command.evaluator,
         limit=command.limit,
         experiment_id=command.experiment_id,
diff --git a/ergon_cli/ergon_cli/domains/workflow/commands.py b/ergon_cli/ergon_cli/domains/workflow/commands.py
index 203a5c4b2..1aae54851 100644
--- a/ergon_cli/ergon_cli/domains/workflow/commands.py
+++ b/ergon_cli/ergon_cli/domains/workflow/commands.py
@@ -31,7 +31,7 @@ async def handle_workflow(args: argparse.Namespace) -> int:
             task_id=args.task_id,
             execution_id=args.execution_id,
             sandbox_task_key=args.sandbox_task_key,
-            benchmark_type=args.benchmark_type,
+            benchmark_type=args.environment_type,
         ),
         session_factory=get_session,
         service=WorkflowService(),
diff --git a/ergon_cli/ergon_cli/domains/workflow/executor.py b/ergon_cli/ergon_cli/domains/workflow/executor.py
index 599b0c65d..f6b97e910 100644
--- a/ergon_cli/ergon_cli/domains/workflow/executor.py
+++ b/ergon_cli/ergon_cli/domains/workflow/executor.py
@@ -26,7 +26,7 @@
     "--execution-id",
     "--sandbox-id",
     "--sandbox-task-key",
-    "--benchmark-type",
+    "--environment-type",
 }
 
 
diff --git a/ergon_cli/ergon_cli/domains/workflow/parser.py b/ergon_cli/ergon_cli/domains/workflow/parser.py
index c67f44258..29820cf4b 100644
--- a/ergon_cli/ergon_cli/domains/workflow/parser.py
+++ b/ergon_cli/ergon_cli/domains/workflow/parser.py
@@ -11,6 +11,6 @@ def register_workflow_parser(subparsers: argparse._SubParsersAction) -> None:
     workflow.add_argument("--execution-id", default=None, help="Current task execution UUID")
     workflow.add_argument("--sandbox-task-key", default=None, help="Sandbox task key UUID")
     workflow.add_argument(
-        "--benchmark-type", default="default", help="Benchmark/sandbox manager slug"
+        "--environment-type", default="default", help="Environment/sandbox manager slug"
     )
     workflow.add_argument("workflow_args", nargs=argparse.REMAINDER)
diff --git a/ergon_cli/tests/unit/architecture/test_cli_domain_boundaries.py b/ergon_cli/tests/unit/architecture/test_cli_domain_boundaries.py
index 898da9c77..080317e62 100644
--- a/ergon_cli/tests/unit/architecture/test_cli_domain_boundaries.py
+++ b/ergon_cli/tests/unit/architecture/test_cli_domain_boundaries.py
@@ -43,7 +43,7 @@ def test_domain_services_do_not_import_argparse() -> None:
 
 
 def test_domain_services_do_not_print_except_setup_streaming_boundaries() -> None:
-    allowed = {DOMAIN_ROOT / "benchmarks" / "service.py"}
+    allowed = {DOMAIN_ROOT / "environments" / "service.py"}
 
     for path in sorted(DOMAIN_ROOT.glob("*/service.py")):
         if path in allowed:
diff --git a/ergon_cli/tests/unit/architecture/test_cli_import_boundaries.py b/ergon_cli/tests/unit/architecture/test_cli_import_boundaries.py
index 6a7c0b151..65306d3cf 100644
--- a/ergon_cli/tests/unit/architecture/test_cli_import_boundaries.py
+++ b/ergon_cli/tests/unit/architecture/test_cli_import_boundaries.py
@@ -61,10 +61,10 @@ def test_cli_production_code_does_not_import_deleted_compatibility_paths() -> No
         assert offenders == [], f"{path}: {offenders}"
 
 
-def test_generic_cli_code_does_not_hardcode_benchmark_metadata() -> None:
+def test_generic_cli_code_does_not_hardcode_environment_metadata() -> None:
     allowed = {
-        CLI_ROOT / "domains" / "benchmarks" / "templates.py",
-        CLI_ROOT / "domains" / "benchmarks" / "service.py",
+        CLI_ROOT / "domains" / "environments" / "templates.py",
+        CLI_ROOT / "domains" / "environments" / "service.py",
     }
     forbidden_fragments = (
         "sandbox_template",
diff --git a/ergon_cli/tests/unit/cli/test_benchmark_setup.py b/ergon_cli/tests/unit/cli/test_environment_setup.py
similarity index 83%
rename from ergon_cli/tests/unit/cli/test_benchmark_setup.py
rename to ergon_cli/tests/unit/cli/test_environment_setup.py
index f36a5835e..1d20afa1a 100644
--- a/ergon_cli/tests/unit/cli/test_benchmark_setup.py
+++ b/ergon_cli/tests/unit/cli/test_environment_setup.py
@@ -1,20 +1,20 @@
-"""Tests for ``ergon benchmark setup <slug>`` CLI command."""
+"""Tests for ``ergon environment setup <slug>`` CLI command."""
 
 import json
 from pathlib import Path
 from unittest.mock import MagicMock
 
 import e2b
-import ergon_cli.domains.benchmarks.service as _bench_service
+import ergon_cli.domains.environments.service as _env_service
 import pytest
-from ergon_cli.domains.benchmarks.templates import sandbox_template_for
-from ergon_cli.domains.benchmarks.commands import setup_benchmark_service
-from ergon_cli.domains.benchmarks.models import BenchmarkCommand
+from ergon_cli.domains.environments.templates import sandbox_template_for
+from ergon_cli.domains.environments.commands import setup_environment_service
+from ergon_cli.domains.environments.models import EnvironmentCommand
 from ergon_core.core.shared.settings import settings
 
 
-def _setup_command(slug: str = "minif2f", *, force: bool = False) -> BenchmarkCommand:
-    return BenchmarkCommand(action="setup", slug=slug, force=force)
+def _setup_command(slug: str = "minif2f", *, force: bool = False) -> EnvironmentCommand:
+    return EnvironmentCommand(action="setup", slug=slug, force=force)
 
 
 class _FakeBuildInfo:
@@ -34,7 +34,7 @@ def _patch_sdk(
     build_info: _FakeBuildInfo | None = None,
     raise_on_build: Exception | None = None,
 ) -> MagicMock:
-    """Patch ``e2b.Template`` so ``setup_benchmark`` never hits the network."""
+    """Patch ``e2b.Template`` so ``setup_environment`` never hits the network."""
 
     # Builder returned from from_dockerfile()/set_start_cmd() — chainable MagicMock.
     builder = MagicMock()
@@ -50,8 +50,8 @@ def _patch_sdk(
         fake_template_cls.build.return_value = build_info or _FakeBuildInfo()
 
     monkeypatch.setattr(e2b, "Template", fake_template_cls)
-    # Also patch the already-imported name in the benchmark domain service.
-    monkeypatch.setattr(_bench_service, "Template", fake_template_cls)
+    # Also patch the already-imported name in the environment domain service.
+    monkeypatch.setattr(_env_service, "Template", fake_template_cls)
     return fake_template_cls
 
 
@@ -88,7 +88,7 @@ def test_error_scenarios(
     else:
         monkeypatch.setenv("E2B_API_KEY", "test-key")
 
-    rc = setup_benchmark_service(_setup_command(**args_kwargs))
+    rc = setup_environment_service(_setup_command(**args_kwargs))
     assert rc != 0
 
     if expected_message is not None:
@@ -115,7 +115,7 @@ def test_idempotent_skip(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Non
         json.dumps({"minif2f": {"template_id": "abc123", "template_name": "ergon-minif2f-v1"}})
     )
 
-    rc = setup_benchmark_service(_setup_command())
+    rc = setup_environment_service(_setup_command())
     assert rc == 0
     fake.build.assert_not_called()
 
@@ -131,7 +131,7 @@ def test_happy_path_creates_registry(monkeypatch: pytest.MonkeyPatch, tmp_path:
     monkeypatch.setattr(settings, "e2b_api_key", "test-key")
     fake = _patch_sdk(monkeypatch)
 
-    rc = setup_benchmark_service(_setup_command())
+    rc = setup_environment_service(_setup_command())
     assert rc == 0
 
     fake.build.assert_called_once()
@@ -151,19 +151,19 @@ def test_success_message_does_not_include_run_hint(
     tmp_path: Path,
     capsys: pytest.CaptureFixture[str],
 ) -> None:
-    """``ergon benchmark run`` was removed in PR 6.5 Phase 2 — success message must not
+    """``ergon environment run`` was removed in PR 6.5 Phase 2 — success message must not
     suggest it."""
     monkeypatch.setenv("E2B_API_KEY", "test-key")
     monkeypatch.setenv("ERGON_CONFIG_DIR", str(tmp_path))
     monkeypatch.setattr(settings, "e2b_api_key", "test-key")
     _patch_sdk(monkeypatch)
 
-    rc = setup_benchmark_service(_setup_command())
+    rc = setup_environment_service(_setup_command())
 
     assert rc == 0
     out = capsys.readouterr().out
-    # The "ergon benchmark run" hint was removed when the authoring route was deleted.
-    assert "ergon benchmark run" not in out
+    # The "ergon environment run" hint was removed when the authoring route was deleted.
+    assert "ergon environment run" not in out
     assert "Success! Template ID:" in out
 
 
@@ -179,7 +179,7 @@ def test_force_rebuild_overwrites(monkeypatch: pytest.MonkeyPatch, tmp_path: Pat
         json.dumps({"minif2f": {"template_id": "old_id", "template_name": "ergon-minif2f-v1"}})
     )
 
-    rc = setup_benchmark_service(_setup_command(force=True))
+    rc = setup_environment_service(_setup_command(force=True))
     assert rc == 0
 
     data = json.loads(registry.read_text())
@@ -197,7 +197,7 @@ def test_build_failure(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
     monkeypatch.setattr(settings, "e2b_api_key", "test-key")
     _patch_sdk(monkeypatch, raise_on_build=RuntimeError("simulated build failure"))
 
-    rc = setup_benchmark_service(_setup_command())
+    rc = setup_environment_service(_setup_command())
     assert rc != 0
 
 
@@ -210,4 +210,4 @@ def test_sandbox_template_for_known_slug_returns_template_path() -> None:
 
 def test_sandbox_template_for_unknown_slug_raises_key_error() -> None:
     with pytest.raises(KeyError):
-        sandbox_template_for("not-a-benchmark")
+        sandbox_template_for("not-a-environment")
diff --git a/ergon_cli/tests/unit/cli/test_eval_cli_required_fields.py b/ergon_cli/tests/unit/cli/test_eval_cli_required_fields.py
index bd0b3333d..a14c9fcb5 100644
--- a/ergon_cli/tests/unit/cli/test_eval_cli_required_fields.py
+++ b/ergon_cli/tests/unit/cli/test_eval_cli_required_fields.py
@@ -7,9 +7,9 @@ def test_eval_commands_require_evaluator_and_model_base(action: str) -> None:
     parser = build_parser()
     args = ["eval", action]
     if action == "watch":
-        args.extend(["--checkpoint-dir", "/tmp/checkpoints", "--benchmark", "minif2f"])
+        args.extend(["--checkpoint-dir", "/tmp/checkpoints", "--environment", "minif2f"])
     else:
-        args.extend(["--checkpoint", "/tmp/checkpoints/checkpoint-1", "--benchmark", "minif2f"])
+        args.extend(["--checkpoint", "/tmp/checkpoints/checkpoint-1", "--environment", "minif2f"])
 
     with pytest.raises(SystemExit) as exc_info:
         parser.parse_args(args)
diff --git a/ergon_cli/tests/unit/cli/test_parser_registration.py b/ergon_cli/tests/unit/cli/test_parser_registration.py
index 346777313..1d760e671 100644
--- a/ergon_cli/tests/unit/cli/test_parser_registration.py
+++ b/ergon_cli/tests/unit/cli/test_parser_registration.py
@@ -8,7 +8,7 @@
 @pytest.mark.parametrize(
     ("argv", "expected"),
     [
-        (["benchmark", "list"], {"command": "benchmark", "bench_action": "list"}),
+        (["environment", "list"], {"command": "environment", "env_action": "list"}),
         (
             ["experiment", "show", "00000000-0000-0000-0000-000000000000"],
             {"command": "experiment", "experiment_action": "show"},
@@ -46,7 +46,7 @@ def test_experimental_domains_are_not_public_top_level_commands(command: str) ->
     assert exc_info.value.code == 2
 
 
-def test_benchmark_setup_is_not_a_public_subcommand() -> None:
+def test_benchmark_command_is_not_public() -> None:
     parser = build_parser()
 
     with pytest.raises(SystemExit) as exc_info:
diff --git a/ergon_cli/tests/unit/cli/test_sample_cli.py b/ergon_cli/tests/unit/cli/test_sample_cli.py
index 06f5599e6..2b280a03a 100644
--- a/ergon_cli/tests/unit/cli/test_sample_cli.py
+++ b/ergon_cli/tests/unit/cli/test_sample_cli.py
@@ -92,6 +92,8 @@ def get_sample_summary(self, requested_sample_id: UUID) -> SampleSummaryDto:
     assert "sample-1" in out
     assert "started_at:" in out
     assert "completed_at:" in out
+    assert "environment_type:" in out
+    assert "benchmark_type:" not in out
 
 
 def test_sample_status_reports_invalid_uuid(capsys) -> None:
diff --git a/ergon_cli/tests/unit/cli/test_training_cli.py b/ergon_cli/tests/unit/cli/test_training_cli.py
index b57eb65e0..621fdd25e 100644
--- a/ergon_cli/tests/unit/cli/test_training_cli.py
+++ b/ergon_cli/tests/unit/cli/test_training_cli.py
@@ -7,7 +7,7 @@ def _train_args(**overrides: object) -> Namespace:
     data = {
         "train_action": "local",
         "ergon_url": "http://localhost:9000/api",
-        "benchmark": "bench",
+        "environment": "env",
         "evaluator": "stub-rubric",
         "limit": None,
         "experiment_id": None,
diff --git a/ergon_cli/tests/unit/state/test_env_writer.py b/ergon_cli/tests/unit/state/test_env_writer.py
index 1a55d44d0..34e3d8dd5 100644
--- a/ergon_cli/tests/unit/state/test_env_writer.py
+++ b/ergon_cli/tests/unit/state/test_env_writer.py
@@ -100,7 +100,7 @@ def test_full_profile_round_trip(self, tmp_path: Path) -> None:
         """A realistic profile produces a readable, parseable .env."""
         env_path = tmp_path / ".env"
         profile = OnboardProfile(
-            benchmarks=["gdpeval", "smoke-test"],
+            environments=["gdpeval", "smoke-test"],
             llm_providers=[LLMProvider.OPENAI, LLMProvider.ANTHROPIC],
             training=True,
             keys={
diff --git a/ergon_cli/tests/unit/state/test_onboard_profile.py b/ergon_cli/tests/unit/state/test_onboard_profile.py
index e17b6b722..727b290cf 100644
--- a/ergon_cli/tests/unit/state/test_onboard_profile.py
+++ b/ergon_cli/tests/unit/state/test_onboard_profile.py
@@ -28,27 +28,27 @@ def test_multiple_providers(self) -> None:
         assert "OPENROUTER_API_KEY" in keys
         assert "GOOGLE_API_KEY" not in keys
 
-    def test_e2b_benchmark_needs_e2b_key(self) -> None:
-        # ``minif2f`` is the lowest-dependency E2B benchmark still in the
+    def test_e2b_environment_needs_e2b_key(self) -> None:
+        # ``minif2f`` is the lowest-dependency E2B environment still in the
         # registry after the canonical-smoke cleanup removed the prior
-        # ``smoke-test`` benchmark.
-        p = OnboardProfile(benchmarks=["minif2f"])
+        # ``smoke-test`` environment.
+        p = OnboardProfile(environments=["minif2f"])
         keys = p.required_keys()
         assert "E2B_API_KEY" in keys
 
     def test_gdpeval_needs_e2b_key(self) -> None:
-        p = OnboardProfile(benchmarks=["gdpeval"])
+        p = OnboardProfile(environments=["gdpeval"])
         keys = p.required_keys()
         assert "E2B_API_KEY" in keys
 
     def test_researchrubrics_has_optional_exa(self) -> None:
-        p = OnboardProfile(benchmarks=["researchrubrics"])
+        p = OnboardProfile(environments=["researchrubrics"])
         keys = p.required_keys()
         assert "EXA_API_KEY" in keys
         assert "E2B_API_KEY" not in keys
 
     def test_no_e2b_for_researchrubrics_only(self) -> None:
-        p = OnboardProfile(benchmarks=["researchrubrics"])
+        p = OnboardProfile(environments=["researchrubrics"])
         keys = p.required_keys()
         assert "E2B_API_KEY" not in keys
 
@@ -71,7 +71,7 @@ def test_local_gpu_needs_no_provider_key(self) -> None:
 
     def test_combined_profile(self) -> None:
         p = OnboardProfile(
-            benchmarks=["gdpeval", "researchrubrics"],
+            environments=["gdpeval", "researchrubrics"],
             llm_providers=[LLMProvider.OPENAI],
             training=True,
             gpu_provider=GPUProvider.RUNPOD,
@@ -89,21 +89,21 @@ def test_empty_profile(self) -> None:
         assert p.required_extras() == []
 
     def test_gdpeval_needs_data_extra(self) -> None:
-        p = OnboardProfile(benchmarks=["gdpeval"])
+        p = OnboardProfile(environments=["gdpeval"])
         extras = p.required_extras()
         assert "ergon-builtins[data]" in extras
 
     def test_researchrubrics_needs_data_extra(self) -> None:
-        p = OnboardProfile(benchmarks=["researchrubrics"])
+        p = OnboardProfile(environments=["researchrubrics"])
         extras = p.required_extras()
         assert "ergon-builtins[data]" in extras
 
     def test_minif2f_needs_no_data_extra(self) -> None:
-        # ``minif2f`` replaces the retired ``smoke-test`` benchmark as
-        # the smallest-dependency E2B benchmark.  Smoke runs use each
-        # benchmark's real sandbox image; no separate ``smoke-test``
-        # benchmark exists after the canonical-smoke cleanup.
-        p = OnboardProfile(benchmarks=["minif2f"])
+        # ``minif2f`` replaces the retired ``smoke-test`` environment as
+        # the smallest-dependency E2B environment.  Smoke runs use each
+        # environment's real sandbox image; no separate ``smoke-test``
+        # environment exists after the canonical-smoke cleanup.
+        p = OnboardProfile(environments=["minif2f"])
         assert "ergon-builtins[data]" not in p.required_extras()
 
     def test_training_adds_infra_training(self) -> None:
@@ -124,13 +124,13 @@ def test_local_gpu_no_skypilot(self) -> None:
         assert "ergon-infra[training]" in extras
 
     def test_deduplicates_data_extra(self) -> None:
-        p = OnboardProfile(benchmarks=["gdpeval", "researchrubrics"])
+        p = OnboardProfile(environments=["gdpeval", "researchrubrics"])
         extras = p.required_extras()
         assert extras.count("ergon-builtins[data]") == 1
 
     def test_sorted_output(self) -> None:
         p = OnboardProfile(
-            benchmarks=["gdpeval"],
+            environments=["gdpeval"],
             training=True,
             gpu_provider=GPUProvider.SHADEFORM,
         )
@@ -138,16 +138,16 @@ def test_sorted_output(self) -> None:
         assert extras == sorted(extras)
 
 
-class TestPreviouslyMissingBenchmarks:
-    """Regression coverage for the remaining object-bound benchmark choices."""
+class TestPreviouslyMissingEnvironments:
+    """Regression coverage for the remaining object-bound environment choices."""
 
     def test_researchrubrics_vanilla_needs_data_extra(self) -> None:
-        p = OnboardProfile(benchmarks=["researchrubrics-vanilla"])
+        p = OnboardProfile(environments=["researchrubrics-vanilla"])
         assert "ergon-builtins[data]" in p.required_extras()
 
 
-class TestOnboardingWizardSeesAllBenchmarks:
-    """The wizard must offer all registered benchmarks."""
+class TestOnboardingWizardSeesAllEnvironments:
+    """The wizard must offer all registered environments."""
 
     def test_wizard_sees_all_registered_slugs(self) -> None:
         expected = {
@@ -157,4 +157,4 @@ def test_wizard_sees_all_registered_slugs(self) -> None:
             "researchrubrics",
             "researchrubrics-vanilla",
         }
-        assert expected <= set(profile_module.available_benchmark_slugs())
+        assert expected <= set(profile_module.available_environment_slugs())
diff --git a/ergon_core/ergon_core/api/__init__.py b/ergon_core/ergon_core/api/__init__.py
index eeecfbafc..71495e743 100644
--- a/ergon_core/ergon_core/api/__init__.py
+++ b/ergon_core/ergon_core/api/__init__.py
@@ -1,10 +1,6 @@
 """Beginner-facing Ergon authoring API surface."""
 
-from ergon_core.api.benchmark import (
-    Benchmark,
-    EmptyTaskPayload,
-    Task,
-)
+from ergon_core.api.task import EmptyTaskPayload, Task
 from ergon_core.api.criterion import (
     Criterion,
     CriterionContext,
@@ -53,7 +49,6 @@
 Task.model_rebuild()
 
 __all__ = [
-    "Benchmark",
     "AwaitCompletionNotSupportedError",
     "ContainmentViolation",
     "Criterion",
diff --git a/ergon_core/ergon_core/api/benchmark/__init__.py b/ergon_core/ergon_core/api/benchmark/__init__.py
deleted file mode 100644
index 09016f9e5..000000000
--- a/ergon_core/ergon_core/api/benchmark/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-"""Public benchmark authoring API."""
-
-from ergon_core.api.benchmark.benchmark import Benchmark
-from ergon_core.api.benchmark.task import EmptyTaskPayload, Task
-
-__all__ = ["Benchmark", "Task", "EmptyTaskPayload"]
diff --git a/ergon_core/ergon_core/api/benchmark/benchmark.py b/ergon_core/ergon_core/api/benchmark/benchmark.py
deleted file mode 100644
index f586d50d0..000000000
--- a/ergon_core/ergon_core/api/benchmark/benchmark.py
+++ /dev/null
@@ -1,84 +0,0 @@
-"""Public benchmark ABC."""
-
-from abc import ABC, abstractmethod
-from collections.abc import Mapping, Sequence
-from typing import Any, ClassVar
-
-from ergon_core.api.benchmark.task import EmptyTaskPayload, Task
-from ergon_core.api.errors import DependencyError
-from ergon_core.core.infrastructure.dependencies import check_packages
-from pydantic import BaseModel
-
-
-class Benchmark(ABC):
-    """Base class for all benchmarks."""
-
-    type_slug: ClassVar[str]
-    task_payload_model: ClassVar[type[BaseModel]] = EmptyTaskPayload
-    required_packages: ClassVar[list[str]] = []
-    install_hint: ClassVar[str | None] = None
-
-    def __init__(
-        self,
-        *,
-        name: str | None = None,
-        description: str | None = None,
-        metadata: Mapping[
-            str,
-            Any,
-        ]
-        | None = None,
-        created_by: str | None = None,
-    ) -> None:
-        self.name = name or self.__class__.__name__
-        self.description = description or ""
-        self.metadata: dict[
-            str,
-            Any,
-        ] = dict(metadata or {})
-        # `created_by` deliberately preserves `None` as the unset sentinel,
-        # unlike `name`/`description` which collapse to defaults via `or`.
-        # Attribution wants the absent state distinguishable from empty
-        # (an empty string would mean "explicitly set to nothing", which is
-        # meaningless for "who created this").
-        self.created_by = created_by
-
-    @abstractmethod
-    def build_instances(self) -> Mapping[str, Sequence[Task[BaseModel]]]:
-        """Materialize benchmark instances."""
-        ...
-
-    def evaluator_requirements(self) -> Sequence[str]:
-        """Declare evaluator slot names required by this benchmark."""
-        return ("default",)
-
-    @classmethod
-    def parse_task_payload(
-        cls,
-        payload: BaseModel
-        | Mapping[
-            str,
-            Any,
-        ]
-        | None,
-    ) -> BaseModel:
-        """Validate persisted JSON into this benchmark's payload model."""
-        if payload is None:
-            return cls.task_payload_model()
-        if isinstance(payload, cls.task_payload_model):
-            return payload
-        if isinstance(payload, BaseModel):
-            payload = payload.model_dump()
-        return cls.task_payload_model.model_validate(payload)
-
-    def validate(self) -> None:
-        """Check that runtime dependencies are available."""
-        errors = check_packages(
-            self.required_packages,
-            f"Benchmark '{self.type_slug}'",
-        )
-        if errors:
-            parts = [*errors]
-            if self.install_hint:
-                parts.append(f"Install with: {self.install_hint}")
-            raise DependencyError("\n".join(parts))
diff --git a/ergon_core/ergon_core/api/criterion/context.py b/ergon_core/ergon_core/api/criterion/context.py
index ae4338b0d..25af1a3d0 100644
--- a/ergon_core/ergon_core/api/criterion/context.py
+++ b/ergon_core/ergon_core/api/criterion/context.py
@@ -3,7 +3,7 @@
 from typing import Any
 from uuid import UUID
 
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.worker.results import WorkerOutput
 from pydantic import BaseModel, ConfigDict, Field
 
diff --git a/ergon_core/ergon_core/api/experiment/environment.py b/ergon_core/ergon_core/api/experiment/environment.py
index b6f76631b..2d640604c 100644
--- a/ergon_core/ergon_core/api/experiment/environment.py
+++ b/ergon_core/ergon_core/api/experiment/environment.py
@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from collections.abc import Iterator, Sequence
-from typing import Literal
+from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
+from typing import Any, Literal, TypeVar
 
 from pydantic import BaseModel, ConfigDict, Field, JsonValue, PrivateAttr
 
 from ergon_core.api.experiment.sample import Sample
 
+RowT = TypeVar("RowT")
+
 
 class Environment(BaseModel):
     """Base class for user-defined sample sources."""
@@ -21,6 +23,46 @@ class Environment(BaseModel):
     metadata: dict[str, JsonValue] = Field(default_factory=dict)
     _stream_cursor: Iterator[Sample] | None = PrivateAttr(default=None)
 
+    @classmethod
+    def from_dataset(
+        cls,
+        *,
+        name: str,
+        dataset: Iterable[RowT],
+        make_sample: Callable[[RowT], Sample],
+        source_mode: Literal["materialized", "streaming"] = "streaming",
+        source_metadata: Mapping[str, JsonValue] | None = None,
+        metadata: Mapping[str, JsonValue] | None = None,
+    ) -> "Environment":
+        return _RowEnvironment(
+            name=name,
+            rows=dataset,
+            make_sample=make_sample,
+            source_mode=source_mode,
+            source_metadata=dict(source_metadata or {}),
+            metadata=dict(metadata or {}),
+        )
+
+    @classmethod
+    def from_records(
+        cls,
+        *,
+        name: str,
+        records: Iterable[RowT],
+        make_sample: Callable[[RowT], Sample],
+        source_mode: Literal["materialized", "streaming"] = "materialized",
+        source_metadata: Mapping[str, JsonValue] | None = None,
+        metadata: Mapping[str, JsonValue] | None = None,
+    ) -> "Environment":
+        return cls.from_dataset(
+            name=name,
+            dataset=records,
+            make_sample=make_sample,
+            source_mode=source_mode,
+            source_metadata=source_metadata,
+            metadata=metadata,
+        )
+
     def all_samples(self) -> Sequence[Sample]:
         if self.source_mode == "streaming":
             raise NotImplementedError("Streaming environments may not materialize all samples")
@@ -46,3 +88,37 @@ def reset_stream_cursor(self) -> None:
     def validate_authoring(self) -> None:
         if not self.name:
             raise ValueError("Environment name is required")
+
+
+class _RowEnvironment(Environment):
+    """Adapter for row-backed user environments."""
+
+    _make_sample: Callable[[Any], Sample] = PrivateAttr()
+    _rows: Iterable[Any] | None = PrivateAttr(default=None)
+    _samples: Sequence[Sample] | None = PrivateAttr(default=None)
+
+    def __init__(
+        self,
+        *,
+        rows: Iterable[Any],
+        make_sample: Callable[[Any], Sample],
+        **data: Any,
+    ) -> None:
+        super().__init__(**data)
+        self._make_sample = make_sample
+        if self.source_mode == "materialized":
+            self._samples = [make_sample(row) for row in rows]
+            self._rows = None
+        else:
+            self._samples = None
+            self._rows = iter(rows)
+
+    def iter_samples(self) -> Iterator[Sample]:
+        if self.source_mode == "materialized":
+            yield from self._samples or []
+            return
+
+        if self._rows is None:
+            return
+        for row in self._rows:
+            yield self._make_sample(row)
diff --git a/ergon_core/ergon_core/api/experiment/sample.py b/ergon_core/ergon_core/api/experiment/sample.py
index f93aef7bc..8fe36e8ce 100644
--- a/ergon_core/ergon_core/api/experiment/sample.py
+++ b/ergon_core/ergon_core/api/experiment/sample.py
@@ -6,7 +6,7 @@
 
 from pydantic import BaseModel, ConfigDict, Field, JsonValue, model_validator
 
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 
 
 class Sample(BaseModel):
diff --git a/ergon_core/ergon_core/api/rubric/evaluator.py b/ergon_core/ergon_core/api/rubric/evaluator.py
index 224735f6a..f778cfd7c 100644
--- a/ergon_core/ergon_core/api/rubric/evaluator.py
+++ b/ergon_core/ergon_core/api/rubric/evaluator.py
@@ -11,7 +11,7 @@
     import_component_subclass,
     inject_type_discriminator,
 )
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.criterion.criterion import Criterion
 from ergon_core.api.criterion.outcome import CriterionOutcome
 from ergon_core.api.errors import DependencyError
diff --git a/ergon_core/ergon_core/api/rubric/rubric.py b/ergon_core/ergon_core/api/rubric/rubric.py
index 7f197d16e..5a230f8a7 100644
--- a/ergon_core/ergon_core/api/rubric/rubric.py
+++ b/ergon_core/ergon_core/api/rubric/rubric.py
@@ -5,7 +5,7 @@
 
 from pydantic import Field, field_serializer, field_validator
 
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.criterion.criterion import Criterion
 from ergon_core.api.criterion.outcome import CriterionOutcome
 from ergon_core.api.rubric.evaluator import Evaluator
diff --git a/ergon_core/ergon_core/api/benchmark/task.py b/ergon_core/ergon_core/api/task.py
similarity index 98%
rename from ergon_core/ergon_core/api/benchmark/task.py
rename to ergon_core/ergon_core/api/task.py
index 1e717c170..941605848 100644
--- a/ergon_core/ergon_core/api/benchmark/task.py
+++ b/ergon_core/ergon_core/api/task.py
@@ -1,4 +1,4 @@
-"""Public benchmark-owned task type."""
+"""Public executable task type."""
 
 import logging
 from collections.abc import Callable
@@ -24,7 +24,7 @@
 
 
 class EmptyTaskPayload(BaseModel):
-    """Default payload for benchmarks that do not need task-specific data."""
+    """Default payload for tasks that do not need task-specific data."""
 
     model_config = {"extra": "forbid", "frozen": True}
 
diff --git a/ergon_core/ergon_core/api/worker/context.py b/ergon_core/ergon_core/api/worker/context.py
index ea32a4f0e..2d13f713d 100644
--- a/ergon_core/ergon_core/api/worker/context.py
+++ b/ergon_core/ergon_core/api/worker/context.py
@@ -6,7 +6,7 @@
 
 from pydantic import AfterValidator, BaseModel, Field
 
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.errors import ContainmentViolation
 from ergon_core.api.worker.results import SpawnedTaskHandle
 from ergon_core.core.application.resources.models import SampleResourceView
diff --git a/ergon_core/ergon_core/api/worker/worker.py b/ergon_core/ergon_core/api/worker/worker.py
index 187ba8210..b9c7df495 100644
--- a/ergon_core/ergon_core/api/worker/worker.py
+++ b/ergon_core/ergon_core/api/worker/worker.py
@@ -11,7 +11,7 @@
     import_component_subclass,
     inject_type_discriminator,
 )
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.errors import DependencyError
 from ergon_core.api.sandbox.sandbox import Sandbox
 from ergon_core.api.worker.context import WorkerContext
diff --git a/ergon_core/ergon_core/core/application/experiments/candidate_pool.py b/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
index 60833a3ba..01f439bea 100644
--- a/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
+++ b/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
@@ -6,8 +6,8 @@
 from pydantic import JsonValue
 from sqlmodel import Session
 
-from ergon_core.api.benchmark import Task
-from ergon_core.api.benchmark.task import EmptyTaskPayload
+from ergon_core.api.task import Task
+from ergon_core.api.task import EmptyTaskPayload
 from ergon_core.api.experiment.experiment import Experiment, ExperimentRef
 from ergon_core.api.experiment.sample import Sample
 from ergon_core.core.application.experiments.repository import (
diff --git a/ergon_core/ergon_core/core/application/runtime/graph_repository.py b/ergon_core/ergon_core/core/application/runtime/graph_repository.py
index 33db1dd28..dce315bd8 100644
--- a/ergon_core/ergon_core/core/application/runtime/graph_repository.py
+++ b/ergon_core/ergon_core/core/application/runtime/graph_repository.py
@@ -37,7 +37,7 @@
     EdgeNotFoundError,
     NodeNotFoundError,
 )
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.core.application.runtime.models import (
     GraphEdgeDto,
     GraphNodeDto,
diff --git a/ergon_core/ergon_core/core/application/runtime/models.py b/ergon_core/ergon_core/core/application/runtime/models.py
index cc8493322..dd6361705 100644
--- a/ergon_core/ergon_core/core/application/runtime/models.py
+++ b/ergon_core/ergon_core/core/application/runtime/models.py
@@ -10,7 +10,7 @@
 
 from uuid import UUID
 
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.core.application.runtime.status import NodeStatus
 from ergon_core.core.persistence.shared.types import (
     EdgeId,
diff --git a/ergon_core/ergon_core/core/application/runtime/sample_records.py b/ergon_core/ergon_core/core/application/runtime/sample_records.py
index 62ecc52cd..46d40cb3b 100644
--- a/ergon_core/ergon_core/core/application/runtime/sample_records.py
+++ b/ergon_core/ergon_core/core/application/runtime/sample_records.py
@@ -75,6 +75,3 @@ def cancel_sample(sample_id: UUID) -> SampleRecord:
 
     logger.info("Cancelled sample %s and dispatched cleanup", sample_id)
     return sample
-
-
-cancel_run = cancel_sample
diff --git a/ergon_core/ergon_core/core/application/runtime/task_execution.py b/ergon_core/ergon_core/core/application/runtime/task_execution.py
index 258040e95..b97377cb6 100644
--- a/ergon_core/ergon_core/core/application/runtime/task_execution.py
+++ b/ergon_core/ergon_core/core/application/runtime/task_execution.py
@@ -3,7 +3,7 @@
 import logging
 from uuid import UUID
 
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.core.application.events.service import get_dashboard_event_publisher
 from ergon_core.core.application.runtime import status as graph_status
 from ergon_core.core.persistence.graph.models import SampleGraphNode
diff --git a/ergon_core/ergon_core/core/application/runtime/task_management.py b/ergon_core/ergon_core/core/application/runtime/task_management.py
index 77536e3c5..8f5bc2e42 100644
--- a/ergon_core/ergon_core/core/application/runtime/task_management.py
+++ b/ergon_core/ergon_core/core/application/runtime/task_management.py
@@ -13,7 +13,7 @@
 from uuid import UUID
 
 import inngest
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.worker.results import SpawnedTaskHandle
 from ergon_core.core.application.events.service import get_dashboard_event_publisher
 from ergon_core.core.application.ports import DashboardEventPublisher
diff --git a/ergon_core/ergon_core/core/application/samples/event_views.py b/ergon_core/ergon_core/core/application/samples/event_views.py
index 6214bfd16..cfe4cded9 100644
--- a/ergon_core/ergon_core/core/application/samples/event_views.py
+++ b/ergon_core/ergon_core/core/application/samples/event_views.py
@@ -253,7 +253,6 @@ class SampleAnnotationDeletedEventView(SampleEventBase):
     | SampleAnnotationDeletedEventView,
     Field(discriminator="event_type"),
 ]
-VIEW_EVENT_TYPES = ALL_SAMPLE_RUNTIME_EVENT_TYPES
 
 
 SampleRuntimeEventRow = (
diff --git a/ergon_core/ergon_core/core/application/testing/suppression_budget.py b/ergon_core/ergon_core/core/application/testing/suppression_budget.py
index ef0dcf664..60abc9582 100644
--- a/ergon_core/ergon_core/core/application/testing/suppression_budget.py
+++ b/ergon_core/ergon_core/core/application/testing/suppression_budget.py
@@ -102,7 +102,7 @@ class SuppressionCounts(NamedTuple):
     # `no-typing-any` (same kwargs reason). `benchmark.py`'s metadata
     # kwarg is typed `Mapping[str, Any]` matching the SWE-Bench /
     # ResearchRubrics constructor surface — but net total includes a
-    # corresponding reduction in `worker_factory.py` (deleted) so the
+    # corresponding reduction in deleted worker factory modules so the
     # arithmetic balances at +5. `noqa: C901` on `build_tools` is the
     # same structural-complexity exemption as the prior two verticals.
     # PR 10d-f net +20 slopcop_ignore. The late PR 10 stack adds the
diff --git a/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py b/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py
index d47e36317..f3cc6c676 100644
--- a/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py
+++ b/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py
@@ -24,10 +24,10 @@
 from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel, Field
 from tests.fixtures.smoke_components.benchmarks import (
-    GDPEvalSmokeBenchmark,
-    MiniF2FSmokeBenchmark,
-    ResearchRubricsSmokeBenchmark,
-    SweBenchSmokeBenchmark,
+    GDPEvalSmokeEnvironment,
+    MiniF2FSmokeEnvironment,
+    ResearchRubricsSmokeEnvironment,
+    SweBenchSmokeEnvironment,
 )
 
 router = APIRouter(
@@ -36,13 +36,13 @@
     include_in_schema=False,
 )
 
-_SMOKE_BENCHMARKS = {
-    benchmark.type_slug: benchmark
-    for benchmark in (
-        GDPEvalSmokeBenchmark,
-        MiniF2FSmokeBenchmark,
-        ResearchRubricsSmokeBenchmark,
-        SweBenchSmokeBenchmark,
+_SMOKE_ENVIRONMENTS = {
+    environment.environment_slug: environment
+    for environment in (
+        GDPEvalSmokeEnvironment,
+        MiniF2FSmokeEnvironment,
+        ResearchRubricsSmokeEnvironment,
+        SweBenchSmokeEnvironment,
     )
 }
 
@@ -143,7 +143,7 @@ def read_experiment_samples(
 
 
 class SeedSampleRequest(BaseModel):
-    benchmark_type: str = "test-harness"
+    environment_type: str = "test-harness"
     instance_key: str = "seeded"
     worker_team: dict = Field(default_factory=lambda: {"primary": "test-harness-worker"})
     experiment: str = "_test_"
@@ -161,7 +161,7 @@ def seed_sample(
 ) -> dict:
     try:
         sample_id = _seed_sample(
-            benchmark_type=body.benchmark_type,
+            benchmark_type=body.environment_type,
             instance_key=body.instance_key,
             worker_team=body.worker_team,
             experiment=body.experiment,
@@ -202,7 +202,7 @@ class ExperimentSampleSlotRequest(BaseModel):
 
 
 class SubmitExperimentSamplesRequest(BaseModel):
-    benchmark_slug: str
+    environment_slug: str
     slots: list[ExperimentSampleSlotRequest]
     experiment: str
     sandbox_slug: str | None = None
@@ -234,52 +234,37 @@ async def submit_experiment_samples(
     sample_ids: list[UUID] = []
     for slot in body.slots:
         try:
-            benchmark_cls = _SMOKE_BENCHMARKS[body.benchmark_slug]
+            environment_cls = _SMOKE_ENVIRONMENTS[body.environment_slug]
         except KeyError:
-            known = ", ".join(sorted(_SMOKE_BENCHMARKS))
+            known = ", ".join(sorted(_SMOKE_ENVIRONMENTS))
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"Unknown smoke benchmark {body.benchmark_slug!r}; known: {known}",
+                detail=f"Unknown smoke environment {body.environment_slug!r}; known: {known}",
             ) from None
-        benchmark_source = benchmark_cls(
+        environment = environment_cls(
             metadata={
-                "benchmark_slug": body.benchmark_slug,
+                "environment_slug": body.environment_slug,
                 "source": "test-harness",
                 "experiment": body.experiment,
                 "default_worker_team": {"primary": slot.worker_slug},
                 "default_evaluator_slug": slot.evaluator_slug,
                 "default_model_target": body.model,
-                "sandbox_slug": body.sandbox_slug or body.benchmark_slug,
+                "sandbox_slug": body.sandbox_slug or body.environment_slug,
                 "dependency_extras": list(body.dependency_extras),
             },
-            created_by="test-harness",
-        )
-        setattr(benchmark_source, "worker_slug", slot.worker_slug)
-        setattr(benchmark_source, "model", body.model)
-        authored_samples: list[Sample] = []
-        for instance_key, tasks in benchmark_source.build_instances().items():
-            authored_samples.append(
-                Sample.from_tasks(
-                    name=f"{body.benchmark_slug}:{instance_key}",
-                    sample_key=instance_key,
-                    environment_name=body.benchmark_slug,
-                    tasks=tasks,
-                    sample_ref={"instance_key": instance_key},
-                    metadata={
-                        "experiment": body.experiment,
-                        "worker_slug": slot.worker_slug,
-                        "evaluator_slug": slot.evaluator_slug,
-                    },
-                )
-            )
-        environment = _HarnessEnvironment(
-            name=body.benchmark_slug,
-            samples=authored_samples[: body.limit],
-            metadata={"source": "test-harness"},
+            name=body.environment_slug,
+            worker_slug=slot.worker_slug,
+            model=body.model,
         )
         experiment = Experiment(
             name=body.experiment,
-            environments=[environment],
+            environments=[
+                _HarnessEnvironment(
+                    name=body.environment_slug,
+                    samples=list(environment.iter_samples())[: body.limit],
+                    metadata={"source": "test-harness"},
+                )
+            ],
             metadata={"source": "test-harness"},
         )
         with get_session() as session:
diff --git a/ergon_core/ergon_core/core/jobs/task/execute/job.py b/ergon_core/ergon_core/core/jobs/task/execute/job.py
index 134d01836..68d4d3982 100644
--- a/ergon_core/ergon_core/core/jobs/task/execute/job.py
+++ b/ergon_core/ergon_core/core/jobs/task/execute/job.py
@@ -62,8 +62,8 @@
 from ergon_core.core.jobs.task.evaluate.contract import TaskEvaluateRequest
 from ergon_core.core.jobs.task.propagate.contract import TaskCompletedEvent, TaskFailedEvent
 from ergon_core.core.jobs.task.worker_execute.contract import (
-    WorkerExecuteJobRequest,
-    WorkerExecuteJobResult,
+    WorkerExecuteRequest,
+    WorkerExecuteResult,
 )
 from ergon_core.core.application.runtime.task_execution import TaskExecutionService
 from ergon_core.core.application.runtime.orchestration import (
@@ -136,7 +136,7 @@ async def _invoke_worker_execute(
     prepared: PreparedTaskExecution,
     sandbox_result: SandboxReadyResult,
     worker_execute_function: Any,
-) -> WorkerExecuteJobResult:
+) -> WorkerExecuteResult:
     if prepared.assigned_worker_slug is None or prepared.worker_type is None:
         raise ContractViolationError(
             "prepared task execution is missing worker identity",
@@ -146,7 +146,7 @@ async def _invoke_worker_execute(
     return await ctx.step.invoke(
         "worker-execute",
         function=worker_execute_function,
-        data=WorkerExecuteJobRequest(
+        data=WorkerExecuteRequest(
             sample_id=payload.sample_id,
             task_id=payload.task_id,
             execution_id=prepared.execution_id,
diff --git a/ergon_core/ergon_core/core/jobs/task/worker_execute/contract.py b/ergon_core/ergon_core/core/jobs/task/worker_execute/contract.py
index ec9bea11c..c6b1c33c5 100644
--- a/ergon_core/ergon_core/core/jobs/task/worker_execute/contract.py
+++ b/ergon_core/ergon_core/core/jobs/task/worker_execute/contract.py
@@ -29,7 +29,3 @@ class WorkerExecuteResult(BaseModel):
     final_assistant_message: str | None = None
     error: str | None = None
     error_json: JsonObject | None = None
-
-
-WorkerExecuteJobRequest = WorkerExecuteRequest
-WorkerExecuteJobResult = WorkerExecuteResult
diff --git a/ergon_core/ergon_core/core/jobs/task/worker_execute/job.py b/ergon_core/ergon_core/core/jobs/task/worker_execute/job.py
index aafa421b0..c438ce864 100644
--- a/ergon_core/ergon_core/core/jobs/task/worker_execute/job.py
+++ b/ergon_core/ergon_core/core/jobs/task/worker_execute/job.py
@@ -13,7 +13,7 @@
 from typing import Any, cast
 from uuid import UUID
 
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.worker import WorkerContext, WorkerOutput, WorkerStreamItem
 from ergon_core.api.worker.results import SpawnedTaskHandle
 from ergon_core.core.jobs._events import send_job_step_event
@@ -28,8 +28,8 @@
 from ergon_core.core.application.context.service import ContextEventService
 from ergon_core.core.infrastructure.inngest.errors import ContractViolationError
 from ergon_core.core.persistence.context.models import SampleContextEvent
-from .contract import WorkerExecuteJobRequest
-from .contract import WorkerExecuteJobResult
+from .contract import WorkerExecuteRequest
+from .contract import WorkerExecuteResult
 from ergon_core.core.infrastructure.tracing import (
     CompletedSpan,
     get_trace_sink,
@@ -44,10 +44,10 @@
 
 
 async def run_worker_execute_job(
-    payload: WorkerExecuteJobRequest,
+    payload: WorkerExecuteRequest,
     *,
     ctx: object | None = None,
-) -> WorkerExecuteJobResult:
+) -> WorkerExecuteResult:
     logger.info(
         "worker-execute sample_id=%s task_id=%s worker_type=%s",
         payload.sample_id,
@@ -128,7 +128,7 @@ async def _publish_context_event(event: SampleContextEvent) -> None:
             chunk_count,
             error_msg,
         )
-        return WorkerExecuteJobResult(
+        return WorkerExecuteResult(
             success=False,
             error=error_msg,
             error_json={
@@ -190,7 +190,7 @@ async def _publish_context_event(event: SampleContextEvent) -> None:
         )
     )
 
-    return WorkerExecuteJobResult(
+    return WorkerExecuteResult(
         success=output.success,
         final_assistant_message=output.output,
         error=None if output.success else output.output,
@@ -332,7 +332,7 @@ async def _consume_worker_stream(
 
 async def _persist_context_events(
     context_event_repo: ContextEventService,
-    payload: WorkerExecuteJobRequest,
+    payload: WorkerExecuteRequest,
     chunk: ContextPartChunk,
     chunk_count: int,
 ) -> None:
diff --git a/ergon_core/ergon_core/test_support/task_factory.py b/ergon_core/ergon_core/test_support/task_factory.py
index 018f58562..45e5e1885 100644
--- a/ergon_core/ergon_core/test_support/task_factory.py
+++ b/ergon_core/ergon_core/test_support/task_factory.py
@@ -12,7 +12,7 @@
 from uuid import UUID
 
 from ergon_core.api.sandbox.sandbox import Sandbox
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.worker.worker import Worker
 from ergon_core.api.worker.results import WorkerOutput
 
diff --git a/ergon_core/tests/integration/experiments/test_submit_starts_materialized_sample.py b/ergon_core/tests/integration/experiments/test_submit_starts_materialized_sample.py
index efc2534c2..40b2b9a0d 100644
--- a/ergon_core/tests/integration/experiments/test_submit_starts_materialized_sample.py
+++ b/ergon_core/tests/integration/experiments/test_submit_starts_materialized_sample.py
@@ -6,7 +6,7 @@
 from sqlmodel import Session, SQLModel, create_engine, select
 
 from ergon_core.api import Sample
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.api.criterion.outcome import CriterionOutcome
 from ergon_core.api.rubric.evaluator import Evaluator
 from ergon_core.api.rubric.results import TaskEvaluationResult
diff --git a/ergon_core/tests/unit/api/test_benchmark_constructor.py b/ergon_core/tests/unit/api/test_benchmark_constructor.py
deleted file mode 100644
index 396978a7b..000000000
--- a/ergon_core/tests/unit/api/test_benchmark_constructor.py
+++ /dev/null
@@ -1,40 +0,0 @@
-"""Unit tests for ``Benchmark.__init__`` identity kwargs.
-
-Locks in the name/description/created_by asymmetry: name and description
-collapse `None` to defaults via `or`; created_by preserves `None` as the
-unset attribution sentinel.
-"""
-
-from collections.abc import Mapping, Sequence
-from typing import ClassVar
-
-from ergon_core.api import Benchmark
-from ergon_core.api.benchmark import Task
-
-
-class _NoopBenchmark(Benchmark):
-    type_slug: ClassVar[str] = "test-noop"
-
-    def build_instances(self) -> Mapping[str, Sequence[Task]]:
-        return {}
-
-
-def test_name_defaults_to_class_name_when_none() -> None:
-    assert _NoopBenchmark(name=None).name == "_NoopBenchmark"
-
-
-def test_name_round_trips_when_set() -> None:
-    assert _NoopBenchmark(name="custom").name == "custom"
-
-
-def test_created_by_defaults_to_none() -> None:
-    assert _NoopBenchmark().created_by is None
-
-
-def test_created_by_round_trips_when_set() -> None:
-    assert _NoopBenchmark(created_by="alice").created_by == "alice"
-
-
-def test_description_round_trips() -> None:
-    assert _NoopBenchmark(description="bar").description == "bar"
-    assert _NoopBenchmark(description=None).description == ""
diff --git a/ergon_core/tests/unit/api/test_environment_constructors.py b/ergon_core/tests/unit/api/test_environment_constructors.py
new file mode 100644
index 000000000..1e084cc04
--- /dev/null
+++ b/ergon_core/tests/unit/api/test_environment_constructors.py
@@ -0,0 +1,59 @@
+from collections.abc import Iterable
+from itertools import islice
+from uuid import uuid4
+
+import pytest
+
+from ergon_core.api import Environment, Sample
+from ergon_core.test_support.task_factory import task_with_id
+
+
+def make_sample(row: str) -> Sample:
+    return Sample.from_tasks(
+        name=f"sample:{row}",
+        sample_key=row,
+        environment_name="records",
+        tasks=[
+            task_with_id(
+                uuid4(),
+                task_slug=f"solve-{row}",
+                instance_key=row,
+                description=f"Solve {row}",
+            )
+        ],
+    )
+
+
+def test_from_records_materializes_rows_to_samples() -> None:
+    env = Environment.from_records(
+        name="records",
+        records=["a", "b"],
+        make_sample=make_sample,
+    )
+
+    assert env.source_mode == "materialized"
+    assert [sample.sample_key for sample in env.all_samples()] == ["a", "b"]
+    assert [sample.sample_key for sample in env.all_samples()] == ["a", "b"]
+
+
+def test_from_dataset_streams_rows_to_samples_without_replaying_cursor() -> None:
+    def rows() -> Iterable[str]:
+        yield "a"
+        yield "b"
+        yield "c"
+
+    env = Environment.from_dataset(
+        name="dataset",
+        dataset=rows(),
+        make_sample=make_sample,
+    )
+
+    assert env.source_mode == "streaming"
+    with pytest.raises(NotImplementedError):
+        env.all_samples()
+
+    first = [sample.sample_key for sample in islice(env.iter_candidate_samples(), 2)]
+    second = [sample.sample_key for sample in islice(env.iter_candidate_samples(), 1)]
+
+    assert first == ["a", "b"]
+    assert second == ["c"]
diff --git a/ergon_core/tests/unit/api/test_public_api_definition_roundtrip.py b/ergon_core/tests/unit/api/test_public_api_definition_roundtrip.py
index 4eb2b26e5..237855e25 100644
--- a/ergon_core/tests/unit/api/test_public_api_definition_roundtrip.py
+++ b/ergon_core/tests/unit/api/test_public_api_definition_roundtrip.py
@@ -6,7 +6,7 @@
 
 import pytest
 
-from ergon_core.api.benchmark.task import EmptyTaskPayload, Task
+from ergon_core.api.task import EmptyTaskPayload, Task
 from ergon_core.api.criterion.context import CriterionContext
 from ergon_core.api.criterion.criterion import Criterion
 from ergon_core.api.criterion import CriterionOutcome
@@ -129,7 +129,7 @@ def test_criterion_from_definition_requires_type_discriminator() -> None:
 
 def test_criterion_from_definition_rejects_non_criterion_type() -> None:
     with pytest.raises(TypeError, match="Criterion _type.*Criterion subclass"):
-        Criterion.from_definition({"_type": "ergon_core.api.benchmark.task:Task", "slug": "wrong"})
+        Criterion.from_definition({"_type": "ergon_core.api.task:Task", "slug": "wrong"})
 
 
 def test_parametrized_generic_task_type_is_rejected_when_persisting() -> None:
diff --git a/ergon_core/tests/unit/api/test_worker_contract.py b/ergon_core/tests/unit/api/test_worker_contract.py
index fea3b7323..81e60be16 100644
--- a/ergon_core/tests/unit/api/test_worker_contract.py
+++ b/ergon_core/tests/unit/api/test_worker_contract.py
@@ -1,6 +1,6 @@
 from collections.abc import AsyncGenerator
 
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.api.worker import Worker, WorkerContext, WorkerOutput
 from ergon_core.api.worker.worker import WorkerStreamItem
 
diff --git a/ergon_core/tests/unit/api/worker/test_worker_context_facade.py b/ergon_core/tests/unit/api/worker/test_worker_context_facade.py
index b5102e7af..ea963c997 100644
--- a/ergon_core/tests/unit/api/worker/test_worker_context_facade.py
+++ b/ergon_core/tests/unit/api/worker/test_worker_context_facade.py
@@ -8,7 +8,7 @@
 from sqlalchemy.pool import StaticPool
 from sqlmodel import Session, SQLModel, create_engine
 
-from ergon_core.api.benchmark.task import EmptyTaskPayload, Task
+from ergon_core.api.task import EmptyTaskPayload, Task
 from ergon_core.api.errors import ContainmentViolation
 from ergon_core.api.worker.context import WorkerContext
 from ergon_core.api.worker.results import AwaitCompletionNotSupportedError, SpawnedTaskHandle
diff --git a/ergon_core/tests/unit/architecture/test_no_deleted_v2_symbols.py b/ergon_core/tests/unit/architecture/test_no_deleted_v2_symbols.py
index 9e85e86f7..a0886875d 100644
--- a/ergon_core/tests/unit/architecture/test_no_deleted_v2_symbols.py
+++ b/ergon_core/tests/unit/architecture/test_no_deleted_v2_symbols.py
@@ -37,6 +37,25 @@
     "launch_run",
     "run_experiment",
     "BenchmarkRequirements",
+    "class Benchmark",
+    "class MiniF2FBenchmark",
+    "class SweBenchVerifiedBenchmark",
+    "class ResearchRubricsBenchmark",
+    "class ResearchRubricsVanillaBenchmark",
+    "class GDPEvalBenchmark",
+    "from ergon_core.api import Benchmark",
+    "from ergon_core.api.benchmark import Benchmark",
+    "ergon_core.api.benchmark",
+    "ergon_cli.domains.benchmarks",
+    "register_benchmark_parser",
+    "handle_benchmark",
+    "setup_benchmark",
+    "BenchmarkCommand",
+    "benchmark_cli_metadata",
+    "ergon benchmark",
+    "build_instances(",
+    "evaluator_requirements(",
+    "task_payload_model",
     "parent_node_id",
     "source_node_id",
     "target_node_id",
diff --git a/ergon_core/tests/unit/architecture/test_public_api_serialization_contracts.py b/ergon_core/tests/unit/architecture/test_public_api_serialization_contracts.py
index f5c7d0474..f60b7dd07 100644
--- a/ergon_core/tests/unit/architecture/test_public_api_serialization_contracts.py
+++ b/ergon_core/tests/unit/architecture/test_public_api_serialization_contracts.py
@@ -9,31 +9,58 @@
     import_component,
     inject_type_discriminator,
 )
-from ergon_core.api.benchmark import Benchmark
-from ergon_core.api.criterion import Criterion
-from ergon_core.api.rubric import Evaluator, Rubric
-from ergon_core.api.worker import Worker
-from ergon_builtins.benchmarks.minif2f.benchmark import MiniF2FTask
+from ergon_builtins.agents.react.worker import ReActWorker
+from ergon_builtins.benchmarks.minif2f.prompts import MINIF2F_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.minif2f.rubric import MiniF2FRubric
 from ergon_builtins.benchmarks.minif2f.sandbox import LeanSandbox
+from ergon_builtins.benchmarks.minif2f.task import MiniF2FTask
 from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FTaskPayload
-from ergon_builtins.benchmarks.minif2f.worker_factory import (
-    make_minif2f_rubric,
-    make_minif2f_worker,
-)
-from ergon_builtins.benchmarks.researchrubrics.benchmark import ResearchRubricsTask
+from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
+from ergon_builtins.benchmarks.researchrubrics.prompts import RESEARCH_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.researchrubrics.rubric import ResearchRubricsRubric
 from ergon_builtins.benchmarks.researchrubrics.sandbox import ResearchE2BSandbox
+from ergon_builtins.benchmarks.researchrubrics.task import ResearchRubricsTask
 from ergon_builtins.benchmarks.researchrubrics.task_schemas import ResearchRubricsTaskPayload
-from ergon_builtins.benchmarks.researchrubrics.worker_factory import (
-    make_research_rubric,
-    make_research_worker,
-)
-from ergon_builtins.benchmarks.swebench_verified.benchmark import SweBenchTask
+from ergon_builtins.benchmarks.researchrubrics.toolkit import ResearchRubricsToolkit
+from ergon_builtins.benchmarks.swebench_verified.prompts import SWEBENCH_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.swebench_verified.rubric import SWEBenchRubric
 from ergon_builtins.benchmarks.swebench_verified.sandbox import SWEBenchSandbox
+from ergon_builtins.benchmarks.swebench_verified.task import SweBenchTask
 from ergon_builtins.benchmarks.swebench_verified.task_schemas import SWEBenchTaskPayload
-from ergon_builtins.benchmarks.swebench_verified.worker_factory import (
-    make_swebench_rubric,
-    make_swebench_worker,
-)
+from ergon_builtins.benchmarks.swebench_verified.toolkit import SWEBenchToolkit
+from ergon_core.api.criterion import Criterion
+from ergon_core.api.rubric import Evaluator, Rubric
+from ergon_core.api.worker import Worker
+
+
+def _minif2f_worker() -> ReActWorker:
+    return ReActWorker(
+        name="mini-proof-solver",
+        model="test:none",
+        system_prompt=MINIF2F_SYSTEM_PROMPT,
+        max_iterations=30,
+        toolkit=MiniF2FToolkit(),
+    )
+
+
+def _swebench_worker() -> ReActWorker:
+    return ReActWorker(
+        name="swebench-solver",
+        model="test:none",
+        system_prompt=SWEBENCH_SYSTEM_PROMPT,
+        max_iterations=50,
+        toolkit=SWEBenchToolkit(),
+    )
+
+
+def _research_worker() -> ReActWorker:
+    return ReActWorker(
+        name="research-runner",
+        model="test:none",
+        system_prompt=RESEARCH_SYSTEM_PROMPT,
+        max_iterations=16,
+        toolkit=ResearchRubricsToolkit(),
+    )
 
 
 _REPO_ROOT = Path(__file__).resolve().parents[4]
@@ -98,7 +125,7 @@ def test_rubric_is_intentionally_core_public_api_evaluator() -> None:
 
 
 def test_dependency_bearing_public_components_require_install_hints() -> None:
-    for base in (Benchmark, Worker, Criterion, Evaluator):
+    for base in (Worker, Criterion, Evaluator):
         assert base.install_hint is None
 
     dependency_bearing_components: list[str] = []
@@ -118,7 +145,6 @@ def test_dependency_bearing_public_components_require_install_hints() -> None:
                 if not _is_non_empty_literal_string(assignments.get("install_hint")):
                     missing_install_hints.append(component)
 
-    assert dependency_bearing_components
     assert missing_install_hints == []
 
 
@@ -133,9 +159,9 @@ def test_type_discriminator_helpers_use_importable_component_paths() -> None:
             formal_statement="theorem mini : 1 = 1 := by",
             header="import Mathlib\n",
         ),
-        worker=make_minif2f_worker(),
+        worker=_minif2f_worker(),
         sandbox=LeanSandbox(),
-        evaluators=(make_minif2f_rubric(),),
+        evaluators=(MiniF2FRubric(name="minif2f-rubric"),),
     )
     payload: dict[str, object] = {"task_slug": task.task_slug}
 
@@ -158,9 +184,9 @@ def test_migrated_builtin_task_classes_persist_importable_type_discriminators()
                 formal_statement="theorem mini : 1 = 1 := by",
                 header="import Mathlib\n",
             ),
-            worker=make_minif2f_worker(),
+            worker=_minif2f_worker(),
             sandbox=LeanSandbox(),
-            evaluators=(make_minif2f_rubric(),),
+            evaluators=(MiniF2FRubric(name="minif2f-rubric"),),
         ),
         SweBenchTask(
             task_slug="swe",
@@ -177,9 +203,9 @@ def test_migrated_builtin_task_classes_persist_importable_type_discriminators()
                 environment_setup_commit="abcdef123456",
                 test_patch="diff --git a/test.py b/test.py\n",
             ),
-            worker=make_swebench_worker(),
+            worker=_swebench_worker(),
             sandbox=SWEBenchSandbox(),
-            evaluators=(make_swebench_rubric(),),
+            evaluators=(SWEBenchRubric(name="swebench-rubric"),),
         ),
         ResearchRubricsTask(
             task_slug="rr",
@@ -191,9 +217,9 @@ def test_migrated_builtin_task_classes_persist_importable_type_discriminators()
                 prompt="Write a report.",
                 rubrics=[],
             ),
-            worker=make_research_worker(),
+            worker=_research_worker(),
             sandbox=ResearchE2BSandbox(),
-            evaluators=(make_research_rubric(),),
+            evaluators=(ResearchRubricsRubric(name="researchrubrics-rubric"),),
         ),
     )
 
diff --git a/ergon_core/tests/unit/architecture/test_public_api_target_structure.py b/ergon_core/tests/unit/architecture/test_public_api_target_structure.py
index 13e961872..de8cd31ba 100644
--- a/ergon_core/tests/unit/architecture/test_public_api_target_structure.py
+++ b/ergon_core/tests/unit/architecture/test_public_api_target_structure.py
@@ -10,7 +10,6 @@ def test_public_api_root_exports_semantic_authoring_names_only() -> None:
     public_api = importlib.import_module("ergon_core.api")
 
     expected = {
-        "Benchmark",
         "Task",
         "EmptyTaskPayload",
         "Environment",
@@ -53,6 +52,7 @@ def test_public_api_root_exports_semantic_authoring_names_only() -> None:
     }
     retired = {
         "BenchmarkTask",
+        "Benchmark",
         "BenchmarkDeps",
         "EvaluationContext",
         "CriterionResult",
@@ -83,16 +83,13 @@ def test_public_api_root_exports_semantic_authoring_names_only() -> None:
 
 
 def test_semantic_api_clusters_are_importable() -> None:
-    benchmark = importlib.import_module("ergon_core.api.benchmark")
+    task = importlib.import_module("ergon_core.api.task")
     worker = importlib.import_module("ergon_core.api.worker")
     criterion = importlib.import_module("ergon_core.api.criterion")
     rubric = importlib.import_module("ergon_core.api.rubric")
 
-    assert benchmark.__all__ == [
-        "Benchmark",
-        "Task",
-        "EmptyTaskPayload",
-    ]
+    assert task.Task.__module__ == "ergon_core.api.task"
+    assert task.EmptyTaskPayload.__module__ == "ergon_core.api.task"
     # PR 9 Task 1 added ``SpawnedTaskHandle`` to the worker cluster as
     # the return type of ``WorkerContext.spawn_task`` and
     # ``WorkerContext.restart_task``.
diff --git a/ergon_core/tests/unit/architecture/test_runtime_read_boundaries.py b/ergon_core/tests/unit/architecture/test_runtime_read_boundaries.py
index d78eee6c5..7ca7b157e 100644
--- a/ergon_core/tests/unit/architecture/test_runtime_read_boundaries.py
+++ b/ergon_core/tests/unit/architecture/test_runtime_read_boundaries.py
@@ -37,12 +37,12 @@ def test_worker_execute_prefers_task_worker_over_payload_bridge() -> None:
     """PR 5 makes ``task.worker`` the canonical source.
 
     The body must read the worker off ``task.worker`` first. A narrow
-    compatibility fallback used to live in a sibling module and only
-    fired when ``task.worker is None`` — i.e. when an unmigrated
-    TaskSpec-returning benchmark reached this path. The body must NOT import
+    bridge used to live in a sibling module and only fired when
+    ``task.worker is None`` — i.e. when an unmigrated TaskSpec-returning
+    fixture reached this path. The body must NOT import
     ``ComponentCatalogService`` directly or define an in-body
     ``_worker_from_payload_bridge`` function; both belong in the
-    sibling. PR 11 (after PR 10c migrates the last benchmark) deletes
+    sibling. PR 11 (after PR 10c migrates the last environment) deletes
     the sibling module and the ``if worker is None:`` branch.
     """
 
diff --git a/ergon_core/tests/unit/architecture/test_v2_final_state_ledger.py b/ergon_core/tests/unit/architecture/test_v2_final_state_ledger.py
index 782415f6d..a5aff2ca9 100644
--- a/ergon_core/tests/unit/architecture/test_v2_final_state_ledger.py
+++ b/ergon_core/tests/unit/architecture/test_v2_final_state_ledger.py
@@ -99,7 +99,7 @@ def _assert_task_has_no_model_post_init() -> None:
 
     import inspect
 
-    from ergon_core.api.benchmark.task import Task
+    from ergon_core.api.task import Task
 
     source = inspect.getsource(Task)
     assert "def model_post_init" not in source, (
diff --git a/ergon_core/tests/unit/core/application/experiments/test_sample_materialization.py b/ergon_core/tests/unit/core/application/experiments/test_sample_materialization.py
index c23bd5f03..b2e976b46 100644
--- a/ergon_core/tests/unit/core/application/experiments/test_sample_materialization.py
+++ b/ergon_core/tests/unit/core/application/experiments/test_sample_materialization.py
@@ -6,7 +6,7 @@
 from sqlmodel import Session, SQLModel, create_engine, select
 
 from ergon_core.api import Sample
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.api.criterion.outcome import CriterionOutcome
 from ergon_core.api.rubric.evaluator import Evaluator
 from ergon_core.api.rubric.results import TaskEvaluationResult
diff --git a/ergon_core/tests/unit/core/application/jobs/test_worker_execute_live_sandbox_attach.py b/ergon_core/tests/unit/core/application/jobs/test_worker_execute_live_sandbox_attach.py
index ae527b0a3..efebb0d5b 100644
--- a/ergon_core/tests/unit/core/application/jobs/test_worker_execute_live_sandbox_attach.py
+++ b/ergon_core/tests/unit/core/application/jobs/test_worker_execute_live_sandbox_attach.py
@@ -6,7 +6,7 @@
 
 from ergon_core.core.jobs.task.execute.contract import TaskReadyEvent
 from ergon_core.api.worker.results import WorkerOutput
-from ergon_core.core.jobs.task.worker_execute.contract import WorkerExecuteJobRequest
+from ergon_core.core.jobs.task.worker_execute.contract import WorkerExecuteRequest
 from ergon_core.core.jobs.task.worker_execute.job import run_worker_execute_job
 
 
@@ -71,7 +71,7 @@ async def _publish(_event):
     )
 
     result = await run_worker_execute_job(
-        WorkerExecuteJobRequest(
+        WorkerExecuteRequest(
             sample_id=uuid4(),
             task_id=uuid4(),
             execution_id=uuid4(),
@@ -113,7 +113,7 @@ async def load_task_view(self, _session, *, sample_id, task_id, sandbox_id=None)
 
     with pytest.raises(Exception, match="live sandbox"):
         await run_worker_execute_job(
-            WorkerExecuteJobRequest(
+            WorkerExecuteRequest(
                 sample_id=uuid4(),
                 task_id=uuid4(),
                 execution_id=uuid4(),
diff --git a/ergon_core/tests/unit/core/application/tasks/test_spawn_dynamic_task_dispatch.py b/ergon_core/tests/unit/core/application/tasks/test_spawn_dynamic_task_dispatch.py
index 3216550f2..b1c6c24c3 100644
--- a/ergon_core/tests/unit/core/application/tasks/test_spawn_dynamic_task_dispatch.py
+++ b/ergon_core/tests/unit/core/application/tasks/test_spawn_dynamic_task_dispatch.py
@@ -4,7 +4,7 @@
 
 import pytest
 
-from ergon_core.api.benchmark.task import EmptyTaskPayload, Task
+from ergon_core.api.task import EmptyTaskPayload, Task
 from ergon_core.core.application.runtime.task_management import TaskManagementService
 from ergon_core.test_support.task_factory import TestSandbox, TestWorker
 
diff --git a/ergon_core/tests/unit/read_models/test_sample_read_service.py b/ergon_core/tests/unit/read_models/test_sample_read_service.py
index 20f62afc2..2d2267a92 100644
--- a/ergon_core/tests/unit/read_models/test_sample_read_service.py
+++ b/ergon_core/tests/unit/read_models/test_sample_read_service.py
@@ -8,7 +8,6 @@
 from ergon_core.core.application.samples.event_views import (
     ALL_SAMPLE_RUNTIME_EVENT_TYPES,
     ROW_MODEL_EVENT_TYPES,
-    VIEW_EVENT_TYPES,
     SampleRuntimeEventView,
 )
 from ergon_core.core.persistence.experiments.models import ExperimentEnvironmentRow, ExperimentRow
@@ -297,7 +296,6 @@ def test_sample_runtime_event_view_union_covers_every_typed_wal_event() -> None:
     }
 
     assert ROW_MODEL_EVENT_TYPES == ALL_SAMPLE_RUNTIME_EVENT_TYPES
-    assert VIEW_EVENT_TYPES == ALL_SAMPLE_RUNTIME_EVENT_TYPES
     assert union_event_types == ALL_SAMPLE_RUNTIME_EVENT_TYPES
 
 
diff --git a/ergon_core/tests/unit/runtime/_test_workers.py b/ergon_core/tests/unit/runtime/_test_workers.py
index 42f277784..76ef9051c 100644
--- a/ergon_core/tests/unit/runtime/_test_workers.py
+++ b/ergon_core/tests/unit/runtime/_test_workers.py
@@ -10,7 +10,7 @@
 from ergon_core.api.worker.worker import Worker, WorkerStreamItem
 from ergon_core.api.worker.context import WorkerContext
 from ergon_core.api.worker.results import WorkerOutput
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 
 
 class EchoSandbox(Sandbox):
diff --git a/ergon_core/tests/unit/runtime/test_execute_task_evaluator_fanout.py b/ergon_core/tests/unit/runtime/test_execute_task_evaluator_fanout.py
index 637c0f461..d3ea086f1 100644
--- a/ergon_core/tests/unit/runtime/test_execute_task_evaluator_fanout.py
+++ b/ergon_core/tests/unit/runtime/test_execute_task_evaluator_fanout.py
@@ -24,7 +24,7 @@
 from ergon_core.core.jobs.task.execute import job as execute_task_module
 from ergon_core.core.jobs.resources.persist_outputs.contract import PersistOutputsResult
 from ergon_core.core.jobs.sandbox.setup.contract import SandboxReadyResult
-from ergon_core.core.jobs.task.worker_execute.contract import WorkerExecuteJobResult
+from ergon_core.core.jobs.task.worker_execute.contract import WorkerExecuteResult
 from ergon_core.core.application.runtime.task_execution import TaskExecutionService
 from ergon_core.core.application.runtime.orchestration import PreparedTaskExecution
 
@@ -54,7 +54,7 @@ async def _invoke(
         data: dict[str, object],
     ) -> object:
         # Return is polymorphic across step.invoke call sites
-        # (SandboxReadyResult, WorkerExecuteJobResult, EvaluateTaskRunResult,
+        # (SandboxReadyResult, WorkerExecuteResult, EvaluateTaskRunResult,
         # ...) — `object` is the honest bound for a test fake that
         # impersonates all of them. The tests below don't read the return.
         del function, data
@@ -146,9 +146,9 @@ async def fake_invoke_worker_execute(
         _prepared: PreparedTaskExecution,
         _sandbox: SandboxReadyResult,
         _fn: inngest.Function,
-    ) -> WorkerExecuteJobResult:
+    ) -> WorkerExecuteResult:
         ordering.append("invoke:worker-execute")
-        return WorkerExecuteJobResult(
+        return WorkerExecuteResult(
             success=True,
             final_assistant_message="ok",
             error=None,
@@ -266,8 +266,8 @@ async def fake_invoke_worker_execute(
         _prepared: PreparedTaskExecution,
         _sandbox: SandboxReadyResult,
         _fn: inngest.Function,
-    ) -> WorkerExecuteJobResult:
-        return WorkerExecuteJobResult(
+    ) -> WorkerExecuteResult:
+        return WorkerExecuteResult(
             success=False,
             final_assistant_message=None,
             error="boom",
diff --git a/ergon_core/tests/unit/runtime/test_experiment_definition_writer.py b/ergon_core/tests/unit/runtime/test_experiment_definition_writer.py
index 96303c41b..756dd9678 100644
--- a/ergon_core/tests/unit/runtime/test_experiment_definition_writer.py
+++ b/ergon_core/tests/unit/runtime/test_experiment_definition_writer.py
@@ -3,18 +3,28 @@
 
 import pytest
 
-from ergon_builtins.benchmarks.minif2f.benchmark import MiniF2FTask
+from ergon_builtins.agents.react.worker import ReActWorker
+from ergon_builtins.benchmarks.minif2f.prompts import MINIF2F_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.minif2f.rubric import MiniF2FRubric
+from ergon_builtins.benchmarks.minif2f.task import MiniF2FTask
 from ergon_builtins.benchmarks.minif2f.task_schemas import MiniF2FTaskPayload
-from ergon_builtins.benchmarks.minif2f.worker_factory import (
-    make_minif2f_rubric,
-    make_minif2f_worker,
-)
 from ergon_builtins.benchmarks.minif2f.sandbox import LeanSandbox
-from ergon_core.api.benchmark.task import Task
+from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
+from ergon_core.api.task import Task
 from ergon_core.api.criterion import Criterion, CriterionContext, CriterionOutcome
 from ergon_core.tests.unit.runtime._test_workers import EchoSandbox, EchoWorker
 
 
+def _mini_worker() -> ReActWorker:
+    return ReActWorker(
+        name="mini-proof-solver",
+        model="test:none",
+        system_prompt=MINIF2F_SYSTEM_PROMPT,
+        max_iterations=30,
+        toolkit=MiniF2FToolkit(),
+    )
+
+
 class _Criterion(Criterion):
     type_slug: ClassVar[str] = "ci-criterion"
 
@@ -58,9 +68,9 @@ def test_minif2f_definition_json_has_v2_object_bound_shape() -> None:
             formal_statement="theorem sample_1 : 1 + 1 = 2 := by",
             header="import Mathlib\n",
         ),
-        worker=make_minif2f_worker(),
+        worker=_mini_worker(),
         sandbox=LeanSandbox(),
-        evaluators=(make_minif2f_rubric(),),
+        evaluators=(MiniF2FRubric(name="minif2f-rubric"),),
     )
     task_json = task.model_dump(mode="json")
 
diff --git a/ergon_core/tests/unit/runtime/test_identity_invariants.py b/ergon_core/tests/unit/runtime/test_identity_invariants.py
index 55af0c7c5..2fe2a9d58 100644
--- a/ergon_core/tests/unit/runtime/test_identity_invariants.py
+++ b/ergon_core/tests/unit/runtime/test_identity_invariants.py
@@ -20,7 +20,7 @@
 
 import pytest
 from ergon_core.api import Sample
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.worker.context import WorkerContext
 from ergon_core.api.worker.results import SpawnedTaskHandle
 from ergon_core.core.application.runtime.graph_repository import RuntimeGraphRepository
diff --git a/ergon_core/tests/unit/runtime/test_rubric_evaluation_service.py b/ergon_core/tests/unit/runtime/test_rubric_evaluation_service.py
index 3949f28e1..7cc87edb6 100644
--- a/ergon_core/tests/unit/runtime/test_rubric_evaluation_service.py
+++ b/ergon_core/tests/unit/runtime/test_rubric_evaluation_service.py
@@ -9,7 +9,7 @@
 from ergon_core.api.rubric import Evaluator, Rubric
 from ergon_core.api.rubric.results import TaskEvaluationResult
 from ergon_core.api.worker import WorkerOutput
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.core.application.evaluation.models import CriterionSpec
 from ergon_core.core.application.evaluation.service import (
     EvaluationService,
diff --git a/ergon_core/tests/unit/runtime/test_sample_graph_task_snapshot.py b/ergon_core/tests/unit/runtime/test_sample_graph_task_snapshot.py
index 3bf3e3ade..2562b2f5b 100644
--- a/ergon_core/tests/unit/runtime/test_sample_graph_task_snapshot.py
+++ b/ergon_core/tests/unit/runtime/test_sample_graph_task_snapshot.py
@@ -20,7 +20,7 @@
 from pydantic import BaseModel, ConfigDict
 from sqlalchemy.pool import StaticPool
 from sqlmodel import Session, SQLModel, create_engine, select
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.test_support.task_factory import TestSandbox, TestWorker
 
 
@@ -167,7 +167,7 @@ async def test_add_node_can_write_dynamic_task_json() -> None:
 
     repo = RuntimeGraphRepository()
     payload = {
-        "_type": "ergon_core.api.benchmark.task:Task",
+        "_type": "ergon_core.api.task:Task",
         "task_slug": "child",
         "description": "child task",
     }
diff --git a/ergon_core/tests/unit/runtime/test_spawn_dynamic_task.py b/ergon_core/tests/unit/runtime/test_spawn_dynamic_task.py
index b42adbec2..1543f6551 100644
--- a/ergon_core/tests/unit/runtime/test_spawn_dynamic_task.py
+++ b/ergon_core/tests/unit/runtime/test_spawn_dynamic_task.py
@@ -14,7 +14,7 @@
 from uuid import UUID, uuid4
 
 import pytest
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.worker.results import SpawnedTaskHandle
 from ergon_core.core.jobs.task.worker_execute.job import _StepAwareTaskManagementService
 from ergon_core.core.application.runtime import management as management_module
diff --git a/ergon_core/tests/unit/runtime/test_walkthrough_smoketest.py b/ergon_core/tests/unit/runtime/test_walkthrough_smoketest.py
index 590a33172..719d26865 100644
--- a/ergon_core/tests/unit/runtime/test_walkthrough_smoketest.py
+++ b/ergon_core/tests/unit/runtime/test_walkthrough_smoketest.py
@@ -16,7 +16,7 @@
 
 import pytest
 from ergon_core.api import Sample
-from ergon_core.api.benchmark.task import Task
+from ergon_core.api.task import Task
 from ergon_core.api.worker.context import WorkerContext
 from ergon_core.core.application.runtime import inspection as inspection_module
 from ergon_core.core.application.runtime import management as management_module
diff --git a/ergon_core/tests/unit/runtime/test_worker_context_containment.py b/ergon_core/tests/unit/runtime/test_worker_context_containment.py
index 27b42b309..e802ab90e 100644
--- a/ergon_core/tests/unit/runtime/test_worker_context_containment.py
+++ b/ergon_core/tests/unit/runtime/test_worker_context_containment.py
@@ -22,7 +22,7 @@
 from uuid import UUID, uuid4
 
 import pytest
-from ergon_core.api.benchmark.task import EmptyTaskPayload, Task
+from ergon_core.api.task import EmptyTaskPayload, Task
 from ergon_core.api.errors import ContainmentViolation
 from ergon_core.api.worker.context import WorkerContext
 from ergon_core.api.worker.results import SpawnedTaskHandle
diff --git a/ergon_core/tests/unit/test_swebench_criterion_no_sandbox.py b/ergon_core/tests/unit/test_swebench_criterion_no_sandbox.py
index 8d95b177f..9e42ac653 100644
--- a/ergon_core/tests/unit/test_swebench_criterion_no_sandbox.py
+++ b/ergon_core/tests/unit/test_swebench_criterion_no_sandbox.py
@@ -13,7 +13,7 @@
 from ergon_builtins.benchmarks.swebench_verified.task_schemas import SWEBenchTaskPayload
 from ergon_core.api.criterion import CriterionContext
 from ergon_core.api.worker import WorkerOutput
-from ergon_core.api.benchmark import Task
+from ergon_core.api.task import Task
 from ergon_core.api.sandbox.runtime import CommandResult
 from ergon_core.test_support.task_factory import task_with_id
 
diff --git a/examples/experiment_api/01_minif2f_single_environment/submit.py b/examples/experiment_api/01_minif2f_single_environment/submit.py
index 9f18c7e71..2f18faa3f 100644
--- a/examples/experiment_api/01_minif2f_single_environment/submit.py
+++ b/examples/experiment_api/01_minif2f_single_environment/submit.py
@@ -4,25 +4,37 @@
 
 import asyncio
 
+from ergon_builtins.agents.react.worker import ReActWorker
+from ergon_builtins.benchmarks.minif2f.dataset import load_minif2f_rows
+from ergon_builtins.benchmarks.minif2f.prompts import MINIF2F_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.minif2f.rubric import MiniF2FRubric
 from ergon_builtins.benchmarks.minif2f.sandbox import LeanSandbox
-from ergon_builtins.benchmarks.minif2f.worker_factory import (
-    make_minif2f_rubric,
-    make_minif2f_worker,
-)
-from ergon_builtins.environments import MiniF2FEnvironment
-from ergon_core.api import Experiment, RandomSampler
+from ergon_builtins.benchmarks.minif2f.sample import make_minif2f_sample
+from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
+from ergon_core.api import Environment, Experiment, RandomSampler
 from experiment_api._shared import experiment_submission_service
 
 
 async def main() -> None:
-    worker = make_minif2f_worker(model="openai:gpt-4o")
-    env = MiniF2FEnvironment(
+    worker = ReActWorker(
+        name="mini-proof-solver",
+        model="openai:gpt-4o",
+        system_prompt=MINIF2F_SYSTEM_PROMPT,
+        max_iterations=30,
+        toolkit=MiniF2FToolkit(),
+    )
+    env = Environment.from_records(
         name="mini-validation",
-        split="validation",
-        limit=10,
-        worker=worker,
-        evaluators=[make_minif2f_rubric()],
-        sandbox=LeanSandbox(),
+        records=load_minif2f_rows(split="validation", limit=10),
+        source_metadata={"provider": "ergon-builtin:minif2f", "split": "validation"},
+        make_sample=lambda row: make_minif2f_sample(
+            row,
+            environment_name="mini-validation",
+            split="validation",
+            worker=worker,
+            evaluators=[MiniF2FRubric(name="minif2f-proof")],
+            sandbox=LeanSandbox(),
+        ),
     )
     experiment = Experiment(name="mini-validation-smoke", environments=[env])
     result = await experiment.submit(
diff --git a/examples/experiment_api/02_mixed_environment_training/submit.py b/examples/experiment_api/02_mixed_environment_training/submit.py
index 041914fb5..0afe3f65c 100644
--- a/examples/experiment_api/02_mixed_environment_training/submit.py
+++ b/examples/experiment_api/02_mixed_environment_training/submit.py
@@ -4,64 +4,121 @@
 
 import asyncio
 
-from ergon_builtins.benchmarks.gdpeval.benchmark import _default_gdpeval_sandbox
-from ergon_builtins.benchmarks.gdpeval.worker_factory import (
-    make_gdpeval_rubric,
-    make_gdpeval_worker,
-)
+from ergon_builtins.agents.react.worker import ReActWorker
+from ergon_builtins.benchmarks.gdpeval.dataset import load_gdpeval_rows
+from ergon_builtins.benchmarks.gdpeval.prompts import GDPEVAL_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.gdpeval.rubric import StagedRubric
+from ergon_builtins.benchmarks.gdpeval.sandbox import GDPEvalSandbox
+from ergon_builtins.benchmarks.gdpeval.sample import make_gdpeval_sample
+from ergon_builtins.benchmarks.gdpeval.toolkit import GDPEvalToolkit
+from ergon_builtins.benchmarks.minif2f.dataset import load_minif2f_rows
+from ergon_builtins.benchmarks.minif2f.prompts import MINIF2F_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.minif2f.rubric import MiniF2FRubric
 from ergon_builtins.benchmarks.minif2f.sandbox import LeanSandbox
-from ergon_builtins.benchmarks.minif2f.worker_factory import make_minif2f_rubric
-from ergon_builtins.benchmarks.researchrubrics.benchmark import _default_research_sandbox
-from ergon_builtins.benchmarks.researchrubrics.worker_factory import make_research_rubric
-from ergon_builtins.benchmarks.swebench_verified.benchmark import _default_swebench_sandbox
-from ergon_builtins.benchmarks.swebench_verified.worker_factory import make_swebench_rubric
-from ergon_builtins.environments import (
-    GDPEvalEnvironment,
-    MiniF2FEnvironment,
-    ResearchRubricsEnvironment,
-    SweBenchVerifiedEnvironment,
-)
-from ergon_core.api import Experiment, RandomSampler
+from ergon_builtins.benchmarks.minif2f.sample import make_minif2f_sample
+from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
+from ergon_builtins.benchmarks.researchrubrics.dataset import load_researchrubrics_rows
+from ergon_builtins.benchmarks.researchrubrics.prompts import RESEARCH_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.researchrubrics.rubric import ResearchRubricsRubric
+from ergon_builtins.benchmarks.researchrubrics.sandbox import ResearchE2BSandbox
+from ergon_builtins.benchmarks.researchrubrics.sample import make_researchrubrics_sample
+from ergon_builtins.benchmarks.researchrubrics.toolkit import ResearchRubricsToolkit
+from ergon_builtins.benchmarks.swebench_verified.dataset import iter_swebench_rows
+from ergon_builtins.benchmarks.swebench_verified.prompts import SWEBENCH_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.swebench_verified.rubric import SWEBenchRubric
+from ergon_builtins.benchmarks.swebench_verified.sandbox import SWEBenchSandbox
+from ergon_builtins.benchmarks.swebench_verified.sample import make_swebench_sample
+from ergon_builtins.benchmarks.swebench_verified.toolkit import SWEBenchToolkit
+from ergon_core.api import Environment, Experiment, RandomSampler
 from experiment_api._shared import experiment_submission_service
 
 
 async def main() -> None:
-    worker = make_gdpeval_worker(model="openai:gpt-4o")
+    mini_worker = ReActWorker(
+        name="mini-proof-solver",
+        model="openai:gpt-4o",
+        system_prompt=MINIF2F_SYSTEM_PROMPT,
+        max_iterations=30,
+        toolkit=MiniF2FToolkit(),
+    )
+    research_worker = ReActWorker(
+        name="research-runner",
+        model="openai:gpt-4o",
+        system_prompt=RESEARCH_SYSTEM_PROMPT,
+        max_iterations=16,
+        toolkit=ResearchRubricsToolkit(),
+    )
+    gdp_worker = ReActWorker(
+        name="gdpeval-runner",
+        model="openai:gpt-4o",
+        system_prompt=GDPEVAL_SYSTEM_PROMPT,
+        max_iterations=40,
+        toolkit=GDPEvalToolkit(),
+    )
+    swe_worker = ReActWorker(
+        name="swebench-solver",
+        model="openai:gpt-4o",
+        system_prompt=SWEBENCH_SYSTEM_PROMPT,
+        max_iterations=50,
+        toolkit=SWEBenchToolkit(),
+    )
     experiment = Experiment(
         name="generalist-mixed-training",
         environments=[
-            MiniF2FEnvironment(
+            Environment.from_records(
                 name="mini-validation",
-                split="validation",
-                limit=10,
-                worker=worker,
-                evaluators=[make_minif2f_rubric()],
-                sandbox=LeanSandbox(),
+                records=load_minif2f_rows(split="validation", limit=10),
+                make_sample=lambda row: make_minif2f_sample(
+                    row,
+                    environment_name="mini-validation",
+                    split="validation",
+                    worker=mini_worker,
+                    evaluators=[MiniF2FRubric(name="minif2f-proof")],
+                    sandbox=LeanSandbox(),
+                ),
             ),
-            ResearchRubricsEnvironment(
+            Environment.from_records(
                 name="research-validation",
-                split="validation",
-                limit=10,
-                worker=worker,
-                evaluators=[make_research_rubric()],
-                sandbox=_default_research_sandbox(),
+                records=load_researchrubrics_rows(split="validation", limit=10),
+                make_sample=lambda row: make_researchrubrics_sample(
+                    row,
+                    environment_name="research-validation",
+                    split="validation",
+                    worker=research_worker,
+                    evaluators=[ResearchRubricsRubric(name="researchrubrics-rubric")],
+                    sandbox=ResearchE2BSandbox(),
+                ),
             ),
-            GDPEvalEnvironment(
+            Environment.from_records(
                 name="gdp-validation",
-                split="validation",
-                limit=10,
-                worker=worker,
-                evaluators=[make_gdpeval_rubric()],
-                sandbox=_default_gdpeval_sandbox(),
+                records=load_gdpeval_rows(split="validation", limit=10),
+                make_sample=lambda row: make_gdpeval_sample(
+                    row,
+                    environment_name="gdp-validation",
+                    split="validation",
+                    worker=gdp_worker,
+                    evaluators=[
+                        StagedRubric(
+                            name="gdpeval-staged-rubric",
+                            category_name="default",
+                            max_total_score=1.0,
+                        )
+                    ],
+                    sandbox=GDPEvalSandbox(),
+                ),
             ),
-            SweBenchVerifiedEnvironment(
+            Environment.from_dataset(
                 name="swebench-train",
-                split="train",
-                streaming=True,
-                limit=100,
-                worker=worker,
-                evaluators=[make_swebench_rubric()],
-                sandbox=_default_swebench_sandbox(),
+                dataset=iter_swebench_rows(split="train", limit=100, streaming=True),
+                source_mode="streaming",
+                make_sample=lambda row: make_swebench_sample(
+                    row,
+                    environment_name="swebench-train",
+                    split="train",
+                    worker=swe_worker,
+                    evaluators=[SWEBenchRubric(name="swebench-rubric")],
+                    sandbox=SWEBenchSandbox(),
+                ),
             ),
         ],
     )
diff --git a/examples/experiment_api/03_streaming_hf_dataset/submit.py b/examples/experiment_api/03_streaming_hf_dataset/submit.py
index 8b7807952..9c95f104c 100644
--- a/examples/experiment_api/03_streaming_hf_dataset/submit.py
+++ b/examples/experiment_api/03_streaming_hf_dataset/submit.py
@@ -4,24 +4,37 @@
 
 import asyncio
 
-from ergon_builtins.benchmarks.swebench_verified.benchmark import _default_swebench_sandbox
-from ergon_builtins.benchmarks.swebench_verified.worker_factory import (
-    make_swebench_rubric,
-    make_swebench_worker,
-)
-from ergon_builtins.environments import SweBenchVerifiedEnvironment
-from ergon_core.api import Experiment, RandomSampler
+from ergon_builtins.agents.react.worker import ReActWorker
+from ergon_builtins.benchmarks.swebench_verified.dataset import iter_swebench_rows
+from ergon_builtins.benchmarks.swebench_verified.prompts import SWEBENCH_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.swebench_verified.rubric import SWEBenchRubric
+from ergon_builtins.benchmarks.swebench_verified.sandbox import SWEBenchSandbox
+from ergon_builtins.benchmarks.swebench_verified.sample import make_swebench_sample
+from ergon_builtins.benchmarks.swebench_verified.toolkit import SWEBenchToolkit
+from ergon_core.api import Environment, Experiment, RandomSampler
 from experiment_api._shared import experiment_submission_service
 
 
 async def main() -> None:
-    env = SweBenchVerifiedEnvironment(
+    worker = ReActWorker(
+        name="swebench-solver",
+        model="openai:gpt-4o",
+        system_prompt=SWEBENCH_SYSTEM_PROMPT,
+        max_iterations=50,
+        toolkit=SWEBenchToolkit(),
+    )
+    env = Environment.from_dataset(
         name="swebench-train",
-        split="train",
-        streaming=True,
-        worker=make_swebench_worker(model="openai:gpt-4o"),
-        evaluators=[make_swebench_rubric()],
-        sandbox=_default_swebench_sandbox(),
+        dataset=iter_swebench_rows(split="train", streaming=True),
+        source_mode="streaming",
+        make_sample=lambda row: make_swebench_sample(
+            row,
+            environment_name="swebench-train",
+            split="train",
+            worker=worker,
+            evaluators=[SWEBenchRubric(name="swebench-rubric")],
+            sandbox=SWEBenchSandbox(),
+        ),
     )
     experiment = Experiment(name="swebench-streaming-buffer", environments=[env])
     result = await experiment.submit(
diff --git a/examples/experiment_api/04_curriculum_sampler/submit.py b/examples/experiment_api/04_curriculum_sampler/submit.py
index a0577a121..7c96f4166 100644
--- a/examples/experiment_api/04_curriculum_sampler/submit.py
+++ b/examples/experiment_api/04_curriculum_sampler/submit.py
@@ -5,8 +5,14 @@
 import asyncio
 from collections.abc import Sequence
 
-from ergon_builtins.environments import MiniF2FEnvironment
-from ergon_core.api import Experiment, RandomSampler, Sample, SamplingContext
+from ergon_builtins.agents.react.worker import ReActWorker
+from ergon_builtins.benchmarks.minif2f.dataset import load_minif2f_rows
+from ergon_builtins.benchmarks.minif2f.prompts import MINIF2F_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.minif2f.rubric import MiniF2FRubric
+from ergon_builtins.benchmarks.minif2f.sandbox import LeanSandbox
+from ergon_builtins.benchmarks.minif2f.sample import make_minif2f_sample
+from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
+from ergon_core.api import Environment, Experiment, RandomSampler, Sample, SamplingContext
 from experiment_api._shared import experiment_submission_service
 
 
@@ -38,7 +44,25 @@ def _difficulty_key(sample: Sample) -> tuple[int, str]:
 
 
 async def main() -> None:
-    env = MiniF2FEnvironment(name="mini-validation", split="validation", limit=64)
+    worker = ReActWorker(
+        name="mini-proof-solver",
+        model="openai:gpt-4o",
+        system_prompt=MINIF2F_SYSTEM_PROMPT,
+        max_iterations=30,
+        toolkit=MiniF2FToolkit(),
+    )
+    env = Environment.from_records(
+        name="mini-validation",
+        records=load_minif2f_rows(split="validation", limit=64),
+        make_sample=lambda row: make_minif2f_sample(
+            row,
+            environment_name="mini-validation",
+            split="validation",
+            worker=worker,
+            evaluators=[MiniF2FRubric(name="minif2f-proof")],
+            sandbox=LeanSandbox(),
+        ),
+    )
     experiment = Experiment(name="mini-curriculum", environments=[env])
     result = await experiment.submit(
         service=experiment_submission_service(),
diff --git a/examples/experiment_api/05_row_dependent_runtime_configs/submit.py b/examples/experiment_api/05_row_dependent_runtime_configs/submit.py
index fbbf37f0a..82ca09431 100644
--- a/examples/experiment_api/05_row_dependent_runtime_configs/submit.py
+++ b/examples/experiment_api/05_row_dependent_runtime_configs/submit.py
@@ -4,44 +4,52 @@
 
 import asyncio
 
-from ergon_builtins.benchmarks.swebench_verified.benchmark import _default_swebench_sandbox
+from ergon_builtins.agents.react.worker import ReActWorker
+from ergon_builtins.benchmarks.swebench_verified.dataset import iter_swebench_rows
+from ergon_builtins.benchmarks.swebench_verified.prompts import SWEBENCH_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.swebench_verified.rubric import SWEBenchRubric
 from ergon_builtins.benchmarks.swebench_verified.sandbox import SWEBenchSandbox
+from ergon_builtins.benchmarks.swebench_verified.sample import make_swebench_sample
 from ergon_builtins.benchmarks.swebench_verified.task_schemas import SWEBenchInstance
-from ergon_builtins.benchmarks.swebench_verified.worker_factory import (
-    make_swebench_rubric,
-    make_swebench_worker,
-)
-from ergon_builtins.environments import SweBenchVerifiedEnvironment
-from ergon_core.api import Evaluator, Experiment, RandomSampler, Sandbox, Worker
+from ergon_builtins.benchmarks.swebench_verified.toolkit import SWEBenchToolkit
+from ergon_core.api import Environment, Evaluator, Experiment, RandomSampler, Sandbox, Worker
 from experiment_api._shared import experiment_submission_service
 
 
 def worker_for_row(row: SWEBenchInstance) -> Worker:
-    if row.repo.startswith("django/"):
-        return make_swebench_worker(model="openai:gpt-4o")
-    return make_swebench_worker(model="openai:gpt-4o-mini")
+    model = "openai:gpt-4o" if row.repo.startswith("django/") else "openai:gpt-4o-mini"
+    return ReActWorker(
+        name="swebench-solver",
+        model=model,
+        system_prompt=SWEBENCH_SYSTEM_PROMPT,
+        max_iterations=50,
+        toolkit=SWEBenchToolkit(),
+    )
 
 
 def evaluators_for_row(row: SWEBenchInstance) -> list[Evaluator]:
     del row
-    return [make_swebench_rubric()]
+    return [SWEBenchRubric(name="swebench-rubric")]
 
 
 def sandbox_for_row(row: SWEBenchInstance) -> Sandbox:
-    if row.repo.startswith("django/"):
-        return SWEBenchSandbox()
-    return _default_swebench_sandbox()
+    del row
+    return SWEBenchSandbox()
 
 
 async def main() -> None:
-    env = SweBenchVerifiedEnvironment(
+    env = Environment.from_dataset(
         name="swebench-row-dependent",
-        split="train",
-        streaming=True,
-        limit=100,
-        worker=worker_for_row,
-        evaluators=evaluators_for_row,
-        sandbox=sandbox_for_row,
+        dataset=iter_swebench_rows(split="train", streaming=True, limit=100),
+        source_mode="streaming",
+        make_sample=lambda row: make_swebench_sample(
+            row,
+            environment_name="swebench-row-dependent",
+            split="train",
+            worker=worker_for_row(row),
+            evaluators=evaluators_for_row(row),
+            sandbox=sandbox_for_row(row),
+        ),
     )
     experiment = Experiment(name="row-dependent-runtime-configs", environments=[env])
     result = await experiment.submit(
diff --git a/examples/getting_started/01_minif2f_local_llamacpp/README.md b/examples/getting_started/01_minif2f_local_llamacpp/README.md
index b65bea090..34ed16317 100644
--- a/examples/getting_started/01_minif2f_local_llamacpp/README.md
+++ b/examples/getting_started/01_minif2f_local_llamacpp/README.md
@@ -130,7 +130,7 @@ E2B account. They cover argument parsing, preflight failures, model-target
 construction, and launch wiring with monkeypatched Ergon APIs.
 
 When running against real services, these are expected setup or integration
-failures rather than successful benchmark launches:
+failures rather than successful environment launches:
 
 - Missing `E2B_API_KEY`: add it to Ergon's `.env` file or process environment.
 - Hugging Face download failure: check the `--base-model` repo/file ref, network
@@ -138,7 +138,7 @@ failures rather than successful benchmark launches:
 - Unreachable llama.cpp server: start `llama-server` and verify
   `GET http://localhost:8080/v1/models` returns a model id.
 - Missing MiniF2F Lean template or E2B provisioning failure: build/pin the
-  template with `uv run ergon benchmark setup minif2f`, then retry.
+  template with `uv run ergon environment setup minif2f`, then retry.
 - Model tool-call incompatibility: try a model and prompt configuration that can
   use OpenAI-compatible tool calls, or inspect the sample artifacts for the failed
   attempts.
diff --git a/examples/getting_started/01_minif2f_local_llamacpp/submit.py b/examples/getting_started/01_minif2f_local_llamacpp/submit.py
index 463459563..f5a75a492 100644
--- a/examples/getting_started/01_minif2f_local_llamacpp/submit.py
+++ b/examples/getting_started/01_minif2f_local_llamacpp/submit.py
@@ -8,14 +8,14 @@
 from collections.abc import Sequence
 from uuid import UUID
 
+from ergon_builtins.agents.react.worker import ReActWorker
+from ergon_builtins.benchmarks.minif2f.dataset import load_minif2f_rows
+from ergon_builtins.benchmarks.minif2f.prompts import MINIF2F_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.minif2f.rubric import MiniF2FRubric
 from ergon_builtins.benchmarks.minif2f.sandbox import LeanSandbox
-from ergon_builtins.benchmarks.minif2f.worker_factory import (
-    make_minif2f_rubric,
-    make_minif2f_worker,
-)
-from ergon_builtins.environments import MiniF2FEnvironment
-from ergon_core.api import Experiment, RandomSampler
-from ergon_core.api.worker import Worker
+from ergon_builtins.benchmarks.minif2f.sample import make_minif2f_sample
+from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
+from ergon_core.api import Environment, Experiment, RandomSampler
 from ergon_core.core.application.experiments.submission import ExperimentSubmissionService
 from ergon_core.core.persistence.shared.db import ensure_db, get_session
 from getting_started._shared.env import (
@@ -181,20 +181,25 @@ async def async_main(argv: Sequence[str] | None = None) -> int:
         print(f"Setup error: {exc}", file=sys.stderr)
         return 2
 
-    def make_worker() -> Worker:
-        return make_minif2f_worker(
+    try:
+        worker = ReActWorker(
+            name="mini-proof-solver",
             model=model_target,
+            system_prompt=MINIF2F_SYSTEM_PROMPT,
             max_iterations=args.max_iterations,
+            toolkit=MiniF2FToolkit(),
         )
-
-    try:
-        env = MiniF2FEnvironment(
+        env = Environment.from_records(
             name="mini-validation",
-            split="validation",
-            limit=args.limit,
-            worker=make_worker(),
-            evaluators=[make_minif2f_rubric()],
-            sandbox=LeanSandbox(),
+            records=load_minif2f_rows(split="validation", limit=args.limit),
+            make_sample=lambda row: make_minif2f_sample(
+                row,
+                environment_name="mini-validation",
+                split="validation",
+                worker=worker,
+                evaluators=[MiniF2FRubric(name="minif2f-proof")],
+                sandbox=LeanSandbox(),
+            ),
         )
         experiment = Experiment(name="minif2f-local-llamacpp", environments=[env])
         result = await experiment.submit(
diff --git a/examples/getting_started/_shared/env.py b/examples/getting_started/_shared/env.py
index 49084c39c..06845d52c 100644
--- a/examples/getting_started/_shared/env.py
+++ b/examples/getting_started/_shared/env.py
@@ -6,10 +6,10 @@
 import urllib.error
 import urllib.request
 from collections.abc import Mapping
-from dataclasses import dataclass
 from typing import cast
 
 from ergon_core.core.shared.settings import settings
+from pydantic import BaseModel, ConfigDict
 
 DEFAULT_LLAMA_CPP_BASE_URL = "http://localhost:8080"
 DEFAULT_MINIF2F_LIMIT = 3
@@ -21,10 +21,11 @@ class ExampleSetupError(RuntimeError):
     """Raised when a common local setup requirement is missing."""
 
 
-@dataclass(frozen=True)
-class PreflightResult:
+class PreflightResult(BaseModel):
     """Result of local model and sandbox setup checks."""
 
+    model_config = ConfigDict(frozen=True)
+
     discovered_model: str | None
 
 
diff --git a/tests/e2e/_asserts.py b/tests/e2e/_asserts.py
index 55abce82f..a4ea672c5 100644
--- a/tests/e2e/_asserts.py
+++ b/tests/e2e/_asserts.py
@@ -337,8 +337,6 @@ def _after(child: str, parents: list[str]) -> None:
     _after("l_3", ["l_2"])
 
 
-SMOKE_DIRECT_TASKS = EXPECTED_SUBTASK_SLUGS
-SMOKE_NESTED_TASKS = NESTED_LINE_SLUGS
 SMOKE_DIRECT_EDGES = (
     ("d_root", "d_left"),
     ("d_root", "d_right"),
@@ -362,9 +360,9 @@ def _assert_sample_runtime_event_stream(
     root_slug = sample_snapshot.tasks[sample_snapshot.root_task_id].name
 
     expected_task_slugs = (
-        (root_slug, *SMOKE_DIRECT_TASKS, *SMOKE_NESTED_TASKS)
+        (root_slug, *EXPECTED_SUBTASK_SLUGS, *NESTED_LINE_SLUGS)
         if profile == "happy"
-        else (root_slug, *SMOKE_DIRECT_TASKS)
+        else (root_slug, *EXPECTED_SUBTASK_SLUGS)
     )
     expected_edge_pairs = (
         (*SMOKE_DIRECT_EDGES, *SMOKE_NESTED_EDGES) if profile == "happy" else SMOKE_DIRECT_EDGES
@@ -437,7 +435,7 @@ def _assert_sample_runtime_event_order(
     }
 
     assert task_add_index[root_slug] < first_executing
-    for slug in SMOKE_DIRECT_TASKS:
+    for slug in EXPECTED_SUBTASK_SLUGS:
         assert task_add_index[slug] > first_executing
 
     for i, event in enumerate(ordered):
diff --git a/tests/e2e/_submit.py b/tests/e2e/_submit.py
index c7f68cfc2..26a5783da 100644
--- a/tests/e2e/_submit.py
+++ b/tests/e2e/_submit.py
@@ -41,7 +41,7 @@ def _api_base() -> str:
 
 def build_experiment_payload(
     *,
-    benchmark_slug: str,
+    environment_slug: str,
     slots: list[tuple[str, str]],
     experiment: str,
     sandbox_slug: str,
@@ -49,7 +49,7 @@ def build_experiment_payload(
     model: str = "openai:gpt-4o",
 ) -> dict:
     return {
-        "benchmark_slug": benchmark_slug,
+        "environment_slug": environment_slug,
         "slots": [
             {"worker_slug": worker, "evaluator_slug": criterion} for worker, criterion in slots
         ],
@@ -62,7 +62,7 @@ def build_experiment_payload(
 
 async def submit_experiment_samples(
     *,
-    benchmark_slug: str,
+    environment_slug: str,
     slots: list[tuple[str, str]],
     experiment: str,
     sandbox_slug: str,
@@ -73,7 +73,7 @@ async def submit_experiment_samples(
     """Submit one sample per slot under ``experiment``; return sample_ids in order.
 
     Args:
-        benchmark_slug:  e.g. ``"researchrubrics"``
+        environment_slug: e.g. ``"researchrubrics"``
         slots:           list of ``(worker_slug, criterion_slug)`` tuples
         experiment:      shared experiment tag (all runs group under this)
         sandbox_slug:    explicit sandbox manager slug for the run
@@ -84,7 +84,7 @@ async def submit_experiment_samples(
                          client-side timeout to propagate.
     """
     payload = build_experiment_payload(
-        benchmark_slug=benchmark_slug,
+        environment_slug=environment_slug,
         slots=slots,
         experiment=experiment,
         sandbox_slug=sandbox_slug,
diff --git a/tests/e2e/reassert.py b/tests/e2e/reassert.py
index 78fc986e8..ae1ac729a 100755
--- a/tests/e2e/reassert.py
+++ b/tests/e2e/reassert.py
@@ -88,7 +88,7 @@ def main() -> int:
         "--env",
         required=True,
         choices=("researchrubrics", "minif2f", "swebench-verified"),
-        help="Benchmark env (kept for symmetry; only affects the label)",
+        help="Environment label",
     )
     p.add_argument(
         "--kind",
diff --git a/tests/e2e/test_minif2f_smoke.py b/tests/e2e/test_minif2f_smoke.py
index 820caea4a..0bf659953 100644
--- a/tests/e2e/test_minif2f_smoke.py
+++ b/tests/e2e/test_minif2f_smoke.py
@@ -62,7 +62,7 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
     smoke_slots = _smoke_slots(EXPERIMENT_GROUP_SIZE)
 
     sample_ids = await submit_experiment_samples(
-        benchmark_slug=ENV,
+        environment_slug=ENV,
         slots=[(worker, criterion) for _, worker, criterion in smoke_slots],
         experiment=experiment,
         sandbox_slug=ENV,
diff --git a/tests/e2e/test_researchrubrics_smoke.py b/tests/e2e/test_researchrubrics_smoke.py
index 21f883c57..32bfbaf74 100644
--- a/tests/e2e/test_researchrubrics_smoke.py
+++ b/tests/e2e/test_researchrubrics_smoke.py
@@ -74,7 +74,7 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
     smoke_slots = _smoke_slots(EXPERIMENT_GROUP_SIZE)
 
     sample_ids = await submit_experiment_samples(
-        benchmark_slug=ENV,
+        environment_slug=ENV,
         slots=[(worker, criterion) for _, worker, criterion in smoke_slots],
         experiment=experiment,
         sandbox_slug=ENV,
diff --git a/tests/e2e/test_swebench_smoke.py b/tests/e2e/test_swebench_smoke.py
index 7ac22cb92..f19298853 100644
--- a/tests/e2e/test_swebench_smoke.py
+++ b/tests/e2e/test_swebench_smoke.py
@@ -33,9 +33,9 @@
 )
 from tests.e2e._submit import submit_experiment_samples
 
-# Benchmark slug is 'swebench-verified' (matches BENCHMARKS registry);
+# Environment slug is 'swebench-verified';
 # worker + criterion slugs use 'swebench' (shorter).  The per-env
-# Playwright spec file uses the benchmark slug so the CI matrix env id
+# Playwright spec file uses the environment slug so the CI matrix env id
 # maps 1:1 to the spec filename.
 ENV = "swebench-verified"
 WORKER_PREFIX = "swebench"
@@ -67,7 +67,7 @@ async def test_smoke_experiment_group(tmp_path: pathlib.Path) -> None:
     smoke_slots = _smoke_slots(EXPERIMENT_GROUP_SIZE)
 
     sample_ids = await submit_experiment_samples(
-        benchmark_slug=ENV,
+        environment_slug=ENV,
         slots=[(worker, criterion) for _, worker, criterion in smoke_slots],
         experiment=experiment,
         sandbox_slug=ENV,
diff --git a/tests/examples/test_experiment_api_examples.py b/tests/examples/test_experiment_api_examples.py
index 95662c2e2..fdc7fe4f8 100644
--- a/tests/examples/test_experiment_api_examples.py
+++ b/tests/examples/test_experiment_api_examples.py
@@ -7,11 +7,21 @@
 import json
 from collections.abc import Iterator, Sequence
 from pathlib import Path
+from types import SimpleNamespace
 from uuid import UUID, uuid4
 
 from pydantic import ConfigDict
 
-from ergon_core.api import Environment, Experiment, ExperimentSubmitResult, Sample
+from ergon_core.api import (
+    Environment,
+    Evaluator,
+    Experiment,
+    ExperimentSubmitResult,
+    Sample,
+    Sandbox,
+    Worker,
+)
+from ergon_core.api.worker.results import WorkerOutput
 from ergon_core.api.experiment.sampling import SamplingContext
 from ergon_core.test_support.task_factory import task_with_id
 
@@ -82,7 +92,7 @@ async def submit(
             }
         )
         return ExperimentSubmitResult(
-            experiment_ref_id=UUID("00000000-0000-0000-0000-000000000001"),
+            experiment_id=UUID("00000000-0000-0000-0000-000000000001"),
             sampler_invocation_id=UUID("00000000-0000-0000-0000-000000000002"),
             requested_k=k,
             candidate_pool_size=candidate_pool_size or k,
@@ -91,27 +101,154 @@ async def submit(
         )
 
 
-def _stub_runtime_components(monkeypatch, module) -> None:
-    for name in (
-        "make_minif2f_worker",
-        "make_minif2f_rubric",
-        "make_gdpeval_worker",
-        "make_gdpeval_rubric",
-        "make_research_rubric",
-        "make_swebench_worker",
-        "make_swebench_rubric",
-    ):
-        if hasattr(module, name):
-            monkeypatch.setattr(module, name, lambda *args, **kwargs: object())
-    for name in (
-        "LeanSandbox",
-        "_default_gdpeval_sandbox",
-        "_default_research_sandbox",
-        "_default_swebench_sandbox",
-        "SWEBenchSandbox",
-    ):
+class FakeComponent:
+    def __init__(self, *args, **kwargs) -> None:
+        self.args = args
+        self.kwargs = kwargs
+
+
+class FakeWorker(Worker):
+    type_slug = "fake-worker"
+
+    max_iterations: int | None = None
+    system_prompt: str | None = None
+    toolkit: object | None = None
+
+    async def execute(self, task, *, context):
+        del task, context
+        if False:
+            yield WorkerOutput(output="ok")
+
+
+class FakeSandbox(Sandbox):
+    async def provision(self) -> None:
+        return None
+
+    async def _bind_runtime(self, sandbox_id: str) -> None:
+        del sandbox_id
+        return None
+
+
+class FakeEvaluator(Evaluator):
+    type_slug = "fake-evaluator"
+
+    def criteria_for(self, task):
+        del task
+        return []
+
+    def aggregate_task(self, task, criterion_results):
+        del task, criterion_results
+        raise NotImplementedError
+
+
+class FakeEnvironmentFactory:
+    calls: list[dict[str, object]] = []
+
+    @classmethod
+    def from_records(cls, **kwargs) -> FakeEnvironment:
+        cls.calls.append({"constructor": "from_records", **kwargs})
+        return FakeEnvironment(
+            name=kwargs["name"], source_mode=kwargs.get("source_mode", "materialized")
+        )
+
+    @classmethod
+    def from_dataset(cls, **kwargs) -> FakeEnvironment:
+        cls.calls.append({"constructor": "from_dataset", **kwargs})
+        return FakeEnvironment(
+            name=kwargs["name"], source_mode=kwargs.get("source_mode", "streaming")
+        )
+
+
+def _fake_rows(*, limit: int | None = None, **kwargs) -> list[SimpleNamespace]:
+    del kwargs
+    size = limit or 1
+    return [
+        SimpleNamespace(
+            name=f"row-{index}",
+            repo="django/django" if index == 0 else "python/cpython",
+            difficulty=index,
+        )
+        for index in range(size)
+    ]
+
+
+def _fake_streaming_rows(*, limit: int | None = None, **kwargs) -> Iterator[SimpleNamespace]:
+    yield from _fake_rows(limit=limit or 1, **kwargs)
+
+
+def _fake_sample_from_row(row, *, environment_name: str, **kwargs) -> Sample:
+    key = getattr(row, "name", getattr(row, "instance_id", "sample-1"))
+    task_kwargs = {}
+    for name in ("worker", "sandbox", "evaluators"):
+        if name in kwargs:
+            task_kwargs[name] = kwargs[name]
+    return Sample.from_tasks(
+        name=f"{environment_name}:{key}",
+        sample_key=str(key),
+        environment_name=environment_name,
+        tasks=[
+            task_with_id(
+                uuid4(),
+                task_slug="solve",
+                instance_key=str(key),
+                description=f"Solve {key}",
+                **task_kwargs,
+            )
+        ],
+    )
+
+
+def _patch_existing(monkeypatch, module, names: Sequence[str], replacement) -> None:
+    for name in names:
         if hasattr(module, name):
-            monkeypatch.setattr(module, name, lambda *args, **kwargs: object())
+            monkeypatch.setattr(module, name, replacement)
+
+
+def _stub_runtime_components(monkeypatch, module) -> None:
+    FakeEnvironmentFactory.calls = []
+    monkeypatch.setattr(module, "Environment", FakeEnvironmentFactory)
+    _patch_existing(
+        monkeypatch,
+        module,
+        (
+            "MiniF2FToolkit",
+            "ResearchRubricsToolkit",
+            "GDPEvalToolkit",
+            "SWEBenchToolkit",
+        ),
+        FakeComponent,
+    )
+    _patch_existing(monkeypatch, module, ("ReActWorker",), FakeWorker)
+    _patch_existing(
+        monkeypatch,
+        module,
+        ("LeanSandbox", "ResearchE2BSandbox", "GDPEvalSandbox", "SWEBenchSandbox"),
+        FakeSandbox,
+    )
+    _patch_existing(
+        monkeypatch,
+        module,
+        ("MiniF2FRubric", "ResearchRubricsRubric", "StagedRubric", "SWEBenchRubric"),
+        FakeEvaluator,
+    )
+    _patch_existing(
+        monkeypatch,
+        module,
+        ("load_minif2f_rows", "load_researchrubrics_rows", "load_gdpeval_rows"),
+        _fake_rows,
+    )
+    _patch_existing(monkeypatch, module, ("iter_swebench_rows",), _fake_streaming_rows)
+    _patch_existing(
+        monkeypatch,
+        module,
+        (
+            "make_minif2f_sample",
+            "make_researchrubrics_sample",
+            "make_gdpeval_sample",
+            "make_swebench_sample",
+        ),
+        _fake_sample_from_row,
+    )
 
 
 def test_minif2f_example_prints_sample_ids_not_run_ids(monkeypatch, capsys) -> None:
@@ -119,14 +256,14 @@ def test_minif2f_example_prints_sample_ids_not_run_ids(monkeypatch, capsys) -> N
     service = FakeSubmissionService()
     _stub_runtime_components(monkeypatch, module)
     monkeypatch.setattr(module, "experiment_submission_service", lambda: service)
-    monkeypatch.setattr(module, "MiniF2FEnvironment", FakeEnvironment)
 
     asyncio.run(module.main())
 
     output = json.loads(capsys.readouterr().out)
-    assert output["experiment_ref_id"]
+    assert output["experiment_id"]
     assert output["sampler_invocation_id"]
     assert output["sample_ids"]
+    assert "experiment_ref_id" not in output
     assert "run_ids" not in output
     assert "definition_id" not in output
 
@@ -135,13 +272,6 @@ def test_mixed_environment_example_composes_all_builtin_environments(monkeypatch
     module = _load_submit_module("02_mixed_environment_training")
     service = FakeSubmissionService()
     _stub_runtime_components(monkeypatch, module)
-    for name in (
-        "MiniF2FEnvironment",
-        "ResearchRubricsEnvironment",
-        "GDPEvalEnvironment",
-        "SweBenchVerifiedEnvironment",
-    ):
-        monkeypatch.setattr(module, name, FakeEnvironment)
     monkeypatch.setattr(module, "experiment_submission_service", lambda: service)
 
     asyncio.run(module.main())
@@ -159,7 +289,6 @@ def test_streaming_example_uses_candidate_pool_larger_than_k(monkeypatch) -> Non
     module = _load_submit_module("03_streaming_hf_dataset")
     service = FakeSubmissionService()
     _stub_runtime_components(monkeypatch, module)
-    monkeypatch.setattr(module, "SweBenchVerifiedEnvironment", FakeEnvironment)
     monkeypatch.setattr(module, "experiment_submission_service", lambda: service)
 
     asyncio.run(module.main())
@@ -172,7 +301,7 @@ def test_streaming_example_uses_candidate_pool_larger_than_k(monkeypatch) -> Non
 def test_curriculum_example_uses_custom_sampler_and_larger_pool(monkeypatch) -> None:
     module = _load_submit_module("04_curriculum_sampler")
     service = FakeSubmissionService()
-    monkeypatch.setattr(module, "MiniF2FEnvironment", FakeEnvironment)
+    _stub_runtime_components(monkeypatch, module)
     monkeypatch.setattr(module, "experiment_submission_service", lambda: service)
 
     asyncio.run(module.main())
@@ -189,16 +318,25 @@ def test_row_dependent_example_passes_runtime_config_callables(monkeypatch) -> N
     captured: dict[str, object] = {}
 
     class CapturingEnvironment(FakeEnvironment):
-        def __init__(self, **kwargs) -> None:
-            captured.update(kwargs)
-            super().__init__(**kwargs)
+        @classmethod
+        def from_dataset(cls, **kwargs) -> FakeEnvironment:
+            row = next(iter(kwargs["dataset"]))
+            sample = kwargs["make_sample"](row)
+            captured["sample"] = sample
+            captured["worker"] = sample.tasks[0].worker
+            captured["evaluators"] = sample.tasks[0].evaluators
+            captured["sandbox"] = sample.tasks[0].sandbox
+            return FakeEnvironment(
+                name=kwargs["name"], source_mode=kwargs.get("source_mode", "streaming")
+            )
 
     _stub_runtime_components(monkeypatch, module)
-    monkeypatch.setattr(module, "SweBenchVerifiedEnvironment", CapturingEnvironment)
+    monkeypatch.setattr(module, "Environment", CapturingEnvironment)
     monkeypatch.setattr(module, "experiment_submission_service", lambda: FakeSubmissionService())
 
     asyncio.run(module.main())
 
-    assert callable(captured["worker"])
-    assert callable(captured["evaluators"])
-    assert callable(captured["sandbox"])
+    assert isinstance(captured["worker"], FakeWorker)
+    assert captured["worker"].model == "openai:gpt-4o"
+    assert captured["evaluators"]
+    assert isinstance(captured["sandbox"], FakeSandbox)
diff --git a/tests/examples/test_getting_started_examples.py b/tests/examples/test_getting_started_examples.py
index 9a87c377f..48412b285 100644
--- a/tests/examples/test_getting_started_examples.py
+++ b/tests/examples/test_getting_started_examples.py
@@ -4,14 +4,14 @@
 
 import importlib.util
 import json
-from collections.abc import Iterator
 from pathlib import Path
+from types import SimpleNamespace
 from uuid import UUID
 
 import pytest
-from pydantic import ConfigDict
 
-from ergon_core.api import Environment, ExperimentSubmitResult, Sample
+from ergon_core.api import Environment, Evaluator, ExperimentSubmitResult, Sample, Sandbox, Worker
+from ergon_core.api.worker.results import WorkerOutput
 from ergon_core.test_support.task_factory import task_with_id
 
 _SUBMIT_PATH = (
@@ -33,20 +33,8 @@ def _load_submit_module():
 
 
 class FakeEnvironment(Environment):
-    model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
-
-    def iter_samples(self) -> Iterator[Sample]:
-        yield Sample.from_tasks(
-            name="mini-validation:sample-1",
-            sample_key="sample-1",
-            environment_name=self.name,
-            tasks=[
-                task_with_id(
-                    UUID("00000000-0000-0000-0000-000000000011"),
-                    description="Solve sample 1",
-                )
-            ],
-        )
+    def iter_samples(self):
+        return iter(())
 
 
 class FakeSubmissionService:
@@ -61,7 +49,7 @@ async def submit(
     ) -> ExperimentSubmitResult:
         del experiment, sampler, candidate_pool_size, policy_version
         return ExperimentSubmitResult(
-            experiment_ref_id=UUID("11111111-1111-1111-1111-111111111111"),
+            experiment_id=UUID("11111111-1111-1111-1111-111111111111"),
             sampler_invocation_id=UUID("22222222-2222-2222-2222-222222222222"),
             requested_k=k,
             candidate_pool_size=k,
@@ -70,6 +58,46 @@ async def submit(
         )
 
 
+class FakeWorker(Worker):
+    type_slug = "fake-worker"
+
+    max_iterations: int | None = None
+    system_prompt: str | None = None
+    toolkit: object | None = None
+
+    async def execute(self, task, *, context):
+        del task, context
+        if False:
+            yield WorkerOutput(output="ok")
+
+
+class FakeSandbox(Sandbox):
+    async def provision(self) -> None:
+        return None
+
+    async def _bind_runtime(self, sandbox_id: str) -> None:
+        del sandbox_id
+        return None
+
+
+class FakeEvaluator(Evaluator):
+    type_slug = "fake-evaluator"
+
+    def criteria_for(self, task):
+        del task
+        return []
+
+    def aggregate_task(self, task, criterion_results):
+        del task, criterion_results
+        raise NotImplementedError
+
+
+class FakeComponent:
+    def __init__(self, *args, **kwargs) -> None:
+        self.args = args
+        self.kwargs = kwargs
+
+
 @pytest.mark.asyncio
 async def test_getting_started_submit_uses_experiment_api(monkeypatch, capsys) -> None:
     module = _load_submit_module()
@@ -79,21 +107,54 @@ def fake_preflight(*, base_url: str) -> object:
         observed["preflight_base_url"] = base_url
         return object()
 
-    def fake_make_worker(*, model: str, max_iterations: int) -> object:
-        observed["worker_model"] = model
-        observed["worker_max_iterations"] = max_iterations
-        return object()
+    def fake_load_rows(*, split: str, limit: int) -> list[SimpleNamespace]:
+        observed["load_rows"] = {"split": split, "limit": limit}
+        return [SimpleNamespace(name="sample-1")]
+
+    def fake_make_sample(
+        row, *, environment_name: str, worker, evaluators, sandbox, **kwargs
+    ) -> Sample:
+        observed["sample_kwargs"] = {
+            "row": row,
+            "environment_name": environment_name,
+            "worker": worker,
+            "evaluators": evaluators,
+            "sandbox": sandbox,
+            **kwargs,
+        }
+        return Sample.from_tasks(
+            name=f"{environment_name}:{row.name}",
+            sample_key=row.name,
+            environment_name=environment_name,
+            tasks=[
+                task_with_id(
+                    UUID("00000000-0000-0000-0000-000000000011"),
+                    task_slug="solve",
+                    instance_key=row.name,
+                    description="Solve sample 1",
+                    worker=worker,
+                    evaluators=tuple(evaluators),
+                    sandbox=sandbox,
+                )
+            ],
+        )
 
-    class CapturingEnvironment(FakeEnvironment):
-        def __init__(self, **kwargs) -> None:
+    class CapturingEnvironment:
+        @classmethod
+        def from_records(cls, **kwargs) -> FakeEnvironment:
             observed["environment_kwargs"] = kwargs
-            super().__init__(**kwargs)
+            samples = [kwargs["make_sample"](row) for row in kwargs["records"]]
+            observed["samples"] = samples
+            return FakeEnvironment(name=kwargs["name"])
 
     monkeypatch.setattr(module, "preflight_llamacpp_and_e2b", fake_preflight)
-    monkeypatch.setattr(module, "MiniF2FEnvironment", CapturingEnvironment)
-    monkeypatch.setattr(module, "make_minif2f_worker", fake_make_worker)
-    monkeypatch.setattr(module, "make_minif2f_rubric", lambda: object())
-    monkeypatch.setattr(module, "LeanSandbox", lambda: object())
+    monkeypatch.setattr(module, "Environment", CapturingEnvironment)
+    monkeypatch.setattr(module, "ReActWorker", FakeWorker)
+    monkeypatch.setattr(module, "MiniF2FToolkit", FakeComponent)
+    monkeypatch.setattr(module, "MiniF2FRubric", FakeEvaluator)
+    monkeypatch.setattr(module, "LeanSandbox", FakeSandbox)
+    monkeypatch.setattr(module, "load_minif2f_rows", fake_load_rows)
+    monkeypatch.setattr(module, "make_minif2f_sample", fake_make_sample)
     monkeypatch.setattr(module, "experiment_submission_service", lambda: FakeSubmissionService())
 
     exit_code = await module.async_main(
@@ -112,12 +173,18 @@ def __init__(self, **kwargs) -> None:
 
     assert exit_code == 0
     assert observed["preflight_base_url"] == "http://localhost:8080"
-    assert observed["worker_model"] == "llamacpp:http://localhost:8080#local-proof-model"
-    assert observed["worker_max_iterations"] == 4
-    assert observed["environment_kwargs"]["limit"] == 2
+    assert observed["load_rows"] == {"split": "validation", "limit": 2}
+    assert (
+        observed["sample_kwargs"]["worker"].model
+        == "llamacpp:http://localhost:8080#local-proof-model"
+    )
+    assert observed["sample_kwargs"]["worker"].max_iterations == 4
+    assert observed["environment_kwargs"]["name"] == "mini-validation"
     output = json.loads(capsys.readouterr().out)
     assert output == {
         "experiment_id": "11111111-1111-1111-1111-111111111111",
+        "sampler_invocation_id": "22222222-2222-2222-2222-222222222222",
+        "batch_id": None,
         "sample_ids": ["33333333-3333-3333-3333-333333333333"],
     }
 
diff --git a/tests/examples/test_minif2f_local_llamacpp_example.py b/tests/examples/test_minif2f_local_llamacpp_example.py
index 5195ee12c..4de45230d 100644
--- a/tests/examples/test_minif2f_local_llamacpp_example.py
+++ b/tests/examples/test_minif2f_local_llamacpp_example.py
@@ -6,12 +6,14 @@
 import urllib.request
 from pathlib import Path
 from types import TracebackType
+from types import SimpleNamespace
 from uuid import UUID
 
 import pytest
-from pydantic import ConfigDict
 
-from ergon_core.api import Environment, ExperimentSubmitResult
+from ergon_core.api import Environment, Evaluator, ExperimentSubmitResult, Sample, Sandbox, Worker
+from ergon_core.api.worker.results import WorkerOutput
+from ergon_core.test_support.task_factory import task_with_id
 from getting_started._shared import llamacpp
 from getting_started._shared import model_cache
 from getting_started._shared import env
@@ -42,7 +44,10 @@ def test_example_uses_packaged_imports_without_repo_root_sys_path_hack() -> None
     assert "MiniF2FBenchmark" not in source
     assert "persist_benchmark" not in source
     assert "launch_run" not in source
-    assert "from ergon_builtins.environments import MiniF2FEnvironment" in source
+    assert "from ergon_core.api import Environment, Experiment, RandomSampler" in source
+    assert "from ergon_builtins.benchmarks.minif2f.dataset import load_minif2f_rows" in source
+    assert "from ergon_builtins.benchmarks.minif2f.sample import make_minif2f_sample" in source
+    assert "MiniF2FEnvironment" not in source
     assert "from getting_started._shared.env import" in source
 
 
@@ -92,18 +97,81 @@ def close(self, *, keep_running: bool) -> None:
         self._observed["server_closed_keep_running"] = keep_running
 
 
-class _ObservedWorker:
-    def __init__(self, *, model: str, max_iterations: int) -> None:
-        self.model = model
-        self.max_iterations = max_iterations
+class _ObservedWorker(Worker):
+    type_slug = "observed-worker"
 
+    max_iterations: int | None = None
+    system_prompt: str | None = None
+    toolkit: object | None = None
 
-class _ObservedBenchmark:
-    observed: dict[str, object]
+    async def execute(self, task, *, context):
+        del task, context
+        if False:
+            yield WorkerOutput(output="ok")
 
-    def __init__(self, *, limit: int, worker_factory) -> None:
-        self.observed["benchmark_limit"] = limit
-        self.worker = worker_factory()
+
+class _ObservedSandbox(Sandbox):
+    async def provision(self) -> None:
+        return None
+
+    async def _bind_runtime(self, sandbox_id: str) -> None:
+        del sandbox_id
+        return None
+
+
+class _ObservedEvaluator(Evaluator):
+    type_slug = "observed-evaluator"
+
+    def criteria_for(self, task):
+        del task
+        return []
+
+    def aggregate_task(self, task, criterion_results):
+        del task, criterion_results
+        raise NotImplementedError
+
+
+class _ObservedComponent:
+    def __init__(self, *args, **kwargs) -> None:
+        self.args = args
+        self.kwargs = kwargs
+
+
+class _ObservedEnvironment(Environment):
+    def iter_samples(self):
+        return iter(())
+
+
+def _fake_minif2f_rows(*, split: str, limit: int) -> list[SimpleNamespace]:
+    return [SimpleNamespace(name=f"sample-{index}", split=split) for index in range(limit)]
+
+
+def _fake_minif2f_sample(
+    row,
+    *,
+    environment_name: str,
+    worker,
+    evaluators,
+    sandbox,
+    **kwargs,
+) -> Sample:
+    del kwargs
+    return Sample.from_tasks(
+        name=f"{environment_name}:{row.name}",
+        sample_key=row.name,
+        environment_name=environment_name,
+        tasks=[
+            task_with_id(
+                UUID("00000000-0000-0000-0000-000000000099"),
+                task_slug="solve",
+                instance_key=row.name,
+                description=f"Solve {row.name}",
+                worker=worker,
+                evaluators=tuple(evaluators),
+                sandbox=sandbox,
+            )
+        ],
+    )
 
 
 def test_parser_uses_getting_started_defaults(monkeypatch) -> None:
@@ -336,22 +404,12 @@ def fake_preflight(*, base_url: str) -> object:
         observed["preflight_base_url"] = base_url
         return object()
 
-    class FakeWorker:
-        def __init__(self, *, model: str, max_iterations: int) -> None:
-            self.model = model
-            self.max_iterations = max_iterations
-
-    def fake_make_worker(*, model: str, max_iterations: int) -> FakeWorker:
-        observed["worker_model"] = model
-        observed["worker_max_iterations"] = max_iterations
-        return FakeWorker(model=model, max_iterations=max_iterations)
-
-    class FakeEnvironment(Environment):
-        model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
-
-        def __init__(self, **kwargs) -> None:
+    class CapturingEnvironment:
+        @classmethod
+        def from_records(cls, **kwargs) -> _ObservedEnvironment:
             observed["environment_kwargs"] = kwargs
-            super().__init__(**kwargs)
+            observed["samples"] = [kwargs["make_sample"](row) for row in kwargs["records"]]
+            return _ObservedEnvironment(name=kwargs["name"])
 
     class FakeService:
         async def submit(
@@ -369,7 +427,7 @@ async def submit(
             observed["candidate_pool_size"] = candidate_pool_size
             observed["policy_version"] = policy_version
             return ExperimentSubmitResult(
-                experiment_ref_id=experiment_id,
+                experiment_id=experiment_id,
                 requested_k=k,
                 candidate_pool_size=k,
                 selected_count=1,
@@ -377,10 +435,13 @@ async def submit(
             )
 
     monkeypatch.setattr(module, "preflight_llamacpp_and_e2b", fake_preflight)
-    monkeypatch.setattr(module, "MiniF2FEnvironment", FakeEnvironment)
-    monkeypatch.setattr(module, "make_minif2f_worker", fake_make_worker)
-    monkeypatch.setattr(module, "make_minif2f_rubric", lambda: object())
-    monkeypatch.setattr(module, "LeanSandbox", lambda: object())
+    monkeypatch.setattr(module, "Environment", CapturingEnvironment)
+    monkeypatch.setattr(module, "ReActWorker", _ObservedWorker)
+    monkeypatch.setattr(module, "MiniF2FToolkit", _ObservedComponent)
+    monkeypatch.setattr(module, "MiniF2FRubric", _ObservedEvaluator)
+    monkeypatch.setattr(module, "LeanSandbox", _ObservedSandbox)
+    monkeypatch.setattr(module, "load_minif2f_rows", _fake_minif2f_rows)
+    monkeypatch.setattr(module, "make_minif2f_sample", _fake_minif2f_sample)
     monkeypatch.setattr(module, "experiment_submission_service", lambda: FakeService())
     monkeypatch.setenv("ERGON_DASHBOARD_URL", "http://localhost:3000")
 
@@ -399,14 +460,14 @@ async def submit(
 
     assert exit_code == 0
     assert observed["preflight_base_url"] == "http://localhost:8080"
-    assert observed["worker_model"] == "llamacpp:http://localhost:8080#local-proof-model"
-    assert observed["worker_max_iterations"] == 4
     environment_kwargs = observed["environment_kwargs"]
     assert environment_kwargs["name"] == "mini-validation"
-    assert environment_kwargs["split"] == "validation"
-    assert environment_kwargs["limit"] == 2
-    assert isinstance(environment_kwargs["worker"], FakeWorker)
-    assert len(environment_kwargs["evaluators"]) == 1
+    assert len(observed["samples"]) == 2
+    worker = observed["samples"][0].tasks[0].worker
+    assert isinstance(worker, _ObservedWorker)
+    assert worker.model == "llamacpp:http://localhost:8080#local-proof-model"
+    assert worker.max_iterations == 4
+    assert len(observed["samples"][0].tasks[0].evaluators) == 1
     assert observed["experiment_name"] == "minif2f-local-llamacpp"
     assert observed["k"] == 2
     assert observed["sampler_name"] == "random"
@@ -445,17 +506,12 @@ def fake_preflight(*, base_url: str) -> object:
         observed["preflight_base_url"] = base_url
         return object()
 
-    def fake_make_worker(*, model: str, max_iterations: int) -> _ObservedWorker:
-        observed["worker_model"] = model
-        observed["worker_max_iterations"] = max_iterations
-        return _ObservedWorker(model=model, max_iterations=max_iterations)
-
-    class FakeEnvironment(Environment):
-        model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
-
-        def __init__(self, **kwargs) -> None:
+    class CapturingEnvironment:
+        @classmethod
+        def from_records(cls, **kwargs) -> _ObservedEnvironment:
             observed["environment_kwargs"] = kwargs
-            super().__init__(**kwargs)
+            observed["samples"] = [kwargs["make_sample"](row) for row in kwargs["records"]]
+            return _ObservedEnvironment(name=kwargs["name"])
 
     class FakeService:
         async def submit(
@@ -473,7 +529,7 @@ async def submit(
             observed["candidate_pool_size"] = candidate_pool_size
             observed["policy_version"] = policy_version
             return ExperimentSubmitResult(
-                experiment_ref_id=experiment_id,
+                experiment_id=experiment_id,
                 requested_k=k,
                 candidate_pool_size=k,
                 selected_count=1,
@@ -483,10 +539,13 @@ async def submit(
     monkeypatch.setattr(module, "resolve_base_model", fake_resolve)
     monkeypatch.setattr(module, "start_llama_server", fake_start)
     monkeypatch.setattr(module, "preflight_llamacpp_and_e2b", fake_preflight)
-    monkeypatch.setattr(module, "MiniF2FEnvironment", FakeEnvironment)
-    monkeypatch.setattr(module, "make_minif2f_worker", fake_make_worker)
-    monkeypatch.setattr(module, "make_minif2f_rubric", lambda: object())
-    monkeypatch.setattr(module, "LeanSandbox", lambda: object())
+    monkeypatch.setattr(module, "Environment", CapturingEnvironment)
+    monkeypatch.setattr(module, "ReActWorker", _ObservedWorker)
+    monkeypatch.setattr(module, "MiniF2FToolkit", _ObservedComponent)
+    monkeypatch.setattr(module, "MiniF2FRubric", _ObservedEvaluator)
+    monkeypatch.setattr(module, "LeanSandbox", _ObservedSandbox)
+    monkeypatch.setattr(module, "load_minif2f_rows", _fake_minif2f_rows)
+    monkeypatch.setattr(module, "make_minif2f_sample", _fake_minif2f_sample)
     monkeypatch.setattr(module, "experiment_submission_service", lambda: FakeService())
 
     exit_code = await module.async_main(
@@ -521,16 +580,12 @@ async def submit(
             "startup_timeout": 15,
         },
         "preflight_base_url": "http://127.0.0.1:8123",
-        "worker_model": "llamacpp:http://127.0.0.1:8123#mini-proof-local",
-        "worker_max_iterations": 12,
         "environment_kwargs": {
             "name": "mini-validation",
-            "split": "validation",
-            "limit": 3,
-            "worker": observed["environment_kwargs"]["worker"],
-            "evaluators": observed["environment_kwargs"]["evaluators"],
-            "sandbox": observed["environment_kwargs"]["sandbox"],
+            "records": observed["environment_kwargs"]["records"],
+            "make_sample": observed["environment_kwargs"]["make_sample"],
         },
+        "samples": observed["samples"],
         "experiment_name": "minif2f-local-llamacpp",
         "k": 3,
         "sampler_name": "random",
@@ -538,3 +593,7 @@ async def submit(
         "policy_version": None,
         "server_closed_keep_running": True,
     }
+    worker = observed["samples"][0].tasks[0].worker
+    assert isinstance(worker, _ObservedWorker)
+    assert worker.model == "llamacpp:http://127.0.0.1:8123#mini-proof-local"
+    assert worker.max_iterations == 12
diff --git a/tests/fixtures/smoke_components/__init__.py b/tests/fixtures/smoke_components/__init__.py
index 2d4ea41be..1ce3a1f81 100644
--- a/tests/fixtures/smoke_components/__init__.py
+++ b/tests/fixtures/smoke_components/__init__.py
@@ -9,6 +9,3 @@ def register_smoke_fixtures() -> None:
     """Compatibility no-op for older smoke harness entrypoints."""
 
     return None
-
-
-register_smoke_components = register_smoke_fixtures
diff --git a/tests/fixtures/smoke_components/benchmarks.py b/tests/fixtures/smoke_components/benchmarks.py
index 9f87ffc1d..2fd17fb8b 100644
--- a/tests/fixtures/smoke_components/benchmarks.py
+++ b/tests/fixtures/smoke_components/benchmarks.py
@@ -1,20 +1,17 @@
-"""Test-owned benchmarks for canonical E2E smoke runs.
+"""Test-owned environments for canonical E2E smoke runs.
 
 The smoke matrix validates Ergon runtime topology, sandbox resource
 publication, evaluation, and dashboard rendering. It should not depend on
 network access or private Hugging Face credentials to materialize the root
-task, so these fixtures replace the production benchmark loaders only when
+task, so these fixtures replace the production environment loaders only when
 ``tests.fixtures.smoke_components`` is imported by the test harness.
 """
 
-from collections.abc import Mapping, Sequence
-from typing import ClassVar
+from collections.abc import Iterator, Sequence
+from typing import ClassVar, Literal
 
-from ergon_core.api.benchmark import (
-    Benchmark,
-    EmptyTaskPayload,
-    Task,
-)
+from ergon_core.api import Environment, Sample
+from ergon_core.api.task import Task
 from ergon_core.api.worker import Worker
 from ergon_core.core.shared.json_types import JsonObject
 from pydantic import BaseModel
@@ -104,21 +101,18 @@ class GDPEvalTaskPayload(BaseModel):
     reference_files: list[str]
 
 
-class _SingleTaskSmokeBenchmark(Benchmark):
-    """Base class for smoke benchmarks that expose one deterministic task.
+class _SingleTaskSmokeEnvironment(Environment):
+    """Base class for smoke environments that expose one deterministic sample."""
 
-    PR 10c: every subclass now overrides ``build_instances`` to return
-    a concrete ``Task[...]`` with inline ``evaluators``.  The base
-    method previously returned a ``object-bound Task``-shaped payload; with all
-    four benchmark subclasses (MiniF2F, SWE-Bench, ResearchRubrics,
-    GDPEval) owning their builds, the default is gone and the import
-    of ``object-bound Task`` no longer fans out from this module.
-    """
+    name: str
+    source_mode: Literal["materialized"] = "materialized"
+    worker_slug: str | None = None
+    model: str = "openai:gpt-4o"
 
+    environment_slug: ClassVar[str]
     task_slug: ClassVar[str]
     task_description: ClassVar[str]
     task_payload: ClassVar[JsonObject] = {}
-    task_payload_model = EmptyTaskPayload
     default_worker_slug: ClassVar[str]
 
     def __init__(
@@ -128,20 +122,37 @@ def __init__(
         model: str = "openai:gpt-4o",
         **kwargs,
     ) -> None:
+        kwargs.setdefault("name", self.environment_slug)
         super().__init__(**kwargs)
         self.worker_slug = worker_slug or self.default_worker_slug
         self.model = model
 
-    def evaluator_requirements(self) -> Sequence[str]:
-        return ("default", "post-root")
-
     def _make_worker(self) -> Worker:
+        slug = self.worker_slug or self.default_worker_slug
         try:
-            worker_cls = _SMOKE_WORKERS[self.worker_slug]
+            worker_cls = _SMOKE_WORKERS[slug]
         except KeyError:
             known = ", ".join(sorted(_SMOKE_WORKERS))
             raise ValueError(f"Unknown smoke worker slug {self.worker_slug!r}; known: {known}")
-        return worker_cls(name=self.worker_slug, model=self.model)
+        return worker_cls(name=slug, model=self.model)
+
+    def iter_samples(self) -> Iterator[Sample]:
+        yield from self.all_samples()
+
+    def all_samples(self) -> Sequence[Sample]:
+        return [
+            Sample.from_tasks(
+                name=f"{self.name}:default",
+                sample_key="default",
+                environment_name=self.name,
+                tasks=self._tasks(),
+                sample_ref={"instance_key": "default"},
+                metadata=dict(self.metadata),
+            )
+        ]
+
+    def _tasks(self) -> Sequence[Task]:
+        raise NotImplementedError
 
 
 class ResearchRubricsSmokeTask(Task[ResearchRubricsTaskPayload]):
@@ -154,21 +165,19 @@ class ResearchRubricsSmokeTask(Task[ResearchRubricsTaskPayload]):
     """
 
 
-class ResearchRubricsSmokeBenchmark(_SingleTaskSmokeBenchmark):
-    """ResearchRubrics smoke benchmark (PR 10b: object-bound Task).
+class ResearchRubricsSmokeEnvironment(_SingleTaskSmokeEnvironment):
+    """ResearchRubrics smoke environment.
 
-    Overrides ``build_instances`` to return a concrete
-    ``ResearchRubricsSmokeTask`` with inline ``evaluators``, so the smoke
+    Returns a concrete ``ResearchRubricsSmokeTask`` with inline ``evaluators``, so the smoke
     fixture exercises the v2 object-bound path that the production
-    ResearchRubrics benchmark now uses. ``sandbox`` uses the test-owned
+    ResearchRubrics environment now uses. ``sandbox`` uses the test-owned
     public wrapper over ``SmokeSandboxManager`` so eval-side
     ``Task.from_definition(..., sandbox_id=...)`` can attach a live
     runtime without reaching E2B.
     """
 
-    type_slug: ClassVar[str] = "researchrubrics"
+    environment_slug: ClassVar[str] = "researchrubrics"
     default_worker_slug: ClassVar[str] = "researchrubrics-smoke-worker"
-    task_payload_model = ResearchRubricsTaskPayload
     task_slug: ClassVar[str] = "smoke-001"
     task_description: ClassVar[str] = "Write a short smoke-test research report."
     task_payload: ClassVar[JsonObject] = {
@@ -184,7 +193,7 @@ class ResearchRubricsSmokeBenchmark(_SingleTaskSmokeBenchmark):
         ],
     }
 
-    def build_instances(self) -> Mapping[str, Sequence[Task[ResearchRubricsTaskPayload]]]:
+    def _tasks(self) -> Sequence[Task[ResearchRubricsTaskPayload]]:
         # Import smoke rubrics lazily so the production import graph of
         # `tests.fixtures.smoke_components.benchmarks` (used by anything that
         # references the smoke payload model) doesn't fan out into the full
@@ -213,7 +222,7 @@ def build_instances(self) -> Mapping[str, Sequence[Task[ResearchRubricsTaskPaylo
                 SmokePostRootTimingRubric(name="post-root"),
             ),
         )
-        return {"default": [task]}
+        return [task]
 
 
 class MiniF2FSmokeTask(Task[MiniF2FTaskPayload]):
@@ -226,21 +235,19 @@ class MiniF2FSmokeTask(Task[MiniF2FTaskPayload]):
     """
 
 
-class MiniF2FSmokeBenchmark(_SingleTaskSmokeBenchmark):
-    """MiniF2F smoke benchmark (PR 10c: object-bound Task).
+class MiniF2FSmokeEnvironment(_SingleTaskSmokeEnvironment):
+    """MiniF2F smoke environment.
 
-    Overrides ``build_instances`` to return a concrete ``MiniF2FSmokeTask``
-    with inline ``evaluators``, so the smoke fixture exercises the v2
-    object-bound path that the production MiniF2F benchmark now uses.
+    Returns a concrete ``MiniF2FSmokeTask`` with inline ``evaluators``, so the smoke fixture exercises the v2
+    object-bound path that the production MiniF2F environment now uses.
     ``sandbox`` uses the test-owned public wrapper over
     ``SmokeSandboxManager`` so eval-side
     ``Task.from_definition(..., sandbox_id=...)`` can attach a live
     runtime without reaching E2B.
     """
 
-    type_slug: ClassVar[str] = "minif2f"
+    environment_slug: ClassVar[str] = "minif2f"
     default_worker_slug: ClassVar[str] = "minif2f-smoke-worker"
-    task_payload_model = MiniF2FTaskPayload
     task_slug: ClassVar[str] = "mathd_algebra_478"
     task_description: ClassVar[str] = "Prove the smoke_trivial theorem in Lean."
     task_payload: ClassVar[JsonObject] = {
@@ -250,8 +257,8 @@ class MiniF2FSmokeBenchmark(_SingleTaskSmokeBenchmark):
         "header": "",
     }
 
-    def build_instances(self) -> Mapping[str, Sequence[Task[MiniF2FTaskPayload]]]:
-        # See ResearchRubricsSmokeBenchmark for the lazy-import rationale.
+    def _tasks(self) -> Sequence[Task[MiniF2FTaskPayload]]:
+        # See ResearchRubricsSmokeEnvironment for the lazy-import rationale.
         # reason: circular import — `criteria.smoke_rubrics` transitively
         # imports `tests.fixtures.smoke_components.smoke_base.criterion_base`,
         # which imports back into the smoke-components package while it is
@@ -276,7 +283,7 @@ def build_instances(self) -> Mapping[str, Sequence[Task[MiniF2FTaskPayload]]]:
                 SmokePostRootTimingRubric(name="post-root"),
             ),
         )
-        return {"default": [task]}
+        return [task]
 
 
 class SweBenchSmokeTask(Task[SWEBenchTaskPayload]):
@@ -289,21 +296,19 @@ class SweBenchSmokeTask(Task[SWEBenchTaskPayload]):
     """
 
 
-class SweBenchSmokeBenchmark(_SingleTaskSmokeBenchmark):
-    """SWE-Bench smoke benchmark (PR 10a: object-bound Task).
+class SweBenchSmokeEnvironment(_SingleTaskSmokeEnvironment):
+    """SWE-Bench smoke environment.
 
-    Overrides ``build_instances`` to return a concrete ``SweBenchSmokeTask``
-    with inline ``evaluators``, so the smoke fixture exercises the v2
-    object-bound path that the production SWE-Bench benchmark now uses.
+    Returns a concrete ``SweBenchSmokeTask`` with inline ``evaluators``, so the smoke fixture exercises the v2
+    object-bound path that the production SWE-Bench environment now uses.
     ``sandbox`` uses the test-owned public wrapper over
     ``SmokeSandboxManager`` so eval-side
     ``Task.from_definition(..., sandbox_id=...)`` can attach a live
     runtime without reaching E2B.
     """
 
-    type_slug: ClassVar[str] = "swebench-verified"
+    environment_slug: ClassVar[str] = "swebench-verified"
     default_worker_slug: ClassVar[str] = "swebench-smoke-worker"
-    task_payload_model = SWEBenchTaskPayload
     task_slug: ClassVar[str] = "astropy__astropy-12907"
     task_description: ClassVar[str] = "Create the simple Python add() patch used by smoke tests."
     task_payload: ClassVar[JsonObject] = {
@@ -319,8 +324,8 @@ class SweBenchSmokeBenchmark(_SingleTaskSmokeBenchmark):
         "test_patch": "",
     }
 
-    def build_instances(self) -> Mapping[str, Sequence[Task[SWEBenchTaskPayload]]]:
-        # See ResearchRubricsSmokeBenchmark for the lazy-import rationale.
+    def _tasks(self) -> Sequence[Task[SWEBenchTaskPayload]]:
+        # See ResearchRubricsSmokeEnvironment for the lazy-import rationale.
         # reason: circular import — `criteria.smoke_rubrics` transitively
         # imports `tests.fixtures.smoke_components.smoke_base.criterion_base`,
         # which imports back into the smoke-components package while it is
@@ -345,7 +350,7 @@ def build_instances(self) -> Mapping[str, Sequence[Task[SWEBenchTaskPayload]]]:
                 SmokePostRootTimingRubric(name="post-root"),
             ),
         )
-        return {"default": [task]}
+        return [task]
 
 
 class GDPEvalSmokeTask(Task[GDPEvalTaskPayload]):
@@ -358,21 +363,19 @@ class GDPEvalSmokeTask(Task[GDPEvalTaskPayload]):
     """
 
 
-class GDPEvalSmokeBenchmark(_SingleTaskSmokeBenchmark):
-    """GDPEval smoke benchmark (PR 10c: object-bound Task).
+class GDPEvalSmokeEnvironment(_SingleTaskSmokeEnvironment):
+    """GDPEval smoke environment.
 
-    Overrides ``build_instances`` to return a concrete ``GDPEvalSmokeTask``
-    with inline ``evaluators``, so the smoke fixture exercises the v2
-    object-bound path that the production GDPEval benchmark now uses.
+    Returns a concrete ``GDPEvalSmokeTask`` with inline ``evaluators``, so the smoke fixture exercises the v2
+    object-bound path that the production GDPEval environment now uses.
     The GDPEval slot did not exist before PR 10c — this is the first
-    smoke fixture row for the benchmark.  The post-root timing rubric is
+    smoke fixture row for the environment.  The post-root timing rubric is
     the only evaluator wired here; per-criterion smoke checks for
     GDPEval can land in a follow-up.
     """
 
-    type_slug: ClassVar[str] = "gdpeval"
+    environment_slug: ClassVar[str] = "gdpeval"
     default_worker_slug: ClassVar[str] = "gdpeval-smoke-worker"
-    task_payload_model = GDPEvalTaskPayload
     task_slug: ClassVar[str] = "gdpeval-smoke-001"
     task_description: ClassVar[str] = "Process the reference documents and write outputs."
     task_payload: ClassVar[JsonObject] = {
@@ -381,8 +384,8 @@ class GDPEvalSmokeBenchmark(_SingleTaskSmokeBenchmark):
         "reference_files": [],
     }
 
-    def build_instances(self) -> Mapping[str, Sequence[Task[GDPEvalTaskPayload]]]:
-        # See ResearchRubricsSmokeBenchmark for the lazy-import rationale.
+    def _tasks(self) -> Sequence[Task[GDPEvalTaskPayload]]:
+        # See ResearchRubricsSmokeEnvironment for the lazy-import rationale.
         # reason: circular import — `criteria.timing` transitively
         # imports `tests.fixtures.smoke_components.smoke_base.criterion_base`,
         # which imports back into the smoke-components package while it is
@@ -401,4 +404,4 @@ def build_instances(self) -> Mapping[str, Sequence[Task[GDPEvalTaskPayload]]]:
             sandbox=SmokePublicSandbox(),
             evaluators=(SmokePostRootTimingRubric(name="post-root"),),
         )
-        return {"default": [task]}
+        return [task]
diff --git a/tests/integration/smokes/test_smoke_harness.py b/tests/integration/smokes/test_smoke_harness.py
index 823e138b4..1efc5a2ba 100644
--- a/tests/integration/smokes/test_smoke_harness.py
+++ b/tests/integration/smokes/test_smoke_harness.py
@@ -103,7 +103,7 @@ def test_seed_sample_then_read_then_reset_roundtrip() -> None:
             seed_resp = client.post(
                 f"{API}/api/__danger__/test-harness/write/samples/seed",
                 json={
-                    "benchmark_type": "ci-smoke-harness",
+                    "environment_type": "ci-smoke-harness",
                     "instance_key": "ci-smoke-harness",
                     "experiment": _EXPERIMENT,
                     "status": "completed",
@@ -163,7 +163,7 @@ def test_write_experiment_samples_accepts_explicit_runtime_choices() -> None:
         response = client.post(
             f"{API}/api/__danger__/test-harness/write/experiment-samples",
             json={
-                "benchmark_slug": "minif2f",
+                "environment_slug": "minif2f",
                 "slots": [
                     {
                         "worker_slug": "minif2f-smoke-worker",
diff --git a/tests/integration/swebench_verified/test_benchmark.py b/tests/integration/swebench_verified/test_benchmark.py
deleted file mode 100644
index 7037f9a3a..000000000
--- a/tests/integration/swebench_verified/test_benchmark.py
+++ /dev/null
@@ -1,115 +0,0 @@
-"""Tests for the SWE-Bench Verified benchmark loader."""
-
-from __future__ import annotations
-
-from unittest.mock import patch
-
-from ergon_builtins.benchmarks.swebench_verified.benchmark import (
-    SweBenchVerifiedBenchmark,
-    _load_rows,
-)
-from ergon_builtins.benchmarks.swebench_verified.task_schemas import SWEBenchInstance
-
-
-def _fake_load_rows(*, limit=None):
-    rows = [SWEBenchInstance.from_raw(row) for row in FAKE_ROWS]
-    return rows if limit is None else rows[:limit]
-
-
-FAKE_ROWS = [
-    {
-        "instance_id": "django__django-1",
-        "repo": "django/django",
-        "base_commit": "aaa",
-        "patch": "GOLD",
-        "test_patch": "TP1",
-        "problem_statement": "p1",
-        "hints_text": "",
-        "version": "3.0",
-        "FAIL_TO_PASS": '["t1"]',
-        "PASS_TO_PASS": '["t0"]',
-        "environment_setup_commit": "aaa",
-    },
-    {
-        "instance_id": "sympy__sympy-2",
-        "repo": "sympy/sympy",
-        "base_commit": "bbb",
-        "patch": "GOLD",
-        "test_patch": "TP2",
-        "problem_statement": "p2",
-        "hints_text": "",
-        "version": "1.10",
-        "FAIL_TO_PASS": '["t2"]',
-        "PASS_TO_PASS": '["t0"]',
-        "environment_setup_commit": "bbb",
-    },
-]
-
-
-def test_build_instances_yields_one_task_per_row() -> None:
-    with patch(
-        "ergon_builtins.benchmarks.swebench_verified.benchmark._load_rows",
-        side_effect=_fake_load_rows,
-    ):
-        benchmark = SweBenchVerifiedBenchmark()
-        instances = benchmark.build_instances()
-
-    assert set(instances.keys()) == {"default"}
-    tasks = instances["default"]
-    assert len(tasks) == 2
-    assert tasks[0].task_slug == "django__django-1"
-    assert tasks[1].task_slug == "sympy__sympy-2"
-
-
-def test_limit_truncates() -> None:
-    with patch(
-        "ergon_builtins.benchmarks.swebench_verified.benchmark._load_rows",
-        side_effect=_fake_load_rows,
-    ):
-        benchmark = SweBenchVerifiedBenchmark(limit=1)
-        tasks = benchmark.build_instances()["default"]
-
-    assert len(tasks) == 1
-    assert tasks[0].task_slug == "django__django-1"
-
-
-def test_task_description_excludes_test_patch_and_gold_patch() -> None:
-    with patch(
-        "ergon_builtins.benchmarks.swebench_verified.benchmark._load_rows",
-        side_effect=_fake_load_rows,
-    ):
-        benchmark = SweBenchVerifiedBenchmark()
-        task = benchmark.build_instances()["default"][0]
-
-    assert "TP1" not in task.description
-    assert "GOLD" not in task.description
-    assert "p1" in task.description
-
-
-def test_task_payload_retains_test_patch_for_evaluator() -> None:
-    with patch(
-        "ergon_builtins.benchmarks.swebench_verified.benchmark._load_rows",
-        side_effect=_fake_load_rows,
-    ):
-        benchmark = SweBenchVerifiedBenchmark()
-        task = benchmark.build_instances()["default"][0]
-
-    assert task.task_payload.test_patch == "TP1"
-    assert not hasattr(task.task_payload, "patch")
-
-
-def test_load_rows_returns_typed_instances() -> None:
-    class FakeDataset:
-        def __len__(self):
-            return 1
-
-        def __iter__(self):
-            return iter(FAKE_ROWS[:1])
-
-    with patch(
-        "ergon_builtins.benchmarks.swebench_verified.benchmark.load_dataset",
-        return_value=FakeDataset(),
-    ):
-        rows = _load_rows()
-
-    assert rows == [SWEBenchInstance.from_raw(FAKE_ROWS[0])]
diff --git a/tests/real_llm/benchmarks/test_researchrubrics.py b/tests/real_llm/benchmarks/test_researchrubrics.py
index f39dee291..23dc37558 100644
--- a/tests/real_llm/benchmarks/test_researchrubrics.py
+++ b/tests/real_llm/benchmarks/test_researchrubrics.py
@@ -1,7 +1,7 @@
-"""Real-LLM rollout harness for the ``researchrubrics`` benchmark.
+"""Real-LLM rollout harness for the ``researchrubrics`` environment.
 
-This test is a **trigger**, not an assertion suite.  It runs a real
-``ergon benchmark run researchrubrics`` end-to-end against a real LLM
+This test is a **trigger**, not an assertion suite.  It submits a real
+ResearchRubrics environment through the Python authoring API
 (Sonnet 4.6 via OpenRouter by default) and dumps an exhaustive
 rollout artifact — every persistence table, dashboard screenshots,
 and a stitched ``report.md`` — to
@@ -11,7 +11,7 @@
 about whether the agent succeeded, and what to iterate on in the
 model or simulator.
 
-The single assertion is that the benchmark reached a terminal status
+The single assertion is that the environment rollout reached a terminal status
 (``completed`` / ``failed`` / ``cancelled``).  ``failed`` is still a
 successful rollout from the harness's perspective — it is data.
 
@@ -24,15 +24,23 @@
 """
 
 import os
-import subprocess
+import json
 import time
 from datetime import datetime, timezone
 from uuid import UUID
 
 import pytest
+from ergon_builtins.agents.react.worker import ReActWorker
+from ergon_builtins.benchmarks.researchrubrics.dataset import load_researchrubrics_rows
+from ergon_builtins.benchmarks.researchrubrics.prompts import RESEARCH_SYSTEM_PROMPT
+from ergon_builtins.benchmarks.researchrubrics.rubric import ResearchRubricsRubric
+from ergon_builtins.benchmarks.researchrubrics.sandbox import ResearchE2BSandbox
+from ergon_builtins.benchmarks.researchrubrics.sample import make_researchrubrics_sample
+from ergon_builtins.benchmarks.researchrubrics.toolkit import ResearchRubricsToolkit
+from ergon_core.api import Environment, Experiment, RandomSampler
+from ergon_core.core.application.experiments.submission import ExperimentSubmissionService
 from ergon_core.core.persistence.shared.db import ensure_db, get_session
 from ergon_core.core.persistence.telemetry.models import (
-    SampleRecord,
     SampleResource,
     SampleTaskEvaluation,
 )
@@ -58,7 +66,6 @@
 # Wall-clock caps.  Real-LLM + real-sandbox rollouts are slow; keep
 # these generous enough to absorb E2B startup + Exa retries but bounded
 # so a wedged run surfaces instead of hanging a session.
-_CLI_TIMEOUT_SECONDS = 900
 _HARNESS_POLL_TIMEOUT_SECONDS = 900
 _POST_TERMINAL_ARTIFACT_TIMEOUT_SECONDS = 300
 
@@ -74,23 +81,48 @@ def _require_keys() -> None:
         )
 
 
-def _latest_run_id_since(since: datetime) -> UUID:
-    """Return the most recent SampleRecord.id created at or after ``since``."""
+async def _submit_researchrubrics_sample(
+    *,
+    model: str,
+    limit: int,
+    max_iterations: int,
+) -> tuple[UUID, dict[str, object]]:
+    """Submit one ResearchRubrics sample through Python composition."""
     ensure_db()
     with get_session() as session:
-        stmt = (
-            select(SampleRecord)
-            .where(SampleRecord.created_at >= since)
-            .order_by(SampleRecord.created_at.desc())
-            .limit(1)
+        worker = ReActWorker(
+            name="research-runner",
+            model=model,
+            system_prompt=RESEARCH_SYSTEM_PROMPT,
+            max_iterations=max_iterations,
+            toolkit=ResearchRubricsToolkit(),
         )
-        row = session.exec(stmt).first()
-        if row is None:
-            raise RuntimeError(
-                "no SampleRecord created since the harness started — "
-                "did the CLI subprocess actually dispatch a run?"
-            )
-        return row.id
+        environment = Environment.from_records(
+            name="researchrubrics-real-llm",
+            records=load_researchrubrics_rows(split="train", limit=limit),
+            make_sample=lambda row: make_researchrubrics_sample(
+                row,
+                environment_name="researchrubrics-real-llm",
+                split="train",
+                worker=worker,
+                evaluators=[ResearchRubricsRubric(name="researchrubrics-rubric")],
+                sandbox=ResearchE2BSandbox(),
+            ),
+        )
+        experiment = Experiment(
+            name=f"real-llm-researchrubrics-{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S')}",
+            environments=[environment],
+            metadata={"source": "real-llm-harness"},
+        )
+        result = await experiment.submit(
+            service=ExperimentSubmissionService.for_session(session),
+            k=1,
+            candidate_pool_size=limit,
+            sampler=RandomSampler(seed=0),
+        )
+    if not result.sample_ids:
+        raise RuntimeError("ResearchRubrics submission returned no sample_ids")
+    return result.sample_ids[0], result.model_dump(mode="json")
 
 
 def _wait_for_post_terminal_artifacts(sample_id: UUID) -> None:
@@ -133,40 +165,23 @@ async def test_researchrubrics_rollout(
     state inside the time budget.
     """
     model = os.environ.get("ERGON_REAL_LLM_MODEL", _DEFAULT_MODEL)
-    benchmark = "researchrubrics"
-    worker = os.environ.get("ERGON_REAL_LLM_WORKER", "researchrubrics-researcher")
-    evaluator = "research-rubric"
-    limit = os.environ.get("ERGON_REAL_LLM_LIMIT", "1")
+    environment_name = "researchrubrics"
+    worker = "research-runner"
+    evaluator = "researchrubrics-rubric"
+    limit = int(os.environ.get("ERGON_REAL_LLM_LIMIT", "1"))
+    max_iterations = int(os.environ.get("ERGON_REAL_LLM_MAX_ITERATIONS", "16"))
 
     budget_before = (
         await openrouter_budget.remaining_usd() if openrouter_budget is not None else None
     )
     started_at = datetime.now(timezone.utc)
 
-    cli_proc = subprocess.run(
-        [
-            "uv",
-            "run",
-            "ergon",
-            "benchmark",
-            "run",
-            benchmark,
-            "--worker",
-            worker,
-            "--evaluator",
-            evaluator,
-            "--model",
-            model,
-            "--limit",
-            limit,
-        ],
-        timeout=_CLI_TIMEOUT_SECONDS,
-        capture_output=True,
-        text=True,
-        check=False,
+    sample_id, submission = await _submit_researchrubrics_sample(
+        model=model,
+        limit=limit,
+        max_iterations=max_iterations,
     )
 
-    sample_id = _latest_run_id_since(started_at)
     terminal_state = harness_client.wait_for_terminal(
         sample_id,
         timeout_s=_HARNESS_POLL_TIMEOUT_SECONDS,
@@ -175,10 +190,9 @@ async def test_researchrubrics_rollout(
 
     out_dir = rollout_dir(sample_id)
 
-    # Persist CLI stdout/stderr up front so a crashed DB dump still
+    # Persist submission metadata up front so a crashed DB dump still
     # leaves breadcrumbs for the reviewing agent.
-    (out_dir / "cli_stdout.txt").write_text(cli_proc.stdout or "")
-    (out_dir / "cli_stderr.txt").write_text(cli_proc.stderr or "")
+    (out_dir / "submission.json").write_text(json.dumps(submission, indent=2, default=str))
 
     table_counts = dump_rollout(sample_id, out_dir)
     screenshots = await capture_dashboard(sample_id, playwright_context, out_dir)
@@ -191,11 +205,11 @@ async def test_researchrubrics_rollout(
     manifest_path = write_manifest(
         out_dir,
         sample_id=sample_id,
-        benchmark=benchmark,
+        benchmark=environment_name,
         worker=worker,
         evaluator=evaluator,
         model=model,
-        cli_returncode=cli_proc.returncode,
+        cli_returncode=0,
         terminal_state=terminal_state,
         started_at=started_at,
         finished_at=finished_at,
diff --git a/tests/real_llm/benchmarks/test_smoke_stub.py b/tests/real_llm/benchmarks/test_smoke_stub.py
index 6e4bed565..aec89b81e 100644
--- a/tests/real_llm/benchmarks/test_smoke_stub.py
+++ b/tests/real_llm/benchmarks/test_smoke_stub.py
@@ -3,38 +3,46 @@
 
 Validates:
   - docker stack up (or --assume-stack-up), stack fixture did not skip
-  - `ergon benchmark run` CLI path works
+  - Pythonic ResearchRubrics smoke environment submission works
   - /api/__danger__/test-harness/read/samples/{id}/state returns a terminal state
   - Postgres row exists with the right relationships
   - Playwright can find the run grouping in the dashboard
 """
 
-import os
-import subprocess
-from datetime import datetime, timezone
+from datetime import timezone, datetime
 
 import pytest
+from ergon_core.api import Experiment, RandomSampler
+from ergon_core.core.application.experiments.submission import ExperimentSubmissionService
 from ergon_core.core.persistence.shared.db import ensure_db, get_session
-from ergon_core.core.persistence.telemetry.models import SampleRecord
-from sqlmodel import select
+from tests.fixtures.smoke_components.benchmarks import ResearchRubricsSmokeEnvironment
 
 pytestmark = [pytest.mark.real_llm, pytest.mark.asyncio]
 
 
-def _latest_run_id_since(since: datetime) -> str:
-    """Query the most recent SampleRecord created at or after `since`."""
+async def _submit_smoke_sample() -> str:
+    """Submit the ResearchRubrics smoke sample through Python composition."""
     ensure_db()
     with get_session() as session:
-        stmt = (
-            select(SampleRecord)
-            .where(SampleRecord.created_at >= since)
-            .order_by(SampleRecord.created_at.desc())
-            .limit(1)
+        environment = ResearchRubricsSmokeEnvironment(
+            name="researchrubrics",
+            worker_slug="researchrubrics-smoke-worker",
+            model="stub:constant",
+            metadata={"source": "real-llm-canary"},
         )
-        row = session.exec(stmt).first()
-        if row is None:
-            raise RuntimeError("no SampleRecord found after canary CLI invocation")
-        return str(row.id)
+        experiment = Experiment(
+            name=f"real-llm-smoke-stub-{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S')}",
+            environments=[environment],
+            metadata={"source": "real-llm-canary"},
+        )
+        result = await experiment.submit(
+            service=ExperimentSubmissionService.for_session(session),
+            k=1,
+            sampler=RandomSampler(seed=0),
+        )
+    if not result.sample_ids:
+        raise RuntimeError("smoke canary submission returned no sample_ids")
+    return str(result.sample_ids[0])
 
 
 async def test_harness_canary_smoke_stub(
@@ -42,43 +50,7 @@ async def test_harness_canary_smoke_stub(
     harness_client,
     playwright_context,
 ) -> None:
-    # Timestamp the boundary so we can filter for a run created *after* this point.
-    before = datetime.now(timezone.utc)
-
-    env = {
-        **os.environ,
-        "ERGON_DATABASE_URL": os.environ.get(
-            "ERGON_DATABASE_URL",
-            "postgresql://ergon:ergon_dev@127.0.0.1:5433/ergon",
-        ),
-    }
-    result = subprocess.run(
-        [
-            "uv",
-            "run",
-            "ergon",
-            "benchmark",
-            "run",
-            "researchrubrics",
-            "--model",
-            "stub:constant",
-            "--worker",
-            "researchrubrics-smoke-worker",
-            "--evaluator",
-            "researchrubrics-smoke-criterion",
-            "--limit",
-            "1",
-        ],
-        capture_output=True,
-        text=True,
-        timeout=180,
-        env=env,
-    )
-    assert result.returncode == 0, (
-        f"CLI failed (rc={result.returncode}):\nstdout: {result.stdout}\nstderr: {result.stderr}"
-    )
-
-    sample_id = _latest_run_id_since(before)
+    sample_id = await _submit_smoke_sample()
 
     # Poll the harness until terminal.
     state = harness_client.wait_for_terminal(sample_id, timeout_s=120)
diff --git a/tests/real_llm/conftest.py b/tests/real_llm/conftest.py
index 6e855fb02..f5e01a5a7 100644
--- a/tests/real_llm/conftest.py
+++ b/tests/real_llm/conftest.py
@@ -8,7 +8,7 @@
     developer to have the stack running (pnpm dev:test + postgres + inngest
     + fastapi).
 
-Session fixtures (docker stack, OpenRouter budget) live here; per-benchmark
+Session fixtures (docker stack, OpenRouter budget) live here; per-environment
 fixtures live inside each test module.
 """
 
diff --git a/tests/real_llm/rollout.py b/tests/real_llm/rollout.py
index 9e44924d8..3d2d87d4c 100644
--- a/tests/real_llm/rollout.py
+++ b/tests/real_llm/rollout.py
@@ -6,7 +6,7 @@
 artifacts and reason about whether the agent succeeded, and what to
 tweak in either the model or the simulator to iterate.
 
-The test asserts only that the benchmark reached a terminal status.
+The test asserts only that the environment rollout reached a terminal status.
 Everything else is captured as artifacts.
 
 Artifact layout:

From 040a885f8e45e3b46ac00cb6a6885afb039253a7 Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Thu, 28 May 2026 15:40:51 +0100
Subject: [PATCH 14/15] Clean public experiment API review feedback

---
 .../scripts/generate-rest-contracts.mjs       |  7 ++
 .../ergon_builtins/sandbox/e2b_runtime.py     | 34 ++-------
 ergon_core/ergon_core/api/__init__.py         |  6 +-
 .../ergon_core/api/experiment/__init__.py     |  9 +--
 .../ergon_core/api/experiment/environment.py  |  8 +-
 .../ergon_core/api/experiment/experiment.py   | 36 ++++-----
 .../ergon_core/api/experiment/persistence.py  | 21 ++----
 .../ergon_core/api/experiment/sampling.py     | 28 +++----
 .../application/experiments/candidate_pool.py | 48 +++++++-----
 .../application/experiments/persistence.py    | 38 +++++++---
 .../application/experiments/repository.py     | 12 +--
 .../application/experiments/submission.py     | 43 ++++++++++-
 .../http/routes/test_harness.py               |  3 +-
 .../test_public_experiment_submit_smoke.py    |  5 +-
 .../tests/unit/api/test_sampler_contract.py   | 74 ++++++++++++-------
 .../test_public_api_target_structure.py       | 36 ++++++++-
 ..._public_sample_authoring_api_boundaries.py |  4 +-
 .../experiments/test_candidate_pool.py        | 27 +++++--
 .../test_experiment_persistence.py            |  5 +-
 .../experiments/test_experiment_submit.py     | 41 ++++++----
 .../01_minif2f_single_environment/submit.py   |  4 +-
 .../02_mixed_environment_training/submit.py   |  4 +-
 .../03_streaming_hf_dataset/submit.py         |  4 +-
 .../04_curriculum_sampler/submit.py           |  4 +-
 .../submit.py                                 |  4 +-
 examples/experiment_api/_shared.py            |  8 +-
 .../01_minif2f_local_llamacpp/submit.py       | 10 +--
 .../examples/test_experiment_api_examples.py  | 38 ++++++++--
 .../examples/test_getting_started_examples.py | 12 ++-
 .../test_minif2f_local_llamacpp_example.py    | 22 +++++-
 .../benchmarks/test_researchrubrics.py        |  3 +-
 tests/real_llm/benchmarks/test_smoke_stub.py  |  3 +-
 32 files changed, 370 insertions(+), 231 deletions(-)

diff --git a/ergon-dashboard/scripts/generate-rest-contracts.mjs b/ergon-dashboard/scripts/generate-rest-contracts.mjs
index 3e27f52ea..6fb74ff38 100644
--- a/ergon-dashboard/scripts/generate-rest-contracts.mjs
+++ b/ergon-dashboard/scripts/generate-rest-contracts.mjs
@@ -28,6 +28,13 @@ let source = readFileSync(contractsPath, "utf8")
   );
 
 const sampleRuntimeEventDiscriminators = {
+  // openapi-zod-client currently loses literal discriminators for this Pydantic
+  // discriminated union. The dashboard relies on eventType narrowing, so this
+  // post-process keeps SampleRuntimeEventView type-safe until the generator can
+  // emit the correct z.discriminatedUnion shape directly.
+  //
+  // When adding a new backend SampleRuntimeEventView union member, add the
+  // schema name and eventType here as well, then regenerate contracts.
   SampleStatusChangedEventView: "sample.status_changed",
   SampleTaskAddedEventView: "task.added",
   SampleTaskRemovedEventView: "task.removed",
diff --git a/ergon_builtins/ergon_builtins/sandbox/e2b_runtime.py b/ergon_builtins/ergon_builtins/sandbox/e2b_runtime.py
index 0968bfc85..068d97474 100644
--- a/ergon_builtins/ergon_builtins/sandbox/e2b_runtime.py
+++ b/ergon_builtins/ergon_builtins/sandbox/e2b_runtime.py
@@ -1,27 +1,15 @@
 """E2B runtime adapter for public ``Sandbox`` implementations."""
 
 from collections.abc import Sequence
-from importlib import import_module
 from shlex import quote
 from typing import Any
 
+from e2b import SandboxNotFoundException, TimeoutException
+from e2b_code_interpreter import AsyncSandbox
+
 from ergon_core.api.sandbox.runtime import CommandResult, SandboxRuntime
 from ergon_core.core.shared.settings import settings
 
-try:
-    from e2b import SandboxNotFoundException, TimeoutException
-
-    _AsyncSandbox: Any = import_module("e2b_code_interpreter").AsyncSandbox
-except ImportError:  # pragma: no cover - optional dependency boundary
-
-    class SandboxNotFoundException(RuntimeError):
-        pass
-
-    class TimeoutException(RuntimeError):
-        pass
-
-    _AsyncSandbox: Any = None
-
 
 class E2BSandboxRuntime(SandboxRuntime):
     """E2B-backed implementation of the public ``SandboxRuntime`` contract."""
@@ -38,8 +26,8 @@ async def create(
         envs: dict[str, str] | None,
         timeout_seconds: int | None,
     ) -> "E2BSandboxRuntime":
-        sandbox_cls = _async_sandbox_cls()
-        sandbox = await sandbox_cls.create(
+        _ensure_e2b_api_key()
+        sandbox = await AsyncSandbox.create(
             template=template,
             timeout=timeout_seconds,
             envs=envs,
@@ -54,9 +42,9 @@ async def create(
 
     @classmethod
     async def connect(cls, sandbox_id: str) -> "E2BSandboxRuntime":
-        sandbox_cls = _async_sandbox_cls()
+        _ensure_e2b_api_key()
         try:
-            sandbox = await sandbox_cls.connect(
+            sandbox = await AsyncSandbox.connect(
                 sandbox_id=sandbox_id,
                 api_key=settings.e2b_api_key,
             )
@@ -100,12 +88,6 @@ async def close_local(self) -> None:
         await self._sandbox.close()
 
 
-def _async_sandbox_cls() -> Any:
-    if _AsyncSandbox is None:
-        raise RuntimeError(
-            "e2b_code_interpreter is not installed. "
-            "Install it with: pip install e2b-code-interpreter"
-        )
+def _ensure_e2b_api_key() -> None:
     if not settings.e2b_api_key:
         raise ValueError("E2B_API_KEY is not set.")
-    return _AsyncSandbox
diff --git a/ergon_core/ergon_core/api/__init__.py b/ergon_core/ergon_core/api/__init__.py
index 71495e743..cd400e8d7 100644
--- a/ergon_core/ergon_core/api/__init__.py
+++ b/ergon_core/ergon_core/api/__init__.py
@@ -19,14 +19,13 @@
 from ergon_core.api.experiment import (
     Environment,
     Experiment,
-    ExperimentRef,
     ExperimentSubmitResult,
+    PersistedExperiment,
     persist_experiment,
     RandomSampler,
     Sample,
     Sampler,
     SamplingContext,
-    SamplingHistory,
 )
 from ergon_core.api.rubric import Evaluator, Rubric, TaskEvaluationResult
 from ergon_core.api.sandbox import Sandbox, SandboxRuntime
@@ -60,8 +59,8 @@
     "EmptyTaskPayload",
     "Environment",
     "Experiment",
-    "ExperimentRef",
     "ExperimentSubmitResult",
+    "PersistedExperiment",
     "Evaluator",
     "EvidenceMessage",
     "persist_experiment",
@@ -75,7 +74,6 @@
     "ScoreScale",
     "Sampler",
     "SamplingContext",
-    "SamplingHistory",
     "SpawnedTaskHandle",
     "Task",
     "TaskEvaluationResult",
diff --git a/ergon_core/ergon_core/api/experiment/__init__.py b/ergon_core/ergon_core/api/experiment/__init__.py
index 1066c2dfa..06c5085c4 100644
--- a/ergon_core/ergon_core/api/experiment/__init__.py
+++ b/ergon_core/ergon_core/api/experiment/__init__.py
@@ -3,28 +3,25 @@
 from ergon_core.api.experiment.environment import Environment
 from ergon_core.api.experiment.experiment import (
     Experiment,
-    ExperimentRef,
     ExperimentSubmitResult,
+    PersistedExperiment,
 )
-from ergon_core.api.experiment.persistence import PersistExperimentPort, persist_experiment
+from ergon_core.api.experiment.persistence import persist_experiment
 from ergon_core.api.experiment.sample import Sample
 from ergon_core.api.experiment.sampling import (
     RandomSampler,
     Sampler,
     SamplingContext,
-    SamplingHistory,
 )
 
 __all__ = [
     "Environment",
     "Experiment",
-    "ExperimentRef",
     "ExperimentSubmitResult",
-    "PersistExperimentPort",
+    "PersistedExperiment",
     "persist_experiment",
     "RandomSampler",
     "Sample",
     "Sampler",
     "SamplingContext",
-    "SamplingHistory",
 ]
diff --git a/ergon_core/ergon_core/api/experiment/environment.py b/ergon_core/ergon_core/api/experiment/environment.py
index 2d640604c..18e51eb38 100644
--- a/ergon_core/ergon_core/api/experiment/environment.py
+++ b/ergon_core/ergon_core/api/experiment/environment.py
@@ -69,9 +69,11 @@ def all_samples(self) -> Sequence[Sample]:
         return list(self.iter_samples())
 
     def iter_samples(self) -> Iterator[Sample]:
-        # TODO(PR06): builtin environments implement this for MiniF2F,
-        # SWE-bench Verified, ResearchRubrics, and GDPEval. User-defined
-        # environments continue to override it directly.
+        """Yield authored samples.
+
+        Subclasses override this for custom loading. ``Environment.from_dataset``
+        and ``Environment.from_records`` provide the common row-backed path.
+        """
         raise NotImplementedError
 
     def iter_candidate_samples(self) -> Iterator[Sample]:
diff --git a/ergon_core/ergon_core/api/experiment/experiment.py b/ergon_core/ergon_core/api/experiment/experiment.py
index c7593921a..f1ec95881 100644
--- a/ergon_core/ergon_core/api/experiment/experiment.py
+++ b/ergon_core/ergon_core/api/experiment/experiment.py
@@ -4,7 +4,7 @@
 
 from collections.abc import Mapping, Sequence
 from datetime import datetime
-from typing import Protocol, runtime_checkable
+from typing import Any
 from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field, JsonValue, PrivateAttr
@@ -13,20 +13,7 @@
 from ergon_core.api.experiment.sampling import RandomSampler, Sampler
 
 
-@runtime_checkable
-class ExperimentSubmissionPort(Protocol):
-    async def submit(
-        self,
-        *,
-        experiment: "Experiment",
-        k: int,
-        sampler: Sampler,
-        candidate_pool_size: int | None,
-        policy_version: int | None,
-    ) -> "ExperimentSubmitResult": ...
-
-
-class ExperimentRef(BaseModel):
+class PersistedExperiment(BaseModel):
     experiment_id: UUID
     name: str
     environment_ids: Mapping[str, UUID] = Field(default_factory=dict)
@@ -56,7 +43,7 @@ class Experiment(BaseModel):
     description: str | None = None
     created_by: str | None = None
     metadata: dict[str, JsonValue] = Field(default_factory=dict)
-    _persisted_ref: ExperimentRef | None = PrivateAttr(default=None)
+    _persisted_experiment: PersistedExperiment | None = PrivateAttr(default=None)
 
     def environment_names(self) -> Sequence[str]:
         return [environment.name for environment in self.environments]
@@ -78,26 +65,31 @@ def validate_authoring(self) -> None:
         for environment in self.environments:
             environment.validate_authoring()
 
-    def persisted_ref(self) -> ExperimentRef | None:
-        return self._persisted_ref
+    def persisted_experiment(self) -> PersistedExperiment | None:
+        return self._persisted_experiment
 
-    def mark_persisted(self, ref: ExperimentRef) -> None:
-        self._persisted_ref = ref
+    def mark_persisted(self, persisted: PersistedExperiment) -> None:
+        self._persisted_experiment = persisted
 
     async def submit(
         self,
         *,
-        service: ExperimentSubmissionPort,
         k: int,
         sampler: Sampler | None = None,
         candidate_pool_size: int | None = None,
         policy_version: int | None = None,
+        session: Any | None = None,
+        event_bus: Any | None = None,
     ) -> ExperimentSubmitResult:
+        from ergon_core.core.application.experiments.submission import submit_experiment
+
         self.validate_authoring()
-        return await service.submit(
+        return await submit_experiment(
             experiment=self,
             k=k,
             sampler=sampler or RandomSampler(),
             candidate_pool_size=candidate_pool_size,
             policy_version=policy_version,
+            session=session,
+            event_bus=event_bus,
         )
diff --git a/ergon_core/ergon_core/api/experiment/persistence.py b/ergon_core/ergon_core/api/experiment/persistence.py
index f4f4c3c1a..fcc3e2f70 100644
--- a/ergon_core/ergon_core/api/experiment/persistence.py
+++ b/ergon_core/ergon_core/api/experiment/persistence.py
@@ -2,24 +2,17 @@
 
 from __future__ import annotations
 
-from typing import Protocol, runtime_checkable
+from typing import Any
 
-from ergon_core.api.experiment.experiment import Experiment, ExperimentRef
-
-
-# PR03 only defines the public seam. PR04 must provide the concrete
-# application-backed adapter, and PR05 submit paths must call that adapter rather
-# than passing bespoke fake ports around. Keep this protocol thin so public API
-# code never imports SQLModel repositories directly.
-@runtime_checkable
-class PersistExperimentPort(Protocol):
-    async def persist_experiment(self, experiment: Experiment) -> ExperimentRef: ...
+from ergon_core.api.experiment.experiment import Experiment, PersistedExperiment
 
 
 async def persist_experiment(
     experiment: Experiment,
     *,
-    service: PersistExperimentPort,
-) -> ExperimentRef:
+    session: Any | None = None,
+) -> PersistedExperiment:
+    from ergon_core.core.application.experiments.persistence import persist_public_experiment
+
     experiment.validate_authoring()
-    return await service.persist_experiment(experiment)
+    return await persist_public_experiment(experiment, session=session)
diff --git a/ergon_core/ergon_core/api/experiment/sampling.py b/ergon_core/ergon_core/api/experiment/sampling.py
index 14920a2c5..154f3dbf7 100644
--- a/ergon_core/ergon_core/api/experiment/sampling.py
+++ b/ergon_core/ergon_core/api/experiment/sampling.py
@@ -3,8 +3,8 @@
 from __future__ import annotations
 
 import random
+from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from typing import Protocol, runtime_checkable
 from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, JsonValue
@@ -12,40 +12,33 @@
 from ergon_core.api.experiment.sample import Sample
 
 
-@runtime_checkable
-class SamplingHistory(Protocol):
-    def completed_sample_keys(
-        self,
-        *,
-        experiment_id: UUID,
-        environment_name: str | None = None,
-    ) -> set[str]: ...
-
-
 class SamplingContext(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     experiment_id: UUID | None = None
     candidate_pool_size: int | None = None
-    history: SamplingHistory | None = None
 
 
-@runtime_checkable
-class Sampler(Protocol):
+class Sampler(BaseModel, ABC):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
     name: str
 
-    def config(self) -> dict[str, JsonValue]: ...
+    def config(self) -> dict[str, JsonValue]:
+        return self.model_dump(mode="json")
 
+    @abstractmethod
     async def select(
         self,
         *,
         samples: Sequence[Sample],
         k: int,
         context: SamplingContext,
-    ) -> Sequence[Sample]: ...
+    ) -> Sequence[Sample]:
+        raise NotImplementedError
 
 
-class RandomSampler(BaseModel):
+class RandomSampler(Sampler):
     name: str = "random"
     seed: int | None = None
 
@@ -59,6 +52,7 @@ async def select(
         k: int,
         context: SamplingContext,
     ) -> Sequence[Sample]:
+        del k, context
         shuffled = list(samples)
         random.Random(self.seed).shuffle(shuffled)
         return shuffled
diff --git a/ergon_core/ergon_core/core/application/experiments/candidate_pool.py b/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
index 01f439bea..6c74b584d 100644
--- a/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
+++ b/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
@@ -3,12 +3,12 @@
 from collections.abc import Sequence
 from uuid import UUID, uuid4
 
-from pydantic import JsonValue
+from pydantic import BaseModel, Field, JsonValue, ValidationError
 from sqlmodel import Session
 
 from ergon_core.api.task import Task
 from ergon_core.api.task import EmptyTaskPayload
-from ergon_core.api.experiment.experiment import Experiment, ExperimentRef
+from ergon_core.api.experiment.experiment import Experiment, PersistedExperiment
 from ergon_core.api.experiment.sample import Sample
 from ergon_core.core.application.experiments.repository import (
     ExperimentRepository,
@@ -21,7 +21,17 @@
 )
 
 
-class SampleCandidatePool:
+class CandidateSampleSnapshot(BaseModel):
+    name: str
+    sample_key: str
+    environment_name: str
+    tasks: list[dict[str, JsonValue]]
+    sample_ref: dict[str, JsonValue] = Field(default_factory=dict)
+    source_metadata: dict[str, JsonValue] = Field(default_factory=dict)
+    metadata: dict[str, JsonValue] = Field(default_factory=dict)
+
+
+class ExperimentCandidatePoolService:
     def __init__(
         self,
         session: Session,
@@ -36,7 +46,7 @@ def fill(
         self,
         *,
         experiment: Experiment,
-        handle: ExperimentRef,
+        handle: PersistedExperiment,
         candidate_pool_size: int,
     ) -> list[ExperimentSamplePoolEntryRow]:
         entries = self._repository.pending_unselected_pool_entries(handle.experiment_id)
@@ -139,7 +149,7 @@ def reserve_sample_pool_entries_for_sampler(
     )
     invocation = record_sampler_invocation(
         session=session,
-        experiment_ref=ExperimentRef(
+        experiment_ref=PersistedExperiment(
             experiment_id=experiment.id,
             name=experiment.name,
             environment_ids={},
@@ -162,23 +172,21 @@ def reserve_sample_pool_entries_for_sampler(
 async def sample_from_pool_entry(entry: ExperimentSamplePoolEntryRow) -> Sample:
     """Rehydrate retained candidate JSON into an authored, unmaterialized Sample."""
 
-    payload = dict(entry.sample_json)
-    task_snapshots = payload.pop("tasks", [])
-    tasks = [await _task_from_candidate_snapshot(task_json) for task_json in task_snapshots]
+    try:
+        snapshot = CandidateSampleSnapshot.model_validate(entry.sample_json)
+    except ValidationError as exc:
+        raise ValueError(
+            f"Candidate sample snapshot for pool entry {entry.id} is malformed"
+        ) from exc
+    tasks = [await _task_from_candidate_snapshot(task_json) for task_json in snapshot.tasks]
     return Sample.from_tasks(
-        name=str(payload["name"]),
-        sample_key=str(payload["sample_key"]),
-        environment_name=str(payload["environment_name"]),
+        name=snapshot.name,
+        sample_key=snapshot.sample_key,
+        environment_name=snapshot.environment_name,
         tasks=tasks,
-        sample_ref=payload.get("sample_ref")
-        if isinstance(payload.get("sample_ref"), dict)
-        else None,
-        source_metadata=(
-            payload.get("source_metadata")
-            if isinstance(payload.get("source_metadata"), dict)
-            else None
-        ),
-        metadata=payload.get("metadata") if isinstance(payload.get("metadata"), dict) else None,
+        sample_ref=snapshot.sample_ref,
+        source_metadata=snapshot.source_metadata,
+        metadata=snapshot.metadata,
     )
 
 
diff --git a/ergon_core/ergon_core/core/application/experiments/persistence.py b/ergon_core/ergon_core/core/application/experiments/persistence.py
index c8ebf269e..4779c20df 100644
--- a/ergon_core/ergon_core/core/application/experiments/persistence.py
+++ b/ergon_core/ergon_core/core/application/experiments/persistence.py
@@ -1,25 +1,41 @@
-"""Concrete core adapter for the public experiment persistence facade."""
+"""Concrete core persistence service for public experiment authoring objects."""
 
 from __future__ import annotations
 
 from sqlmodel import Session
 
-from ergon_core.api.experiment.experiment import Experiment, ExperimentRef
+from ergon_core.api.experiment.experiment import Experiment, PersistedExperiment
 from ergon_core.core.application.experiments.repository import (
     persist_experiment as persist_row_graph,
 )
+from ergon_core.core.persistence.shared.db import get_session
 
 
-class CoreExperimentPersistencePort:
-    """Application-backed implementation of ``api.experiment.persist_experiment``."""
+class ExperimentPersistenceService:
+    """Application-backed persistence for public ``Experiment`` objects."""
 
     def __init__(self, session: Session) -> None:
         self._session = session
 
-    async def persist_experiment(self, experiment: Experiment) -> ExperimentRef:
-        ref = experiment.persisted_ref()
-        if ref is not None:
-            return ref
-        ref = persist_row_graph(session=self._session, experiment=experiment)
-        experiment.mark_persisted(ref)
-        return ref
+    async def persist_experiment(self, experiment: Experiment) -> PersistedExperiment:
+        persisted = experiment.persisted_experiment()
+        if persisted is not None:
+            return persisted
+        persisted = persist_row_graph(session=self._session, experiment=experiment)
+        experiment.mark_persisted(persisted)
+        return persisted
+
+
+async def persist_public_experiment(
+    experiment: Experiment,
+    *,
+    session: Session | None = None,
+) -> PersistedExperiment:
+    if session is not None:
+        return await ExperimentPersistenceService(session).persist_experiment(experiment)
+    with get_session() as managed_session:
+        persisted = await ExperimentPersistenceService(managed_session).persist_experiment(
+            experiment
+        )
+        managed_session.commit()
+        return persisted
diff --git a/ergon_core/ergon_core/core/application/experiments/repository.py b/ergon_core/ergon_core/core/application/experiments/repository.py
index 6fed5860b..16fd13dea 100644
--- a/ergon_core/ergon_core/core/application/experiments/repository.py
+++ b/ergon_core/ergon_core/core/application/experiments/repository.py
@@ -5,7 +5,7 @@
 from pydantic import JsonValue
 from sqlmodel import Session, select
 
-from ergon_core.api.experiment.experiment import Experiment, ExperimentRef
+from ergon_core.api.experiment.experiment import Experiment, PersistedExperiment
 from ergon_core.api.experiment.sample import Sample
 from ergon_core.core.persistence.experiments.models import (
     ExperimentEnvironmentRow,
@@ -22,7 +22,7 @@ class ExperimentRepository:
     def __init__(self, session: Session) -> None:
         self._session = session
 
-    def persist_experiment(self, experiment: Experiment) -> ExperimentRef:
+    def persist_experiment(self, experiment: Experiment) -> PersistedExperiment:
         experiment.validate_authoring()
         row = ExperimentRow(
             name=experiment.name,
@@ -53,7 +53,7 @@ def persist_experiment(self, experiment: Experiment) -> ExperimentRef:
                 )
             ).all()
         }
-        return ExperimentRef(
+        return PersistedExperiment(
             experiment_id=row.id,
             name=row.name,
             environment_ids=environment_ids,
@@ -103,7 +103,7 @@ def known_sample_keys_by_environment(self, experiment_id: UUID) -> dict[str, set
     def record_candidate(
         self,
         *,
-        handle: ExperimentRef,
+        handle: PersistedExperiment,
         environment_id: UUID,
         sample: Sample,
     ) -> ExperimentSamplePoolEntryRow:
@@ -133,14 +133,14 @@ def mark_pool_entries_selected(
         self._session.flush()
 
 
-def persist_experiment(*, session: Session, experiment: Experiment) -> ExperimentRef:
+def persist_experiment(*, session: Session, experiment: Experiment) -> PersistedExperiment:
     return ExperimentRepository(session).persist_experiment(experiment)
 
 
 def record_sampler_invocation(
     *,
     session: Session,
-    experiment_ref: ExperimentRef,
+    experiment_ref: PersistedExperiment,
     sampler_name: str,
     requested_k: int,
     candidate_pool_size: int,
diff --git a/ergon_core/ergon_core/core/application/experiments/submission.py b/ergon_core/ergon_core/core/application/experiments/submission.py
index 8503c6ceb..07780dfa9 100644
--- a/ergon_core/ergon_core/core/application/experiments/submission.py
+++ b/ergon_core/ergon_core/core/application/experiments/submission.py
@@ -12,15 +12,16 @@
 from ergon_core.api.experiment.sampling import Sampler, SamplingContext
 from ergon_core.core.application.events.runtime import SampleStartedEvent
 from ergon_core.core.application.experiments.candidate_pool import (
-    SampleCandidatePool,
+    ExperimentCandidatePoolService,
     sample_from_pool_entry,
 )
-from ergon_core.core.application.experiments.persistence import CoreExperimentPersistencePort
+from ergon_core.core.application.experiments.persistence import ExperimentPersistenceService
 from ergon_core.core.application.experiments.repository import (
     record_sampler_invocation,
 )
 from ergon_core.core.application.samples.materialization import materialize_sample
 from ergon_core.core.infrastructure.inngest.client import InngestEvent, inngest_client
+from ergon_core.core.persistence.shared.db import get_session
 from ergon_core.core.persistence.experiments.models import (
     ExperimentSamplePoolEntryRow,
     ExperimentSamplerInvocationRow,
@@ -66,9 +67,9 @@ async def submit(
         candidate_pool_size: int | None,
         policy_version: int | None = None,
     ) -> ExperimentSubmitResult:
-        handle = await CoreExperimentPersistencePort(self._session).persist_experiment(experiment)
+        handle = await ExperimentPersistenceService(self._session).persist_experiment(experiment)
         pool_size = candidate_pool_size or k
-        pool = SampleCandidatePool(self._session)
+        pool = ExperimentCandidatePoolService(self._session)
         entries = pool.fill(
             experiment=experiment,
             handle=handle,
@@ -183,3 +184,37 @@ def _assignment_json(sample: Sample) -> dict[str, JsonValue]:
         "source_metadata": dict(sample.source_metadata),
         "metadata": dict(sample.metadata),
     }
+
+
+async def submit_experiment(
+    *,
+    experiment: Experiment,
+    k: int,
+    sampler: Sampler,
+    candidate_pool_size: int | None = None,
+    policy_version: int | None = None,
+    session: Session | None = None,
+    event_bus: EventBus | None = None,
+) -> ExperimentSubmitResult:
+    if session is not None:
+        return await ExperimentSubmissionService.for_session(
+            session,
+            event_bus=event_bus,
+        ).submit(
+            experiment=experiment,
+            k=k,
+            sampler=sampler,
+            candidate_pool_size=candidate_pool_size,
+            policy_version=policy_version,
+        )
+    with get_session() as managed_session:
+        return await ExperimentSubmissionService.for_session(
+            managed_session,
+            event_bus=event_bus,
+        ).submit(
+            experiment=experiment,
+            k=k,
+            sampler=sampler,
+            candidate_pool_size=candidate_pool_size,
+            policy_version=policy_version,
+        )
diff --git a/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py b/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py
index f3cc6c676..c869fc80c 100644
--- a/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py
+++ b/ergon_core/ergon_core/core/infrastructure/http/routes/test_harness.py
@@ -11,7 +11,6 @@
 from uuid import UUID
 
 from ergon_core.api.experiment import Environment, Experiment, Sample
-from ergon_core.core.application.experiments.service import ExperimentSubmissionService
 from ergon_core.core.application.testing.test_harness_service import (
     UnknownSampleStatusError,
     get_session_dep,
@@ -269,7 +268,7 @@ async def submit_experiment_samples(
         )
         with get_session() as session:
             result = await experiment.submit(
-                service=ExperimentSubmissionService.for_session(session),
+                session=session,
                 k=body.limit,
             )
         sample_ids.extend(result.sample_ids)
diff --git a/ergon_core/tests/integration/experiments/test_public_experiment_submit_smoke.py b/ergon_core/tests/integration/experiments/test_public_experiment_submit_smoke.py
index 4f501b849..37432b4cf 100644
--- a/ergon_core/tests/integration/experiments/test_public_experiment_submit_smoke.py
+++ b/ergon_core/tests/integration/experiments/test_public_experiment_submit_smoke.py
@@ -53,13 +53,12 @@ def session() -> Iterator[Session]:
 
 @pytest.mark.asyncio
 async def test_public_experiment_submit_materializes_samples_and_typed_wal(session) -> None:
-    from ergon_core.core.application.experiments.submission import ExperimentSubmissionService
-
     env = MaterializedEnvironment(name="mini")
     experiment = Experiment(name="mini-smoke", environments=[env])
 
     result = await experiment.submit(
-        service=ExperimentSubmissionService.for_session(session, event_bus=FakeEventBus()),
+        session=session,
+        event_bus=FakeEventBus(),
         k=1,
         sampler=RandomSampler(seed=0),
     )
diff --git a/ergon_core/tests/unit/api/test_sampler_contract.py b/ergon_core/tests/unit/api/test_sampler_contract.py
index 4dca9cbe2..a8b98ed47 100644
--- a/ergon_core/tests/unit/api/test_sampler_contract.py
+++ b/ergon_core/tests/unit/api/test_sampler_contract.py
@@ -8,11 +8,12 @@
 from ergon_core.api import (
     Environment,
     Experiment,
-    ExperimentRef,
+    PersistedExperiment,
     ExperimentSubmitResult,
     persist_experiment,
     RandomSampler,
     Sample,
+    Sampler,
     SamplingContext,
 )
 from ergon_core.test_support.task_factory import task_with_id
@@ -65,11 +66,25 @@ async def test_random_sampler_returns_all_candidates_in_seeded_order_without_tru
     assert [sample.sample_key for sample in selected] != ["0", "1", "2", "3", "4"]
 
 
-class FakeSubmissionService:
+class ReverseSampler(Sampler):
+    name: str = "reverse"
+
+    async def select(
+        self,
+        *,
+        samples,
+        k: int,
+        context: SamplingContext,
+    ):
+        del k, context
+        return list(reversed(samples))
+
+
+class FakeSubmissionResult:
     def __init__(self) -> None:
         self.calls: list[dict[str, object]] = []
 
-    async def submit(
+    async def __call__(
         self,
         *,
         experiment: Experiment,
@@ -77,7 +92,10 @@ async def submit(
         sampler: RandomSampler,
         candidate_pool_size: int | None,
         policy_version: int | None,
+        session,
+        event_bus,
     ) -> ExperimentSubmitResult:
+        del session, event_bus
         self.calls.append(
             {
                 "experiment": experiment,
@@ -97,15 +115,32 @@ async def submit(
 
 
 @pytest.mark.asyncio
-async def test_experiment_submit_validates_then_delegates_to_service() -> None:
-    service = FakeSubmissionService()
+async def test_experiment_submit_validates_then_delegates_to_core(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    fake_submit = FakeSubmissionResult()
+    monkeypatch.setattr(
+        "ergon_core.core.application.experiments.submission.submit_experiment",
+        fake_submit,
+    )
     experiment = Experiment(name="x", environments=[MaterializedEnvironment(name="m")])
 
-    result = await experiment.submit(service=service, k=1, sampler=RandomSampler(seed=1))
+    result = await experiment.submit(k=1, sampler=RandomSampler(seed=1))
 
     assert isinstance(result.experiment_id, UUID)
-    assert service.calls[0]["k"] == 1
-    assert service.calls[0]["experiment"] is experiment
+    assert fake_submit.calls[0]["k"] == 1
+    assert fake_submit.calls[0]["experiment"] is experiment
+
+
+@pytest.mark.asyncio
+async def test_custom_sampler_subclasses_public_base_model() -> None:
+    selected = await ReverseSampler().select(
+        samples=[make_sample("a"), make_sample("b")],
+        k=1,
+        context=SamplingContext(experiment_id=uuid4()),
+    )
+
+    assert [sample.sample_key for sample in selected] == ["b", "a"]
 
 
 def test_experiment_rejects_duplicate_environment_names() -> None:
@@ -130,36 +165,23 @@ def test_streaming_environment_candidate_cursor_does_not_replay() -> None:
     assert second == ["3", "4"]
 
 
-def test_experiment_can_remember_persisted_ref_between_submissions() -> None:
+def test_experiment_can_remember_persisted_experiment_between_submissions() -> None:
     experiment = Experiment(name="x", environments=[MaterializedEnvironment(name="m")])
-    ref = ExperimentRef(experiment_id=uuid4(), name="x")
+    ref = PersistedExperiment(experiment_id=uuid4(), name="x")
 
     experiment.mark_persisted(ref)
 
-    assert experiment.persisted_ref() == ref
-
-
-class FakePersistenceService:
-    def __init__(self) -> None:
-        self.calls: list[Experiment] = []
-
-    async def persist_experiment(self, experiment: Experiment):
-        self.calls.append(experiment)
-        raise AssertionError("invalid experiment should not reach persistence service")
+    assert experiment.persisted_experiment() == ref
 
 
 @pytest.mark.asyncio
 async def test_persist_experiment_validates_before_delegating() -> None:
-    service = FakePersistenceService()
-
     with pytest.raises(ValueError, match="Experiment name is required"):
-        await persist_experiment(Experiment(name="", environments=[]), service=service)
-
-    assert service.calls == []
+        await persist_experiment(Experiment(name="", environments=[]))
 
 
 def test_public_experiment_api_uses_experiment_id_names() -> None:
-    ref = ExperimentRef(
+    ref = PersistedExperiment(
         experiment_id=uuid4(),
         name="demo",
         environment_ids={},
diff --git a/ergon_core/tests/unit/architecture/test_public_api_target_structure.py b/ergon_core/tests/unit/architecture/test_public_api_target_structure.py
index de8cd31ba..400fa7bc4 100644
--- a/ergon_core/tests/unit/architecture/test_public_api_target_structure.py
+++ b/ergon_core/tests/unit/architecture/test_public_api_target_structure.py
@@ -1,5 +1,6 @@
 """Architecture guards for the Phase 1 public API target structure."""
 
+from abc import ABC
 import importlib
 import inspect
 
@@ -14,8 +15,8 @@ def test_public_api_root_exports_semantic_authoring_names_only() -> None:
         "EmptyTaskPayload",
         "Environment",
         "Experiment",
-        "ExperimentRef",
         "ExperimentSubmitResult",
+        "PersistedExperiment",
         "Worker",
         "WorkerContext",
         "WorkerOutput",
@@ -46,7 +47,6 @@ def test_public_api_root_exports_semantic_authoring_names_only() -> None:
         "SandboxNotLiveError",
         "Sampler",
         "SamplingContext",
-        "SamplingHistory",
         "TaskEvaluationResult",
         "CriterionCheckError",
     }
@@ -82,6 +82,38 @@ def test_public_api_root_exports_semantic_authoring_names_only() -> None:
     assert all(not hasattr(public_api, name) for name in retired)
 
 
+def test_experiment_public_api_does_not_export_service_ports() -> None:
+    public_api = importlib.import_module("ergon_core.api")
+    experiment_api = importlib.import_module("ergon_core.api.experiment")
+
+    forbidden = {
+        "ExperimentSubmissionPort",
+        "PersistExperimentPort",
+        "SamplingHistory",
+    }
+
+    for module in (public_api, experiment_api):
+        for name in forbidden:
+            assert not hasattr(module, name), f"{module.__name__} exports {name}"
+
+
+def test_sampler_is_public_abstract_base_model() -> None:
+    from pydantic import BaseModel
+
+    from ergon_core.api import RandomSampler, Sampler
+
+    assert issubclass(Sampler, BaseModel)
+    assert issubclass(Sampler, ABC)
+    assert issubclass(RandomSampler, Sampler)
+
+
+def test_persisted_experiment_is_the_public_persistence_receipt() -> None:
+    public_api = importlib.import_module("ergon_core.api")
+
+    assert hasattr(public_api, "PersistedExperiment")
+    assert not hasattr(public_api, "ExperimentRef")
+
+
 def test_semantic_api_clusters_are_importable() -> None:
     task = importlib.import_module("ergon_core.api.task")
     worker = importlib.import_module("ergon_core.api.worker")
diff --git a/ergon_core/tests/unit/architecture/test_public_sample_authoring_api_boundaries.py b/ergon_core/tests/unit/architecture/test_public_sample_authoring_api_boundaries.py
index 524ab4809..ed768a1a2 100644
--- a/ergon_core/tests/unit/architecture/test_public_sample_authoring_api_boundaries.py
+++ b/ergon_core/tests/unit/architecture/test_public_sample_authoring_api_boundaries.py
@@ -22,12 +22,12 @@ def test_public_api_exports_new_names_and_not_retired_names() -> None:
     assert "Sample" in public_api.__all__
     assert "Environment" in public_api.__all__
     assert "Experiment" in public_api.__all__
-    assert "ExperimentRef" in public_api.__all__
+    assert "PersistedExperiment" in public_api.__all__
     assert "ExperimentSubmitResult" in public_api.__all__
     assert "RandomSampler" in public_api.__all__
     assert "Sampler" in public_api.__all__
     assert "SamplingContext" in public_api.__all__
-    assert "SamplingHistory" in public_api.__all__
+    assert "SamplingHistory" not in public_api.__all__
     assert "persist_experiment" in public_api.__all__
     assert "SourceDescriptor" not in public_api.__all__
     assert "EnvironmentSource" not in public_api.__all__
diff --git a/ergon_core/tests/unit/core/application/experiments/test_candidate_pool.py b/ergon_core/tests/unit/core/application/experiments/test_candidate_pool.py
index 9be5948db..202ab3d52 100644
--- a/ergon_core/tests/unit/core/application/experiments/test_candidate_pool.py
+++ b/ergon_core/tests/unit/core/application/experiments/test_candidate_pool.py
@@ -9,7 +9,7 @@
 
 from ergon_core.api import Environment, Experiment, Sample
 from ergon_core.core.application.experiments.candidate_pool import (
-    SampleCandidatePool,
+    ExperimentCandidatePoolService,
     sample_from_pool_entry,
 )
 from ergon_core.core.application.experiments.repository import (
@@ -112,7 +112,7 @@ def test_candidate_pool_retains_unselected_streamed_candidates(
     streamed_experiment: Experiment,
 ) -> None:
     handle = persist_experiment(session=session, experiment=streamed_experiment)
-    pool = SampleCandidatePool(session)
+    pool = ExperimentCandidatePoolService(session)
 
     candidates = pool.fill(
         experiment=streamed_experiment,
@@ -144,7 +144,7 @@ def test_candidate_pool_reuses_unselected_entries_before_advancing_stream(
     counted_streaming_experiment: Experiment,
 ) -> None:
     handle = persist_experiment(session=session, experiment=counted_streaming_experiment)
-    pool = SampleCandidatePool(session)
+    pool = ExperimentCandidatePoolService(session)
 
     first = pool.fill(
         experiment=counted_streaming_experiment,
@@ -169,7 +169,7 @@ def test_candidate_pool_resumes_stateless_stream_cursor_after_retained_entries(
     streamed_experiment: Experiment,
 ) -> None:
     handle = persist_experiment(session=session, experiment=streamed_experiment)
-    pool = SampleCandidatePool(session)
+    pool = ExperimentCandidatePoolService(session)
 
     first = pool.fill(
         experiment=streamed_experiment,
@@ -208,7 +208,7 @@ def test_candidate_pool_round_robins_new_entries_across_environments(
         ],
     )
     handle = persist_experiment(session=session, experiment=experiment)
-    pool = SampleCandidatePool(session)
+    pool = ExperimentCandidatePoolService(session)
 
     entries = pool.fill(experiment=experiment, handle=handle, candidate_pool_size=4)
 
@@ -229,7 +229,7 @@ def test_candidate_pool_stops_after_duplicate_pull_budget(
     duplicate_env = DuplicateStreamingEnvironment(name="stream")
     experiment = Experiment(name="duplicates", environments=[duplicate_env])
     handle = persist_experiment(session=session, experiment=experiment)
-    pool = SampleCandidatePool(session, max_duplicate_pulls_per_environment=3)
+    pool = ExperimentCandidatePoolService(session, max_duplicate_pulls_per_environment=3)
 
     entries = pool.fill(experiment=experiment, handle=handle, candidate_pool_size=2)
 
@@ -255,7 +255,7 @@ async def test_candidate_pool_entry_rehydrates_object_bound_sample_without_runti
         environments=[MaterializedEnvironment(name="mini-validation", keys=("a",))],
     )
     handle = persist_experiment(session=session, experiment=experiment)
-    entry = SampleCandidatePool(session).fill(
+    entry = ExperimentCandidatePoolService(session).fill(
         experiment=experiment,
         handle=handle,
         candidate_pool_size=1,
@@ -268,3 +268,16 @@ async def test_candidate_pool_entry_rehydrates_object_bound_sample_without_runti
     assert sample.tasks[0].task_slug == "solve-mini-validation-a"
     with pytest.raises(RuntimeError, match="not been materialized"):
         _ = sample.tasks[0].task_id
+
+
+@pytest.mark.asyncio
+async def test_candidate_pool_entry_rejects_malformed_sample_snapshot() -> None:
+    entry = ExperimentSamplePoolEntryRow(
+        experiment_id=uuid4(),
+        environment_id=uuid4(),
+        sample_key="bad",
+        sample_json={"name": "bad", "sample_key": "bad", "environment_name": "mini"},
+    )
+
+    with pytest.raises(ValueError, match="malformed"):
+        await sample_from_pool_entry(entry)
diff --git a/ergon_core/tests/unit/core/application/experiments/test_experiment_persistence.py b/ergon_core/tests/unit/core/application/experiments/test_experiment_persistence.py
index ddee0e038..db953d7e1 100644
--- a/ergon_core/tests/unit/core/application/experiments/test_experiment_persistence.py
+++ b/ergon_core/tests/unit/core/application/experiments/test_experiment_persistence.py
@@ -12,7 +12,6 @@
     Sample,
     persist_experiment as persist_public_experiment,
 )
-from ergon_core.core.application.experiments.persistence import CoreExperimentPersistencePort
 from ergon_core.core.application.experiments.repository import (
     persist_experiment,
     record_sampler_invocation,
@@ -132,13 +131,13 @@ def test_record_sampler_invocation_writes_no_runtime_state(
 
 
 @pytest.mark.asyncio
-async def test_public_persistence_facade_wires_to_core_port(
+async def test_public_persistence_facade_wires_to_core(
     session: Session,
     two_env_experiment: Experiment,
 ) -> None:
     ref = await persist_public_experiment(
         two_env_experiment,
-        service=CoreExperimentPersistencePort(session),
+        session=session,
     )
 
     assert ref.experiment_id
diff --git a/ergon_core/tests/unit/core/application/experiments/test_experiment_submit.py b/ergon_core/tests/unit/core/application/experiments/test_experiment_submit.py
index 3d91a004e..11662d58e 100644
--- a/ergon_core/tests/unit/core/application/experiments/test_experiment_submit.py
+++ b/ergon_core/tests/unit/core/application/experiments/test_experiment_submit.py
@@ -8,7 +8,7 @@
 import pytest
 from sqlmodel import Session, SQLModel, create_engine, select
 
-from ergon_core.api import Environment, Experiment, RandomSampler, Sample
+from ergon_core.api import Environment, Experiment, RandomSampler, Sample, Sampler
 from ergon_core.api.experiment.sampling import SamplingContext
 from ergon_core.core.application.events.runtime import SampleStartedEvent
 from ergon_core.core.application.experiments.submission import (
@@ -60,8 +60,8 @@ async def publish(self, event: SampleStartedEvent) -> None:
         self.events.append(event)
 
 
-class SequentialSampler:
-    name = "sequential"
+class SequentialSampler(Sampler):
+    name: str = "sequential"
 
     def config(self) -> dict:
         return {}
@@ -161,7 +161,9 @@ async def test_submit_selects_and_materializes_k_samples(
 ) -> None:
     service = ExperimentSubmissionService(session=session, event_bus=FakeEventBus())
 
-    result = await experiment.submit(service=service, k=3, sampler=SequentialSampler())
+    result = await experiment.submit(
+        session=session, event_bus=service._event_bus, k=3, sampler=SequentialSampler()
+    )
 
     assert result.selected_count == 3
     assert len(result.sample_ids) == 3
@@ -183,7 +185,8 @@ async def test_submit_retains_unselected_candidate_pool_entries(
     service = ExperimentSubmissionService(session=session, event_bus=FakeEventBus())
 
     result = await streaming_experiment.submit(
-        service=service,
+        session=session,
+        event_bus=service._event_bus,
         k=2,
         sampler=SequentialSampler(),
         candidate_pool_size=8,
@@ -203,13 +206,15 @@ async def test_submit_reuses_persisted_experiment_and_retained_candidates(
     service = ExperimentSubmissionService(session=session, event_bus=FakeEventBus())
 
     first = await streaming_experiment.submit(
-        service=service,
+        session=session,
+        event_bus=service._event_bus,
         k=2,
         sampler=SequentialSampler(),
         candidate_pool_size=8,
     )
     second = await streaming_experiment.submit(
-        service=service,
+        session=session,
+        event_bus=service._event_bus,
         k=2,
         sampler=SequentialSampler(),
         candidate_pool_size=8,
@@ -231,7 +236,8 @@ async def test_submit_caps_random_sampler_selection_to_requested_k(
     service = ExperimentSubmissionService(session=session, event_bus=FakeEventBus())
 
     result = await streaming_experiment.submit(
-        service=service,
+        session=session,
+        event_bus=service._event_bus,
         k=2,
         sampler=RandomSampler(seed=7),
         candidate_pool_size=8,
@@ -253,7 +259,9 @@ async def test_submit_records_selected_sample_provenance(
 ) -> None:
     service = ExperimentSubmissionService(session=session, event_bus=FakeEventBus())
 
-    result = await two_env_experiment.submit(service=service, k=2, sampler=SequentialSampler())
+    result = await two_env_experiment.submit(
+        session=session, event_bus=service._event_bus, k=2, sampler=SequentialSampler()
+    )
 
     sample_rows = session.exec(select(SampleRecord).order_by(SampleRecord.created_at)).all()
     pool_rows = session.exec(select(ExperimentSamplePoolEntryRow)).all()
@@ -277,7 +285,8 @@ async def test_submit_records_sampler_policy_version(
     service = ExperimentSubmissionService(session=session, event_bus=FakeEventBus())
 
     result = await experiment.submit(
-        service=service,
+        session=session,
+        event_bus=service._event_bus,
         k=1,
         sampler=SequentialSampler(),
         policy_version=7,
@@ -296,7 +305,9 @@ async def test_submit_emits_sample_start_events_without_definition_or_run_ids(
     event_bus = FakeEventBus()
     service = ExperimentSubmissionService(session=session, event_bus=event_bus)
 
-    result = await experiment.submit(service=service, k=1, sampler=SequentialSampler())
+    result = await experiment.submit(
+        session=session, event_bus=service._event_bus, k=1, sampler=SequentialSampler()
+    )
 
     assert event_bus.events
     assert event_bus.events[0].payload["sample_id"] == str(result.sample_ids[0])
@@ -317,7 +328,9 @@ async def test_submit_commits_materialized_sample_before_start_event(tmp_path: P
         )
         service = ExperimentSubmissionService(session=session, event_bus=event_bus)
 
-        result = await experiment.submit(service=service, k=1, sampler=SequentialSampler())
+        result = await experiment.submit(
+            session=session, event_bus=service._event_bus, k=1, sampler=SequentialSampler()
+        )
 
     assert [event.sample_id for event in event_bus.events] == list(result.sample_ids)
 
@@ -359,7 +372,9 @@ async def fake_send(event: object) -> None:
     )
     service = ExperimentSubmissionService(session=session)
 
-    result = await experiment.submit(service=service, k=1, sampler=SequentialSampler())
+    result = await experiment.submit(
+        session=session, event_bus=service._event_bus, k=1, sampler=SequentialSampler()
+    )
 
     assert len(sent) == 1
     assert getattr(sent[0], "name") == SampleStartedEvent.name
diff --git a/examples/experiment_api/01_minif2f_single_environment/submit.py b/examples/experiment_api/01_minif2f_single_environment/submit.py
index 2f18faa3f..979796e66 100644
--- a/examples/experiment_api/01_minif2f_single_environment/submit.py
+++ b/examples/experiment_api/01_minif2f_single_environment/submit.py
@@ -12,7 +12,7 @@
 from ergon_builtins.benchmarks.minif2f.sample import make_minif2f_sample
 from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
 from ergon_core.api import Environment, Experiment, RandomSampler
-from experiment_api._shared import experiment_submission_service
+from experiment_api._shared import prepare_experiment_runtime
 
 
 async def main() -> None:
@@ -37,8 +37,8 @@ async def main() -> None:
         ),
     )
     experiment = Experiment(name="mini-validation-smoke", environments=[env])
+    prepare_experiment_runtime()
     result = await experiment.submit(
-        service=experiment_submission_service(),
         k=10,
         sampler=RandomSampler(seed=0),
     )
diff --git a/examples/experiment_api/02_mixed_environment_training/submit.py b/examples/experiment_api/02_mixed_environment_training/submit.py
index 0afe3f65c..3d12cb32b 100644
--- a/examples/experiment_api/02_mixed_environment_training/submit.py
+++ b/examples/experiment_api/02_mixed_environment_training/submit.py
@@ -30,7 +30,7 @@
 from ergon_builtins.benchmarks.swebench_verified.sample import make_swebench_sample
 from ergon_builtins.benchmarks.swebench_verified.toolkit import SWEBenchToolkit
 from ergon_core.api import Environment, Experiment, RandomSampler
-from experiment_api._shared import experiment_submission_service
+from experiment_api._shared import prepare_experiment_runtime
 
 
 async def main() -> None:
@@ -122,8 +122,8 @@ async def main() -> None:
             ),
         ],
     )
+    prepare_experiment_runtime()
     result = await experiment.submit(
-        service=experiment_submission_service(),
         k=32,
         candidate_pool_size=128,
         sampler=RandomSampler(seed=0),
diff --git a/examples/experiment_api/03_streaming_hf_dataset/submit.py b/examples/experiment_api/03_streaming_hf_dataset/submit.py
index 9c95f104c..cfe45e776 100644
--- a/examples/experiment_api/03_streaming_hf_dataset/submit.py
+++ b/examples/experiment_api/03_streaming_hf_dataset/submit.py
@@ -12,7 +12,7 @@
 from ergon_builtins.benchmarks.swebench_verified.sample import make_swebench_sample
 from ergon_builtins.benchmarks.swebench_verified.toolkit import SWEBenchToolkit
 from ergon_core.api import Environment, Experiment, RandomSampler
-from experiment_api._shared import experiment_submission_service
+from experiment_api._shared import prepare_experiment_runtime
 
 
 async def main() -> None:
@@ -37,8 +37,8 @@ async def main() -> None:
         ),
     )
     experiment = Experiment(name="swebench-streaming-buffer", environments=[env])
+    prepare_experiment_runtime()
     result = await experiment.submit(
-        service=experiment_submission_service(),
         k=8,
         candidate_pool_size=32,
         sampler=RandomSampler(seed=0),
diff --git a/examples/experiment_api/04_curriculum_sampler/submit.py b/examples/experiment_api/04_curriculum_sampler/submit.py
index 7c96f4166..6b805056f 100644
--- a/examples/experiment_api/04_curriculum_sampler/submit.py
+++ b/examples/experiment_api/04_curriculum_sampler/submit.py
@@ -13,7 +13,7 @@
 from ergon_builtins.benchmarks.minif2f.sample import make_minif2f_sample
 from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
 from ergon_core.api import Environment, Experiment, RandomSampler, Sample, SamplingContext
-from experiment_api._shared import experiment_submission_service
+from experiment_api._shared import prepare_experiment_runtime
 
 
 class EasyFirstSampler(RandomSampler):
@@ -64,8 +64,8 @@ async def main() -> None:
         ),
     )
     experiment = Experiment(name="mini-curriculum", environments=[env])
+    prepare_experiment_runtime()
     result = await experiment.submit(
-        service=experiment_submission_service(),
         k=16,
         candidate_pool_size=64,
         sampler=EasyFirstSampler(seed=0),
diff --git a/examples/experiment_api/05_row_dependent_runtime_configs/submit.py b/examples/experiment_api/05_row_dependent_runtime_configs/submit.py
index 82ca09431..6974d5179 100644
--- a/examples/experiment_api/05_row_dependent_runtime_configs/submit.py
+++ b/examples/experiment_api/05_row_dependent_runtime_configs/submit.py
@@ -13,7 +13,7 @@
 from ergon_builtins.benchmarks.swebench_verified.task_schemas import SWEBenchInstance
 from ergon_builtins.benchmarks.swebench_verified.toolkit import SWEBenchToolkit
 from ergon_core.api import Environment, Evaluator, Experiment, RandomSampler, Sandbox, Worker
-from experiment_api._shared import experiment_submission_service
+from experiment_api._shared import prepare_experiment_runtime
 
 
 def worker_for_row(row: SWEBenchInstance) -> Worker:
@@ -52,8 +52,8 @@ async def main() -> None:
         ),
     )
     experiment = Experiment(name="row-dependent-runtime-configs", environments=[env])
+    prepare_experiment_runtime()
     result = await experiment.submit(
-        service=experiment_submission_service(),
         k=8,
         candidate_pool_size=32,
         sampler=RandomSampler(seed=0),
diff --git a/examples/experiment_api/_shared.py b/examples/experiment_api/_shared.py
index f403e08ce..658aae3e1 100644
--- a/examples/experiment_api/_shared.py
+++ b/examples/experiment_api/_shared.py
@@ -2,11 +2,9 @@
 
 from __future__ import annotations
 
-from ergon_core.core.application.experiments.submission import ExperimentSubmissionService
-from ergon_core.core.persistence.shared.db import ensure_db, get_session
+from ergon_core.core.persistence.shared.db import ensure_db
 
 
-def experiment_submission_service() -> ExperimentSubmissionService:
-    """Create the concrete submission service used by example scripts."""
+def prepare_experiment_runtime() -> None:
+    """Prepare persistence before examples submit through the public API."""
     ensure_db()
-    return ExperimentSubmissionService.for_session(get_session())
diff --git a/examples/getting_started/01_minif2f_local_llamacpp/submit.py b/examples/getting_started/01_minif2f_local_llamacpp/submit.py
index f5a75a492..e01c5f9be 100644
--- a/examples/getting_started/01_minif2f_local_llamacpp/submit.py
+++ b/examples/getting_started/01_minif2f_local_llamacpp/submit.py
@@ -16,8 +16,7 @@
 from ergon_builtins.benchmarks.minif2f.sample import make_minif2f_sample
 from ergon_builtins.benchmarks.minif2f.toolkit import MiniF2FToolkit
 from ergon_core.api import Environment, Experiment, RandomSampler
-from ergon_core.core.application.experiments.submission import ExperimentSubmissionService
-from ergon_core.core.persistence.shared.db import ensure_db, get_session
+from ergon_core.core.persistence.shared.db import ensure_db
 from getting_started._shared.env import (
     DEFAULT_LLAMA_CPP_BASE_URL,
     DEFAULT_MINIF2F_LIMIT,
@@ -142,10 +141,9 @@ def preflight_base_url_from_args(args: argparse.Namespace) -> str:
     return base_url
 
 
-def experiment_submission_service() -> ExperimentSubmissionService:
-    """Create the concrete service behind this Python composition example."""
+def prepare_experiment_runtime() -> None:
+    """Prepare persistence before submitting through the public API."""
     ensure_db()
-    return ExperimentSubmissionService.for_session(get_session())
 
 
 async def async_main(argv: Sequence[str] | None = None) -> int:
@@ -202,8 +200,8 @@ async def async_main(argv: Sequence[str] | None = None) -> int:
             ),
         )
         experiment = Experiment(name="minif2f-local-llamacpp", environments=[env])
+        prepare_experiment_runtime()
         result = await experiment.submit(
-            service=experiment_submission_service(),
             k=args.limit,
             sampler=RandomSampler(seed=0),
         )
diff --git a/tests/examples/test_experiment_api_examples.py b/tests/examples/test_experiment_api_examples.py
index fdc7fe4f8..2a00ff35e 100644
--- a/tests/examples/test_experiment_api_examples.py
+++ b/tests/examples/test_experiment_api_examples.py
@@ -66,7 +66,7 @@ def __init__(self) -> None:
         self.submitted_experiments: list[Experiment] = []
         self.submit_calls: list[dict[str, object]] = []
 
-    async def submit(
+    async def __call__(
         self,
         *,
         experiment: Experiment,
@@ -74,13 +74,15 @@ async def submit(
         sampler,
         candidate_pool_size: int | None,
         policy_version: int | None,
+        session,
+        event_bus,
     ) -> ExperimentSubmitResult:
-        del policy_version
+        del policy_version, session, event_bus
         samples = [_sample(str(index), "fake") for index in range(candidate_pool_size or k)]
         selected = await sampler.select(
             samples=samples,
             k=k,
-            context=SamplingContext(experiment_ref_id=uuid4(), candidate_pool_size=len(samples)),
+            context=SamplingContext(experiment_id=uuid4(), candidate_pool_size=len(samples)),
         )
         self.submitted_experiments.append(experiment)
         self.submit_calls.append(
@@ -255,7 +257,11 @@ def test_minif2f_example_prints_sample_ids_not_run_ids(monkeypatch, capsys) -> N
     module = _load_submit_module("01_minif2f_single_environment")
     service = FakeSubmissionService()
     _stub_runtime_components(monkeypatch, module)
-    monkeypatch.setattr(module, "experiment_submission_service", lambda: service)
+    monkeypatch.setattr(module, "prepare_experiment_runtime", lambda: None)
+    monkeypatch.setattr(
+        "ergon_core.core.application.experiments.submission.submit_experiment",
+        service,
+    )
 
     asyncio.run(module.main())
 
@@ -272,7 +278,11 @@ def test_mixed_environment_example_composes_all_builtin_environments(monkeypatch
     module = _load_submit_module("02_mixed_environment_training")
     service = FakeSubmissionService()
     _stub_runtime_components(monkeypatch, module)
-    monkeypatch.setattr(module, "experiment_submission_service", lambda: service)
+    monkeypatch.setattr(module, "prepare_experiment_runtime", lambda: None)
+    monkeypatch.setattr(
+        "ergon_core.core.application.experiments.submission.submit_experiment",
+        service,
+    )
 
     asyncio.run(module.main())
 
@@ -289,7 +299,11 @@ def test_streaming_example_uses_candidate_pool_larger_than_k(monkeypatch) -> Non
     module = _load_submit_module("03_streaming_hf_dataset")
     service = FakeSubmissionService()
     _stub_runtime_components(monkeypatch, module)
-    monkeypatch.setattr(module, "experiment_submission_service", lambda: service)
+    monkeypatch.setattr(module, "prepare_experiment_runtime", lambda: None)
+    monkeypatch.setattr(
+        "ergon_core.core.application.experiments.submission.submit_experiment",
+        service,
+    )
 
     asyncio.run(module.main())
 
@@ -302,7 +316,11 @@ def test_curriculum_example_uses_custom_sampler_and_larger_pool(monkeypatch) ->
     module = _load_submit_module("04_curriculum_sampler")
     service = FakeSubmissionService()
     _stub_runtime_components(monkeypatch, module)
-    monkeypatch.setattr(module, "experiment_submission_service", lambda: service)
+    monkeypatch.setattr(module, "prepare_experiment_runtime", lambda: None)
+    monkeypatch.setattr(
+        "ergon_core.core.application.experiments.submission.submit_experiment",
+        service,
+    )
 
     asyncio.run(module.main())
 
@@ -332,7 +350,11 @@ def from_dataset(cls, **kwargs) -> FakeEnvironment:
 
     _stub_runtime_components(monkeypatch, module)
     monkeypatch.setattr(module, "Environment", CapturingEnvironment)
-    monkeypatch.setattr(module, "experiment_submission_service", lambda: FakeSubmissionService())
+    monkeypatch.setattr(module, "prepare_experiment_runtime", lambda: None)
+    monkeypatch.setattr(
+        "ergon_core.core.application.experiments.submission.submit_experiment",
+        FakeSubmissionService(),
+    )
 
     asyncio.run(module.main())
 
diff --git a/tests/examples/test_getting_started_examples.py b/tests/examples/test_getting_started_examples.py
index 48412b285..0416d79b9 100644
--- a/tests/examples/test_getting_started_examples.py
+++ b/tests/examples/test_getting_started_examples.py
@@ -38,7 +38,7 @@ def iter_samples(self):
 
 
 class FakeSubmissionService:
-    async def submit(
+    async def __call__(
         self,
         *,
         experiment,
@@ -46,8 +46,10 @@ async def submit(
         sampler,
         candidate_pool_size: int | None,
         policy_version: int | None,
+        session,
+        event_bus,
     ) -> ExperimentSubmitResult:
-        del experiment, sampler, candidate_pool_size, policy_version
+        del experiment, sampler, candidate_pool_size, policy_version, session, event_bus
         return ExperimentSubmitResult(
             experiment_id=UUID("11111111-1111-1111-1111-111111111111"),
             sampler_invocation_id=UUID("22222222-2222-2222-2222-222222222222"),
@@ -155,7 +157,11 @@ def from_records(cls, **kwargs) -> FakeEnvironment:
     monkeypatch.setattr(module, "LeanSandbox", FakeSandbox)
     monkeypatch.setattr(module, "load_minif2f_rows", fake_load_rows)
     monkeypatch.setattr(module, "make_minif2f_sample", fake_make_sample)
-    monkeypatch.setattr(module, "experiment_submission_service", lambda: FakeSubmissionService())
+    monkeypatch.setattr(module, "prepare_experiment_runtime", lambda: None)
+    monkeypatch.setattr(
+        "ergon_core.core.application.experiments.submission.submit_experiment",
+        FakeSubmissionService(),
+    )
 
     exit_code = await module.async_main(
         [
diff --git a/tests/examples/test_minif2f_local_llamacpp_example.py b/tests/examples/test_minif2f_local_llamacpp_example.py
index 4de45230d..789413603 100644
--- a/tests/examples/test_minif2f_local_llamacpp_example.py
+++ b/tests/examples/test_minif2f_local_llamacpp_example.py
@@ -412,7 +412,7 @@ def from_records(cls, **kwargs) -> _ObservedEnvironment:
             return _ObservedEnvironment(name=kwargs["name"])
 
     class FakeService:
-        async def submit(
+        async def __call__(
             self,
             *,
             experiment,
@@ -420,7 +420,10 @@ async def submit(
             sampler,
             candidate_pool_size,
             policy_version,
+            session,
+            event_bus,
         ):
+            del session, event_bus
             observed["experiment_name"] = experiment.name
             observed["k"] = k
             observed["sampler_name"] = sampler.name
@@ -442,7 +445,11 @@ async def submit(
     monkeypatch.setattr(module, "LeanSandbox", _ObservedSandbox)
     monkeypatch.setattr(module, "load_minif2f_rows", _fake_minif2f_rows)
     monkeypatch.setattr(module, "make_minif2f_sample", _fake_minif2f_sample)
-    monkeypatch.setattr(module, "experiment_submission_service", lambda: FakeService())
+    monkeypatch.setattr(module, "prepare_experiment_runtime", lambda: None)
+    monkeypatch.setattr(
+        "ergon_core.core.application.experiments.submission.submit_experiment",
+        FakeService(),
+    )
     monkeypatch.setenv("ERGON_DASHBOARD_URL", "http://localhost:3000")
 
     exit_code = await module.async_main(
@@ -514,7 +521,7 @@ def from_records(cls, **kwargs) -> _ObservedEnvironment:
             return _ObservedEnvironment(name=kwargs["name"])
 
     class FakeService:
-        async def submit(
+        async def __call__(
             self,
             *,
             experiment,
@@ -522,7 +529,10 @@ async def submit(
             sampler,
             candidate_pool_size,
             policy_version,
+            session,
+            event_bus,
         ):
+            del session, event_bus
             observed["experiment_name"] = experiment.name
             observed["k"] = k
             observed["sampler_name"] = sampler.name
@@ -546,7 +556,11 @@ async def submit(
     monkeypatch.setattr(module, "LeanSandbox", _ObservedSandbox)
     monkeypatch.setattr(module, "load_minif2f_rows", _fake_minif2f_rows)
     monkeypatch.setattr(module, "make_minif2f_sample", _fake_minif2f_sample)
-    monkeypatch.setattr(module, "experiment_submission_service", lambda: FakeService())
+    monkeypatch.setattr(module, "prepare_experiment_runtime", lambda: None)
+    monkeypatch.setattr(
+        "ergon_core.core.application.experiments.submission.submit_experiment",
+        FakeService(),
+    )
 
     exit_code = await module.async_main(
         [
diff --git a/tests/real_llm/benchmarks/test_researchrubrics.py b/tests/real_llm/benchmarks/test_researchrubrics.py
index 23dc37558..ab35ef80f 100644
--- a/tests/real_llm/benchmarks/test_researchrubrics.py
+++ b/tests/real_llm/benchmarks/test_researchrubrics.py
@@ -38,7 +38,6 @@
 from ergon_builtins.benchmarks.researchrubrics.sample import make_researchrubrics_sample
 from ergon_builtins.benchmarks.researchrubrics.toolkit import ResearchRubricsToolkit
 from ergon_core.api import Environment, Experiment, RandomSampler
-from ergon_core.core.application.experiments.submission import ExperimentSubmissionService
 from ergon_core.core.persistence.shared.db import ensure_db, get_session
 from ergon_core.core.persistence.telemetry.models import (
     SampleResource,
@@ -115,7 +114,7 @@ async def _submit_researchrubrics_sample(
             metadata={"source": "real-llm-harness"},
         )
         result = await experiment.submit(
-            service=ExperimentSubmissionService.for_session(session),
+            session=session,
             k=1,
             candidate_pool_size=limit,
             sampler=RandomSampler(seed=0),
diff --git a/tests/real_llm/benchmarks/test_smoke_stub.py b/tests/real_llm/benchmarks/test_smoke_stub.py
index aec89b81e..bf57ef5b4 100644
--- a/tests/real_llm/benchmarks/test_smoke_stub.py
+++ b/tests/real_llm/benchmarks/test_smoke_stub.py
@@ -13,7 +13,6 @@
 
 import pytest
 from ergon_core.api import Experiment, RandomSampler
-from ergon_core.core.application.experiments.submission import ExperimentSubmissionService
 from ergon_core.core.persistence.shared.db import ensure_db, get_session
 from tests.fixtures.smoke_components.benchmarks import ResearchRubricsSmokeEnvironment
 
@@ -36,7 +35,7 @@ async def _submit_smoke_sample() -> str:
             metadata={"source": "real-llm-canary"},
         )
         result = await experiment.submit(
-            service=ExperimentSubmissionService.for_session(session),
+            session=session,
             k=1,
             sampler=RandomSampler(seed=0),
         )

From b22d1508cb55e662971cd4a3ffb4c4d0043cd892 Mon Sep 17 00:00:00 2001
From: Charlie Masters <69640669+cm2435@users.noreply.github.com>
Date: Thu, 28 May 2026 16:23:53 +0100
Subject: [PATCH 15/15] Remove public experiment persistence facade

---
 ergon_core/ergon_core/api/__init__.py         |  2 -
 .../ergon_core/api/experiment/__init__.py     |  4 +-
 .../ergon_core/api/experiment/experiment.py   | 40 +++++++------------
 .../ergon_core/api/experiment/persistence.py  | 18 ---------
 .../ergon_core/api/experiment/results.py      |  8 ++++
 .../application/experiments/candidate_pool.py | 23 +++++++----
 .../application/experiments/persistence.py    | 11 +++--
 .../application/experiments/repository.py     | 16 +++++---
 .../core/application/experiments/results.py   | 29 ++++++++++++++
 .../application/experiments/submission.py     | 13 ++++--
 .../application/samples/materialization.py    | 15 +++++--
 .../tests/unit/api/test_public_api_imports.py |  3 +-
 .../tests/unit/api/test_sampler_contract.py   | 16 ++++----
 .../test_public_api_target_structure.py       |  2 +-
 ..._public_sample_authoring_api_boundaries.py |  2 +-
 .../test_experiment_persistence.py            |  6 +--
 16 files changed, 123 insertions(+), 85 deletions(-)
 delete mode 100644 ergon_core/ergon_core/api/experiment/persistence.py
 create mode 100644 ergon_core/ergon_core/api/experiment/results.py
 create mode 100644 ergon_core/ergon_core/core/application/experiments/results.py

diff --git a/ergon_core/ergon_core/api/__init__.py b/ergon_core/ergon_core/api/__init__.py
index cd400e8d7..1052671a4 100644
--- a/ergon_core/ergon_core/api/__init__.py
+++ b/ergon_core/ergon_core/api/__init__.py
@@ -21,7 +21,6 @@
     Experiment,
     ExperimentSubmitResult,
     PersistedExperiment,
-    persist_experiment,
     RandomSampler,
     Sample,
     Sampler,
@@ -63,7 +62,6 @@
     "PersistedExperiment",
     "Evaluator",
     "EvidenceMessage",
-    "persist_experiment",
     "RandomSampler",
     "Rubric",
     "Sample",
diff --git a/ergon_core/ergon_core/api/experiment/__init__.py b/ergon_core/ergon_core/api/experiment/__init__.py
index 06c5085c4..92303fe19 100644
--- a/ergon_core/ergon_core/api/experiment/__init__.py
+++ b/ergon_core/ergon_core/api/experiment/__init__.py
@@ -3,10 +3,11 @@
 from ergon_core.api.experiment.environment import Environment
 from ergon_core.api.experiment.experiment import (
     Experiment,
+)
+from ergon_core.core.application.experiments.results import (
     ExperimentSubmitResult,
     PersistedExperiment,
 )
-from ergon_core.api.experiment.persistence import persist_experiment
 from ergon_core.api.experiment.sample import Sample
 from ergon_core.api.experiment.sampling import (
     RandomSampler,
@@ -19,7 +20,6 @@
     "Experiment",
     "ExperimentSubmitResult",
     "PersistedExperiment",
-    "persist_experiment",
     "RandomSampler",
     "Sample",
     "Sampler",
diff --git a/ergon_core/ergon_core/api/experiment/experiment.py b/ergon_core/ergon_core/api/experiment/experiment.py
index f1ec95881..62d541b94 100644
--- a/ergon_core/ergon_core/api/experiment/experiment.py
+++ b/ergon_core/ergon_core/api/experiment/experiment.py
@@ -2,35 +2,19 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping, Sequence
-from datetime import datetime
+from collections.abc import Sequence
 from typing import Any
-from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field, JsonValue, PrivateAttr
 
 from ergon_core.api.experiment.environment import Environment
+from ergon_core.core.application.experiments.results import (
+    ExperimentSubmitResult,
+    PersistedExperiment,
+)
 from ergon_core.api.experiment.sampling import RandomSampler, Sampler
-
-
-class PersistedExperiment(BaseModel):
-    experiment_id: UUID
-    name: str
-    environment_ids: Mapping[str, UUID] = Field(default_factory=dict)
-    created_at: datetime | None = None
-    dashboard_url: str | None = None
-    metadata: dict[str, JsonValue] = Field(default_factory=dict)
-
-
-class ExperimentSubmitResult(BaseModel):
-    experiment_id: UUID
-    sampler_invocation_id: UUID | None = None
-    batch_id: UUID | None = None
-    requested_k: int
-    candidate_pool_size: int
-    selected_count: int
-    sample_ids: Sequence[UUID]
-    dashboard_url: str | None = None
+from ergon_core.core.application.experiments.persistence import persist_public_experiment
+from ergon_core.core.application.experiments.submission import submit_experiment
 
 
 class Experiment(BaseModel):
@@ -71,6 +55,14 @@ def persisted_experiment(self) -> PersistedExperiment | None:
     def mark_persisted(self, persisted: PersistedExperiment) -> None:
         self._persisted_experiment = persisted
 
+    async def persist(
+        self,
+        *,
+        session: Any | None = None,
+    ) -> PersistedExperiment:
+        self.validate_authoring()
+        return await persist_public_experiment(self, session=session)
+
     async def submit(
         self,
         *,
@@ -81,8 +73,6 @@ async def submit(
         session: Any | None = None,
         event_bus: Any | None = None,
     ) -> ExperimentSubmitResult:
-        from ergon_core.core.application.experiments.submission import submit_experiment
-
         self.validate_authoring()
         return await submit_experiment(
             experiment=self,
diff --git a/ergon_core/ergon_core/api/experiment/persistence.py b/ergon_core/ergon_core/api/experiment/persistence.py
deleted file mode 100644
index fcc3e2f70..000000000
--- a/ergon_core/ergon_core/api/experiment/persistence.py
+++ /dev/null
@@ -1,18 +0,0 @@
-"""Public persistence facade for experiment authoring objects."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from ergon_core.api.experiment.experiment import Experiment, PersistedExperiment
-
-
-async def persist_experiment(
-    experiment: Experiment,
-    *,
-    session: Any | None = None,
-) -> PersistedExperiment:
-    from ergon_core.core.application.experiments.persistence import persist_public_experiment
-
-    experiment.validate_authoring()
-    return await persist_public_experiment(experiment, session=session)
diff --git a/ergon_core/ergon_core/api/experiment/results.py b/ergon_core/ergon_core/api/experiment/results.py
new file mode 100644
index 000000000..bc9c1d5e3
--- /dev/null
+++ b/ergon_core/ergon_core/api/experiment/results.py
@@ -0,0 +1,8 @@
+"""Public import location for experiment application result models."""
+
+from ergon_core.core.application.experiments.results import (
+    ExperimentSubmitResult,
+    PersistedExperiment,
+)
+
+__all__ = ["ExperimentSubmitResult", "PersistedExperiment"]
diff --git a/ergon_core/ergon_core/core/application/experiments/candidate_pool.py b/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
index 6c74b584d..db6f7a721 100644
--- a/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
+++ b/ergon_core/ergon_core/core/application/experiments/candidate_pool.py
@@ -1,15 +1,15 @@
 """Candidate-pool persistence for public experiment samples."""
 
+from __future__ import annotations
+
 from collections.abc import Sequence
+from typing import TYPE_CHECKING
 from uuid import UUID, uuid4
 
 from pydantic import BaseModel, Field, JsonValue, ValidationError
 from sqlmodel import Session
 
-from ergon_core.api.task import Task
-from ergon_core.api.task import EmptyTaskPayload
-from ergon_core.api.experiment.experiment import Experiment, PersistedExperiment
-from ergon_core.api.experiment.sample import Sample
+from ergon_core.core.application.experiments.results import PersistedExperiment
 from ergon_core.core.application.experiments.repository import (
     ExperimentRepository,
     record_sampler_invocation,
@@ -20,6 +20,11 @@
     ExperimentSamplePoolEntryRow,
 )
 
+if TYPE_CHECKING:
+    from ergon_core.api.experiment.experiment import Experiment
+    from ergon_core.api.experiment.sample import Sample
+    from ergon_core.api.task import Task
+
 
 class CandidateSampleSnapshot(BaseModel):
     name: str
@@ -45,7 +50,7 @@ def __init__(
     def fill(
         self,
         *,
-        experiment: Experiment,
+        experiment: "Experiment",
         handle: PersistedExperiment,
         candidate_pool_size: int,
     ) -> list[ExperimentSamplePoolEntryRow]:
@@ -169,9 +174,11 @@ def reserve_sample_pool_entries_for_sampler(
     return invocation, selected_entries
 
 
-async def sample_from_pool_entry(entry: ExperimentSamplePoolEntryRow) -> Sample:
+async def sample_from_pool_entry(entry: ExperimentSamplePoolEntryRow) -> "Sample":
     """Rehydrate retained candidate JSON into an authored, unmaterialized Sample."""
 
+    from ergon_core.api.experiment.sample import Sample
+
     try:
         snapshot = CandidateSampleSnapshot.model_validate(entry.sample_json)
     except ValidationError as exc:
@@ -190,7 +197,9 @@ async def sample_from_pool_entry(entry: ExperimentSamplePoolEntryRow) -> Sample:
     )
 
 
-async def _task_from_candidate_snapshot(task_json: object) -> Task:
+async def _task_from_candidate_snapshot(task_json: object) -> "Task":
+    from ergon_core.api.task import EmptyTaskPayload, Task
+
     if not isinstance(task_json, dict):
         raise ValueError(
             f"Candidate task snapshot must be an object, got {type(task_json).__name__}"
diff --git a/ergon_core/ergon_core/core/application/experiments/persistence.py b/ergon_core/ergon_core/core/application/experiments/persistence.py
index 4779c20df..e58dce439 100644
--- a/ergon_core/ergon_core/core/application/experiments/persistence.py
+++ b/ergon_core/ergon_core/core/application/experiments/persistence.py
@@ -2,14 +2,19 @@
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from sqlmodel import Session
 
-from ergon_core.api.experiment.experiment import Experiment, PersistedExperiment
+from ergon_core.core.application.experiments.results import PersistedExperiment
 from ergon_core.core.application.experiments.repository import (
     persist_experiment as persist_row_graph,
 )
 from ergon_core.core.persistence.shared.db import get_session
 
+if TYPE_CHECKING:
+    from ergon_core.api.experiment.experiment import Experiment
+
 
 class ExperimentPersistenceService:
     """Application-backed persistence for public ``Experiment`` objects."""
@@ -17,7 +22,7 @@ class ExperimentPersistenceService:
     def __init__(self, session: Session) -> None:
         self._session = session
 
-    async def persist_experiment(self, experiment: Experiment) -> PersistedExperiment:
+    async def persist_experiment(self, experiment: "Experiment") -> PersistedExperiment:
         persisted = experiment.persisted_experiment()
         if persisted is not None:
             return persisted
@@ -27,7 +32,7 @@ async def persist_experiment(self, experiment: Experiment) -> PersistedExperimen
 
 
 async def persist_public_experiment(
-    experiment: Experiment,
+    experiment: "Experiment",
     *,
     session: Session | None = None,
 ) -> PersistedExperiment:
diff --git a/ergon_core/ergon_core/core/application/experiments/repository.py b/ergon_core/ergon_core/core/application/experiments/repository.py
index 16fd13dea..316f378a6 100644
--- a/ergon_core/ergon_core/core/application/experiments/repository.py
+++ b/ergon_core/ergon_core/core/application/experiments/repository.py
@@ -1,12 +1,14 @@
 """Application repository helpers for experiment persistence."""
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 from uuid import UUID
 
 from pydantic import JsonValue
 from sqlmodel import Session, select
 
-from ergon_core.api.experiment.experiment import Experiment, PersistedExperiment
-from ergon_core.api.experiment.sample import Sample
+from ergon_core.core.application.experiments.results import PersistedExperiment
 from ergon_core.core.persistence.experiments.models import (
     ExperimentEnvironmentRow,
     ExperimentRow,
@@ -15,6 +17,10 @@
 )
 from ergon_core.core.shared.utils import utcnow
 
+if TYPE_CHECKING:
+    from ergon_core.api.experiment.experiment import Experiment
+    from ergon_core.api.experiment.sample import Sample
+
 
 class ExperimentRepository:
     """Data-access boundary for experiment authoring persistence."""
@@ -22,7 +28,7 @@ class ExperimentRepository:
     def __init__(self, session: Session) -> None:
         self._session = session
 
-    def persist_experiment(self, experiment: Experiment) -> PersistedExperiment:
+    def persist_experiment(self, experiment: "Experiment") -> PersistedExperiment:
         experiment.validate_authoring()
         row = ExperimentRow(
             name=experiment.name,
@@ -105,7 +111,7 @@ def record_candidate(
         *,
         handle: PersistedExperiment,
         environment_id: UUID,
-        sample: Sample,
+        sample: "Sample",
     ) -> ExperimentSamplePoolEntryRow:
         row = ExperimentSamplePoolEntryRow(
             experiment_id=handle.experiment_id,
@@ -133,7 +139,7 @@ def mark_pool_entries_selected(
         self._session.flush()
 
 
-def persist_experiment(*, session: Session, experiment: Experiment) -> PersistedExperiment:
+def persist_experiment(*, session: Session, experiment: "Experiment") -> PersistedExperiment:
     return ExperimentRepository(session).persist_experiment(experiment)
 
 
diff --git a/ergon_core/ergon_core/core/application/experiments/results.py b/ergon_core/ergon_core/core/application/experiments/results.py
new file mode 100644
index 000000000..1ba19c902
--- /dev/null
+++ b/ergon_core/ergon_core/core/application/experiments/results.py
@@ -0,0 +1,29 @@
+"""Experiment application result models shared with the public API."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from datetime import datetime
+from uuid import UUID
+
+from pydantic import BaseModel, Field, JsonValue
+
+
+class PersistedExperiment(BaseModel):
+    experiment_id: UUID
+    name: str
+    environment_ids: Mapping[str, UUID] = Field(default_factory=dict)
+    created_at: datetime | None = None
+    dashboard_url: str | None = None
+    metadata: dict[str, JsonValue] = Field(default_factory=dict)
+
+
+class ExperimentSubmitResult(BaseModel):
+    experiment_id: UUID
+    sampler_invocation_id: UUID | None = None
+    batch_id: UUID | None = None
+    requested_k: int
+    candidate_pool_size: int
+    selected_count: int
+    sample_ids: Sequence[UUID]
+    dashboard_url: str | None = None
diff --git a/ergon_core/ergon_core/core/application/experiments/submission.py b/ergon_core/ergon_core/core/application/experiments/submission.py
index 07780dfa9..32d877aec 100644
--- a/ergon_core/ergon_core/core/application/experiments/submission.py
+++ b/ergon_core/ergon_core/core/application/experiments/submission.py
@@ -1,13 +1,15 @@
 """Experiment submit orchestration for selected sample materialization."""
 
+from __future__ import annotations
+
 from collections.abc import Sequence
-from typing import Protocol
+from typing import TYPE_CHECKING, Protocol
 from uuid import UUID
 
 from pydantic import JsonValue
 from sqlmodel import Session
 
-from ergon_core.api.experiment.experiment import Experiment, ExperimentSubmitResult
+from ergon_core.core.application.experiments.results import ExperimentSubmitResult
 from ergon_core.api.experiment.sample import Sample
 from ergon_core.api.experiment.sampling import Sampler, SamplingContext
 from ergon_core.core.application.events.runtime import SampleStartedEvent
@@ -29,6 +31,9 @@
 from ergon_core.core.persistence.shared.enums import SampleStatus
 from ergon_core.core.persistence.telemetry.models import SampleRecord
 
+if TYPE_CHECKING:
+    from ergon_core.api.experiment.experiment import Experiment
+
 
 class EventBus(Protocol):
     async def publish(self, event: SampleStartedEvent) -> None: ...
@@ -61,7 +66,7 @@ def for_session(
     async def submit(
         self,
         *,
-        experiment: Experiment,
+        experiment: "Experiment",
         k: int,
         sampler: Sampler,
         candidate_pool_size: int | None,
@@ -188,7 +193,7 @@ def _assignment_json(sample: Sample) -> dict[str, JsonValue]:
 
 async def submit_experiment(
     *,
-    experiment: Experiment,
+    experiment: "Experiment",
     k: int,
     sampler: Sampler,
     candidate_pool_size: int | None = None,
diff --git a/ergon_core/ergon_core/core/application/samples/materialization.py b/ergon_core/ergon_core/core/application/samples/materialization.py
index b8839a718..c01e393d7 100644
--- a/ergon_core/ergon_core/core/application/samples/materialization.py
+++ b/ergon_core/ergon_core/core/application/samples/materialization.py
@@ -1,13 +1,12 @@
 """Materialize authored Samples into typed runtime WAL and graph projections."""
 
+from typing import TYPE_CHECKING
 from uuid import UUID, uuid4
 
 from sqlmodel import Session
 
 from pydantic import JsonValue
 
-from ergon_core.api._serialization import component_type_path
-from ergon_core.api.experiment.sample import Sample
 from ergon_core.core.application.runtime import status as graph_status
 from ergon_core.core.application.samples.events import (
     SampleRuntimeEventAppender,
@@ -24,11 +23,14 @@
 from ergon_core.core.persistence.shared.enums import SampleStatus
 from ergon_core.core.persistence.telemetry.models import SampleRecord
 
+if TYPE_CHECKING:
+    from ergon_core.api.experiment.sample import Sample
+
 
 def materialize_sample(
     session: Session,
     *,
-    sample: Sample,
+    sample: "Sample",
     sample_row: SampleRecord,
 ) -> None:
     wal = SampleRuntimeEventAppender(session)
@@ -50,7 +52,7 @@ def materialize_sample(
         worker_slug = task.worker.type_slug
         sandbox_type = _snapshot_type(
             sandbox_snapshot,
-            fallback=component_type_path(task.sandbox),
+            fallback=_component_type_path(task.sandbox),
         )
         sandbox_slug = _component_display_slug(sandbox_type)
 
@@ -169,6 +171,11 @@ def _component_display_slug(type_path: str) -> str:
     return type_path.rsplit(":", 1)[-1].rsplit(".", 1)[-1]
 
 
+def _component_type_path(component: object) -> str:
+    cls = component.__class__
+    return f"{cls.__module__}:{cls.__qualname__}"
+
+
 def _snapshot_type(snapshot: dict[str, JsonValue], *, fallback: str) -> str:
     value = snapshot.get("_type")
     return str(value) if value else fallback
diff --git a/ergon_core/tests/unit/api/test_public_api_imports.py b/ergon_core/tests/unit/api/test_public_api_imports.py
index 1ea95702e..8d0a279c5 100644
--- a/ergon_core/tests/unit/api/test_public_api_imports.py
+++ b/ergon_core/tests/unit/api/test_public_api_imports.py
@@ -39,7 +39,8 @@ class is replaced by the PR03 public sample authoring ``Experiment``.
     assert not hasattr(public_api, "ExperimentRunHandle")
     assert hasattr(public_api, "Experiment")
     assert hasattr(public_api, "Sample")
-    assert hasattr(public_api, "persist_experiment")
+    assert hasattr(public_api.Experiment, "persist")
+    assert not hasattr(public_api, "persist_experiment")
     assert not hasattr(public_api, "persist_benchmark")
 
 
diff --git a/ergon_core/tests/unit/api/test_sampler_contract.py b/ergon_core/tests/unit/api/test_sampler_contract.py
index a8b98ed47..e538523e1 100644
--- a/ergon_core/tests/unit/api/test_sampler_contract.py
+++ b/ergon_core/tests/unit/api/test_sampler_contract.py
@@ -8,9 +8,8 @@
 from ergon_core.api import (
     Environment,
     Experiment,
-    PersistedExperiment,
     ExperimentSubmitResult,
-    persist_experiment,
+    PersistedExperiment,
     RandomSampler,
     Sample,
     Sampler,
@@ -120,7 +119,7 @@ async def test_experiment_submit_validates_then_delegates_to_core(
 ) -> None:
     fake_submit = FakeSubmissionResult()
     monkeypatch.setattr(
-        "ergon_core.core.application.experiments.submission.submit_experiment",
+        "ergon_core.api.experiment.experiment.submit_experiment",
         fake_submit,
     )
     experiment = Experiment(name="x", environments=[MaterializedEnvironment(name="m")])
@@ -175,9 +174,9 @@ def test_experiment_can_remember_persisted_experiment_between_submissions() -> N
 
 
 @pytest.mark.asyncio
-async def test_persist_experiment_validates_before_delegating() -> None:
+async def test_experiment_persist_validates_before_delegating() -> None:
     with pytest.raises(ValueError, match="Experiment name is required"):
-        await persist_experiment(Experiment(name="", environments=[]))
+        await Experiment(name="", environments=[]).persist()
 
 
 def test_public_experiment_api_uses_experiment_id_names() -> None:
@@ -202,7 +201,8 @@ def test_public_experiment_api_uses_experiment_id_names() -> None:
     assert context.experiment_id == ref.experiment_id
 
 
-def test_public_persistence_facade_is_owned_by_api_package() -> None:
-    from ergon_core.api.experiment.persistence import persist_experiment as facade
+def test_public_persistence_facade_is_retired() -> None:
+    import ergon_core.api as public_api
 
-    assert facade is persist_experiment
+    assert not hasattr(public_api, "persist_experiment")
+    assert hasattr(Experiment, "persist")
diff --git a/ergon_core/tests/unit/architecture/test_public_api_target_structure.py b/ergon_core/tests/unit/architecture/test_public_api_target_structure.py
index 400fa7bc4..e327db8bf 100644
--- a/ergon_core/tests/unit/architecture/test_public_api_target_structure.py
+++ b/ergon_core/tests/unit/architecture/test_public_api_target_structure.py
@@ -37,7 +37,6 @@ def test_public_api_root_exports_semantic_authoring_names_only() -> None:
         "EvidenceMessage",
         # PR 5 — object-bound authoring surface.
         "Evaluator",
-        "persist_experiment",
         "RandomSampler",
         "Rubric",
         "Sample",
@@ -68,6 +67,7 @@ def test_public_api_root_exports_semantic_authoring_names_only() -> None:
         "ExperimentHandle",
         "ExperimentRunHandle",
         "persist_benchmark",
+        "persist_experiment",
         "SourceDescriptor",
         # Toolkit is a ReAct/builtins implementation detail, not a core
         # authoring API concept.
diff --git a/ergon_core/tests/unit/architecture/test_public_sample_authoring_api_boundaries.py b/ergon_core/tests/unit/architecture/test_public_sample_authoring_api_boundaries.py
index ed768a1a2..16a96c4e4 100644
--- a/ergon_core/tests/unit/architecture/test_public_sample_authoring_api_boundaries.py
+++ b/ergon_core/tests/unit/architecture/test_public_sample_authoring_api_boundaries.py
@@ -28,7 +28,7 @@ def test_public_api_exports_new_names_and_not_retired_names() -> None:
     assert "Sampler" in public_api.__all__
     assert "SamplingContext" in public_api.__all__
     assert "SamplingHistory" not in public_api.__all__
-    assert "persist_experiment" in public_api.__all__
+    assert "persist_experiment" not in public_api.__all__
     assert "SourceDescriptor" not in public_api.__all__
     assert "EnvironmentSource" not in public_api.__all__
     assert "Episode" not in public_api.__all__
diff --git a/ergon_core/tests/unit/core/application/experiments/test_experiment_persistence.py b/ergon_core/tests/unit/core/application/experiments/test_experiment_persistence.py
index db953d7e1..ca84cc5a5 100644
--- a/ergon_core/tests/unit/core/application/experiments/test_experiment_persistence.py
+++ b/ergon_core/tests/unit/core/application/experiments/test_experiment_persistence.py
@@ -10,7 +10,6 @@
     Environment,
     Experiment,
     Sample,
-    persist_experiment as persist_public_experiment,
 )
 from ergon_core.core.application.experiments.repository import (
     persist_experiment,
@@ -131,12 +130,11 @@ def test_record_sampler_invocation_writes_no_runtime_state(
 
 
 @pytest.mark.asyncio
-async def test_public_persistence_facade_wires_to_core(
+async def test_experiment_persist_method_wires_to_core(
     session: Session,
     two_env_experiment: Experiment,
 ) -> None:
-    ref = await persist_public_experiment(
-        two_env_experiment,
+    ref = await two_env_experiment.persist(
         session=session,
     )