diff --git a/plugins/nemo-eval-author/src/nemo_eval_author_plugin/eval_author/agent.py b/plugins/nemo-eval-author/src/nemo_eval_author_plugin/eval_author/agent.py
index a799618e6a..3d5e51a08d 100644
--- a/plugins/nemo-eval-author/src/nemo_eval_author_plugin/eval_author/agent.py
+++ b/plugins/nemo-eval-author/src/nemo_eval_author_plugin/eval_author/agent.py
@@ -459,6 +459,13 @@ async def _run(
                 total=len(trials),
                 unit="trace",
             )
+
+        async def load_trace(reference: ResourceRef) -> TraceExplorer:
+            """Resolve a trace ref with this run's client, matching the Experimentalist's
+            `ctx.load_trace`: the analyzer takes a loader rather than a platform client,
+            so its signature names no platform type."""
+            return await TraceExplorer.from_ref(reference, client, insight.workspace)
+
         raw_diagnostics: list[Diagnostic | BaseException] = list(
             await asyncio.gather(
                 *[
@@ -467,8 +474,7 @@ async def _run(
                         task=task,
                         agent_path=resolved_agent,
                         insight=insight,
-                        client=client,
-                        workspace=insight.workspace,
+                        load_trace=load_trace,
                     )
                     for analyzer, trial, task in zip(analyzers, trials, tasks, strict=True)
                 ],
diff --git a/plugins/nemo-eval-author/src/nemo_eval_author_plugin/eval_author/config.yaml b/plugins/nemo-eval-author/src/nemo_eval_author_plugin/eval_author/config.yaml
index 08cc95dcee..559b5e62c7 100644
--- a/plugins/nemo-eval-author/src/nemo_eval_author_plugin/eval_author/config.yaml
+++ b/plugins/nemo-eval-author/src/nemo_eval_author_plugin/eval_author/config.yaml
@@ -10,7 +10,7 @@
 workspace: default
 base_url: http://localhost:8080
 mode: local
-evaluator_type: harbor_native
+evaluator_type: harbor-native
 
 # Required per run.
 insight: ""
diff --git a/plugins/nemo-eval-author/src/nemo_eval_author_plugin/eval_author/run.py b/plugins/nemo-eval-author/src/nemo_eval_author_plugin/eval_author/run.py
index bd4340fbb7..08303119ad 100644
--- a/plugins/nemo-eval-author/src/nemo_eval_author_plugin/eval_author/run.py
+++ b/plugins/nemo-eval-author/src/nemo_eval_author_plugin/eval_author/run.py
@@ -51,7 +51,7 @@ async def run_eval_author(
     base_url: str | None,
     config: EvalAuthorConfig,
     agent: Path | str | None = None,
-    evaluator_type: EvaluatorType = "harbor_native",
+    evaluator_type: EvaluatorType = "harbor-native",
     model_refs: ConfiguredModelRefs | None = None,
 ) -> EvalAuthorResult:
     """Stage evaluation inputs, resolve one Insight, then run Eval Author.
diff --git a/plugins/nemo-eval-author/src/nemo_eval_author_plugin/traces.py b/plugins/nemo-eval-author/src/nemo_eval_author_plugin/traces.py
index 69fd1d98d2..0e314d7e5e 100644
--- a/plugins/nemo-eval-author/src/nemo_eval_author_plugin/traces.py
+++ b/plugins/nemo-eval-author/src/nemo_eval_author_plugin/traces.py
@@ -401,11 +401,17 @@ async def analyze_trace(
         trace=ResourceRef(uri=f"intake://{trace_id}", description="Production trace read from Intake."),
         metadata={"source": "intake"},
     )
+
+    async def load_trace(reference: ResourceRef) -> TraceExplorer:
+        """Resolve a trace ref with this call's client, matching the Experimentalist's
+        `ctx.load_trace`: the analyzer takes a loader rather than a platform client, so
+        its signature names no platform type."""
+        return await TraceExplorer.from_ref(reference, client, workspace)
+
     return await TraceAnalyzer(experiment_dir=experiment_dir).run(
         trial=trial,
         task=task,
         agent_path=agent_path,
         insight=None,
-        client=client,
-        workspace=workspace,
+        load_trace=load_trace,
     )
diff --git a/plugins/nemo-eval-author/tests/test_eval_author_agent.py b/plugins/nemo-eval-author/tests/test_eval_author_agent.py
index c4329c64c6..cb16b44b95 100644
--- a/plugins/nemo-eval-author/tests/test_eval_author_agent.py
+++ b/plugins/nemo-eval-author/tests/test_eval_author_agent.py
@@ -186,10 +186,9 @@ async def run(
             task: Task,
             agent_path: Path,
             insight: Insight,
-            client: Any,
-            workspace: str,
+            load_trace: Any,
         ) -> Diagnostic:
-            del task, agent_path, insight, client, workspace
+            del task, agent_path, insight, load_trace
             ref = cast(str, trial.metadata["trace_ref"])
             calls.analyzed_refs.append(ref)
             outcome = outcomes[self.index]
diff --git a/plugins/nemo-eval-author/tests/test_eval_author_repair_e2e.py b/plugins/nemo-eval-author/tests/test_eval_author_repair_e2e.py
index 0e79e446c7..332e76a79a 100644
--- a/plugins/nemo-eval-author/tests/test_eval_author_repair_e2e.py
+++ b/plugins/nemo-eval-author/tests/test_eval_author_repair_e2e.py
@@ -15,12 +15,10 @@
 from nemo_eval_author_plugin.eval_author.models import EvalAuthorConfig
 from nemo_experimentalist_plugin.client import make_client
 from nemo_experimentalist_plugin.entities import DatasetValidationError, local_path_from_uri
-from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor import (
-    HarborDataset,
-)
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native import (
-    HarborEvaluator,
+    HarborDataset,
     HarborEvaluatorConfig,
+    HarborNativeOutcomeEvaluator,
 )
 from nemo_experimentalist_plugin.experimentalist.components.trace_analyzer import Diagnostic
 from nemo_insights_plugin.entities import Insight
@@ -401,7 +399,7 @@ async def test_eval_author_metric_scores_known_failing_harbor_baseline_low(
 
     assert summary.summary
     await insight_suite.validate()
-    evaluator = HarborEvaluator(experiment_dir=tmp_path)
+    evaluator = HarborNativeOutcomeEvaluator(experiment_dir=tmp_path)
     result = await asyncio.wait_for(
         evaluator.run(
             agent=agent_dir,
@@ -530,7 +528,7 @@ async def test_eval_author_metric_discriminates_controlled_harbor_tool_evidence(
 
     assert summary.summary
     await insight_suite.validate()
-    evaluator = HarborEvaluator(experiment_dir=tmp_path)
+    evaluator = HarborNativeOutcomeEvaluator(experiment_dir=tmp_path)
 
     async def run_agent(agent_dir: Path, job_name: str):
         return await asyncio.wait_for(
diff --git a/plugins/nemo-eval-author/tests/test_eval_author_run.py b/plugins/nemo-eval-author/tests/test_eval_author_run.py
index 3ec5cfa33c..f0d86c96d5 100644
--- a/plugins/nemo-eval-author/tests/test_eval_author_run.py
+++ b/plugins/nemo-eval-author/tests/test_eval_author_run.py
@@ -158,7 +158,7 @@ def missing_model_refs() -> eval_author_run.ConfiguredModelRefs:
     make_client.assert_not_called()
 
 
-@pytest.mark.parametrize("evaluator_type", ["harbor_native", "harbor_evaluator"])
+@pytest.mark.parametrize("evaluator_type", ["harbor-native", "harbor-runner"])
 @pytest.mark.asyncio
 async def test_run_eval_author_resolves_inputs_and_returns_datasets(
     monkeypatch: pytest.MonkeyPatch,
@@ -315,7 +315,7 @@ async def resolve_model_clients(*_: object) -> ClosingModelClients:
     results: list[EvalAuthorResult] = []
     calls: list[tuple[Insight, Path, Task, Dataset, Dataset, ClosingClient]] = []
 
-    for evaluator_type in ("harbor_native", "harbor_evaluator"):
+    for evaluator_type in ("harbor-native", "harbor-runner"):
         results.append(
             await eval_author_run.run_eval_author(
                 insight="insight-remote-123",
@@ -354,7 +354,7 @@ async def resolve_model_clients(*_: object) -> ClosingModelClients:
     assert all(model_clients.closed for model_clients in model_client_sets)
 
 
-@pytest.mark.parametrize("evaluator_type", ["harbor_native", "harbor_evaluator"])
+@pytest.mark.parametrize("evaluator_type", ["harbor-native", "harbor-runner"])
 @pytest.mark.asyncio
 async def test_run_eval_author_hydrates_fileset_task_template(
     monkeypatch: pytest.MonkeyPatch,
diff --git a/plugins/nemo-experimentalist/AGENTS.md b/plugins/nemo-experimentalist/AGENTS.md
index 94d57f6d77..62522c968e 100644
--- a/plugins/nemo-experimentalist/AGENTS.md
+++ b/plugins/nemo-experimentalist/AGENTS.md
@@ -70,17 +70,17 @@ breaking rename with no compatibility aliases:
 Two names deliberately did **not** change. `optimizer.yaml` and the
 `.nemo-optimizer/` state directory are a shared contract with
 `nemo-insights-plugin`: `PROFILE_FILENAME` and `discover_profile()` live in
-`nemo_insights_plugin.contracts.profile`, and `nemo agents analyst run` can
-mirror the Platform rows it wrote into `<profile-dir>/.nemo-optimizer/insights.yaml`
-via `--insights-file-output`, which this plugin reads as the default insight when
-the file exists. Rename them only in lockstep with a Platform change to that
-contract. `EvolutionaryOptimizer` and `EvolutionaryOptimizerConfig` also keep
-their names — they describe the optimization algorithm, not the product.
-
-At the time of this rename the command group was top-level (`nemo
-experimentalist`), because the platform's `nemo.cli` entry-point group was flat
-and nesting under `nemo agents` needed a Platform-side change first. That change
-has since landed — see the `nemo agents` entry above for the current path.
+`nemo_insights_plugin.contracts.profile`, and `nemo agents analyst run` writes
+`<profile-dir>/.nemo-optimizer/insights.yaml`, which this plugin reads as the
+default insight. Rename them only in lockstep with a Platform change to that
+contract.
+
+`EvolutionaryOptimizer` is now `EvolutionaryStrategy`, in
+`experimentalist/strategies/evolutionary.py`, and is resolved by name like any other
+component (`strategy: evolutionary`).
+
+Run `nemo agents experimentalist components` to see everything this install can resolve,
+including components registered by a separately installed package.
 
 ### 2026-07-21: Curator renamed to Eval Author
 
diff --git a/plugins/nemo-experimentalist/benchmarks/configs/tau3-quality.yaml b/plugins/nemo-experimentalist/benchmarks/configs/tau3-quality.yaml
index 08d6d09aae..0461d875b5 100644
--- a/plugins/nemo-experimentalist/benchmarks/configs/tau3-quality.yaml
+++ b/plugins/nemo-experimentalist/benchmarks/configs/tau3-quality.yaml
@@ -14,9 +14,9 @@ optimizer:
   max_trajectory_tasks: 8
   max_train_batch_tasks: 16
   train_batch_seed: 20260727
-  disable_trajectory_scoring: false
-  disable_convergence_check: false
-  evaluator:
+  trajectory_scorer: goal-tree
+  terminator: convergence
+  outcome_evaluator_config:
     n_attempts: 2
     # Keep at 3 or lower: each task requests 8192 MB and parallel image builds
     # have triggered Docker Hub rate limiting and DNS failures.
diff --git a/plugins/nemo-experimentalist/benchmarks/configs/tau3-smoke.yaml b/plugins/nemo-experimentalist/benchmarks/configs/tau3-smoke.yaml
index 9d2359f909..ddb518059d 100644
--- a/plugins/nemo-experimentalist/benchmarks/configs/tau3-smoke.yaml
+++ b/plugins/nemo-experimentalist/benchmarks/configs/tau3-smoke.yaml
@@ -14,9 +14,9 @@ optimizer:
   max_trajectory_tasks: 2
   max_train_batch_tasks: 4
   train_batch_seed: 20260727
-  disable_trajectory_scoring: true
-  disable_convergence_check: true
-  evaluator:
+  trajectory_scorer: null
+  terminator: null
+  outcome_evaluator_config:
     n_attempts: 1
     n_concurrent_trials: 1
     quiet: true
diff --git a/plugins/nemo-experimentalist/benchmarks/configs/terminal-bench-quality.yaml b/plugins/nemo-experimentalist/benchmarks/configs/terminal-bench-quality.yaml
index 08e1270887..5f4e3d577c 100644
--- a/plugins/nemo-experimentalist/benchmarks/configs/terminal-bench-quality.yaml
+++ b/plugins/nemo-experimentalist/benchmarks/configs/terminal-bench-quality.yaml
@@ -13,8 +13,8 @@ optimizer:
   max_trajectory_tasks: 6
   max_train_batch_tasks: 12
   train_batch_seed: 20260722
-  disable_trajectory_scoring: true
-  evaluator:
+  trajectory_scorer: null
+  outcome_evaluator_config:
     n_attempts: 2
     n_concurrent_trials: 2
     quiet: true
diff --git a/plugins/nemo-experimentalist/benchmarks/configs/terminal-bench-smoke.yaml b/plugins/nemo-experimentalist/benchmarks/configs/terminal-bench-smoke.yaml
index 1dec23bd5c..942e051505 100644
--- a/plugins/nemo-experimentalist/benchmarks/configs/terminal-bench-smoke.yaml
+++ b/plugins/nemo-experimentalist/benchmarks/configs/terminal-bench-smoke.yaml
@@ -13,9 +13,9 @@ optimizer:
   max_trajectory_tasks: 2
   max_train_batch_tasks: 4
   train_batch_seed: 20260722
-  disable_trajectory_scoring: true
-  disable_convergence_check: true
-  evaluator:
+  trajectory_scorer: null
+  terminator: null
+  outcome_evaluator_config:
     n_attempts: 1
     n_concurrent_trials: 1
     quiet: true
diff --git a/plugins/nemo-experimentalist/benchmarks/run.py b/plugins/nemo-experimentalist/benchmarks/run.py
index 27362ea9a7..10653a45ff 100644
--- a/plugins/nemo-experimentalist/benchmarks/run.py
+++ b/plugins/nemo-experimentalist/benchmarks/run.py
@@ -14,6 +14,7 @@
 from typing import Any, Literal, Self
 
 import yaml
+from harbor.models.task.id import GitTaskId, LocalTaskId, PackageTaskId
 from harbor.registry.client.package import PackageDatasetClient
 from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
 from nemo_experimentalist_plugin.entities import (
@@ -24,9 +25,10 @@
 )
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor import HarborDataset
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native import (
-    HarborEvaluator,
     HarborEvaluatorConfig,
+    HarborNativeOutcomeEvaluator,
 )
+from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import load_winner
 from nemo_experimentalist_plugin.resolve import resolve_dataset
 from pydantic import BaseModel, Field, model_validator
 
@@ -151,6 +153,24 @@ def load_benchmark_config(path: Path) -> BenchmarkConfig:
     return BenchmarkConfig.model_validate(_load_yaml(path))
 
 
+def _canonical_task_id(task: GitTaskId | LocalTaskId | PackageTaskId) -> str:
+    """The suite-facing id of one Harbor task.
+
+    Harbor's task ids are a union, and only ``PackageTaskId`` carries a ``name``. The
+    others do have a ``get_name()``, but it means something different — ``hello-world``
+    for a git or local task versus ``org/hello-world`` for a package one — so there is no
+    accessor that yields the same string across the union. Benchmark suites are pinned to
+    a published package, so anything else is a suite that was authored wrong, and saying
+    so beats silently substituting a value.
+    """
+    if not isinstance(task, PackageTaskId):
+        raise RuntimeError(
+            f"Benchmark suites address tasks by package name, but this dataset yielded a "
+            f"{type(task).__name__}. Point the suite at a published package dataset."
+        )
+    return task.name
+
+
 def validate_canonical_suite(
     suite: SuiteSpec,
     *,
@@ -376,7 +396,7 @@ async def _evaluate_heldout(
         environment_build_timeout_multiplier=2.0,
     )
     started = time.monotonic()
-    result = await HarborEvaluator(experiment_dir=run_dir).run(
+    result = await HarborNativeOutcomeEvaluator(experiment_dir=run_dir).run(
         agent=agent_dir,
         dataset=dataset,
         options=options,
@@ -467,11 +487,9 @@ async def run_benchmark(args: argparse.Namespace) -> Path:
         framework_skills_dirs=framework_skills_dirs,
         model_refs=optimizer_model_refs,
     )
-    run_document = json.loads((experimentalist_dir / "eval-and-optimize" / "run.json").read_text(encoding="utf-8"))
-    winner_label = run_document.get("winner_agent")
-    if not isinstance(winner_label, str) or not winner_label:
-        raise RuntimeError("Experimentalist completed without a selected winner")
-    winner_dir = experimentalist_dir / "eval-and-optimize" / "agents" / winner_label
+    winner_candidate = load_winner(experimentalist_dir / "eval-and-optimize")
+    winner_label = winner_candidate.label
+    winner_dir = local_path_from_uri(winner_candidate.artifact.uri, context="Winner artifact")
     winner = await _evaluate_heldout(
         label="winner",
         agent_dir=winner_dir,
diff --git a/plugins/nemo-experimentalist/examples/acme-strategies/acme_strategies/random_search.py b/plugins/nemo-experimentalist/examples/acme-strategies/acme_strategies/random_search.py
new file mode 100644
index 0000000000..ec6462c78e
--- /dev/null
+++ b/plugins/nemo-experimentalist/examples/acme-strategies/acme_strategies/random_search.py
@@ -0,0 +1,106 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""A strategy written outside the Experimentalist repository.
+
+Everything it uses is public: the entities, the `Strategy` role, and the context
+Protocol. It never imports a private module, and it is selected with
+`strategy: random-search` in the run config.
+
+The search itself is deliberately trivial. What it demonstrates is that a package
+installed beside the plugin can fill the strategy role, reach the platform only through
+the context, and land results in Studio like any other run.
+"""
+
+import random
+from pathlib import Path
+
+from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.entities import Candidate, Proposal
+from nemo_experimentalist_plugin.experimentalist.roles import Strategy
+from nemo_experimentalist_plugin.experimentalist.seam import StrategyContext
+
+#: Reuses the code-change Proposal kind, so the built-in Coder can build what this emits.
+CODE_CHANGE = "code-change"
+
+_IDEAS = [
+    "add a retry around the tool call that fails most often",
+    "split the single prompt into a plan step and an execute step",
+    "cache the lookup the agent repeats within one task",
+]
+
+
+def _validation_score(candidate: Candidate) -> float:
+    """Mean of whatever the evaluator measured on the validation channel.
+
+    Reads `metrics`, not `summary`: `summary` is an optional scalar rollup that nothing
+    currently writes, so ranking on it scores every candidate zero.
+    """
+    metrics = candidate.rewards["validation"].metrics
+    return sum(metrics.values()) / len(metrics) if metrics else 0.0
+
+
+class RandomSearch(Strategy):
+    """Propose a random change each round and keep whatever scores best."""
+
+    name = "random-search"
+    supports_resume = True
+
+    def __init__(
+        self,
+        working_dir: Path,
+        config: EvolutionaryOptimizerConfig | None = None,
+        framework_skills_dirs: list[Path] | None = None,
+        **_: object,
+    ) -> None:
+        """The arguments the runner constructs a strategy with; the rest are ignored.
+
+        Spelled out rather than left untyped because this package is the worked example a
+        third party copies: the signature is the contract, so it should show it.
+        """
+        del working_dir, framework_skills_dirs
+        settings = config or EvolutionaryOptimizerConfig()
+        self._rounds = settings.max_rounds
+        self._per_round = settings.max_candidates
+        self._builder = settings.builder
+
+    async def run(self, ctx: StrategyContext) -> Candidate | None:
+        """Import the agent, then build and score random variants of it."""
+        population = await ctx.candidates()
+        if not population:
+            population = [await self._import_baseline(ctx)]
+
+        rng = random.Random(0)
+        # Resume where the store left off. `supports_resume` is true, so `ctx.candidates()`
+        # can return work from an earlier attempt; restarting at 1 would rebuild it and
+        # report progress that goes backwards.
+        done = max((c.generation for c in population), default=0)
+        if done >= self._rounds:
+            return self._best(population)
+        for generation in range(done + 1, self._rounds + 1):
+            parent = rng.choice(population)
+            for _ in range(self._per_round):
+                proposal = Proposal(
+                    ancestor=parent.id,
+                    description=rng.choice(_IDEAS),
+                    kind=CODE_CHANGE,
+                    payload={"root_cause": "chosen at random", "optimization_type": "add_method", "task_ids": []},
+                )
+                builder = ctx.component("builder", self._builder)
+                candidate = await builder.build(ctx, proposal, generation=generation)
+                result = await ctx.evaluate(candidate)
+                await ctx.record_reward(candidate, channel="validation", result=result)
+                population.append(candidate)
+            await ctx.report_progress(completed=generation, total=self._rounds, unit="round")
+
+        return self._best(population)
+
+    @staticmethod
+    def _best(population: list[Candidate]) -> Candidate | None:
+        """Highest validation score, or None when the run produced nothing."""
+        return max(population, key=_validation_score) if population else None
+
+    async def _import_baseline(self, ctx: StrategyContext) -> Candidate:
+        """Commit the agent under test unchanged, using the built-in import Builder."""
+        proposal = Proposal(ancestor=None, description="the agent under test", kind="import", payload={})
+        return await ctx.component("builder", "import").build(ctx, proposal, generation=0)
diff --git a/plugins/nemo-experimentalist/examples/acme-strategies/pyproject.toml b/plugins/nemo-experimentalist/examples/acme-strategies/pyproject.toml
new file mode 100644
index 0000000000..22b5f70a48
--- /dev/null
+++ b/plugins/nemo-experimentalist/examples/acme-strategies/pyproject.toml
@@ -0,0 +1,22 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# A component package written the way someone outside this repository would write one.
+# It depends on the plugin, not on the monorepo, and ships one entry point.
+[project]
+name = "acme-strategies"
+version = "0.1.0"
+description = "An out-of-tree Experimentalist strategy, used to prove the plugin mechanism."
+requires-python = ">=3.12,<3.14"
+dependencies = ["nemo-experimentalist-plugin"]
+
+# The entry point's only job is to import the module, so the class registers itself.
+[project.entry-points."nemo.experimentalist.components"]
+"strategy.random-search" = "acme_strategies.random_search"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["acme_strategies"]
diff --git a/plugins/nemo-experimentalist/examples/smoke-agent/configs/full.yaml b/plugins/nemo-experimentalist/examples/smoke-agent/configs/full.yaml
index 308ec32876..9c1f531a68 100644
--- a/plugins/nemo-experimentalist/examples/smoke-agent/configs/full.yaml
+++ b/plugins/nemo-experimentalist/examples/smoke-agent/configs/full.yaml
@@ -80,12 +80,13 @@ max_train_batch_tasks: null
 # scenario. Multiple rounds, survivors, ranking, and the convergence check are.
 # Turning it on is worthwhile once it is dependable -- build_all_group.py holds
 # g5 out of the combined set for the same reason.
-disable_trajectory_scoring: true
+trajectory_scorer: null
 
 # The one that matters here: the terminator deciding when to stop is the point.
-disable_convergence_check: false
+# The terminator deciding when to stop is the point of this scenario, so it keeps
+# its default ('convergence') rather than being turned off.
 
-evaluator:
+outcome_evaluator_config:
   n_attempts: 1
   n_concurrent_trials: 5
   quiet: true
diff --git a/plugins/nemo-experimentalist/examples/smoke-agent/configs/short.yaml b/plugins/nemo-experimentalist/examples/smoke-agent/configs/short.yaml
index c614a994c3..b55362393f 100644
--- a/plugins/nemo-experimentalist/examples/smoke-agent/configs/short.yaml
+++ b/plugins/nemo-experimentalist/examples/smoke-agent/configs/short.yaml
@@ -60,7 +60,7 @@ objective_function:
     direction: maximize
     target: 1.0
 
-disable_trajectory_scoring: true
+trajectory_scorer: null
 
 # Off, and it should stay off at this depth. The terminator only tests for
 # *stagnation* -- whether any new candidate reached the Pareto front, then an LLM
@@ -82,9 +82,9 @@ disable_trajectory_scoring: true
 #
 # `full.yaml` is where the terminator earns its place: five rounds, three
 # candidates, and stopping when the front genuinely stops moving.
-disable_convergence_check: true
+terminator: null
 
-evaluator:
+outcome_evaluator_config:
   n_attempts: 1
   n_concurrent_trials: 3
   quiet: true
diff --git a/plugins/nemo-experimentalist/examples/smoke-agent/scripts/record_traces.py b/plugins/nemo-experimentalist/examples/smoke-agent/scripts/record_traces.py
index 018e014d60..355d453fe7 100644
--- a/plugins/nemo-experimentalist/examples/smoke-agent/scripts/record_traces.py
+++ b/plugins/nemo-experimentalist/examples/smoke-agent/scripts/record_traces.py
@@ -20,10 +20,10 @@
 
 from nemo_experimentalist_plugin.client import make_client
 from nemo_experimentalist_plugin.entities import TrialResult, local_path_from_uri
-from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor import (
+from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native import (
     HarborDataset,
-    HarborEvaluator,
     HarborEvaluatorConfig,
+    HarborNativeOutcomeEvaluator,
 )
 from nemo_experimentalist_plugin.experimentalist.otlp import jsonl_to_protobuf, read_trace_id
 from nemo_platform import AsyncNeMoPlatform, NotFoundError
@@ -121,7 +121,7 @@ async def run(args: argparse.Namespace) -> dict[str, str]:
             n_concurrent_trials=args.concurrency,
             quiet=True,
         )
-        result = await HarborEvaluator(experiment_dir=run_dir).run(
+        result = await HarborNativeOutcomeEvaluator(experiment_dir=run_dir).run(
             agent=agent_path,
             dataset=dataset,
             options=options,
diff --git a/plugins/nemo-experimentalist/examples/tau3-nooa-agent/experimentalist-smoke.yaml b/plugins/nemo-experimentalist/examples/tau3-nooa-agent/experimentalist-smoke.yaml
index c4b00ce3fc..4b6c043500 100644
--- a/plugins/nemo-experimentalist/examples/tau3-nooa-agent/experimentalist-smoke.yaml
+++ b/plugins/nemo-experimentalist/examples/tau3-nooa-agent/experimentalist-smoke.yaml
@@ -7,11 +7,11 @@ max_survivors: 1
 max_candidates: 1
 max_trajectory_tasks: 2
 train_batch_seed: 20260727
-disable_trajectory_scoring: true
-disable_convergence_check: true
+trajectory_scorer: null
+terminator: null
 storage:
   archive_candidates: true
-evaluator:
+outcome_evaluator_config:
   n_attempts: 1
   quiet: true
   agent_setup_timeout_multiplier: 2.0
diff --git a/plugins/nemo-experimentalist/examples/tau3-nooa-agent/record_tau_airline_traces.py b/plugins/nemo-experimentalist/examples/tau3-nooa-agent/record_tau_airline_traces.py
index 9558a74b9e..e153b2f8fe 100644
--- a/plugins/nemo-experimentalist/examples/tau3-nooa-agent/record_tau_airline_traces.py
+++ b/plugins/nemo-experimentalist/examples/tau3-nooa-agent/record_tau_airline_traces.py
@@ -20,8 +20,8 @@
 from nemo_experimentalist_plugin.entities import TrialResult, local_path_from_uri
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor import HarborDataset
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native import (
-    HarborEvaluator,
     HarborEvaluatorConfig,
+    HarborNativeOutcomeEvaluator,
 )
 from nemo_experimentalist_plugin.experimentalist.otlp import jsonl_to_protobuf, read_trace_id
 from nemo_platform import AsyncNeMoPlatform, NotFoundError
@@ -214,7 +214,7 @@ async def run(args: argparse.Namespace) -> Path:
 
     if args.upload_dir is not None:
         job_dir, run_dir = _resolve_harbor_output_dir(args.upload_dir)
-        evaluator = HarborEvaluator(experiment_dir=run_dir)
+        evaluator = HarborNativeOutcomeEvaluator(experiment_dir=run_dir)
         trials = list(await evaluator._trials_from_dir(job_dir, dataset.tasks))
         uploadable_trials = [trial for trial in trials if trial.status == "completed" and trial.trace is not None]
         if not uploadable_trials:
@@ -279,7 +279,7 @@ async def run(args: argparse.Namespace) -> Path:
             agent_setup_timeout_multiplier=2.0,
             environment_build_timeout_multiplier=3.0,
         )
-        result = await HarborEvaluator(experiment_dir=run_dir).run(
+        result = await HarborNativeOutcomeEvaluator(experiment_dir=run_dir).run(
             agent=agent_path,
             dataset=dataset,
             options=options,
diff --git a/plugins/nemo-experimentalist/pyproject.toml b/plugins/nemo-experimentalist/pyproject.toml
index 6e8b622a6d..ba16ec7552 100644
--- a/plugins/nemo-experimentalist/pyproject.toml
+++ b/plugins/nemo-experimentalist/pyproject.toml
@@ -28,6 +28,24 @@ experimentalist = "nemo_experimentalist_plugin.cli:ExperimentalistCLI"
 [project.entry-points."nemo.skills"]
 experimentalist = "nemo_experimentalist_plugin.skills:skills_dir"
 
+# Our own components are discovered exactly the way a third party's are: one entry point
+# per module, whose only job is to import it so its classes self-register. There are no
+# privileged built-ins — if this mechanism breaks, our loop stops resolving too, which is
+# the point.
+#
+# One entry per module, not per component: importing the module registers every class in it.
+[project.entry-points."nemo.experimentalist.components"]
+"strategy.evolutionary" = "nemo_experimentalist_plugin.experimentalist.strategies.evolutionary"
+"builder.code-edit" = "nemo_experimentalist_plugin.experimentalist.components.coder"
+"builder.import" = "nemo_experimentalist_plugin.experimentalist.components.importer"
+"selector.pareto-diversity" = "nemo_experimentalist_plugin.experimentalist.components.selector"
+"proposer.code-change" = "nemo_experimentalist_plugin.experimentalist.components.proposer"
+"terminator.convergence" = "nemo_experimentalist_plugin.experimentalist.components.terminator"
+"root-cause-analyzer.trace" = "nemo_experimentalist_plugin.experimentalist.components.analyzer"
+"trajectory-scorer.goal-tree" = "nemo_experimentalist_plugin.experimentalist.components.trace_scorer"
+"outcome-evaluator.harbor-native" = "nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native"
+"outcome-evaluator.harbor-runner" = "nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_evaluator"
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
@@ -37,7 +55,7 @@ packages = ["src/nemo_experimentalist_plugin"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
-pythonpath = ["src"]
+pythonpath = ["src", "tests"]
 testpaths = ["tests"]
 markers = [
     "e2e: executes model-written shell and requires a sandbox, Docker, a running Platform, and configured models",
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/cli.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/cli.py
index ba4779cca6..509745d3ea 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/cli.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/cli.py
@@ -270,7 +270,7 @@ async def _flow() -> str:
                         task_template=plan.task_template,
                         agent_source=plan.agent,
                         storage=plan.config.storage.model_dump(exclude_unset=True),
-                        evaluator=plan.config.evaluator,
+                        evaluator=plan.config.outcome_evaluator_config,
                         require_template=plan.insight is not None,
                         probes=_PREFLIGHT_PROBES,
                     )
@@ -317,6 +317,29 @@ async def _flow() -> str:
                 raise typer.Exit(code=1) from None
             typer.echo(output_text)
 
+        @app.command("components")
+        def components(
+            role: str | None = typer.Option(None, "--role", help="Show only this role."),
+        ) -> None:
+            """List the components this install can resolve by name.
+
+            Includes anything a `pip install`ed package registered, which is how a
+            developer checks their own component was picked up.
+            """
+            from nemo_experimentalist_plugin.experimentalist.registry import Component, load_plugins
+
+            load_plugins()
+            rows = sorted(Component._registry.items())
+            if role is not None:
+                rows = [row for row in rows if row[0][0] == role]
+            if not rows:
+                typer.echo(f"No components registered{f' for role {role!r}' if role else ''}.")
+                raise typer.Exit(1)
+            width = max(len(registered_role) for (registered_role, _), _ in rows)
+            for (registered_role, registered_name), component in rows:
+                where = f"{component.__module__}.{component.__qualname__}"
+                typer.echo(f"{registered_role:<{width}}  {registered_name:<24}  {where}")
+
         @app.command("doctor")
         def doctor(
             insight: str | None = typer.Option(None, "--insight", help="Optional insight ref to verify."),
@@ -414,7 +437,7 @@ def doctor(
                         task_template=plan.task_template,
                         agent_source=plan.agent,
                         storage=plan.config.storage.model_dump(),
-                        evaluator=plan.config.evaluator,
+                        evaluator=plan.config.outcome_evaluator_config,
                         require_template=plan.insight is not None,
                         probes=_PREFLIGHT_PROBES,
                     )
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/config.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/config.py
index b6c4f93c40..886246955f 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/config.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/config.py
@@ -12,21 +12,19 @@
 The optimizer's own default/fast model pair is selected by ``nemo setup`` and
 stored in the active Platform CLI context.
 
-Component-owned slices (``CoderConfig``, ``AnalyzerConfig``, ...) are imported from the
-components that consume them rather than redeclared here -- ``resolve.py`` used to carry a
-second copy of each because importing a component module required credentials, which it no
-longer does.
+Component-owned slices (``CodeEditBuilderConfig``, ``AnalyzerConfig``, ...) are imported from the
+components that consume them rather than redeclared here.
 """
 
 from pathlib import Path
-from typing import Any, Literal, Self
+from typing import Any, Self
 
 from nemo_eval_author_plugin.eval_author.models import EvalAuthorConfig
-from nemo_experimentalist_plugin.experimentalist.components.analyzer import AnalyzerConfig
-from nemo_experimentalist_plugin.experimentalist.components.coder import CoderConfig
-from nemo_experimentalist_plugin.experimentalist.components.evaluator.base import EvaluatorTypeField
-from nemo_experimentalist_plugin.experimentalist.components.goal_tree import GoalTreeConfig
-from nemo_experimentalist_plugin.experimentalist.components.proposer import ProposerConfig
+from nemo_experimentalist_plugin.entities import MetricTarget
+from nemo_experimentalist_plugin.experimentalist.components.models import (  # noqa: F401 - re-exported
+    has_metric_dimensions,
+    pareto_objectives,
+)
 from pydantic import BaseModel, Field, model_validator
 
 
@@ -51,55 +49,6 @@ class CandidateStorageConfig(BaseModel):
     pr_labels: list[str] = Field(default_factory=list)
 
 
-class MetricTarget(BaseModel):
-    """One evaluator-produced metric and the desired direction of change."""
-
-    name: str = Field(min_length=1, description="Exact metric name emitted by the evaluator.")
-    direction: Literal["maximize", "minimize"] = Field(
-        description="Whether higher or lower values are better for this target."
-    )
-    target: float | None = Field(
-        default=None,
-        description=(
-            "Value at which this objective counts as satisfied, in the metric's own "
-            "units. When every targeted objective is met the run stops, so a solved "
-            "problem stops paying for rounds. Unset means no such stop: metrics are not "
-            "required to be normalized, so there is no value that means 'as good as "
-            "possible' for an arbitrary one."
-        ),
-    )
-
-    def is_satisfied_by(self, value: float | None) -> bool:
-        """Whether *value* meets this target. False when either side is absent.
-
-        A missing measurement is not evidence of success, and a target that was never
-        configured must not end a run.
-        """
-        if value is None or self.target is None:
-            return False
-        return value >= self.target if self.direction == "maximize" else value <= self.target
-
-
-def pareto_objectives(metrics: dict[str, float], objective_function: list[MetricTarget]) -> dict[str, float]:
-    """Project evaluator metrics onto the configured objectives for Pareto ranking.
-
-    The generic Pareto utility maximizes every dimension. Minimized objective
-    values are sign-inverted here; regression metrics are intentionally absent.
-    """
-    objectives: dict[str, float] = {}
-    for target in objective_function:
-        value = metrics.get(target.name)
-        if value is None:
-            return {}
-        objectives[target.name] = float(value) if target.direction == "maximize" else -float(value)
-    return objectives
-
-
-def has_metric_dimensions(metrics: dict[str, float], targets: list[MetricTarget]) -> bool:
-    """Return whether an evaluator result contains every required metric target."""
-    return all(target.name in metrics for target in targets)
-
-
 class EvolutionaryOptimizerConfig(BaseModel):
     """Parameters for one optimizer run, read from ``--config`` and nothing else.
 
@@ -107,6 +56,9 @@ class EvolutionaryOptimizerConfig(BaseModel):
     named explicitly on the command line, and are recorded in ``config_snapshot`` as the
     account of what ran. Letting an ambient environment variable override them would make
     that account wrong. Agent model settings live in the active Platform CLI context.
+
+    Unknown keys are tolerated, so a key that was *removed* has to be rejected explicitly
+    below — silently ignoring one would change what the run does.
     """
 
     @model_validator(mode="before")
@@ -116,12 +68,105 @@ def reject_legacy_curator_config(cls, data: Any) -> Any:
             return data
         if "curator" in data:
             raise ValueError("'curator' was renamed to 'eval_author'; update the optimizer configuration")
+
+        # A step is turned off by choosing no implementation of its role.
+        for removed, replacement in (
+            ("disable_convergence_check", "terminator"),
+            ("disable_trajectory_scoring", "trajectory_scorer"),
+        ):
+            if removed in data:
+                raise ValueError(
+                    f"{removed!r} is no longer a run-config key; write '{replacement}: null' instead. "
+                    "Turning a step off is how you choose no implementation of its role."
+                )
+
+        # The role key now names a component, so its tuning moved under '<role>_config'.
+        # A string is a component name and stays valid; only a config block is legacy.
+        for removed, replacement in (("analyzer", "analyzer_config"), ("proposer", "proposer_config")):
+            if isinstance(data.get(removed), dict):
+                raise ValueError(
+                    f"{removed!r} now names the component to run, so its settings moved to {replacement!r}."
+                )
+
+        # Renamed outright. These are not fields at all, so any value here is legacy and
+        # would otherwise be dropped in silence — changing what the run does.
+        for removed, role, config_key in (
+            ("evaluator", "outcome_evaluator", "outcome_evaluator_config"),
+            ("evaluation", "outcome_evaluator", "outcome_evaluator_config"),
+            ("evaluation_config", "outcome_evaluator", "outcome_evaluator_config"),
+            ("coder", "builder", "builder_config"),
+            ("goal_config", "trajectory_scorer", "trajectory_scorer_config"),
+        ):
+            if removed in data:
+                raise ValueError(
+                    f"{removed!r} is no longer a run-config key; the role is {role!r} and its settings "
+                    f"belong under {config_key!r}."
+                )
         if "models" in data:
             raise ValueError(
                 "'models' is no longer a run-config key. Run `nemo setup` to select the default and fast agent models."
             )
+
+        # `harbor` shipped as an evaluator_type before the evaluator was split into two
+        # implementations, so configs in the wild carry it.
+        if data.get("outcome_evaluator") == "harbor":
+            raise ValueError(
+                "outcome_evaluator: 'harbor' was split into 'harbor-native' (the default) and "
+                "'harbor-runner', which drives Harbor through the NeMo Evaluator SDK."
+            )
         return data
 
+    strategy: str = Field(
+        default="evolutionary",
+        description=(
+            "Registered 'strategy' component the runner runs. Ours is resolved by name "
+            "like any other, so a strategy shipped by another package is selected here "
+            "with no code change."
+        ),
+    )
+    # Every step the strategy delegates to is named here, so swapping one is configuration.
+    # A null means "no such step": turning a step off is the degenerate case of choosing a
+    # different implementation, which is why there are no disable_* booleans.
+    analyzer: str | None = Field(
+        default="trace",
+        description="Registered 'root-cause-analyzer'. Null skips diagnosis and the train eval feeding it.",
+    )
+    outcome_evaluator: str = Field(
+        default="harbor-native",
+        description=(
+            "Registered 'outcome-evaluator' measuring what a candidate achieved. Named for "
+            "the outcome because the trajectory-scorer measures the process of the same run."
+        ),
+    )
+    proposer: str = Field(default="code-change", description="Registered 'proposer' emitting each round's Proposals.")
+    terminator: str | None = Field(
+        default="convergence",
+        description="Registered 'terminator'. Null stops only on max_rounds.",
+    )
+    trajectory_scorer: str | None = Field(
+        default="goal-tree",
+        description="Registered 'trajectory-scorer'. Null skips step scoring and the goal tree it needs.",
+    )
+    selector: str = Field(
+        default="pareto-diversity",
+        description="Registered 'selector' component choosing survivors and the winner.",
+    )
+    selector_config: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Settings for the selector named above, validated against *that component's* `config_type` when it is built — so a component from another package is configurable without this schema knowing its fields.",
+    )
+    terminator_config: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Settings for the terminator named above, validated against *that component's* `config_type` when it is built — so a component from another package is configurable without this schema knowing its fields.",
+    )
+    builder: str = Field(
+        default="code-edit",
+        description=(
+            "Registered 'builder' component that turns a Proposal into a Candidate. "
+            "Swap it for one shipped by another package to change how candidates are "
+            "built without touching the loop."
+        ),
+    )
     max_rounds: int = Field(default=15, description="Hard ceiling on optimization rounds.")
     min_rounds_before_stopping: int = Field(
         default=3, description="Rounds that must complete before the convergence check may stop the run."
@@ -137,12 +182,7 @@ def reject_legacy_curator_config(cls, data: Any) -> Any:
     model_catalog_path: Path | None = Field(
         default=None, description="Model catalog overriding the packaged assets/models.yaml."
     )
-    disable_trajectory_scoring: bool = Field(
-        default=False, description="Skip goal-tree trajectory scoring and the goal tree it needs."
-    )
-    disable_convergence_check: bool = Field(
-        default=False, description="Stop only on max_rounds, never on the terminator's convergence judgement."
-    )
+
     objective_function: list[MetricTarget] = Field(
         default_factory=lambda: [MetricTarget(name="reward", direction="maximize")],
         min_length=1,
@@ -154,12 +194,26 @@ def reject_legacy_curator_config(cls, data: Any) -> Any:
     )
     source: AgentSourceConfig = Field(default_factory=AgentSourceConfig)
     storage: CandidateStorageConfig = Field(default_factory=CandidateStorageConfig)
-    goal_config: GoalTreeConfig = Field(default_factory=GoalTreeConfig)
-    coder: CoderConfig = Field(default_factory=CoderConfig)
-    analyzer: AnalyzerConfig = Field(default_factory=AnalyzerConfig)
-    proposer: ProposerConfig = Field(default_factory=ProposerConfig)
-    evaluator_type: EvaluatorTypeField = "harbor_native"
-    evaluator: dict[str, Any] = Field(default_factory=dict)
+    trajectory_scorer_config: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Settings for the trajectory-scorer named above, validated against *that component's* `config_type` when it is built — so a component from another package is configurable without this schema knowing its fields.",
+    )
+    builder_config: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Settings for the builder named above, validated against *that component's* `config_type` when it is built — so a component from another package is configurable without this schema knowing its fields.",
+    )
+    analyzer_config: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Settings for the root-cause-analyzer named above, validated against *that component's* `config_type` when it is built — so a component from another package is configurable without this schema knowing its fields.",
+    )
+    proposer_config: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Settings for the proposer named above, validated against *that component's* `config_type` when it is built — so a component from another package is configurable without this schema knowing its fields.",
+    )
+    outcome_evaluator_config: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Config for the selected 'evaluation' component; its own model validates it.",
+    )
     eval_author: EvalAuthorConfig = Field(default_factory=EvalAuthorConfig)
 
     @model_validator(mode="after")
@@ -190,3 +244,25 @@ def render(target: MetricTarget) -> str:
             f"Do not regress these metric(s): {regressions}. "
             "Metric values, including aggregates, are produced by the evaluator; do not invent formulas or weights."
         )
+
+
+def with_insight_objective(
+    config: "EvolutionaryOptimizerConfig", metric_keys: tuple[str, ...]
+) -> "EvolutionaryOptimizerConfig":
+    """Make insight metrics objectives and preserve all configured targets as guardrails."""
+    if not metric_keys:
+        return config
+    insight_metric_names = set(metric_keys)
+    objective = [MetricTarget(name=metric_key, direction="maximize") for metric_key in metric_keys]
+    regression_by_name = {
+        target.name: target
+        for target in [*config.objective_function, *config.regression_metrics]
+        if target.name not in insight_metric_names
+    }
+    return EvolutionaryOptimizerConfig.model_validate(
+        config.model_dump(mode="python")
+        | {
+            "objective_function": [target.model_dump(mode="python") for target in objective],
+            "regression_metrics": [target.model_dump(mode="python") for target in regression_by_name.values()],
+        }
+    )
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/entities.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/entities.py
index f3f5075878..634de2f57b 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/entities.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/entities.py
@@ -23,7 +23,7 @@
 from urllib.parse import unquote, urlparse
 
 from nemo_platform_plugin.entity import NemoEntity
-from pydantic import BaseModel, ConfigDict, Field, SerializeAsAny, model_validator
+from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, SerializeAsAny, model_validator
 
 DataValue: TypeAlias = str | int | float | bool | dict[str, Any] | list[Any] | None
 MetricValue: TypeAlias = float | int
@@ -386,15 +386,32 @@ class ExperimentRun(NemoEntity, entity_type="experiment_run"):
         default="running",
         description="Lifecycle status of this optimization run.",
     )
-    rounds_completed: int = Field(
+    progress_completed: int = Field(
         default=0,
-        description="Number of full optimization rounds completed so far.",
+        description="Units of work the strategy reports finished so far. Display only.",
+    )
+    progress_total: int | None = Field(
+        default=None,
+        description=(
+            "Units of work expected in total, when the strategy can say. None means it "
+            "cannot — an opaque strategy has no honest denominator, so consumers show a "
+            "counter rather than a bar."
+        ),
+    )
+    progress_unit: str = Field(
+        default="step",
+        description="What one unit of progress is: 'round' for the evolutionary loop, 'trial' for a search.",
+    )
+    progress_note: str | None = Field(
+        default=None,
+        description="What the strategy is currently doing, for strategies with no meaningful total.",
     )
     winner_agent: str | None = Field(
         default=None,
         description=(
-            "Entity id of the winning Candidate, or a local filesystem path "
-            "to the agent directory when running offline; set on completion."
+            "Label of the winning Candidate — 'agent-3', not its id. Every artifact "
+            "path in a run is built from the label, so this is the form a reader can "
+            "resolve; set on completion."
         ),
     )
     summary: str | None = Field(
@@ -413,7 +430,6 @@ def _restore_id_from_json(cls, data: Any, handler: Any) -> "ExperimentRun":
         Without this, resumed runs lose their identity and projection names collapse.
         """
         if isinstance(data, dict) and "id" in data:
-            # Pydantic wraps the dict during validation, extract the raw data
             instance = handler(data)
             instance._id = data["id"]  # type: ignore[attr-defined]
             return instance
@@ -437,70 +453,158 @@ class RewardRecord(BaseModel):
     metadata: dict[str, DataValue] = Field(default_factory=dict, description="Provenance for this measurement.")
 
 
+class RewardMap(dict[str, RewardRecord]):
+    """A candidate's measurements, keyed by reward channel.
+
+    One mapping answers both questions: ``rewards[channel]`` always yields a record, so
+    ``rewards["train"].metrics`` needs no presence check, while ``channel in rewards``
+    answers *was this measured at all* — which is what gates whether to evaluate.
+
+    ``__missing__`` **returns** without inserting, which is the whole point and why this
+    is not a ``defaultdict``: that one's ``__missing__`` inserts, so merely reading a
+    channel would mark it measured, skip its evaluation, and persist a phantom record.
+    """
+
+    def __missing__(self, channel: str) -> RewardRecord:
+        return RewardRecord()
+
+    def __setitem__(self, channel: str, record: RewardRecord) -> None:
+        """Refuse a direct write: it mutates memory and is never persisted.
+
+        A measurement reaches the store through ``ctx.record_reward``, which also
+        persists the evaluation's traces and updates the candidate. Assigning here
+        instead leaves a candidate that looks measured until the next reload.
+        """
+        raise TypeError(
+            f"cannot set rewards[{channel!r}] directly; record a measurement with "
+            "ctx.record_reward(candidate, channel=..., result=...) so it is persisted"
+        )
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source_type: Any, handler: Any) -> Any:
+        """Validate as a plain channel map, then re-wrap so ``__missing__`` survives.
+
+        Pydantic rejects a bare ``dict`` subclass, and validating into one would hand
+        back a plain ``dict`` that has lost the behaviour this class exists for.
+        """
+        from pydantic_core import core_schema
+
+        return core_schema.no_info_after_validator_function(cls, handler.generate_schema(dict[str, RewardRecord]))
+
+
+class Proposal(BaseModel):
+    """A request to build one candidate — the Proposer → Builder contract.
+
+    A transient component message, not a separately persisted entity and not an
+    unfinished Candidate: a proposal describes work to perform, and a Candidate is the
+    durable result after a Builder completes it. Failed proposals produce no Candidate
+    and are not retained; a successful one is embedded in ``Candidate.generated_from``.
+
+    ``kind`` is an opaque compatibility discriminator, not a global enumeration: it
+    routes the proposal to a Builder that declares it can accept it. ``payload`` is
+    owned by that Proposer/Builder pair — Layer A stores and transports it and
+    interprets neither.
+    """
+
+    ancestor: str | None = Field(
+        default=None,
+        description="Parent Candidate id to build from. None means the baseline.",
+    )
+    description: str = Field(
+        min_length=1,
+        description="Human-readable explanation of the proposed variant.",
+    )
+    kind: str = Field(
+        min_length=1,
+        description="Builder compatibility discriminator, e.g. 'code-change' or 'parameters'.",
+    )
+    payload: dict[str, DataValue] = Field(
+        default_factory=dict,
+        description="Build instructions, validated by the component-owned schema for this kind.",
+    )
+
+
 class Candidate(NemoEntity, entity_type="candidate"):
     """A candidate agent version produced during an Experimentalist run.
 
-    Lives in the entity store so candidates are queryable, resumable, and
-    survive the local working directory being deleted.  ``run_id`` groups all
-    candidates for a single ExperimentRun.
+    Metadata and measurements live in the entity store; the completed work is
+    *addressed*, not contained. ``artifact`` points at the resource that defines this
+    candidate and, when external evaluation is used, is directly consumable by the
+    run's evaluation component. Its format belongs to the components that produce and
+    consume that candidate kind — the host only stores, transports, archives and
+    publishes the reference.
 
-    Like every entity in this plugin, a Candidate's durable identity is its
-    store-assigned ``id`` (``name`` is left for the store to auto-slug).
-    ``label`` is the run-scoped handle ("agent-0", "agent-1", ...) used for the
-    working directory, evolution-tree key, and ``ancestor`` references; it is
-    unique within a run, not globally.
+    A Candidate is only ever created once its artifact exists and validates, so
+    ``artifact`` is required and no durable record points at partial work. Incomplete
+    work is a runner-owned path, not a Candidate.
 
-    A candidate's completed artifact is not stored here yet: it is still the
-    ``agents/<label>/`` directory the loop materialises. ``artifact: ResourceRef``
-    and runner-owned storage arrive with the candidate contract (plan §3.1, M1).
+    Identity is the store-assigned ``id``. ``label`` survives purely as a display
+    handle for reports and the evolution tree; it is unique within a run, not globally,
+    and nothing may derive storage or lineage from it.
     """
 
+    #: Set by :meth:`slim`. A slim copy has had its trials emptied for prompting, so
+    #: persisting one would write that loss back; ``update_candidate`` refuses it.
+    _slim: bool = PrivateAttr(default=False)
+
     workspace: str = Field(
         default="default",
         description="NeMo Platform workspace this candidate belongs to.",
     )
     run_id: str = Field(
         ...,
+        frozen=True,
         description="ExperimentRun entity id that this candidate belongs to.",
     )
     label: str = Field(
         ...,
+        frozen=True,
         description=(
-            "Run-scoped handle for this candidate (e.g. 'agent-0'): the working "
-            "directory name, evolution-tree key, and target of ``ancestor`` "
-            "references. Unique within a run, not globally — the store-assigned "
-            "``id`` is the durable identity."
+            "Display handle for this candidate (e.g. 'agent-0'), used in reports and the "
+            "evolution tree. Unique within a run, not globally, and not identity."
         ),
     )
     ancestor: str | None = Field(
+        frozen=True,
         default=None,
-        description="Parent Candidate ``label``. None means this is the baseline (round 0).",
-    )
-    round: int = Field(description="Optimization round that produced this candidate. 0 = baseline.")
-    optimization: str = Field(
         description=(
-            "Graph-level description of the architecture change that produced this candidate "
-            "(nodes added/removed/modified, edges changed, prompts rewritten). "
-            "No source file paths or line numbers."
+            "Parent Candidate id. None means this is the baseline, and is the only place that distinction is encoded."
         ),
     )
-    optimization_type: str | None = Field(
-        default=None,
-        description="OptimizationType literal that categorizes the change.",
+    generation: int = Field(
+        frozen=True,
+        default=0,
+        description=(
+            "Strategy-supplied grouping index. Our loop sets the round and HPO sets the "
+            "generation; a strategy with no such notion leaves it 0."
+        ),
     )
-    task_ids: list[str] = Field(
-        default_factory=list,
+    generated_from: Proposal = Field(
+        frozen=True,
         description=(
-            "Task ids the Proposer flagged as most exercising this candidate's root "
-            "cause; the coder uses them to validate the fix during subproblem refinement."
+            "Immutable snapshot of the Proposal this candidate was built from, so a Proposer "
+            "can read the history of what worked. Every candidate has one, including the "
+            "baseline, whose Proposal asks for the agent under test to be imported unchanged."
         ),
     )
-    rewards: dict[str, RewardRecord] = Field(
-        default_factory=dict,
+    description: str = Field(
+        frozen=True,
+        description="Human-readable explanation of this candidate; derived from the Proposal when there is one.",
+    )
+    artifact: ResourceRef = Field(
+        ...,
+        frozen=True,
+        description="The completed resource that defines this candidate, written by its Builder.",
+    )
+    rewards: RewardMap = Field(
+        default_factory=RewardMap,
         description=(
-            "Measurements keyed by reward channel. This is an open set that includes "
-            "'train', 'validation', and 'validation-trajectory'. A channel is a measurement, "
-            "not a dataset split, so adding one costs no entity change."
+            "Measurements keyed by reward channel. An open set: 'train', 'validation', "
+            "'insight' and 'validation-trajectory' today. A channel is a measurement, not a "
+            "dataset split — trajectory scoring is a second measurement of the validation "
+            "split — so adding one costs no entity change. Read with rewards[channel], "
+            "which always yields a record; ask 'channel in rewards' to learn whether it "
+            "was ever measured."
         ),
     )
     trajectory_detail: dict[str, Any] | None = Field(
@@ -508,76 +612,120 @@ class Candidate(NemoEntity, entity_type="candidate"):
         description=(
             "Per-node, per-task trajectory scores and explanations "
             "(node_id -> task_id -> {reward, explanation}). Shaped unlike RewardRecord.trials "
-            "and produced by one scorer; revisit when the trajectory-scorer seam lands."
+            "and produced by one scorer."
         ),
     )
-    killed_round: int | None = Field(
+    killed_generation: int | None = Field(
         default=None,
-        description="Round in which this candidate was eliminated. None means still alive.",
+        description="Generation in which this candidate was eliminated. None means still alive.",
     )
+    discarded: bool = Field(
+        default=False,
+        description=(
+            "True once this candidate has been rolled back. The record and its artifact "
+            "both survive so the rollback is auditable and reversible; listing excludes it "
+            "by default. Distinct from killed_generation, which marks a candidate that "
+            "lost selection but is still part of the run's history."
+        ),
+    )
+
+    @model_validator(mode="wrap")
+    @classmethod
+    def _restore_id_from_json(cls, data: Any, handler: Any) -> "Candidate":
+        """Restore the computed ``id`` when deserializing.
+
+        ``id`` is backed by private ``_id``; it serializes but ``model_validate`` ignores
+        computed fields, so a Candidate that has been through JSON comes back with an
+        empty id while its label survives intact. Selection crosses exactly that boundary
+        — survivors are the return value of an LLM method — and an empty id makes every
+        candidate look unselected, so the round marks all of them killed.
+        """
+        instance = handler(data)
+        if isinstance(data, dict) and data.get("id"):
+            instance._id = data["id"]  # type: ignore[attr-defined]
+        return instance
+
+    @model_validator(mode="after")
+    def _projections_agree_with_origin(self) -> "Candidate":
+        """Reject a record whose derived projections disagree with its origin.
+
+        ``ancestor`` and ``description`` are generic, queryable copies of what the
+        embedded Proposal already says. ``commit_candidate`` derives them, so a
+        disagreement means something set a copy independently and the two accounts of
+        this candidate's origin have drifted.
+        """
+        origin = self.generated_from
+        if self.ancestor != origin.ancestor:
+            raise ValueError(f"Candidate ancestor {self.ancestor!r} disagrees with its Proposal's {origin.ancestor!r}")
+        if self.description != origin.description:
+            raise ValueError("Candidate description disagrees with its Proposal's")
+        return self
+
+    @property
+    def is_baseline(self) -> bool:
+        """True for the agent under test as it arrived, before any change."""
+        return self.ancestor is None
 
     def __repr__(self) -> str:
-        parts = [f"Candidate(label={self.label!r}, round={self.round}"]
+        parts = [f"Candidate(label={self.label!r}, generation={self.generation}"]
         if self.ancestor is not None:
             parts.append(f", ancestor={self.ancestor!r}")
-        parts.append(f", optimization={self.optimization!r}")
-        if self.optimization_type is not None:
-            parts.append(f", optimization_type={self.optimization_type!r}")
+        parts.append(f", description={self.description!r}")
+        if self.generated_from is not None:
+            parts.append(f", kind={self.generated_from.kind!r}")
         for channel, record in self.rewards.items():
             if record.metrics:
                 scores = ", ".join(f"{k}={v:.3f}" for k, v in record.metrics.items())
                 parts.append(f", {channel}={{{scores}}}")
-        if self.killed_round is not None:
-            parts.append(f", killed_round={self.killed_round}")
+        if self.killed_generation is not None:
+            parts.append(f", killed_generation={self.killed_generation}")
         parts.append(")")
         return "".join(parts)
 
-    def reward(self, channel: str) -> RewardRecord:
-        """This candidate's measurement on *channel*, empty when unmeasured.
-
-        Returns a blank record rather than ``None`` so call sites read
-        ``candidate.reward("train").metrics`` without a presence check. Use
-        ``channel in candidate.rewards`` to ask whether it was measured at all —
-        an empty record and an unmeasured channel are different things.
-        """
-        return self.rewards.get(channel) or RewardRecord()
-
-    def record_reward(
-        self,
-        channel: str,
-        *,
-        metrics: dict[str, float] | None = None,
-        summary: float | None = None,
-        trials: Sequence[TrialResult] | None = None,
-        metadata: dict[str, DataValue] | None = None,
-    ) -> None:
-        """Merge a measurement into *channel*, leaving unspecified parts untouched.
-
-        Named ``record_`` rather than ``set_`` because it merges: an argument left as
-        ``None`` keeps whatever the channel already holds. Every caller today writes a
-        channel exactly once, so nothing currently depends on that — but the channel set
-        is open, and a second writer adding ``metadata`` to a channel another path
-        measured should not silently drop its ``metrics``. Replace semantics would make
-        that a data loss no test would catch.
-        """
-        current = self.rewards.get(channel) or RewardRecord()
-        update = {
-            key: value
-            for key, value in (
-                ("metrics", metrics),
-                ("summary", summary),
-                ("trials", trials),
-                ("metadata", metadata),
-            )
-            if value is not None
-        }
-        self.rewards = {**self.rewards, channel: current.model_copy(update=update)}
-
     def slim(self) -> "Candidate":
-        """Return a copy without per-trial detail (safe to pass to LLM methods)."""
-        return self.model_copy(
+        """Return a read-only copy without per-trial detail, for passing to LLM methods.
+
+        Read-only because it is lossy: persisting one writes the emptied trials back over
+        the real ones, for every channel at once. The marker that lets
+        ``update_candidate`` refuse it is a private attribute, so it is lost through JSON
+        — which is why a caller whose copies cross that boundary, as an LLM method's
+        return value does, looks the real candidates back up by id rather than relying
+        on the guard.
+        """
+        copy = self.model_copy(
             update={
-                "rewards": {c: r.model_copy(update={"trials": []}) for c, r in self.rewards.items()},
+                "rewards": RewardMap((c, r.model_copy(update={"trials": []})) for c, r in self.rewards.items()),
                 "trajectory_detail": None,
             }
         )
+        copy._slim = True
+        return copy
+
+
+class MetricTarget(BaseModel):
+    """One evaluator-produced metric and the desired direction of change."""
+
+    name: str = Field(min_length=1, description="Exact metric name emitted by the evaluator.")
+    direction: Literal["maximize", "minimize"] = Field(
+        description="Whether higher or lower values are better for this target."
+    )
+    target: float | None = Field(
+        default=None,
+        description=(
+            "Value at which this objective counts as satisfied, in the metric's own "
+            "units. When every targeted objective is met the run stops, so a solved "
+            "problem stops paying for rounds. Unset means no such stop: metrics are not "
+            "required to be normalized, so there is no value that means 'as good as "
+            "possible' for an arbitrary one."
+        ),
+    )
+
+    def is_satisfied_by(self, value: float | None) -> bool:
+        """Whether *value* meets this target. False when either side is absent.
+
+        A missing measurement is not evidence of success, and a target that was never
+        configured must not end a run.
+        """
+        if value is None or self.target is None:
+            return False
+        return value >= self.target if self.direction == "maximize" else value <= self.target
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/agent.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/agent.py
index f121e71a80..f2cd264a87 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/agent.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/agent.py
@@ -1,32 +1,43 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-"""Experimentalist agent factory."""
+"""Resolve the configured optimization strategy."""
 
 from pathlib import Path
 
-from nemo_experimentalist_plugin.experimentalist.components.loop import (
-    EvolutionaryOptimizer,
-    EvolutionaryOptimizerConfig,
-)
+from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.experimentalist.registry import get_component
+from nemo_experimentalist_plugin.experimentalist.roles import Strategy
 
 
 def build_experimentalist_agent(
     working_dir: Path,
     config: EvolutionaryOptimizerConfig | None = None,
     framework_skills_dirs: list[Path] | None = None,
-) -> EvolutionaryOptimizer:
-    """Build and return a configured :class:`EvolutionaryOptimizer`.
+) -> Strategy:
+    """Resolve ``config.strategy`` by name and construct it.
+
+    Nothing here names a strategy class. Ours is registered and looked up exactly the way
+    one from another package is, so pointing ``strategy:`` at a ``pip install``ed
+    implementation needs no change in this repository.
 
     Args:
-        working_dir: Local temp directory hydrated from the agent's fileset
-            before the run starts. The optimizer reads/writes all intermediate
-            artifacts here.
-        config: Optional optimizer config. When None the optimizer uses its
-            built-in defaults.
-        framework_skills_dirs: Optional list of directories containing framework
-            skills to load into all optimizer agents.
+        working_dir: Working directory for the run. The runner copies the agent under
+            test into it before the strategy starts, and the strategy reads and writes
+            its intermediate artifacts there.
+        config: Run configuration. When None the defaults select the evolutionary loop.
+        framework_skills_dirs: Directories of framework skills to load into the
+            strategy's agents.
+
+    Raises:
+        LookupError: if no strategy is registered under ``config.strategy`` — naming one
+            that is not installed fails here, before the run spends anything.
     """
-    return EvolutionaryOptimizer(
-        working_dir=working_dir, config=config, framework_skills_dirs=framework_skills_dirs or []
+    resolved = config or EvolutionaryOptimizerConfig()
+    return get_component(
+        "strategy",
+        resolved.strategy,
+        working_dir=working_dir,
+        config=resolved,
+        framework_skills_dirs=framework_skills_dirs or [],
     )
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/analyzer.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/analyzer.py
index 566069f758..35b82ff942 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/analyzer.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/analyzer.py
@@ -11,14 +11,23 @@
 from pathlib import Path
 from typing import Any, Literal, Sequence
 
-from nemo_experimentalist_plugin.entities import Dataset, EvaluationResult, Task, TrialResult
+from nemo_experimentalist_plugin.entities import (
+    Candidate,
+    Dataset,
+    EvaluationResult,
+    MetricTarget,
+    Task,
+    TrialResult,
+    local_path_from_uri,
+)
+from nemo_experimentalist_plugin.experimentalist import roles
 from nemo_experimentalist_plugin.experimentalist.components.trace_analyzer import (  # noqa: F401
     Diagnostic,
     TraceAnalyzer,
     TraceAnalyzerConfig,
 )
 from nemo_experimentalist_plugin.experimentalist.components.trace_explorer import TraceExplorer  # noqa: F401
-from nemo_platform import AsyncNeMoPlatform
+from nemo_experimentalist_plugin.experimentalist.seam import TraceLoader
 from nemo_platform_plugin.nooa_model_client import get_default_model, get_fast_model
 from nooa import Agent, CodeActStrategy, strategy
 from nooa.agentdoc import doc, spec
@@ -38,7 +47,7 @@
 
 
 class AnalyzerConfig(BaseModel):
-    """Configure tuning parameters for AgentAnalyzer."""
+    """Configure tuning parameters for TraceRootCauseAnalyzer."""
 
     max_summary_tokens: int = Field(
         default=80_000,
@@ -225,14 +234,21 @@ def __repr__(self) -> str:
         return "\n\n".join(sections)
 
 
-class AgentAnalyzer(Agent):
+class TraceRootCauseAnalyzer(Agent, roles.Analyzer):
     """Analyze an agent's trace and failure patterns for a single optimization round."""
 
+    config_type = AnalyzerConfig
+
+    name = "trace"
+
     def __init__(
         self,
         workspace: Path,
         config: AnalyzerConfig | None = None,
         framework_skills_dirs: list[Path] | None = None,
+        load_trace: TraceLoader | None = None,
+        objective_metrics: list[MetricTarget] | None = None,
+        regression_metrics: list[MetricTarget] | None = None,
         **kwargs: Any,
     ):
         """Initialize the analyzer for the given workspace.
@@ -241,12 +257,17 @@ def __init__(
             workspace: Absolute path to the eval-and-optimize workspace root.
             config: Tuning parameters; defaults to ``AnalyzerConfig()`` if ``None``.
             framework_skills_dirs: Optional list of directories containing framework skills to load.
+            load_trace: Resolves a trace reference to a TraceExplorer. Taken from the
+                context so this signature names no platform type.
             **kwargs: Forwarded to ``Agent.__init__``.
 
         """
         super().__init__(llm=kwargs.pop("llm", None) or get_default_model(), **kwargs)
         self._config = config or AnalyzerConfig()
         self._workspace_path = workspace
+        self._load_trace = load_trace
+        self._objective_metrics = objective_metrics or []
+        self._regression_metrics = regression_metrics or []
         self._framework_skills_dirs: list[Path] = framework_skills_dirs or []
         self.shell = GuardedShellTools(cwd=workspace)
         # Two generation methods run on the fast tier. Resolved here, like every other
@@ -632,68 +653,55 @@ async def _narrate_peer_comparison(
         """
         ...
 
-    def _agent_id_and_path(self, agent: Path | str) -> tuple[str, Path]:
-        """Return stable agent id and local path for analyzer calls."""
-        if isinstance(agent, Path):
-            return agent.name, agent
-        return agent, self._workspace_path / "eval-and-optimize" / "agents" / agent
-
     def _tasks_by_id(self, dataset: Dataset) -> dict[str, Task]:
         """Return dataset tasks keyed by id."""
         return {task.id: task for task in dataset.list_tasks()}
 
     async def run(
         self,
-        agent: Path | str,
+        *,
+        candidate: Candidate,
         dataset: Dataset,
         evaluation: EvaluationResult,
-        round: int | None = None,  # noqa: A002
         peer_evaluations: dict[str, EvaluationResult] | None = None,
-        client: AsyncNeMoPlatform | None = None,
-        nmp_workspace: str | None = None,
+        round_num: int | None = None,
         agent_spec: Path | None = None,
-        objective_metrics: list[dict[str, Any]] | None = None,
-        regression_metrics: list[dict[str, Any]] | None = None,
     ) -> AgentAnalysis:
         """Run the full analysis pipeline for one agent in one optimization round.
 
         Args:
-            agent: The agent path or stable agent id to analyze.
+            candidate: The candidate to analyze; its artifact is where the code lives.
             dataset: The dataset to analyze.
             evaluation: The evaluation result to analyze.
-            round: Current optimization round number, if available.
             peer_evaluations: Optional peer evaluation results keyed by agent id.
-            client: NeMo Platform client used to load ``intake://`` trial traces.
-                When ``None``, Intake traces cannot be loaded and are skipped.
-            nmp_workspace: NeMo Platform (Intake) workspace *name* — the request
-                context for ``intake://`` trace lookups. Distinct from the
-                constructor's ``workspace: Path`` (the filesystem eval dir).
-            objective_metrics: Active metrics to improve.
-            regression_metrics: Active metrics to preserve.
+            round_num: Current optimization round number, if available.
+            agent_spec: Markdown description of the agent under test, when the run has one.
 
         Returns:
             AgentAnalysis: per-trial diagnostics, failure classification, and peer
             comparison for the given agent.
 
         """
-        agent_id, agent_path = self._agent_id_and_path(agent)
-        round_key = f":round:{round}" if round is not None else ""
+        agent_id, agent_path = candidate.label, local_path_from_uri(candidate.artifact.uri)
+        round_key = f":round:{round_num}" if round_num is not None else ""
         # Fold intake availability into the key: when no client/workspace is
         # supplied, intake:// trial traces are skipped and the analysis is
         # trace-starved. Keying on availability prevents such a degraded result
         # from being replayed on a later run that *can* load those traces.
-        intake_key = ":intake:1" if client is not None and nmp_workspace is not None else ":intake:0"
-        objective_metrics = objective_metrics or []
-        regression_metrics = regression_metrics or []
+        intake_key = ":intake:1" if self._load_trace is not None else ":intake:0"
+        # The objectives are part of the question asked, so a change of objective must not
+        # replay an analysis produced under the old one.
         cache_key = cache.agent_hash(
             f"{agent_id}:evaluation:{evaluation.id}{round_key}{intake_key}:"
-            f"objective-metrics:{objective_metrics}:regression-metrics:{regression_metrics}"
+            f"objective-metrics:{self._objective_metrics}:regression-metrics:{self._regression_metrics}"
         )
         cached = cache.load(self._workspace_path, cache_key, AgentAnalysis)
         if cached is not None:
             return cached
 
-        selections = await self.select_trials(agent_id, dataset, evaluation, objective_metrics, regression_metrics)
+        objectives = [t.model_dump() for t in self._objective_metrics]
+        regressions = [t.model_dump() for t in self._regression_metrics]
+        selections = await self.select_trials(agent_id, dataset, evaluation, objectives, regressions)
         trials_by_id = {trial.id: trial for trial in evaluation.trials}
         selected_trials: list[tuple[TrialResult, str]] = []
         for selection in selections:
@@ -756,10 +764,9 @@ async def run(
                     agent_path=agent_path,
                     rationale=rationales.get(task.id),
                     selection_reason=selection_reason,
-                    objective_metrics=objective_metrics,
-                    regression_metrics=regression_metrics,
-                    client=client,
-                    workspace=nmp_workspace,
+                    objective_metrics=objectives,
+                    regression_metrics=regressions,
+                    load_trace=self._load_trace,
                 )
                 for trial, task, selection_reason in trial_tasks
             ],
@@ -803,16 +810,16 @@ async def run(
                 agent_id,
                 diagnoses,
                 [trial for trial, _ in selected_trials],
-                objective_metrics,
-                regression_metrics,
+                objectives,
+                regressions,
             ),
             self.compare_with_peers(
                 agent_id,
                 evaluation,
                 diagnoses,
                 peer_evaluations,
-                objective_metrics,
-                regression_metrics,
+                objectives,
+                regressions,
             ),
         )
 
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/cards.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/cards.py
index 60a5faebc9..ad56de2229 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/cards.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/cards.py
@@ -1130,7 +1130,7 @@ class OptimizeModelCapability(Skill):
     Candidate agents should use only model IDs listed in `assets/models.yaml`;
     do not invent provider/model IDs outside that catalog.
 
-    To inspect the catalog from the optimizer Coder, run:
+    To inspect the catalog from the optimizer CodeEditBuilder, run:
 
     ```python
     catalog = self.optimize.optimize_model_capability.read_model_catalog()
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/coder.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/coder.py
index cdcd3b3560..ab3a3620e0 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/coder.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/coder.py
@@ -5,14 +5,24 @@
 import json
 import random
 import re  # noqa: F401
+import shlex
 import shutil
 from collections import Counter, defaultdict  # noqa: F401
 from collections.abc import Sequence
 from pathlib import Path
 from typing import Any
 
-from nemo_experimentalist_plugin.entities import Candidate, Dataset, EvaluationResult, Task, TrialResult
-from nemo_experimentalist_plugin.experimentalist.components.evaluator import Evaluator, EvaluatorConfig
+from nemo_experimentalist_plugin.entities import (
+    Candidate,
+    Dataset,
+    EvaluationResult,
+    Proposal,
+    Task,
+    TrialResult,
+)
+from nemo_experimentalist_plugin.experimentalist import roles
+from nemo_experimentalist_plugin.experimentalist.components.evaluator import Evaluator
+from nemo_experimentalist_plugin.experimentalist.seam import BuilderContext
 from nemo_platform_plugin.nooa_model_client import get_default_model, get_fast_model
 from nooa import Agent, CodeActStrategy, strategy
 from nooa.agentdoc import doc, spec
@@ -25,12 +35,13 @@
 from pydantic import BaseModel, Field
 
 from .cards import Optimize
+from .proposer import CODE_CHANGE, CodeChange
 from .tools import GuardedShellTools
 from .util import load_framework_skills
 
 
-class CoderConfig(BaseModel):
-    """Store tuning parameters for Coder optimization."""
+class CodeEditBuilderConfig(BaseModel):
+    """Store tuning parameters for CodeEditBuilder optimization."""
 
     max_summary_tokens: int = Field(
         default=80_000,
@@ -567,22 +578,40 @@ async def run(self, dataset: Dataset) -> None:
     """
 
 
-class Coder(Agent):
+# Keeps its own Evaluator rather than using ctx.evaluate: its smoke checks run against an
+# artifact that is deliberately not yet a Candidate, and ctx.evaluate exists to associate a
+# result with one. An internal check has nothing to associate and must not be recorded
+# against the run.
+class CodeEditBuilder(Agent, roles.Builder):
     """Create and modify agent source code as part of the optimization loop."""
 
+    config_type = CodeEditBuilderConfig
+
+    name = "code-edit"
+    accepts = frozenset({CODE_CHANGE})
+
     def __init__(
         self,
         workspace: Path,
-        config: CoderConfig | None = None,
+        config: CodeEditBuilderConfig | None = None,
         framework_skills_dirs: list[Path] | None = None,
+        *,
+        evaluator: Evaluator | None = None,
+        dataset: Dataset | None = None,
+        source_path: str | None = None,
+        entrypoint: str | None = None,
         **kwargs: Any,
     ):
         """Initialize the coder for the given workspace."""
         super().__init__(llm=kwargs.pop("llm", None) or get_default_model(), **kwargs)
         # Architecture extraction requires the same quality-oriented model as
         # the rest of the coding work.
+        self._evaluator = evaluator
+        self._dataset = dataset
+        self._source_path = source_path
+        self._entrypoint = entrypoint
         self._architecture_model = get_default_model()
-        self._config = config or CoderConfig()
+        self._config = config or CodeEditBuilderConfig()
         self._workspace_path = workspace.resolve()
         self.shell = GuardedShellTools(cwd=self._workspace_path)
         self.todos = TodoManager()
@@ -593,8 +622,8 @@ def __init__(
         load_framework_skills(self.skills, framework_skills_dirs or [])
         self.skills.register("ext.architecture_skill", ArchitectureSkill())
         # Attach the optimization-card index so apply_change / wire_up_change
-        # can consult the card matching candidate.optimization_type. Without
-        # this, the Coder only sees the proposer's prose and the framework
+        # can consult the card matching change.optimization_type. Without
+        # this, the CodeEditBuilder only sees the proposer's prose and the framework
         # skill -- the optimize cards never reach it (gitlab #148).
         self.optimize = Optimize(model_catalog_path=self._config.model_catalog_path)
         self.skills.register("ext.optimize", self.optimize)
@@ -605,6 +634,10 @@ def __init__(
             config=TokenBudgetConfig(max_tokens=self._config.max_summary_tokens),
         )
 
+    async def describe(self, artifact: Path) -> None:
+        """Document the artifact's architecture, for the next round's proposal to read."""
+        await self.create_architecture_doc(artifact, source_path=self._source_path, entrypoint=self._entrypoint)
+
     async def list_available_models(self) -> list[str]:
         """Return the curated model IDs allowed for agent-under-test mutations.
 
@@ -615,70 +648,73 @@ async def list_available_models(self) -> list[str]:
         catalog = self.optimize.optimize_model_capability.read_model_catalog()
         return [model.model_id for model in catalog.models]
 
-    async def run(
-        self,
-        candidate: Candidate,
-        dataset: Dataset,
-        evaluator: Evaluator,
-        evaluator_options: EvaluatorConfig | None = None,
-        source_path: str | None = None,
-        entrypoint: str | None = None,
-    ) -> None:
-        """Implement the improvement described in candidate and verify it integrates cleanly.
+    async def build(self, ctx: BuilderContext, proposal: Proposal, *, generation: int) -> Candidate:
+        """Implement *proposal*, verify it integrates, and commit the Candidate for it.
 
         Args:
-            candidate: The agent variant to implement. Identifies the agent directory,
-                carries the optimization description, and links to its ancestor.
-            dataset: The dataset to use for the evaluation.
-            evaluator: The evaluator to use for the evaluation.
-            evaluator_options: The options to pass to the evaluator.
-            source_path: The path to the agent source code, relative to the agent directory.
-            entrypoint: The file that the evaluation harness invokes to run the agent, relative to the agent directory.
+            ctx: Reserve a working copy, commit the result — the only two verbs a Builder gets.
+            proposal: What to change, and what to change it from.
+            generation: Strategy-supplied grouping index, stamped onto the Candidate.
+
+        Returns:
+            Candidate: committed, with its artifact validated. A failed build returns
+            nothing at all, because it raises.
 
         Raises:
-            RuntimeError: if no training tasks are available for integration_check.
-            IntegrationCheckFailed: if the candidate cannot pass a smoke eval after the
+            RuntimeError: if the CodeEditBuilder was constructed without an evaluator or dataset,
+                or if no tasks are available for the integration check.
+            IntegrationCheckFailed: if the build cannot pass a smoke eval after the
                 bounded number of fix attempts.
 
         """
-        await self.apply_change(candidate)
-        await self.wire_up_change(candidate)
-        await self.run_pyright(candidate.name)
-        await self.optimize_subproblem(candidate, dataset, evaluator, evaluator_options)
-        await self.run_pyright(candidate.name)
-        if not await self.integration_check(candidate, dataset, evaluator, evaluator_options):
-            raise IntegrationCheckFailed(f"{candidate.name} smoke eval failed after fix attempts")
-        if candidate.ancestor:
-            ancestor_arch = (
-                self._workspace_path / "eval-and-optimize" / "agents" / candidate.ancestor / "architecture.md"
-            )
-            candidate_arch = self._workspace_path / "eval-and-optimize" / "agents" / candidate.name / "architecture.md"
-            if ancestor_arch.exists() and not candidate_arch.exists():
-                shutil.copy2(ancestor_arch, candidate_arch)
-        await self.create_architecture_doc(candidate.name, source_path=source_path, entrypoint=entrypoint)
+        if self._evaluator is None or self._dataset is None:
+            raise RuntimeError("CodeEditBuilder needs an evaluator and a dataset to verify a build; none were injected")
+        change = CodeChange.model_validate(proposal.payload)
+        fork = await ctx.fork(proposal)
+
+        await self.apply_change(fork.workdir, proposal.description, change)
+        await self.wire_up_change(fork.workdir, proposal.description, change)
+        await self.run_pyright(fork.workdir)
+        await self.optimize_subproblem(fork.workdir, proposal.description, change, self._dataset, self._evaluator)
+        await self.run_pyright(fork.workdir)
+        if not await self.integration_check(fork.workdir, self._dataset, self._evaluator, task_ids=change.task_ids):
+            raise IntegrationCheckFailed(f"{fork.workdir.name} smoke eval failed after fix attempts")
+
+        # Seeded only now, after the change is final: during editing the ancestor's
+        # architecture doc would describe an agent that no longer exists, and the fork
+        # deliberately leaves it out for that reason. Here it becomes the base to edit.
+        if fork.upstream is not None:
+            upstream_doc = fork.upstream / "architecture.md"
+            own_doc = fork.workdir / "architecture.md"
+            if upstream_doc.exists() and not own_doc.exists():
+                shutil.copy2(upstream_doc, own_doc)
+        await self.describe(fork.workdir)
+
+        return await ctx.commit_candidate(proposal=proposal, artifact=fork.workdir, generation=generation)
 
     @strategy(CodeActStrategy(config=CodeActConfig(max_iterations=50, cell_timeout=3600.0)))
-    async def apply_change(self, candidate: Candidate) -> None:
-        """Apply the ONE change from candidate.optimization.
+    async def apply_change(self, workdir: Path, optimization: str, change: CodeChange) -> None:
+        """Apply the ONE change described by `optimization`.
 
         Args:
-        - candidate (Candidate): the agent variant being built. Identifies
-          which agent directory to modify, describes the change to apply, and
-          carries lineage info from its ancestor
+        - workdir (Path): the agent directory to modify. Every file you touch is under here.
+        - optimization (str): graph-level description of the change to make.
+        - change (CodeChange): why this change was proposed — `change.root_cause` is the
+          diagnosed reason the agent underperforms, `change.optimization_type` says which
+          optimization card covers it, and `change.task_ids` are the tasks that exercise it.
 
         ## Pre-staged destination — DO NOT re-copy from the ancestor
-        The destination directory ``agents/{candidate.id}/`` has ALREADY been
-        populated by the framework with a copy of the ancestor's source files
-        (everything except generated framework artifacts: ``metadata.json`` and
-        ``architecture.md``). Runtime harness files are inherited when present
-        but are not part of the agent behavior being optimized.
+        {workdir} has ALREADY been populated with a copy of the ancestor's source files
+        (everything except ``architecture.md``, which describes the ancestor and is
+        re-seeded and rewritten after you are done). Runtime harness files are inherited
+        when present but are not part of the agent behavior being optimized.
         Open and modify files in place. You do NOT need to copy anything in.
 
         ## Required reading before editing
         - The framework skill — how to write agents in the target framework (NeMo OO, LangChain, etc.).
         - The optimization card for this change. First run `print(doc(self.optimize))`
           to see the decision tree mapping optimization types to cards. Find which
-          card covers `candidate.optimization_type` (e.g. `add_concrete_method` is
+          card covers `change.optimization_type` (e.g. `add_concrete_method` is
           covered by `optimize_execution`), then load that card's details with
           `print(doc(self.optimize.optimize_execution))`. The card lists approved approaches,
           code examples, and success criteria.
@@ -687,13 +723,11 @@ async def apply_change(self, candidate: Candidate) -> None:
           for chunking patterns that avoid `max_param_chars` truncation errors.
 
         ## Constraints
-        - Make one change matching candidate.optimization
+        - Make one change matching `optimization`, addressing `change.root_cause`.
         - No hardcoded knowledge (keyword lists, lookup tables, if/elif on task-specific strings). This applies to BOTH code AND skill edits: skill additions must improve generalizable methodology (process steps, classification rules, evidence requirements), never add dataset-specific facts about specific libraries, frameworks, CVEs, or package internals — that is memorization of training data, not domain knowledge.
-        - NEVER read from, copy from, or overwrite files in any OTHER agent
-          directory (``agents/agent-N/`` for N != candidate.id). The pre-staged
-          files in your own directory are the only source you should edit.
-        - NEVER modify ``metadata.json`` in any agent directory. It is owned by
-          the framework and carries the correct agent id, lineage, and scores.
+        - NEVER read from, copy from, or overwrite files in any OTHER agent directory.
+          {workdir} is yours; its sibling directories belong to other candidates and the
+          pre-staged files inside it are the only source you should edit.
         - VERIFY INTEGRATION: In the integration test, check traces to confirm new code is actually
           called by the agent. Code that exists but isn't invoked is useless.
         - If the change involves editing an LLM model id, call
@@ -703,16 +737,16 @@ async def apply_change(self, candidate: Candidate) -> None:
         ...
 
     @strategy(CodeActStrategy(config=CodeActConfig(max_iterations=50, cell_timeout=3600.0)))
-    async def wire_up_change(self, candidate: Candidate) -> None:
+    async def wire_up_change(self, workdir: Path, optimization: str, change: CodeChange) -> None:
         """Wire up the change to the agent such that it is called by the agent. Load the framework skill and use it to understand how to wire up the change.
 
         Args:
-        - candidate (Candidate): the agent variant being built. Identifies
-          which agent directory to modify, describes the change to apply, and
-          carries lineage info from its ancestor
+        - workdir (Path): the agent directory to modify.
+        - optimization (str): the change that was just applied.
+        - change (CodeChange): why it was proposed, and which optimization card covers it.
 
         Consult `doc(self.optimize)` to find which card covers
-        `candidate.optimization_type`, then read that card via
+        `change.optimization_type`, then read that card via
         `doc(self.optimize.optimize_<type>)` for what "wired" means in the target framework.
         (e.g. for `add_skill` covered by `optimize_domain_knowledge`, the new skill
         must be reachable by the agent at runtime — a file that is never imported or
@@ -723,37 +757,38 @@ async def wire_up_change(self, candidate: Candidate) -> None:
     @strategy(CodeActStrategy(config=CodeActConfig(max_iterations=200, cell_timeout=3600.0)))
     async def optimize_subproblem(
         self,
-        candidate: Candidate,
+        workdir: Path,
+        optimization: str,
+        change: CodeChange,
         dataset: Dataset,
         evaluator: Evaluator,
-        evaluator_options: EvaluatorConfig | None = None,
     ) -> None:
         """Validate and iteratively refine the subproblem fix until the agent's behavior improves.
 
         Args:
-        - candidate (Candidate): the agent variant being built. Identifies
-          which agent directory to modify, describes the change to apply, and
-          carries lineage info from its ancestor
+        - workdir (Path): the agent directory being refined.
+        - optimization (str): graph-level description of the change that was applied.
+        - change (CodeChange): `change.root_cause` is the diagnosed reason the agent
+          underperforms, and `change.task_ids` are the tasks that exercise it.
         - dataset (Dataset): The dataset to use for the evaluation.
         - evaluator (Evaluator): The evaluator to use for the evaluation.
-        - evaluator_options (EvaluatorConfig): The options to pass to the evaluator.
 
         ## Workflow
 
         1. **Pick test tasks**:
-           - **Target tasks**: use `candidate.task_ids` — the tasks the Proposer flagged as
-             most directly exercising this candidate's root cause. The fix must improve these.
-             Only if `candidate.task_ids` is empty, fall back to picking 2-3 representative
+           - **Target tasks**: use `change.task_ids` — the tasks the Proposer flagged as
+             most directly exercising `change.root_cause`. The fix must improve these.
+             Only if `change.task_ids` is empty, fall back to picking 2-3 representative
              tasks that exercise the subproblem yourself.
            - **Regression tasks**: also pick 2-3 tasks the ancestor/baseline already handled
              correctly and that are unrelated to this subproblem. The fix must NOT regress
              these — they guard against the change breaking previously-working behavior.
-           - Consider `candidate.optimization` to understand what was changed
+           - Consider `optimization` to understand what was changed
 
         2. **Isolate the subproblem**:
            - Read the agent's architecture.md to understand the agent's behavior
-           - Read the optimization card for `candidate.optimization_type` to understand what was changed
-           - Read `candidate.optimization` to understand the specific subproblem being fixed
+           - Read the optimization card for `change.optimization_type` to understand what was changed
+           - Read `optimization` and `change.root_cause` to understand the specific subproblem being fixed
            - Run the subproblem fix on the tasks and inspect the results.
              E.g. if the subproblem was the behavior of a single method, call that method on the tasks
              and inspect the results. If it was a single tool, run that tool directly.
@@ -804,24 +839,26 @@ async def create_unit_tests(self, issue: str, repo: str) -> str:
 
     async def integration_check(
         self,
-        candidate: Candidate,
+        workdir: Path,
         dataset: Dataset,
         evaluator: Evaluator,
-        evaluator_options: EvaluatorConfig | None = None,
         max_fix_attempts: int | None = None,
+        task_ids: Sequence[str] | None = None,
     ) -> bool:
-        """Smoke-test the candidate and attempt bounded LLM repairs if it fails.
+        """Smoke-test the build and attempt bounded LLM repairs if it fails.
 
         Args:
-            candidate: The agent variant to smoke-test.
+            workdir: The agent directory to smoke-test.
             dataset: The dataset to use for the evaluation.
             evaluator: The evaluator to use for the evaluation.
-            evaluator_options: The options to pass to the evaluator.
             max_fix_attempts: Maximum repair iterations; defaults to
                 ``self._config.max_fix_attempts``.
+            task_ids: The tasks the change claims to fix. Checking these is what makes a
+                failure informative — a random task the change does not touch passes on
+                the first attempt, and the repair loop below never runs.
 
         Returns:
-            bool: True if the candidate passes the smoke eval, False otherwise.
+            bool: True if the build passes the smoke eval, False otherwise.
 
         Raises:
             RuntimeError: if no training tasks are available.
@@ -832,14 +869,18 @@ async def integration_check(
         all_tasks = list(dataset.list_tasks())
         if not all_tasks:
             raise RuntimeError("No tasks available for integration_check")
-        # One task to keep smoke wall time low; seeded by candidate.name so retries hit the same task.
-        tasks = [random.Random(candidate.name).choice(all_tasks)]
+        # The tasks the Proposal named as evidence, so a build that does not repair what
+        # it claimed fails here and gets the repair attempts below. Falling back to one
+        # random task — seeded by the directory name so retries hit the same one — keeps
+        # the old "does it run at all" check for a Proposal that names none.
+        targeted = [task for task in all_tasks if task.id in set(task_ids or ())]
+        tasks = targeted or [random.Random(workdir.name).choice(all_tasks)]
         for attempt in range(_max_fix_attempts + 1):
-            evaluation = await self.run_smoke_eval(candidate.name, tasks, dataset, evaluator, evaluator_options)
+            evaluation = await self.run_smoke_eval(workdir, tasks, dataset, evaluator)
             if self._is_smoke_results_healthy(evaluation, tasks):
                 return True
             if attempt < _max_fix_attempts:
-                await self._fix_runtime_issues(candidate, evaluation)
+                await self._fix_runtime_issues(workdir, evaluation)
         return False
 
     def _is_smoke_results_healthy(self, evaluation: EvaluationResult, tasks: Sequence[Task]) -> bool:
@@ -872,13 +913,11 @@ def _trial_runtime_healthy(self, trial: TrialResult) -> bool:
         return trial.status == "completed"
 
     @strategy(CodeActStrategy(config=CodeActConfig(max_iterations=50, cell_timeout=3600.0)))
-    async def _fix_runtime_issues(self, candidate: Candidate, evaluation: EvaluationResult) -> None:
+    async def _fix_runtime_issues(self, workdir: Path, evaluation: EvaluationResult) -> None:
         """Diagnose and repair runtime failures surfaced by the most recent smoke eval.
 
         Args:
-        - candidate (Candidate): the agent variant being repaired. Identifies
-          which agent directory to modify, describes the change that was applied,
-          and carries lineage info from its ancestor
+        - workdir (Path): the agent directory being repaired. Every file you touch is under here.
         - evaluation (EvaluationResult): the smoke evaluation result. Use its
           trials, metrics, outputs, resources, errors, and metadata as failure evidence.
 
@@ -903,9 +942,8 @@ async def _fix_runtime_issues(self, candidate: Candidate, evaluation: Evaluation
 
         ## What to fix
 
-        Edit files in `eval-and-optimize/agents/{candidate.id}/` — the same files
-        `apply_change` and `wire_up_change` produced. Common runtime failure modes
-        and their fixes:
+        Edit files in {workdir} — the same files `apply_change` and `wire_up_change`
+        produced. Common runtime failure modes and their fixes:
 
         - **TypeError / wrong signature** — tool/function called with bad kwargs.
           Match the call to the definition.
@@ -922,7 +960,6 @@ async def _fix_runtime_issues(self, candidate: Candidate, evaluation: Evaluation
 
         ## Constraints
 
-        - Do NOT modify `metadata.json`.
         - Do NOT touch optimizer infrastructure: `init_structure.py`,
           `optimize_agent.py`, anything under `.claude/skills/`.
         - Do NOT call `run_smoke_eval` — the orchestrator re-runs it after you finish.
@@ -930,18 +967,18 @@ async def _fix_runtime_issues(self, candidate: Candidate, evaluation: Evaluation
         """
         ...
 
-    async def run_pyright(self, agent_id: str) -> str:
+    async def run_pyright(self, workdir: Path) -> str:
         """Run pyright on the agent's directory and return diagnostic lines.
 
         Args:
-            agent_id: The agent directory under eval-and-optimize/agents/ to check.
+            workdir: The agent directory to check.
 
         Returns:
             str: newline-separated error and warning lines, or an empty string
                 if pyright reports no issues.
 
         """
-        r = await self.shell.run(f"pyright --outputjson eval-and-optimize/agents/{agent_id} 2>/dev/null || true")
+        r = await self.shell.run(f"pyright --outputjson {shlex.quote(str(workdir))} 2>/dev/null || true")
         output = (r.stdout or "").strip()
         try:
             data = json.loads(output)
@@ -963,20 +1000,21 @@ async def run_pyright(self, agent_id: str) -> str:
 
     async def run_smoke_eval(
         self,
-        agent_id: str,
+        workdir: Path,
         tasks: Sequence[Task],
         dataset: Dataset,
         evaluator: Evaluator,
-        evaluator_options: EvaluatorConfig | None = None,
     ) -> EvaluationResult:
         """Run smoke evaluation against a specific subset of tasks.
 
+        Unrecorded by design: this measures work in progress, which is not yet a
+        Candidate, so there is nothing for the run to associate a result with.
+
         Args:
-            agent_id: The agent directory under eval-and-optimize/agents/ to evaluate.
+            workdir: The agent directory to evaluate.
             tasks: Non-empty task objects to evaluate.
             dataset: The dataset to use for the evaluation.
             evaluator: The evaluator to use for the evaluation.
-            evaluator_options: The options to pass to the evaluator.
 
         Returns:
             EvaluationResult: smoke evaluation result.
@@ -989,11 +1027,16 @@ async def run_smoke_eval(
             raise ValueError("run_smoke_eval requires at least one task")
 
         smoke_dataset = dataset.subset([task.id for task in tasks])
-        base_options = evaluator_options if evaluator_options is not None else evaluator.options
-        smoke_options = base_options.model_copy(update={"force_rerun": True})
-        agent_path = self._workspace_path / "eval-and-optimize" / "agents" / agent_id
+        base_options = evaluator.options
+        # A configured job_name would otherwise be shared: builds run concurrently, and
+        # `force_rerun` deletes the results directory that name points at, so one builder's
+        # smoke check would clear another's mid-read. The workdir and the task subset are
+        # what make this check distinct, so they name it.
+        smoke_options = base_options.model_copy(
+            update={"force_rerun": True, "job_name": f"smoke-{workdir.name}-{smoke_dataset.id}"}
+        )
         return await evaluator.run(
-            agent=agent_path,
+            agent=workdir,
             dataset=smoke_dataset,
             options=smoke_options,
         )
@@ -1003,12 +1046,12 @@ async def run_smoke_eval(
         llm=lambda self: self._architecture_model,
     )
     async def create_architecture_doc(
-        self, agent_id: str, source_path: str | None = None, entrypoint: str | None = None
+        self, workdir: Path, source_path: str | None = None, entrypoint: str | None = None
     ) -> None:
         """Update (or, only if absent, create) architecture.md for the given agent.
 
         Args:
-        - agent_id (str): identifies which agent directory under {self._workspace_path}/eval-and-optimize/agents/ to document
+        - workdir (Path): the agent directory to document. Its architecture.md is at {workdir}/architecture.md
         - source_path (str | None): directory containing the agent source code, relative to the
           agent directory (e.g. "app/"). Read .py files from here when following imports.
           When absent, infer the source root from AGENT-SPEC.md or the directory structure.
@@ -1021,7 +1064,7 @@ async def create_architecture_doc(
 
         ## Edit in place — do NOT regenerate from scratch
         For any candidate with an ancestor, the framework has ALREADY seeded
-        {self._workspace_path}/eval-and-optimize/agents/{agent_id}/architecture.md with a
+        {workdir}/architecture.md with a
         byte-for-byte copy of the ancestor's architecture.md. Open the existing file and edit it
         in place to reflect the FINAL state of the candidate source (after all automated repairs),
         not just its originally declared change. Compare the final source against the ancestor and
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/base.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/base.py
index 73a4c9a31a..ba7344f608 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/base.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/base.py
@@ -9,64 +9,21 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
 from pathlib import Path
-from typing import Annotated, Any, Literal, TypeAlias
+from typing import TypeAlias
 
 from nemo_experimentalist_plugin.entities import (
     Dataset,
     EvaluationResult,
     TrialResult,
 )
-from pydantic import BaseModel, BeforeValidator, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 logger = logging.getLogger(__name__)
 
-EvaluatorType: TypeAlias = Literal["harbor_native", "harbor_evaluator"]
-"""Selects which evaluator drives the run.
-
-``harbor_native`` is the default: the plugin builds and runs Harbor's ``Job``
-directly. ``harbor_evaluator`` routes orchestration through the NeMo Evaluator
-SDK's ``HarborAgentTaskRunner``, which owns the ``JobConfig``, the success-aware
-job-dir cache, and agent import scoping.
-"""
-_DEPRECATED_EVALUATOR_TYPES: dict[str, EvaluatorType] = {"harbor": "harbor_native"}
-"""Retired spellings still accepted on input, mapped to their current name.
-
-``harbor`` shipped before the rename, so experiment configs in the wild carry it.
-``harbor_agent_task_runner`` is deliberately absent: it never shipped, so nothing
-can be pinned to it.
-"""
-
-_warned_evaluator_types: set[str] = set()
-
-
-def normalize_evaluator_type(value: Any) -> Any:
-    """Map a retired evaluator-type spelling onto its current name, warning once.
-
-    Non-strings and unknown strings pass through untouched so pydantic still
-    produces its own error for a genuinely invalid value, rather than this
-    function masking it with a confusing one.
-
-    Args:
-        value(Any): Raw ``evaluator_type`` as supplied by config or a caller.
-
-    Returns:
-        Any: The canonical evaluator type, or ``value`` unchanged.
-    """
-    replacement = _DEPRECATED_EVALUATOR_TYPES.get(value) if isinstance(value, str) else None
-    if replacement is None:
-        return value
-    if value not in _warned_evaluator_types:
-        _warned_evaluator_types.add(value)
-        logger.warning(
-            "evaluator_type %r is deprecated and will be removed; use %r instead.",
-            value,
-            replacement,
-        )
-    return replacement
-
-
-EvaluatorTypeField: TypeAlias = Annotated[EvaluatorType, BeforeValidator(normalize_evaluator_type)]
-"""``EvaluatorType`` for config models, accepting the retired spellings on input."""
+#: Name of a registered `outcome-evaluator` component. A plain string rather than a
+#: Literal: the set is open, and a package can add to it without editing this module.
+#: `harbor-native` and `harbor-runner` are two entries in it, not the whole of it.
+EvaluatorType: TypeAlias = str
 
 
 class EvaluatorConfig(BaseModel):
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/factory.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/factory.py
index 25751c8ed1..84c5eaf470 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/factory.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/factory.py
@@ -4,7 +4,7 @@
 """Factories for evaluator-specific datasets and evaluators."""
 
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any, cast
 
 from nemo_experimentalist_plugin.entities import Dataset, DatasetRef, Task
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.base import (
@@ -12,44 +12,34 @@
     EvaluatorConfig,
     EvaluatorType,
 )
-from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor import HarborDataset
-from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_evaluator import (
-    HarborRunnerConfig,
-    HarborRunnerEvaluator,
-)
-from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native import (
-    HarborEvaluator,
-    HarborEvaluatorConfig,
-)
+from nemo_experimentalist_plugin.experimentalist.registry import resolve
+
+if TYPE_CHECKING:
+    from nemo_experimentalist_plugin.experimentalist.roles import OutcomeEvaluator
+
 
-# Both Harbor-backed types read the same Harbor dataset layout; only who drives
-# the run differs, so they share ``HarborDataset``.
-_SUPPORTED_EVALUATOR_TYPES: dict[EvaluatorType, tuple[type[Dataset], type[Evaluator], type[EvaluatorConfig]]] = {
-    "harbor_native": (HarborDataset, HarborEvaluator, HarborEvaluatorConfig),
-    "harbor_evaluator": (
-        HarborDataset,
-        HarborRunnerEvaluator,
-        HarborRunnerConfig,
-    ),
-}
+def _evaluation(name: EvaluatorType) -> "type[OutcomeEvaluator]":
+    """The registered `outcome-evaluator` component called *name*.
+
+    Resolved rather than looked up in a table: a table keyed on the names this package
+    knows is exactly what stops `outcome_evaluator:` being swappable from config. The
+    two Harbor-backed evaluators are entries in the registry like any other.
+    """
+    return cast("type[OutcomeEvaluator]", resolve("outcome-evaluator", name))
 
 
 class DatasetFactory:
     """Build evaluator-compatible Dataset objects from source references."""
 
-    def __init__(
-        self,
-        supported_evaluator_types: dict[EvaluatorType, tuple[type[Dataset], type[Evaluator], type[EvaluatorConfig]]]
-        | None = None,
-    ) -> None:
-        self.supported_evaluator_types = supported_evaluator_types or _SUPPORTED_EVALUATOR_TYPES
-
     def build_dataset(self, evaluator_type: EvaluatorType, dataset_ref: DatasetRef, **options: Any) -> Dataset:
         """Build a Dataset for the selected evaluator type.
 
         Args:
             evaluator_type(EvaluatorType): The type of evaluator to build the dataset for.
             dataset_ref(DatasetRef): The reference to the dataset to build.
+            **options: Forwarded to the dataset type's ``from_ref``. ``allow_empty=True``
+                is what lets an Insight-driven run start with splits the Eval Author has
+                not filled yet.
 
         Returns:
             Dataset: The built dataset.
@@ -59,10 +49,7 @@ def build_dataset(self, evaluator_type: EvaluatorType, dataset_ref: DatasetRef,
         """
         if not evaluator_type or not dataset_ref:
             raise ValueError("Evaluator type and dataset reference are required")
-
-        if evaluator_type not in self.supported_evaluator_types:
-            raise ValueError(f"Unsupported evaluator type: {evaluator_type}")
-        return self.supported_evaluator_types[evaluator_type][0].from_ref(dataset_ref, **options)
+        return _evaluation(evaluator_type).dataset_type.from_ref(dataset_ref, **options)
 
     def build_task_template(self, evaluator_type: EvaluatorType, template_ref: DatasetRef) -> Task:
         """Parse an evaluator-specific template directory as one task.
@@ -105,17 +92,12 @@ def build_evaluator(
             ValueError: If the evaluator type is not supported.
             TypeError: If the evaluator config is not an EvaluatorConfig or dict.
         """
-        if evaluator_type in _SUPPORTED_EVALUATOR_TYPES:
-            if isinstance(config, EvaluatorConfig):
-                config = config.model_dump()
-            elif not isinstance(config, dict):
-                # Quoted rather than .capitalize()d: these names are snake_case, so
-                # capitalizing produced "Harbor_native" — and it silently changes
-                # shape every time a type is renamed.
-                raise TypeError(f"{evaluator_type!r} evaluator config must be an EvaluatorConfig or dict")
-            evaluator_config = _SUPPORTED_EVALUATOR_TYPES[evaluator_type][2].model_validate(config)
-            return _SUPPORTED_EVALUATOR_TYPES[evaluator_type][1](
-                options=evaluator_config, experiment_dir=experiment_dir
-            )
-
-        raise ValueError(f"Unsupported evaluator type: {evaluator_type}")
+        component = _evaluation(evaluator_type)
+        if isinstance(config, EvaluatorConfig):
+            config = config.model_dump()
+        elif not isinstance(config, dict):
+            # Quoted rather than .capitalize()d: these names are hyphenated, so
+            # capitalizing produced "Harbor-native" — and it silently changes shape
+            # every time a component is renamed.
+            raise TypeError(f"{evaluator_type!r} evaluator config must be an EvaluatorConfig or dict")
+        return component(options=component.config_type.model_validate(config), experiment_dir=experiment_dir)
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/harbor_evaluator.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/harbor_evaluator.py
index dde0ec6059..cc2e5f3a94 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/harbor_evaluator.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/harbor_evaluator.py
@@ -38,8 +38,8 @@
 )
 from nemo_evaluator_sdk.agent_eval.tasks import AgentEvalTask
 from nemo_experimentalist_plugin.entities import Dataset, TrialResult, local_path_from_uri
+from nemo_experimentalist_plugin.experimentalist import roles
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.base import (
-    Evaluator,
     EvaluatorConfig,
     EvaluatorType,
 )
@@ -122,10 +122,14 @@ class HarborRunnerConfig(EvaluatorConfig):
     )
 
 
-class HarborRunnerEvaluator(Evaluator):
+class HarborRunnerOutcomeEvaluator(roles.OutcomeEvaluator):
     """Run Harbor through the SDK's ``HarborAgentTaskRunner`` and parse the job dir."""
 
-    evaluator_type: EvaluatorType = "harbor_evaluator"
+    name = "harbor-runner"
+    dataset_type = HarborDataset
+    config_type = HarborRunnerConfig
+
+    evaluator_type: EvaluatorType = "harbor-runner"
 
     def __init__(
         self,
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/harbor_native.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/harbor_native.py
index 0c1bac90c2..d60e373fd3 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/harbor_native.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/evaluator/harbor_native.py
@@ -17,8 +17,8 @@
 from harbor.job import DatasetConfig, Job, JobConfig
 from harbor.models.job.config import AgentConfig, ArtifactConfig, RetryConfig
 from nemo_experimentalist_plugin.entities import Dataset, Task, TrialResult
+from nemo_experimentalist_plugin.experimentalist import roles
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.base import (
-    Evaluator,
     EvaluatorConfig,
     EvaluatorType,
 )
@@ -28,6 +28,7 @@
 )
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor import (
     DEFAULT_TRACE_ARTIFACT_SOURCE,
+    HarborDataset,
     resolve_harbor_run_inputs,
     trials_from_job_dir,
 )
@@ -157,10 +158,14 @@ class HarborEvaluatorConfig(EvaluatorConfig):
     )
 
 
-class HarborEvaluator(Evaluator):
+class HarborNativeOutcomeEvaluator(roles.OutcomeEvaluator):
     """Run Harbor evaluations directly and return parsed reward payloads."""
 
-    evaluator_type: EvaluatorType = "harbor_native"
+    name = "harbor-native"
+    dataset_type = HarborDataset
+    config_type = HarborEvaluatorConfig
+
+    evaluator_type: EvaluatorType = "harbor-native"
 
     def __init__(self, options: HarborEvaluatorConfig | None = None, experiment_dir: Path | None = None) -> None:
         super().__init__(options or HarborEvaluatorConfig(), experiment_dir=experiment_dir)
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/goal_tree.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/goal_tree.py
index 8f3f48ad84..476b47b351 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/goal_tree.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/goal_tree.py
@@ -275,7 +275,6 @@ def find_node(root: GoalNode, node_id: str) -> GoalNode | None:
     return None
 
 
-# Standard Pydantic v2 pattern for recursive models
 GoalNode.model_rebuild()
 
 
@@ -289,7 +288,11 @@ class GoalTreeGenerator(Agent):
     """
 
     def __init__(
-        self, workspace: Path, config: GoalTreeConfig, framework_skills_dirs: list[Path] | None = None, **kwargs: Any
+        self,
+        workspace: Path,
+        config: GoalTreeConfig,
+        framework_skills_dirs: list[Path] | None = None,
+        **kwargs: Any,
     ):
         """Initialize the goal tree generator.
 
@@ -431,7 +434,7 @@ async def _generate(self, dataset: Dataset, agent_spec: Path | None = None) -> G
         # IDs
 
         Use kebab-case identifiers stable across the run (e.g. "parse-input",
-        "reason-about-cues", "emit-schema"). They appear in metadata.json and selection logs,
+        "reason-about-cues", "emit-schema"). They appear in trajectory rewards and selection logs,
         so prefer descriptive over short.
 
         # Output
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/importer.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/importer.py
new file mode 100644
index 0000000000..73ca787c97
--- /dev/null
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/importer.py
@@ -0,0 +1,35 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""The Builder that takes an agent as it arrived and commits it unchanged."""
+
+from nemo_experimentalist_plugin.entities import Candidate, Proposal
+from nemo_experimentalist_plugin.experimentalist import roles
+from nemo_experimentalist_plugin.experimentalist.seam import BuilderContext
+
+#: Proposal kind meaning "commit this source as a candidate, changing nothing".
+IMPORT = "import"
+
+
+def import_proposal(description: str = "the agent under test, unchanged") -> Proposal:
+    """A Proposal asking for the agent under test to be committed as-is.
+
+    ``ancestor`` is None, which is the only thing that makes the result the baseline.
+    """
+    return Proposal(ancestor=None, description=description, kind=IMPORT, payload={})
+
+
+class ImportBuilder(roles.Builder):
+    """Commit a candidate that is the agent under test, unchanged.
+
+    An ordinary build of an ordinary Proposal, so ``commit_candidate`` stays the only way
+    a Candidate is born and a strategy wanting several roots gets that for free.
+    """
+
+    name = "import"
+    accepts = frozenset({IMPORT})
+
+    async def build(self, ctx: BuilderContext, proposal: Proposal, *, generation: int = 0) -> Candidate:
+        """Fork the agent under test and commit it with nothing changed."""
+        fork = await ctx.fork(proposal)
+        return await ctx.commit_candidate(proposal=proposal, artifact=fork.workdir, generation=generation)
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/loop.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/loop.py
deleted file mode 100644
index 38d0073091..0000000000
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/loop.py
+++ /dev/null
@@ -1,1945 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-"""Evolutionary optimization loop — ported from AAD ``optimizer/optimize_agent.py``.
-
-The public entry point is :class:`EvolutionaryOptimizer`.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import fnmatch
-import json
-import logging
-import random
-import shutil
-from collections import defaultdict
-from pathlib import Path
-from typing import Any, Literal, cast, get_args
-
-from nemo_eval_author_plugin.eval_author.agent import EvalAuthor
-from nemo_experimentalist_plugin.config import (
-    EvolutionaryOptimizerConfig,
-    MetricTarget,
-    has_metric_dimensions,
-    pareto_objectives,
-)
-from nemo_experimentalist_plugin.entities import (
-    Candidate,
-    Dataset,
-    EvaluationResult,
-    ExperimentRun,
-    TrialResult,
-)
-from nemo_experimentalist_plugin.experimentalist.components.analyzer import AgentAnalyzer
-from nemo_experimentalist_plugin.experimentalist.components.coder import Coder, CoderConfig
-from nemo_experimentalist_plugin.experimentalist.components.dataset_staging import (
-    distribute_insight_suite_tasks,
-    stage_eval_author_inputs,
-)
-from nemo_experimentalist_plugin.experimentalist.components.evaluator import Evaluator
-from nemo_experimentalist_plugin.experimentalist.components.evaluator.factory import DatasetFactory, EvaluatorFactory
-from nemo_experimentalist_plugin.experimentalist.components.goal_tree import (
-    GoalTree,
-    GoalTreeConfig,
-    GoalTreeGenerator,
-    leaf_weights_by_id,
-    traverse_tree,
-)
-from nemo_experimentalist_plugin.experimentalist.components.holdout_utils import (
-    ensure_heldout_hidden,
-    restore_heldout_splits,
-)
-from nemo_experimentalist_plugin.experimentalist.components.models import (
-    EvolutionNode,
-    EvolutionTree,
-    OptimizationType,
-    pareto_front,
-    pareto_sort,
-)
-from nemo_experimentalist_plugin.experimentalist.components.proposer import Improvement, Proposer
-from nemo_experimentalist_plugin.experimentalist.components.selector import SurvivorSelector
-from nemo_experimentalist_plugin.experimentalist.components.terminator import Terminator
-from nemo_experimentalist_plugin.experimentalist.components.tools import (
-    GuardedShellTools,
-    WorkspaceTool,
-)
-from nemo_experimentalist_plugin.experimentalist.components.trace_scorer import (
-    GroupLeafScorer,
-)
-from nemo_experimentalist_plugin.experimentalist.deps import ExperimentalistDeps
-from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import (
-    ExperimentalistBackend,
-)
-from nemo_experimentalist_plugin.experimentalist.result import ExperimentalistResult
-from nemo_platform import AsyncNeMoPlatform
-from nemo_platform_plugin.nooa_model_client import get_default_model, get_fast_model
-from nooa import Agent, CodeActStrategy, strategy
-from nooa.agentdoc import doc, spec
-from nooa.agents import TokenBudgetSummarizer
-from nooa.config import CodeActConfig
-from nooa.config.summarizer_config import TokenBudgetConfig
-from nooa.skill import Skill
-from nooa.skill_registry import SkillRegistry
-from nooa.tools import Match
-
-from .util import load_framework_skills
-
-logger = logging.getLogger(__name__)
-
-_BASELINE_AGENT_LABEL = "agent-0"
-
-_EXCLUDE_DIRS = {
-    "eval-and-optimize",
-    "__pycache__",
-    ".git",
-    ".runtime-cache",
-    ".claude",
-    ".uv",
-    ".venv",
-    "artifacts",
-    "dataset",
-    "scratch",
-}
-_EXCLUDE_GLOBS = {"*traces*", "*eval-and-optimize_*"}
-
-
-def _warn_persistence_failure(operation: Literal["archive", "publish"], candidate: str, exc: Exception) -> None:
-    """Log best-effort persistence failure context."""
-    logger.warning(
-        "[PERSISTENCE] %s failed for candidate %s; continuing: %s",
-        operation,
-        candidate,
-        exc,
-    )
-
-
-def _ignore_patterns(directory: str, contents: list[str]) -> set[str]:
-    ignored = set()
-    for name in contents:
-        if name in _EXCLUDE_DIRS:
-            ignored.add(name)
-        elif any(fnmatch.fnmatch(name, pattern) for pattern in _EXCLUDE_GLOBS):
-            ignored.add(name)
-    return ignored
-
-
-def _coerce_optimization_type(optimization_type: str | None) -> OptimizationType | None:
-    if optimization_type in get_args(OptimizationType):
-        return cast(OptimizationType, optimization_type)
-    return None
-
-
-def _creation_order(node: EvolutionNode) -> tuple[int, str]:
-    """Order candidates by creation, independently of how the caller ordered them.
-
-    Labels are run-scoped and assigned in sequence (``agent-0``, ``agent-1``, ...), so
-    the numeric suffix recovers creation order. The label itself is the final component
-    so the key stays total if a label ever stops matching that shape.
-    """
-    _, _, suffix = node.label.rpartition("-")
-    return (int(suffix) if suffix.isdigit() else 0, node.label)
-
-
-def _regresses(
-    node: EvolutionNode,
-    baseline: EvolutionNode,
-    regression_metrics: list[MetricTarget],
-) -> bool:
-    """Whether *node* is worse than *baseline* on any metric that must not regress.
-
-    A target missing from either side is skipped: absent evidence is not a regression.
-    """
-    if node is baseline:
-        return False
-    for target in regression_metrics:
-        before = baseline.val_reward.get(target.name)
-        after = node.val_reward.get(target.name)
-        if before is None or after is None:
-            continue
-        if after < before if target.direction == "maximize" else after > before:
-            return True
-    return False
-
-
-def finalization_pool(
-    evolution_tree: EvolutionTree,
-    objective_function: list[MetricTarget],
-) -> tuple[list[EvolutionNode], EvolutionNode | None]:
-    """Return the nodes that may win, and the round-0 baseline they are measured against.
-
-    Survivor selection runs mid-loop and can kill the baseline: it is told to always
-    keep a candidate created this round, and the baseline never is one. Finalization
-    asks a different question -- "is any of this better than shipping nothing?" -- so
-    the baseline is re-admitted here regardless of ``is_survivor``. Without that, a run
-    whose baseline was killed mid-loop can only choose among diffs, and the regression
-    comparison silently rehomes onto the oldest surviving candidate.
-
-    The baseline is returned separately so it is used as the regression reference even
-    if it is not itself the winner. It is None when the run has no round-0 result, or
-    when that result lacks the configured objective dimensions.
-    """
-    scored = [node for node in evolution_tree.nodes.values() if node.is_survivor and node.val_reward]
-    baseline = next(
-        (node for node in evolution_tree.nodes.values() if node.round == 0 and node.val_reward),
-        None,
-    )
-    if baseline is not None and all(node is not baseline for node in scored):
-        scored.insert(0, baseline)
-    eligible = [node for node in scored if has_metric_dimensions(node.val_reward, objective_function)]
-    if baseline is not None and all(node is not baseline for node in eligible):
-        baseline = None
-    return eligible, baseline
-
-
-def select_winner_node(
-    eligible: list[EvolutionNode],
-    objective_function: list[MetricTarget],
-    regression_metrics: list[MetricTarget] | None = None,
-    baseline: EvolutionNode | None = None,
-) -> EvolutionNode | None:
-    """Return the run's winner, or None when there is nothing eligible.
-
-    Candidates that worsen a ``regression_metrics`` target against *baseline* are
-    dropped before ranking, so a gain on the objectives cannot pay for a regression.
-    The winner is then taken from the Pareto front over ``objective_function``, with
-    ties going to the lowest round and then to creation order.
-
-    *baseline* is the reference for regression and is never dropped by it, so a run
-    whose candidates all regress -- or all merely tie -- keeps the baseline rather than
-    shipping a diff that bought nothing. It defaults to the oldest eligible node, which
-    is only correct when the true baseline is still present; callers that can tell
-    should pass it explicitly (see ``finalization_pool``).
-    """
-    if not eligible:
-        return None
-    reference = baseline if baseline is not None else min(eligible, key=lambda n: (n.round, _creation_order(n)))
-    kept = [node for node in eligible if not _regresses(node, reference, regression_metrics or [])]
-    front = pareto_front(kept or eligible, lambda node: pareto_objectives(node.val_reward, objective_function))
-    return min(front, key=lambda node: (node.round, _creation_order(node))) if front else None
-
-
-def _with_insight_objective(
-    config: EvolutionaryOptimizerConfig, metric_keys: tuple[str, ...]
-) -> EvolutionaryOptimizerConfig:
-    """Make insight metrics objectives and preserve all configured targets as guardrails."""
-    if not metric_keys:
-        return config
-    insight_metric_names = set(metric_keys)
-    objective = [MetricTarget(name=metric_key, direction="maximize") for metric_key in metric_keys]
-    regression_by_name = {
-        target.name: target
-        for target in [*config.objective_function, *config.regression_metrics]
-        if target.name not in insight_metric_names
-    }
-    return EvolutionaryOptimizerConfig.model_validate(
-        config.model_dump(mode="python")
-        | {
-            "objective_function": [target.model_dump(mode="python") for target in objective],
-            "regression_metrics": [target.model_dump(mode="python") for target in regression_by_name.values()],
-        }
-    )
-
-
-def _trajectory_detail_from_reward(value: Any) -> dict[str, Any]:
-    if isinstance(value, dict):
-        reward_val = value.get("reward", value.get("score", 0.0))
-        explanation = value.get("reason") or value.get("explanation") or ""
-    else:
-        reward_val = getattr(value, "reward", getattr(value, "score", value))
-        explanation = getattr(value, "reason", "") or getattr(value, "explanation", "")
-    detail: dict[str, Any] = {"reward": float(reward_val)}
-    if explanation:
-        detail["explanation"] = str(explanation)
-    return detail
-
-
-def _complete_trace_groups(
-    traces_by_task: dict[str, dict[str, TrialResult]], agent_ids: list[str]
-) -> dict[str, dict[str, TrialResult]]:
-    required_agents = set(agent_ids)
-    return {
-        task_id: by_agent
-        for task_id, by_agent in traces_by_task.items()
-        if set(by_agent) == required_agents and all(by_agent[aid] for aid in required_agents)
-    }
-
-
-class AnalysisSkill(Skill):
-    """Standard format for the per-round analysis file the optimizer writes each round.
-
-    The round analysis merges every agent's per-agent analysis into one markdown file
-    (``eval-and-optimize/analysis/round-N.md``). It is the record a human or the next
-    round reads to understand what happened: which agents lead on which reward
-    dimensions, where they diverge, and which failures are systematic vs mechanical.
-    Follow this format exactly and fill every section with real data from the per-agent
-    analyses and metadata — no placeholders.
-
-    ---
-
-    ```markdown
-    # Round N Analysis
-
-    ## Rewards
-
-    **Show every dimension as its own column** so agents with different strengths are visible
-    and easier to reason about for merging. An agent may have lower values on some dimensions
-    but higher on others — that's a candidate to merge with a complementary agent.
-
-    Train Reward:
-    | Agent | <dim1> | <dim2> | <dim3> | ... | Ancestor | vs. Ancestor |
-    | ----- | ------ | ------ | ------ | --- | -------- | ------------ |
-    | agent-3 | 0.61 | 0.72 | 0.51 | ... | agent-0 | +0.16 |
-    | agent-1 | 0.58 | 0.68 | 0.48 | ... | agent-0 | +0.13 |
-    | agent-0 | 0.45 | 0.55 | 0.40 | ... | --- | baseline |
-
-    Validation Reward:
-    | Agent | <dim1> | <dim2> | <dim3> | ... | Ancestor | vs. Ancestor |
-    | ----- | ------ | ------ | ------ | --- | -------- | ------------ |
-    | agent-3 | 0.51 | 0.62 | 0.44 | ... | agent-0 | -0.10 |
-    | agent-1 | 0.48 | 0.58 | 0.41 | ... | agent-0 | -0.10 |
-    | agent-0 | 0.45 | 0.55 | 0.40 | ... | --- | baseline |
-
-    ## Trajectory Rewards
-
-    Trajectory rewards measure intermediate step quality (goal-tree subgoal rollup).
-    Read from metadata:
-
-    ```python
-    candidate = self.workspace.get_metadata(agent_id)
-    traj = candidate.reward("validation-trajectory").metrics or {}
-    # e.g. {"aggregate": 0.74, "parse-cli-input": 0.31, "search-web-sources": 0.78}
-    details = candidate.trajectory_detail or {}
-    # details[node_id][task_id] = {"reward": 0.7, "explanation": "..."}
-    ```
-
-    | Agent | <step1> | <step2> | ... | aggregate |
-    | ----- | ------- | ------- | --- | --------- |
-    | agent-3 | 0.45 | 0.85 | ... | 0.78 |
-    | agent-1 | 0.32 | 0.90 | ... | 0.75 |
-    | agent-0 | 0.31 | 0.78 | ... | 0.74 |
-
-    [Omit if the `validation-trajectory` channel is absent or empty. Show the `aggregate` key as
-    the overall column and each node_id entry as its node column.
-    When a trajectory reward explains a selection tradeoff or outcome-reward disagreement,
-    quote/paraphrase the relevant `trajectory_detail` explanation.]
-
-    ## Divergent Trial Analysis
-
-    For each agent pair with divergent results:
-
-    ### agent-A vs agent-B
-
-    | Task | agent-A | agent-B | Winner's Key Insight |
-    |------|---------|---------|----------------------|
-    | task-003 | ✓ 1.0 | ✗ 0.0 | Checked container type before classifying |
-    | task-007 | ✗ 0.0 | ✓ 1.0 | Verified code reachability not just presence |
-
-    **Divergence Pattern**: agent-A excels at X, agent-B excels at Y.
-    **Transferable Insight**: agent-B's reachability check could be added to agent-A.
-
-    ## Complementary Failures
-
-    Agent pairs with complementary strengths (each passes tasks the other fails):
-
-    - **agent-A + agent-B**: 5 complementary tasks (ensemble would score 0.85 vs 0.65/0.70 individual)
-    - **agent-C + agent-D**: 2 complementary tasks
-
-    ## Failure Patterns
-    For each systematic failure pattern (≥2 tasks), describe:
-    - Root cause description (in your own words, as specific as the evidence allows)
-    - How many tasks affected (e.g. "5/8 tasks")
-    - Concrete example: task name, what agent did, what it should have done
-    - Trace evidence: session + turn + direct quote from the trace
-
-    Example:
-    - **Agent interprets "net revenue" as "gross revenue"** (4/7 tasks): In task `q3-analysis`,
-      turn 3: agent wrote "I'll use total_sales which represents net revenue" — but total_sales
-      is pre-discount. Root cause confirmed via trace.search("net revenue") returning 0 matches
-      before the wrong computation.
-      **agent-2 passes this task** by explicitly checking the column metadata for "net" vs "gross".
-
-    ## Root Causes
-    For each root cause, answer these three questions explicitly:
-    1. **What** specifically did the agent do wrong? (concrete action or output)
-    2. **Why** did it do that? (missing knowledge, wrong assumption, context issue, code bug)
-    3. **What would fix it?** (the minimal change that addresses the root cause directly)
-    4. **Which agents don't have this root cause?** — and what's different about them
-
-    Do NOT write vague statements like "the agent misunderstood the task" without
-    specifying what it misunderstood and why. Do NOT write "improve the prompt" without
-    specifying what information is missing and where in the agent's reasoning it would help.
-
-    ## Mechanical/Infrastructure Errors
-
-    Errors that are NOT agent logic problems — fix these on the infrastructure side:
-
-    | Task | Error Type | Issue | Suggested Fix |
-    |------|------------|-------|---------------|
-    | task-005 | environment | `ModuleNotFoundError: cryptography` | Add to container requirements |
-    | task-012 | timeout | Agent hit 5min limit mid-analysis | Increase task timeout to 10min |
-    | task-018 | dataset | Ground truth expects format X but instruction says Y | Fix instruction.md |
-    | task-023 | api | CVE server returned 503 | Add retry logic to cve-server |
-    | task-001 | config | `max_iterations` set to 100 | Increase `max_iterations` to 1000 |
-
-    **Do NOT optimize agents to work around these issues.** Report them for infra fixes.
-
-    Common mechanical error categories:
-    - **config**: wrong config parameters, missing config, config limits exceeded
-    - **environment**: missing packages, wrong versions, container config
-    - **timeout**: legitimate work cut short by time limits
-    - **dataset**: incorrect ground truth, ambiguous instructions, missing fixtures
-    - **api/service**: external service failures, rate limits, network issues
-    - **scorer**: evaluation bug, wrong expected format, edge case not handled
-
-    **What qualifies as a mechanical error:**
-    - Crashes or `sys.exit` on recoverable errors (e.g., scraping fails → exit instead of fallback)
-    - Wrong output path, missing required fields, schema violations
-    - Unhandled exceptions that silently discard valid data
-    - Missing error handling where failure is expected (network calls, file I/O)
-    - Misconfigured agent, llms, config, etc.
-
-    **What is NOT a mechanical error** (use root cause analysis + improvements instead):
-    - Shallow reasoning, poor query strategy, suboptimal architecture
-    - The code works but produces low-quality output
-    ```
-
-    Fill in every section with real data from the per-agent analyses. No placeholders.
-    Return the complete markdown content as a string — the caller writes it to disk.
-    """
-
-
-class EvolutionaryOptimizer(Agent):
-    """The Experimentalist's deterministic Pareto optimization loop.
-
-    Orchestrates the baseline → [convergence-check → select → train-eval →
-    analyze → propose → implement → record → validation-eval] cycle across
-    rounds, mirroring the AAD ``EvolutionaryOptimizer``.
-    """
-
-    def __init__(
-        self,
-        working_dir: Path,
-        config: EvolutionaryOptimizerConfig | None = None,
-        framework_skills_dirs: list[Path] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(llm=kwargs.pop("llm", None) or get_default_model(), **kwargs)
-        self.working_dir = working_dir.resolve()
-        self.config = config or EvolutionaryOptimizerConfig()
-        self._config = self.config
-        self._workspace_path = self.working_dir
-        self._framework_skills_dirs: list[Path] = framework_skills_dirs or []
-        self.terminator = Terminator()
-        self.selector = SurvivorSelector(workspace=self.working_dir)
-        self.shell = GuardedShellTools(cwd=self.working_dir)
-        self.workspace = WorkspaceTool(workspace=self.working_dir)
-        self.context["file_match"] = doc(Match)
-        self.context["workspace_tool_documentation"] = doc(WorkspaceTool)
-        self.skills: SkillRegistry = SkillRegistry(self)
-        spec(self, "skills", hidden=True)
-        load_framework_skills(self.skills, self._framework_skills_dirs)
-        self.skills.register("ext.analysis_skill", AnalysisSkill())
-        self.skills.activate(["cmd.*", "ext.*"])
-        TokenBudgetSummarizer.install(
-            self,
-            llm=get_fast_model(),
-            config=TokenBudgetConfig(max_tokens=self.config.max_summary_tokens),
-        )
-
-    @staticmethod
-    def _coder_config(config: EvolutionaryOptimizerConfig) -> CoderConfig:
-        if config.model_catalog_path is None or config.coder.model_catalog_path is not None:
-            return config.coder
-        return config.coder.model_copy(update={"model_catalog_path": config.model_catalog_path})
-
-    # ------------------------------------------------------------------
-    # Public entry point
-    # ------------------------------------------------------------------
-
-    async def run(self, deps: ExperimentalistDeps) -> ExperimentalistResult:
-        """Run optimization and always close the owned shell session."""
-        try:
-            return await self._run(deps)
-        finally:
-            await self.shell.close()
-
-    async def _run(self, deps: ExperimentalistDeps) -> ExperimentalistResult:
-        """Run the Pareto evolutionary optimization loop.
-
-        Args:
-            deps: Per-run dependencies (workspace, insight_id, dataset,
-                backend, optional config override).
-
-        Returns:
-            An :class:`ExperimentalistResult` committed to the entity store
-            via ``backend.persist_result()``.
-        """
-        if deps.backend is None:
-            raise ValueError("deps.backend must be set before calling run()")
-        backend = deps.backend
-        workspace = deps.workspace
-        config = deps.config if deps.config is not None else self.config
-        self.config = config
-        reporter = getattr(deps, "reporter", None)
-
-        # ---- Preflight: fail fast when persistence is enabled but git is missing.
-        if (config.storage.archive_candidates or config.storage.publish_winner) and shutil.which("git") is None:
-            raise ValueError(
-                "Candidate persistence is enabled (storage.archive_candidates/publish_winner) "
-                "but 'git' is not on PATH, so nothing can be persisted. Install git, or disable "
-                "storage to run without persistence."
-            )
-
-        # ---- Working directory structure ---------------------------------
-        agents_dir, analysis_dir, results_dir = self._init_structure()
-        evaluator_factory = EvaluatorFactory()
-        evaluator = evaluator_factory.build_evaluator(
-            deps.evaluator_type,
-            config.evaluator,
-            experiment_dir=self.working_dir,
-        )
-        dataset_factory = DatasetFactory()
-
-        train_dataset_ref = deps.train_dataset
-        validation_dataset_ref = deps.validation_dataset
-        task_template_ref = deps.task_template
-        if deps.insight is not None:
-            if task_template_ref is None:
-                raise ValueError("Task template is required for insight trace analysis")
-            if backend.client is None:
-                raise ValueError("Platform client is required for insight task template loading")
-            staged_inputs = await stage_eval_author_inputs(
-                self.working_dir,
-                train_dataset=train_dataset_ref,
-                validation_dataset=validation_dataset_ref,
-                task_template=task_template_ref,
-                client=backend.client,
-                workspace=workspace,
-            )
-            train_dataset_ref = staged_inputs.train_dataset
-            validation_dataset_ref = staged_inputs.validation_dataset
-            task_template_ref = staged_inputs.task_template
-
-        # ---- Resolve datasets to evaluator-domain objects -----------------
-        train_eval_dataset = dataset_factory.build_dataset(
-            deps.evaluator_type,
-            train_dataset_ref,
-            allow_empty=deps.insight is not None,
-        )
-
-        validation_eval_dataset = dataset_factory.build_dataset(
-            deps.evaluator_type,
-            validation_dataset_ref,
-            allow_empty=deps.insight is not None,
-        )
-
-        # ---- Resolve insight (Mode 1) vs local agent (Mode 2) -----------
-        insight = (
-            await backend.get_insight(workspace=workspace, insight_id=str(deps.insight))
-            if deps.insight is not None
-            else None
-        )
-        agent_ref: str | Path | None = deps.agent
-        if agent_ref is None and insight is not None:
-            agent_ref = insight.agent
-        if agent_ref is None:
-            raise ValueError("Insight or agent is required")
-
-        agent_path = self.working_dir / "eval-and-optimize" / "source-agent"
-        await backend.get_agent_code(
-            workspace=workspace,
-            agent=agent_ref,
-            dest=agent_path,
-            clone_depth=config.source.clone_depth,
-        )
-        agent_name = str(agent_ref)
-
-        agent_spec_path: Path | None = None
-        if deps.agent_spec is not None:
-            agent_spec_path = await backend.get_agent_spec(
-                workspace=workspace,
-                spec=deps.agent_spec,
-                dest=self.working_dir / "AGENT-SPEC.md",
-            )
-
-        if insight is not None:
-            insight_ref: str = str(deps.insight)
-            # run the eval_author
-            if backend.client is None:
-                raise ValueError("Platform client is required for insight trace loading")
-            assert task_template_ref is not None
-            eval_author = EvalAuthor(
-                experiment_dir=self.working_dir,
-                config=config.eval_author,
-                reporter=reporter,
-            )
-            eval_author_result = await eval_author.run(
-                insight=insight,
-                agent_path=agent_path,
-                task_template=dataset_factory.build_task_template(deps.evaluator_type, task_template_ref),
-                train_dataset=train_eval_dataset,
-                validation_dataset=validation_eval_dataset,
-                client=backend.client,
-            )
-            config = _with_insight_objective(config, eval_author_result.metric_keys)
-            self.config = config
-            logger.info("[METRICS] Insight objective: %s", config.optimization_policy())
-            train_eval_dataset = eval_author_result.train_dataset
-            validation_eval_dataset = eval_author_result.validation_dataset
-            if eval_author_result.insight_suite is not None:
-                restore_heldout_splits(self.working_dir)
-                try:
-                    distribute_insight_suite_tasks(
-                        eval_author_result.insight_suite,
-                        train_eval_dataset,
-                        validation_eval_dataset,
-                    )
-                finally:
-                    ensure_heldout_hidden(self.working_dir)
-        else:
-            # Mode 2: local agent directory as baseline, no insight required.
-            insight = None
-            insight_ref = ""
-
-        # ---- Resume or fresh start ---------------------------------------
-        if (round_num := self._detect_last_round()) is not None:
-            logger.info(f"[RESUME] round {round_num}")
-            self._delete_all_artifacts(from_round=round_num)
-            evolution_tree = EvolutionTree.from_dir(agents_dir)
-            candidates: list[Candidate] = list(evolution_tree.survivors(round_num))
-            if reporter:
-                # agent-0 is not re-evaluated on resume; seed the delta baseline
-                # from its cached validation reward so later deltas are correct.
-                baseline_node = next(
-                    (n for n in evolution_tree.nodes.values() if n.label == _BASELINE_AGENT_LABEL),
-                    None,
-                )
-                if baseline_node is not None and baseline_node.val_reward:
-                    reporter.seed_baseline(baseline_node.val_reward)
-            run_entity = self._load_run_entity() or await self._create_experiment_run(
-                workspace=workspace,
-                backend=backend,
-                agent_name=agent_name or None,
-                agent_path=agent_path,
-                insight_ref=insight_ref or None,
-                config=config,
-            )
-        else:
-            round_num = 0
-            logger.info("phase=baseline round=0")
-            if reporter:
-                reporter.progress(phase="baseline", completed=0, total=config.max_rounds)
-            run_entity = await self._create_experiment_run(
-                workspace=workspace,
-                backend=backend,
-                agent_name=agent_name or None,
-                agent_path=agent_path,
-                insight_ref=insight_ref or None,
-                config=config,
-            )
-
-            try:
-                # ---- Fetch + build baseline agent (agent-0) --------------
-                baseline = await self._create_baseline_agent(
-                    workspace=workspace,
-                    backend=backend,
-                    agents_dir=agents_dir,
-                    agent_name=agent_name,
-                    agent_path=agent_path,
-                    run_id=run_entity.id or "",
-                    config=config,
-                )
-                await self._update_candidate(
-                    baseline,
-                    workspace=workspace,
-                    backend=backend,
-                    run_id=run_entity.id or "",
-                )
-                evolution_tree = EvolutionTree.from_dir(agents_dir)
-                candidates = list(evolution_tree.survivors(0))
-
-                # ---- Baseline validation evaluation (round 0) ------------
-                validation_candidate_results = await self._evaluate_validation_candidates(
-                    dataset=validation_eval_dataset,
-                    evaluator=evaluator,
-                    candidates=candidates,
-                )
-                validation_result = validation_candidate_results[candidates[0].label]
-                await backend.persist_evaluation(
-                    workspace=workspace,
-                    result=validation_result,
-                    candidate=candidates[0],
-                    split="validation",
-                )
-                candidates[0].record_reward(
-                    "validation",
-                    metrics=validation_result.aggregate_metrics,
-                    trials=validation_result.trials,
-                )
-                await self._update_candidate(
-                    candidates[0],
-                    workspace=workspace,
-                    backend=backend,
-                    run_id=run_entity.id or "",
-                )
-                if reporter:
-                    reporter.candidate_evaluated(
-                        label=candidates[0].label,
-                        split="validation",
-                        metrics=validation_result.aggregate_metrics,
-                        objective_metrics=config.objective_function,
-                        artifacts=self._results_dir(validation_result.id),
-                    )
-            except Exception:
-                run_entity.status = "failed"
-                await backend.update_run(workspace=workspace, run=run_entity)
-                raise
-
-        run_id = run_entity.id or ""
-
-        # ---- Initial goal tree (idempotent) ------------------------------
-        await self._generate_initial_goal_tree(
-            dataset=train_eval_dataset,
-            disable_trajectory_scoring=config.disable_trajectory_scoring,
-            config=config,
-            agent_spec_path=agent_spec_path,
-        )
-
-        phase: Literal["exploration", "exploitation"] = "exploration" if round_num % 2 == 0 else "exploitation"
-
-        # ---- Pareto optimization loop (shared by fresh start and resume) --
-        try:
-            while True:
-                prior_analysis = (
-                    await self._load_round_analysis(analysis_dir=analysis_dir, round_num=round_num - 1)
-                    if round_num > 0
-                    else None
-                )
-                decision = await self.terminator.run(
-                    round_num=round_num,
-                    evolution_tree=evolution_tree,
-                    prior_analysis=prior_analysis,
-                    config=config,
-                )
-                if decision.stop:
-                    logger.info(f"phase=terminate reason={decision.reason}")
-                    break
-
-                survivors = (
-                    await self._select_survivors(
-                        [c.slim() for c in candidates],
-                        k=config.max_survivors,
-                    )
-                    if len(candidates) > 1
-                    else list(candidates)
-                )
-                survivor_labels = {s.label for s in survivors}
-                killed = [c for c in candidates if c.label not in survivor_labels]
-                for candidate in killed:
-                    await self._update_candidate(
-                        candidate,
-                        workspace=workspace,
-                        backend=backend,
-                        run_id=run_id,
-                        updates={"killed_round": round_num},
-                    )
-
-                train_candidate_results = await self._evaluate_train_candidates(
-                    dataset=train_eval_dataset,
-                    evaluator=evaluator,
-                    survivors=survivors,
-                    round_num=round_num,
-                    max_train_batch_tasks=config.max_train_batch_tasks,
-                    train_batch_seed=config.train_batch_seed,
-                )
-                for survivor in survivors:
-                    if survivor.label in train_candidate_results:
-                        await backend.persist_evaluation(
-                            workspace=workspace,
-                            result=train_candidate_results[survivor.label],
-                            candidate=survivor,
-                            split="train",
-                        )
-                        survivor.record_reward(
-                            "train",
-                            metrics=train_candidate_results[survivor.label].aggregate_metrics,
-                            trials=train_candidate_results[survivor.label].trials,
-                        )
-                        await self._update_candidate(
-                            survivor,
-                            workspace=workspace,
-                            backend=backend,
-                            run_id=run_id,
-                        )
-                        if reporter:
-                            reporter.candidate_evaluated(
-                                label=survivor.label,
-                                split="train",
-                                metrics=train_candidate_results[survivor.label].aggregate_metrics,
-                                objective_metrics=config.objective_function,
-                                artifacts=self._results_dir(train_candidate_results[survivor.label].id),
-                            )
-                analysis = await self._analyze_round(
-                    analysis_dir=analysis_dir,
-                    dataset=train_eval_dataset,
-                    evaluations=train_candidate_results,
-                    survivors=[c.slim() for c in survivors],
-                    round_num=round_num,
-                    config=config,
-                    client=backend.client,
-                    nmp_workspace=workspace,
-                    agent_spec_path=agent_spec_path,
-                )
-                await self._update_goal_tree(
-                    analysis_dir=analysis_dir,
-                    round_num=round_num,
-                    analysis=analysis,
-                    dataset=train_eval_dataset,
-                    config=config,
-                    agent_spec_path=agent_spec_path,
-                )
-
-                improvements = await self._propose_improvements(
-                    workspace=workspace,
-                    backend=backend,
-                    analysis=analysis,
-                    evolution_tree=evolution_tree,
-                    round_num=round_num,
-                    phase=phase,
-                    config=config,
-                )
-                if not improvements:
-                    logger.info("[TERMINATOR] no improvements proposed; finalizing evaluated candidates")
-                    break
-                new_candidates = [
-                    self._create_agent(
-                        agents_dir=agents_dir,
-                        improvement=imp,
-                        round_num=round_num + 1,
-                        run_id=run_entity.id or "",
-                    )
-                    for imp in improvements
-                ]
-                # Persist metadata.json before Coder runs so snapshot can read it.
-                for candidate in new_candidates:
-                    await self._update_candidate(
-                        candidate,
-                        workspace=workspace,
-                        backend=backend,
-                        run_id=run_entity.id or "",
-                    )
-                new_candidates = await self._implement_candidates(
-                    workspace=workspace,
-                    backend=backend,
-                    dataset=train_eval_dataset,
-                    evaluator=evaluator,
-                    candidates=new_candidates,
-                    config=config,
-                )
-                for candidate in new_candidates:
-                    await self._update_candidate(
-                        candidate,
-                        workspace=workspace,
-                        backend=backend,
-                        run_id=run_id,
-                    )
-                for c in new_candidates:
-                    evolution_tree.add(c)
-
-                candidates = survivors + new_candidates
-                round_num += 1
-                phase = "exploration" if round_num % 2 == 0 else "exploitation"
-                if reporter:
-                    reporter.progress(
-                        phase="evaluating candidates",
-                        completed=round_num,
-                        total=config.max_rounds,
-                    )
-                    # Announce candidates before the (batched) validation eval,
-                    # so the narration reports work beginning, not completed.
-                    # Mirror _evaluate_validation_candidates' own filter so we
-                    # only announce candidates that will actually be evaluated
-                    # (cached survivors already carry a validation_reward).
-                    pending_validation = [c for c in candidates if "validation" not in c.rewards]
-                    for i, candidate in enumerate(pending_validation, start=1):
-                        reporter.candidate_started(
-                            label=candidate.label,
-                            optimization=candidate.optimization,
-                            i=i,
-                            n=len(pending_validation),
-                        )
-
-                validation_candidate_results = await self._evaluate_validation_candidates(
-                    dataset=validation_eval_dataset,
-                    evaluator=evaluator,
-                    candidates=candidates,
-                )
-                for candidate in candidates:
-                    if candidate.label in validation_candidate_results:
-                        await backend.persist_evaluation(
-                            workspace=workspace,
-                            result=validation_candidate_results[candidate.label],
-                            candidate=candidate,
-                            split="validation",
-                        )
-                        candidate.record_reward(
-                            "validation",
-                            metrics=validation_candidate_results[candidate.label].aggregate_metrics,
-                            trials=validation_candidate_results[candidate.label].trials,
-                        )
-                        await self._update_candidate(
-                            candidate,
-                            workspace=workspace,
-                            backend=backend,
-                            run_id=run_id,
-                        )
-                        if reporter:
-                            reporter.candidate_evaluated(
-                                label=candidate.label,
-                                split="validation",
-                                metrics=validation_candidate_results[candidate.label].aggregate_metrics,
-                                objective_metrics=config.objective_function,
-                                artifacts=self._results_dir(validation_candidate_results[candidate.label].id),
-                            )
-                if not config.disable_trajectory_scoring:
-                    trajectory_results = await self._reward_trajectories(
-                        workspace=workspace,
-                        backend=backend,
-                        dataset=validation_eval_dataset,
-                        candidates=candidates,
-                        config=config,
-                        client=backend.client,
-                    )
-                    for candidate in candidates:
-                        if candidate.label in trajectory_results:
-                            candidate.record_reward(
-                                "validation-trajectory",
-                                metrics=trajectory_results[candidate.label]["reward"],
-                            )
-                            await self._update_candidate(
-                                candidate,
-                                workspace=workspace,
-                                backend=backend,
-                                run_id=run_id,
-                                updates={
-                                    "trajectory_detail": trajectory_results[candidate.label]["details"],
-                                },
-                            )
-
-                if config.storage.archive_candidates:
-                    for candidate in new_candidates:
-                        try:
-                            await backend.archive_candidate(workspace=workspace, candidate=candidate)
-                        except Exception as exc:  # noqa: BLE001 - archival must never fail the run
-                            _warn_persistence_failure("archive", candidate.label, exc)
-
-                run_entity.rounds_completed = round_num
-                await backend.update_run(workspace=workspace, run=run_entity)
-
-        except Exception:
-            run_entity.status = "failed"
-            await backend.update_run(workspace=workspace, run=run_entity)
-            raise
-
-        # ---- Finalize ----------------------------------------------------
-        winner_entity = await self._finalize(
-            workspace=workspace,
-            backend=backend,
-            agents_dir=agents_dir,
-            run_entity=run_entity,
-            evolution_tree=evolution_tree,
-            agent_name=agent_name,
-        )
-
-        baseline_entity = next(
-            (node.candidate for node in evolution_tree.nodes.values() if node.round == 0),
-            None,
-        )
-        result = ExperimentalistResult(
-            summary=self._render_summary(
-                rounds_completed=round_num,
-                baseline=baseline_entity,
-                winner=winner_entity,
-            ),
-            run_id=run_id,
-            rounds_completed=round_num,
-            winner=winner_entity,
-        )
-
-        # Persist the terminal result
-        await backend.persist_result(workspace=workspace, result=result)
-
-        # Publish the winner as a draft PR/MR
-        if config.storage.publish_winner and winner_entity is not None and winner_entity.round != 0:
-            try:
-                url = await backend.publish_candidate(workspace=workspace, candidate=winner_entity)
-                if url:
-                    logger.info(f"[TERMINATOR] opened draft PR/MR for winner {winner_entity.label}: {url}")
-            except Exception as exc:  # noqa: BLE001 - publishing must never fail the run
-                _warn_persistence_failure("publish", winner_entity.label, exc)
-        return result
-
-    async def select_diverse_survivors(
-        self,
-        ranked: list[Candidate],
-        k: int,
-        objective_metrics: list[MetricTarget],
-        regression_metrics: list[MetricTarget],
-    ) -> list[Candidate]:  # pyright: ignore[reportReturnType]
-        """Backward-compatible delegate for :class:`SurvivorSelector`."""
-        return await self.selector.select(ranked, k, objective_metrics, regression_metrics)
-
-    @strategy(CodeActStrategy(config=CodeActConfig(max_iterations=100, cell_timeout=3600.0)))
-    async def merge_analysis(
-        self,
-        agent_ids: list[Candidate],
-        round: int,
-        per_agent_analyses: list[str],  # noqa: A002
-        objective_metrics: list[MetricTarget],
-        regression_metrics: list[MetricTarget],
-    ) -> str:  # pyright: ignore[reportReturnType]
-        """Merge per-agent analyses, compare agents, and write the round analysis file.
-
-        ## Step 1: Compare agents at reward level
-
-        Active objectives: ``objective_metrics``. Active regression guardrails:
-        ``regression_metrics``. Analyze objective improvements and shortfalls first;
-        discuss regression only as a constraint on objective improvement.
-        Treat evaluator metrics (including aggregate metrics) as authoritative;
-        do not derive a scalar score or prescribe a selection algorithm.
-
-        Read each agent's per-dimension train rewards from metadata:
-
-        ```python
-        rewards = {c.id: self.workspace.get_metadata(c.name).reward("train").metrics or {} for c in agent_ids}
-        ```
-
-        - Compare siblings: which optimization strategy worked better this round?
-        - Compare to ancestors: did the change actually fix the targeted root cause?
-
-        ## Step 2: Analyze divergent and complementary patterns
-
-        Using the per-dimension rewards above, identify where agents diverge (one
-        leads, another trails on a dimension) and where their strengths are
-        complementary. Prioritize divergences on objective metrics. A regression
-        metric can identify a guardrail risk, but must not become the primary
-        failure pattern or root cause. Ground observations in the per-agent
-        analyses passed in.
-
-        ## Step 3: Build the round analysis markdown
-
-        First, discover reward dimensions from metadata:
-        ```python
-        candidate = self.workspace.get_metadata(agent_ids[0].name).slim()
-        train_reward = candidate.reward("train").metrics or {}
-        dim_keys = sorted(train_reward.keys())
-        ```
-
-        Follow the `ext.analysis_skill` format exactly for every section (Rewards tables,
-        Trajectory Rewards; Divergent Trial Analysis; Complementary Failures; Failure Patterns; Root Causes;
-        Mechanical/Infrastructure Errors).
-
-        Fill in every included section with real data. No placeholders.
-        Every Failure Pattern and Root Cause must explain a failing or
-        underperforming objective metric. Do not write a root-cause narrative
-        solely about a regression metric; record it as a regression risk instead.
-        Return the complete markdown content as a string.
-        """
-        ...
-
-    @strategy(CodeActStrategy(config=CodeActConfig(max_iterations=100, cell_timeout=3600.0)))
-    async def write_final_report(self, best_agent_id: str) -> None:  # pyright: ignore[reportReturnType]
-        """Write the final optimization report to eval-and-optimize/OPTIMIZATION.md.
-
-        ## MANDATORY: use self.workspace — DO NOT ls / cat / find manually
-
-        ```python
-        agent_ids = self.workspace.list_agents()
-        candidate = self.workspace.get_metadata(agent_id).slim()
-        analysis  = self.workspace.read_analysis_file(n)
-        ```
-
-        ## Steps
-        1. Collect metadata for every agent.
-        2. Read round analysis files.
-        3. Build the lineage tree by following ancestor chains.
-        4. Write eval-and-optimize/OPTIMIZATION.md with format:
-           - Summary (baseline vs best rewards, rounds completed, total agents)
-           - Reward Breakdown table (one row per agent, per-dimension columns)
-           - Lineage Tree (ASCII tree with rewards and optimization type)
-           - Round-by-Round Analysis
-           - Optimization Insights
-
-        Fill in every section with real data. Every agent must appear in the lineage tree.
-        Mark the best agent with * BEST.
-        """
-        ...
-
-    # ------------------------------------------------------------------
-    # Private helpers — concrete (no LLM, no evaluator)
-    # ------------------------------------------------------------------
-
-    def _init_structure(self) -> tuple[Path, Path, Path]:
-        """Create the eval-and-optimize workspace directories; return (agents_dir, analysis_dir, results_dir)."""
-        agents_dir = self.working_dir / "eval-and-optimize" / "agents"
-        analysis_dir = self.working_dir / "eval-and-optimize" / "analysis"
-        results_dir = self.working_dir / "eval-and-optimize" / "results"
-        agents_dir.mkdir(parents=True, exist_ok=True)
-        analysis_dir.mkdir(parents=True, exist_ok=True)
-        results_dir.mkdir(parents=True, exist_ok=True)
-        return agents_dir, analysis_dir, results_dir
-
-    def _load_run_entity(self) -> ExperimentRun | None:
-        """Read run.json from the workspace; return None if absent or unparseable."""
-        run_path = self.working_dir / "eval-and-optimize" / "run.json"
-        if not run_path.exists():
-            return None
-        try:
-            data = json.loads(run_path.read_text())
-            # ExperimentRun._restore_id_from_json validator handles id restoration
-            return ExperimentRun.model_validate(data)
-        except Exception as exc:  # noqa: BLE001
-            logger.warning(f"[RESUME] Could not parse run.json: {exc}")
-            return None
-
-    def _detect_last_round(self) -> int | None:
-        """Return the last completed round by scanning analysis files, or None if starting fresh."""
-        analysis_dir = self.working_dir / "eval-and-optimize" / "analysis"
-        if not analysis_dir.exists():
-            return None
-        rounds = []
-        for f in analysis_dir.glob("round-*.md"):
-            try:
-                rounds.append(int(f.stem.split("-")[1]))
-            except (IndexError, ValueError):
-                continue
-        return max(rounds) if rounds else None
-
-    def _delete_all_artifacts(self, from_round: int) -> None:
-        """Delete agents and analysis files created after *from_round*.
-
-        Rolls back any partial work so the loop can cleanly re-enter at
-        the start of ``from_round + 1``.  Also clears stale ``killed_round``
-        markers on surviving agents whose killer round was itself rolled back.
-        """
-        agents_dir = self.working_dir / "eval-and-optimize" / "agents"
-        results_dir = self.working_dir / "eval-and-optimize" / "results"
-        analysis_dir = self.working_dir / "eval-and-optimize" / "analysis"
-        smoke_dataset_dir = self.working_dir / "eval-and-optimize" / "smoke-dataset"
-        smoke_results_dir = self.working_dir / "eval-and-optimize" / "smoke-results"
-
-        for agent_dir in sorted(agents_dir.iterdir()):
-            if not (
-                agent_dir.is_dir() and agent_dir.name.startswith("agent-") and agent_dir.name.split("-")[1].isdigit()
-            ):
-                continue
-            meta_path = agent_dir / "metadata.json"
-            if not meta_path.exists():
-                continue
-            try:
-                meta = json.loads(meta_path.read_text())
-            except (json.JSONDecodeError, OSError):
-                continue
-            if (meta.get("round") or 0) > from_round:
-                shutil.rmtree(agent_dir)
-                for result_dir in results_dir.glob(f"{agent_dir.name}-*"):
-                    if result_dir.is_dir():
-                        shutil.rmtree(result_dir)
-                for rd in (
-                    smoke_results_dir / agent_dir.name,
-                    smoke_dataset_dir / agent_dir.name,
-                ):
-                    if rd.exists():
-                        shutil.rmtree(rd)
-
-        # Clear stale killed_round markers whose killer round was rolled back.
-        for agent_dir in sorted(agents_dir.iterdir()):
-            if not (
-                agent_dir.is_dir() and agent_dir.name.startswith("agent-") and agent_dir.name.split("-")[1].isdigit()
-            ):
-                continue
-            meta_path = agent_dir / "metadata.json"
-            if not meta_path.exists():
-                continue
-            try:
-                meta = json.loads(meta_path.read_text())
-            except (json.JSONDecodeError, OSError):
-                continue
-            killed = meta.get("killed_round")
-            if killed is not None and killed > from_round:
-                meta["killed_round"] = None
-                meta_path.write_text(json.dumps(meta, indent=2))
-
-        for pattern in ("round-*.md", "round-*-goal.json"):
-            for f in analysis_dir.glob(pattern):
-                try:
-                    n = int(f.stem.split("-")[1])
-                except (IndexError, ValueError):
-                    continue
-                if n > from_round:
-                    f.unlink()
-
-    async def _create_baseline_agent(
-        self,
-        *,
-        workspace: str,
-        backend: ExperimentalistBackend,
-        agents_dir: Path,
-        agent_name: str | None,
-        agent_path: Path | None,
-        run_id: str,
-        config: EvolutionaryOptimizerConfig,
-    ) -> Candidate:
-        """Materialize the source agent into ``agents_dir/agent-0`` and return the baseline candidate.
-
-        An explicit ``--agent`` (``agent_path``, a local dir or a git clone) takes
-        precedence and is copied directly; otherwise the code is fetched by the
-        insight's agent name via ``backend.get_agent_code``. Skips the copy when the
-        directory already exists (resume case).
-        """
-        baseline_dir = agents_dir / _BASELINE_AGENT_LABEL
-        if not baseline_dir.exists():
-            if agent_path is not None:
-                shutil.copytree(agent_path, baseline_dir, ignore=_ignore_patterns)
-            elif agent_name:
-                await backend.get_agent_code(workspace=workspace, agent=agent_name, dest=baseline_dir)
-        await self._generate_architecture_doc(agent_dir=baseline_dir, config=config)
-        candidate = Candidate(
-            name=_BASELINE_AGENT_LABEL,
-            label=_BASELINE_AGENT_LABEL,
-            workspace=workspace,
-            run_id=run_id,
-            ancestor=None,
-            round=0,
-            optimization="baseline",
-        )
-        return candidate
-
-    def _create_agent(
-        self,
-        *,
-        agents_dir: Path,
-        improvement: Improvement,
-        round_num: int,
-        run_id: str,
-    ) -> Candidate:
-        """Copy the ancestor directory to a new ``agent-N`` directory and return the candidate."""
-        next_label = self._next_agent_label(agents_dir)
-        ancestor_dir = agents_dir / improvement.ancestor
-        candidate_dir = agents_dir / next_label
-        generated_files = {
-            "architecture.md",
-        }
-
-        def _ignore_agent_meta(directory: str, contents: list[str]) -> set[str]:
-            ignored = _ignore_patterns(directory, contents)
-            if Path(directory).resolve() != ancestor_dir.resolve():
-                return ignored
-            return ignored | {name for name in contents if name == "metadata.json" or name in generated_files}
-
-        if ancestor_dir.is_dir():
-            shutil.copytree(ancestor_dir, candidate_dir, ignore=_ignore_agent_meta)
-        else:
-            candidate_dir.mkdir(parents=True, exist_ok=True)
-        opt_type = _coerce_optimization_type(improvement.optimization_type)
-        candidate = Candidate(
-            name=next_label,
-            label=next_label,
-            ancestor=improvement.ancestor,
-            round=round_num,
-            optimization=improvement.optimization,
-            optimization_type=opt_type,
-            task_ids=improvement.task_ids,
-            run_id=run_id,
-        )
-        return candidate
-
-    def _next_agent_label(self, agents_dir: Path) -> str:
-        """Return the next sequential ``agent-N`` label based on existing directories."""
-        nums = [
-            int(d.name.split("-")[1])
-            for d in agents_dir.iterdir()
-            if d.is_dir() and d.name.startswith("agent-") and d.name.split("-")[1].isdigit()
-        ]
-        return f"agent-{max(nums, default=-1) + 1}"
-
-    async def _load_round_analysis(
-        self,
-        *,
-        analysis_dir: Path,
-        round_num: int,
-    ) -> str | None:
-        """Return the cached analysis markdown for *round_num*, or None if absent."""
-        path = analysis_dir / f"round-{round_num}.md"
-        return path.read_text() if path.exists() else None
-
-    async def _update_candidate(
-        self,
-        candidate: Candidate,
-        *,
-        workspace: str,
-        backend: ExperimentalistBackend,
-        run_id: str,
-        updates: dict[str, Any] | None = None,
-    ) -> None:
-        """Sync candidates to the entity store.
-
-        Fills in ``workspace`` and ``run_id`` from the call-site context
-        (which is authoritative) before persisting.  On first persist the
-        backend assigns a store id (``_id``); on subsequent calls it updates
-        the existing record.
-        """
-        candidate.workspace = workspace
-        candidate.run_id = run_id
-        if updates is not None:
-            for key, value in updates.items():
-                setattr(candidate, key, value)
-        if candidate.id:
-            await backend.update_candidate(workspace=workspace, candidate=candidate)
-        else:
-            result = await backend.create_candidate(workspace=workspace, candidate=candidate)
-            candidate._id = result._id  # type: ignore[attr-defined]
-
-    def _goal_tree_path(self, round_num: int) -> Path:
-        return self.working_dir / "eval-and-optimize" / "analysis" / f"round-{round_num}-goal.json"
-
-    def _latest_goal_tree_path(self) -> Path | None:
-        analysis_dir = self.working_dir / "eval-and-optimize" / "analysis"
-        best: tuple[int, Path] | None = None
-        for p in analysis_dir.glob("round-*-goal.json"):
-            try:
-                n = int(p.stem.split("-")[1])
-            except (IndexError, ValueError):
-                continue
-            if best is None or n > best[0]:
-                best = (n, p)
-        return best[1] if best else None
-
-    def _results_dir(self, result_id: str) -> Path:
-        return self.working_dir / "eval-and-optimize" / "results" / result_id
-
-    def _load_goal_tree(
-        self,
-        path: Path,
-        goal_config: GoalTreeConfig,
-        context: str,
-    ) -> GoalTree | None:
-        try:
-            return GoalTree.from_path(path, config=goal_config)
-        except (OSError, ValueError) as exc:
-            logger.warning(f"[TRAJ] Failed to load {context} goal tree {path}: {exc}")
-            return None
-
-    def _format_evolution_table(self, evolution_tree: EvolutionTree) -> str:
-        if not evolution_tree.nodes:
-            return "(none yet — this is the first round)"
-        return evolution_tree.to_markdown_table()
-
-    def _copy_best_to_workspace(self, agent_id: str) -> None:
-        src = self.working_dir / "eval-and-optimize" / "agents" / agent_id
-        skip_names = {
-            "metadata.json",
-            "harbor_wrapper.py",
-            "dind_environment.py",
-            "architecture.md",
-        }
-        for entry in src.iterdir():
-            if entry.name in skip_names:
-                continue
-            dst = self.working_dir / entry.name
-            if entry.is_dir():
-                if dst.exists():
-                    shutil.rmtree(dst)
-                shutil.copytree(entry, dst)
-            else:
-                shutil.copy2(entry, dst)
-
-    def _snapshot_metadata(self, candidate_name: str) -> str | None:
-        """Read and return the metadata.json content for a candidate, or None if absent."""
-        path = self.working_dir / "eval-and-optimize" / "agents" / candidate_name / "metadata.json"
-        try:
-            return path.read_text()
-        except OSError:
-            return None
-
-    def _restore_metadata(self, candidate_name: str, content: str | None) -> None:
-        """Restore metadata.json for a candidate to a previously snapshotted content."""
-        if content is None:
-            return
-        path = self.working_dir / "eval-and-optimize" / "agents" / candidate_name / "metadata.json"
-        try:
-            path.write_text(content)
-        except OSError:
-            pass
-
-    async def _evaluate_agent(
-        self,
-        candidate: Candidate,
-        dataset: Dataset,
-        evaluator: Evaluator,
-        task_ids: list[str] | None = None,
-    ) -> tuple[Candidate, EvaluationResult]:
-        """Run evaluator for one candidate and return the candidate/result pair."""
-        eval_dataset = dataset.subset(task_ids) if task_ids is not None else dataset
-        # Force a unique job name per candidate so concurrent candidates don't
-        # collide on the same results directory when the user sets a fixed job_name.
-        options_dict = evaluator.options.model_dump()
-        options_dict["job_name"] = f"{candidate.label}-{eval_dataset.id}"
-        per_candidate_options = type(evaluator.options).model_validate(options_dict)
-        result = await evaluator.run(
-            agent=self.working_dir / "eval-and-optimize" / "agents" / candidate.label,
-            dataset=eval_dataset,
-            options=per_candidate_options,
-        )
-        return (candidate, result)
-
-    # ------------------------------------------------------------------
-    # Private step methods — implementations
-    # ------------------------------------------------------------------
-
-    async def _create_experiment_run(
-        self,
-        *,
-        workspace: str,
-        backend: ExperimentalistBackend,
-        agent_name: str | None,
-        agent_path: Path | None,
-        insight_ref: str | None,
-        config: EvolutionaryOptimizerConfig,
-    ) -> ExperimentRun:
-        """Create an ExperimentRun entity; return it with its store-assigned id."""
-        run = ExperimentRun(
-            workspace=workspace,
-            agent=agent_name or str(agent_path or ""),
-            insight=insight_ref,
-            config_snapshot=config.model_dump(mode="json"),
-            status="running",
-            rounds_completed=0,
-        )
-        return await backend.create_run(workspace=workspace, run=run)
-
-    async def _generate_architecture_doc(
-        self,
-        *,
-        agent_dir: Path,
-        config: EvolutionaryOptimizerConfig,
-    ) -> None:
-        """Generate ``architecture.md`` for *agent_dir* via Coder."""
-        if (agent_dir / "architecture.md").exists():
-            return
-        agent_id = agent_dir.name
-        await Coder(
-            workspace=self.working_dir,
-            config=self._coder_config(config),
-            framework_skills_dirs=self._framework_skills_dirs,
-        ).create_architecture_doc(
-            agent_id,
-            source_path=config.source.source_path,
-            entrypoint=config.source.entrypoint,
-        )
-
-    async def _evaluate_validation_candidates(
-        self,
-        *,
-        dataset: Dataset,
-        evaluator: Evaluator,
-        candidates: list[Candidate],
-    ) -> dict[str, EvaluationResult]:
-        """Evaluate candidates on the validation split; skip any that already have a reward."""
-        pending = [c for c in candidates if "validation" not in c.rewards]
-        if not pending:
-            return {}
-        if pending:
-            splits = frozenset({"validation"})
-            restore_heldout_splits(self.working_dir, splits=splits)
-            try:
-                candidate_results = await asyncio.gather(
-                    *[
-                        self._evaluate_agent(
-                            c,
-                            dataset,
-                            evaluator,
-                        )
-                        for c in pending
-                    ]
-                )
-            finally:
-                ensure_heldout_hidden(self.working_dir, splits=splits)
-        return {
-            candidate_result[0].label: candidate_result[1]
-            for candidate_result in candidate_results
-            if candidate_result is not None
-        }
-
-    async def _generate_initial_goal_tree(
-        self,
-        *,
-        dataset: Dataset,
-        disable_trajectory_scoring: bool,
-        config: EvolutionaryOptimizerConfig,
-        agent_spec_path: Path | None = None,
-    ) -> None:
-        """Generate and persist the round-0 goal tree if it does not already exist."""
-        if disable_trajectory_scoring:
-            return
-        tree_path = self._goal_tree_path(0)
-        if tree_path.exists():
-            return
-        try:
-            tree = await GoalTreeGenerator(
-                workspace=self.working_dir,
-                config=config.goal_config,
-                framework_skills_dirs=self._framework_skills_dirs,
-            ).generate(dataset, agent_spec=agent_spec_path)
-        except Exception as exc:  # noqa: BLE001
-            logger.warning(f"[TRAJ] Failed to generate initial goal tree; continuing without trajectory scoring: {exc}")
-            return
-        tree_path.parent.mkdir(parents=True, exist_ok=True)
-        tree_path.write_text(tree.to_json())
-
-    async def _select_survivors(
-        self,
-        candidates: list[Candidate],
-        k: int,
-    ) -> list[Candidate]:
-        """Return diverse Pareto survivors, with regression metrics as selector context."""
-        eligible = [
-            candidate
-            for candidate in candidates
-            if has_metric_dimensions(candidate.reward("validation").metrics or {}, self.config.objective_function)
-        ]
-        if not eligible:
-            raise ValueError(
-                "No candidate reports every objective metric: "
-                f"{[target.name for target in self.config.objective_function]}"
-            )
-        ranked = pareto_sort(
-            eligible,
-            lambda candidate: pareto_objectives(
-                candidate.reward("validation").metrics or {}, self.config.objective_function
-            ),
-        )
-        return await self.select_diverse_survivors(
-            ranked,
-            k,
-            self.config.objective_function,
-            self.config.regression_metrics,
-        )
-
-    async def _evaluate_train_candidates(
-        self,
-        *,
-        dataset: Dataset,
-        evaluator: Evaluator,
-        max_train_batch_tasks: int | None,
-        train_batch_seed: int,
-        survivors: list[Candidate],
-        round_num: int,
-    ) -> dict[str, EvaluationResult]:
-        """Evaluate survivors on the train split.
-
-        In full-dataset mode (``max_train_batch_tasks is None``) the eval set is
-        identical every round, so a survivor's cached ``train_reward`` is reused and
-        only survivors without one are evaluated. In batch mode the sampled batch
-        changes per round, so cached rewards are not comparable within a round: every
-        survivor is re-evaluated on the same freshly sampled batch.
-        """
-        if max_train_batch_tasks is None:
-            # Full-dataset mode: the eval set is identical every round, so evaluate only
-            # survivors that lack a reward and reuse each survivor's cached train reward.
-            pending = [s for s in survivors if "train" not in s.rewards]
-            evaluated: list[tuple[Candidate, EvaluationResult]] = []
-            if pending:
-                evaluated = await asyncio.gather(*[self._evaluate_agent(c, dataset, evaluator) for c in pending])
-            results = {candidate.label: result for candidate, result in evaluated}
-            for survivor in survivors:
-                if survivor.label in results:
-                    continue
-                if "train" not in survivor.rewards:
-                    continue
-                results[survivor.label] = EvaluationResult(
-                    id=f"{survivor.label}-train",
-                    aggregate_metrics=survivor.reward("train").metrics or {},
-                    trials=list(survivor.reward("train").trials or []),
-                )
-            return results
-
-        # Batch mode: the sampled batch changes per round, so a cached reward computed on
-        # a different task set is not comparable within a round. Re-evaluate every survivor
-        # on the same freshly sampled batch instead of reusing cached rewards.
-        if max_train_batch_tasks <= 0:
-            raise ValueError("max_train_batch_tasks must be positive or None")
-        all_task_ids = sorted(task.id for task in dataset.list_tasks())
-        if not all_task_ids:
-            raise ValueError(f"No train tasks found in dataset {dataset.id!r}")
-        rng = random.Random(train_batch_seed + round_num)
-        batch_size = min(max_train_batch_tasks, len(all_task_ids))
-        task_ids = sorted(rng.sample(all_task_ids, batch_size))
-        evaluated = await asyncio.gather(
-            *[self._evaluate_agent(c, dataset, evaluator, task_ids=task_ids) for c in survivors]
-        )
-        return {candidate.label: result for candidate, result in evaluated}
-
-    async def _analyze_round(
-        self,
-        *,
-        analysis_dir: Path,
-        dataset: Dataset,
-        evaluations: dict[str, EvaluationResult],
-        survivors: list[Candidate],
-        round_num: int,
-        config: EvolutionaryOptimizerConfig,
-        client: AsyncNeMoPlatform | None = None,
-        nmp_workspace: str | None = None,
-        agent_spec_path: Path | None = None,
-    ) -> str:
-        """Run AgentAnalyzer per survivor, merge analyses, persist to disk.
-
-        ``client`` and ``nmp_workspace`` are threaded into each ``AgentAnalyzer``
-        so its ``TraceAnalyzer`` can load ``intake://`` trial traces; when
-        ``None`` those traces are skipped (local ``file://`` traces still load).
-
-        Returns the merged analysis markdown string.
-        """
-        analysis_path = analysis_dir / f"round-{round_num}.md"
-        if analysis_path.exists():
-            return analysis_path.read_text()
-
-        per_agent = await asyncio.gather(
-            *[
-                AgentAnalyzer(
-                    workspace=self.working_dir,
-                    config=config.analyzer,
-                    framework_skills_dirs=self._framework_skills_dirs,
-                ).run(
-                    agent=s.label,
-                    dataset=dataset,
-                    evaluation=evaluations[s.label],
-                    round=round_num,
-                    peer_evaluations={k: v for k, v in evaluations.items() if k != s.label},
-                    client=client,
-                    nmp_workspace=nmp_workspace,
-                    agent_spec=agent_spec_path,
-                    objective_metrics=[target.model_dump() for target in config.objective_function],
-                    regression_metrics=[target.model_dump() for target in config.regression_metrics],
-                )
-                for s in survivors
-            ]
-        )
-        analysis = await self.merge_analysis(
-            survivors,
-            round_num,
-            [str(a) for a in per_agent],
-            config.objective_function,
-            config.regression_metrics,
-        )
-        analysis_path.parent.mkdir(parents=True, exist_ok=True)
-        analysis_path.write_text(analysis)
-        return analysis
-
-    async def _update_goal_tree(
-        self,
-        *,
-        analysis_dir: Path,
-        round_num: int,
-        analysis: str,
-        dataset: Dataset,
-        config: EvolutionaryOptimizerConfig,
-        agent_spec_path: Path | None = None,
-    ) -> None:
-        """Refine and persist the goal tree for round *round_num* + 1."""
-        next_goal_path = self._goal_tree_path(round_num + 1)
-        if next_goal_path.exists():
-            return
-        goal_tree_path = self._latest_goal_tree_path()
-        if goal_tree_path is None:
-            return
-        goal_config = config.goal_config
-        goal_tree = self._load_goal_tree(goal_tree_path, goal_config, context="analysis")
-        if goal_tree is None:
-            return
-        generator = GoalTreeGenerator(
-            workspace=self.working_dir, config=goal_config, framework_skills_dirs=self._framework_skills_dirs
-        )
-        updated_tree = await generator.update(goal_tree, analysis, round_num, dataset, agent_spec=agent_spec_path)
-        next_goal_path.parent.mkdir(parents=True, exist_ok=True)
-        next_goal_path.write_text(updated_tree.to_json())
-
-    async def _propose_improvements(
-        self,
-        *,
-        workspace: str,
-        backend: ExperimentalistBackend,
-        analysis: str,
-        evolution_tree: EvolutionTree,
-        round_num: int,
-        phase: Literal["exploration", "exploitation"],
-        config: EvolutionaryOptimizerConfig,
-    ) -> list[Improvement]:
-        """Run Proposer; return up to ``config.max_candidates`` Improvements."""
-        proposer = Proposer(
-            workspace=self.working_dir,
-            config=config.proposer,
-            framework_skills_dirs=self._framework_skills_dirs,
-        )
-        return await proposer.run(
-            analysis=analysis,
-            evolution_history=self._format_evolution_table(evolution_tree),
-            evolution_tree=evolution_tree,
-            round_num=round_num,
-            phase=phase,
-            max_candidates=config.max_candidates,
-            objective_metrics=[target.model_dump(mode="json") for target in config.objective_function],
-            regression_metrics=[target.model_dump(mode="json") for target in config.regression_metrics],
-        )
-
-    async def _implement_candidates(
-        self,
-        *,
-        workspace: str,
-        backend: ExperimentalistBackend,
-        dataset: Dataset,
-        evaluator: Evaluator,
-        candidates: list[Candidate],
-        config: EvolutionaryOptimizerConfig,
-    ) -> list[Candidate]:
-        """Apply proposed changes to each candidate via Coder; return the updated candidates."""
-        snapshots = {c.name: self._snapshot_metadata(c.name) for c in candidates}
-        try:
-            results = await asyncio.gather(
-                *[
-                    Coder(
-                        workspace=self.working_dir,
-                        config=self._coder_config(config),
-                        framework_skills_dirs=self._framework_skills_dirs,
-                    ).run(
-                        c,
-                        dataset,
-                        evaluator,
-                        source_path=config.source.source_path,
-                        entrypoint=config.source.entrypoint,
-                    )
-                    for c in candidates
-                ],
-                return_exceptions=True,
-            )
-        finally:
-            for c in candidates:
-                self._restore_metadata(c.name, snapshots[c.name])
-        # `return_exceptions=True` above means a build failure arrives as a value, not a
-        # raise, so the reason is only ever seen if we log it here. Keep the exception
-        # itself: "Impl failed: agent-1" with no cause is not diagnosable after the fact,
-        # and a killed candidate is the one thing a run cannot reproduce cheaply.
-        # Cancellation is not a build failure and must not be swallowed as one:
-        # `CancelledError` derives from BaseException, so the `Exception` filter below
-        # would let a cancelled candidate through as if it had built, and it would go on
-        # to be evaluated and ranked. Re-raise so the whole round unwinds instead.
-        for result in results:
-            if isinstance(result, asyncio.CancelledError):
-                raise result
-        failures = {c.name: r for c, r in zip(candidates, results, strict=True) if isinstance(r, Exception)}
-        # Persist a killed marker on failed candidates so a later resume via
-        # EvolutionTree.from_dir does not resurrect them as active survivors
-        # (a node is a survivor exactly when killed_round is None).
-        for candidate in candidates:
-            if candidate.name not in failures:
-                continue
-            error = failures[candidate.name]
-            logger.warning(
-                "Impl failed: %s — %s: %s",
-                candidate.name,
-                type(error).__name__,
-                error,
-                exc_info=error,
-            )
-            await self._update_candidate(
-                candidate,
-                workspace=workspace,
-                backend=backend,
-                run_id=candidate.run_id,
-                updates={"killed_round": candidate.round},
-            )
-        return [c for c in candidates if c.name not in failures]
-
-    async def _reward_trajectories(
-        self,
-        *,
-        workspace: str,
-        backend: ExperimentalistBackend,
-        dataset: Dataset,
-        candidates: list[Candidate],
-        config: EvolutionaryOptimizerConfig,
-        client: AsyncNeMoPlatform | None = None,
-    ) -> dict[str, dict[str, Any]]:
-        """Score candidates against the goal tree; return trajectory results keyed by candidate label."""
-        tree_path = self._latest_goal_tree_path()
-        if tree_path is None:
-            logger.info("[TRAJ] No goal tree found, skipping trajectory scoring")
-            return {}
-
-        goal_tree = self._load_goal_tree(tree_path, config.goal_config, context="trajectory scoring")
-        if goal_tree is None:
-            logger.info("[TRAJ] Invalid goal tree, skipping trajectory scoring")
-            return {}
-
-        pending = [c.label for c in candidates]
-        if len(pending) == 1:
-            logger.info("[TRAJ] Only one agent to score, skipping GRA")
-            return {}
-
-        logger.info(f"[TRAJ] Scoring {len(pending)} agents using GRA")
-
-        nodes = traverse_tree(goal_tree.root)
-        node_weights = leaf_weights_by_id(goal_tree.root)
-        traces_by_task: dict[str, dict[str, TrialResult]] = {}
-        for candidate in candidates:
-            if "validation" not in candidate.rewards:
-                continue
-            for trial in candidate.reward("validation").trials or []:
-                if trial.trace is None:
-                    continue
-                traces_by_task.setdefault(trial.task_id, {}).setdefault(candidate.label, trial)
-
-        # Only require agents that actually contributed traces; a candidate with no
-        # traces at all (e.g. its validation run failed entirely) must not cause every
-        # task to be dropped from scoring.
-        agents_with_traces = {label for task_traces in traces_by_task.values() for label in task_traces}
-        if len(agents_with_traces) < 2:
-            logger.info("[TRAJ] Fewer than two agents have traces, skipping trajectory scoring")
-            return {}
-        complete_traces = _complete_trace_groups(traces_by_task, list(agents_with_traces))
-        dropped = len(traces_by_task) - len(complete_traces)
-        if dropped:
-            logger.info(f"[TRAJ] Skipping {dropped} tasks missing traces for one or more agents")
-        traces_by_task = complete_traces
-
-        task_names = sorted(traces_by_task)
-        total_tasks = len(task_names)
-        max_tasks = config.max_trajectory_tasks
-        if max_tasks and total_tasks > max_tasks:
-            task_names = task_names[:max_tasks]
-            traces_by_task = {t: traces_by_task[t] for t in task_names}
-            logger.info(f"[TRAJ] Selected first {max_tasks}/{total_tasks} complete tasks")
-
-        if not traces_by_task:
-            logger.info("[TRAJ] No complete trace groups found, skipping")
-            return {}
-
-        scores_by_node_trial_agent: dict[str, dict[str, dict[str, dict[str, Any]]]] = defaultdict(
-            lambda: defaultdict(dict)
-        )
-        keys = [(node.id, task_id) for node in nodes for task_id in traces_by_task]
-        logger.info(f"[TRAJ] Starting {len(keys)} GRA scoring tasks...")
-
-        scorer = GroupLeafScorer(workspace=self.working_dir, client=client, nmp_workspace=workspace)
-        scoring_results = await asyncio.gather(
-            *[scorer.run(node, traces_by_task[task_id], dataset) for node in nodes for task_id in traces_by_task]
-        )
-        logger.info("[TRAJ] Scoring completed")
-        for (node_id, task_id), group_scores in zip(keys, scoring_results, strict=True):
-            for aid, gs in group_scores.items():
-                scores_by_node_trial_agent[node_id][task_id][aid] = _trajectory_detail_from_reward(gs)
-
-        trajectory_results: dict[str, dict[str, Any]] = {}
-        for aid in pending:
-            details: dict[str, dict[str, dict[str, Any]]] = {}
-            for node in nodes:
-                details[node.id] = {
-                    tid: by_agent[aid]
-                    for tid, by_agent in scores_by_node_trial_agent[node.id].items()
-                    if aid in by_agent
-                }
-            node_means = {
-                node.id: sum(item["reward"] for item in details[node.id].values()) / len(details[node.id])
-                for node in nodes
-                if details[node.id]
-            }
-            trajectory_reward = sum(node_weights[node.id] * node_means.get(node.id, 0.0) for node in nodes)
-            trajectory_results[aid] = {
-                "details": details,
-                "reward": {
-                    "aggregate": trajectory_reward,
-                    **node_means,
-                },
-            }
-            logger.info(f"[TRAJ] {aid}: trajectory_reward={trajectory_reward:.3f}")
-
-        return trajectory_results
-
-    async def _finalize(
-        self,
-        *,
-        workspace: str,
-        backend: ExperimentalistBackend,
-        agents_dir: Path,
-        run_entity: ExperimentRun,
-        evolution_tree: EvolutionTree,
-        agent_name: str,
-    ) -> Candidate | None:
-        """Select the winner, copy to workspace root, write final report."""
-        # Survivors with a validation reward, plus the baseline even if it was killed
-        # mid-loop -- finalization must still be able to decide to ship nothing.
-        eligible, baseline = finalization_pool(evolution_tree, self.config.objective_function)
-        best = select_winner_node(
-            eligible,
-            self.config.objective_function,
-            self.config.regression_metrics,
-            baseline,
-        )
-        best_id = best.label if best else None
-
-        restore_heldout_splits(self.working_dir)
-
-        if best_id is None:
-            logger.warning("[FINAL] no candidates to finalize")
-            run_entity.status = "completed"
-            await backend.update_run(workspace=workspace, run=run_entity)
-            return None
-
-        evolution_tree.mark_best(best_id)
-        self._copy_best_to_workspace(best_id)
-
-        winner = evolution_tree.nodes[best_id].candidate
-        baseline = next(
-            (node.candidate for node in evolution_tree.nodes.values() if node.round == 0),
-            None,
-        )
-        report_path = self.working_dir / "eval-and-optimize" / "OPTIMIZATION.md"
-        final_report_failed = False
-        try:
-            await self.write_final_report(best_id)
-        except Exception as exc:  # noqa: BLE001
-            logger.warning(f"[FINAL] Failed to write final report: {exc}")
-            final_report_failed = True
-        if not report_path.exists() or not report_path.read_text().strip():
-            final_report_failed = True
-        if final_report_failed:
-            summary = self._render_summary(
-                rounds_completed=run_entity.rounds_completed,
-                baseline=baseline,
-                winner=winner,
-            )
-            report_path.write_text(f"# Optimization Report\n\n## Compact Run Summary\n\n{summary}\n")
-
-        run_entity.status = "completed"
-        run_entity.winner_agent = best_id
-        await backend.update_run(workspace=workspace, run=run_entity)
-
-        return winner
-
-    def _render_summary(
-        self,
-        rounds_completed: int,
-        baseline: Candidate | None,
-        winner: Candidate | None,
-    ) -> str:
-        """Render a human-readable summary of the run outcome."""
-        winner_str = winner.name if winner else "none"
-        details: list[str] = []
-        if winner:
-            if winner.reward("validation").metrics:
-                details.append(f"validation_metrics={winner.reward('validation').metrics}")
-        suffix = f", {', '.join(details)}" if details else ""
-        return f"Optimization complete: {rounds_completed} round(s) completed, winner={winner_str}{suffix}"
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/models.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/models.py
index 5dc6964e14..c4ffe2eb8d 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/models.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/models.py
@@ -10,12 +10,10 @@
 
 from __future__ import annotations
 
-import json
 from collections.abc import Callable, Iterable
-from pathlib import Path
 from typing import Literal, TypeVar
 
-from nemo_experimentalist_plugin.entities import Candidate
+from nemo_experimentalist_plugin.entities import Candidate, MetricTarget
 from pydantic import BaseModel
 
 # ---------------------------------------------------------------------------
@@ -132,32 +130,35 @@ def ancestor(self) -> str | None:
         return self.candidate.ancestor
 
     @property
-    def round(self) -> int:
-        return self.candidate.round
+    def generation(self) -> int:
+        return self.candidate.generation
 
     @property
     def optimization_type(self) -> str | None:
-        return self.candidate.optimization_type
+        """The kind of change this candidate's Proposal asked for, when it had one."""
+        origin = self.candidate.generated_from
+        value = origin.payload.get("optimization_type") if origin is not None else None
+        return value if isinstance(value, str) else None
 
     @property
-    def optimization(self) -> str:
-        return self.candidate.optimization
+    def description(self) -> str:
+        return self.candidate.description
 
     @property
     def train_reward(self) -> dict[str, float]:
-        return self.candidate.reward("train").metrics or {}
+        return self.candidate.rewards["train"].metrics or {}
 
     @property
     def val_reward(self) -> dict[str, float]:
-        return self.candidate.reward("validation").metrics or {}
+        return self.candidate.rewards["validation"].metrics or {}
 
     @property
     def trajectory_reward(self) -> dict[str, float]:
-        return self.candidate.reward("validation-trajectory").metrics or {}
+        return self.candidate.rewards["validation-trajectory"].metrics or {}
 
     @property
     def is_survivor(self) -> bool:
-        return self.candidate.killed_round is None
+        return self.candidate.killed_generation is None
 
     @property
     def reward_str(self) -> str:
@@ -183,50 +184,51 @@ def __init__(self) -> None:
         self._children: dict[str, list[str]] = {}
 
     @classmethod
-    def from_dir(cls, agents_dir: Path) -> EvolutionTree:
-        """Rebuild the full tree from agent directories on disk."""
+    def from_candidates(cls, candidates: Iterable[Candidate]) -> EvolutionTree:
+        """Rebuild the full tree from the run's persisted candidates.
+
+        The tree is a view over stored entities, not over a directory layout — which
+        is what lets a strategy resume without checkpointing its population.
+        """
         tree = cls()
-        if not agents_dir.exists():
-            return tree
-        for agent_dir in sorted(agents_dir.iterdir()):
-            meta_path = agent_dir / "metadata.json"
-            if not agent_dir.is_dir() or not meta_path.exists():
-                continue
-            try:
-                meta = json.loads(meta_path.read_text())
-            except (json.JSONDecodeError, OSError):
-                continue
-            candidate = Candidate.model_validate(meta)
-            entity_id = meta.get("id", "")
-            if entity_id:
-                candidate._id = entity_id  # type: ignore[attr-defined]
+        for candidate in candidates:
             tree.add(candidate)
         return tree
 
-    def survivors(self, max_round: int | None = None) -> list[Candidate]:
-        """Return alive candidates up to *max_round* (or all if None)."""
+    def survivors(self, max_generation: int | None = None) -> list[Candidate]:
+        """Return alive candidates up to *max_generation* (or all if None)."""
         return [
-            n.candidate for n in self.nodes.values() if n.is_survivor and (max_round is None or n.round <= max_round)
+            n.candidate
+            for n in self.nodes.values()
+            if n.is_survivor and (max_generation is None or n.generation <= max_generation)
         ]
 
     def add(self, candidate: Candidate) -> EvolutionNode:
-        """Add or update a candidate in the tree."""
-        if candidate.label in self.nodes:
-            node = self.nodes[candidate.label]
+        """Add or update a candidate in the tree, keyed by its durable id."""
+        key = candidate.id or candidate.label
+        if key in self.nodes:
+            node = self.nodes[key]
             node.candidate = candidate
             return node
         node = EvolutionNode(candidate=candidate)
-        self.nodes[candidate.label] = node
-        parent_key = candidate.ancestor or "__root__"
-        self._children.setdefault(parent_key, []).append(candidate.label)
+        self.nodes[key] = node
+        self._children.setdefault(candidate.ancestor or "__root__", []).append(key)
         return node
 
-    def mark_best(self, label: str) -> None:
-        """Designate the node with *label* as the best, clearing all other best flags."""
+    def mark_best(self, key: str) -> None:
+        """Designate the node under *key* as the best, clearing all other best flags.
+
+        *key* is a candidate id, which is what :meth:`add` files nodes under. Raising on
+        an unknown key is deliberate: a display label would otherwise no-op silently.
+
+        Raises:
+            KeyError: if no node is filed under *key*.
+        """
+        if key not in self.nodes:
+            raise KeyError(f"No candidate {key!r} in the evolution tree; keys are candidate ids")
         for node in self.nodes.values():
             node.is_best = False
-        if label in self.nodes:
-            self.nodes[label].is_best = True
+        self.nodes[key].is_best = True
 
     def get_best(self) -> list[EvolutionNode]:
         """Return the Pareto-optimal nodes by validation reward."""
@@ -250,27 +252,24 @@ def to_markdown_table(self) -> str:
         for channel in channels:
             dimensions[channel].sort()
 
-        fixed = ["round", "agent", "ancestor", "type"]
+        fixed = ["gen", "agent", "ancestor", "type"]
         reward_cols = [(channel, dimension) for channel in channels for dimension in dimensions[channel]]
-        all_cols = fixed + [f"{channel}:{dimension}" for channel, dimension in reward_cols] + ["optimization"]
+        all_cols = fixed + [f"{channel}:{dimension}" for channel, dimension in reward_cols] + ["description"]
         header = "| " + " | ".join(all_cols) + " |"
         sep = "| " + " | ".join("---" for _ in all_cols) + " |"
         lines = [header, sep]
 
-        for label in sorted(
-            self.nodes.keys(),
-            key=lambda x: int(x.split("-")[1]) if x.split("-")[-1].isdigit() else 0,
-        ):
-            n = self.nodes[label]
+        for key in sorted(self.nodes, key=lambda k: (self.nodes[k].generation, self.nodes[k].label)):
+            n = self.nodes[key]
             reward_vals = []
             for channel, dimension in reward_cols:
-                metrics = n.candidate.reward(channel).metrics
+                metrics = n.candidate.rewards[channel].metrics
                 reward_vals.append(f"{metrics[dimension]:.2f}" if dimension in metrics else "-")
-            opt = (n.optimization or "")[:50].replace("\n", " ")
+            opt = (n.description or "")[:50].replace("\n", " ")
             cells = [
-                str(n.round),
+                str(n.generation),
                 n.label,
-                n.ancestor or "-",
+                self._ancestor_label(n) or "-",
                 n.optimization_type or "-",
             ]
             cells += [*reward_vals, opt]
@@ -288,10 +287,17 @@ def __repr__(self) -> str:
             lines.extend(self._build_tree_lines(root_id, "", i == len(roots) - 1))
         return "\n".join(lines)
 
+    def _ancestor_label(self, node: EvolutionNode) -> str | None:
+        """The ancestor's display handle, since ``ancestor`` is an id."""
+        if node.ancestor is None:
+            return None
+        parent = self.nodes.get(node.ancestor)
+        return parent.label if parent is not None else node.ancestor
+
     def _render_node(self, node: EvolutionNode) -> str:
         opt_type = f"[{node.optimization_type}]" if node.optimization_type else ""
-        opt_desc = (node.optimization or "")[:40].replace("\n", " ")
-        if opt_desc and len(node.optimization) > 40:
+        opt_desc = (node.description or "")[:40].replace("\n", " ")
+        if opt_desc and len(node.description) > 40:
             opt_desc += "..."
         markers = (" *BEST*" if node.is_best else "") + (" [S]" if node.is_survivor else "")
         return f"{node.label} ({node.reward_str}){markers} {opt_type} {opt_desc}".strip()
@@ -308,3 +314,23 @@ def _build_tree_lines(self, label: str, prefix: str = "", is_last: bool = True)
         for i, child_id in enumerate(sorted(children)):
             lines.extend(self._build_tree_lines(child_id, child_prefix, i == len(children) - 1))
         return lines
+
+
+def pareto_objectives(metrics: dict[str, float], objective_function: list[MetricTarget]) -> dict[str, float]:
+    """Project evaluator metrics onto the configured objectives for Pareto ranking.
+
+    The generic Pareto utility maximizes every dimension. Minimized objective
+    values are sign-inverted here; regression metrics are intentionally absent.
+    """
+    objectives: dict[str, float] = {}
+    for target in objective_function:
+        value = metrics.get(target.name)
+        if value is None:
+            return {}
+        objectives[target.name] = float(value) if target.direction == "maximize" else -float(value)
+    return objectives
+
+
+def has_metric_dimensions(metrics: dict[str, float], targets: list[MetricTarget]) -> bool:
+    """Return whether an evaluator result contains every required metric target."""
+    return all(target.name in metrics for target in targets)
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/proposer.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/proposer.py
index 331bd28459..514c73b830 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/proposer.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/proposer.py
@@ -3,10 +3,11 @@
 
 import logging
 from pathlib import Path
-from typing import Any, Literal, get_args
+from typing import Any, ClassVar, Literal, cast, get_args
 
+from nemo_experimentalist_plugin.entities import Candidate, MetricTarget, Proposal, local_path_from_uri
+from nemo_experimentalist_plugin.experimentalist import roles
 from nemo_experimentalist_plugin.experimentalist.components.models import (
-    EvolutionTree,
     OptimizationType,
 )
 from nemo_platform_plugin.nooa_model_client import get_default_model, get_fast_model
@@ -25,10 +26,19 @@
 logger = logging.getLogger(__name__)
 
 
-class Improvement(BaseModel):
-    """A proposed single-change improvement for a specific ancestor agent."""
+#: What this Proposer produces and the built-in CodeEditBuilder accepts. An opaque
+#: discriminator, not a global enumeration — it only has to match a Builder.
+CODE_CHANGE = "code-change"
+
+
+class CodeChange(BaseModel):
+    """The ``code-change`` payload schema, owned by this Proposer and the CodeEditBuilder.
+
+    Nothing here belongs on ``Candidate``: it is what the Builder was *asked* to
+    produce, which the committed Candidate keeps as ``generated_from`` provenance
+    alongside the artifact it actually produced.
+    """
 
-    ancestor: str
     root_cause: str = Field(
         min_length=1,
         description=(
@@ -37,6 +47,22 @@ class Improvement(BaseModel):
             "Do not mention the proposed change or any remedy here."
         ),
     )
+    optimization_type: OptimizationType
+    task_ids: list[str] = Field(
+        default_factory=list,
+        description=(
+            "Task ids from the analysis that most directly exercise this root cause — "
+            "the concrete tasks the agent fails (or barely passes) for this reason. "
+            "The coder uses these to validate the fix, so pick tasks whose failure "
+            "evidence in the analysis is caused by `root_cause`. 2-3 is typical."
+        ),
+    )
+
+
+class Improvement(BaseModel):
+    """One proposed change, as the LLM returns it, before it becomes a Proposal."""
+
+    ancestor: str = Field(description="Candidate id to branch from.")
     optimization: str = Field(
         min_length=1,
         description=(
@@ -45,17 +71,33 @@ class Improvement(BaseModel):
             "Must NOT reference source file paths, line numbers, or implementation details."
         ),
     )
+    root_cause: str = Field(
+        min_length=1,
+        description=(
+            "The diagnosed cause of poor performance from the analysis — WHY the agent fails, "
+            "not what would fix it. Must complete: 'The agent underperforms because...' "
+            "Do not mention the proposed change or any remedy here."
+        ),
+    )
     optimization_type: OptimizationType
     task_ids: list[str] = Field(
         default_factory=list,
-        description=(
-            "Task ids from the analysis that most directly exercise this root cause — "
-            "the concrete tasks the agent fails (or barely passes) for this reason. "
-            "The coder uses these to validate the fix, so pick tasks whose failure "
-            "evidence in the analysis is caused by `root_cause`. 2-3 is typical."
-        ),
+        description="Task ids whose failure evidence is caused by `root_cause`.",
     )
 
+    def as_proposal(self) -> Proposal:
+        """The Layer A message a Builder receives, with this pair's payload inside it."""
+        return Proposal(
+            ancestor=self.ancestor,
+            description=self.optimization,
+            kind=CODE_CHANGE,
+            payload=CodeChange(
+                root_cause=self.root_cause,
+                optimization_type=self.optimization_type,
+                task_ids=self.task_ids,
+            ).model_dump(),
+        )
+
 
 class ProposerConfig(BaseModel):
     """Configuration for Proposer tuning parameters."""
@@ -66,18 +108,27 @@ class ProposerConfig(BaseModel):
     )
 
 
-class Proposer(Agent):
+class CodeChangeProposer(Agent, roles.Proposer):
     """Propose the next round's isolated optimization candidates."""
 
+    config_type = ProposerConfig
+
+    name = "code-change"
+    produces: ClassVar[frozenset[str]] = frozenset({CODE_CHANGE})
+
     def __init__(
         self,
         workspace: Path,
         config: ProposerConfig | None = None,
         framework_skills_dirs: list[Path] | None = None,
+        objective_metrics: list[MetricTarget] | None = None,
+        regression_metrics: list[MetricTarget] | None = None,
         **kwargs: Any,
     ):
         super().__init__(llm=kwargs.pop("llm", None) or get_default_model(), **kwargs)
         self._config = config or ProposerConfig()
+        self._objective_metrics = objective_metrics or []
+        self._regression_metrics = regression_metrics or []
         self._workspace_path = workspace.resolve()
         self.workspace = WorkspaceTool(workspace=self._workspace_path)
         self.context["workspace_tool_documentation"] = doc(WorkspaceTool)
@@ -93,62 +144,72 @@ def __init__(
             config=TokenBudgetConfig(max_tokens=self._config.max_summary_tokens),
         )
 
+    @staticmethod
+    def _evolution_table(candidates: list[Candidate]) -> str:
+        """Render the population as the markdown table the prompt reads."""
+        if not candidates:
+            return "(none yet — this is the first round)"
+        rows = ["| agent | generation | ancestor | validation reward |", "| --- | --- | --- | --- |"]
+        for c in sorted(candidates, key=lambda c: (c.generation, c.label)):
+            reward = c.rewards["validation"].metrics or {}
+            ancestor = next((o.label for o in candidates if o.id == c.ancestor), "—")
+            rows.append(f"| {c.label} | {c.generation} | {ancestor} | {reward or '—'} |")
+        return "\n".join(rows)
+
     async def run(
         self,
+        *,
         analysis: str,
-        evolution_history: str,
-        evolution_tree: EvolutionTree,
+        candidates: list[Candidate],
         round_num: int,
-        phase: Literal["exploration", "exploitation"],
         max_candidates: int,
-        objective_metrics: list[dict[str, Any]],
-        regression_metrics: list[dict[str, Any]],
-    ) -> list[Improvement]:
+        hint: str | None = None,
+    ) -> list[Proposal]:
         """Return up to max_candidates targeted improvement proposals.
 
         Args:
             analysis: merged round analysis markdown with root causes already enumerated.
-            evolution_history: markdown table of prior rounds for context.
-            evolution_tree: live tree used to derive survivors and tried optimization types.
-            round_num: current optimization round number; used to filter survivors.
-            phase: "exploration" for novel directions, "exploitation" to refine the best.
-            max_candidates: maximum number of Improvement objects to return.
-            objective_metrics: Evaluator metric dimensions this round must improve.
-            regression_metrics: Evaluator metric dimensions this round must preserve.
+            candidates: the scored population to propose against; lineage is on each one.
+            round_num: the round these Proposals are for.
+            max_candidates: maximum number of Proposals to return.
+            hint: optional steer from the strategy, e.g. to explore rather than refine.
 
         Returns:
-            list[Improvement]: up to max_candidates targeted improvement proposals.
+            list[Proposal]: up to max_candidates build requests, each routed to a
+            Builder by its ``kind``.
 
         """
         all_types = set(get_args(OptimizationType))
         tried_types = sorted(
             {
-                n.optimization_type
-                for n in evolution_tree.nodes.values()
-                if n.optimization_type and n.optimization_type in all_types
+                kind
+                for c in candidates
+                if (kind := (c.generated_from.payload or {}).get("optimization_type")) in all_types
             }
         )
         available_types = sorted(all_types - set(tried_types))
-        proposal_survivors = evolution_tree.survivors(round_num)
+        proposal_survivors = [c for c in candidates if c.killed_generation is None]
 
-        agents_dir = self._workspace_path / "eval-and-optimize" / "agents"
         survivor_context: list[dict[str, Any]] = []
         for s in proposal_survivors:
-            arch_path = agents_dir / s.label / "architecture.md"
-            try:
-                arch_text = arch_path.read_text()
-            except OSError:
-                arch_text = f"(architecture.md missing for {s.label})"
+            # Through the artifact the record addresses, never `agents/<label>/`: the
+            # label is a display handle and nothing may derive storage from it.
+            arch_text = f"(architecture.md missing for {s.label})"
+            meta: dict[str, Any] = {}
             try:
                 candidate = self.workspace.get_metadata(s.label)
                 meta = candidate.slim().model_dump()
-            except Exception:  # noqa: BLE001
-                meta = {}
+                artifact = local_path_from_uri(candidate.artifact.uri)
+                artifact = artifact if artifact.is_dir() else artifact.parent
+                arch_text = (artifact / "architecture.md").read_text()
+            except Exception:  # noqa: BLE001 - a survivor without a readable doc is still proposable
+                pass
             survivor_context.append(
                 {
-                    "id": s.label,
-                    "metrics": s.reward("validation").metrics or {},
-                    "trajectory_reward": s.reward("validation-trajectory").metrics or {},
+                    "id": s.id,
+                    "label": s.label,
+                    "reward": s.rewards["validation"].metrics or {},
+                    "trajectory_reward": s.rewards["validation-trajectory"].metrics or {},
                     "metadata": meta,
                     "architecture": arch_text,
                 }
@@ -156,41 +217,78 @@ async def run(
 
         improvements = await self._run_with_context(
             analysis=analysis,
-            evolution_history=evolution_history,
+            evolution_history=self._evolution_table(candidates),
             tried_types=tried_types,
             available_types=available_types,
             survivors=survivor_context,
             cards_index=doc(self.optimize),
-            phase=phase,
+            phase=cast("Literal['exploration', 'exploitation']", hint or "exploration"),
             max_candidates=max_candidates,
-            objective_metrics=objective_metrics,
-            regression_metrics=regression_metrics,
+            objective_metrics=[t.model_dump() for t in self._objective_metrics],
+            regression_metrics=[t.model_dump() for t in self._regression_metrics],
         )
-        # allowed_types is every type, not just the untried ones. available_types
-        # still reaches the prompt, so novelty stays a *preference*: a type that
-        # worked in an earlier round can be used again when it is the right tool.
-        return self._filter_improvements(
-            improvements=improvements,
-            max_candidates=max_candidates,
+        # allowed_types is every type, not just the untried ones (#1163). available_types
+        # still reaches the prompt, so novelty stays a *preference*: a type that worked in
+        # an earlier round can be used again when it is the right tool.
+        usable = self._usable_improvements(
+            improvements,
+            known_ancestors={c.id for c in proposal_survivors},
             allowed_types=all_types,
         )
+        kept = self._validate_improvements(improvements=usable, max_candidates=max_candidates)
+        return [improvement.as_proposal() for improvement in kept]
 
     @staticmethod
-    def _filter_improvements(
-        *,
-        improvements: list[Improvement],
-        max_candidates: int,
-        allowed_types: set[str],
+    def _usable_improvements(
+        improvements: list[Improvement], *, known_ancestors: set[str], allowed_types: set[str]
     ) -> list[Improvement]:
-        """Return at most ``max_candidates`` usable improvements, dropping the rest.
+        """Keep the improvements a Builder could actually build, dropping the rest.
 
-        An improvement is dropped when its ``optimization_type`` is outside
-        ``allowed_types`` or its optimization text repeats one already kept; a
-        repeated ``optimization_type`` is fine. Every drop is logged, so a Proposer
-        emitting consistently unusable output cannot look healthy.
+        Two ways a model gets this wrong, and neither is worth a run. ``ancestor`` is a
+        candidate id while survivors carry both id and label, so a plausible "agent-2" is
+        exactly what comes back. And ``optimization_type`` has twenty valid values, so a
+        near-miss like "edit_method" for "edit_concrete_method" is equally likely.
 
-        Raises:
-            ValueError: if no usable improvement remains, which leaves nothing to build.
+        Both checks run *after* the CodeAct loop, so raising buys no retry: it unwinds
+        through the strategy and ends a run that has already spent hours. Same policy as
+        the Builder — one bad proposal is not a bad round.
+        """
+        usable: list[Improvement] = []
+        for improvement in improvements:
+            if improvement.ancestor not in known_ancestors:
+                logger.warning(
+                    "Dropping a proposal whose ancestor %r is not a survivor id (%s): %s",
+                    improvement.ancestor,
+                    sorted(known_ancestors),
+                    improvement.optimization,
+                )
+            elif improvement.optimization_type not in allowed_types:
+                logger.warning(
+                    "Dropping a proposal with unusable optimization_type %r (allowed: %s): %s",
+                    improvement.optimization_type,
+                    sorted(allowed_types),
+                    improvement.optimization,
+                )
+            else:
+                usable.append(improvement)
+        if improvements and not usable:
+            raise ValueError(
+                f"None of the Proposer's {len(improvements)} improvements were usable: every one named "
+                f"an ancestor outside {sorted(known_ancestors)} or a type outside {sorted(allowed_types)}"
+            )
+        return usable
+
+    @staticmethod
+    def _validate_improvements(*, improvements: list[Improvement], max_candidates: int) -> list[Improvement]:
+        """Reject a batch that is malformed as a whole, and return the ones worth building.
+
+        Deduplicates by optimization text and truncates to the round's budget — the cut
+        falls on the kept list, since a surplus improvement past it may be the only
+        usable one.
+
+        A repeated ``optimization_type`` is fine (#1163): there are twenty of them and
+        two genuinely different changes to the same method share one, so it is not
+        evidence of a malformed batch. Duplicate *text* is, and is dropped below.
         """
         if not improvements:
             raise ValueError("Proposer returned no improvements")
@@ -198,15 +296,6 @@ def _filter_improvements(
         kept: list[Improvement] = []
         seen_descriptions: set[str] = set()
         for improvement in improvements:
-            optimization_type = improvement.optimization_type
-            if optimization_type not in allowed_types:
-                logger.warning(
-                    "dropping improvement with disallowed optimization_type %r; allowed: %s",
-                    optimization_type,
-                    sorted(allowed_types),
-                )
-                continue
-
             description = improvement.optimization.strip()
             if description in seen_descriptions:
                 logger.warning("dropping improvement with duplicate optimization text: %r", description)
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/selector.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/selector.py
index 2b904de9e5..13261994bf 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/selector.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/selector.py
@@ -1,36 +1,146 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-"""The reasoning component that selects a diverse survivor set."""
+"""Which candidates breed, and which one wins."""
 
-from __future__ import annotations
-
-from pathlib import Path
 from typing import Any
 
-from nemo_experimentalist_plugin.config import MetricTarget
-from nemo_experimentalist_plugin.entities import Candidate
-from nemo_experimentalist_plugin.experimentalist.components.tools import WorkspaceTool
-from nemo_platform_plugin.nooa_model_client import get_default_model
+from nemo_experimentalist_plugin.entities import Candidate, MetricTarget
+from nemo_experimentalist_plugin.experimentalist import roles
+from nemo_experimentalist_plugin.experimentalist.components.models import (
+    has_metric_dimensions,
+    pareto_front,
+    pareto_objectives,
+    pareto_sort,
+)
+from nemo_platform_plugin.nooa_model_client import get_default_model, get_fast_model
 from nooa import Agent, CodeActStrategy, strategy
+from nooa.agents import TokenBudgetSummarizer
 from nooa.config import CodeActConfig
+from nooa.config.summarizer_config import TokenBudgetConfig
+from pydantic import BaseModel, Field
+
+
+class SelectorConfig(BaseModel):
+    """Tuning parameters for survivor selection."""
+
+    max_summary_tokens: int = Field(default=80_000, description="Max tokens the token-budget summarizer may use.")
+    objectives: list[str] = Field(
+        default_factory=lambda: ["validation"],
+        description=(
+            "Reward channels ranked on. Selection policy lives here rather than on the "
+            "entity: 'insight rewards must never feed Pareto selection' is a selector "
+            "concern, and a flag on the channel would be wrong for anyone ranking on train."
+        ),
+    )
 
 
-class SurvivorSelector(Agent):
-    """Select survivors from a Pareto-ranked population."""
+# Selection is two questions, and only the first needs a model: Pareto ranking is
+# arithmetic over reward channels, while choosing among incomparable candidates inside one
+# front is a judgement about architectural diversity. Splitting them is what lets a
+# numeric strategy reuse the ranking and skip the model entirely.
+class ParetoDiversitySelector(Agent, roles.Selector):
+    """Pareto-rank on the configured objectives, then pick diverse survivors with a model."""
 
-    def __init__(self, workspace: Path, **kwargs: Any) -> None:
+    config_type = SelectorConfig
+
+    name = "pareto-diversity"
+
+    def __init__(
+        self,
+        config: SelectorConfig | None = None,
+        objective_metrics: list[MetricTarget] | None = None,
+        regression_metrics: list[MetricTarget] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the selector."""
         super().__init__(llm=kwargs.pop("llm", None) or get_default_model(), **kwargs)
-        self.workspace = WorkspaceTool(workspace=workspace)
+        self._config = config or SelectorConfig()
+        self._objective_metrics = objective_metrics or [MetricTarget(name="reward", direction="maximize")]
+        self._regression_metrics = regression_metrics or []
+        TokenBudgetSummarizer.install(
+            self, llm=get_fast_model(), config=TokenBudgetConfig(max_tokens=self._config.max_summary_tokens)
+        )
+
+    def rank(self, candidates: list[Candidate]) -> list[Candidate]:
+        """Sort by non-domination rank over the configured objectives."""
+        return pareto_sort(candidates, self._objectives_of)
+
+    async def survivors(self, candidates: list[Candidate], *, k: int) -> list[Candidate]:
+        """Up to *k* candidates to carry into the next round as parents."""
+        return await self.select_diverse_survivors(self.rank(candidates), k)
+
+    def winner(self, candidates: list[Candidate]) -> Candidate | None:
+        """The run's winner, or None when nothing carries a comparable measurement.
+
+        Finalization asks a different question from survivor selection. `survivors` is
+        told to keep a candidate created this round, and the generation-0 baseline never
+        is one, so a baseline can be killed mid-loop. But "is any of this better than
+        shipping nothing?" has to be able to answer *no*, so the baseline is re-admitted
+        here regardless, and anchors the regression comparison even when it does not win.
+
+        A candidate that worsens a `regression_metrics` target against that baseline is
+        dropped before ranking, so a gain on the objectives cannot pay for a regression.
+        Ties go to the oldest candidate: equal score means the diff bought nothing.
+        """
+        measured = [c for c in candidates if has_metric_dimensions(self._ranked_metrics(c), self._objective_metrics)]
+        baseline = next((c for c in measured if c.generation == 0), None)
+        eligible = [c for c in measured if c.killed_generation is None]
+        if baseline is not None and all(c is not baseline for c in eligible):
+            eligible.insert(0, baseline)
+        if not eligible:
+            return None
+        reference = baseline if baseline is not None else min(eligible, key=self._creation_order)
+        kept = [c for c in eligible if not self._regresses(c, reference)]
+        front = pareto_front(kept or eligible, self._objectives_of)
+        return min(front, key=self._creation_order) if front else None
+
+    def _objectives_of(self, candidate: Candidate) -> dict[str, float]:
+        """The candidate's ranked metrics projected onto the objectives.
+
+        Ranking is uniformly "higher is better", so a minimized target is negated and
+        anything outside the objectives is dropped — a protected metric must not sway
+        the front, only disqualify through :meth:`_regresses`.
+        """
+        return pareto_objectives(self._ranked_metrics(candidate), self._objective_metrics)
+
+    def _regresses(self, candidate: Candidate, baseline: Candidate) -> bool:
+        """Whether *candidate* is worse than *baseline* on a metric that must not regress.
+
+        A target missing from either side is skipped: absent evidence is not a regression.
+        """
+        if candidate is baseline:
+            return False
+        before, after = self._ranked_metrics(baseline), self._ranked_metrics(candidate)
+        for target in self._regression_metrics:
+            was, now = before.get(target.name), after.get(target.name)
+            if was is None or now is None:
+                continue
+            if now < was if target.direction == "maximize" else now > was:
+                return True
+        return False
+
+    @staticmethod
+    def _creation_order(candidate: Candidate) -> tuple[int, int, str]:
+        """Order by creation, independently of how the caller ordered the list.
+
+        Labels are run-scoped and handed out in sequence (``agent-0``, ``agent-1``, ...),
+        so the numeric suffix recovers creation order within a generation. The label
+        itself is the final component, keeping the key total if a label ever stops
+        matching that shape.
+        """
+        _, _, suffix = candidate.label.rpartition("-")
+        return (candidate.generation, int(suffix) if suffix.isdigit() else 0, candidate.label)
+
+    def _ranked_metrics(self, candidate: Candidate) -> dict[str, float]:
+        """The metrics this selector ranks on, merged across its objective channels."""
+        merged: dict[str, float] = {}
+        for channel in self._config.objectives:
+            merged.update(candidate.rewards[channel].metrics or {})
+        return merged
 
     @strategy(CodeActStrategy(config=CodeActConfig(max_iterations=100, cell_timeout=3600.0)))
-    async def select(
-        self,
-        ranked: list[Candidate],
-        k: int,
-        objective_metrics: list[MetricTarget],
-        regression_metrics: list[MetricTarget],
-    ) -> list[Candidate]:  # pyright: ignore[reportReturnType]
+    async def select_diverse_survivors(self, ranked: list[Candidate], k: int) -> list[Candidate]:  # pyright: ignore[reportReturnType]
         """Choose up to k survivors from Pareto-ranked candidates.
 
         ``ranked`` is already Pareto-sorted using outcome and trajectory scores:
@@ -39,28 +149,16 @@ async def select(
         changes, complementary task coverage, and different trajectory strengths.
 
         To avoid getting stuck on the same agents round after round:
-        1. Always include at least 1 candidate that was newly created this round. Look up
-           `self.workspace.get_metadata(c.name)["round"]` for each candidate; new candidates
-           are the ones whose round equals the max round across `ranked`.
-        2. Prefer candidates with different optimization_type values or that address different root causes.
-        3. If all new candidates sit on a worse Pareto front, still include the best new candidate.
-
-        ## MANDATORY: Prefer agents with complementary strengths
-
-        Read each candidate's per-dimension validation rewards from metadata and
-        prefer a set whose strong dimensions cover each other (one agent leads on
-        dimensions where another trails):
-
-        ```python
-        rewards = {c.id: self.workspace.get_metadata(c.name).reward("validation").metrics or {} for c in ranked}
-        ```
-
-        Between 1 to 3 survivors per round.
-        Return the selected subset, preserving the input's Pareto-front order.
+        - Always include at least one candidate created this round — the ones whose
+          `generation` equals the highest across `ranked`. If every new candidate sits on
+          a worse Pareto front, still take the best of them.
+        - Prefer candidates with different `optimization_type` values, or that address
+          different root causes.
+        - Prefer a mix of recent and older lineages over k agents from one branch.
+        - Prefer an agent whose failures differ from the others already chosen.
+        - Read each candidate's `description` and `generated_from` to tell what
+          actually changed; two agents with near-identical changes are one choice.
 
-        ``objective_metrics`` are the evaluator metric dimensions to improve.
-        ``regression_metrics`` are evaluator metric dimensions that must not
-        worsen. Use their reported values as evidence; do not invent formulas,
-        weights, thresholds, or another mechanical selection rule.
+        Return exactly the candidates you choose, in preference order, at most k.
         """
         ...
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/terminator.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/terminator.py
index 46344d68b9..de3fe6267e 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/terminator.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/terminator.py
@@ -14,15 +14,13 @@
 import logging
 from typing import Any
 
-# Imported from `resolve` rather than `.loop`, which merely re-exports it: `loop` imports
-# this module, so going through it would be circular.
-from nemo_experimentalist_plugin.config import (
-    EvolutionaryOptimizerConfig,
-    MetricTarget,
+from nemo_experimentalist_plugin.entities import Candidate, MetricTarget
+from nemo_experimentalist_plugin.experimentalist import roles
+from nemo_experimentalist_plugin.experimentalist.components.models import (
     has_metric_dimensions,
+    pareto_front,
     pareto_objectives,
 )
-from nemo_experimentalist_plugin.experimentalist.components.models import EvolutionTree, pareto_front
 from nemo_experimentalist_plugin.skills import skills_dir
 from nemo_platform_plugin.nooa_model_client import get_fast_model
 from nooa import Agent, CodeActStrategy, TextSkill, hidden, strategy
@@ -33,6 +31,16 @@
 logger = logging.getLogger(__name__)
 
 
+class TerminatorConfig(BaseModel):
+    """Tuning parameters for early stopping.
+
+    ``min_rounds_before_stopping`` is deliberately absent: it sits on the run config
+    beside ``max_rounds``, and reaches this component through the constructor, the same
+    way the objective and regression targets do. Two homes for one value is what made it
+    silently ignorable.
+    """
+
+
 class TerminationDecision(BaseModel):
     """Structured result of a termination assessment.
 
@@ -45,11 +53,27 @@ class TerminationDecision(BaseModel):
     reason: str = ""
 
 
-class Terminator(Agent):
+class ConvergenceTerminator(Agent, roles.Terminator):
     """Decides when the evolutionary optimization loop should stop."""
 
-    def __init__(self, **kwargs: Any) -> None:
+    config_type = TerminatorConfig
+
+    name = "convergence"
+
+    def __init__(
+        self,
+        *,
+        config: TerminatorConfig | None = None,
+        min_rounds_before_stopping: int = 3,
+        objective_metrics: list[MetricTarget] | None = None,
+        regression_metrics: list[MetricTarget] | None = None,
+        **kwargs: Any,
+    ) -> None:
         super().__init__(llm=kwargs.pop("llm", None) or get_fast_model(), **kwargs)
+        self._config = config or TerminatorConfig()
+        self._min_rounds_before_stopping = min_rounds_before_stopping
+        self._objective_metrics = objective_metrics or [MetricTarget(name="reward", direction="maximize")]
+        self._regression_metrics = regression_metrics or []
         self.terminator_skill = TextSkill(path=skills_dir() / "terminator")
 
     @hidden
@@ -57,165 +81,123 @@ async def run(
         self,
         *,
         round_num: int,
-        evolution_tree: EvolutionTree,
-        prior_analysis: str | None,
-        config: EvolutionaryOptimizerConfig,
+        candidates: list[Candidate],
+        prior_analysis: str | None = None,
     ) -> TerminationDecision:
         """Canonical termination decision, consulted once per round at the top of the loop.
 
-        Stops when the round budget is exhausted; otherwise stops when the
-        optimization has converged. Composes :meth:`assess_round_budget` and
-        :meth:`assess_convergence` (budget first — it is cheap and deterministic,
-        so an exhausted budget avoids the qualitative LLM call).
+        Early stopping only: the round budget belongs to the loop, so a terminator that
+        never stops still cannot produce an unbounded run.
 
         Args:
             round_num: Rounds completed so far.
-            evolution_tree: Live tree of scored candidates across rounds.
+            candidates: The scored population; convergence is judged from their rewards.
             prior_analysis: Markdown analysis from the previous round, if any.
-            config: Active optimizer config (read-only).
 
         Returns:
             A :class:`TerminationDecision`.
         """
-        reached = self.assess_objective_reached(evolution_tree=evolution_tree, config=config)
+        reached = self.assess_objective_reached(candidates)
         if reached.stop:
             return reached
-        budget = self.assess_round_budget(round_num=round_num, config=config)
-        if budget.stop:
-            return budget
-        return await self.assess_convergence(
-            evolution_tree=evolution_tree,
-            prior_analysis=prior_analysis,
-            config=config,
-        )
+        return await self.assess_convergence(candidates=candidates, prior_analysis=prior_analysis)
 
     @hidden
-    def assess_objective_reached(
-        self,
-        *,
-        evolution_tree: EvolutionTree,
-        config: EvolutionaryOptimizerConfig,
-    ) -> TerminationDecision:
-        """Stop when a candidate that could win already satisfies every targeted objective.
+    def assess_objective_reached(self, candidates: list[Candidate]) -> TerminationDecision:
+        """Stop when a live candidate already satisfies every targeted objective.
 
         Convergence asks whether progress has stalled; this asks whether any is left to
-        make. Not gated by ``disable_convergence_check``: that disables a judgement about
-        stagnation, this is a threshold the caller stated. To keep going, set no target.
-
-        Consulted before every round, so a baseline that already qualifies costs nothing.
-        Only survivors and the round-0 baseline count, mirroring finalization -- a killed
-        candidate would end the run in favour of a winner that never reaches the target.
+        make. It is not part of that judgement, so selecting no terminator does not
+        disable it -- a target is a threshold the caller stated, not an opinion about
+        stagnation. To keep going, set no target.
+
+        Only what finalization would consider counts: a live candidate, or the
+        generation-0 baseline even if survivor selection killed it — the same
+        re-admission the selector makes when deciding whether anything beat doing
+        nothing. Otherwise the run could end in favour of a winner that never reaches
+        the target, or fail to end when shipping nothing already satisfies it.
         """
-        targets = [target for target in config.objective_function if target.target is not None]
+        targets = [target for target in self._objective_metrics if target.target is not None]
         if not targets:
             return TerminationDecision(stop=False)
-        for node in evolution_tree.nodes.values():
-            if not node.val_reward or not (node.is_survivor or node.round == 0):
+        for candidate in candidates:
+            if candidate.killed_generation is not None and candidate.generation != 0:
                 continue
-            if all(target.is_satisfied_by(node.val_reward.get(target.name)) for target in targets):
-                summary = ", ".join(f"{target.name}={node.val_reward.get(target.name)}" for target in targets)
-                return TerminationDecision(stop=True, reason=f"objective reached by {node.label} ({summary})")
+            metrics = candidate.rewards["validation"].metrics or {}
+            if all(target.is_satisfied_by(metrics.get(target.name)) for target in targets):
+                summary = ", ".join(f"{target.name}={metrics.get(target.name)}" for target in targets)
+                return TerminationDecision(stop=True, reason=f"objective reached by {candidate.label} ({summary})")
         return TerminationDecision(stop=False)
 
     @hidden
     async def assess_convergence(
         self,
         *,
-        evolution_tree: EvolutionTree,
+        candidates: list[Candidate],
         prior_analysis: str | None,
-        config: EvolutionaryOptimizerConfig,
     ) -> TerminationDecision:
         """Decide whether to early-stop before running another round.
 
-        Mirrors the original top-of-loop gating: returns ``stop=False`` immediately
-        when there is no prior analysis to reason about or when the convergence
-        check is disabled. Otherwise consults :meth:`_has_converged`.
+        Returns ``stop=False`` without consulting a model when there is no prior round
+        to compare against. Otherwise consults :meth:`_has_converged`.
 
         Args:
-            evolution_tree: Live tree of scored candidates across rounds.
+            candidates: The scored population.
             prior_analysis: Markdown analysis from the previous round, if any.
-            config: Active optimizer config (read-only).
 
         Returns:
             A :class:`TerminationDecision`.
         """
-        if prior_analysis is None or config.disable_convergence_check:
+        if prior_analysis is None:
             return TerminationDecision(stop=False)
         converged = await self._has_converged(
-            evolution_tree=evolution_tree,
+            candidates=candidates,
             prior_analysis=prior_analysis,
-            min_rounds_before_stopping=config.min_rounds_before_stopping,
-            objective_metrics=config.objective_function,
-            regression_metrics=config.regression_metrics,
+            min_rounds_before_stopping=self._min_rounds_before_stopping,
+            objective_metrics=self._objective_metrics,
+            regression_metrics=self._regression_metrics,
         )
         if converged:
             return TerminationDecision(stop=True, reason="optimization converged (Pareto front stagnated)")
         return TerminationDecision(stop=False)
 
-    @hidden
-    def assess_round_budget(
-        self,
-        *,
-        round_num: int,
-        config: EvolutionaryOptimizerConfig,
-    ) -> TerminationDecision:
-        """Decide whether the round budget is exhausted.
-
-        Args:
-            round_num: The number of rounds completed so far.
-            config: Active optimizer config (read-only).
-
-        Returns:
-            A :class:`TerminationDecision` that stops when
-            ``round_num >= config.max_rounds``.
-        """
-        if round_num >= config.max_rounds:
-            return TerminationDecision(stop=True, reason=f"reached max_rounds ({config.max_rounds})")
-        return TerminationDecision(stop=False)
-
     @hidden
     async def _has_converged(
         self,
         *,
-        evolution_tree: EvolutionTree,
+        candidates: list[Candidate],
         prior_analysis: str,
         min_rounds_before_stopping: int,
         objective_metrics: list[MetricTarget] | None = None,
-        regression_metrics: list[MetricTarget] | None = None,
+        regression_metrics: list[MetricTarget],
     ) -> bool:
         """Return True if the optimization has converged and should stop early."""
-        # Truthy check (not ``is not None``): ``EvolutionNode.val_reward`` returns ``{}`` for
-        # unscored nodes, so ``is not None`` would pull them in and skew the round cutoff /
-        # Pareto front. Match ``EvolutionTree.get_best()``.
-        scored = [n for n in evolution_tree.nodes.values() if n.val_reward]
-        rounds = sorted({n.round for n in scored})
+        # Truthy check, not ``is not None``: an unscored candidate has an empty metrics
+        # dict, and counting those would skew both the round cutoff and the front.
+        scored = [c for c in candidates if c.rewards["validation"].metrics]
+        rounds = sorted({n.generation for n in scored})
         if len(rounds) < min_rounds_before_stopping:
             return False
         cutoff_round = rounds[-min_rounds_before_stopping]
-        old = [n for n in scored if n.round <= cutoff_round]
+        old = [n for n in scored if n.generation <= cutoff_round]
         if not old:
             return False
-        active_objectives = objective_metrics or EvolutionaryOptimizerConfig().objective_function
-        active_regressions = regression_metrics or []
-        scored = [node for node in scored if has_metric_dimensions(node.val_reward, active_objectives)]
+        objectives = objective_metrics or []
+        scored = [c for c in scored if has_metric_dimensions(c.rewards["validation"].metrics or {}, objectives)]
         if not scored:
             return False
-        old = [node for node in old if node in scored]
+        old = [c for c in old if c in scored]
         if not old:
             return False
-        old_front_ids = {
-            node.label for node in pareto_front(old, lambda node: pareto_objectives(node.val_reward, active_objectives))
-        }
-        full_front_ids = {
-            node.label
-            for node in pareto_front(scored, lambda node: pareto_objectives(node.val_reward, active_objectives))
-        }
+        ranked = lambda c: pareto_objectives(c.rewards["validation"].metrics or {}, objectives)  # noqa: E731
+        old_front_ids = {c.id for c in pareto_front(old, ranked)}
+        full_front_ids = {c.id for c in pareto_front(scored, ranked)}
         if full_front_ids.issubset(old_front_ids):
             return True
         return await self.qualitative_stop_check(
             prior_analysis,
-            active_objectives,
-            active_regressions,
+            objectives,
+            regression_metrics,
         )
 
     @strategy(CodeActStrategy(config=CodeActConfig(max_iterations=5)))
@@ -224,7 +206,7 @@ async def qualitative_stop_check(
         analysis: str,
         objective_metrics: list[MetricTarget],
         regression_metrics: list[MetricTarget],
-    ) -> bool:  # pyright: ignore[reportReturnType]  # ty: ignore[invalid-return-type]
+    ) -> bool:  # ty: ignore[invalid-return-type]  # pyright: ignore[reportReturnType]
         """Decide whether the optimization has qualitatively plateaued; return True to stop.
 
         Judge the round ``analysis`` text against the terminator skill's stop
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/tools.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/tools.py
index 7d664d9494..2fdc687a72 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/tools.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/tools.py
@@ -102,23 +102,20 @@ def __init__(self, workspace: Path) -> None:
         self._eval_root = self.workspace / "eval-and-optimize"
         self._agents_root = self._eval_root / "agents"
         self._analysis_root = self._eval_root / "analysis"
+        self._candidates_root = self._eval_root / "candidates"
+        self._candidates_cache: tuple[tuple[tuple[str, int], ...], list[Candidate]] | None = None
 
     # ── Navigation ────────────────────────────────────────────────────────────
 
     def list_agents(self) -> list[str]:
-        """Return all agent IDs that have a ``metadata.json``, sorted naturally.
+        """Return every candidate's display handle, in natural numeric order.
 
         Returns:
             list[str]: agent IDs in natural numeric order.
 
         """
-        if not self._agents_root.exists():
-            return []
-        ids = [d.name for d in self._agents_root.iterdir() if d.is_dir() and (d / "metadata.json").exists()]
-        return sorted(
-            ids,
-            key=lambda s: int(s.split("-")[1]) if s.split("-")[1].isdigit() else 0,
-        )
+        ids = [candidate.label for candidate in self._candidates()]
+        return sorted(ids, key=lambda s: int(s.split("-")[1]) if s.split("-")[1].isdigit() else 0)
 
     def get_agent_path(self, agent_id: str) -> str:
         """Return the absolute path to an agent's directory.
@@ -156,7 +153,7 @@ def read_agent_file(self, agent_id: str, relative_path: str, limit: int | None =
 
         Args:
             agent_id:      e.g. "agent-2"
-            relative_path: e.g. "main.py", "metadata.json"
+            relative_path: e.g. "main.py", "agent.py"
             limit:         max characters (default 8000, None = no truncation)
 
         Returns:
@@ -185,23 +182,49 @@ def read_analysis_file(self, path_or_round: "str | int", limit: int | None = 800
         return self._read_file(path, limit=limit)
 
     def get_metadata(self, agent_id: str) -> Candidate:
-        """Read ``agents/{agent_id}/metadata.json`` as a :class:`Candidate`.
+        """Read the stored :class:`Candidate` whose display handle is *agent_id*.
+
+        Candidate metadata lives in the run's candidate store, not inside the agent
+        directory, so nothing an agent-editing tool can reach owns it.
 
         Args:
             agent_id: the agent whose metadata to read.
 
         Returns:
-            Candidate: parsed candidate, or a minimal candidate with default
-            values if the file is missing or unreadable.
+            Candidate: the stored candidate.
+
+        Raises:
+            FileNotFoundError: when no candidate carries that handle.
 
+        """
+        for candidate in self._candidates():
+            if candidate.label == agent_id:
+                return candidate
+        raise FileNotFoundError(f"No candidate with label {agent_id!r} in {self._candidates_root}")
+
+    def _candidates(self) -> list[Candidate]:
+        """Every candidate record this run has stored so far.
+
+        Memoized on the set of record paths and their mtimes, because the prompts call
+        `get_metadata` once per agent in a loop and each record carries its full trial
+        list including traces — re-reading the store per lookup made a report pass
+        quadratic in the number of candidates.
         """
         # Function-local import: experimentalist_backend imports this module.
         from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import load_candidate
 
-        path = self._agents_root / agent_id / "metadata.json"
-        if not path.exists():
-            raise FileNotFoundError(f"Metadata file not found: {path}")
-        return load_candidate(path)
+        if not self._candidates_root.is_dir():
+            return []
+        paths = sorted(self._candidates_root.glob("*.json"))
+        stamp = tuple((str(path), path.stat().st_mtime_ns) for path in paths)
+        if self._candidates_cache is not None and self._candidates_cache[0] == stamp:
+            return self._candidates_cache[1]
+        # Discarded candidates are excluded here for the same reason `list_candidates`
+        # excludes them: these feed the report and analysis prompts, and a rolled-back
+        # candidate in the lineage tree is one the run already abandoned.
+        loaded = [c for c in (load_candidate(path) for path in paths) if not c.discarded]
+        self._candidates_cache = (stamp, loaded)
+        return loaded
 
     # ── Private helpers ───────────────────────────────────────────────────────
 
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/trace_analyzer.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/trace_analyzer.py
index 956eefd057..c6ccb0a5a1 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/trace_analyzer.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/trace_analyzer.py
@@ -14,8 +14,8 @@
 from nemo_experimentalist_plugin.entities import DependencyRuntime, MetricResult, Task, TrialResult
 from nemo_experimentalist_plugin.experimentalist.components import cache
 from nemo_experimentalist_plugin.experimentalist.components.tools import GuardedShellTools, WorkspaceTool
+from nemo_experimentalist_plugin.experimentalist.seam import TraceLoader
 from nemo_insights_plugin.entities import Insight
-from nemo_platform import AsyncNeMoPlatform
 from nemo_platform_plugin.nooa_model_client import get_default_model, get_fast_model
 from nooa import Agent, CodeActStrategy, strategy
 from nooa.agentdoc import doc, spec
@@ -97,7 +97,7 @@ def _outcome_from_eval_passed(eval_passed: bool | None) -> Literal["SUCCESS", "F
 class TraceAnalyzer(Agent):
     """Perform deep trace analysis for a single task.
 
-    Spawned by AgentAnalyzer.run in parallel — one instance per task.
+    Spawned by TraceRootCauseAnalyzer.run in parallel — one instance per task.
     Never call this sequentially; always use asyncio.gather.
 
     When using TraceExplorer return types, prefer attribute access. If you
@@ -304,8 +304,7 @@ async def run(
         selection_reason: str = "",
         objective_metrics: list[dict[str, Any]] | None = None,
         regression_metrics: list[dict[str, Any]] | None = None,
-        client: AsyncNeMoPlatform | None = None,
-        workspace: str | None = None,
+        load_trace: TraceLoader | None = None,
     ) -> Diagnostic:
         """Run the full trace analysis pipeline for one agent trial.
 
@@ -320,8 +319,8 @@ async def run(
             objective_metrics: Evaluator metric dimensions the optimization run
                 aims to improve.
             regression_metrics: Evaluator metric dimensions that must not worsen.
-            client: Existing NeMo Platform client for Intake trace identifiers.
-            workspace: NMP workspace request context for Intake trace identifiers.
+            load_trace: Resolves a trace reference to a TraceExplorer, wherever the
+                trace is stored. Supplied by the context; ``None`` skips trace analysis.
 
         Returns:
             Diagnostic: outcome, summary, failure point span index, and root cause.
@@ -338,7 +337,9 @@ async def run(
             )
 
         try:
-            trace = await TraceExplorer.from_ref(trial.trace, client, workspace)
+            if load_trace is None:
+                raise ValueError("no trace loader was supplied")
+            trace = await load_trace(trial.trace)
         except Exception as exc:
             logger.warning("Skipping unloadable trace %s for trial %s: %s", trial.trace.uri, trial.id, exc)
             return Diagnostic(
@@ -352,7 +353,7 @@ async def run(
             )
 
         # The cache key intentionally omits the insight lens. Within the optimization
-        # loop the Eval Author (insight-conditioned) and the AgentAnalyzer (no insight)
+        # loop the Eval Author (insight-conditioned) and the TraceRootCauseAnalyzer (no insight)
         # analyze disjoint trace sets in a single experiment_dir, so a given trace is
         # only ever diagnosed through one lens and cannot collide here. If a future
         # caller analyzes the same trace under different insights in one experiment_dir,
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/trace_scorer.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/trace_scorer.py
index 0e0b2b72ab..48811ac176 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/trace_scorer.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/trace_scorer.py
@@ -1,23 +1,54 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+import asyncio
 import logging
+from collections import defaultdict
 from pathlib import Path
 from typing import Any
 
-from nemo_experimentalist_plugin.entities import Dataset, TrialResult
+from nemo_experimentalist_plugin.entities import Candidate, Dataset, RewardRecord, TrialResult
+from nemo_experimentalist_plugin.experimentalist import roles
 from nemo_experimentalist_plugin.experimentalist.components.trace_explorer import TraceExplorer  # noqa: F401
-from nemo_platform import AsyncNeMoPlatform
+from nemo_experimentalist_plugin.experimentalist.seam import PRIMARY_SPLIT, StrategyContext, TraceLoader
 from nemo_platform_plugin.nooa_model_client import get_fast_model
 from nooa import Agent, CodeActStrategy, strategy
 from nooa.agentdoc import doc
 from nooa.config import CodeActConfig
 from pydantic import BaseModel, Field
 
-from .goal_tree import GoalNode
+from .goal_tree import GoalNode, GoalTree, GoalTreeConfig, GoalTreeGenerator, leaf_weights_by_id, traverse_tree
 
 logger = logging.getLogger(__name__)
 
+#: Concurrent scoring calls. `max_trajectory_tasks` caps tasks, not the nodes each is
+#: scored against, so the product is what needs bounding.
+_MAX_CONCURRENT_SCORING = 8
+
+
+def _trajectory_detail_from_reward(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        reward_val = value.get("reward", value.get("score", 0.0))
+        explanation = value.get("reason") or value.get("explanation") or ""
+    else:
+        reward_val = getattr(value, "reward", getattr(value, "score", value))
+        explanation = getattr(value, "reason", "") or getattr(value, "explanation", "")
+    detail: dict[str, Any] = {"reward": float(reward_val)}
+    if explanation:
+        detail["explanation"] = str(explanation)
+    return detail
+
+
+def _complete_trace_groups(
+    traces_by_task: dict[str, dict[str, TrialResult]], agent_ids: list[str]
+) -> dict[str, dict[str, TrialResult]]:
+    required_agents = set(agent_ids)
+    return {
+        task_id: by_agent
+        for task_id, by_agent in traces_by_task.items()
+        if set(by_agent) == required_agents and all(by_agent[aid] for aid in required_agents)
+    }
+
 
 class GroupLeafScore(BaseModel):
     """A numeric score and qualitative reason for a single agent on a goal-tree leaf."""
@@ -34,15 +65,21 @@ class GroupLeafScore(BaseModel):
     )
 
 
-class GroupLeafScorer(Agent):
+class GoalTreeTrajectoryScorer(Agent, roles.TrajectoryScorer):
     """Score a group of agent traces against a goal-tree leaf node."""
 
+    config_type = GoalTreeConfig
+
+    name = "goal-tree"
+
     def __init__(
         self,
         workspace: Path,
         llm: Any | None = None,
-        client: AsyncNeMoPlatform | None = None,
-        nmp_workspace: str | None = None,
+        load_trace: TraceLoader | None = None,
+        config: GoalTreeConfig | None = None,
+        max_trajectory_tasks: int | None = None,
+        framework_skills_dirs: list[Path] | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize the scorer for the given workspace.
@@ -50,8 +87,8 @@ def __init__(
         Args:
             workspace: Path to the workspace directory.
             llm: Language model instance; defaults to the configured fast model.
-            client: NeMo Platform client; required to load ``intake://`` traces.
-            nmp_workspace: NeMo Platform workspace name; required to load ``intake://`` traces.
+            load_trace: Resolves a trace reference to a TraceExplorer. Supplied by the
+                context; ``run`` takes the run's own if none was given here.
             **kwargs: Additional arguments passed to parent Agent class.
 
         Raises:
@@ -60,12 +97,14 @@ def __init__(
         """
         super().__init__(llm=llm or get_fast_model(), **kwargs)
         self.workspace = workspace
-        self._client = client
-        self._nmp_workspace = nmp_workspace
+        self._load_trace = load_trace
         self.context["trace_explorer_documentation"] = doc(TraceExplorer)
+        self._goal_config = config or GoalTreeConfig()
+        self._max_trajectory_tasks = max_trajectory_tasks
+        self._framework_skills_dirs = framework_skills_dirs or []
 
     @strategy(CodeActStrategy(config=CodeActConfig(max_iterations=15, cell_timeout=120.0)))
-    async def run(
+    async def score_group(
         self,
         node: GoalNode,
         trials: dict[str, TrialResult],
@@ -84,7 +123,7 @@ async def run(
         ## Loading traces
 
         Load each trace with
-        `await TraceExplorer.from_ref(trial.trace, self._client, self._nmp_workspace)`.
+        `await self._load_trace(trial.trace)`.
         If the trace is not available, skip the trial.
 
         Use TraceExplorer to inspect the full span hierarchy: sessions, turns, LLM messages, tool
@@ -138,12 +177,226 @@ async def run(
             score, a reason citing specific trace evidence, and the span IDs that ground the reason.
         """
         explorers: dict[str, TraceExplorer] = {}
+        if self._load_trace is None:
+            raise ValueError(
+                "No trace loader was supplied, so no trajectory can be read. `run` takes the "
+                "run's own from the context; a direct caller must pass `load_trace`."
+            )
         for agent_id, trial in trials.items():
             if not trial.trace:
                 continue
-            explorer = await TraceExplorer.from_ref(trial.trace, self._client, self._nmp_workspace)
+            explorer = await self._load_trace(trial.trace)
             explorers[agent_id] = explorer
             print(f"Agent {agent_id} trace overview:")
             print(await explorer.get_overview())
             print(await explorer.get_errors())
         ...
+
+    async def run(
+        self,
+        ctx: StrategyContext,
+        *,
+        candidates: list[Candidate],
+        round_num: int = 0,
+        analysis: str | None = None,
+    ) -> dict[str, RewardRecord]:
+        """Score how each candidate got to its result, as one reward record each.
+
+        The goal tree this scorer ranks against is its own: built on first use from the
+        train split, refined from each round's analysis, and persisted under the run's
+        analysis directory.
+        """
+        self._load_trace = ctx.load_trace
+        await self._ensure_goal_tree(ctx.datasets["train"], ctx.agent_spec)
+        if analysis is not None:
+            await self._update_goal_tree(
+                round_num=round_num, analysis=analysis, dataset=ctx.datasets["train"], agent_spec=ctx.agent_spec
+            )
+        results = await self._reward_trajectories(dataset=ctx.datasets[PRIMARY_SPLIT], candidates=candidates)
+        by_label = {c.label: c for c in candidates}
+        scored: dict[str, RewardRecord] = {}
+        for label, payload in results.items():
+            candidate = by_label.get(label)
+            if candidate is None:
+                continue
+            candidate.trajectory_detail = payload["details"]
+            scored[candidate.id] = RewardRecord(metrics=payload["reward"])
+        return scored
+
+    def _goal_tree_path(self, round_num: int) -> Path:
+        return self.workspace / "eval-and-optimize" / "analysis" / f"round-{round_num}-goal.json"
+
+    def _latest_goal_tree_path(self) -> Path | None:
+        analysis_dir = self.workspace / "eval-and-optimize" / "analysis"
+        best: tuple[int, Path] | None = None
+        for p in analysis_dir.glob("round-*-goal.json"):
+            try:
+                n = int(p.stem.split("-")[1])
+            except (IndexError, ValueError):
+                continue
+            if best is None or n > best[0]:
+                best = (n, p)
+        return best[1] if best else None
+
+    def _load_goal_tree(
+        self,
+        path: Path,
+        goal_config: GoalTreeConfig,
+        context: str,
+    ) -> GoalTree | None:
+        try:
+            return GoalTree.from_path(path, config=goal_config)
+        except (OSError, ValueError) as exc:
+            logger.warning(f"[TRAJ] Failed to load {context} goal tree {path}: {exc}")
+            return None
+
+    async def _ensure_goal_tree(self, dataset: Dataset, agent_spec: Path | None) -> None:
+        """Generate and persist the round-0 goal tree if it does not already exist."""
+        tree_path = self._goal_tree_path(0)
+        if tree_path.exists():
+            return
+        try:
+            tree = await GoalTreeGenerator(
+                workspace=self.workspace,
+                config=self._goal_config,
+                framework_skills_dirs=self._framework_skills_dirs,
+            ).generate(dataset, agent_spec=agent_spec)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(f"[TRAJ] Failed to generate initial goal tree; continuing without trajectory scoring: {exc}")
+            return
+        tree_path.parent.mkdir(parents=True, exist_ok=True)
+        tree_path.write_text(tree.to_json())
+
+    async def _update_goal_tree(
+        self, *, round_num: int, analysis: str, dataset: Dataset, agent_spec: Path | None = None
+    ) -> None:
+        """Refine and persist the goal tree for round *round_num* + 1."""
+        next_goal_path = self._goal_tree_path(round_num + 1)
+        if next_goal_path.exists():
+            return
+        goal_tree_path = self._latest_goal_tree_path()
+        if goal_tree_path is None:
+            return
+        goal_config = self._goal_config
+        goal_tree = self._load_goal_tree(goal_tree_path, goal_config, context="analysis")
+        if goal_tree is None:
+            return
+        generator = GoalTreeGenerator(
+            workspace=self.workspace,
+            config=goal_config,
+            framework_skills_dirs=self._framework_skills_dirs,
+        )
+        updated_tree = await generator.update(goal_tree, analysis, round_num, dataset, agent_spec=agent_spec)
+        next_goal_path.parent.mkdir(parents=True, exist_ok=True)
+        next_goal_path.write_text(updated_tree.to_json())
+
+    async def _reward_trajectories(self, *, dataset: Dataset, candidates: list[Candidate]) -> dict[str, dict[str, Any]]:
+        """Score candidates against the goal tree; return trajectory results keyed by candidate label."""
+        tree_path = self._latest_goal_tree_path()
+        if tree_path is None:
+            logger.info("[TRAJ] No goal tree found, skipping trajectory scoring")
+            return {}
+
+        goal_tree = self._load_goal_tree(tree_path, self._goal_config, context="trajectory scoring")
+        if goal_tree is None:
+            logger.info("[TRAJ] Invalid goal tree, skipping trajectory scoring")
+            return {}
+
+        pending = [c.label for c in candidates]
+        if len(pending) == 1:
+            logger.info("[TRAJ] Only one agent to score, skipping GRA")
+            return {}
+
+        logger.info(f"[TRAJ] Scoring {len(pending)} agents using GRA")
+
+        nodes = traverse_tree(goal_tree.root)
+        node_weights = leaf_weights_by_id(goal_tree.root)
+        traces_by_task: dict[str, dict[str, TrialResult]] = {}
+        for candidate in candidates:
+            if "validation" not in candidate.rewards:
+                continue
+            for trial in candidate.rewards["validation"].trials or []:
+                if trial.trace is None:
+                    continue
+                traces_by_task.setdefault(trial.task_id, {}).setdefault(candidate.label, trial)
+
+        # Only require agents that actually contributed traces; a candidate with no
+        # traces at all (e.g. its validation run failed entirely) must not cause every
+        # task to be dropped from scoring.
+        agents_with_traces = {label for task_traces in traces_by_task.values() for label in task_traces}
+        if len(agents_with_traces) < 2:
+            logger.info("[TRAJ] Fewer than two agents have traces, skipping trajectory scoring")
+            return {}
+        complete_traces = _complete_trace_groups(traces_by_task, list(agents_with_traces))
+        dropped = len(traces_by_task) - len(complete_traces)
+        if dropped:
+            logger.info(f"[TRAJ] Skipping {dropped} tasks missing traces for one or more agents")
+        traces_by_task = complete_traces
+
+        task_names = sorted(traces_by_task)
+        total_tasks = len(task_names)
+        max_tasks = self._max_trajectory_tasks
+        if max_tasks and total_tasks > max_tasks:
+            task_names = task_names[:max_tasks]
+            traces_by_task = {t: traces_by_task[t] for t in task_names}
+            logger.info(f"[TRAJ] Selected first {max_tasks}/{total_tasks} complete tasks")
+
+        if not traces_by_task:
+            logger.info("[TRAJ] No complete trace groups found, skipping")
+            return {}
+        if self._goal_config is None:
+            return {}
+
+        scores_by_node_trial_agent: dict[str, dict[str, dict[str, dict[str, Any]]]] = defaultdict(
+            lambda: defaultdict(dict)
+        )
+        keys = [(node.id, task_id) for node in nodes for task_id in traces_by_task]
+        logger.info(f"[TRAJ] Starting {len(keys)} GRA scoring tasks...")
+
+        # Bounded, and tolerant of one call failing. The fan-out is nodes x tasks and every
+        # element is an LLM call, so a wide goal tree would otherwise issue them all at
+        # once; and this whole channel is optional, so one unreadable trace must not end a
+        # run that has already spent hours.
+        limit = asyncio.Semaphore(_MAX_CONCURRENT_SCORING)
+
+        async def _score(node: GoalNode, task_id: str) -> dict[str, GroupLeafScore]:
+            async with limit:
+                return await self.score_group(node, traces_by_task[task_id], dataset)
+
+        scoring_results = await asyncio.gather(
+            *[_score(node, task_id) for node in nodes for task_id in traces_by_task],
+            return_exceptions=True,
+        )
+        logger.info("[TRAJ] Scoring completed")
+        for (node_id, task_id), group_scores in zip(keys, scoring_results, strict=True):
+            if isinstance(group_scores, BaseException):
+                logger.warning("[TRAJ] scoring %s on %s failed; skipping: %s", node_id, task_id, group_scores)
+                continue
+            for aid, gs in group_scores.items():
+                scores_by_node_trial_agent[node_id][task_id][aid] = _trajectory_detail_from_reward(gs)
+
+        trajectory_results: dict[str, dict[str, Any]] = {}
+        for aid in pending:
+            details: dict[str, dict[str, dict[str, Any]]] = {}
+            for node in nodes:
+                details[node.id] = {
+                    tid: by_agent[aid]
+                    for tid, by_agent in scores_by_node_trial_agent[node.id].items()
+                    if aid in by_agent
+                }
+            node_means = {
+                node.id: sum(item["reward"] for item in details[node.id].values()) / len(details[node.id])
+                for node in nodes
+                if details[node.id]
+            }
+            trajectory_reward = sum(node_weights[node.id] * node_means.get(node.id, 0.0) for node in nodes)
+            trajectory_results[aid] = {
+                "details": details,
+                "reward": {
+                    "aggregate": trajectory_reward,
+                    **node_means,
+                },
+            }
+            logger.info(f"[TRAJ] {aid}: trajectory_reward={trajectory_reward:.3f}")
+
+        return trajectory_results
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/context.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/context.py
new file mode 100644
index 0000000000..08f4e2f8e9
--- /dev/null
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/context.py
@@ -0,0 +1,530 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""The plugin-facing seam: everything a strategy is allowed to reach.
+
+``ExperimentContext`` is the implementation; ``StrategyContext`` in :mod:`seam` is the
+Protocol it satisfies, and is what components are typed against so a role contract does
+not depend on this module.
+
+A strategy receives one context and nothing else. The context holds
+the :class:`~nemo_experimentalist_plugin.experimentalist.experimentalist_backend.ExperimentalistBackend`
+privately, so no component ever sees ``create_run``, ``publish_candidate``, or the
+platform client; the runner that built the context is the only code that holds a
+backend.
+
+The two keyword arguments below are deliberately different words. ``evaluate(split=…)``
+names a *dataset split* to run against; ``record_reward(channel=…)`` names a *reward
+channel* to store under. Usually a run on the validation split lands in the
+``validation`` channel, but trajectory scoring produces a second channel from the same
+split, which is why one is not spelled with the other's name.
+"""
+
+from __future__ import annotations
+
+import fnmatch
+import inspect
+import logging
+import shutil
+from collections.abc import Callable, Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+from nemo_experimentalist_plugin.entities import (
+    Candidate,
+    Dataset,
+    DataValue,
+    EvaluationResult,
+    ExperimentRun,
+    MetricTarget,
+    Proposal,
+    ResourceRef,
+    RewardRecord,
+    local_path_from_uri,
+)
+from nemo_experimentalist_plugin.experimentalist.components.evaluator import Evaluator
+from nemo_experimentalist_plugin.experimentalist.components.trace_explorer import TraceExplorer
+from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import (
+    ExperimentalistBackend,
+)
+from nemo_experimentalist_plugin.experimentalist.registry import resolve, validated_config
+from nemo_experimentalist_plugin.experimentalist.reporting import RunReporter
+from nemo_experimentalist_plugin.experimentalist.seam import PRIMARY_SPLIT, Fork
+
+logger = logging.getLogger(__name__)
+
+
+def _accepted(constructor: Any, supplied: dict[str, Any]) -> dict[str, Any]:
+    """Narrow *supplied* to the arguments *constructor* names.
+
+    Named parameters only. A ``**kwargs`` on a component almost always means "forward
+    the rest to my base class" rather than "I tolerate anything", so treating it as
+    permission hands an nooa ``Agent`` a ``workspace`` it will reject.
+    """
+    parameters = inspect.signature(constructor).parameters
+    return {
+        key: value
+        for key, value in supplied.items()
+        if parameters.get(key) is not None and parameters[key].kind is not inspect.Parameter.VAR_KEYWORD
+    }
+
+
+#: What a fork must not carry from its source, composed from the owners that actually
+#: contribute names: this run's own layout, generic developer hygiene, the evaluator's
+#: scratch, and the strategy's generated documentation. Hardcoding one flat list is how
+#: a third-party strategy's real output gets stripped.
+#: Directories the run owns. A fork must not inherit them, and the winner copy-out
+#: must not overwrite them -- both directions of the same rule, so it lives here once.
+RUN_LAYOUT = frozenset({"eval-and-optimize", "artifacts", "dataset", "scratch"})
+_HYGIENE = frozenset({"__pycache__", ".git", ".runtime-cache", ".claude", ".uv", ".venv"})
+_EVALUATOR_SCRATCH_GLOBS = ("*traces*", "*eval-and-optimize_*")
+#: Generated *about* the ancestor rather than part of it, and the Proposer's only view of
+#: an agent — it is told to reason from this file and not to read source. The Builder
+#: re-seeds it from the ancestor after building and rewrites it against the finished
+#: source, so the fork must leave it absent: absence is what tells the Proposer it has no
+#: model of a candidate. Inherit it and a failed regeneration silently hands the Proposer
+#: the *ancestor's* graph instead, which is worse than handing it nothing.
+_GENERATED_DOCS = frozenset({"architecture.md"})
+
+
+def _ignore_forked(source_root: Path) -> Callable[[str, list[str]], set[str]]:
+    """What a forked candidate must not inherit from the directory it came from.
+
+    Returns a callable bound to *source_root* because one of the three owners applies at
+    the top level only: ``architecture.md`` is generated *about* the agent and sits beside
+    it, so an agent whose own source contains ``docs/architecture.md`` must keep it. The
+    others — run layout, hygiene, evaluator scratch — are stripped at every depth.
+    """
+    root = source_root.resolve()
+
+    def _ignore(directory: str, contents: list[str]) -> set[str]:
+        skip = RUN_LAYOUT | _HYGIENE
+        if Path(directory).resolve() == root:
+            skip = skip | _GENERATED_DOCS
+        return {
+            name
+            for name in contents
+            if name in skip or any(fnmatch.fnmatch(name, pattern) for pattern in _EVALUATOR_SCRATCH_GLOBS)
+        }
+
+    return _ignore
+
+
+class ExperimentContext:
+    """One run's view of the platform, handed to exactly one strategy.
+
+    Args:
+        backend: Data-access backend. Held privately; never handed to a component.
+        workspace: NeMo Platform workspace this run belongs to.
+        run: The ``ExperimentRun`` entity the runner created (or re-opened on resume).
+        root: Working directory for the run's artifacts.
+        agent_dir: The agent under test, materialized by the runner. A strategy forks
+            candidates from here; it must not write into it.
+        agent_spec: Optional markdown description of the agent under test.
+        datasets: Evaluator-domain datasets keyed by split. ``validation`` is always
+            present; ``train`` and ``insight`` are present when the run has them.
+        evaluator: OutcomeEvaluator component the run was configured with.
+        resuming: True when the runner re-opened an existing run, so the strategy
+            should rebuild its state from :meth:`candidates` instead of starting over.
+        reporter: Optional human narration sink. Best-effort and never load-bearing.
+    """
+
+    def __init__(
+        self,
+        *,
+        backend: ExperimentalistBackend,
+        workspace: str,
+        run: ExperimentRun,
+        root: Path,
+        agent_dir: Path,
+        agent_spec: Path | None = None,
+        datasets: Mapping[str, Dataset],
+        evaluator: Evaluator,
+        resuming: bool = False,
+        reporter: RunReporter | None = None,
+        objective_metrics: list[MetricTarget] | None = None,
+        regression_metrics: list[MetricTarget] | None = None,
+    ) -> None:
+        if PRIMARY_SPLIT not in datasets:
+            raise ValueError(f"ExperimentContext requires a {PRIMARY_SPLIT!r} dataset; got {sorted(datasets)}")
+        self._backend = backend
+        self._run = run
+        self._evaluator = evaluator
+        self._reporter = reporter
+        self._objective_metrics = objective_metrics or [MetricTarget(name="reward", direction="maximize")]
+        self._regression_metrics = regression_metrics or []
+        self.workspace = workspace
+        self.root = root
+        self.agent_dir = agent_dir
+        self.agent_spec = agent_spec
+        self.datasets: Mapping[str, Dataset] = dict(datasets)
+        self.resuming = resuming
+
+    # -- Inputs --------------------------------------------------------------
+
+    @property
+    def run_id(self) -> str:
+        """Durable id of this run, and the key every Candidate is grouped under."""
+        return self._run.id or ""
+
+    @property
+    def outcome_evaluator(self) -> Evaluator:
+        """The evaluation component this run was configured with.
+
+        Exposed so a composite strategy can hand it to a component it owns — the CodeEditBuilder
+        runs smoke evals of its own, against work that is not yet a Candidate.
+        """
+        return self._evaluator
+
+    async def load_trace(self, ref: ResourceRef) -> TraceExplorer:
+        """The trace *ref* names, wherever it is stored.
+
+        A ``file://`` ref is read from disk and an ``intake://`` one from the platform.
+        Which of those a run produces is the host's business, so this is the seam: a
+        component that reads traces asks for ``load_trace`` and never names a platform
+        type, which is what lets one shipped by another package read traces at all.
+
+        Raises:
+            ValueError: if the reference names a scheme this run cannot resolve.
+        """
+        return await TraceExplorer.from_ref(ref, self._backend.client, self.workspace)
+
+    # -- Candidates ----------------------------------------------------------
+
+    async def candidates(self, *, include_discarded: bool = False) -> list[Candidate]:
+        """The Candidates committed to this run, in store order.
+
+        Persisted rather than checkpointed, which is what lets a strategy the host did
+        not write rebuild its population on resume.
+        """
+        return await self._backend.list_candidates(
+            workspace=self.workspace, run_id=self.run_id, include_discarded=include_discarded
+        )
+
+    def candidate_dir(self, candidate: Candidate) -> Path:
+        """Local directory holding *candidate*'s artifact.
+
+        A record whose artifact has gone is broken, not a candidate whose directory can
+        be guessed. Falling back to the parent resolves it to the shared candidate root,
+        which callers then copy out of and push wholesale.
+
+        Raises:
+            ValueError: if the artifact does not exist.
+        """
+        path = local_path_from_uri(candidate.artifact.uri, context="Candidate artifact")
+        if not path.exists():
+            raise ValueError(
+                f"Candidate {candidate.label!r} ({candidate.id}) has no artifact at {path}; "
+                "its record outlived the resource it addresses"
+            )
+        return path if path.is_dir() else path.parent
+
+    async def fork(self, proposal: Proposal) -> Fork:
+        """Reserve a working copy for *proposal*, seeded from what it branches off.
+
+        The ignore policy is host knowledge composed from three owners — this run's
+        layout, generic hygiene, and the evaluator's scratch — so it lives here rather
+        than in a Builder.
+
+        Returns:
+            Fork: the reserved directory to write into, and the pristine parent it came
+            from. Neither is a Candidate until :meth:`commit_candidate` validates the
+            finished work and commits it.
+        """
+        upstream = await self._ancestor_dir(proposal) if proposal.ancestor is not None else None
+        # No "already forked?" guard: _reserve returns max(existing) + 1, so the name is
+        # always fresh. A stray *file* by that name would make copytree raise, which is
+        # the right outcome — skipping the copy would hand the Builder a Fork whose
+        # workdir is a file.
+        destination = self._reserve()
+        source = upstream or self.agent_dir
+        shutil.copytree(source, destination, ignore=_ignore_forked(source))
+        return Fork(workdir=destination, upstream=upstream)
+
+    async def commit_candidate(self, *, proposal: Proposal, artifact: Path, generation: int = 0) -> Candidate:
+        """Validate a finished artifact and create the Candidate that addresses it.
+
+        This is the only way a Candidate is born from a build, which is what makes
+        ``artifact`` safe to require: nothing durable ever points at partial work.
+
+        ``ancestor`` and ``description`` are always derived from the Proposal — there is
+        no override, so the two accounts of a candidate's origin cannot drift.
+
+        Raises:
+            ValueError: if the artifact is missing or lies outside the run's candidate root.
+        """
+        return await self._create(
+            artifact=artifact,
+            proposal=proposal,
+            description=proposal.description,
+            generation=generation,
+        )
+
+    async def _create(self, *, artifact: Path, proposal: Proposal, description: str, generation: int) -> Candidate:
+        """Validate a finished artifact and persist the Candidate addressing it.
+
+        Private, so a caller cannot assemble a Candidate and persist it around the
+        validation that makes ``artifact`` safe to require.
+        """
+        if not artifact.exists():
+            raise ValueError(f"Candidate artifact does not exist: {artifact}")
+        artifact = artifact.resolve()
+        root = self._candidate_root.resolve()
+        if not artifact.is_relative_to(root):
+            raise ValueError(f"Candidate artifact must live under {root}, got {artifact}")
+
+        handle = (artifact.parent if artifact.is_file() else artifact).name
+        candidate = Candidate(
+            name=handle,
+            label=handle,
+            workspace=self.workspace,
+            run_id=self.run_id,
+            ancestor=proposal.ancestor,
+            generation=generation,
+            generated_from=proposal,
+            description=description,
+            artifact=ResourceRef(uri=artifact.as_uri(), description=description),
+        )
+        stored = await self._backend.create_candidate(workspace=self.workspace, candidate=candidate)
+        candidate._id = stored._id  # type: ignore[attr-defined]
+        return candidate
+
+    @property
+    def _candidate_root(self) -> Path:
+        """Runner-owned root every candidate artifact must live under."""
+        return self.root / "eval-and-optimize" / "agents"
+
+    def _reserve(self) -> Path:
+        """Pick the next free candidate directory under the run's candidate root.
+
+        Every fork gets a fresh directory, including one built from the agent under test
+        rather than from a parent: a run may hold many of those, and sharing a directory
+        would have them overwrite each other while still reporting separate rewards. The
+        baseline lands on ``agent-0`` simply by being the first.
+        """
+        root = self._candidate_root
+        root.mkdir(parents=True, exist_ok=True)
+        taken = [
+            int(entry.name.split("-")[1])
+            for entry in root.iterdir()
+            if entry.is_dir() and entry.name.startswith("agent-") and entry.name.split("-")[1].isdigit()
+        ]
+        return root / f"agent-{max(taken, default=-1) + 1}"
+
+    async def _ancestor_dir(self, proposal: Proposal) -> Path:
+        """Where the candidate *proposal* branches from keeps its artifact.
+
+        Resolved through the ancestor's stored ``artifact``, not by treating the id as
+        a directory name — that identification is exactly what this contract removes.
+        """
+        assert proposal.ancestor is not None
+        ancestor = await self._backend.get_candidate(workspace=self.workspace, candidate_id=proposal.ancestor)
+        return self.candidate_dir(ancestor)
+
+    async def update_candidate(self, candidate: Candidate, **fields: Any) -> Candidate:
+        """Persist changes to a candidate that already exists.
+
+        Update-only: the create path is private, so nothing can persist a Candidate that
+        never went through :meth:`commit_candidate`.
+
+        Raises:
+            ValueError: if *candidate* was never committed, or is a lossy :meth:`~.slim`
+                copy whose emptied trials would be written back over the real ones. The
+                second check is best-effort: the marker does not survive serialization.
+        """
+        if not candidate.id:
+            raise ValueError(
+                f"Candidate {candidate.label!r} has no store id; a Candidate is created by "
+                "commit_candidate, never by updating one into existence"
+            )
+        if candidate._slim:
+            raise ValueError(
+                f"Candidate {candidate.label!r} is a slim() copy; persisting one empties every "
+                "channel's trials in the store. Look the real candidate up by id first."
+            )
+        for key, value in fields.items():
+            setattr(candidate, key, value)
+        return await self._backend.update_candidate(workspace=self.workspace, candidate=candidate)
+
+    async def discard_candidate(self, candidate: Candidate) -> None:
+        """Mark *candidate* as rolled back, keeping both its record and its artifact.
+
+        Both halves survive together: deleting the directory while keeping the record
+        would let :meth:`_reserve` hand out a label the record still claims, giving one
+        run two candidates with the same handle. :meth:`candidates` excludes them.
+        """
+        await self.update_candidate(candidate, discarded=True)
+
+    async def archive_candidate(self, candidate: Candidate) -> None:
+        """Persist *candidate*'s code to durable storage, if the run archives at all.
+
+        Best-effort in both directions: a backend that cannot archive returns nothing,
+        and a failure is logged rather than raised — archival must never fail a run.
+        """
+        if not self._backend.storage.archive_candidates:
+            return
+        try:
+            await self._backend.archive_candidate(workspace=self.workspace, candidate=candidate)
+        except Exception as exc:  # noqa: BLE001 - archival must never fail the run
+            logger.warning("[PERSISTENCE] archive failed for candidate %s; continuing: %s", candidate.label, exc)
+
+    # -- Measurement ---------------------------------------------------------
+
+    async def record_reward(
+        self,
+        candidate: Candidate,
+        *,
+        channel: str,
+        result: EvaluationResult | RewardRecord,
+        metadata: dict[str, DataValue] | None = None,
+    ) -> None:
+        """Store one measurement of *candidate* on *channel*, and persist the candidate.
+
+        An ``EvaluationResult`` is the outcome of running the candidate, so its traces
+        are persisted before the record is stored; a ``RewardRecord`` is a measurement
+        the strategy computed itself (trajectory scoring, a self-scoring strategy) and
+        is stored as given. Either way the channel is an open key — adding one costs no
+        entity change.
+        """
+        if isinstance(result, EvaluationResult):
+            await self._backend.persist_evaluation(
+                workspace=self.workspace,
+                result=result,
+                candidate=candidate,
+                split=channel,
+            )
+            record = RewardRecord(
+                metrics={k: float(v) for k, v in result.aggregate_metrics.items()},
+                trials=list(result.trials),
+                metadata=dict(metadata or {}),
+            )
+        else:
+            record = result if metadata is None else result.model_copy(update={"metadata": dict(metadata)})
+        # The one sanctioned write: RewardMap refuses __setitem__ so an in-memory-only
+        # measurement cannot masquerade as a recorded one. Persisting is the next line.
+        dict.__setitem__(candidate.rewards, channel, record)
+        await self.update_candidate(candidate)
+
+    async def evaluate(
+        self,
+        candidate: Candidate,
+        *,
+        split: str = PRIMARY_SPLIT,
+        task_ids: Sequence[str] | None = None,
+        minimum_attempts: int | None = None,
+    ) -> EvaluationResult:
+        """Run the configured evaluation component over *candidate*'s artifact.
+
+        Optional by design: a strategy that scores itself skips this and calls
+        :meth:`record_reward` directly. The association between the result and the
+        candidate is owned here, not by the evaluation component.
+
+        Args:
+            candidate: Whose artifact to evaluate.
+            split: Which of :attr:`datasets` to run against.
+            task_ids: Restrict the run to these task ids.
+            minimum_attempts: Raise the evaluator's attempt count to at least this.
+
+        Raises:
+            KeyError: if *split* is not one of the run's datasets.
+        """
+        dataset = self.datasets[split]
+        if task_ids is not None:
+            dataset = dataset.subset(list(task_ids))
+        # Force a unique job name per candidate so concurrent candidates never collide on
+        # one results directory when a fixed job_name is configured. job_name/n_attempts
+        # are Harbor's vocabulary reaching a generic call site — an evaluator leak the
+        # registered evaluation component closes.
+        options = self._evaluator.options.model_dump()
+        options["job_name"] = f"{candidate.label}-{dataset.id}"
+        if minimum_attempts is not None:
+            configured = options.get("n_attempts")
+            if not isinstance(configured, int):
+                raise ValueError("Evaluator options must define integer n_attempts to raise the attempt floor")
+            options["n_attempts"] = max(configured, minimum_attempts)
+        result = await self._evaluator.run(
+            agent=self.candidate_dir(candidate),
+            dataset=dataset,
+            options=type(self._evaluator.options).model_validate(options),
+        )
+        if self._reporter is not None:
+            self._reporter.candidate_evaluated(
+                label=candidate.label,
+                split=split,
+                metrics=result.aggregate_metrics,
+                objective_metrics=self._objective_metrics,
+                artifacts=self.root / "eval-and-optimize" / "results" / result.id,
+            )
+        return result
+
+    # -- Progress ------------------------------------------------------------
+
+    async def report_progress(
+        self,
+        *,
+        completed: int,
+        total: int | None = None,
+        unit: str = "step",
+        note: str | None = None,
+    ) -> None:
+        """Report how far the strategy has got, as a counter rather than a fraction.
+
+        A counter is always producible; a fraction usually is not — an opaque strategy
+        cannot say how many trials it will run, and even a round-based one stops early
+        on convergence. When *total* is known a consumer may render a bar; when it is
+        not, ``note`` is where a strategy says what it is doing instead.
+        """
+        self._run.progress_completed = completed
+        self._run.progress_total = total
+        self._run.progress_unit = unit
+        self._run.progress_note = note
+        await self._backend.update_run(workspace=self.workspace, run=self._run)
+        if self._reporter is not None:
+            self._reporter.progress(phase=note or unit, completed=completed, total=total, unit=unit)
+
+    def component(self, role: str, name: str, **kwargs: Any) -> Any:
+        """Resolve a component by name and build it against this run.
+
+        Supplies the run-scoped arguments a component cannot know for itself — the model
+        tiers, the run root, the evaluator, the primary dataset — to whichever of them the
+        constructor names, and passes *kwargs* through untouched. Explicit *kwargs* win.
+
+        Raises:
+            LookupError: if nothing is registered under that name.
+        """
+        component = resolve(role, name)
+        # Two spellings of the same run root; both are offered so a component keeps
+        # whichever it names.
+        supplied: dict[str, Any] = {
+            "workspace": self.root,
+            "working_dir": self.root,
+            "evaluator": self._evaluator,
+            # A trace reader takes this rather than a platform client, so no component
+            # signature names a platform type and storage can move without touching one.
+            "load_trace": self.load_trace,
+            # Train, not the primary split: a Builder runs bounded repair loops against
+            # whatever it is handed, and `validation` is held out for scoring.
+            "dataset": self.datasets.get("train", self.datasets[PRIMARY_SPLIT]),
+            **kwargs,
+        }
+        return component(**validated_config(component, _accepted(component.__init__, supplied)))
+
+    @property
+    def objective_metrics(self) -> list[MetricTarget]:
+        """The run's effective objectives, after any Insight suite narrowed them."""
+        return list(self._objective_metrics)
+
+    @property
+    def regression_metrics(self) -> list[MetricTarget]:
+        """The run's effective guardrail metrics, alongside :attr:`objective_metrics`."""
+        return list(self._regression_metrics)
+
+    def note(self, message: str) -> None:
+        """Say what is happening, for a human watching the run.
+
+        Narration only: it touches no entity and never raises, so a strategy may call it
+        as freely as it likes. Use :meth:`report_progress` for anything a consumer
+        should be able to read back off the run.
+        """
+        if self._reporter is not None:
+            self._reporter.note(message)
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/deps.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/deps.py
deleted file mode 100644
index be1275332a..0000000000
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/deps.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-"""Run-time dependencies injected into every Experimentalist tool call.
-
-A single :class:`ExperimentalistDeps` instance carries the resolved run
-configuration through the Experimentalist loop. Keeping it in its own module
-avoids an import cycle between the agent definition and the components it
-coordinates.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
-from nemo_experimentalist_plugin.entities import DatasetRef
-from nemo_experimentalist_plugin.experimentalist.components.evaluator.base import EvaluatorType
-from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import (
-    ExperimentalistBackend,
-)
-from nemo_experimentalist_plugin.experimentalist.reporting import RunReporter
-from pydantic import BaseModel, model_validator
-
-
-class ExperimentalistDeps(BaseModel):
-    """Per-run configuration injected into every Experimentalist tool.
-
-    At least one of ``insight`` or ``agent`` must be set:
-    - Mode 1 (``insight``): agent code defaults to the NMP insight entity's agent.
-      When ``agent`` is also set, it overrides the insight's agent.
-    - Mode 2 (``agent``): a local agent directory is used as the baseline.
-
-    Attributes:
-        workspace: NMP workspace the Experimentalist operates in.
-        insight: Entity id of the Insight being processed (Mode 1).
-        agent: Local path to the baseline agent directory (Mode 2), or an
-            override for the agent referenced by ``insight``.
-        dataset: Local directory path OR fileset ID for the evaluation dataset.
-            A :class:`~pathlib.Path` means a local directory; a plain string
-            means a fileset ID that the backend will resolve at evaluation time.
-            Defaults to None and must be set before ``run()``.
-        evaluator_type: Which evaluator drives the run. ``run_experimentalist``
-            passes the value resolved from ``EvolutionaryOptimizerConfig``; the
-            default here only applies to callers that construct deps directly.
-        backend: Shared data-access backend used by every tool. The CLI
-            owns the backend's client lifecycle — tools must not close it.
-        config: Optional per-run override of the EvolutionaryOptimizerConfig.
-            When None the optimizer uses its own default config.
-    """
-
-    model_config = {"arbitrary_types_allowed": True}
-
-    workspace: str = "default"
-    insight: Path | str | None = None
-    agent: Path | str | None = None
-    train_dataset: DatasetRef
-    validation_dataset: DatasetRef
-    task_template: DatasetRef | None = None
-    evaluator_type: EvaluatorType = "harbor_native"
-    agent_spec: str | None = None
-    backend: ExperimentalistBackend | None = None
-    reporter: RunReporter | None = None
-    config: EvolutionaryOptimizerConfig | None = None
-
-    @model_validator(mode="after")
-    def _require_insight_or_agent(self) -> ExperimentalistDeps:
-        has_insight = self.insight is not None
-        has_agent = self.agent is not None
-        if not has_insight and not has_agent:
-            raise ValueError("One of 'insight' (Mode 1) or 'agent' (Mode 2) must be set.")
-        if has_insight and self.task_template is None:
-            raise ValueError("'task_template' is required when 'insight' is set.")
-        return self
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/experiment_mirror.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/experiment_mirror.py
index 8003f0cb31..b1472878fa 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/experiment_mirror.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/experiment_mirror.py
@@ -9,7 +9,7 @@
 ``ExperimentRun → ExperimentGroup`` (1:1) and ``Candidate → Experiment[]`` (one per
 evaluated split). It mirrors **structure only** (identity/lineage/status/description);
 eval results (reward/trials) are NOT copied into ``Experiment.metadata`` — those arrive
-via the Intake rollup path later (spec §4.3).
+via the Intake rollup path (spec §4.3).
 """
 
 from __future__ import annotations
@@ -59,9 +59,11 @@ def pseudo_source_link(gname: str, label: str) -> str:
 
 def experiment_status(candidate: Candidate) -> str:
     """Derive the producer status string from candidate lineage (spec §4.1)."""
-    if candidate.killed_round is not None:
+    if candidate.discarded:
+        return "discarded"
+    if candidate.killed_generation is not None:
         return "killed"
-    if candidate.round == 0:
+    if candidate.is_baseline:
         return "baseline"
     return "survived"
 
@@ -70,26 +72,37 @@ def group_metadata(run: ExperimentRun) -> dict[str, str]:
     """The ExperimentRun fields with no first-class ExperimentGroup home (spec §4.1).
 
     Platform ``metadata`` is ``dict[str, str]``: every value must be a string. Non-string
-    fields are serialized (``config_snapshot`` as JSON, ``rounds_completed`` via ``str``);
+    fields are serialized (``config_snapshot`` as JSON, the progress counter via ``str``);
     ``winner_candidate`` is omitted until a winner exists rather than sent as ``None``.
     """
     md = {
         "agent": run.agent,
         "config_snapshot": json.dumps(run.config_snapshot, sort_keys=True),
         "status": run.status,
-        "rounds_completed": str(run.rounds_completed),
+        "progress_completed": str(run.progress_completed),
+        "progress_unit": run.progress_unit,
     }
+    if run.progress_total is not None:
+        md["progress_total"] = str(run.progress_total)
     if run.winner_agent is not None:
         md["winner_candidate"] = run.winner_agent
     return md
 
 
 def experiment_metadata(candidate: Candidate, split: str) -> dict[str, str]:
-    """Identity/grouping metadata only. Eval results (reward/trials) are NOT copied this
-    PR — scores/traces arrive via the Intake rollup path later (spec §4.3).
-
-    Platform ``metadata`` is ``dict[str, str]``, so ``round`` is serialized via ``str``."""
-    return {"round": str(candidate.round), "candidate_id": candidate.label, "split": split}
+    """Identity/grouping metadata only. Eval results (reward/trials) are not copied here;
+    scores and traces arrive via the Intake rollup path (spec §4.3).
+
+    Platform ``metadata`` is ``dict[str, str]``, so ``generation`` is serialized via ``str``.
+    Both the durable id and the display label are recorded: ``ancestor`` references are
+    ids, while Experiment names are built from labels, so a consumer reconstructing
+    lineage needs the pair."""
+    return {
+        "generation": str(candidate.generation),
+        "candidate_id": candidate.id,
+        "candidate_label": candidate.label,
+        "split": split,
+    }
 
 
 class ExperimentMirror:
@@ -100,7 +113,11 @@ def __init__(self, client: AsyncNeMoPlatform, workspace: str) -> None:
         self._client = client
         self._workspace = workspace
         self._group_ids: dict[str, str] = {}  # run_id -> ExperimentGroup id
-        self._experiment_ids: dict[tuple[str, str], str] = {}  # (label, split) -> Experiment id
+        # Keyed by candidate *id*, because that is what ``Candidate.ancestor`` holds. The
+        # Experiment *name* is built from the display label instead — it is meant to be
+        # greppable — so the two are kept side by side rather than derived from each other.
+        self._experiment_ids: dict[tuple[str, str], str] = {}  # (candidate id, split) -> Experiment id
+        self._labels: dict[str, str] = {}  # candidate id -> display label
 
     # -- ExperimentGroup ----------------------------------------------------
 
@@ -201,7 +218,7 @@ async def _upsert_experiment(
                 workspace=self._workspace,
                 experiment_ids=[group_id],
                 source_link=link,
-                description=candidate.optimization,
+                description=candidate.description,
                 parent_evaluation_id=parent_id,
                 root_cause="",  # OQ-RC: left empty for now
                 status=st,
@@ -216,19 +233,21 @@ async def _upsert_experiment(
                 body_name=name,
                 experiment_ids=[group_id],
                 source_link=link,
-                description=candidate.optimization,
+                description=candidate.description,
                 parent_evaluation_id=parent_id,
                 root_cause="",  # OQ-RC: left empty for now
                 status=st,
                 metadata=md,
             )
-        self._experiment_ids[(candidate.label, split)] = exp.id
+        if candidate.id:
+            self._experiment_ids[(candidate.id, split)] = exp.id
+            self._labels[candidate.id] = candidate.label
 
     def _dataset_name(self, split: str) -> str:
         return split  # OQ-8: derive a real dataset name/version later
 
     def _source_link(self, gname: str, candidate: Candidate, agent_source: Any) -> str:
-        if candidate.round == 0 and agent_source is not None:
+        if candidate.is_baseline and agent_source is not None:
             return f"{agent_source.repo_url}@{agent_source.ref}"
         return pseudo_source_link(gname, candidate.label)
 
@@ -247,19 +266,34 @@ async def _existing_source_link(self, gname: str, label: str, split: str) -> str
         return exp.source_link
 
     async def _parent_experiment_id(self, candidate: Candidate, gname: str) -> str | None:
+        """The ancestor's Experiment id, or None when this run cannot name it.
+
+        ``ancestor`` is a candidate id and Experiment names are built from labels, so the
+        ancestor's label has to be resolved before a name can be composed. Within a run
+        the ancestor is always projected first; across a resume it may not be, and an
+        omitted lineage link is the honest outcome rather than a guessed name.
+        """
         if not candidate.ancestor:
             return None
         cached = self._experiment_ids.get((candidate.ancestor, "train"))
         if cached is not None:
             return cached
+        ancestor_label = self._labels.get(candidate.ancestor)
+        if ancestor_label is None:
+            logger.debug(
+                "Ancestor %r of candidate %r has not been projected; lineage link omitted",
+                candidate.ancestor,
+                candidate.label,
+            )
+            return None
         try:  # resume / ancestor created earlier this run
             exp = await self._client.evaluations.retrieve(
-                experiment_name(gname, candidate.ancestor, "train"), workspace=self._workspace
+                experiment_name(gname, ancestor_label, "train"), workspace=self._workspace
             )
         except NotFoundError:
             logger.debug(
                 "Ancestor experiment %r not found for candidate %r; lineage link omitted",
-                experiment_name(gname, candidate.ancestor, "train"),
+                experiment_name(gname, ancestor_label, "train"),
                 candidate.label,
             )
             return None
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/experimentalist_backend.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/experimentalist_backend.py
index a9cfebf172..115b7f9388 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/experimentalist_backend.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/experimentalist_backend.py
@@ -14,6 +14,7 @@
 import asyncio
 import json
 import logging
+import os
 import shutil
 import subprocess
 import uuid
@@ -31,6 +32,7 @@
     ExperimentRun,
     ResourceRef,
     TrialResult,
+    local_path_from_uri,
 )
 from nemo_experimentalist_plugin.experimentalist.atif import build_ingest_payload, read_session_id
 from nemo_experimentalist_plugin.experimentalist.components.repository import (
@@ -180,8 +182,13 @@ async def get_candidate(self, *, workspace: str, candidate_id: str) -> Candidate
         ...
 
     @abstractmethod
-    async def list_candidates(self, *, workspace: str, run_id: str) -> list[Candidate]:
-        """Return all Candidates that belong to a given ExperimentRun."""
+    async def list_candidates(self, *, workspace: str, run_id: str, include_discarded: bool = False) -> list[Candidate]:
+        """Return the Candidates belonging to an ExperimentRun.
+
+        Discarded candidates are excluded unless asked for: a rolled-back candidate is
+        still on disk, and a consumer that got one back would evaluate, rank or publish
+        work the run has already abandoned.
+        """
         ...
 
     # -- Result persistence --------------------------------------------------
@@ -278,9 +285,9 @@ async def get_agent_spec(self, *, workspace: str, spec: str, dest: Path) -> Path
 
 
 def load_candidate(path: Path) -> Candidate:
-    """Deserialize a ``metadata.json`` file into a :class:`Candidate`.
+    """Deserialize one stored candidate record into a :class:`Candidate`.
 
-    Free function rather than a backend method: read-only callers (the Coder's
+    Free function rather than a backend method: read-only callers (the CodeEditBuilder's
     workspace tool) need the deserialization without constructing a backend,
     which would create directories and projection state as a side effect.
     """
@@ -293,6 +300,46 @@ def load_candidate(path: Path) -> Candidate:
     return candidate
 
 
+def _atomic_write(path: Path, text: str) -> None:
+    """Write *text* to *path* so a reader never sees a partial file.
+
+    ``os.replace`` is atomic within a filesystem, so a crash leaves either the previous
+    contents or the new ones — never a truncated file.
+    """
+    temporary = path.with_name(f".{path.name}.tmp")
+    temporary.write_text(text, encoding="utf-8")
+    os.replace(temporary, path)
+
+
+def load_winner(run_dir: Path) -> Candidate:
+    """The winning Candidate of a finished run, read from its stored record.
+
+    Here so consumers do not rebuild the run layout themselves. ``run.json`` names the
+    winner by **label** — 'agent-3', the form every artifact path in the run is built
+    from — while the records under ``candidates/`` are filed by id, so this resolves one
+    to the other. The winner's location then comes from its own artifact reference,
+    which stays true even if candidates move off local disk.
+
+    Args:
+        run_dir: The run's directory — the one holding ``run.json`` and ``candidates/``.
+
+    Raises:
+        FileNotFoundError: if the run or the record it names is missing.
+        ValueError: if the run completed without selecting a winner.
+    """
+    document = json.loads((run_dir / "run.json").read_text(encoding="utf-8"))
+    winner_label = document.get("winner_agent")
+    if not isinstance(winner_label, str) or not winner_label:
+        raise ValueError(f"Run at {run_dir} completed without a selected winner")
+    for record in sorted((run_dir / "candidates").glob("*.json")):
+        candidate = load_candidate(record)
+        if candidate.label == winner_label:
+            return candidate
+    raise FileNotFoundError(
+        f"Run at {run_dir} names winner {winner_label!r}, but no candidate record carries that label"
+    )
+
+
 def _load_entity(cls: type[_ModelT], path: Path) -> _ModelT:
     """Deserialize *path* as JSON into *cls*, restoring the private ``_id`` field."""
     data = json.loads(path.read_text())
@@ -313,11 +360,12 @@ class LocalExperimentalistBackend(ExperimentalistBackend):
           eval-and-optimize/
             insight.json          ← loaded via get_insight(insight_id=path)
             run.json              ← ExperimentRun state
+            candidates/
+              <candidate-id>.json ← Candidate metadata and measurements
+              ...
             agents/
-              agent-0/
-                metadata.json     ← Candidate fields
+              agent-0/            ← the candidates' artifacts
               agent-1/
-                metadata.json
               ...
             analysis/
               round-0.md
@@ -340,7 +388,7 @@ def __init__(
         super().__init__(client, path, storage)
         self.path = path
         self._eo = path / "eval-and-optimize"
-        for subdir in ("agents", "analysis", "results"):
+        for subdir in ("agents", "analysis", "candidates", "results"):
             (self._eo / subdir).mkdir(parents=True, exist_ok=True)
         # Best-effort, one-way projection onto native platform Experiments. Active only when
         # a platform client is present (offline/local-only runs leave it a no-op); mirrors are
@@ -428,8 +476,17 @@ def _candidate_branch(self, candidate: Candidate) -> str:
         return f"{self.storage.candidate_branch_prefix}/{candidate.run_id}/{candidate.label}"
 
     def _candidate_code_dir(self, candidate: Candidate) -> Path:
-        """Local directory holding *candidate*'s code (the per-candidate agent dir)."""
-        return self._eo / "agents" / candidate.label
+        """Local directory holding *candidate*'s code, read off its artifact reference.
+
+        Raises:
+            ValueError: if the artifact does not exist. Falling back to the parent would
+                resolve to the shared candidate root and push every candidate's code as
+                this one's.
+        """
+        path = local_path_from_uri(candidate.artifact.uri, context="Candidate artifact")
+        if not path.exists():
+            raise ValueError(f"Candidate {candidate.label!r} ({candidate.id}) has no artifact at {path}")
+        return path if path.is_dir() else path.parent
 
     async def archive_candidate(self, *, workspace: str, candidate: Candidate) -> str | None:
         """Git implementation: push ``<prefix>/<run-id>/<label>`` (subtree at the agent's
@@ -442,7 +499,8 @@ async def archive_candidate(self, *, workspace: str, candidate: Candidate) -> st
         checkout, branch = self._agent_checkout, self._candidate_branch(candidate)
         code_dir = self._candidate_code_dir(candidate)
         message = (
-            f"Experimentalist candidate {candidate.label} (round {candidate.round}): {candidate.optimization}\n\n"
+            f"Experimentalist candidate {candidate.label} "
+            f"(generation {candidate.generation}): {candidate.description}\n\n"
             f"Candidate-Id: {candidate.id}"
         )
         pushed = await asyncio.to_thread(
@@ -471,9 +529,14 @@ async def publish_candidate(self, *, workspace: str, candidate: Candidate) -> st
         if src is None or self._agent_checkout is None:
             return None
         checkout, branch = self._agent_checkout, self._candidate_branch(candidate)
-        title = (
-            self.storage.pr_title
-            or f"Experimentalist: candidate {candidate.label} ({candidate.optimization_type or 'improvement'})"
+        # A PR title is one line, and `description` is the Proposer's graph-level prose —
+        # often several sentences, sometimes with newlines — which forges truncate or
+        # reject, and which `_compose_pr_body` already puts in the body. The optimization
+        # type is the short handle, and lives in the payload the Proposer and Builder own.
+        payload = candidate.generated_from.payload if candidate.generated_from is not None else {}
+        kind = payload.get("optimization_type")
+        title = self.storage.pr_title or (
+            f"Experimentalist: candidate {candidate.label} ({kind if isinstance(kind, str) and kind else 'improvement'})"
         )
         body = self.storage.pr_body or await self._compose_pr_body(workspace=workspace, candidate=candidate)
         code_dir = self._candidate_code_dir(candidate)
@@ -507,7 +570,7 @@ async def _compose_pr_body(self, *, workspace: str, candidate: Candidate) -> str
             if sib.label == _BASELINE_AGENT_LABEL:
                 continue
             marker = " (winner)" if sib.label == candidate.label else ""
-            metrics = sib.reward("validation").metrics or sib.reward("train").metrics or {}
+            metrics = sib.rewards["validation"].metrics or sib.rewards["train"].metrics or {}
             lines.append(f"- `{sib.label}`{marker}: `{self._candidate_branch(sib)}` — metrics={metrics}")
         return summary + "\n" + "\n".join(lines) + "\n"
 
@@ -528,44 +591,55 @@ async def get_agent_spec(self, *, workspace: str, spec: str, dest: Path) -> Path
     async def create_run(self, *, workspace: str, run: ExperimentRun) -> ExperimentRun:
         if not run.id:
             run._id = str(uuid.uuid4())  # type: ignore[attr-defined]
-        (self._eo / "run.json").write_text(run.model_dump_json(indent=2))
+        _atomic_write(self._eo / "run.json", run.model_dump_json(indent=2))
         await self._project_best_effort(workspace, lambda m: m.ensure_group(run))
         return run
 
     async def update_run(self, *, workspace: str, run: ExperimentRun) -> ExperimentRun:
-        (self._eo / "run.json").write_text(run.model_dump_json(indent=2))
+        # Written through a temp file and renamed, because this is rewritten on every
+        # progress report and it is the only record of which run owns the candidates on
+        # disk. A plain write_text truncates first, so killing the process mid-round leaves
+        # a half-written file that resume cannot parse.
+        _atomic_write(self._eo / "run.json", run.model_dump_json(indent=2))
         await self._project_best_effort(workspace, lambda m: m.update_group(run))
         return run
 
     # ------------------------------------------------------------------
-    # Candidate CRUD  (eval-and-optimize/agents/{label}/metadata.json)
+    # Candidate CRUD  (eval-and-optimize/candidates/{id}.json)
     #
-    # The candidate ``label`` is the agent directory name (e.g. "agent-0").
-    # Locally we use it as the entity id so lookup is O(1); remotely the store
-    # assigns the id and auto-slugs ``name`` (identity is the id, as for every
-    # entity in this plugin).
+    # Metadata lives in a store the runner owns, keyed by the candidate's durable
+    # id — never inside the artifact it describes. Listing therefore reads the
+    # store rather than walking a directory layout, so a strategy that does not
+    # produce one directory per candidate can still store, list and resume.
     # ------------------------------------------------------------------
 
-    def _candidate_path(self, label: str) -> Path:
-        if not label:
-            raise ValueError("Label is required")
-        return self._eo / "agents" / label / "metadata.json"
+    def _candidate_path(self, candidate_id: str) -> Path:
+        """Where *candidate_id*'s record lives, refusing an id that is not one name.
 
-    def _load_candidate(self, path: Path) -> Candidate:
-        """Deserialize a current-schema ``metadata.json`` file into a Candidate."""
-        return load_candidate(path)
+        The id is interpolated into a path, so one containing a separator escapes the
+        candidates directory: ``../run`` lands on ``eval-and-optimize/run.json`` and a
+        candidate write would overwrite the run. Ids are minted as uuids here, but a
+        Candidate can arrive from a component this repo did not write -- which is the
+        point of the registry -- so the check belongs at the path, not at the mint.
+        """
+        if not candidate_id:
+            raise ValueError("Candidate id is required")
+        if candidate_id != Path(candidate_id).name or candidate_id in {".", ".."}:
+            raise ValueError(f"Candidate id must be a single path component, got {candidate_id!r}")
+        return self._eo / "candidates" / f"{candidate_id}.json"
+
+    def _write_candidate(self, candidate: Candidate) -> None:
+        path = self._candidate_path(candidate.id)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        # Atomic for the same reason as run.json: this runs on every record_reward, and a
+        # truncated candidates/<id>.json makes list_candidates raise, which leaves the whole
+        # run unresumable rather than losing one record.
+        _atomic_write(path, json.dumps({**candidate.model_dump(), "id": candidate.id}, indent=2))
 
     async def create_candidate(self, *, workspace: str, candidate: Candidate) -> Candidate:
         if not candidate.id:
-            candidate._id = candidate.label or str(uuid.uuid4())  # type: ignore[attr-defined]
-        p = self._candidate_path(candidate.label)
-        p.parent.mkdir(parents=True, exist_ok=True)
-        p.write_text(
-            json.dumps(
-                {**candidate.model_dump(), "id": candidate.id},
-                indent=2,
-            )
-        )
+            candidate._id = str(uuid.uuid4())  # type: ignore[attr-defined]
+        self._write_candidate(candidate)
         await self._project_best_effort(
             workspace,
             lambda m: m.project_candidate(
@@ -577,13 +651,7 @@ async def create_candidate(self, *, workspace: str, candidate: Candidate) -> Can
         return candidate
 
     async def update_candidate(self, *, workspace: str, candidate: Candidate) -> Candidate:
-        p = self._candidate_path(candidate.label)
-        p.write_text(
-            json.dumps(
-                {**candidate.model_dump(), "id": candidate.id},
-                indent=2,
-            )
-        )
+        self._write_candidate(candidate)
         await self._project_best_effort(
             workspace,
             lambda m: m.project_candidate(
@@ -595,19 +663,15 @@ async def update_candidate(self, *, workspace: str, candidate: Candidate) -> Can
         return candidate
 
     async def get_candidate(self, *, workspace: str, candidate_id: str) -> Candidate:
-        # In local mode the store id equals the candidate label (e.g. "agent-0"),
-        # which is also the agent directory name.
-        p = self._candidate_path(candidate_id)
-        return self._load_candidate(p)
-
-    async def list_candidates(self, *, workspace: str, run_id: str) -> list[Candidate]:
-        results: list[Candidate] = []
-        agents_dir = self._eo / "agents"
-        for meta in sorted(agents_dir.glob("*/metadata.json")):
-            c: Candidate = self._load_candidate(meta)
-            if c.run_id == run_id:
-                results.append(c)
-        return results
+        return load_candidate(self._candidate_path(candidate_id))
+
+    async def list_candidates(self, *, workspace: str, run_id: str, include_discarded: bool = False) -> list[Candidate]:
+        store = self._eo / "candidates"
+        if not store.is_dir():
+            return []
+        candidates = [load_candidate(path) for path in sorted(store.glob("*.json"))]
+        live = (c for c in candidates if c.run_id == run_id and (include_discarded or not c.discarded))
+        return sorted(live, key=lambda c: (c.generation, c.label))
 
     # ------------------------------------------------------------------
     # Result persistence  (eval-and-optimize/OPTIMIZATION.md)
@@ -630,7 +694,6 @@ async def persist_evaluation(
         if self.client is None:
             return  # pure-offline run: traces stay on local disk
 
-        # Derive the Evaluation name internally (ensures the entity exists and returns a deterministic name).
         evaluation_name = await self.get_evaluation_name(workspace=workspace, candidate=candidate, split=split)
         if not evaluation_name:
             return  # projection failed (shouldn't happen, but defensive)
@@ -777,11 +840,11 @@ async def persist_result(self, *, workspace: str, result: ExperimentalistResult)
         if run_path.exists():
             run: ExperimentRun = _load_entity(ExperimentRun, run_path)
             run.status = "completed"
-            run.rounds_completed = result.rounds_completed
+            run.progress_completed = result.progress_completed
             run.summary = result.summary  # so publish_candidate's _compose_pr_body reads the real summary
             if result.winner is not None:
-                run.winner_agent = result.winner.id
-            run_path.write_text(run.model_dump_json(indent=2))
+                run.winner_agent = result.winner.label
+            _atomic_write(run_path, run.model_dump_json(indent=2))
         await self._project_best_effort(
             workspace,
             lambda m: m.finalize(
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/registry.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/registry.py
new file mode 100644
index 0000000000..ce4689890b
--- /dev/null
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/registry.py
@@ -0,0 +1,181 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Components are found by ``(role, name)``, and our own register like anyone else's.
+
+This is the whole plugin mechanism. A developer writes a component in *their* package,
+ships one entry point, ``pip install``s it beside this one, and selects it by name in
+config — without ever checking out this repository:
+
+    [project.entry-points."nemo.experimentalist.components"]
+    "strategy.bandit" = "acme_strategies.bandit"
+
+The entry point's only job is to import the module, so the ``__init_subclass__`` below
+fires and the class registers itself. First-party components need no entry point: they
+register by being imported, which :func:`load_plugins` also arranges.
+
+Two behaviours are deliberately different:
+
+* **Resolving** a named component raises on an unknown name. Never skip, never fall back
+  to a default: a run configured for ``strategy: bandit`` that quietly runs the
+  evolutionary loop instead has produced a result for a question nobody asked.
+* **Enumerating** degrades. One third-party package that fails to import must not take
+  down a run that does not use it — the failure is logged, and asking for that component
+  by name still raises with the reason attached.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Mapping
+from importlib.metadata import entry_points
+from typing import Any, ClassVar
+
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+#: Entry-point group third parties ship their components in.
+ENTRY_POINT_GROUP = "nemo.experimentalist.components"
+
+#: Import failures from :func:`load_plugins`, keyed by entry-point name, so a later
+#: resolution failure can say *why* the component is missing rather than only that it is.
+_LOAD_FAILURES: dict[str, str] = {}
+
+_loaded = False
+
+
+def _identity(component: type["Component"]) -> tuple[str, str]:
+    """Where a component class is defined, which is what makes two of them the same one."""
+    return (component.__module__, component.__qualname__)
+
+
+class Component:
+    """Base of every resolvable component. Subclassing with a name registers it.
+
+    ``role`` says what slot this fills (``"strategy"``, ``"builder"``, …) and ``name``
+    which implementation it is. A class that sets ``role`` but no ``name`` is a role base
+    class — ``Strategy``, ``Builder`` — and stays unregistered, which is what lets the
+    roles be declared here without pretending to be implementations.
+    """
+
+    role: ClassVar[str] = ""
+    name: ClassVar[str] = ""
+
+    #: Pydantic model this component's ``<role>_config`` slice is validated against.
+    #: Declared by the component because the component owns its settings: the run config
+    #: carries that slice as a plain mapping, so a component from another package is
+    #: configurable without this repo knowing its fields. ``None`` means it takes none.
+    config_type: ClassVar[type[BaseModel] | None] = None
+
+    #: Every registered component, keyed by ``(role, name)``. Private: mutating it
+    #: from outside ``__init_subclass__`` is how a name silently stops meaning what
+    #: it resolved to a moment ago.
+    _registry: ClassVar[dict[tuple[str, str], type["Component"]]] = {}
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        # Cooperative: nooa's Agent also defines __init_subclass__ and consumes its own
+        # keywords, so a component that is both an Agent and a Component registers only
+        # because both links in the chain call up.
+        super().__init_subclass__(**kwargs)
+        # `role` is inherited on purpose — CodeEditBuilder gets "builder" from Builder. `name` is
+        # read from this class alone: inheriting it would make `class MyCoder(CodeEditBuilder)`
+        # look like a second claim on "code-edit" and raise at import, which is the most
+        # obvious way someone customises a built-in Builder. A subclass registers by
+        # naming itself, or not at all.
+        role, name = cls.__dict__.get("role", cls.role), cls.__dict__.get("name", "")
+        if not (role and name):
+            return
+        key = (role, name)
+        existing = Component._registry.get(key)
+        # By module and qualname, not object identity: a module executed twice — reloaded,
+        # or reachable under two import paths — re-registers rather than clashing with
+        # itself. Two *different* classes claiming one name still raises.
+        if existing is not None and _identity(existing) != _identity(cls):
+            raise RuntimeError(
+                f"duplicate component {role}.{name}: {existing.__module__}.{existing.__qualname__} "
+                f"and {cls.__module__}.{cls.__qualname__}"
+            )
+        Component._registry[key] = cls
+
+
+def load_plugins(*, force: bool = False) -> None:
+    """Import every installed component package so its classes self-register.
+
+    Idempotent. A broken third-party entry point is logged and skipped rather than
+    raised, so it only breaks runs that actually name it.
+    """
+    global _loaded
+    if _loaded and not force:
+        return
+    # Marked loaded only after a full pass. Setting it up front means that if
+    # ``entry_points()`` itself raises, discovery is recorded as done and never retried —
+    # every later resolution then fails for a component that is installed and fine.
+    _LOAD_FAILURES.clear()
+    for entry_point in entry_points(group=ENTRY_POINT_GROUP):
+        try:
+            entry_point.load()
+        except Exception as exc:  # noqa: BLE001 - one bad plugin must not kill unrelated runs
+            _LOAD_FAILURES[entry_point.name] = f"{type(exc).__name__}: {exc}"
+            logger.warning(
+                "[REGISTRY] component entry point %r (%s) failed to import; components it "
+                "provides will not resolve: %s",
+                entry_point.name,
+                entry_point.value,
+                exc,
+            )
+    _loaded = True
+
+
+def registered(role: str) -> list[str]:
+    """Names registered for *role*, sorted. What ``strategies list`` will read."""
+    load_plugins()
+    return sorted(name for registered_role, name in Component._registry if registered_role == role)
+
+
+def resolve(role: str, name: str) -> type[Component]:
+    """The class registered as *(role, name)*.
+
+    Raises:
+        LookupError: if nothing is registered under that name. The message lists what is,
+            and names any plugin that failed to import — the usual cause of a name that
+            the user is certain they installed.
+    """
+    load_plugins()
+    component = Component._registry.get((role, name))
+    if component is not None:
+        return component
+    known = registered(role) or ["(none)"]
+    detail = f"; known {role}: {', '.join(known)}"
+    if _LOAD_FAILURES:
+        broken = "; ".join(f"{ep} ({why})" for ep, why in sorted(_LOAD_FAILURES.items()))
+        detail += f". Note these component packages failed to import: {broken}"
+    raise LookupError(f"no {role} registered as {name!r}{detail}")
+
+
+def get_component(role: str, name: str, **kwargs: Any) -> Any:
+    """Resolve *(role, name)* and construct it.
+
+    Construction arguments are the consuming strategy's business, not the registry's, so
+    *kwargs* pass through untouched — except ``config``, which is validated against the
+    resolved component's own ``config_type``. That is what lets the run config keep each
+    ``<role>_config`` as a plain mapping: a third-party component validates its settings
+    with its own model, and a typo still fails while the run is starting rather than at
+    round three, an hour of image builds later.
+    """
+    component = resolve(role, name)
+    return component(**validated_config(component, kwargs))
+
+
+def validated_config(component: type[Component], kwargs: dict[str, Any]) -> dict[str, Any]:
+    """*kwargs* with ``config`` validated against *component*'s own ``config_type``.
+
+    Separate from :func:`get_component` because the context builds components its own way
+    -- it narrows the run-scoped arguments to those the constructor names -- and both
+    paths must validate, or whichever one a role happens to use decides whether a typo in
+    its settings is caught.
+    """
+    config = kwargs.get("config")
+    if component.config_type is None or not isinstance(config, Mapping):
+        return kwargs
+    return {**kwargs, "config": component.config_type.model_validate(dict(config))}
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/reporting.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/reporting.py
index 17366d3676..0110b8ee02 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/reporting.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/reporting.py
@@ -17,7 +17,7 @@
 from pathlib import Path
 from typing import TextIO
 
-from nemo_experimentalist_plugin.config import MetricTarget
+from nemo_experimentalist_plugin.entities import MetricTarget
 
 _RULE = "═" * 62
 _THIN = "─" * 62
@@ -35,6 +35,11 @@ class Verbosity(str, Enum):
     NORMAL = "normal"
 
 
+def reward_scalar(aggregate_metrics: dict[str, float | int]) -> float:
+    """Extract the scalar reward from an evaluation's aggregate metrics."""
+    return float(aggregate_metrics.get("reward", 0.0))
+
+
 class RunReporter:
     """Formats run-progress narration to a sink. Never raises into the run."""
 
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/result.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/result.py
index 0d4a4038f1..7c7b349605 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/result.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/result.py
@@ -33,9 +33,9 @@ class ExperimentalistResult(BaseModel):
         min_length=1,
         description="ExperimentRun entity id updated by persist_result.",
     )
-    rounds_completed: int = Field(
+    progress_completed: int = Field(
         ge=0,
-        description="Number of full optimization rounds that ran.",
+        description="Units of work the strategy reported finished — rounds, trials, whatever it counts.",
     )
     winner: Candidate | None = Field(
         default=None,
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/roles.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/roles.py
new file mode 100644
index 0000000000..15b755eb0f
--- /dev/null
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/roles.py
@@ -0,0 +1,247 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""The roles a component can fill, and what each must implement.
+
+Each class sets ``role`` and leaves ``name`` empty, so it declares a slot without
+claiming to implement it.
+
+A role's *signature* is owned by whatever resolves it, not by this module: an
+out-of-tree builder targets the evolutionary strategy's ``builder`` contract, because
+that strategy is what calls it.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar
+
+from nemo_experimentalist_plugin.entities import Candidate, Dataset, EvaluationResult, Proposal, RewardRecord
+from nemo_experimentalist_plugin.experimentalist.components.evaluator.base import Evaluator, EvaluatorConfig
+from nemo_experimentalist_plugin.experimentalist.registry import Component
+from nemo_experimentalist_plugin.experimentalist.seam import BuilderContext, StrategyContext
+
+if TYPE_CHECKING:
+    from nemo_experimentalist_plugin.experimentalist.components.terminator import TerminationDecision
+
+
+class Strategy(Component):
+    """Optimize the agent under test and return the winner.
+
+    One entry point, not two: a strategy reads ``ctx.resuming`` and one that does not care
+    ignores it. ``supports_resume`` is a ``ClassVar`` rather than an optional ``resume()``
+    so it is answerable from the class — which is what lets ``strategies list`` report it
+    without constructing anything. The runner happens to read it off the instance it
+    already resolved.
+    """
+
+    role: ClassVar[str] = "strategy"
+
+    #: When False the runner refuses a resume loudly, naming the strategy, rather than
+    #: silently starting over. These runs cost hours; the silent restart is the expensive
+    #: failure, and preventing it is the whole point of the flag.
+    supports_resume: ClassVar[bool] = False
+
+    async def run(self, ctx: StrategyContext) -> Candidate | None:
+        """Run the optimization and return the winning Candidate, or None if there is none."""
+        raise NotImplementedError
+
+
+class OutcomeEvaluator(Component, Evaluator):
+    """Measure a candidate's artifact and return an EvaluationResult.
+
+    Named for the role rather than the implementation: it is platform vocabulary
+    (`EvaluationResult`, `persist_evaluation`, NeMo Evaluator), and it measures the
+    *outcome*, where a trajectory-scorer measures the process of the same run.
+
+    Two bases because they answer different questions. :class:`Evaluator` is the *shape*
+    — what it means to measure an artifact — and is usable without the registry, which is
+    what lets the Builder hold one for its own smoke checks without registering it.
+    :class:`Component` is the *role*: resolvable by name, and swappable from config.
+
+    Inheriting both means resolving this role yields one type that is constructible
+    (``options``, ``experiment_dir``) and carries the two ClassVars, rather than an
+    implicit pairing a plugin author would have to infer.
+    """
+
+    role: ClassVar[str] = "outcome-evaluator"
+
+    #: Dataset implementation this evaluator consumes, and the model it validates its
+    #: options with. Declared here so resolving the component is enough to build both:
+    #: a factory keyed on a hardcoded name cannot be swapped by config, whatever the
+    #: registry says.
+    dataset_type: ClassVar[type[Dataset]]
+    config_type: ClassVar[type[EvaluatorConfig]]
+
+    #: ``run(agent, dataset, ...) -> EvaluationResult`` is inherited from :class:`Evaluator`
+    #: rather than redeclared: overriding it here with a stub would shadow the working
+    #: implementation every evaluator relies on.
+
+
+class Proposer(Component):
+    """Turn scored candidates into Proposals for the next round."""
+
+    role: ClassVar[str] = "proposer"
+
+    #: Proposal kinds this Proposer emits, checked against the Builder's ``accepts``
+    #: before the run starts. Empty means undeclared, and the pairing is only found out
+    #: per proposal, a round at a time.
+    produces: ClassVar[frozenset[str]] = frozenset()
+
+    async def run(
+        self,
+        *,
+        analysis: str,
+        candidates: list[Candidate],
+        round_num: int,
+        max_candidates: int,
+        hint: str | None = None,
+    ) -> list[Proposal]:
+        """Up to *max_candidates* Proposals for the next round.
+
+        Args:
+            analysis: The round's diagnosis, or an empty string when none was produced.
+            candidates: The scored population to propose against; lineage is on each one.
+            round_num: The round these Proposals are for.
+            max_candidates: Upper bound. Returning fewer is normal.
+            hint: A free-form steer from the strategy — the evolutionary loop alternates
+                "exploration" and "exploitation". Ignorable.
+        """
+        raise NotImplementedError
+
+
+class Analyzer(Component):
+    """Diagnose why candidates fail, as input to proposing.
+
+    Optional: a strategy that does not reason about failures — numeric search — selects
+    none and skips the train evaluation that feeds it.
+    """
+
+    role: ClassVar[str] = "root-cause-analyzer"
+
+    async def run(
+        self,
+        *,
+        candidate: Candidate,
+        dataset: Dataset,
+        evaluation: EvaluationResult,
+        peer_evaluations: dict[str, EvaluationResult] | None = None,
+        round_num: int | None = None,
+        agent_spec: Path | None = None,
+    ) -> object:
+        """Diagnose why *candidate* scored what it did, for the Proposer to act on.
+
+        Peers are passed so a diagnosis can say what this candidate did differently,
+        which is the difference between a root cause and a description.
+        """
+        raise NotImplementedError
+
+
+class Terminator(Component):
+    """Decide whether to stop before the round budget is spent."""
+
+    role: ClassVar[str] = "terminator"
+
+    async def run(
+        self,
+        *,
+        round_num: int,
+        candidates: list[Candidate],
+        prior_analysis: str | None = None,
+    ) -> "TerminationDecision":
+        """Whether to stop *before* spending another round.
+
+        Only early stopping: the round budget is the loop's own and holds regardless, so
+        a terminator that never stops cannot produce an unbounded run.
+        """
+        raise NotImplementedError
+
+
+class TrajectoryScorer(Component):
+    """Score the steps a candidate took, not just its outcome.
+
+    A second measurement of the same run, landing in its own reward channel.
+    """
+
+    role: ClassVar[str] = "trajectory-scorer"
+
+    async def run(
+        self,
+        ctx: "StrategyContext",
+        *,
+        candidates: list[Candidate],
+        round_num: int = 0,
+        analysis: str | None = None,
+    ) -> dict[str, RewardRecord]:
+        """One reward record per candidate **id**, measuring *how* it got there.
+
+        Keyed by id rather than by the Candidate: a Candidate is a pydantic model and so
+        unhashable, and identity is the id in any case.
+
+        Whatever a scorer needs to decompose a trajectory — the built-in ranks against a
+        goal tree it builds and refines itself — is its own state, kept wherever it likes
+        under the run. The strategy hands over the population and this round's analysis
+        and takes back reward records.
+
+        Returning fewer records than candidates is normal: a candidate with no usable
+        traces is skipped rather than scored zero.
+        """
+        raise NotImplementedError
+
+
+class Selector(Component):
+    """Decide which candidates breed, and which one wins.
+
+    Ranks on reward channels alone and never reads a Proposal or an artifact, which is
+    what lets one selector serve a code-optimizing run and a numeric one.
+    """
+
+    role: ClassVar[str] = "selector"
+
+    async def survivors(self, candidates: list[Candidate], *, k: int) -> list[Candidate]:
+        """Up to *k* candidates to carry into the next round as parents."""
+        raise NotImplementedError
+
+    def winner(self, candidates: list[Candidate]) -> Candidate | None:
+        """The run's winner, or None when nothing is eligible."""
+        raise NotImplementedError
+
+
+class Builder(Component):
+    """Turn one Proposal into one committed Candidate.
+
+    The Builder owns the whole span: it asks the context for somewhere to work, writes,
+    and hands back the committed Candidate. No filesystem path crosses into it from
+    outside, which is what lets candidate storage move without changing this signature.
+
+    A build that cannot succeed raises. It leaves no Candidate behind, so there is no
+    half-finished record to resurrect on resume and no killed marker to remember to write.
+    """
+
+    role: ClassVar[str] = "builder"
+
+    #: Proposal kinds this Builder accepts. The strategy drops a proposal no configured
+    #: Builder claims, so a Proposer and Builder that disagree produce empty rounds.
+    accepts: ClassVar[frozenset[str]] = frozenset()
+
+    async def build(self, ctx: BuilderContext, proposal: Proposal, *, generation: int) -> Candidate:
+        """Build *proposal* and return the Candidate committed for it.
+
+        Args:
+            ctx: The two verbs a Builder gets — reserve a working copy, commit the result.
+            proposal: What to change, and what to change it from.
+            generation: Strategy-supplied grouping index, stamped onto the Candidate.
+                It travels through rather than being used, because the strategy owns what
+                a generation means and the Builder is what holds the commit.
+        """
+        raise NotImplementedError
+
+    async def describe(self, artifact: Path) -> None:
+        """Write whatever a later build of *artifact* will want to read back.
+
+        The CodeEditBuilder documents the architecture here, because the next build's proposal is
+        written against that document. The strategy calls this for the baseline; a
+        Builder calls it for the candidates it builds. A Builder with nothing to say does
+        nothing, which is why this is not abstract.
+        """
+        return None
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/run.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/run.py
index a1b960911a..88bbbfef78 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/run.py
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/run.py
@@ -9,12 +9,12 @@
 
 from nemo_experimentalist_plugin.entities import DatasetRef
 from nemo_experimentalist_plugin.experimentalist.agent import build_experimentalist_agent
-from nemo_experimentalist_plugin.experimentalist.components.loop import EvolutionaryOptimizerConfig
-from nemo_experimentalist_plugin.experimentalist.deps import ExperimentalistDeps
 from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import (
     make_experimentalist_backend,
 )
 from nemo_experimentalist_plugin.experimentalist.reporting import RunReporter, Verbosity
+from nemo_experimentalist_plugin.experimentalist.runner import ExperimentRunner
+from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryOptimizerConfig
 from nemo_platform import AsyncNeMoPlatform
 from nemo_platform_plugin.nooa_model_client import (
     ConfiguredModelClients,
@@ -43,7 +43,7 @@ def build_run_reporter(
 
 async def run_experimentalist(
     *,
-    agent: Path | str | None = None,
+    agent: str | Path | None = None,
     agent_spec: str | None = None,
     insight: Path | str | None,
     train_dataset: DatasetRef,
@@ -51,16 +51,16 @@ async def run_experimentalist(
     experiment_dir: Path,
     workspace: str,
     client: AsyncNeMoPlatform | None,
+    model_refs: ConfiguredModelRefs | None = None,
     config: EvolutionaryOptimizerConfig,
     task_template: DatasetRef | None = None,
     framework_skills_dirs: list[Path] | None = None,
-    model_refs: ConfiguredModelRefs | None = None,
 ) -> str:
     """Build and run the Experimentalist against an agent and dataset.
 
     Args:
         agent: Optional baseline agent for Mode 2, or an override for the agent
-            referenced by ``insight``. A local directory or a git ``url@ref``; a git
+            referenced by ``insight``. A local directory path or a git ``url@ref``; a git
             source is fetched by the backend and enables opening a draft PR/MR for
             the winner against that ref.
         agent_spec: Optional URI of a markdown file describing the agent under test.
@@ -72,12 +72,12 @@ async def run_experimentalist(
         task_template: Evaluator-specific task template used for production traces.
         experiment_dir: Working directory for optimization artifacts.
         workspace: Platform workspace.
-        client: Optional caller-owned Platform client. When omitted, the run
-            creates one from the active Platform context for model resolution;
-            the data backend remains local-only.
+        model_refs: Optional explicit default/fast Model Entity IDs. Unset uses the
+            active Platform CLI context.
+        client: Optional caller-owned Platform client. Local-only Mode 2 runs
+            may pass ``None``; Platform Insight access, mirroring, and Intake
+            persistence require a client.
         config: Evolutionary optimizer configuration.
-        model_refs: Optional explicit default/fast Model Entity IDs. Unset uses
-            the active Platform CLI context.
 
     Returns:
         Terminal optimization summary.
@@ -103,38 +103,32 @@ async def run_experimentalist(
         experiments_output=str(experiment_dir),
         storage=config.storage,
     )
+    # Every component resolves its models through the platform (#1159), so the resolved
+    # clients have to stay active for the whole run, not just while the runner is built.
     model_platform_client = client or AsyncNeMoPlatform()
     owns_model_platform_client = client is None
     model_clients: ConfiguredModelClients | None = None
     try:
         model_clients = await resolve_model_clients(model_platform_client, model_refs)
-        deps = ExperimentalistDeps(
-            workspace=workspace,
-            agent=agent,
-            agent_spec=agent_spec,
-            insight=insight,
-            train_dataset=train_dataset,
-            validation_dataset=validation_dataset,
-            task_template=task_template,
-            evaluator_type=config.evaluator_type,
-            backend=backend,
-            reporter=reporter,
-            config=config,
-        )
         with activate_model_clients(model_clients):
-            experimentalist = build_experimentalist_agent(
-                working_dir=experiment_dir,
+            result = await ExperimentRunner(
+                backend=backend,
+                strategy=build_experimentalist_agent(
+                    working_dir=experiment_dir,
+                    config=config,
+                    framework_skills_dirs=framework_skills_dirs,
+                ),
                 config=config,
-                framework_skills_dirs=framework_skills_dirs,
-            )
-            result = await experimentalist.run(deps)
-        winner = result.winner
-        reporter.run_finished(
-            winner=winner.label if winner is not None else None,
-            scores=dict(winner.reward("validation").metrics) if winner and winner.reward("validation").metrics else {},
-            report_path=(experiment_dir / "eval-and-optimize" / "OPTIMIZATION.md") if winner is not None else None,
-        )
-        return result.summary
+                workspace=workspace,
+                root=experiment_dir,
+                agent=agent,
+                agent_spec=agent_spec,
+                insight=insight,
+                train_dataset=train_dataset,
+                validation_dataset=validation_dataset,
+                task_template=task_template,
+                reporter=reporter,
+            ).run()
     finally:
         try:
             if model_clients is not None:
@@ -142,3 +136,11 @@ async def run_experimentalist(
         finally:
             if owns_model_platform_client:
                 await model_platform_client.close()
+
+    winner = result.winner
+    reporter.run_finished(
+        winner=winner.label if winner is not None else None,
+        scores=dict(winner.rewards["validation"].metrics) if winner and winner.rewards["validation"].metrics else {},
+        report_path=(experiment_dir / "eval-and-optimize" / "OPTIMIZATION.md") if winner is not None else None,
+    )
+    return result.summary
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/runner.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/runner.py
new file mode 100644
index 0000000000..ccb68b22a0
--- /dev/null
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/runner.py
@@ -0,0 +1,446 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""The experiment runner — the composition root.
+
+It does three things: **prepare inputs → run one strategy → persist and publish.**
+Inputs are an agent directory, an optional ``Insight``, and the eval datasets; the
+strategy is whatever the run was configured with; persisting and publishing are the
+host's, not the strategy's.
+
+The runner is the only code that holds an
+:class:`~nemo_experimentalist_plugin.experimentalist.experimentalist_backend.ExperimentalistBackend`.
+Everything a strategy is allowed to reach goes through the
+:class:`~nemo_experimentalist_plugin.experimentalist.context.ExperimentContext` it builds.
+"""
+
+from __future__ import annotations
+
+import logging
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig, with_insight_objective
+from nemo_experimentalist_plugin.entities import (
+    Candidate,
+    Dataset,
+    DatasetRef,
+    ExperimentRun,
+)
+from nemo_experimentalist_plugin.experimentalist.components.dataset_staging import (
+    distribute_insight_suite_tasks,
+    stage_eval_author_inputs,
+)
+from nemo_experimentalist_plugin.experimentalist.components.evaluator.factory import (
+    DatasetFactory,
+    EvaluatorFactory,
+)
+from nemo_experimentalist_plugin.experimentalist.components.holdout_utils import (
+    ensure_heldout_hidden,
+    restore_heldout_splits,
+)
+from nemo_experimentalist_plugin.experimentalist.context import RUN_LAYOUT, ExperimentContext
+from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import (
+    ExperimentalistBackend,
+)
+from nemo_experimentalist_plugin.experimentalist.reporting import RunReporter
+from nemo_experimentalist_plugin.experimentalist.result import ExperimentalistResult
+from nemo_experimentalist_plugin.experimentalist.roles import Strategy
+
+logger = logging.getLogger(__name__)
+
+#: Names the winner's artifact must not carry into the user's workspace, named by the
+#: owner that generates them rather than as one flat list — a third-party strategy's
+#: real output has to survive this, and it cannot if the reason for each entry is lost.
+_STRATEGY_ARTIFACTS = frozenset({"architecture.md"})
+_EVALUATOR_ARTIFACTS = frozenset({"harbor_wrapper.py", "dind_environment.py"})
+
+
+@dataclass(frozen=True)
+class PreparedInputs:
+    """Everything the strategy runs against, after the runner has materialized it."""
+
+    agent_dir: Path
+    agent_name: str
+    agent_spec: Path | None
+    insight_ref: str | None
+    datasets: dict[str, Dataset]
+
+
+class ExperimentRunner:
+    """Wires one run up and calls it in order.
+
+    Args:
+        backend: The run's data-access backend. Not shared with the strategy.
+        strategy: The optimization strategy to run.
+        config: Resolved run configuration.
+        workspace: NeMo Platform workspace.
+        root: Working directory for run artifacts.
+        agent: Baseline agent — a local directory, a git ``url@ref``, or None to take
+            the agent the Insight names.
+        agent_spec: Optional URI of a markdown description of the agent under test.
+        insight: Optional Insight id or local Insight file.
+        train_dataset: Dataset reference the strategy develops against.
+        validation_dataset: Dataset reference the winner is selected on.
+        task_template: Evaluator-specific task template; required with an Insight.
+        reporter: Optional human narration sink.
+    """
+
+    def __init__(
+        self,
+        *,
+        backend: ExperimentalistBackend,
+        strategy: Strategy,
+        config: EvolutionaryOptimizerConfig,
+        workspace: str,
+        root: Path,
+        agent: str | Path | None,
+        agent_spec: str | None = None,
+        insight: str | Path | None = None,
+        train_dataset: DatasetRef,
+        validation_dataset: DatasetRef,
+        task_template: DatasetRef | None = None,
+        reporter: RunReporter | None = None,
+    ) -> None:
+        if agent is None and insight is None:
+            raise ValueError("One of 'insight' or 'agent' must be set.")
+        if insight is not None and task_template is None:
+            raise ValueError("'task_template' is required when 'insight' is set.")
+        self._backend = backend
+        self._strategy = strategy
+        self._config = config
+        self._workspace = workspace
+        self._root = root.resolve()
+        self._agent = agent
+        self._agent_spec = agent_spec
+        self._insight = insight
+        self._train_dataset = train_dataset
+        self._validation_dataset = validation_dataset
+        self._task_template = task_template
+        self._reporter = reporter
+        # One object for the whole run, so every component runs on the tiers the run
+        # record reports and not on whatever the environment says at each construction.
+        self._eo = self._root / "eval-and-optimize"
+
+    async def run(self) -> ExperimentalistResult:
+        """Prepare inputs, run the strategy, then persist and publish the outcome."""
+        self._preflight()
+        for subdir in ("agents", "analysis", "results"):
+            (self._eo / subdir).mkdir(parents=True, exist_ok=True)
+        evaluator = EvaluatorFactory().build_evaluator(
+            self._config.outcome_evaluator, self._config.outcome_evaluator_config, experiment_dir=self._root
+        )
+        inputs = await self._prepare_inputs()
+        run, resuming = await self._open_run(inputs)
+        ctx = ExperimentContext(
+            backend=self._backend,
+            workspace=self._workspace,
+            run=run,
+            root=self._root,
+            agent_dir=inputs.agent_dir,
+            agent_spec=inputs.agent_spec,
+            datasets=inputs.datasets,
+            evaluator=evaluator,
+            resuming=resuming,
+            reporter=self._reporter,
+            objective_metrics=self._config.objective_function,
+            regression_metrics=self._config.regression_metrics,
+        )
+        if resuming:
+            await self._seed_narration_baseline(ctx)
+
+        # Finalizing is inside the handler, not after it. It resolves the winner's
+        # artifact, copies it out and persists the result — any of which can fail — and
+        # if it did, the run entity stayed `running` forever with no result written,
+        # while the work had actually finished.
+        try:
+            winner = await self._strategy.run(ctx)
+            return await self._finalize(ctx, run, inputs, winner)
+        except Exception:
+            run.status = "failed"
+            await self._backend.update_run(workspace=self._workspace, run=run)
+            raise
+
+    # -- Prepare -------------------------------------------------------------
+
+    def _preflight(self) -> None:
+        """Fail fast when persistence is enabled but the tool it needs is missing."""
+        storage = self._config.storage
+        if (storage.archive_candidates or storage.publish_winner) and shutil.which("git") is None:
+            raise ValueError(
+                "Candidate persistence is enabled (storage.archive_candidates/publish_winner) "
+                "but 'git' is not on PATH, so nothing can be persisted. Install git, or disable "
+                "storage to run without persistence."
+            )
+
+    async def _prepare_inputs(self) -> PreparedInputs:
+        """Materialize the agent, the datasets, and — with an Insight — its eval suite."""
+        dataset_factory = DatasetFactory()
+        train_ref, validation_ref, template_ref = (
+            self._train_dataset,
+            self._validation_dataset,
+            self._task_template,
+        )
+
+        insight = None
+        if self._insight is not None:
+            insight = await self._backend.get_insight(workspace=self._workspace, insight_id=str(self._insight))
+            if self._backend.client is None:
+                raise ValueError("Platform client is required for insight task template loading")
+            assert template_ref is not None
+            staged = await stage_eval_author_inputs(
+                self._root,
+                train_dataset=train_ref,
+                validation_dataset=validation_ref,
+                task_template=template_ref,
+                client=self._backend.client,
+                workspace=self._workspace,
+            )
+            train_ref, validation_ref, template_ref = (
+                staged.train_dataset,
+                staged.validation_dataset,
+                staged.task_template,
+            )
+
+        datasets: dict[str, Dataset] = {
+            # allow_empty in insight mode: the Eval Author fills these splits, so they are
+            # legitimately empty when the run starts.
+            "train": dataset_factory.build_dataset(
+                self._config.outcome_evaluator, train_ref, allow_empty=insight is not None
+            ),
+            "validation": dataset_factory.build_dataset(
+                self._config.outcome_evaluator, validation_ref, allow_empty=insight is not None
+            ),
+        }
+
+        agent_ref = self._agent if self._agent is not None else (insight.agent if insight is not None else None)
+        if agent_ref is None:
+            raise ValueError("Insight or agent is required")
+        agent_dir = self._eo / "source-agent"
+        await self._backend.get_agent_code(
+            workspace=self._workspace,
+            agent=agent_ref,
+            dest=agent_dir,
+            clone_depth=self._config.source.clone_depth,
+        )
+
+        agent_spec: Path | None = None
+        if self._agent_spec is not None:
+            agent_spec = await self._backend.get_agent_spec(
+                workspace=self._workspace,
+                spec=self._agent_spec,
+                dest=self._root / "AGENT-SPEC.md",
+            )
+
+        if insight is not None:
+            assert template_ref is not None
+            assert self._backend.client is not None
+            # Lazy: a run without an Insight never authors an eval suite, so it must not
+            # fail to import when the Eval Author package is absent.
+            from nemo_eval_author_plugin.eval_author.agent import EvalAuthor  # noqa: PLC0415
+
+            authored = await EvalAuthor(
+                experiment_dir=self._root, config=self._config.eval_author, reporter=self._reporter
+            ).run(
+                insight=insight,
+                agent_path=agent_dir,
+                task_template=dataset_factory.build_task_template(self._config.outcome_evaluator, template_ref),
+                train_dataset=datasets["train"],
+                validation_dataset=datasets["validation"],
+                client=self._backend.client,
+            )
+            datasets["train"] = authored.train_dataset
+            datasets["validation"] = authored.validation_dataset
+
+            # The authored verifiers emit their own metric keys, so they become the
+            # run's objective and the configured targets demote to guardrails. Without
+            # this the run keeps optimizing `reward`, which those verifiers never emit,
+            # and no candidate is eligible to win.
+            self._config = with_insight_objective(self._config, authored.metric_keys)
+
+            # The suite is production-trace evidence: it belongs in the splits the loop
+            # actually evaluates, not parked beside them. Held-out splits are restored
+            # for the write and re-hidden afterwards, so the distribution can see them.
+            if authored.insight_suite is not None:
+                restore_heldout_splits(self._root)
+                try:
+                    distribute_insight_suite_tasks(authored.insight_suite, datasets["train"], datasets["validation"])
+                finally:
+                    ensure_heldout_hidden(self._root)
+
+        return PreparedInputs(
+            agent_dir=agent_dir,
+            agent_name=str(agent_ref),
+            agent_spec=agent_spec,
+            insight_ref=str(self._insight) if self._insight is not None else None,
+            datasets=datasets,
+        )
+
+    async def _open_run(self, inputs: PreparedInputs) -> tuple[ExperimentRun, bool]:
+        """Re-open this run if one already exists here, else create it.
+
+        Resume is strategy-independent at this level: the runner restores the
+        ``ExperimentRun`` and its inputs, and the strategy rebuilds its own state from
+        ``ctx.candidates()``. A strategy that cannot do that is refused loudly rather
+        than silently restarted — these runs cost hours, so the silent restart is the
+        expensive failure.
+        """
+        existing = self._load_run()
+        if existing is None and await self._has_candidate_records():
+            raise ValueError(
+                f"{self._eo / 'run.json'} is missing or unreadable, but {self._eo / 'candidates'} still "
+                "holds candidate records. Starting fresh would mint a new run id, and every candidate "
+                "already built here would become invisible to it — hours of work still on disk and "
+                "unreachable. Restore run.json, or move the directory aside to start over."
+            )
+        if existing is not None:
+            if existing.status == "completed":
+                # Resume exists for a run that was interrupted. A completed one has its
+                # winner chosen, its report written and possibly a PR opened; re-opening
+                # marks it running again and lets the strategy rewrite all of it. Refusing
+                # costs a fresh directory and keeps a finished result finished.
+                raise ValueError(
+                    f"Run {existing.id!r} in {self._eo / 'run.json'} already completed. Point "
+                    "--experiment-dir at a fresh directory to start a new run, or delete that "
+                    "run to redo it."
+                )
+            if not self._strategy.supports_resume:
+                raise ValueError(
+                    f"{type(self._strategy).__name__} does not support resume, but "
+                    f"{self._eo / 'run.json'} already holds run {existing.id!r}. Point --experiment-dir "
+                    "at a fresh directory, or delete that run to start over."
+                )
+            logger.info("[RESUME] re-opening run %s", existing.id)
+            existing.status = "running"
+            await self._backend.update_run(workspace=self._workspace, run=existing)
+            return existing, True
+
+        run = ExperimentRun(
+            workspace=self._workspace,
+            agent=inputs.agent_name,
+            insight=inputs.insight_ref,
+            config_snapshot={
+                **self._config.model_dump(mode="json"),
+            },
+            status="running",
+        )
+        return await self._backend.create_run(workspace=self._workspace, run=run), False
+
+    async def _seed_narration_baseline(self, ctx: ExperimentContext) -> None:
+        """Point the reporter's delta at the baseline it will not see re-evaluated.
+
+        On resume the baseline is not scored again, so without this the first newly
+        evaluated candidate becomes the delta reference and every later delta is
+        measured against the wrong thing. Narration only; never fails a run.
+        """
+        if self._reporter is None:
+            return
+        try:
+            baseline = next((c for c in await ctx.candidates() if c.ancestor is None), None)
+        except Exception as exc:  # noqa: BLE001 - narration must never fail the run
+            logger.debug("[RESUME] could not seed the narration baseline: %s", exc)
+            return
+        if baseline is not None and baseline.rewards["validation"].metrics:
+            self._reporter.seed_baseline(baseline.rewards["validation"].metrics or {})
+
+    async def _has_candidate_records(self) -> bool:
+        """Whether this directory already holds committed candidates.
+
+        Read off the filesystem rather than through the backend: the backend lists by
+        run id, and the run id is exactly what is unavailable when this is asked.
+        """
+        candidates_dir = self._eo / "candidates"
+        return candidates_dir.is_dir() and any(candidates_dir.glob("*.json"))
+
+    def _load_run(self) -> ExperimentRun | None:
+        """Read this directory's ``run.json``, or None when it is absent or unreadable."""
+        run_path = self._eo / "run.json"
+        if not run_path.exists():
+            return None
+        try:
+            # ExperimentRun's wrap validator restores the computed id.
+            return ExperimentRun.model_validate_json(run_path.read_text())
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("[RESUME] Could not parse run.json: %s", exc)
+            return None
+
+    # -- Persist and publish -------------------------------------------------
+
+    async def _finalize(
+        self,
+        ctx: ExperimentContext,
+        run: ExperimentRun,
+        inputs: PreparedInputs,
+        winner: Candidate | None,
+    ) -> ExperimentalistResult:
+        """Close the run out: report, workspace copy, terminal result, draft PR."""
+        restore_heldout_splits(self._root)
+        report_path = self._eo / "OPTIMIZATION.md"
+        candidates = await ctx.candidates()
+        baseline = next((c for c in candidates if c.ancestor is None), None)
+        summary = _render_summary(run.progress_completed, run.progress_unit, baseline, winner)
+
+        # The strategy writes the real report. When it produced nothing usable, leave a
+        # compact one behind so the Insight sections below have a document to append to.
+        if not report_path.exists() or not report_path.read_text().strip():
+            report_path.write_text(f"# Optimization Report\n\n## Compact Run Summary\n\n{summary}\n")
+
+        if winner is not None:
+            self._copy_winner_to_workspace(ctx.candidate_dir(winner))
+
+        result = ExperimentalistResult(
+            summary=summary,
+            run_id=run.id or "",
+            progress_completed=run.progress_completed,
+            winner=winner,
+        )
+        run.status = "completed"
+        run.winner_agent = winner.label if winner is not None else None
+        await self._backend.update_run(workspace=self._workspace, run=run)
+        await self._backend.persist_result(workspace=self._workspace, result=result)
+
+        if self._config.storage.publish_winner and winner is not None and winner.ancestor is not None:
+            try:
+                url = await self._backend.publish_candidate(workspace=self._workspace, candidate=winner)
+                if url:
+                    logger.info("[PUBLISH] opened draft PR/MR for winner %s: %s", winner.label, url)
+            except Exception as exc:  # noqa: BLE001 - publishing must never fail the run
+                logger.warning("[PERSISTENCE] publish failed for candidate %s; continuing: %s", winner.label, exc)
+        return result
+
+    def _copy_winner_to_workspace(self, winner_dir: Path) -> None:
+        """Copy the winner's artifact to the workspace root, minus every owner's scaffolding."""
+        # The run's own layout is never copied over. `fork` already strips these on the way
+        # in, but `commit_candidate` accepts any artifact under the candidate root, so a
+        # strategy that builds without forking -- the documented extension point -- can
+        # commit one containing `eval-and-optimize`, and the rmtree below would delete the
+        # run it is finalizing.
+        skip = _STRATEGY_ARTIFACTS | _EVALUATOR_ARTIFACTS | RUN_LAYOUT
+        if not winner_dir.is_dir():
+            logger.warning("[FINAL] winner artifact %s is not a directory; skipping workspace copy", winner_dir)
+            return
+        for entry in winner_dir.iterdir():
+            if entry.name in skip:
+                continue
+            dst = self._root / entry.name
+            if entry.is_dir():
+                if dst.exists():
+                    shutil.rmtree(dst)
+                shutil.copytree(entry, dst)
+            else:
+                shutil.copy2(entry, dst)
+
+
+def _render_summary(completed: int, unit: str, baseline: Candidate | None, winner: Candidate | None) -> str:
+    """One-line outcome summary, used when the strategy's own report is missing."""
+    details: list[str] = []
+    if winner is not None:
+        if winner.rewards["validation"].metrics:
+            details.append(f"validation_reward={winner.rewards['validation'].metrics}")
+    suffix = f", {', '.join(details)}" if details else ""
+    winner_str = winner.label if winner is not None else "none"
+    return f"Optimization complete: {completed} {unit}(s) completed, winner={winner_str}{suffix}"
+
+
+__all__ = ["ExperimentRunner", "PreparedInputs", "Strategy"]
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/seam.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/seam.py
new file mode 100644
index 0000000000..dd67cb86d3
--- /dev/null
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/seam.py
@@ -0,0 +1,186 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""What a component sees of the run, and the working copy a Builder builds in.
+
+Protocols rather than the concrete context, so a role contract does not import the
+implementation: naming ``ExperimentContext`` in :mod:`roles` closes an import cycle
+through the backend, the config tree, and every component config slice. It also lets an
+out-of-tree strategy type its own ``run`` without importing our internals.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable, Mapping, Sequence
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+from nemo_experimentalist_plugin.entities import (
+    Candidate,
+    Dataset,
+    DataValue,
+    EvaluationResult,
+    MetricTarget,
+    Proposal,
+    ResourceRef,
+    RewardRecord,
+)
+from nemo_experimentalist_plugin.experimentalist.components.evaluator import Evaluator
+from nemo_experimentalist_plugin.experimentalist.components.trace_explorer import TraceExplorer
+from pydantic import BaseModel, ConfigDict, Field
+
+#: The split a candidate's headline reward is measured on, and the winner chosen by.
+PRIMARY_SPLIT = "validation"
+
+
+class Fork(BaseModel):
+    """A working copy, and the thing it was forked from, as one value."""
+
+    model_config = ConfigDict(frozen=True)
+
+    workdir: Path = Field(description="Write here. Seeded from upstream, and this becomes the candidate's artifact.")
+    # Still needed after seeding: once the Builder edits, the parent is gone from its
+    # view, and architecture.md is excluded from the seeding by design.
+    upstream: Path | None = Field(
+        default=None, description="The pristine parent, read-only; None when forked from the agent under test."
+    )
+
+
+TraceLoader = Callable[[ResourceRef], Awaitable[TraceExplorer]]
+"""Resolves a trace reference to a loaded trace, wherever it is stored.
+
+The context supplies one to any component whose constructor names ``load_trace``, so a
+component that reads traces never names a platform type and one shipped by another
+package can read them too.
+"""
+
+
+@runtime_checkable
+class BuilderContext(Protocol):
+    """Everything a Builder may reach, which is two verbs: get a place to work, hand back
+    the finished thing.
+
+    Both take the ``Proposal`` and return a ``Fork`` or a ``Candidate``. A Builder never
+    handles an id and never receives a path from outside. Resolving a proposal's ancestor
+    to a location is the context's job, which is what lets candidate storage move without
+    changing a single Builder signature.
+    """
+
+    async def fork(self, proposal: Proposal) -> Fork:
+        """Reserve a working copy for *proposal*, seeded from what it branches off."""
+        ...
+
+    async def commit_candidate(self, *, proposal: Proposal, artifact: Path, generation: int = 0) -> Candidate:
+        """Validate the finished artifact and create the Candidate addressing it."""
+        ...
+
+
+@runtime_checkable
+class StrategyContext(BuilderContext, Protocol):
+    """Everything the run offers, which is what a strategy orchestrating it needs.
+
+    Wider than :class:`BuilderContext` on purpose. The point is not to restrict the
+    strategy — it is the thing in charge — but to let ``roles`` and any out-of-tree
+    strategy name this contract without importing the implementation behind it.
+    """
+
+    #: True when the runner re-opened an existing run, so the strategy should rebuild its
+    #: state from :meth:`candidates` rather than starting over.
+    resuming: bool
+
+    #: NeMo Platform workspace this run belongs to.
+    workspace: str
+
+    @property
+    def run_id(self) -> str:
+        """Durable id of this run."""
+        ...
+
+    #: Evaluator-domain datasets keyed by split. ``validation`` is always present.
+    datasets: Mapping[str, Dataset]
+
+    #: Markdown description of the agent under test, when the run has one.
+    agent_spec: Path | None
+
+    @property
+    def objective_metrics(self) -> list[MetricTarget]:
+        """The run's effective objectives.
+
+        Settled by the host before the strategy starts, because authoring an Insight
+        suite can narrow them: the authored verifiers emit their own metric keys, and
+        those become what the run is scored against. A strategy resolved before that
+        happens must read the contract from here rather than from its own config.
+        """
+        ...
+
+    @property
+    def regression_metrics(self) -> list[MetricTarget]:
+        """The run's effective guardrails, settled alongside :attr:`objective_metrics`."""
+        ...
+
+    @property
+    def outcome_evaluator(self) -> Evaluator:
+        """The run's configured evaluation component."""
+        ...
+
+    async def load_trace(self, ref: ResourceRef) -> TraceExplorer:
+        """The trace *ref* names, wherever this run stores traces."""
+        ...
+
+    async def candidates(self) -> list[Candidate]:
+        """Every Candidate committed to this run. What makes resume possible."""
+        ...
+
+    def candidate_dir(self, candidate: Candidate) -> Path:
+        """Where *candidate*'s artifact lives, raising if the record outlived it."""
+        ...
+
+    async def update_candidate(self, candidate: Candidate, **fields: object) -> Candidate:
+        """Persist changes to a Candidate that already exists."""
+        ...
+
+    async def discard_candidate(self, candidate: Candidate) -> None:
+        """Remove a Candidate entirely: its artifact and the record addressing it."""
+        ...
+
+    async def archive_candidate(self, candidate: Candidate) -> None:
+        """Persist a Candidate's code to durable storage, if this run archives at all."""
+        ...
+
+    async def record_reward(
+        self,
+        candidate: Candidate,
+        *,
+        channel: str,
+        result: EvaluationResult | RewardRecord,
+        metadata: dict[str, DataValue] | None = None,
+    ) -> None:
+        """Store one measurement of *candidate* on *channel*. Universal."""
+        ...
+
+    async def evaluate(
+        self,
+        candidate: Candidate,
+        *,
+        split: str = "validation",
+        task_ids: Sequence[str] | None = None,
+        minimum_attempts: int | None = None,
+    ) -> EvaluationResult:
+        """Run the configured evaluation component. Optional: a self-scoring strategy
+        skips this and calls :meth:`record_reward` directly."""
+        ...
+
+    async def report_progress(
+        self, *, completed: int, total: int | None = None, unit: str = "step", note: str | None = None
+    ) -> None:
+        """Report progress as a counter, not a fraction — opaque strategies cannot
+        compute one."""
+        ...
+
+    def note(self, message: str) -> None:
+        """Narrate, for a human watching. Touches no entity and never raises."""
+        ...
+
+    def component(self, role: str, name: str, **kwargs: object) -> object:
+        """Resolve a component by name, so a strategy need not import the registry."""
+        ...
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/strategies/evolutionary.py b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/strategies/evolutionary.py
new file mode 100644
index 0000000000..7d0091161d
--- /dev/null
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/strategies/evolutionary.py
@@ -0,0 +1,1043 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""The default strategy: a Pareto evolutionary loop over candidate agents.
+
+Orchestrates baseline → [stop? → select → train-eval → analyze → propose → build →
+record → validation-eval] across rounds, delegating every step to a resolved component.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import random
+import shutil
+from pathlib import Path
+from typing import Any, ClassVar, Literal, cast
+
+from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.entities import (
+    Candidate,
+    Dataset,
+    EvaluationResult,
+    Proposal,
+)
+from nemo_experimentalist_plugin.experimentalist import roles
+from nemo_experimentalist_plugin.experimentalist.components.holdout_utils import (
+    ensure_heldout_hidden,
+    restore_heldout_splits,
+)
+from nemo_experimentalist_plugin.experimentalist.components.importer import IMPORT, import_proposal
+from nemo_experimentalist_plugin.experimentalist.components.models import (
+    EvolutionTree,
+)
+from nemo_experimentalist_plugin.experimentalist.components.tools import (
+    GuardedShellTools,
+    WorkspaceTool,
+)
+from nemo_experimentalist_plugin.experimentalist.components.util import load_framework_skills
+from nemo_experimentalist_plugin.experimentalist.registry import get_component, resolve
+from nemo_experimentalist_plugin.experimentalist.seam import StrategyContext, TraceLoader
+from nemo_platform_plugin.nooa_model_client import get_default_model, get_fast_model
+from nooa import Agent, CodeActStrategy, strategy
+from nooa.agentdoc import doc, spec
+from nooa.agents import TokenBudgetSummarizer
+from nooa.config import CodeActConfig
+from nooa.config.summarizer_config import TokenBudgetConfig
+from nooa.skill import Skill
+from nooa.skill_registry import SkillRegistry
+from nooa.tools import Match
+
+logger = logging.getLogger(__name__)
+
+
+class AnalysisSkill(Skill):
+    """Standard format for the per-round analysis file the optimizer writes each round.
+
+    The round analysis merges every agent's per-agent analysis into one markdown file
+    (``eval-and-optimize/analysis/round-N.md``). It is the record a human or the next
+    round reads to understand what happened: which agents lead on which reward
+    dimensions, where they diverge, and which failures are systematic vs mechanical.
+    Follow this format exactly and fill every section with real data from the per-agent
+    analyses and metadata — no placeholders.
+
+    ---
+
+    ```markdown
+    # Round N Analysis
+
+    ## Rewards
+
+    **Show every dimension as its own column** so agents with different strengths are visible
+    and easier to reason about for merging. An agent may have lower values on some dimensions
+    but higher on others — that's a candidate to merge with a complementary agent.
+
+    Train Reward:
+    | Agent | <dim1> | <dim2> | <dim3> | ... | Ancestor | vs. Ancestor |
+    | ----- | ------ | ------ | ------ | --- | -------- | ------------ |
+    | agent-3 | 0.61 | 0.72 | 0.51 | ... | agent-0 | +0.16 |
+    | agent-1 | 0.58 | 0.68 | 0.48 | ... | agent-0 | +0.13 |
+    | agent-0 | 0.45 | 0.55 | 0.40 | ... | --- | baseline |
+
+    Validation Reward:
+    | Agent | <dim1> | <dim2> | <dim3> | ... | Ancestor | vs. Ancestor |
+    | ----- | ------ | ------ | ------ | --- | -------- | ------------ |
+    | agent-3 | 0.51 | 0.62 | 0.44 | ... | agent-0 | -0.10 |
+    | agent-1 | 0.48 | 0.58 | 0.41 | ... | agent-0 | -0.10 |
+    | agent-0 | 0.45 | 0.55 | 0.40 | ... | --- | baseline |
+
+    ## Trajectory Rewards
+
+    Trajectory rewards measure intermediate step quality (goal-tree subgoal rollup).
+    Read from metadata:
+
+    ```python
+    candidate = self.workspace.get_metadata(agent_id)
+    traj = candidate.rewards["validation-trajectory"].metrics or {}
+    # e.g. {"aggregate": 0.74, "parse-cli-input": 0.31, "search-web-sources": 0.78}
+    details = candidate.trajectory_detail or {}
+    # details[node_id][task_id] = {"reward": 0.7, "explanation": "..."}
+    ```
+
+    | Agent | <step1> | <step2> | ... | aggregate |
+    | ----- | ------- | ------- | --- | --------- |
+    | agent-3 | 0.45 | 0.85 | ... | 0.78 |
+    | agent-1 | 0.32 | 0.90 | ... | 0.75 |
+    | agent-0 | 0.31 | 0.78 | ... | 0.74 |
+
+    [Omit if the `validation-trajectory` channel is absent or empty. Show the `aggregate` key as
+    the overall column and each node_id entry as its node column.
+    When a trajectory reward explains a selection tradeoff or outcome-reward disagreement,
+    quote/paraphrase the relevant `trajectory_detail` explanation.]
+
+    ## Divergent Trial Analysis
+
+    For each agent pair with divergent results:
+
+    ### agent-A vs agent-B
+
+    | Task | agent-A | agent-B | Winner's Key Insight |
+    |------|---------|---------|----------------------|
+    | task-003 | ✓ 1.0 | ✗ 0.0 | Checked container type before classifying |
+    | task-007 | ✗ 0.0 | ✓ 1.0 | Verified code reachability not just presence |
+
+    **Divergence Pattern**: agent-A excels at X, agent-B excels at Y.
+    **Transferable Insight**: agent-B's reachability check could be added to agent-A.
+
+    ## Complementary Failures
+
+    Agent pairs with complementary strengths (each passes tasks the other fails):
+
+    - **agent-A + agent-B**: 5 complementary tasks (ensemble would score 0.85 vs 0.65/0.70 individual)
+    - **agent-C + agent-D**: 2 complementary tasks
+
+    ## Failure Patterns
+    For each systematic failure pattern (≥2 tasks), describe:
+    - Root cause description (in your own words, as specific as the evidence allows)
+    - How many tasks affected (e.g. "5/8 tasks")
+    - Concrete example: task name, what agent did, what it should have done
+    - Trace evidence: session + turn + direct quote from the trace
+
+    Example:
+    - **Agent interprets "net revenue" as "gross revenue"** (4/7 tasks): In task `q3-analysis`,
+      turn 3: agent wrote "I'll use total_sales which represents net revenue" — but total_sales
+      is pre-discount. Root cause confirmed via trace.search("net revenue") returning 0 matches
+      before the wrong computation.
+      **agent-2 passes this task** by explicitly checking the column metadata for "net" vs "gross".
+
+    ## Root Causes
+    For each root cause, answer these three questions explicitly:
+    1. **What** specifically did the agent do wrong? (concrete action or output)
+    2. **Why** did it do that? (missing knowledge, wrong assumption, context issue, code bug)
+    3. **What would fix it?** (the minimal change that addresses the root cause directly)
+    4. **Which agents don't have this root cause?** — and what's different about them
+
+    Do NOT write vague statements like "the agent misunderstood the task" without
+    specifying what it misunderstood and why. Do NOT write "improve the prompt" without
+    specifying what information is missing and where in the agent's reasoning it would help.
+
+    ## Mechanical/Infrastructure Errors
+
+    Errors that are NOT agent logic problems — fix these on the infrastructure side:
+
+    | Task | Error Type | Issue | Suggested Fix |
+    |------|------------|-------|---------------|
+    | task-005 | environment | `ModuleNotFoundError: cryptography` | Add to container requirements |
+    | task-012 | timeout | Agent hit 5min limit mid-analysis | Increase task timeout to 10min |
+    | task-018 | dataset | Ground truth expects format X but instruction says Y | Fix instruction.md |
+    | task-023 | api | CVE server returned 503 | Add retry logic to cve-server |
+    | task-001 | config | `max_iterations` set to 100 | Increase `max_iterations` to 1000 |
+
+    **Do NOT optimize agents to work around these issues.** Report them for infra fixes.
+
+    Common mechanical error categories:
+    - **config**: wrong config parameters, missing config, config limits exceeded
+    - **environment**: missing packages, wrong versions, container config
+    - **timeout**: legitimate work cut short by time limits
+    - **dataset**: incorrect ground truth, ambiguous instructions, missing fixtures
+    - **api/service**: external service failures, rate limits, network issues
+    - **scorer**: evaluation bug, wrong expected format, edge case not handled
+
+    **What qualifies as a mechanical error:**
+    - Crashes or `sys.exit` on recoverable errors (e.g., scraping fails → exit instead of fallback)
+    - Wrong output path, missing required fields, schema violations
+    - Unhandled exceptions that silently discard valid data
+    - Missing error handling where failure is expected (network calls, file I/O)
+    - Misconfigured agent, llms, config, etc.
+
+    **What is NOT a mechanical error** (use root cause analysis + improvements instead):
+    - Shallow reasoning, poor query strategy, suboptimal architecture
+    - The code works but produces low-quality output
+    ```
+
+    Fill in every section with real data from the per-agent analyses. No placeholders.
+    Return the complete markdown content as a string — the caller writes it to disk.
+    """
+
+
+class EvolutionaryStrategy(Agent, roles.Strategy):
+    """Merge each round's per-agent analyses, and write the run's optimization report."""
+
+    #: This strategy's settings are the run config itself, not a slice of it.
+    config_type = EvolutionaryOptimizerConfig
+
+    name = "evolutionary"
+
+    #: This loop resumes from its own round-analysis files plus ``ctx.candidates()``,
+    #: so the runner may re-open an existing run and hand it back.
+    supports_resume: ClassVar[bool] = True
+
+    def __init__(
+        self,
+        working_dir: Path,
+        config: EvolutionaryOptimizerConfig | None = None,
+        framework_skills_dirs: list[Path] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(llm=kwargs.pop("llm", None) or get_default_model(), **kwargs)
+        self.working_dir = working_dir.resolve()
+        self.config = config or EvolutionaryOptimizerConfig()
+        self._config = self.config
+        self._workspace_path = self.working_dir
+        self._framework_skills_dirs: list[Path] = framework_skills_dirs or []
+
+        self.shell = GuardedShellTools(cwd=self.working_dir)
+        self.workspace = WorkspaceTool(workspace=self.working_dir)
+        self.context["file_match"] = doc(Match)
+        self.context["workspace_tool_documentation"] = doc(WorkspaceTool)
+        self.skills: SkillRegistry = SkillRegistry(self)
+        spec(self, "skills", hidden=True)
+        load_framework_skills(self.skills, self._framework_skills_dirs)
+        self.skills.register("ext.analysis_skill", AnalysisSkill())
+        self.skills.activate(["cmd.*", "ext.*"])
+        TokenBudgetSummarizer.install(
+            self,
+            llm=get_fast_model(),
+            config=TokenBudgetConfig(max_tokens=self.config.max_summary_tokens),
+        )
+
+    @staticmethod
+    def _coder_config(config: EvolutionaryOptimizerConfig) -> dict[str, Any]:
+        """The builder's settings, with the run's model catalog filled in if it named one.
+
+        A mapping, not a model: the builder validates it against its own `config_type`, so
+        a builder from another package is configured the same way. The run-level
+        `model_catalog_path` is a default the builder's own setting overrides.
+        """
+        settings = dict(config.builder_config)
+        if config.model_catalog_path is not None and settings.get("model_catalog_path") is None:
+            settings["model_catalog_path"] = config.model_catalog_path
+        return settings
+
+    # ------------------------------------------------------------------
+    # Public entry point
+    # ------------------------------------------------------------------
+
+    async def run(self, ctx: StrategyContext) -> Candidate | None:
+        """Run optimization and always close the owned shell session."""
+        try:
+            return await self._run(ctx)
+        finally:
+            await self.shell.close()
+
+    async def _run(self, ctx: StrategyContext) -> Candidate | None:
+        """Run the Pareto evolutionary optimization loop.
+
+        Args:
+            ctx: The run's context — its datasets, its candidates, and the verbs for
+                measuring and recording them. Nothing else is reachable from here.
+
+        Returns:
+            The winning Candidate, or None when no candidate was ever scored. The
+            runner turns that into the run's terminal result.
+        """
+        # The host may have narrowed the metric contract after authoring an Insight
+        # suite, and it settles that before the strategy starts. Take it from the
+        # context rather than the config captured at construction, so every component
+        # resolved below ranks on what the run is actually being scored against.
+        config = self.config.model_copy(
+            update={
+                "objective_function": ctx.objective_metrics,
+                "regression_metrics": ctx.regression_metrics,
+            }
+        )
+        self._check_proposer_builder_pairing(config)
+        agents_dir, analysis_dir, _ = self._init_structure()
+        train_eval_dataset = ctx.datasets["train"]
+        agent_spec_path = ctx.agent_spec
+
+        # ---- Resume or fresh start ---------------------------------------
+        # Round analysis files are this strategy's own private state, so detecting the
+        # last round is its own business; ``ctx.resuming`` only tells it that the runner
+        # re-opened an existing run.
+        if (round_num := self._detect_last_round()) is not None:
+            logger.info(f"[RESUME] round {round_num}")
+            await self._roll_back_to(ctx=ctx, from_round=round_num)
+            evolution_tree = EvolutionTree.from_candidates(await ctx.candidates())
+            candidates: list[Candidate] = list(evolution_tree.survivors(round_num))
+        else:
+            round_num = 0
+            logger.info("phase=baseline round=0")
+            await ctx.report_progress(completed=0, total=config.max_rounds, unit="round", note="baseline")
+
+            # ---- Fetch + build baseline agent (agent-0) ------------------
+            await self._ensure_baseline(ctx=ctx, config=config)
+            evolution_tree = EvolutionTree.from_candidates(await ctx.candidates())
+            candidates = list(evolution_tree.survivors(0))
+
+            # ---- Baseline validation evaluation (round 0) ----------------
+            validation_candidate_results = await self._evaluate_validation_candidates(
+                ctx=ctx,
+                candidates=candidates,
+            )
+            await self._record_baseline_validation(
+                ctx=ctx, baseline=candidates[0], results=validation_candidate_results
+            )
+
+        phase: Literal["exploration", "exploitation"] = "exploration" if round_num % 2 == 0 else "exploitation"
+
+        # ---- Pareto optimization loop (shared by fresh start and resume) --
+        # The round budget bounds the loop itself rather than being a component's opinion:
+        # a terminator that never stops — or none at all — must not produce an unbounded
+        # run. The terminator decides whether to stop *early*.
+        while round_num < config.max_rounds:
+            prior_analysis = (
+                await self._load_round_analysis(analysis_dir=analysis_dir, round_num=round_num - 1)
+                if round_num > 0
+                else None
+            )
+            if config.terminator is not None:
+                terminator = self._terminator(ctx, config)
+                # The whole history, not this round's working set: convergence counts distinct
+                # generations and compares an older Pareto front against the current one.
+                # `candidates` holds only survivors plus the previous round's builds, so
+                # eliminated candidates would be invisible and the generation window could
+                # never fill -- a converged run would then pay for every remaining round.
+                decision = await terminator.run(
+                    round_num=round_num,
+                    candidates=[node.candidate for node in evolution_tree.nodes.values()],
+                    prior_analysis=prior_analysis,
+                )
+                if decision.stop:
+                    logger.info(f"phase=terminate reason={decision.reason}")
+                    break
+
+            # The selector sees slim copies so per-trial detail never reaches an LLM
+            # prompt, but the population must keep the full records: a later
+            # record_reward persists the whole candidate, so carrying a slim copy
+            # forward would erase every other channel's trials in the store.
+            # Matched on label, not id: `survivors` is a generated method, so its return
+            # value can come back either as the objects themselves or re-specified as
+            # JSON. A candidate's id is a computed property over a private attribute and
+            # is not a model field, so the JSON route cannot carry it and validation
+            # mints a fresh one. The label is an ordinary field and survives both routes,
+            # and is unique within a run.
+            by_label = {c.label: c for c in candidates}
+            chosen = (
+                await self._selector(config).survivors([c.slim() for c in candidates], k=config.max_survivors)
+                if len(candidates) > 1
+                else list(candidates)
+            )
+            survivors = [by_label[s.label] for s in chosen if s.label in by_label]
+            if len(survivors) != len(chosen):
+                logger.warning(
+                    "Selector returned %d candidates this round but only %d are in the population; "
+                    "the rest are dropped and their originals killed.",
+                    len(chosen),
+                    len(survivors),
+                )
+            if chosen and not survivors:
+                # Nothing the selector named exists here, so this says nothing about which
+                # candidates are worth keeping. Killing is durable and kills everything:
+                # the run would spend its remaining rounds with an empty population and
+                # could not recover, on resume either. Keep them and let the next round
+                # ask again.
+                logger.warning("No returned survivor resolved; keeping the population for this round.")
+                survivors = list(candidates)
+            survived = {s.label for s in survivors}
+            for candidate in [c for c in candidates if c.label not in survived]:
+                await ctx.update_candidate(candidate, killed_generation=round_num)
+
+            # Only the analyzer consumes these, so a diagnosis-blind run does not pay for
+            # them — which is what makes `analyzer: null` cheaper and not merely quieter.
+            train_candidate_results = (
+                {}
+                if config.analyzer is None
+                else await self._evaluate_train_candidates(
+                    ctx=ctx,
+                    survivors=survivors,
+                    round_num=round_num,
+                    max_train_batch_tasks=config.max_train_batch_tasks,
+                    train_batch_seed=config.train_batch_seed,
+                )
+            )
+            for survivor in survivors:
+                if survivor.label in train_candidate_results:
+                    await ctx.record_reward(
+                        survivor,
+                        channel="train",
+                        result=train_candidate_results[survivor.label],
+                    )
+            analysis = await self._analyze_round(
+                load_trace=ctx.load_trace,
+                analysis_dir=analysis_dir,
+                dataset=train_eval_dataset,
+                evaluations=train_candidate_results,
+                survivors=[c.slim() for c in survivors],
+                round_num=round_num,
+                config=config,
+                agent_spec_path=agent_spec_path,
+            )
+            proposals = await self._propose_improvements(
+                analysis=analysis,
+                evolution_tree=evolution_tree,
+                round_num=round_num,
+                phase=phase,
+                config=config,
+            )
+            if not proposals:
+                # Nothing to build, so another round would re-analyze the same population
+                # and pay for it. Finalize on what has been evaluated instead.
+                logger.info("phase=terminate reason=no proposals")
+                break
+            new_candidates = await self._build_candidates(
+                ctx=ctx,
+                dataset=train_eval_dataset,
+                proposals=proposals,
+                generation=round_num + 1,
+                config=config,
+            )
+            for c in new_candidates:
+                evolution_tree.add(c)
+
+            candidates = survivors + new_candidates
+            round_num += 1
+            phase = "exploration" if round_num % 2 == 0 else "exploitation"
+            await ctx.report_progress(
+                completed=round_num,
+                total=config.max_rounds,
+                unit="round",
+                note="evaluating candidates",
+            )
+            # Announce candidates before the (batched) validation eval, so the narration
+            # reports work beginning, not completed. Mirror
+            # _evaluate_validation_candidates' own filter so we only announce candidates
+            # that will actually be evaluated (cached survivors already carry one).
+            pending_validation = [c for c in candidates if "validation" not in c.rewards]
+            for i, candidate in enumerate(pending_validation, start=1):
+                ctx.note(f"{candidate.label} ({i}/{len(pending_validation)}): {candidate.description}")
+
+            validation_candidate_results = await self._evaluate_validation_candidates(
+                ctx=ctx,
+                candidates=candidates,
+            )
+            for candidate in candidates:
+                if candidate.label in validation_candidate_results:
+                    await ctx.record_reward(
+                        candidate,
+                        channel="validation",
+                        result=validation_candidate_results[candidate.label],
+                    )
+            if config.trajectory_scorer is not None:
+                scorer = cast(
+                    "roles.TrajectoryScorer",
+                    self._trajectory_scorer(ctx, config),
+                )
+                # round_num - 1: the counter has already advanced past the round this
+                # analysis describes, and the scorer names its state after that round.
+                scored = await scorer.run(ctx, candidates=candidates, round_num=round_num - 1, analysis=analysis)
+                for candidate in candidates:
+                    if (record := scored.get(candidate.id)) is not None:
+                        await ctx.record_reward(candidate, channel="validation-trajectory", result=record)
+
+            for candidate in new_candidates:
+                await ctx.archive_candidate(candidate)
+
+        return await self._finalize(evolution_tree=evolution_tree, selector=self._selector(config))
+
+    @strategy(CodeActStrategy(config=CodeActConfig(max_iterations=100, cell_timeout=3600.0)))
+    async def merge_analysis(
+        self,
+        agent_ids: list[Candidate],
+        round: int,
+        per_agent_analyses: list[str],  # noqa: A002
+    ) -> str:  # pyright: ignore[reportReturnType]
+        """Merge per-agent analyses, compare agents, and write the round analysis file.
+
+        ## Step 1: Compare agents at reward level
+
+        Read each agent's per-dimension train rewards from metadata:
+
+        ```python
+        rewards = {c.label: self.workspace.get_metadata(c.label).rewards["train"].metrics or {} for c in agent_ids}
+        all_candidates = [
+            self.workspace.get_metadata(agent_id).slim() for agent_id in self.workspace.list_agents()
+        ]
+        baseline = next((candidate for candidate in all_candidates if candidate.is_baseline), None)
+        ```
+
+        - Compare siblings: which optimization strategy worked better this round?
+        - Compare to ancestors: did the change actually fix the targeted root cause?
+        - When any Insight Suite rewards are present, compare those dimensions to the
+          round-zero baseline separately from train and validation rewards.
+
+        ## Step 2: Analyze divergent and complementary patterns
+
+        Using the per-dimension rewards above, identify where agents diverge (one
+        leads, another trails on a dimension) and where their strengths are
+        complementary. Ground observations in the per-agent analyses passed in.
+
+        ## Step 3: Build the round analysis markdown
+
+        First, discover reward dimensions from metadata:
+        ```python
+        candidate = self.workspace.get_metadata(agent_ids[0].label).slim()
+        train_reward = candidate.rewards["train"].metrics or {}
+        dim_keys = sorted(train_reward.keys())
+        insight_dim_keys = sorted({key for reward in insight_rewards.values() for key in reward})
+        ```
+
+        Follow the `ext.analysis_skill` format exactly for every section (Rewards tables,
+        including the conditional Insight Suite Reward table; Trajectory Rewards; Divergent
+        Trial Analysis; Complementary Failures; Failure Patterns; Root Causes;
+        Mechanical/Infrastructure Errors).
+
+        If at least one agent has a non-empty `insight_reward`, the round analysis must name
+        every available Insight Suite dimension and show its values in the separate Insight
+        Suite Reward table. Never blend those metrics into train/validation rewards or imply
+        that they affected ranking. These metrics may steer this analysis, the goal tree, and
+        the proposer only as adaptive/development feedback; label claims accordingly and never
+        present them as independent validation evidence. Fill in every included section with
+        real data. No placeholders.
+        Return the complete markdown content as a string.
+        """
+        ...
+
+    @strategy(CodeActStrategy(config=CodeActConfig(max_iterations=100, cell_timeout=3600.0)))
+    async def write_final_report(self, best_agent_id: str) -> None:  # pyright: ignore[reportReturnType]
+        """Write the final optimization report to eval-and-optimize/OPTIMIZATION.md.
+
+        ## MANDATORY: use self.workspace — DO NOT ls / cat / find manually
+
+        ```python
+        agent_ids = self.workspace.list_agents()
+        candidate = self.workspace.get_metadata(agent_id).slim()
+        analysis  = self.workspace.read_analysis_file(n)
+        ```
+
+        ## Steps
+        1. Collect metadata for every agent.
+        2. Read round analysis files.
+        3. Build the lineage tree by following ancestor chains.
+        4. Write eval-and-optimize/OPTIMIZATION.md with format:
+           - Summary (baseline vs best rewards, rounds completed, total agents)
+           - Reward Breakdown table (one row per agent, per-dimension columns)
+           - Insight Suite Metrics table when available
+           - Lineage Tree (ASCII tree with rewards and optimization type)
+           - Round-by-Round Analysis
+           - Optimization Insights
+
+        When both the round-zero baseline and best agent have non-empty `insight_reward`,
+        the Summary must state whether the Insight-specific scenarios improved and the
+        Insight Suite Metrics table must show every available dimension with baseline,
+        winner, and signed delta columns. Keep this table separate from generic train and
+        validation rewards. Omit it only when Insight Suite rewards are unavailable.
+
+        Fill in every section with real data. Every agent must appear in the lineage tree.
+        Mark the best agent with * BEST.
+        """
+        ...
+
+    # ------------------------------------------------------------------
+    # Private helpers — concrete (no LLM, no evaluator)
+    # ------------------------------------------------------------------
+
+    def _init_structure(self) -> tuple[Path, Path, Path]:
+        """Create the eval-and-optimize workspace directories; return (agents_dir, analysis_dir, results_dir)."""
+        agents_dir = self.working_dir / "eval-and-optimize" / "agents"
+        analysis_dir = self.working_dir / "eval-and-optimize" / "analysis"
+        results_dir = self.working_dir / "eval-and-optimize" / "results"
+        agents_dir.mkdir(parents=True, exist_ok=True)
+        analysis_dir.mkdir(parents=True, exist_ok=True)
+        results_dir.mkdir(parents=True, exist_ok=True)
+        return agents_dir, analysis_dir, results_dir
+
+    def _detect_last_round(self) -> int | None:
+        """Return the last completed round by scanning analysis files, or None if starting fresh."""
+        analysis_dir = self.working_dir / "eval-and-optimize" / "analysis"
+        if not analysis_dir.exists():
+            return None
+        rounds = []
+        for f in analysis_dir.glob("round-*.md"):
+            try:
+                rounds.append(int(f.stem.split("-")[1]))
+            except (IndexError, ValueError):
+                continue
+        return max(rounds) if rounds else None
+
+    async def _roll_back_to(self, *, ctx: StrategyContext, from_round: int) -> None:
+        """Roll back everything produced after *from_round* so the loop can re-enter cleanly.
+
+        Which candidates those are comes from the stored records rather than a directory
+        walk, so the rollback follows the entity contract rather than our own layout.
+        Candidates are discarded, not deleted: the record and artifact both survive, and
+        ``ctx.candidates()`` stops returning them. Evaluator scratch *is* removed, since
+        it is keyed by label and the re-run would otherwise read a previous round's
+        results. Stale ``killed_generation`` markers whose killing round was itself rolled
+        back are cleared, or those survivors stay dead.
+        """
+        eo = self.working_dir / "eval-and-optimize"
+        results_dir, analysis_dir = eo / "results", eo / "analysis"
+        smoke_dataset_dir, smoke_results_dir = eo / "smoke-dataset", eo / "smoke-results"
+
+        for candidate in await ctx.candidates():
+            if candidate.generation > from_round:
+                await ctx.discard_candidate(candidate)
+                for scratch in (
+                    *results_dir.glob(f"{candidate.label}-*"),
+                    smoke_results_dir / candidate.label,
+                    smoke_dataset_dir / candidate.label,
+                ):
+                    if scratch.is_dir():
+                        shutil.rmtree(scratch)
+            elif candidate.killed_generation is not None and candidate.killed_generation > from_round:
+                await ctx.update_candidate(candidate, killed_generation=None)
+
+        for pattern in ("round-*.md", "round-*-goal.json"):
+            for f in analysis_dir.glob(pattern):
+                try:
+                    n = int(f.stem.split("-")[1])
+                except (IndexError, ValueError):
+                    continue
+                if n > from_round:
+                    f.unlink()
+
+    @staticmethod
+    async def _record_baseline_validation(
+        *, ctx: StrategyContext, baseline: Candidate, results: dict[str, EvaluationResult]
+    ) -> None:
+        """Record the baseline's validation reward, if this round actually measured one.
+
+        Absent whenever the baseline was already scored before the crash that sent us
+        here: `_ensure_baseline` keeps the existing baseline rather than minting a second,
+        and `_evaluate_validation_candidates` only returns candidates it actually ran. A
+        round-0 resume therefore has nothing to record, and indexing the map raised
+        KeyError on a round-0 resume.
+        """
+        measured = results.get(baseline.label)
+        if measured is not None:
+            await ctx.record_reward(baseline, channel="validation", result=measured)
+
+    async def _ensure_baseline(self, *, ctx: StrategyContext, config: EvolutionaryOptimizerConfig) -> None:
+        """Create the baseline candidate unless this run already has one.
+
+        A crash during round 0 leaves ``run.json`` behind but no round analysis, so the
+        runner resumes and this branch runs again. Candidate ids are uuids, so a
+        second commit mints a duplicate baseline that is re-evaluated, offered to the
+        Proposer, and published to the same branch as the original.
+        """
+        if any(candidate.is_baseline for candidate in await ctx.candidates()):
+            logger.info("[RESUME] baseline already committed; not creating a second one")
+            return
+        await self._create_baseline_agent(ctx=ctx, config=config)
+
+    async def _create_baseline_agent(
+        self,
+        *,
+        ctx: StrategyContext,
+        config: EvolutionaryOptimizerConfig,
+    ) -> Candidate:
+        """Build the run's baseline: the agent under test, committed unchanged.
+
+        An ordinary build of an ordinary Proposal — it is the baseline only because
+        nothing precedes it. The architecture doc is generated afterwards, into the
+        artifact the Candidate already addresses.
+        """
+        proposal = import_proposal("baseline: the agent under test, unchanged")
+        builder = cast("type[roles.Builder]", resolve("builder", IMPORT))()
+        baseline = await builder.build(ctx, proposal, generation=0)
+        await self._generate_architecture_doc(ctx=ctx, agent_dir=ctx.candidate_dir(baseline), config=config)
+        return baseline
+
+    async def _load_round_analysis(
+        self,
+        *,
+        analysis_dir: Path,
+        round_num: int,
+    ) -> str | None:
+        """Return the cached analysis markdown for *round_num*, or None if absent."""
+        path = analysis_dir / f"round-{round_num}.md"
+        return path.read_text() if path.exists() else None
+
+    def _format_evolution_table(self, evolution_tree: EvolutionTree) -> str:
+        if not evolution_tree.nodes:
+            return "(none yet — this is the first round)"
+        return evolution_tree.to_markdown_table()
+
+    async def _evaluate_agent(
+        self,
+        ctx: StrategyContext,
+        candidate: Candidate,
+        split: str,
+        task_ids: list[str] | None = None,
+        minimum_attempts: int | None = None,
+    ) -> tuple[Candidate, EvaluationResult]:
+        """Evaluate one candidate and return the candidate/result pair, for ``gather``."""
+        result = await ctx.evaluate(
+            candidate,
+            split=split,
+            task_ids=task_ids,
+            minimum_attempts=minimum_attempts,
+        )
+        return (candidate, result)
+
+    # ------------------------------------------------------------------
+    # Private step methods — implementations
+    # ------------------------------------------------------------------
+
+    async def _generate_architecture_doc(
+        self,
+        *,
+        ctx: StrategyContext,
+        agent_dir: Path,
+        config: EvolutionaryOptimizerConfig,
+    ) -> None:
+        """Ask the run's Builder to document *agent_dir*, unless it already is.
+
+        The configured Builder, not the CodeEditBuilder: a Builder that writes no architecture doc
+        must not have one written for it by a component the config did not name.
+        """
+        if (agent_dir / "architecture.md").exists():
+            return
+        await self._new_builder(ctx=ctx, dataset=ctx.datasets["train"], config=config).describe(agent_dir)
+
+    async def _evaluate_validation_candidates(
+        self,
+        *,
+        ctx: StrategyContext,
+        candidates: list[Candidate],
+    ) -> dict[str, EvaluationResult]:
+        """Evaluate candidates on the validation split; skip any that already have a reward."""
+        pending = [c for c in candidates if "validation" not in c.rewards]
+        if not pending:
+            return {}
+        splits = frozenset({"validation"})
+        restore_heldout_splits(self.working_dir, splits=splits)
+        try:
+            candidate_results = await asyncio.gather(*[self._evaluate_agent(ctx, c, "validation") for c in pending])
+        finally:
+            ensure_heldout_hidden(self.working_dir, splits=splits)
+        return {candidate.label: result for candidate, result in candidate_results}
+
+    def _check_proposer_builder_pairing(self, config: EvolutionaryOptimizerConfig) -> None:
+        """Fail before the run spends anything if no proposal could ever be built.
+
+        A Proposer emitting only kinds the Builder rejects produces empty rounds that
+        look like a run doing work. Only checked when the Proposer declares what it
+        emits; an undeclared one is still caught per proposal, a round at a time.
+        """
+        produces = cast("type[roles.Proposer]", resolve("proposer", config.proposer)).produces
+        accepts = cast("type[roles.Builder]", resolve("builder", config.builder)).accepts
+        if produces and not produces & accepts:
+            raise ValueError(
+                f"proposer {config.proposer!r} emits {sorted(produces)} but builder "
+                f"{config.builder!r} accepts {sorted(accepts) or 'nothing'}; no proposal could be built"
+            )
+
+    async def _evaluate_train_candidates(
+        self,
+        *,
+        ctx: StrategyContext,
+        max_train_batch_tasks: int | None,
+        train_batch_seed: int,
+        survivors: list[Candidate],
+        round_num: int,
+    ) -> dict[str, EvaluationResult]:
+        """Evaluate survivors on the train split.
+
+        In full-dataset mode (``max_train_batch_tasks is None``) the eval set is
+        identical every round, so a survivor's cached ``train_reward`` is reused and
+        only survivors without one are evaluated. In batch mode the sampled batch
+        changes per round, so cached rewards are not comparable within a round: every
+        survivor is re-evaluated on the same freshly sampled batch.
+        """
+        dataset = ctx.datasets["train"]
+        if max_train_batch_tasks is None:
+            # Full-dataset mode: the eval set is identical every round, so evaluate only
+            # survivors that lack a reward and reuse each survivor's cached train reward.
+            pending = [s for s in survivors if "train" not in s.rewards]
+            evaluated: list[tuple[Candidate, EvaluationResult]] = []
+            if pending:
+                evaluated = await asyncio.gather(*[self._evaluate_agent(ctx, c, "train") for c in pending])
+            results = {candidate.label: result for candidate, result in evaluated}
+            for survivor in survivors:
+                if survivor.label in results:
+                    continue
+                if "train" not in survivor.rewards:
+                    continue
+                results[survivor.label] = EvaluationResult(
+                    id=f"{survivor.label}-train",
+                    aggregate_metrics=survivor.rewards["train"].metrics or {},
+                    trials=list(survivor.rewards["train"].trials or []),
+                )
+            return results
+
+        # Batch mode: the sampled batch changes per round, so a cached reward computed on
+        # a different task set is not comparable within a round. Re-evaluate every survivor
+        # on the same freshly sampled batch instead of reusing cached rewards.
+        if max_train_batch_tasks <= 0:
+            raise ValueError("max_train_batch_tasks must be positive or None")
+        all_task_ids = sorted(task.id for task in dataset.list_tasks())
+        if not all_task_ids:
+            raise ValueError(f"No train tasks found in dataset {dataset.id!r}")
+        rng = random.Random(train_batch_seed + round_num)
+        batch_size = min(max_train_batch_tasks, len(all_task_ids))
+        task_ids = sorted(rng.sample(all_task_ids, batch_size))
+        evaluated = await asyncio.gather(*[self._evaluate_agent(ctx, c, "train", task_ids=task_ids) for c in survivors])
+        return {candidate.label: result for candidate, result in evaluated}
+
+    async def _analyze_round(
+        self,
+        *,
+        analysis_dir: Path,
+        dataset: Dataset,
+        evaluations: dict[str, EvaluationResult],
+        survivors: list[Candidate],
+        round_num: int,
+        config: EvolutionaryOptimizerConfig,
+        load_trace: TraceLoader | None = None,
+        agent_spec_path: Path | None = None,
+    ) -> str:
+        """Run TraceRootCauseAnalyzer per survivor, merge analyses, persist to disk.
+        ``None`` those traces are skipped (local ``file://`` traces still load).
+
+        Returns the merged analysis markdown string.
+        """
+        analysis_path = analysis_dir / f"round-{round_num}.md"
+        if analysis_path.exists():
+            return analysis_path.read_text()
+        if config.analyzer is None:
+            # Still written, empty. This file is the strategy's resume marker as much as
+            # its analysis: `_detect_last_round` globs for it, so skipping the write on a
+            # diagnosis-blind run leaves a restart unable to tell which rounds finished —
+            # it starts from zero and every earlier cohort stays alive in the store.
+            analysis_path.parent.mkdir(parents=True, exist_ok=True)
+            analysis_path.write_text("")
+            return ""
+
+        per_agent = await asyncio.gather(
+            *[
+                get_component(
+                    "root-cause-analyzer",
+                    config.analyzer,
+                    workspace=self.working_dir,
+                    config=config.analyzer_config,
+                    framework_skills_dirs=self._framework_skills_dirs,
+                    load_trace=load_trace,
+                ).run(
+                    candidate=s,
+                    dataset=dataset,
+                    evaluation=evaluations[s.label],
+                    peer_evaluations={k: v for k, v in evaluations.items() if k != s.label},
+                    round_num=round_num,
+                    agent_spec=agent_spec_path,
+                )
+                for s in survivors
+            ]
+        )
+        analysis = await self.merge_analysis(survivors, round_num, [str(a) for a in per_agent])
+        analysis_path.parent.mkdir(parents=True, exist_ok=True)
+        analysis_path.write_text(analysis)
+        return analysis
+
+    async def _propose_improvements(
+        self,
+        *,
+        analysis: str,
+        evolution_tree: EvolutionTree,
+        round_num: int,
+        phase: Literal["exploration", "exploitation"],
+        config: EvolutionaryOptimizerConfig,
+    ) -> list[Proposal]:
+        """Run Proposer; return up to ``config.max_candidates`` build requests."""
+        proposer = get_component(
+            "proposer",
+            config.proposer,
+            workspace=self.working_dir,
+            config=config.proposer_config,
+            objective_metrics=config.objective_function,
+            regression_metrics=config.regression_metrics,
+            framework_skills_dirs=self._framework_skills_dirs,
+        )
+        return await proposer.run(
+            analysis=analysis,
+            candidates=[n.candidate for n in evolution_tree.nodes.values()],
+            round_num=round_num,
+            max_candidates=config.max_candidates,
+            hint=phase,
+        )
+
+    async def _build_candidates(
+        self,
+        *,
+        ctx: StrategyContext,
+        dataset: Dataset,
+        proposals: list[Proposal],
+        generation: int,
+        config: EvolutionaryOptimizerConfig,
+    ) -> list[Candidate]:
+        """Build each proposal with the CodeEditBuilder and commit the ones that succeed.
+
+        A failed build produces no Candidate at all: the proposal is discarded and its
+        forked directory is left behind as scratch. That is the point of committing only
+        after the build validates — there is no half-finished record to resurrect on
+        resume, and no killed marker to remember to write.
+
+        The Builder owns the whole span, forking included, so every way a build can fail
+        — an ancestor whose artifact has gone, a smoke eval that will not pass — arrives
+        here the same way: the Builder raised. One bad proposal is not a reason to end a
+        run that has already spent hours, so it is logged and dropped.
+        """
+        builder_cls = cast("type[roles.Builder]", resolve("builder", config.builder))
+        buildable = [proposal for proposal in proposals if proposal.kind in builder_cls.accepts]
+        for proposal in proposals:
+            if proposal.kind not in builder_cls.accepts:
+                logger.warning(
+                    "No builder for a %r proposal: %r accepts %s. Dropping %r.",
+                    proposal.kind,
+                    config.builder,
+                    sorted(builder_cls.accepts) or "nothing",
+                    proposal.description,
+                )
+
+        outcomes = await asyncio.gather(
+            *[
+                self._new_builder(ctx=ctx, dataset=dataset, config=config).build(ctx, proposal, generation=generation)
+                for proposal in buildable
+            ],
+            return_exceptions=True,
+        )
+
+        # Cancellation is not a build failure and must not be swallowed as one:
+        # `CancelledError` derives from BaseException, so the filter below would let a
+        # cancelled candidate through as if it had built, and it would go on to be
+        # evaluated and ranked. Re-raise so the whole round unwinds instead.
+        for outcome in outcomes:
+            if isinstance(outcome, asyncio.CancelledError):
+                raise outcome
+
+        built: list[Candidate] = []
+        for proposal, outcome in zip(buildable, outcomes, strict=True):
+            if isinstance(outcome, BaseException):
+                # `return_exceptions=True` means a failure arrives as a value, not a
+                # raise, so the reason is only ever seen if it is logged here. A build
+                # that never became a candidate is the one thing a run cannot cheaply
+                # reproduce, so keep the exception and its traceback.
+                logger.warning(
+                    "Build failed for proposal %r — %s: %s",
+                    proposal.description,
+                    type(outcome).__name__,
+                    outcome,
+                    exc_info=outcome,
+                )
+                continue
+            built.append(outcome)
+        return built
+
+    def _terminator(self, ctx: StrategyContext, config: EvolutionaryOptimizerConfig) -> roles.Terminator:
+        """Resolve this run's terminator, with the run's own convergence window."""
+        return cast(
+            "roles.Terminator",
+            ctx.component(
+                "terminator",
+                config.terminator,
+                config=config.terminator_config,
+                min_rounds_before_stopping=config.min_rounds_before_stopping,
+                objective_metrics=config.objective_function,
+                regression_metrics=config.regression_metrics,
+            ),
+        )
+
+    def _trajectory_scorer(self, ctx: StrategyContext, config: EvolutionaryOptimizerConfig) -> roles.TrajectoryScorer:
+        """Resolve this run's trajectory scorer, with the run's own per-round task cap."""
+        return cast(
+            "roles.TrajectoryScorer",
+            ctx.component(
+                "trajectory-scorer",
+                config.trajectory_scorer,
+                config=config.trajectory_scorer_config,
+                max_trajectory_tasks=config.max_trajectory_tasks,
+                framework_skills_dirs=self._framework_skills_dirs,
+            ),
+        )
+
+    def _selector(self, config: EvolutionaryOptimizerConfig) -> roles.Selector:
+        """Resolve this run's selector."""
+        return get_component(
+            "selector",
+            config.selector,
+            config=config.selector_config,
+            objective_metrics=config.objective_function,
+            regression_metrics=config.regression_metrics,
+        )
+
+    def _new_builder(
+        self, *, ctx: StrategyContext, dataset: Dataset, config: EvolutionaryOptimizerConfig
+    ) -> roles.Builder:
+        """Resolve and construct this run's Builder, one per build.
+
+        One instance per build because a Builder is stateful — the CodeEditBuilder holds a shell
+        session and a todo list — and builds run concurrently.
+
+        """
+        return get_component(
+            "builder",
+            config.builder,
+            workspace=self.working_dir,
+            config=self._coder_config(config),
+            framework_skills_dirs=self._framework_skills_dirs,
+            evaluator=ctx.outcome_evaluator,
+            dataset=dataset,
+            source_path=config.source.source_path,
+            entrypoint=config.source.entrypoint,
+        )
+
+    async def _finalize(self, *, evolution_tree: EvolutionTree, selector: roles.Selector) -> Candidate | None:
+        """Pick the winner and write this strategy's own report; return the winner.
+
+        Restoring held-out splits, copying the winner out, closing the run entity and
+        the Insight-suite report sections are the runner's.
+        """
+        best = selector.winner([n.candidate for n in evolution_tree.nodes.values()])
+        if best is None:
+            logger.warning("[FINAL] no candidates to finalize")
+            return None
+
+        evolution_tree.mark_best(best.id or best.label)
+        try:
+            # The report writer reads the workspace, which files agents by display handle.
+            await self.write_final_report(best.label)
+        except Exception as exc:  # noqa: BLE001 - the runner falls back to a compact summary
+            logger.warning(f"[FINAL] Failed to write final report: {exc}")
+        return best
diff --git a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/skills/nemo-experimentalist/SKILL.md b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/skills/nemo-experimentalist/SKILL.md
index ac1c9112dc..0cf2c1c9b1 100644
--- a/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/skills/nemo-experimentalist/SKILL.md
+++ b/plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/skills/nemo-experimentalist/SKILL.md
@@ -221,7 +221,7 @@ default Insight created by the former.
 
 Start with the deliberately small configuration below. The top-level options control rounds and
 candidate counts; `source` controls checkout behavior; `storage` controls
-candidate branches and PR/MR publication; `evaluator` controls trial
+candidate branches and PR/MR publication; `outcome_evaluator_config` controls trial
 execution; and `eval_author` controls Insight-driven evaluation authoring. See
 the [example-agent walkthrough](https://github.com/NVIDIA-NeMo/nemo-platform/blob/main/docs/get-started/example-agent.mdx)
 for a complete worked optimizer configuration and run.
@@ -234,9 +234,9 @@ python -c \
   'import json; from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig; print(json.dumps(EvolutionaryOptimizerConfig.model_json_schema(), indent=2))'
 ```
 
-`evaluator` deliberately renders as an open mapping in that schema. For its
+`outcome_evaluator_config` deliberately renders as an open mapping in that schema. For its
 Harbor-specific settings, use the smoke configuration below and the plugin's
-Harbor evaluator documentation; for example, `evaluator.n_attempts` defaults
+Harbor evaluator documentation; for example, `outcome_evaluator_config.n_attempts` defaults
 to `1`.
 
 Keep model endpoint and model-tier settings out of this file; configure those
@@ -256,9 +256,9 @@ to select the winner.
 | `max_candidates` / `max_survivors` | `1` / `1` | `3` / `3` | Exploration per round and candidates retained as parents. |
 | `max_train_batch_tasks` | Small fixed batch, e.g. `4` | `null` for all train tasks, or a representative fixed batch | Cost and signal available while proposing changes. |
 | `max_trajectory_tasks` | `2` | `8` | Tasks used for trajectory/goal-tree scoring. |
-| `disable_trajectory_scoring` / `disable_convergence_check` | `true` / `true` | Omit them (both default to `false`) | Skips costly diagnostic work for smoke runs; restores quality and early stopping for real runs. |
-| `coder.max_fix_attempts` | `1` | `2` (default) | Maximum repair iterations when a candidate fails its integration check. |
-| `evaluator.n_attempts` | `1` | `1`; increase only when task results are noisy | Repeats each evaluation trial. |
+| `trajectory_scorer` / `terminator` | `null` / `null` | Omit them (they default to `goal-tree` and `convergence`) | `null` means no implementation of that role, skipping costly diagnostic work for smoke runs; omitting restores quality and early stopping for real runs. |
+| `builder_config.max_fix_attempts` | `1` | `2` (default) | Maximum repair iterations when a candidate fails its integration check. |
+| `outcome_evaluator_config.n_attempts` | `1` | `1`; increase only when task results are noisy | Repeats each evaluation trial. |
 | `eval_author.max_traces` | `3` | `10` | Representative Insight traces deeply analyzed in Insight-driven mode. |
 
 A small explicit smoke configuration looks like this:
@@ -270,14 +270,14 @@ max_survivors: 1
 max_candidates: 1
 max_trajectory_tasks: 2
 max_train_batch_tasks: 4
-disable_trajectory_scoring: true
-disable_convergence_check: true
+trajectory_scorer: null
+terminator: null
 storage:
   # The real default is true. Keep this false until you intend to create a PR/MR.
   publish_winner: false
-coder:
+builder_config:
   max_fix_attempts: 1
-evaluator:
+outcome_evaluator_config:
   n_attempts: 1
 eval_author:
   max_traces: 3
diff --git a/plugins/nemo-experimentalist/tests/doubles.py b/plugins/nemo-experimentalist/tests/doubles.py
new file mode 100644
index 0000000000..e2a7d68dc5
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/doubles.py
@@ -0,0 +1,270 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Shared doubles for the runner, the context, and anything a strategy touches.
+
+Before the runner existed every test that wanted to drive the loop had to assemble a
+backend, an evaluator and a bag of ``deps`` by hand. These three build the same things
+once: an in-memory backend that records what it was asked to persist, an evaluator that
+returns a fixed result, and a context wired from both.
+
+``conftest.py`` re-exports these as fixtures; import the classes directly when a test
+needs to build more than one.
+"""
+
+import pathlib
+import tempfile
+import uuid
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from types import SimpleNamespace
+from typing import cast
+
+from nemo_experimentalist_plugin.config import CandidateStorageConfig
+from nemo_experimentalist_plugin.entities import (
+    Candidate,
+    Dataset,
+    EvaluationResult,
+    ExperimentRun,
+    MetricTarget,
+    Proposal,
+    ResourceRef,
+    RewardRecord,
+    TrialResult,
+)
+from nemo_experimentalist_plugin.experimentalist.components.evaluator.base import Evaluator, EvaluatorConfig
+from nemo_experimentalist_plugin.experimentalist.components.repository import AgentSource
+from nemo_experimentalist_plugin.experimentalist.context import ExperimentContext
+from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import ExperimentalistBackend
+from nemo_experimentalist_plugin.experimentalist.reporting import RunReporter
+from nemo_experimentalist_plugin.experimentalist.result import ExperimentalistResult
+from nemo_insights_plugin.entities import Insight
+from nemo_platform import AsyncNeMoPlatform
+
+
+def fake_client() -> AsyncNeMoPlatform:
+    """A stand-in platform client for paths that only check whether one is present."""
+    return cast(AsyncNeMoPlatform, SimpleNamespace())
+
+
+class RecordedEvaluation(dict):
+    """One ``persist_evaluation`` call, as keyword arguments."""
+
+
+class FakeBackend(ExperimentalistBackend):
+    """In-memory backend that keeps everything it was asked to persist.
+
+    Candidates are keyed by durable id, the way the local backend keys them — a double
+    that equated id with display label would make any id/label confusion in the code
+    under test pass, which is the defect class this contract exists to separate.
+    ``by_label`` is there for assertions that want the readable handle.
+    """
+
+    def __init__(
+        self,
+        *,
+        client: AsyncNeMoPlatform | None = None,
+        storage: CandidateStorageConfig | None = None,
+        insight: Insight | None = None,
+    ) -> None:
+        super().__init__(client, None, storage)
+        self.candidates: dict[str, Candidate] = {}
+        self.runs: list[ExperimentRun] = []
+        self.evaluations: list[RecordedEvaluation] = []
+        self.results: list[ExperimentalistResult] = []
+        self.archived: list[str] = []
+        self.published: list[str] = []
+        self.agent_code_calls: list[tuple[str | Path, Path]] = []
+        self._insight = insight
+
+    async def get_insight(self, *, workspace: str, insight_id: str) -> Insight:
+        if self._insight is None:
+            raise ValueError(f"FakeBackend has no insight to return for {insight_id!r}")
+        return self._insight
+
+    async def create_run(self, *, workspace: str, run: ExperimentRun) -> ExperimentRun:
+        run._id = run.id or f"run-{len(self.runs) + 1}"  # type: ignore[attr-defined]
+        self.runs.append(run)
+        return run
+
+    async def update_run(self, *, workspace: str, run: ExperimentRun) -> ExperimentRun:
+        return run
+
+    async def create_candidate(self, *, workspace: str, candidate: Candidate) -> Candidate:
+        candidate._id = candidate.id or f"id-{uuid.uuid4()}"  # type: ignore[attr-defined]
+        self.candidates[candidate.id] = candidate
+        return candidate
+
+    async def update_candidate(self, *, workspace: str, candidate: Candidate) -> Candidate:
+        self.candidates[candidate.id] = candidate
+        return candidate
+
+    async def get_candidate(self, *, workspace: str, candidate_id: str) -> Candidate:
+        return self.candidates[candidate_id]
+
+    @property
+    def by_label(self) -> dict[str, Candidate]:
+        """Stored candidates keyed by display handle, for readable assertions."""
+        return {c.label: c for c in self.candidates.values()}
+
+    async def list_candidates(self, *, workspace: str, run_id: str, include_discarded: bool = False) -> list[Candidate]:
+        return [c for c in self.candidates.values() if c.run_id == run_id and (include_discarded or not c.discarded)]
+
+    async def persist_result(self, *, workspace: str, result: ExperimentalistResult) -> None:
+        self.results.append(result)
+
+    async def persist_evaluation(
+        self, *, workspace: str, result: EvaluationResult, candidate: Candidate, split: str
+    ) -> None:
+        self.evaluations.append(
+            RecordedEvaluation(workspace=workspace, result=result, candidate=candidate, split=split)
+        )
+
+    async def get_evaluation_name(self, *, workspace: str, candidate: Candidate, split: str) -> str:
+        return f"exp-{candidate.label}-{split}"
+
+    async def get_agent_code(
+        self, *, workspace: str, agent: str | Path, dest: Path, clone_depth: int | None = None
+    ) -> AgentSource | None:
+        self.agent_code_calls.append((agent, dest))
+        dest.mkdir(parents=True, exist_ok=True)
+        return None
+
+    async def archive_candidate(self, *, workspace: str, candidate: Candidate) -> str | None:
+        self.archived.append(candidate.label)
+        return f"archived://{candidate.label}"
+
+    async def publish_candidate(self, *, workspace: str, candidate: Candidate) -> str | None:
+        self.published.append(candidate.label)
+        return f"https://example.invalid/pr/{candidate.label}"
+
+    async def get_agent_spec(self, *, workspace: str, spec: str, dest: Path) -> Path:
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(f"# spec from {spec}\n")
+        return dest
+
+
+class FakeEvaluator(Evaluator):
+    """Returns a fixed reward and records the options each run was given."""
+
+    evaluator_type = "harbor"
+
+    def __init__(self, *, reward: float = 0.5, options: EvaluatorConfig | None = None) -> None:
+        super().__init__(options or EvaluatorConfig(), None)
+        self.reward = reward
+        self.runs: list[dict[str, object]] = []
+
+    async def _run(self, agent: Path, dataset: Dataset, options: EvaluatorConfig) -> Sequence[TrialResult]:
+        self.runs.append({"agent": agent, "dataset": dataset, "options": options})
+        return [
+            TrialResult(id=f"{agent.name}-{task.id}", task_id=task.id, status="completed")
+            for task in dataset.list_tasks()
+        ]
+
+    async def aggregate_results(self, results: Sequence[TrialResult]) -> dict[str, float | int]:
+        return {"reward": self.reward}
+
+
+#: Artifacts must exist -- ``candidate_dir`` refuses a record whose resource has gone,
+#: because resolving it to the shared root is what let a stale record copy every
+#: candidate's code out as its own. Doubles therefore materialise a real directory.
+_ARTIFACT_ROOT = pathlib.Path(tempfile.mkdtemp(prefix="experimentalist-doubles-"))
+
+
+def make_candidate(
+    *,
+    label: str = "agent-0",
+    run_id: str = "run-1",
+    generation: int = 0,
+    description: str | None = None,
+    ancestor: str | None = None,
+    optimization_type: str | None = None,
+    artifact: str | None = None,
+    candidate_id: str | None = None,
+    rewards: Mapping[str, RewardRecord] | None = None,
+    killed_generation: int | None = None,
+    workspace: str = "default",
+) -> Candidate:
+    """A Candidate with a synthetic artifact, for tests that only care about metadata.
+
+    Every real Candidate is created by ``ctx.commit_candidate()`` from a finished
+    artifact; a test that is not exercising that path still needs one, so this supplies
+    a plausible directory URI and derives the projections the same way the context does.
+    """
+    text = description if description is not None else ("baseline" if ancestor is None else f"change in {label}")
+    # Every candidate has an origin, including the baseline: its Proposal asks for the
+    # agent under test to be imported unchanged, and `ancestor is None` is what makes it
+    # the baseline.
+    proposal = Proposal(
+        ancestor=ancestor,
+        description=text,
+        kind="code-change" if ancestor is not None else "import",
+        payload={"optimization_type": optimization_type} if optimization_type else {},
+    )
+    candidate = Candidate(
+        name=label,
+        label=label,
+        run_id=run_id,
+        generation=generation,
+        ancestor=ancestor,
+        generated_from=proposal,
+        description=text,
+        artifact=ResourceRef(uri=artifact or _default_artifact(run_id, label)),
+        rewards=dict(rewards or {}),
+        killed_generation=killed_generation,
+        workspace=workspace,
+    )
+    # Distinct from the label by default: identity and the display handle are different
+    # strings in a real run, and a double that conflates them hides that class of bug.
+    candidate._id = candidate_id or f"id-{label}"  # type: ignore[attr-defined]
+    return candidate
+
+
+def _default_artifact(run_id: str, label: str) -> str:
+    """A real, empty directory standing in for a built candidate."""
+    path = _ARTIFACT_ROOT / run_id / "eval-and-optimize" / "agents" / label
+    path.mkdir(parents=True, exist_ok=True)
+    return path.as_uri()
+
+
+def make_context(
+    *,
+    root: Path,
+    backend: ExperimentalistBackend | None = None,
+    evaluator: Evaluator | None = None,
+    datasets: Mapping[str, Dataset] | None = None,
+    run: ExperimentRun | None = None,
+    workspace: str = "default",
+    resuming: bool = False,
+    reporter: RunReporter | None = None,
+    objective_metrics: list[MetricTarget] | None = None,
+    regression_metrics: list[MetricTarget] | None = None,
+) -> ExperimentContext:
+    """Build a context over *root*, defaulting every collaborator to a double."""
+    run = run or ExperimentRun(workspace=workspace, agent="agent-under-test")
+    if not run.id:
+        run._id = "run-1"  # type: ignore[attr-defined]
+    agent_dir = root / "eval-and-optimize" / "source-agent"
+    agent_dir.mkdir(parents=True, exist_ok=True)
+    return ExperimentContext(
+        backend=backend or FakeBackend(),
+        workspace=workspace,
+        run=run,
+        root=root,
+        agent_dir=agent_dir,
+        datasets=datasets or {"train": Dataset(id="train"), "validation": Dataset(id="validation")},
+        evaluator=evaluator or FakeEvaluator(),
+        resuming=resuming,
+        reporter=reporter,
+        objective_metrics=objective_metrics,
+        regression_metrics=regression_metrics,
+    )
+
+
+def seed_reward(candidate: Candidate, channel: str, record: RewardRecord) -> None:
+    """Put a measurement on a candidate for a fixture, without persisting it.
+
+    Production writes go through ``ctx.record_reward``; this exists so a test can build
+    a candidate that is already scored without standing up a store.
+    """
+    dict.__setitem__(candidate.rewards, channel, record)
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/conftest.py b/plugins/nemo-experimentalist/tests/experimentalist/conftest.py
index f09ad1d71f..bd4038ae7c 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/conftest.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/conftest.py
@@ -1,18 +1,37 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-"""Shared fixtures for the evaluator test modules.
+"""Fixture wrappers around the doubles in ``doubles.py``.
 
-Test directories carry no ``__init__.py`` in this repo, so helpers are shared as
-fixtures rather than imports.
+Test directories carry no ``__init__.py`` in this repo, so helpers that are not doubles
+are shared as fixtures rather than imports.
 """
 
-from __future__ import annotations
-
 from collections.abc import Callable, Sequence
+from pathlib import Path
 from typing import Any
 
 import pytest
+from doubles import FakeBackend, FakeEvaluator, make_context
+from nemo_experimentalist_plugin.experimentalist.context import ExperimentContext
+
+
+@pytest.fixture
+def fake_backend() -> FakeBackend:
+    """An in-memory backend that records every entity it is handed."""
+    return FakeBackend()
+
+
+@pytest.fixture
+def fake_evaluator() -> FakeEvaluator:
+    """An evaluator that scores everything 0.5 and records the options each run got."""
+    return FakeEvaluator()
+
+
+@pytest.fixture
+def experiment_context(tmp_path: Path, fake_backend: FakeBackend, fake_evaluator: FakeEvaluator) -> ExperimentContext:
+    """A context over ``tmp_path`` wired to the fake backend and evaluator."""
+    return make_context(root=tmp_path, backend=fake_backend, evaluator=fake_evaluator)
 
 
 def _comparable_trials(trials: Sequence[Any], *, include_id: bool = False) -> list[dict[str, Any]]:
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_candidate_contract.py b/plugins/nemo-experimentalist/tests/experimentalist/test_candidate_contract.py
new file mode 100644
index 0000000000..ce5ffa5e9b
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_candidate_contract.py
@@ -0,0 +1,534 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""The candidate contract: fork → build → commit, and what commit refuses.
+
+A Candidate exists only once its artifact does, so nothing durable can point at partial
+work. These cover the ways that could be violated — committing a missing artifact,
+committing one outside the run's candidate root, letting the derived projections drift
+from the Proposal they came from, and updating a Candidate into existence without ever
+having built one.
+"""
+
+import json
+import shutil
+from pathlib import Path
+
+import pytest
+from doubles import FakeBackend, make_candidate, make_context
+from nemo_experimentalist_plugin.entities import (
+    Candidate,
+    Dataset,
+    EvaluationResult,
+    Proposal,
+    ResourceRef,
+    RewardRecord,
+    Task,
+    TrialResult,
+)
+from nemo_experimentalist_plugin.experimentalist.context import ExperimentContext
+
+
+def _proposal(ancestor: str | None = "agent-0") -> Proposal:
+    return Proposal(
+        ancestor=ancestor,
+        description="add a retrieval step before the planner",
+        kind="code-change",
+        payload={"optimization_type": "add_method", "task_ids": ["task-1"], "root_cause": "no retrieval step"},
+    )
+
+
+async def _import_baseline(ctx: ExperimentContext, description: str = "baseline") -> Candidate:
+    """Build the baseline the way a strategy does: an import Proposal through its Builder."""
+    from nemo_experimentalist_plugin.experimentalist.components.importer import ImportBuilder, import_proposal
+
+    return await ImportBuilder().build(ctx, import_proposal(description))
+
+
+@pytest.mark.asyncio
+async def test_importing_the_baseline_copies_the_agent_under_test(tmp_path: Path) -> None:
+    ctx = make_context(root=tmp_path)
+    (ctx.agent_dir / "main.py").write_text("print('hello')\n")
+
+    baseline = await _import_baseline(ctx)
+
+    assert baseline.label == "agent-0", "the first fork takes the first free handle; nothing names it"
+    assert baseline.is_baseline
+    assert baseline.generated_from.kind == "import"
+    assert (ctx.candidate_dir(baseline) / "main.py").read_text() == "print('hello')\n"
+
+
+@pytest.mark.asyncio
+async def test_a_baseline_import_carries_no_owners_scaffolding(tmp_path: Path) -> None:
+    """The ignore set is composed from three owners, so no one list can strip too much."""
+    ctx = make_context(root=tmp_path)
+    (ctx.agent_dir / "main.py").write_text("keep me\n")
+    for name in ("__pycache__", ".venv", "dataset", "eval-and-optimize", "my-traces"):
+        (ctx.agent_dir / name).mkdir()
+
+    imported = ctx.candidate_dir(await _import_baseline(ctx))
+
+    assert (imported / "main.py").exists()
+    for name in ("__pycache__", ".venv", "dataset", "eval-and-optimize", "my-traces"):
+        assert not (imported / name).exists(), name
+
+
+@pytest.mark.asyncio
+async def test_forking_a_proposal_branches_from_its_ancestors_artifact(tmp_path: Path) -> None:
+    """The ancestor is resolved through its stored artifact, not by treating its id as a path."""
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    baseline = await _import_baseline(ctx)
+    (ctx.candidate_dir(baseline) / "main.py").write_text("ancestor code\n")
+
+    fork = await ctx.fork(_proposal(ancestor=baseline.id))
+
+    assert fork.workdir.name == "agent-1"
+    assert (fork.workdir / "main.py").read_text() == "ancestor code\n"
+
+
+@pytest.mark.asyncio
+async def test_a_fork_reports_the_upstream_it_was_taken_from(tmp_path: Path) -> None:
+    """A Builder cannot diff its finished work without a pristine parent to diff against.
+
+    Once it starts editing, the copy in its workdir is no longer the parent — and
+    architecture.md is excluded from the seeding entirely, so the upstream directory is
+    the only place it can be read.
+    """
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    baseline = await _import_baseline(ctx)
+
+    from_parent = await ctx.fork(_proposal(ancestor=baseline.id))
+    from_scratch = await ctx.fork(_proposal(ancestor=None))
+
+    assert from_parent.upstream == ctx.candidate_dir(baseline)
+    assert from_scratch.upstream is None, "forked from the agent under test, which is not a candidate"
+
+
+@pytest.mark.asyncio
+async def test_committing_derives_lineage_and_description_from_the_proposal(tmp_path: Path) -> None:
+    ctx = make_context(root=tmp_path)
+    baseline = await _import_baseline(ctx)
+    # The ancestor is the baseline's durable id, which is not its display handle.
+    proposal = _proposal(ancestor=baseline.id)
+    fork = await ctx.fork(proposal)
+
+    candidate = await ctx.commit_candidate(proposal=proposal, artifact=fork.workdir, generation=1)
+
+    assert candidate.ancestor == baseline.id
+    assert candidate.ancestor != baseline.label
+    assert candidate.description == proposal.description
+    assert candidate.generated_from == proposal
+    assert candidate.generation == 1
+    assert candidate.artifact.uri == fork.workdir.resolve().as_uri()
+    assert not candidate.is_baseline
+
+
+@pytest.mark.asyncio
+async def test_committing_a_missing_artifact_is_refused(tmp_path: Path) -> None:
+    ctx = make_context(root=tmp_path)
+
+    with pytest.raises(ValueError, match="does not exist"):
+        await ctx.commit_candidate(
+            proposal=_proposal(ancestor=None),
+            artifact=tmp_path / "eval-and-optimize" / "agents" / "never-written",
+        )
+
+
+@pytest.mark.asyncio
+async def test_an_artifact_outside_the_candidate_root_is_refused(tmp_path: Path) -> None:
+    """The runner must be able to archive and publish every candidate without help."""
+    ctx = make_context(root=tmp_path)
+    elsewhere = tmp_path / "elsewhere"
+    elsewhere.mkdir()
+
+    with pytest.raises(ValueError, match="must live under"):
+        await ctx.commit_candidate(proposal=_proposal(ancestor=None), artifact=elsewhere)
+
+
+@pytest.mark.asyncio
+async def test_a_candidate_cannot_be_updated_into_existence(tmp_path: Path) -> None:
+    """``commit_candidate`` and ``import_baseline`` are the only ways one is born.
+
+    A create-or-update verb would happily persist a record whose artifact had never been
+    validated, which is exactly what "nothing durable points at partial work" forbids.
+    """
+    ctx = make_context(root=tmp_path)
+    # Assembled by hand rather than committed, so it has no store id — exactly the shape
+    # a component could otherwise smuggle into the store.
+    never_committed = make_candidate(label="agent-7", ancestor=None)
+    never_committed._id = ""
+
+    with pytest.raises(ValueError, match="never by updating one into existence"):
+        await ctx.update_candidate(never_committed, killed_generation=3)
+
+
+@pytest.mark.asyncio
+async def test_updating_a_committed_candidate_persists_the_change(tmp_path: Path) -> None:
+    """Through the on-disk backend deliberately.
+
+    The in-memory double stores the very object the context hands back, so ``setattr``
+    alone would satisfy this and deleting the backend write would leave it green.
+    """
+    from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import LocalExperimentalistBackend
+
+    ctx = make_context(root=tmp_path, backend=LocalExperimentalistBackend(path=tmp_path))
+    baseline = await _import_baseline(ctx)
+
+    await ctx.update_candidate(baseline, killed_generation=2)
+
+    reread = json.loads((tmp_path / "eval-and-optimize" / "candidates" / f"{baseline.id}.json").read_text())
+    assert reread["killed_generation"] == 2
+
+
+def test_a_candidate_whose_projections_drift_from_its_origin_is_invalid() -> None:
+    proposal = _proposal()
+
+    with pytest.raises(ValueError, match="disagrees with its Proposal"):
+        Candidate(
+            label="agent-1",
+            run_id="run-1",
+            ancestor="somewhere-else",
+            generated_from=proposal,
+            description=proposal.description,
+            artifact=ResourceRef(uri="file:///tmp/agent-1"),
+        )
+
+
+def test_the_baseline_is_the_one_without_an_ancestor() -> None:
+    assert make_candidate(label="agent-0").is_baseline
+    assert not make_candidate(label="agent-1", ancestor="agent-0").is_baseline
+
+
+@pytest.mark.asyncio
+async def test_candidates_are_listed_from_the_store_not_from_a_directory_walk(tmp_path: Path) -> None:
+    """A strategy that does not produce one directory per candidate can still list them."""
+    from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import LocalExperimentalistBackend
+
+    backend = LocalExperimentalistBackend(path=tmp_path)
+    ctx = make_context(root=tmp_path, backend=backend)
+    committed = await _import_baseline(ctx)
+
+    listed = await ctx.candidates()
+
+    assert [c.id for c in listed] == [committed.id]
+    assert (tmp_path / "eval-and-optimize" / "candidates" / f"{committed.id}.json").is_file()
+    # Metadata never lands inside the artifact it describes.
+    assert not (ctx.candidate_dir(committed) / "metadata.json").exists()
+
+
+@pytest.mark.asyncio
+async def test_a_fork_does_not_inherit_the_ancestors_architecture_doc(tmp_path: Path) -> None:
+    """The Builder is told its directory holds the ancestor's source and nothing else.
+
+    `architecture.md` describes the ancestor, not the candidate. Inheriting it makes that
+    statement false at the moment the Builder reads it, and hands a code-writing agent a
+    description that no longer matches what it is about to change. The CodeEditBuilder re-seeds it
+    from ``Fork.upstream`` afterwards, to edit in place against the finished source.
+    """
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    baseline = await _import_baseline(ctx)
+    ancestor_dir = ctx.candidate_dir(baseline)
+    (ancestor_dir / "main.py").write_text("print('ancestor')\n")
+    (ancestor_dir / "architecture.md").write_text("# describes agent-0\n")
+
+    fork = await ctx.fork(_proposal(ancestor=baseline.id))
+
+    assert (fork.workdir / "main.py").read_text() == "print('ancestor')\n"
+    assert not (fork.workdir / "architecture.md").exists()
+    assert (fork.upstream / "architecture.md").exists(), "still reachable through the fork's upstream"
+
+
+@pytest.mark.asyncio
+async def test_a_record_whose_artifact_is_gone_is_refused_not_guessed(tmp_path: Path) -> None:
+    """Resolving it to the parent yields the shared candidate root.
+
+    Callers copy out of and push whatever that returns, so a stale record would take
+    every other candidate's code with it.
+    """
+    ctx = make_context(root=tmp_path)
+    baseline = await _import_baseline(ctx)
+    shutil.rmtree(ctx.candidate_dir(baseline))
+
+    with pytest.raises(ValueError, match="has no artifact at"):
+        ctx.candidate_dir(baseline)
+
+
+@pytest.mark.asyncio
+async def test_a_discarded_candidate_is_hidden_but_kept(tmp_path: Path) -> None:
+    """Rolling back a round is the only thing that discards, and that work is redone.
+
+    Keeping both halves is what stops `_reserve` handing out a label a discarded record
+    still claims, and leaves a wrong rollback recoverable.
+    """
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    baseline = await _import_baseline(ctx)
+    artifact = ctx.candidate_dir(baseline)
+
+    await ctx.discard_candidate(baseline)
+
+    assert await ctx.candidates() == [], "nothing may evaluate, rank or publish it"
+    assert artifact.exists(), "the artifact survives, so its directory name stays taken"
+    (kept,) = await ctx.candidates(include_discarded=True)
+    assert kept.discarded is True
+
+
+@pytest.mark.asyncio
+async def test_every_ancestorless_proposal_gets_its_own_directory(tmp_path: Path) -> None:
+    """Only the baseline owns the baseline handle.
+
+    A strategy that builds from the agent under test rather than from a parent — the HPO
+    case — emits many ancestor-less proposals; sharing one directory would have them
+    overwrite each other and the baseline while still reporting distinct rewards.
+    """
+    ctx = make_context(root=tmp_path)
+    baseline_dir = ctx.candidate_dir(await _import_baseline(ctx))
+
+    first = await ctx.fork(_proposal(ancestor=None))
+    second = await ctx.fork(_proposal(ancestor=None))
+
+    assert first.workdir != second.workdir
+    assert first.workdir != baseline_dir
+    assert second.workdir != baseline_dir
+
+
+@pytest.mark.asyncio
+async def test_concurrent_forks_never_share_a_directory(tmp_path: Path) -> None:
+    """Builds run under ``asyncio.gather``, so several forks are in flight at once.
+
+    ``_reserve`` picks ``max(existing) + 1`` by listing the directory, which is only safe
+    because nothing awaits between choosing the name and creating it — two candidates
+    sharing a directory would overwrite each other's source while still reporting
+    separate rewards.
+    """
+    import asyncio
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    baseline = await _import_baseline(ctx)
+    proposals = [_proposal(ancestor=baseline.id) for _ in range(8)]
+
+    forks = await asyncio.gather(*(ctx.fork(p) for p in proposals))
+
+    workdirs = [fork.workdir for fork in forks]
+    assert len(set(workdirs)) == len(workdirs), f"reservations collided: {sorted(p.name for p in workdirs)}"
+    assert ctx.candidate_dir(baseline) not in workdirs
+
+
+@pytest.mark.asyncio
+async def test_a_cancelled_build_unwinds_the_round_rather_than_being_dropped(tmp_path: Path) -> None:
+    """Cancellation is not a build failure, and the difference is invisible to `Exception`.
+
+    `asyncio.gather(..., return_exceptions=True)` hands back `CancelledError` as a *value*.
+    It derives from `BaseException`, so a filter written as `isinstance(outcome, Exception)`
+    lets a cancelled build through: the round carries on with a partial population and
+    ranks candidates that were never built. This covered `_build_candidates` before the
+    Builder refactor moved it; without it the guard can be dropped and nothing fails.
+    """
+    import asyncio
+
+    from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    class _CancellingBuilder:
+        accepts = frozenset({"code-change"})
+
+        async def build(self, ctx: object, proposal: Proposal, *, generation: int) -> None:
+            raise asyncio.CancelledError
+
+    optimizer = object.__new__(EvolutionaryStrategy)
+    optimizer.working_dir = tmp_path
+    optimizer._framework_skills_dirs = []
+    optimizer._models = None
+    optimizer._new_builder = lambda **_: _CancellingBuilder()  # type: ignore[method-assign]
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    config = EvolutionaryOptimizerConfig()
+
+    with pytest.raises(asyncio.CancelledError):
+        await optimizer._build_candidates(
+            ctx=ctx,
+            dataset=ctx.datasets["validation"],
+            proposals=[_proposal(ancestor=None)],
+            generation=1,
+            config=config,
+        )
+
+
+@pytest.mark.asyncio
+async def test_a_nested_architecture_doc_is_the_agents_own_and_survives(tmp_path: Path) -> None:
+    """Only the one beside the agent is ours to strip.
+
+    `architecture.md` is generated *about* the agent and sits at its root, and the fork
+    leaves it out so its absence tells the Proposer it has no model of this candidate.
+    An agent whose own source ships `docs/architecture.md` is a different file entirely —
+    stripping it at every depth silently deletes the user's documentation from every
+    candidate, and from the winner copied back over their workspace.
+    """
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    (ctx.agent_dir / "architecture.md").write_text("# generated about the agent\n")
+    (ctx.agent_dir / "docs").mkdir()
+    (ctx.agent_dir / "docs" / "architecture.md").write_text("# the agent's own docs\n")
+
+    imported = ctx.candidate_dir(await _import_baseline(ctx))
+
+    assert not (imported / "architecture.md").exists(), "the generated one is ours to leave out"
+    assert (imported / "docs" / "architecture.md").read_text() == "# the agent's own docs\n"
+
+
+@pytest.mark.asyncio
+async def test_the_store_itself_hides_discarded_candidates(tmp_path: Path) -> None:
+    """Through the real backend, not the double.
+
+    The filter lives in `list_candidates` rather than at each call site precisely so a
+    consumer cannot forget it — which means the check has to go through the backend that
+    ships, or it only proves the double agrees with itself.
+    """
+    from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import LocalExperimentalistBackend
+
+    ctx = make_context(root=tmp_path, backend=LocalExperimentalistBackend(path=tmp_path))
+    baseline = await _import_baseline(ctx)
+    await ctx.discard_candidate(baseline)
+
+    assert await ctx.candidates() == []
+    assert [c.id for c in await ctx.candidates(include_discarded=True)] == [baseline.id]
+    # The record is still on disk, marked — not removed.
+    stored = json.loads((tmp_path / "eval-and-optimize" / "candidates" / f"{baseline.id}.json").read_text())
+    assert stored["discarded"] is True
+
+
+def test_a_candidate_keeps_its_identity_through_serialization() -> None:
+    """Selection crosses a JSON boundary, and identity has to survive it.
+
+    Survivors are the return value of an LLM method, so they arrive validated from the
+    model's JSON rather than as the objects that went in. `id` is a computed field backed
+    by a private attribute, so without restoring it a survivor comes back with an empty
+    id while its label looks fine — and `survived = {s.id for s in survivors}` becomes
+    `{""}`, which marks every candidate in the round killed.
+    """
+    candidate = make_candidate(label="agent-1", ancestor="id-agent-0", candidate_id="a-real-uuid")
+
+    assert Candidate.model_validate(candidate.model_dump()).id == "a-real-uuid"
+    assert Candidate.model_validate_json(candidate.model_dump_json()).id == "a-real-uuid"
+    assert candidate.slim().id == "a-real-uuid"
+
+
+@pytest.mark.asyncio
+async def test_a_slim_copy_cannot_be_persisted(tmp_path: Path) -> None:
+    """`slim()` empties trials so a candidate can go into an LLM prompt. Persisting one
+    writes that loss back for every channel at once, and trajectory scoring — which reads
+    validation traces — then reports 0.0 for a candidate that has them. Refused instead.
+    """
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    candidate = await _import_baseline(ctx)
+    measured = RewardRecord(
+        metrics={"reward": 0.5}, trials=[TrialResult(id="t1", task_id="task-a", status="completed")]
+    )
+    await ctx.record_reward(candidate, channel="validation", result=measured)
+
+    with pytest.raises(ValueError, match="slim"):
+        await ctx.record_reward(candidate.slim(), channel="train", result=RewardRecord(metrics={"reward": 1.0}))
+
+    assert (await ctx.candidates())[0].rewards["validation"].trials
+
+
+@pytest.mark.asyncio
+async def test_a_builder_documents_the_candidates_it_builds(tmp_path: Path) -> None:
+    """`describe` is a Builder verb so a subclass can replace it. The CodeEditBuilder called
+    `create_architecture_doc` directly, which honoured an override for the baseline and
+    bypassed it for every candidate built after.
+    """
+    from nemo_experimentalist_plugin.experimentalist.components.coder import CodeEditBuilder
+
+    described: list[Path] = []
+
+    class QuietEditor(CodeEditBuilder):
+        """Create and modify agent source code as part of the optimization loop."""
+
+        async def describe(self, artifact: Path) -> None:
+            described.append(artifact)
+
+        async def apply_change(self, *args: object, **kwargs: object) -> None:
+            return None
+
+        async def wire_up_change(self, *args: object, **kwargs: object) -> None:
+            return None
+
+        async def run_pyright(self, *args: object, **kwargs: object) -> None:
+            return None
+
+        async def optimize_subproblem(self, *args: object, **kwargs: object) -> None:
+            return None
+
+        async def integration_check(self, *args: object, **kwargs: object) -> bool:
+            return True
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    baseline = await _import_baseline(ctx)
+    proposal = Proposal(
+        ancestor=baseline.id,
+        description="a change",
+        kind="code-change",
+        payload={"root_cause": "none", "optimization_type": "edit_config", "task_ids": []},
+    )
+
+    builder = QuietEditor(workspace=tmp_path, evaluator=ctx.outcome_evaluator, dataset=ctx.datasets["train"])
+    candidate = await builder.build(ctx, proposal, generation=1)
+
+    assert described == [ctx.candidate_dir(candidate)]
+
+
+@pytest.mark.asyncio
+async def test_the_smoke_check_evaluates_the_tasks_the_change_claims_to_fix(tmp_path: Path) -> None:
+    """Otherwise a build that repairs nothing passes on the first attempt, and the repair
+    loop the check exists to drive never runs.
+
+    Observed: a candidate adding an aggregation handler was smoke-checked against a
+    lookup control it does not touch, passed, and shipped with both targeted tasks at 0.
+    """
+    from nemo_experimentalist_plugin.experimentalist.components.coder import CodeEditBuilder
+
+    seen: list[list[str]] = []
+
+    class RecordingEditor(CodeEditBuilder):
+        """Create and modify agent source code as part of the optimization loop."""
+
+        async def run_smoke_eval(self, workdir, tasks, dataset, evaluator):  # type: ignore[no-untyped-def]
+            seen.append(sorted(t.id for t in tasks))
+            return EvaluationResult(id="smoke", trials=[])
+
+        def _is_smoke_results_healthy(self, evaluation, tasks) -> bool:  # type: ignore[no-untyped-def]
+            return True
+
+    dataset = Dataset(id="train", tasks=[Task(id="targeted-a"), Task(id="targeted-b"), Task(id="control")])
+    ctx = make_context(root=tmp_path, backend=FakeBackend(), datasets={"train": dataset, "validation": dataset})
+    coder = RecordingEditor(workspace=tmp_path, evaluator=ctx.outcome_evaluator, dataset=dataset)
+    wanted = ["targeted-a", "targeted-b"]
+
+    assert await coder.integration_check(tmp_path, dataset, ctx.outcome_evaluator, task_ids=wanted)
+
+    assert seen == [sorted(wanted)], "the smoke check ignored the tasks the change targeted"
+
+
+@pytest.mark.asyncio
+async def test_the_smoke_check_still_runs_when_a_proposal_names_no_tasks(tmp_path: Path) -> None:
+    """A Proposal with no task_ids keeps the old "does it run at all" check."""
+    from nemo_experimentalist_plugin.experimentalist.components.coder import CodeEditBuilder
+
+    seen: list[list[str]] = []
+
+    class RecordingEditor(CodeEditBuilder):
+        """Create and modify agent source code as part of the optimization loop."""
+
+        async def run_smoke_eval(self, workdir, tasks, dataset, evaluator):  # type: ignore[no-untyped-def]
+            seen.append(sorted(t.id for t in tasks))
+            return EvaluationResult(id="smoke", trials=[])
+
+        def _is_smoke_results_healthy(self, evaluation, tasks) -> bool:  # type: ignore[no-untyped-def]
+            return True
+
+    dataset = Dataset(id="train", tasks=[Task(id="a"), Task(id="b"), Task(id="c")])
+    ctx = make_context(root=tmp_path, backend=FakeBackend(), datasets={"train": dataset, "validation": dataset})
+    coder = RecordingEditor(workspace=tmp_path, evaluator=ctx.outcome_evaluator, dataset=dataset)
+
+    assert await coder.integration_check(tmp_path, dataset, ctx.outcome_evaluator, task_ids=None)
+
+    assert len(seen) == 1 and len(seen[0]) == 1, "expected the single-random-task fallback"
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_dataset_staging_loop.py b/plugins/nemo-experimentalist/tests/experimentalist/test_dataset_staging_loop.py
deleted file mode 100644
index a53863ec39..0000000000
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_dataset_staging_loop.py
+++ /dev/null
@@ -1,123 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-"""Loop integration: Experimentalist stages Eval Author inputs before calling Eval Author."""
-
-from pathlib import Path
-from types import SimpleNamespace
-from unittest.mock import AsyncMock
-
-import pytest
-from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
-from nemo_experimentalist_plugin.entities import DatasetRef
-from nemo_experimentalist_plugin.experimentalist.components import loop as loop_module
-from nemo_experimentalist_plugin.experimentalist.components.loop import EvolutionaryOptimizer
-
-
-def _write_tree(root: Path, content: str) -> None:
-    tests = root / "task-1" / "tests"
-    tests.mkdir(parents=True)
-    (tests / "test.sh").write_text(content, encoding="utf-8")
-
-
-@pytest.mark.asyncio
-async def test_insight_run_stages_inputs_and_stops_at_eval_author_handoff(
-    monkeypatch: pytest.MonkeyPatch,
-    tmp_path: Path,
-) -> None:
-    source = tmp_path / "source"
-    train = source / "train"
-    validation = source / "validation"
-    template = source / "task-template"
-    _write_tree(train, "train source")
-    _write_tree(validation, "validation source")
-    _write_tree(template, "template source")
-    experiment = tmp_path / "experiment"
-    captured: dict[str, Path] = {}
-
-    class EvalAuthorHandoff:
-        def __init__(self, train_dataset: SimpleNamespace, validation_dataset: SimpleNamespace) -> None:
-            self.train_dataset = train_dataset
-            self.validation_dataset = validation_dataset
-            self.insight_suite = None
-            self.metric_keys = ("reward",)
-
-    class RecordingDatasetFactory:
-        def build_dataset(self, evaluator_type: str, ref: DatasetRef, **_options: object) -> SimpleNamespace:
-            return SimpleNamespace(ref=ref)
-
-        def build_task_template(self, evaluator_type: str, ref: DatasetRef) -> SimpleNamespace:
-            return SimpleNamespace(uri=ref.uri)
-
-    class MutatingEvalAuthor:
-        def __init__(self, **kwargs: object) -> None:
-            pass
-
-        async def run(
-            self,
-            *,
-            task_template: SimpleNamespace,
-            train_dataset: SimpleNamespace,
-            validation_dataset: SimpleNamespace,
-            **kwargs: object,
-        ) -> EvalAuthorHandoff:
-            captured["train"] = Path(train_dataset.ref.uri)
-            captured["validation"] = Path(validation_dataset.ref.uri)
-            captured["template"] = Path(task_template.uri)
-            (captured["train"] / "task-1" / "tests" / "test.sh").write_text("curated", encoding="utf-8")
-            (captured["template"].parent / "generated-task").mkdir()
-            return EvalAuthorHandoff(train_dataset, validation_dataset)
-
-    monkeypatch.setattr(
-        loop_module,
-        "EvaluatorFactory",
-        lambda: SimpleNamespace(build_evaluator=lambda *args, **kwargs: object()),
-    )
-    monkeypatch.setattr(loop_module, "DatasetFactory", RecordingDatasetFactory)
-    monkeypatch.setattr(loop_module, "EvalAuthor", MutatingEvalAuthor)
-    monkeypatch.setattr(
-        EvolutionaryOptimizer,
-        "_init_structure",
-        lambda self: (experiment / "agents", experiment / "analysis", experiment / "results"),
-    )
-    monkeypatch.setattr(EvolutionaryOptimizer, "_detect_last_round", lambda self: None)
-    monkeypatch.setattr(
-        EvolutionaryOptimizer,
-        "_create_experiment_run",
-        AsyncMock(side_effect=RuntimeError("stop after eval_author")),
-    )
-
-    backend = SimpleNamespace(
-        client=object(),
-        get_insight=AsyncMock(return_value=SimpleNamespace(agent=str(tmp_path / "agent"))),
-        get_agent_code=AsyncMock(),
-    )
-    config = EvolutionaryOptimizerConfig()
-    optimizer = object.__new__(EvolutionaryOptimizer)
-    optimizer.working_dir = experiment
-    optimizer.config = config
-    optimizer.shell = SimpleNamespace(close=AsyncMock())
-    deps = SimpleNamespace(
-        backend=backend,
-        workspace="default",
-        config=config,
-        evaluator_type="harbor_native",
-        train_dataset=DatasetRef(uri=str(train)),
-        validation_dataset=DatasetRef(uri=str(validation)),
-        task_template=DatasetRef(uri=str(template)),
-        insight="insight-1",
-        agent=tmp_path / "agent",
-        agent_spec=None,
-    )
-
-    with pytest.raises(RuntimeError, match="stop after eval_author"):
-        await optimizer.run(deps)
-
-    optimizer.shell.close.assert_awaited_once()
-    assert captured == {
-        "train": experiment / "dataset" / "train",
-        "validation": experiment / "dataset" / "validation",
-        "template": experiment / "dataset" / "task-template",
-    }
-    assert (train / "task-1" / "tests" / "test.sh").read_text(encoding="utf-8") == "train source"
-    assert not (template.parent / "generated-task").exists()
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_dataset_staging_runner.py b/plugins/nemo-experimentalist/tests/experimentalist/test_dataset_staging_runner.py
new file mode 100644
index 0000000000..6ee92cd68c
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_dataset_staging_runner.py
@@ -0,0 +1,212 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""The runner stages Eval Author's inputs before calling it, so the source is untouched."""
+
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any, cast
+
+import pytest
+from doubles import FakeBackend, fake_client
+from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.entities import DatasetRef
+from nemo_experimentalist_plugin.experimentalist import runner as runner_module
+from nemo_experimentalist_plugin.experimentalist.runner import ExperimentRunner
+from nemo_insights_plugin.entities import Insight
+
+
+class _StopAfterStaging:
+    """Ends the run as soon as inputs are prepared.
+
+    What is under test is that Eval Author was handed *staged copies* under the
+    experiment directory rather than the caller's own dataset, so the run only has to
+    get as far as the strategy.
+    """
+
+    supports_resume = True
+    seen_objectives: list[Any] = []
+
+    async def run(self, ctx: object) -> None:
+        type(self).seen_objectives = list(getattr(ctx, "objective_metrics", []))
+        raise RuntimeError("stop after eval_author")
+
+
+def _write_tree(root: Path, content: str) -> None:
+    tests = root / "task-1" / "tests"
+    tests.mkdir(parents=True)
+    (tests / "test.sh").write_text(content, encoding="utf-8")
+
+
+@pytest.mark.asyncio
+async def test_insight_run_stages_inputs_and_stops_at_eval_author_handoff(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    source = tmp_path / "source"
+    train = source / "train"
+    validation = source / "validation"
+    template = source / "task-template"
+    _write_tree(train, "train source")
+    _write_tree(validation, "validation source")
+    _write_tree(template, "template source")
+    experiment = tmp_path / "experiment"
+    captured: dict[str, Path] = {}
+    build_options: list[dict[str, object]] = []
+
+    class EvalAuthorHandoff:
+        def __init__(self, train_dataset: SimpleNamespace, validation_dataset: SimpleNamespace) -> None:
+            self.train_dataset = train_dataset
+            self.validation_dataset = validation_dataset
+            self.insight_suite = None
+            self.metric_keys = ("reward",)
+
+    class RecordingDatasetFactory:
+        def build_dataset(self, evaluator_type: str, ref: DatasetRef, **options: object) -> SimpleNamespace:
+            build_options.append(options)
+            return SimpleNamespace(ref=ref)
+
+        def build_task_template(self, evaluator_type: str, ref: DatasetRef) -> SimpleNamespace:
+            return SimpleNamespace(uri=ref.uri)
+
+    class MutatingEvalAuthor:
+        def __init__(self, **kwargs: object) -> None:
+            pass
+
+        async def run(
+            self,
+            *,
+            task_template: SimpleNamespace,
+            train_dataset: SimpleNamespace,
+            validation_dataset: SimpleNamespace,
+            **kwargs: object,
+        ) -> EvalAuthorHandoff:
+            captured["train"] = Path(train_dataset.ref.uri)
+            captured["validation"] = Path(validation_dataset.ref.uri)
+            captured["template"] = Path(task_template.uri)
+            (captured["train"] / "task-1" / "tests" / "test.sh").write_text("curated", encoding="utf-8")
+            (captured["template"].parent / "generated-task").mkdir()
+            return EvalAuthorHandoff(train_dataset, validation_dataset)
+
+    monkeypatch.setattr(
+        runner_module,
+        "EvaluatorFactory",
+        lambda: SimpleNamespace(build_evaluator=lambda *args, **kwargs: object()),
+    )
+    monkeypatch.setattr(runner_module, "DatasetFactory", RecordingDatasetFactory)
+    monkeypatch.setattr("nemo_eval_author_plugin.eval_author.agent.EvalAuthor", MutatingEvalAuthor)
+
+    agent_dir = tmp_path / "agent"
+    agent_dir.mkdir()
+    runner = ExperimentRunner(
+        backend=FakeBackend(
+            client=fake_client(),
+            insight=Insight(workspace="default", agent=str(agent_dir), title="t", description="d"),
+        ),
+        strategy=_StopAfterStaging(),
+        config=EvolutionaryOptimizerConfig(),
+        workspace="default",
+        root=experiment,
+        agent=agent_dir,
+        insight="insight-1",
+        train_dataset=DatasetRef(uri=str(train)),
+        validation_dataset=DatasetRef(uri=str(validation)),
+        task_template=DatasetRef(uri=str(template)),
+    )
+
+    with pytest.raises(RuntimeError, match="stop after eval_author"):
+        await runner.run()
+
+    assert captured == {
+        "train": experiment / "dataset" / "train",
+        "validation": experiment / "dataset" / "validation",
+        "template": experiment / "dataset" / "task-template",
+    }
+    assert (train / "task-1" / "tests" / "test.sh").read_text(encoding="utf-8") == "train source"
+    # An insight run's splits are empty until the Eval Author fills them, and build_dataset
+    # refuses an empty split by default -- so the run cannot start without this.
+    assert build_options and all(o.get("allow_empty") is True for o in build_options), (
+        f"runner built datasets without allow_empty in insight mode: {build_options}"
+    )
+    assert not (template.parent / "generated-task").exists()
+
+
+@pytest.mark.asyncio
+async def test_authored_metrics_and_suite_reach_the_run(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """Mode 1's authored output must change what the run optimizes and evaluates.
+
+    The Eval Author writes verifiers that emit their own metric keys and a suite of
+    production-trace tasks. If the keys do not become the objective, selection keeps
+    ranking on `reward` — which those verifiers never emit, so nothing is eligible to
+    win. If the suite is not distributed into the splits the loop evaluates, the tasks
+    it authored are never run.
+    """
+    source = tmp_path / "source"
+    for name in ("train", "validation", "task-template"):
+        _write_tree(source / name, f"{name} source")
+    experiment = tmp_path / "experiment"
+    distributed: dict[str, Any] = {}
+
+    class Authored:
+        def __init__(self, train_dataset: SimpleNamespace, validation_dataset: SimpleNamespace) -> None:
+            self.train_dataset = train_dataset
+            self.validation_dataset = validation_dataset
+            self.insight_suite: Any = SimpleNamespace(id="insight-suite")
+            self.metric_keys = ("cites_source", "uses_required_tool")
+
+    class Factory:
+        def build_dataset(self, evaluator_type: str, ref: DatasetRef, **_options: object) -> SimpleNamespace:
+            return SimpleNamespace(ref=ref)
+
+        def build_task_template(self, evaluator_type: str, ref: DatasetRef) -> SimpleNamespace:
+            return SimpleNamespace(uri=ref.uri)
+
+    class Author:
+        def __init__(self, **kwargs: object) -> None: ...
+
+        async def run(self, *, train_dataset, validation_dataset, **kwargs: object) -> Authored:  # noqa: ANN001
+            return Authored(train_dataset, validation_dataset)
+
+    monkeypatch.setattr(
+        runner_module, "EvaluatorFactory", lambda: SimpleNamespace(build_evaluator=lambda *a, **k: object())
+    )
+    monkeypatch.setattr(runner_module, "DatasetFactory", Factory)
+    monkeypatch.setattr("nemo_eval_author_plugin.eval_author.agent.EvalAuthor", Author)
+    monkeypatch.setattr(
+        runner_module,
+        "distribute_insight_suite_tasks",
+        lambda suite, train, validation: distributed.update(suite=suite, train=train, validation=validation),
+    )
+
+    agent_dir = tmp_path / "agent"
+    agent_dir.mkdir()
+    runner = ExperimentRunner(
+        backend=FakeBackend(
+            client=fake_client(),
+            insight=Insight(workspace="default", agent=str(agent_dir), title="t", description="d"),
+        ),
+        strategy=_StopAfterStaging(),
+        config=EvolutionaryOptimizerConfig(),
+        workspace="default",
+        root=experiment,
+        agent=agent_dir,
+        insight="insight-1",
+        train_dataset=DatasetRef(uri=str(source / "train")),
+        validation_dataset=DatasetRef(uri=str(source / "validation")),
+        task_template=DatasetRef(uri=str(source / "task-template")),
+    )
+
+    with pytest.raises(RuntimeError, match="stop after eval_author"):
+        await runner.run()
+
+    assert [t.name for t in runner._config.objective_function] == ["cites_source", "uses_required_tool"]
+    assert [t.name for t in _StopAfterStaging.seen_objectives] == ["cites_source", "uses_required_tool"], (
+        "the strategy must receive the settled contract through the context"
+    )
+    assert [t.name for t in runner._config.regression_metrics] == ["reward"], "configured targets demote to guardrails"
+    assert cast(Any, distributed["suite"]).id == "insight-suite", (
+        "the authored suite must reach the splits the loop evaluates"
+    )
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_evaluator_factory.py b/plugins/nemo-experimentalist/tests/experimentalist/test_evaluator_factory.py
index d67de2e875..581c250c8f 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_evaluator_factory.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_evaluator_factory.py
@@ -7,16 +7,16 @@
 
 import pytest
 from nemo_experimentalist_plugin.entities import DatasetRef, Task
+from nemo_experimentalist_plugin.experimentalist import roles
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.base import (
     Dataset,
-    Evaluator,
     EvaluatorConfig,
     TrialResult,
 )
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.factory import DatasetFactory, EvaluatorFactory
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native import (
-    HarborEvaluator,
     HarborEvaluatorConfig,
+    HarborNativeOutcomeEvaluator,
 )
 
 _UNSUPPORTED_TYPE = "unsupported"
@@ -24,11 +24,6 @@
 _NONEXISTENT_URI = "/tmp/nonexistent.jsonl"
 
 
-class ConcreteEvaluator(Evaluator):
-    async def _run(self, agent: Path, dataset: Dataset, options: EvaluatorConfig) -> Sequence[TrialResult]:
-        return []
-
-
 class ConcreteDataset(Dataset):
     """Takes a jsonl file with every line being a task."""
 
@@ -52,30 +47,39 @@ def _from_jsonl(uri: str) -> list[Task]:
             ]
 
 
-@pytest.mark.parametrize(
-    "evaluator_type, dataset_ref, expected_error",
-    [
-        (_UNSUPPORTED_TYPE, DatasetRef(uri=_NONEXISTENT_URI, description="test"), ValueError),
-    ],
-)
-def test_build_dataset_raises_on_invalid_type(evaluator_type, dataset_ref, expected_error):
-    with pytest.raises(expected_error):
-        DatasetFactory(
-            supported_evaluator_types={_SUPPORTED_TYPE: (ConcreteDataset, ConcreteEvaluator, EvaluatorConfig)}
-        ).build_dataset(evaluator_type, dataset_ref)
+class ConcreteEvaluator(roles.OutcomeEvaluator):
+    """A registered evaluation component, the way a separate package would ship one."""
+
+    name = _SUPPORTED_TYPE
+    dataset_type = ConcreteDataset
+    config_type = EvaluatorConfig
+
+    async def _run(self, agent: Path, dataset: Dataset, options: EvaluatorConfig) -> Sequence[TrialResult]:
+        return []
+
+
+def test_build_dataset_raises_on_a_name_no_component_claims() -> None:
+    """Never falls back to the built-in: a run configured for one evaluator must not
+    silently be measured by another."""
+    with pytest.raises(LookupError, match="no outcome-evaluator registered"):
+        DatasetFactory().build_dataset(_UNSUPPORTED_TYPE, DatasetRef(uri=_NONEXISTENT_URI, description="test"))
+
 
+def test_build_dataset_uses_the_dataset_the_component_declares(tmp_path):
+    """The component owns its Dataset type, so naming it in config is enough.
 
-def test_build_dataset_on_supported_type(tmp_path):
+    A table of the types this package knows is what stopped `evaluation:` being
+    swappable — it resolved by name and then died on a hardcoded lookup.
+    """
     jsonl = tmp_path / "tasks.jsonl"
     rows = [
         {"question": "What is 2+2?", "answer": "4"},
         {"question": "Capital of France?", "answer": "Paris"},
     ]
     jsonl.write_text("\n".join(json.dumps(r) for r in rows) + "\n")
-    dataset = DatasetFactory(
-        supported_evaluator_types={_SUPPORTED_TYPE: (ConcreteDataset, ConcreteEvaluator, EvaluatorConfig)}
-    ).build_dataset(_SUPPORTED_TYPE, DatasetRef(uri=str(jsonl), description="test"))
+    dataset = DatasetFactory().build_dataset(_SUPPORTED_TYPE, DatasetRef(uri=str(jsonl), description="test"))
     assert len(dataset.list_tasks()) == 2
+    assert isinstance(dataset, ConcreteDataset)
 
 
 def test_concrete_dataset_raises_on_nonexistent_file():
@@ -117,7 +121,7 @@ def test_build_dataset_falsy_evaluator_type():
 
 def test_build_dataset_falsy_dataset_ref():
     with pytest.raises(ValueError, match="Evaluator type and dataset reference are required"):
-        DatasetFactory().build_dataset("harbor_native", None)
+        DatasetFactory().build_dataset("harbor-native", None)
 
 
 def test_build_task_template_zero_tasks(tmp_path):
@@ -125,7 +129,7 @@ def test_build_task_template_zero_tasks(tmp_path):
     empty_dir.mkdir()
     (empty_dir / "not-a-task").mkdir()
     with pytest.raises(ValueError, match="contains no Harbor task directories"):
-        DatasetFactory().build_task_template("harbor_native", DatasetRef(uri=str(empty_dir)))
+        DatasetFactory().build_task_template("harbor-native", DatasetRef(uri=str(empty_dir)))
 
 
 def test_build_task_template_multiple_tasks(tmp_path):
@@ -134,35 +138,35 @@ def test_build_task_template_multiple_tasks(tmp_path):
     (dataset_dir / "task-a" / "task.toml").write_text("")
     (dataset_dir / "task-b").mkdir()
     (dataset_dir / "task-b" / "task.toml").write_text("")
-    with pytest.raises(ValueError, match="exactly one harbor_native task"):
-        DatasetFactory().build_task_template("harbor_native", DatasetRef(uri=str(dataset_dir)))
+    with pytest.raises(ValueError, match="exactly one harbor-native task"):
+        DatasetFactory().build_task_template("harbor-native", DatasetRef(uri=str(dataset_dir)))
 
 
 def test_build_task_template_single_task(tmp_path):
     task_dir = tmp_path / "task-only"
     task_dir.mkdir()
     (task_dir / "task.toml").write_text("")
-    task = DatasetFactory().build_task_template("harbor_native", DatasetRef(uri=str(task_dir)))
+    task = DatasetFactory().build_task_template("harbor-native", DatasetRef(uri=str(task_dir)))
     assert task.id == "task-only"
 
 
 def test_evaluator_factory_build_evaluator_with_config():
     factory = EvaluatorFactory()
-    evaluator = factory.build_evaluator("harbor_native", HarborEvaluatorConfig())
-    assert isinstance(evaluator, HarborEvaluator)
+    evaluator = factory.build_evaluator("harbor-native", HarborEvaluatorConfig())
+    assert isinstance(evaluator, HarborNativeOutcomeEvaluator)
 
 
 def test_evaluator_factory_build_evaluator_with_dict():
     factory = EvaluatorFactory()
-    evaluator = factory.build_evaluator("harbor_native", {"import_path": "x:Y"})
-    assert isinstance(evaluator, HarborEvaluator)
+    evaluator = factory.build_evaluator("harbor-native", {"import_path": "x:Y"})
+    assert isinstance(evaluator, HarborNativeOutcomeEvaluator)
 
 
 def test_harbor_orchestrators_live_outside_the_shared_harbor_module():
     factory = EvaluatorFactory()
 
-    native = factory.build_evaluator("harbor_native", {})
-    sdk_backed = factory.build_evaluator("harbor_evaluator", {})
+    native = factory.build_evaluator("harbor-native", {})
+    sdk_backed = factory.build_evaluator("harbor-runner", {})
 
     assert type(native).__module__ == ("nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native")
     assert type(sdk_backed).__module__ == (
@@ -172,11 +176,11 @@ def test_harbor_orchestrators_live_outside_the_shared_harbor_module():
 
 def test_evaluator_factory_build_evaluator_unsupported():
     factory = EvaluatorFactory()
-    with pytest.raises(ValueError, match="Unsupported evaluator type"):
+    with pytest.raises(LookupError, match="no outcome-evaluator registered"):
         factory.build_evaluator("unsupported", {})
 
 
 def test_evaluator_factory_build_evaluator_wrong_config_type():
     factory = EvaluatorFactory()
-    with pytest.raises(TypeError, match="'harbor_native' evaluator config must be an EvaluatorConfig or dict"):
-        factory.build_evaluator("harbor_native", 42)
+    with pytest.raises(TypeError, match="'harbor-native' evaluator config must be an EvaluatorConfig or dict"):
+        factory.build_evaluator("harbor-native", 42)
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_evaluator_harbor.py b/plugins/nemo-experimentalist/tests/experimentalist/test_evaluator_harbor.py
index 625d95ab7f..a3f88ccc33 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_evaluator_harbor.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_evaluator_harbor.py
@@ -42,8 +42,8 @@
 )
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native import (
     _TRACE_ARTIFACT_DESTINATION,
-    HarborEvaluator,
     HarborEvaluatorConfig,
+    HarborNativeOutcomeEvaluator,
     _cleanup_scoped_imports,
     _ensure_package,
     _safe_identifier,
@@ -581,7 +581,7 @@ async def test_harbor_trial_metric_spec_uses_task_verifier_dir(tmp_path: Path) -
     )
     _write(trial_dir / "verifier" / "reward.txt", "0.5")
 
-    trials = await HarborEvaluator()._trials_from_dir(
+    trials = await HarborNativeOutcomeEvaluator()._trials_from_dir(
         tmp_path / "job",
         [Task(id="task-a", metric_specs={"reward": MetricSpec(name="reward", description="reward")})],
     )
@@ -638,7 +638,7 @@ async def test_harbor_trial_metric_spec_uses_task_verifier_dir(tmp_path: Path) -
 
 @pytest.mark.asyncio
 async def test_harbor_evaluator_runs_job_and_maps_output(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    evaluator = HarborEvaluator()
+    evaluator = HarborNativeOutcomeEvaluator()
     agent_dir = tmp_path / "agent"
     agent_dir.mkdir()
     dataset_dir = tmp_path / "dataset"
@@ -881,7 +881,7 @@ def counting_compile(source, filename, mode):
     monkeypatch.setattr("builtins.compile", counting_compile)
 
     with pytest.raises(HarborVerifierValidationError) as exc_info:
-        await HarborEvaluator()._run(agent_dir, dataset, HarborEvaluatorConfig())
+        await HarborNativeOutcomeEvaluator()._run(agent_dir, dataset, HarborEvaluatorConfig())
 
     message = str(exc_info.value)
     assert "task 'task-a'" in message
@@ -992,7 +992,7 @@ async def test_harbor_evaluator_accepts_valid_python_verifier(
     fake_job = _recording_job(tmp_path / "jobs" / "valid-python")
     monkeypatch.setattr("nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native.Job", fake_job)
 
-    trials = await HarborEvaluator()._run(agent_dir, dataset, HarborEvaluatorConfig())
+    trials = await HarborNativeOutcomeEvaluator()._run(agent_dir, dataset, HarborEvaluatorConfig())
 
     assert trials == []
     assert fake_job.create_calls == 1
@@ -1015,7 +1015,7 @@ async def test_harbor_evaluator_rejects_invalid_configured_test_sh_before_job_cr
     monkeypatch.setattr("nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native.Job", fake_job)
 
     with pytest.raises(HarborVerifierValidationError) as exc_info:
-        await HarborEvaluator()._run(agent_dir, dataset, HarborEvaluatorConfig())
+        await HarborNativeOutcomeEvaluator()._run(agent_dir, dataset, HarborEvaluatorConfig())
 
     message = str(exc_info.value)
     assert "task 'task-a'" in message
@@ -1039,7 +1039,7 @@ async def test_harbor_evaluator_accepts_valid_legacy_test_sh(
     fake_job = _recording_job(tmp_path / "jobs" / "valid-shell")
     monkeypatch.setattr("nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native.Job", fake_job)
 
-    trials = await HarborEvaluator()._run(agent_dir, dataset, HarborEvaluatorConfig())
+    trials = await HarborNativeOutcomeEvaluator()._run(agent_dir, dataset, HarborEvaluatorConfig())
 
     assert trials == []
     assert fake_job.create_calls == 1
@@ -1048,7 +1048,7 @@ async def test_harbor_evaluator_accepts_valid_legacy_test_sh(
 
 @pytest.mark.asyncio
 async def test_harbor_evaluator_rejects_invalid_inputs(tmp_path: Path) -> None:
-    evaluator = HarborEvaluator()
+    evaluator = HarborNativeOutcomeEvaluator()
     task_dir = tmp_path / "dataset" / "task-a"
     _write(task_dir / "task.toml", "")
     harbor_dataset = HarborDataset.from_path(task_dir.parent)
@@ -1410,7 +1410,7 @@ def test_harbor_dataset_get_task_found(tmp_path):
 
 @pytest.mark.asyncio
 async def test_harbor_evaluator_force_rerun(tmp_path, monkeypatch):
-    evaluator = HarborEvaluator()
+    evaluator = HarborNativeOutcomeEvaluator()
     agent_dir = tmp_path / "agent"
     agent_dir.mkdir()
     task_dir = tmp_path / "dataset" / "task-a"
@@ -1474,7 +1474,7 @@ def test_validated_job_dir_rejects_parent_escape(tmp_path: Path) -> None:
 async def test_harbor_evaluator_force_rerun_rejects_job_name_outside_jobs_dir(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    evaluator = HarborEvaluator()
+    evaluator = HarborNativeOutcomeEvaluator()
     agent_dir = tmp_path / "agent"
     agent_dir.mkdir()
     task_dir = tmp_path / "dataset" / "task-a"
@@ -1528,7 +1528,7 @@ async def test_harbor_trials_from_dir_trial_id_fallback(tmp_path):
         },
     )
 
-    evaluator = HarborEvaluator()
+    evaluator = HarborNativeOutcomeEvaluator()
     trials = await evaluator._trials_from_dir(job_dir, [Task(id="task-x", metric_specs={})])
     assert trials[0].id == trial_dir.name
 
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_evaluator_harbor_evaluator.py b/plugins/nemo-experimentalist/tests/experimentalist/test_evaluator_harbor_evaluator.py
index dbfbf5dc73..04569d3633 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_evaluator_harbor_evaluator.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_evaluator_harbor_evaluator.py
@@ -12,7 +12,6 @@
 
 import inspect
 import json
-import logging
 import sys
 from pathlib import Path
 from typing import Any
@@ -22,21 +21,19 @@
 from nemo_experimentalist_plugin.entities import local_path_from_uri
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.base import (
     EvaluatorConfig,
-    _warned_evaluator_types,
 )
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.factory import EvaluatorFactory
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor import HarborDataset
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_evaluator import (
     HarborRunnerConfig,
-    HarborRunnerEvaluator,
+    HarborRunnerOutcomeEvaluator,
     HarborTaskNameError,
     harbor_task_names,
 )
 from nemo_experimentalist_plugin.experimentalist.components.evaluator.harbor_native import (
-    HarborEvaluator,
     HarborEvaluatorConfig,
+    HarborNativeOutcomeEvaluator,
 )
-from nemo_experimentalist_plugin.experimentalist.deps import ExperimentalistDeps
 from pydantic import ValidationError
 
 
@@ -160,7 +157,7 @@ def write_complete_results(config: Any) -> None:
             )
 
     fake_job.on_run = write_complete_results
-    await HarborRunnerEvaluator(experiment_dir=tmp_path)._run(
+    await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)._run(
         agent_dir, dataset, HarborRunnerConfig(jobs_dir=Path("jobs"))
     )
     fake_job.calls = []
@@ -181,46 +178,33 @@ def agent_dir(tmp_path: Path) -> Path:
 
 
 async def test_optimizer_config_defaults_to_native_harbor() -> None:
-    assert EvolutionaryOptimizerConfig().evaluator_type == "harbor_native"
+    assert EvolutionaryOptimizerConfig().outcome_evaluator == "harbor-native"
 
 
-async def test_deps_default_matches_the_optimizer_config_default() -> None:
-    """The two defaults must not drift: run.py threads one into the other."""
-    assert (
-        ExperimentalistDeps.model_fields["evaluator_type"].default
-        == EvolutionaryOptimizerConfig.model_fields["evaluator_type"].default
-        == "harbor_native"
-    )
-
+async def test_both_harbor_evaluators_are_selectable() -> None:
+    """Native Harbor stays the default, and the SDK-driven one is selectable beside it."""
+    assert EvolutionaryOptimizerConfig().outcome_evaluator == "harbor-native"
+    chosen = EvolutionaryOptimizerConfig.model_validate({"outcome_evaluator": "harbor-runner"})
+    assert chosen.outcome_evaluator == "harbor-runner"
 
-async def test_optimizer_config_still_accepts_plain_harbor() -> None:
-    """Plain Harbor stays selectable — it is the A/B baseline."""
-    config = EvolutionaryOptimizerConfig.model_validate({"evaluator_type": "harbor_native"})
-    assert config.evaluator_type == "harbor_native"
 
+async def test_the_retired_harbor_spelling_names_both_replacements() -> None:
+    """`harbor` shipped when there was one Harbor evaluator; now there are two.
 
-async def test_retired_harbor_spelling_still_resolves_and_warns(caplog: pytest.LogCaptureFixture) -> None:
-    # `harbor` shipped before the rename, so experiment YAMLs in the wild are pinned
-    # to it. Those configs must keep running, and the operator must be told once.
-    _warned_evaluator_types.clear()
-    with caplog.at_level(logging.WARNING):
-        config = EvolutionaryOptimizerConfig.model_validate({"evaluator_type": "harbor"})
-        again = EvolutionaryOptimizerConfig.model_validate({"evaluator_type": "harbor"})
-
-    assert config.evaluator_type == "harbor_native"
-    assert again.evaluator_type == "harbor_native", "the alias must keep resolving, not just the first time"
-    assert caplog.text.count("is deprecated") == 1, "a pinned config must not warn once per round"
+    It is rejected rather than mapped onto one of them: the config key changed in the
+    same release, so a pinned config has to be edited anyway, and silently choosing a
+    side would decide which evaluator runs on the operator's behalf.
+    """
+    with pytest.raises(ValidationError, match="harbor-native.*harbor-runner"):
+        EvolutionaryOptimizerConfig.model_validate({"outcome_evaluator": "harbor"})
 
 
-async def test_retired_spelling_is_not_extended_to_the_never_shipped_name() -> None:
-    # `harbor_agent_task_runner` only ever existed on an unmerged branch, so nothing
-    # can be pinned to it. Accepting it would advertise a name we never released.
-    with pytest.raises(ValidationError) as excinfo:
-        EvolutionaryOptimizerConfig.model_validate({"evaluator_type": "harbor_agent_task_runner"})
+async def test_an_unregistered_evaluator_is_not_invented() -> None:
+    """The set is open, but only to components something actually registers."""
+    from nemo_experimentalist_plugin.experimentalist.registry import resolve
 
-    # Pin the error *location*, not just the type: a BeforeValidator that raised for
-    # some unrelated field would otherwise satisfy this test.
-    assert [error["loc"] for error in excinfo.value.errors()] == [("evaluator_type",)]
+    with pytest.raises(LookupError):
+        resolve("outcome-evaluator", "harbor_agent_task_runner")
 
 
 async def test_job_name_comes_from_the_resolved_agent_dir(
@@ -276,24 +260,35 @@ async def test_eval_author_default_tracks_the_experimentalist_default() -> None:
 
     assert (
         inspect.signature(run_eval_author).parameters["evaluator_type"].default
-        == EvolutionaryOptimizerConfig.model_fields["evaluator_type"].default
+        == EvolutionaryOptimizerConfig.model_fields["outcome_evaluator"].default
     )
 
 
-async def test_optimizer_config_rejects_unknown_evaluator_type() -> None:
-    with pytest.raises(ValidationError):
-        EvolutionaryOptimizerConfig.model_validate({"evaluator_type": "not-an-evaluator"})
+async def test_an_unknown_evaluator_fails_at_resolution_not_at_parse() -> None:
+    """The set of evaluators is open, so the config cannot know the valid names.
+
+    A closed `Literal` would reject an unknown name here, but it would also reject a
+    perfectly good evaluator shipped by another package. The name is checked where it is
+    used instead, which still fails while the run is starting.
+    """
+    from nemo_experimentalist_plugin.experimentalist.registry import resolve
+
+    config = EvolutionaryOptimizerConfig.model_validate({"outcome_evaluator": "not-an-evaluator"})
+    assert config.outcome_evaluator == "not-an-evaluator"
+
+    with pytest.raises(LookupError, match="not-an-evaluator"):
+        resolve("outcome-evaluator", config.outcome_evaluator)
 
 
 async def test_factory_builds_sdk_evaluator(tmp_path: Path) -> None:
     evaluator = EvaluatorFactory().build_evaluator(
-        "harbor_evaluator",
+        "harbor-runner",
         {"n_attempts": 3, "quiet": True},
         experiment_dir=tmp_path,
     )
 
-    assert isinstance(evaluator, HarborRunnerEvaluator)
-    assert evaluator.evaluator_type == "harbor_evaluator"
+    assert isinstance(evaluator, HarborRunnerOutcomeEvaluator)
+    assert evaluator.evaluator_type == "harbor-runner"
     assert isinstance(evaluator.options, HarborRunnerConfig)
     assert evaluator.options.n_attempts == 3
     assert evaluator.experiment_dir == tmp_path
@@ -319,7 +314,7 @@ async def test_plain_harbor_still_builds() -> None:
     imported lazily. That premise is gone: ``nemo-evaluator-sdk`` is a declared,
     workspace-linked dependency, so it ships with the plugin and cannot be absent.
     """
-    assert isinstance(EvaluatorFactory().build_evaluator("harbor_native", {}), HarborEvaluator)
+    assert isinstance(EvaluatorFactory().build_evaluator("harbor-native", {}), HarborNativeOutcomeEvaluator)
 
 
 # --------------------------------------------------------------------------
@@ -375,7 +370,7 @@ async def test_runner_receives_expected_job_config(
     agent_dir: Path,
     fake_job: type[_FakeJob],
 ) -> None:
-    evaluator = HarborRunnerEvaluator(experiment_dir=tmp_path)
+    evaluator = HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)
     options = HarborRunnerConfig(
         jobs_dir=Path("jobs"),
         n_attempts=2,
@@ -423,7 +418,7 @@ async def test_complete_cached_job_is_not_rerun(
     cached_job_dir: Path,
     fake_job: type[_FakeJob],
 ) -> None:
-    trials = await HarborRunnerEvaluator(experiment_dir=tmp_path)._run(
+    trials = await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)._run(
         agent_dir, dataset, HarborRunnerConfig(jobs_dir=Path("jobs"))
     )
 
@@ -450,7 +445,7 @@ async def test_errored_cached_job_is_rerun(
     errored["exception_info"] = {"exception_type": "TimeoutError"}
     _write(cached_job_dir / "sum-three__0" / "result.json", json.dumps(errored))
 
-    await HarborRunnerEvaluator(experiment_dir=tmp_path)._run(
+    await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)._run(
         agent_dir, dataset, HarborRunnerConfig(jobs_dir=Path("jobs"))
     )
 
@@ -464,7 +459,7 @@ async def test_under_sampled_cached_job_is_rerun(
     cached_job_dir: Path,
     fake_job: type[_FakeJob],
 ) -> None:
-    await HarborRunnerEvaluator(experiment_dir=tmp_path)._run(
+    await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)._run(
         agent_dir, dataset, HarborRunnerConfig(jobs_dir=Path("jobs"), n_attempts=2)
     )
 
@@ -478,7 +473,7 @@ async def test_force_rerun_discards_a_complete_cache(
     cached_job_dir: Path,
     fake_job: type[_FakeJob],
 ) -> None:
-    trials = await HarborRunnerEvaluator(experiment_dir=tmp_path)._run(
+    trials = await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)._run(
         agent_dir, dataset, HarborRunnerConfig(jobs_dir=Path("jobs"), force_rerun=True)
     )
 
@@ -492,7 +487,7 @@ async def test_concurrent_candidates_use_distinct_job_dirs(
     dataset: HarborDataset,
     fake_job: type[_FakeJob],
 ) -> None:
-    evaluator = HarborRunnerEvaluator(experiment_dir=tmp_path)
+    evaluator = HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)
     options = HarborRunnerConfig(jobs_dir=Path("jobs"))
     for name in ("agent-0", "agent-1"):
         candidate = tmp_path / "agents" / name
@@ -510,7 +505,9 @@ async def test_missing_agent_directory_fails_before_docker(
     fake_job: type[_FakeJob],
 ) -> None:
     with pytest.raises(FileNotFoundError, match="Harbor agent path not found"):
-        await HarborRunnerEvaluator(experiment_dir=tmp_path)._run(tmp_path / "nope", dataset, HarborRunnerConfig())
+        await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)._run(
+            tmp_path / "nope", dataset, HarborRunnerConfig()
+        )
     assert fake_job.calls == []
 
 
@@ -528,7 +525,7 @@ async def test_broken_verifier_fails_before_docker(
     )
 
     with pytest.raises(HarborVerifierValidationError):
-        await HarborRunnerEvaluator(experiment_dir=tmp_path)._run(
+        await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)._run(
             agent_dir, HarborDataset.from_path(dataset_dir), HarborRunnerConfig()
         )
     assert fake_job.calls == []
@@ -536,7 +533,7 @@ async def test_broken_verifier_fails_before_docker(
 
 async def test_wrong_options_type_is_rejected(tmp_path: Path, dataset: HarborDataset, agent_dir: Path) -> None:
     with pytest.raises(TypeError, match="HarborRunnerConfig"):
-        await HarborRunnerEvaluator(experiment_dir=tmp_path)._run(agent_dir, dataset, EvaluatorConfig())
+        await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)._run(agent_dir, dataset, EvaluatorConfig())
 
 
 # --------------------------------------------------------------------------
@@ -573,7 +570,7 @@ def write_results(config: Any) -> None:
         )
 
     fake_job.on_run = write_results
-    sdk_result = await HarborRunnerEvaluator(experiment_dir=tmp_path).run(
+    sdk_result = await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path).run(
         agent_dir, dataset, HarborRunnerConfig(jobs_dir=Path("sdk-jobs"))
     )
 
@@ -588,7 +585,7 @@ def __init__(self, config: Any) -> None:
         PlainJob,
     )
     PlainJob.on_run = write_results
-    plain_result = await HarborEvaluator(experiment_dir=tmp_path).run(
+    plain_result = await HarborNativeOutcomeEvaluator(experiment_dir=tmp_path).run(
         agent_dir, dataset, HarborEvaluatorConfig(jobs_dir=Path("plain-jobs"))
     )
 
@@ -627,7 +624,7 @@ def write_results(config: Any) -> None:
 
     fake_job.on_run = write_results
 
-    result = await HarborRunnerEvaluator(experiment_dir=tmp_path).run(
+    result = await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path).run(
         agent_dir,
         selected_dataset,
         HarborRunnerConfig(jobs_dir=Path("jobs"), trace_format="atif"),
@@ -666,7 +663,7 @@ def write_results(config: Any) -> None:
         )
 
     fake_job.on_run = write_results
-    trials = await HarborRunnerEvaluator(experiment_dir=tmp_path)._run(
+    trials = await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)._run(
         agent_dir, dataset, HarborRunnerConfig(jobs_dir=Path("jobs"))
     )
 
@@ -697,7 +694,7 @@ async def test_editing_the_candidate_invalidates_the_cache_through_the_sdk(
     """
     _write(agent_dir / "harbor_wrapper.py", "class WrappedAgent:\n    version = 2\n")
 
-    await HarborRunnerEvaluator(experiment_dir=tmp_path)._run(
+    await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)._run(
         agent_dir, dataset, HarborRunnerConfig(jobs_dir=Path("jobs"))
     )
 
@@ -712,7 +709,7 @@ async def test_unchanged_candidate_still_hits_the_cache(
     fake_job: type[_FakeJob],
 ) -> None:
     """The guard must not be so strict that it defeats caching entirely."""
-    await HarborRunnerEvaluator(experiment_dir=tmp_path)._run(
+    await HarborRunnerOutcomeEvaluator(experiment_dir=tmp_path)._run(
         agent_dir, dataset, HarborRunnerConfig(jobs_dir=Path("jobs"))
     )
 
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_evolution_tree_rendering.py b/plugins/nemo-experimentalist/tests/experimentalist/test_evolution_tree_rendering.py
index 3f226ae51c..cadfbd93c6 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_evolution_tree_rendering.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_evolution_tree_rendering.py
@@ -9,17 +9,19 @@
 `Candidate` accessors on a node raises `AttributeError`.
 """
 
-from nemo_experimentalist_plugin.entities import Candidate, RewardRecord
+import pytest
+from doubles import make_candidate, seed_reward
+from nemo_experimentalist_plugin.entities import RewardRecord
 from nemo_experimentalist_plugin.experimentalist.components.models import EvolutionNode, EvolutionTree
 
 
 def _node(label: str, *, round_num: int, train: dict[str, float], val: dict[str, float]) -> EvolutionNode:
     return EvolutionNode(
-        candidate=Candidate(
+        candidate=make_candidate(
             run_id="run-1",
             label=label,
-            round=round_num,
-            optimization="baseline" if round_num == 0 else "improve tool use",
+            generation=round_num,
+            description="baseline" if round_num == 0 else "improve tool use",
             rewards={
                 "train": RewardRecord(metrics=train),
                 "validation": RewardRecord(metrics=val),
@@ -41,7 +43,7 @@ def test_markdown_table_renders_every_reward_dimension() -> None:
     table = _tree().to_markdown_table()
 
     assert table.split("\n") == [
-        "| round | agent | ancestor | type | train:reward | validation:reward | optimization |",
+        "| gen | agent | ancestor | type | train:reward | validation:reward | description |",
         "| --- | --- | --- | --- | --- | --- | --- |",
         "| 0 | agent-0 | - | - | 0.25 | 0.50 | baseline |",
         "| 1 | agent-1 | - | - | 0.75 | 1.00 | improve tool use |",
@@ -60,10 +62,32 @@ def test_node_reward_str_renders_every_measured_channel() -> None:
 def test_rendering_picks_up_an_unknown_channel_without_code_changes() -> None:
     """The point of the channel map: a new channel reaches the report unaided."""
     node = _node("agent-0", round_num=0, train={"reward": 0.25}, val={"reward": 0.5})
-    node.candidate.record_reward("some-new-channel", metrics={"score": 0.9})
+    seed_reward(node.candidate, "some-new-channel", RewardRecord(metrics={"score": 0.9}))
     tree = EvolutionTree()
     tree.nodes = {"agent-0": node}
 
     assert "some-new-channel[" in node.reward_str
     assert "some-new-channel:score" in tree.to_markdown_table()
     assert "0.90" in tree.to_markdown_table()
+
+
+def test_the_tree_is_keyed_by_candidate_id_not_by_display_label() -> None:
+    """Identity and the display handle are different strings, and only one is a key."""
+    baseline = make_candidate(label="agent-0", generation=0)
+    child = make_candidate(label="agent-1", ancestor=baseline.id, generation=1)
+    tree = EvolutionTree.from_candidates([baseline, child])
+
+    assert set(tree.nodes) == {baseline.id, child.id}
+    assert tree.nodes[child.id].candidate is child
+
+
+def test_marking_the_best_by_display_label_fails_loudly() -> None:
+    """A silent no-op here surfaced one line later as an unrelated KeyError."""
+    baseline = make_candidate(label="agent-0", generation=0)
+    tree = EvolutionTree.from_candidates([baseline])
+
+    tree.mark_best(baseline.id)
+    assert tree.nodes[baseline.id].is_best
+
+    with pytest.raises(KeyError, match="keys are candidate ids"):
+        tree.mark_best("agent-0-that-is-a-label")
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_loop_failure.py b/plugins/nemo-experimentalist/tests/experimentalist/test_loop_failure.py
deleted file mode 100644
index efd005c6b3..0000000000
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_loop_failure.py
+++ /dev/null
@@ -1,216 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-import asyncio
-import json
-from types import SimpleNamespace
-from unittest.mock import AsyncMock
-
-import pytest
-from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
-from nemo_experimentalist_plugin.entities import Candidate, EvaluationResult, ExperimentRun
-from nemo_experimentalist_plugin.experimentalist.components import loop as loop_module
-from nemo_experimentalist_plugin.experimentalist.components.loop import EvolutionaryOptimizer
-from nemo_experimentalist_plugin.experimentalist.components.models import EvolutionTree
-from nemo_experimentalist_plugin.experimentalist.components.terminator import TerminationDecision
-from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import LocalExperimentalistBackend
-
-
-@pytest.mark.asyncio
-@pytest.mark.parametrize("failure_method", ["create", "evaluate"])
-async def test_baseline_failure_marks_run_failed(monkeypatch, tmp_path, failure_method):
-    candidate = SimpleNamespace(label="agent-0")
-    evolution_tree = SimpleNamespace(survivors=lambda round_num: [candidate])
-    backend = LocalExperimentalistBackend(path=tmp_path)
-    run_entity = await backend.create_run(
-        workspace="default",
-        run=ExperimentRun(
-            workspace="default",
-            agent="agent",
-            config_snapshot={},
-            status="running",
-            rounds_completed=0,
-        ),
-    )
-    monkeypatch.setattr(backend, "get_agent_code", AsyncMock())
-    config = EvolutionaryOptimizerConfig()
-
-    monkeypatch.setattr(
-        loop_module,
-        "EvaluatorFactory",
-        lambda: SimpleNamespace(build_evaluator=lambda *args, **kwargs: object()),
-    )
-    monkeypatch.setattr(
-        loop_module,
-        "DatasetFactory",
-        lambda: SimpleNamespace(build_dataset=lambda *args, **kwargs: object()),
-    )
-    monkeypatch.setattr(loop_module.EvolutionTree, "from_dir", lambda path: evolution_tree)
-    monkeypatch.setattr(EvolutionaryOptimizer, "_init_structure", lambda self: (tmp_path, tmp_path, tmp_path))
-    monkeypatch.setattr(EvolutionaryOptimizer, "_detect_last_round", lambda self: None)
-    monkeypatch.setattr(
-        EvolutionaryOptimizer,
-        "_create_experiment_run",
-        AsyncMock(return_value=run_entity),
-    )
-    baseline_failure = ValueError("baseline failed")
-    create_baseline = (
-        AsyncMock(side_effect=baseline_failure) if failure_method == "create" else AsyncMock(return_value=candidate)
-    )
-    monkeypatch.setattr(EvolutionaryOptimizer, "_create_baseline_agent", create_baseline)
-    monkeypatch.setattr(EvolutionaryOptimizer, "_update_candidate", AsyncMock())
-    evaluate_validation = (
-        AsyncMock(side_effect=baseline_failure)
-        if failure_method == "evaluate"
-        else AsyncMock(return_value={"agent-0": object()})
-    )
-    monkeypatch.setattr(EvolutionaryOptimizer, "_evaluate_validation_candidates", evaluate_validation)
-
-    optimizer = object.__new__(EvolutionaryOptimizer)
-    optimizer.working_dir = tmp_path
-    optimizer.config = config
-    optimizer.shell = SimpleNamespace(close=AsyncMock())
-    deps = SimpleNamespace(
-        backend=backend,
-        workspace="default",
-        config=config,
-        evaluator_type="harbor_native",
-        train_dataset=object(),
-        validation_dataset=object(),
-        insight=None,
-        agent=tmp_path / "agent",
-        agent_spec=None,
-        task_template=None,
-    )
-
-    with pytest.raises(ValueError, match="baseline failed"):
-        await optimizer.run(deps)
-
-    optimizer.shell.close.assert_awaited_once()
-    assert run_entity.status == "failed"
-    saved = json.loads((tmp_path / "eval-and-optimize" / "run.json").read_text(encoding="utf-8"))
-    assert saved["status"] == "failed"
-
-
-@pytest.mark.asyncio
-async def test_a_cancelled_coder_does_not_pass_as_a_built_candidate(monkeypatch, tmp_path):
-    """Cancellation must unwind the round, not be filed as an ordinary build failure.
-
-    ``asyncio.gather(..., return_exceptions=True)`` hands back ``CancelledError``, which
-    derives from ``BaseException``. An ``isinstance(r, Exception)`` filter therefore sees
-    neither a failure nor a success, and the candidate would flow on to evaluation and
-    ranking as though its source had been written.
-    """
-
-    class _CancellingCoder:
-        def __init__(self, **kwargs):
-            pass
-
-        async def run(self, *args, **kwargs):
-            raise asyncio.CancelledError
-
-    monkeypatch.setattr(loop_module, "Coder", _CancellingCoder)
-    monkeypatch.setattr(EvolutionaryOptimizer, "_snapshot_metadata", lambda self, name: None)
-    monkeypatch.setattr(EvolutionaryOptimizer, "_restore_metadata", lambda self, name, snap: None)
-    monkeypatch.setattr(EvolutionaryOptimizer, "_coder_config", lambda self, config: None)
-    monkeypatch.setattr(EvolutionaryOptimizer, "_update_candidate", AsyncMock())
-
-    optimizer = object.__new__(EvolutionaryOptimizer)
-    optimizer.working_dir = tmp_path
-    optimizer._framework_skills_dirs = []
-    candidate = Candidate(run_id="run-1", label="agent-1", round=1, optimization="x")
-
-    with pytest.raises(asyncio.CancelledError):
-        await optimizer._implement_candidates(
-            workspace="default",
-            backend=AsyncMock(),
-            dataset=object(),
-            evaluator=object(),
-            candidates=[candidate],
-            config=EvolutionaryOptimizerConfig(),
-        )
-
-
-@pytest.mark.asyncio
-async def test_no_proposals_finalizes_evaluated_candidates(monkeypatch, tmp_path):
-    """An exhausted proposer ends successfully with the best evaluated candidate."""
-    baseline = Candidate(run_id="run-1", label="agent-0", round=0, optimization="baseline")
-    tree = EvolutionTree()
-    tree.add(baseline)
-    run = ExperimentRun(
-        workspace="default",
-        agent="agent",
-        config_snapshot={},
-        status="running",
-        rounds_completed=0,
-    )
-    run._id = "run-1"
-    evaluation = EvaluationResult(id="agent-0-validation", aggregate_metrics={"reward": 1.0})
-    backend = SimpleNamespace(
-        client=None,
-        get_agent_code=AsyncMock(),
-        persist_evaluation=AsyncMock(),
-        update_run=AsyncMock(),
-        persist_result=AsyncMock(),
-    )
-    finalized = AsyncMock(return_value=baseline)
-
-    monkeypatch.setattr(
-        loop_module,
-        "EvaluatorFactory",
-        lambda: SimpleNamespace(build_evaluator=lambda *args, **kwargs: object()),
-    )
-    monkeypatch.setattr(
-        loop_module,
-        "DatasetFactory",
-        lambda: SimpleNamespace(build_dataset=lambda *args, **kwargs: object()),
-    )
-    monkeypatch.setattr(
-        EvolutionaryOptimizer,
-        "_init_structure",
-        lambda self: (tmp_path / "agents", tmp_path / "analysis", tmp_path / "results"),
-    )
-    monkeypatch.setattr(EvolutionaryOptimizer, "_detect_last_round", lambda self: None)
-    monkeypatch.setattr(EvolutionaryOptimizer, "_create_experiment_run", AsyncMock(return_value=run))
-    monkeypatch.setattr(EvolutionaryOptimizer, "_create_baseline_agent", AsyncMock(return_value=baseline))
-    monkeypatch.setattr(EvolutionaryOptimizer, "_update_candidate", AsyncMock())
-    monkeypatch.setattr(
-        EvolutionaryOptimizer, "_evaluate_validation_candidates", AsyncMock(return_value={"agent-0": evaluation})
-    )
-    monkeypatch.setattr(EvolutionaryOptimizer, "_generate_initial_goal_tree", AsyncMock())
-    monkeypatch.setattr(EvolutionaryOptimizer, "_select_survivors", AsyncMock(return_value=[baseline]))
-    monkeypatch.setattr(
-        EvolutionaryOptimizer, "_evaluate_train_candidates", AsyncMock(return_value={"agent-0": evaluation})
-    )
-    monkeypatch.setattr(EvolutionaryOptimizer, "_analyze_round", AsyncMock(return_value="analysis"))
-    monkeypatch.setattr(EvolutionaryOptimizer, "_update_goal_tree", AsyncMock())
-    propose = AsyncMock(return_value=[])
-    monkeypatch.setattr(EvolutionaryOptimizer, "_propose_improvements", propose)
-    monkeypatch.setattr(EvolutionaryOptimizer, "_implement_candidates", AsyncMock())
-    monkeypatch.setattr(EvolutionaryOptimizer, "_finalize", finalized)
-    monkeypatch.setattr(loop_module.EvolutionTree, "from_dir", lambda path: tree)
-
-    optimizer = object.__new__(EvolutionaryOptimizer)
-    optimizer.working_dir = tmp_path
-    optimizer.config = EvolutionaryOptimizerConfig()
-    optimizer.shell = SimpleNamespace(close=AsyncMock())
-    optimizer.terminator = SimpleNamespace(run=AsyncMock(return_value=TerminationDecision(stop=False)))
-    optimizer._framework_skills_dirs = []
-    deps = SimpleNamespace(
-        backend=backend,
-        workspace="default",
-        config=EvolutionaryOptimizerConfig(),
-        evaluator_type="harbor",
-        train_dataset=object(),
-        validation_dataset=object(),
-        insight=None,
-        agent=tmp_path / "agent",
-        agent_spec=None,
-        task_template=None,
-    )
-
-    result = await optimizer.run(deps)
-
-    assert result.winner is baseline
-    propose.assert_awaited_once()
-    finalized.assert_awaited_once()
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_loop_helpers.py b/plugins/nemo-experimentalist/tests/experimentalist/test_loop_helpers.py
index 4ddb85007f..bc94719391 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_loop_helpers.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_loop_helpers.py
@@ -1,44 +1,52 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-import json
+"""Rolling a round back so the loop can re-enter it cleanly."""
+
 from pathlib import Path
 
-from nemo_experimentalist_plugin.experimentalist.components.loop import EvolutionaryOptimizer
-
-
-def test_rollback_removes_all_result_directories_for_removed_candidate(tmp_path: Path) -> None:
-    root = tmp_path / "eval-and-optimize"
-    agents_dir = root / "agents"
-    results_dir = root / "results"
-    analysis_dir = root / "analysis"
-    smoke_dataset_dir = root / "smoke-dataset"
-    smoke_results_dir = root / "smoke-results"
-    for directory in (agents_dir, results_dir, analysis_dir, smoke_dataset_dir, smoke_results_dir):
-        directory.mkdir(parents=True)
-
-    removed_agent = agents_dir / "agent-2"
-    removed_agent.mkdir()
-    (removed_agent / "metadata.json").write_text(json.dumps({"round": 2}))
-    surviving_agent = agents_dir / "agent-20"
-    surviving_agent.mkdir()
-    (surviving_agent / "metadata.json").write_text(json.dumps({"round": 1}))
-
-    removed_results = [
-        results_dir / "agent-2-train",
-        results_dir / "agent-2-validation",
-        results_dir / "agent-2-custom-channel",
+import pytest
+from doubles import FakeBackend, make_context
+from nemo_experimentalist_plugin.entities import Proposal
+from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+
+async def _commit(ctx, description: str, generation: int):
+    """Commit a candidate the way a Builder does."""
+    proposal = Proposal(ancestor=None, description=description, kind="import", payload={})
+    return await ctx.component("builder", "import").build(ctx, proposal, generation=generation)
+
+
+@pytest.mark.asyncio
+async def test_rollback_discards_later_candidates_and_clears_their_evaluator_scratch(tmp_path: Path) -> None:
+    """Which candidates go comes from the stored records, not a directory walk.
+
+    The candidate itself is discarded rather than deleted — the record and artifact both
+    survive so a wrong rollback stays recoverable. Evaluator scratch *is* removed, since
+    it is keyed by label and the re-run would otherwise read the previous round's results.
+    """
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    kept = await _commit(ctx, "from the round we roll back to", generation=1)
+    rolled_back = await _commit(ctx, "from the round being discarded", generation=2)
+
+    eo = tmp_path / "eval-and-optimize"
+    for sub in ("results", "smoke-results", "smoke-dataset", "analysis"):
+        (eo / sub).mkdir(parents=True, exist_ok=True)
+    scratch = [
+        eo / "results" / f"{rolled_back.label}-validation",
+        eo / "smoke-results" / rolled_back.label,
+        eo / "smoke-dataset" / rolled_back.label,
     ]
-    for result_dir in removed_results:
-        result_dir.mkdir()
-    surviving_result = results_dir / "agent-20-custom-channel"
-    surviving_result.mkdir()
-
-    optimizer = object.__new__(EvolutionaryOptimizer)
-    optimizer.working_dir = tmp_path
-    optimizer._delete_all_artifacts(from_round=1)
-
-    assert not removed_agent.exists()
-    assert all(not result_dir.exists() for result_dir in removed_results)
-    assert surviving_agent.is_dir()
-    assert surviving_result.is_dir()
+    survivor_scratch = eo / "results" / f"{kept.label}-validation"
+    for d in [*scratch, survivor_scratch]:
+        d.mkdir(parents=True, exist_ok=True)
+
+    strategy = EvolutionaryStrategy(working_dir=tmp_path)
+    await strategy._roll_back_to(ctx=ctx, from_round=1)
+
+    assert [c.id for c in await ctx.candidates()] == [kept.id], "the later candidate is still live"
+    discarded = next(c for c in await ctx.candidates(include_discarded=True) if c.id == rolled_back.id)
+    assert discarded.discarded is True
+    assert ctx.candidate_dir(discarded).exists(), "the artifact must survive a rollback"
+    assert not any(d.exists() for d in scratch), "stale evaluator scratch would be read on re-run"
+    assert survivor_scratch.exists(), "a survivor's results must not be swept up"
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_merge_survivors.py b/plugins/nemo-experimentalist/tests/experimentalist/test_merge_survivors.py
new file mode 100644
index 0000000000..4b0a4ffb43
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_merge_survivors.py
@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Behaviour that arrived from `main` and has no other test on this branch.
+
+This lived in `components/loop.py`, which this refactor deletes, so merging
+main dropped them silently: the suite stayed green because nothing here asserted them.
+A per-commit audit of the merge is what found them. It is pinned here so the next merge
+cannot repeat it. The other loss that audit found -- `allow_empty` for insight runs --
+is pinned in `test_dataset_staging_runner.py`, where the staging doubles already live.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import pytest
+from doubles import FakeBackend, make_context
+from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.entities import Proposal
+from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+
+@pytest.mark.asyncio
+async def test_a_round_with_no_proposals_finalizes_instead_of_buying_another(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """An empty proposal list means the round produced nothing to build.
+
+    Continuing re-analyzes the same population and pays for it again, so the loop stops
+    and finalizes on what it has. Without this the run spends its whole round budget
+    producing nothing, which looks like a slow run rather than a stuck one.
+    """
+    config = EvolutionaryOptimizerConfig(max_rounds=5, terminator=None, analyzer=None, trajectory_scorer=None)
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    rounds = 0
+
+    async def _no_proposals(*_a: Any, **_k: Any) -> list[Proposal]:
+        nonlocal rounds
+        rounds += 1
+        return []
+
+    async def _baseline(*, ctx: Any, config: Any) -> None:
+        proposal = Proposal(ancestor=None, description="baseline", kind="import", payload={})
+        await ctx.component("builder", "import").build(ctx, proposal, generation=0)
+
+    async def _none(*_a: Any, **_k: Any) -> Any:
+        return {}
+
+    async def _nothing(*_a: Any, **_k: Any) -> None:
+        return None
+
+    async def _no_analysis(*_a: Any, **_k: Any) -> str:
+        return ""
+
+    monkeypatch.setattr(loop, "_ensure_baseline", _baseline)
+    monkeypatch.setattr(loop, "_propose_improvements", _no_proposals)
+    monkeypatch.setattr(loop, "_evaluate_validation_candidates", _none)
+    monkeypatch.setattr(loop, "_evaluate_train_candidates", _none)
+    monkeypatch.setattr(loop, "_record_baseline_validation", _nothing)
+    monkeypatch.setattr(loop, "_analyze_round", _no_analysis)
+
+    await loop._run(ctx)
+
+    assert rounds == 1, f"proposed {rounds} times; an empty proposal list must end the loop"
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_metric_targets_reach_components.py b/plugins/nemo-experimentalist/tests/experimentalist/test_metric_targets_reach_components.py
new file mode 100644
index 0000000000..8713112909
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_metric_targets_reach_components.py
@@ -0,0 +1,81 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""The run's metric contract must actually reach the components that enforce it.
+
+``objective_function`` and ``regression_metrics`` are validated on the run config,
+which made them look wired when they were not: every component fell back to its own
+default of "maximize reward" and the configured contract was silently ignored. The
+failure is invisible -- a run completes, reports, and picks a winner, just against the
+wrong objective -- so each construction site is named here.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import pytest
+from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.entities import MetricTarget
+from nemo_experimentalist_plugin.experimentalist.components.selector import ParetoDiversitySelector
+from nemo_experimentalist_plugin.experimentalist.strategies import evolutionary
+from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+OBJECTIVES = [MetricTarget(name="pass_rate", direction="maximize")]
+REGRESSIONS = [MetricTarget(name="latency", direction="minimize")]
+
+
+@pytest.fixture
+def config() -> EvolutionaryOptimizerConfig:
+    return EvolutionaryOptimizerConfig(objective_function=OBJECTIVES, regression_metrics=REGRESSIONS)
+
+
+def test_the_selector_is_built_with_the_configured_targets(tmp_path: Path, config: EvolutionaryOptimizerConfig) -> None:
+    """Without this the winner is chosen against 'reward', whatever the run configured."""
+    selector = EvolutionaryStrategy(working_dir=tmp_path, config=config)._selector(config)
+
+    assert isinstance(selector, ParetoDiversitySelector)
+    assert selector._objective_metrics == OBJECTIVES
+    assert selector._regression_metrics == REGRESSIONS
+
+
+@pytest.mark.asyncio
+async def test_the_proposer_is_built_with_the_configured_targets(
+    tmp_path: Path, config: EvolutionaryOptimizerConfig, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The Proposer states the objective in its own prompt, so a wrong one misdirects the round."""
+    captured: dict[str, Any] = {}
+
+    def capture(role: str, name: str, **kwargs: Any) -> Any:
+        captured.update(kwargs)
+        raise _Stop
+
+    monkeypatch.setattr(evolutionary, "get_component", capture)
+    strategy = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+    with pytest.raises(_Stop):
+        await strategy._propose_improvements(
+            analysis="",
+            evolution_tree=evolutionary.EvolutionTree(),
+            round_num=1,
+            phase="exploration",
+            config=config,
+        )
+
+    assert captured["objective_metrics"] == OBJECTIVES
+    assert captured["regression_metrics"] == REGRESSIONS
+
+
+def test_defaults_are_used_when_the_run_configures_none(tmp_path: Path) -> None:
+    """An unconfigured run still ranks on something, rather than ranking on nothing."""
+    default = EvolutionaryOptimizerConfig()
+    selector = EvolutionaryStrategy(working_dir=tmp_path, config=default)._selector(default)
+
+    assert isinstance(selector, ParetoDiversitySelector)
+    assert [target.name for target in selector._objective_metrics] == [
+        target.name for target in default.objective_function
+    ]
+
+
+class _Stop(Exception):
+    """Cut the call short once the constructor kwargs have been seen."""
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_model_injection_coverage.py b/plugins/nemo-experimentalist/tests/experimentalist/test_model_injection_coverage.py
new file mode 100644
index 0000000000..f513d6ff76
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_model_injection_coverage.py
@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Every component the strategy builds must receive the run's resolved tiers.
+
+`ModelTiers` exists so two runs in one process can target different endpoints and a test
+can inject fakes without touching the environment, and the runner records what it
+resolved as what the run used. A single construction that omits `models=` silently opts
+that component out — the build CodeEditBuilder did, which is the one that writes candidate code —
+and `config_snapshot` still claims otherwise. Asserting over the source catches the
+omission at the construction site rather than needing a live run per component.
+"""
+
+import ast
+import pathlib
+
+COMPONENTS = {
+    "CodeEditBuilder",
+    "TraceRootCauseAnalyzer",
+    "Proposer",
+    "Terminator",
+    "GoalTreeGenerator",
+    "GoalTreeTrajectoryScorer",
+}
+SOURCES = ("strategies/evolutionary.py", "components/analyzer.py")
+
+
+def test_no_component_construction_omits_the_runs_model_tiers() -> None:
+    root = pathlib.Path(__file__).resolve().parents[2] / "src/nemo_experimentalist_plugin/experimentalist"
+    omissions: list[str] = []
+    for rel in SOURCES:
+        path = root / rel
+        for node in ast.walk(ast.parse(path.read_text())):
+            if not (isinstance(node, ast.Call) and isinstance(node.func, ast.Name)):
+                continue
+            if node.func.id in COMPONENTS and not any(kw.arg == "models" for kw in node.keywords):
+                omissions.append(f"{rel}:{node.lineno} {node.func.id}(...)")
+    assert omissions == []
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_objective_reached.py b/plugins/nemo-experimentalist/tests/experimentalist/test_objective_reached.py
index e1ec72a5d1..d00c5f4f32 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_objective_reached.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_objective_reached.py
@@ -15,39 +15,36 @@
 from __future__ import annotations
 
 import pytest
-from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig, MetricTarget
-from nemo_experimentalist_plugin.entities import Candidate, RewardRecord
-from nemo_experimentalist_plugin.experimentalist.components.models import EvolutionNode, EvolutionTree
-from nemo_experimentalist_plugin.experimentalist.components.terminator import Terminator
+from nemo_experimentalist_plugin.entities import Candidate, MetricTarget, Proposal, ResourceRef, RewardRecord
+from nemo_experimentalist_plugin.experimentalist.components.terminator import ConvergenceTerminator
 
 SOLVED = [MetricTarget(name="reward", direction="maximize", target=1.0)]
 UNTARGETED = [MetricTarget(name="reward", direction="maximize")]
 
 
-def _node(label: str, round_: int, killed: int | None = None, **metrics: float) -> EvolutionNode:
+def _node(label: str, round_: int, killed: int | None = None, **metrics: float) -> Candidate:
+    description = "baseline" if round_ == 0 else "some change"
     candidate = Candidate(
         run_id="run-1",
         label=label,
-        round=round_,
-        optimization="baseline" if round_ == 0 else "some change",
+        generation=round_,
+        description=description,
+        generated_from=Proposal(ancestor=None, description=description, kind="import"),
+        artifact=ResourceRef(uri=f"file:///tmp/{label}"),
         rewards={"validation": RewardRecord(metrics=dict(metrics))},
     )
-    candidate.killed_round = killed
-    return EvolutionNode(candidate=candidate)
+    candidate.killed_generation = killed
+    return candidate
 
 
-def _tree(*nodes: EvolutionNode) -> EvolutionTree:
-    tree = EvolutionTree()
-    for node in nodes:
-        tree.add(node.candidate)
-    return tree
+def _tree(*candidates: Candidate) -> list[Candidate]:
+    """The population, in the shape this role's `run` receives it."""
+    return list(candidates)
 
 
-def _assess(tree: EvolutionTree, objectives: list[MetricTarget], **overrides: object):
-    config = EvolutionaryOptimizerConfig.model_validate(
-        {"objective_function": [target.model_dump() for target in objectives], **overrides}
-    )
-    return Terminator.assess_objective_reached(Terminator, evolution_tree=tree, config=config)  # type: ignore[arg-type]
+def _assess(candidates: list[Candidate], objectives: list[MetricTarget], **_overrides: object):
+    """Objectives reach the Terminator at construction, not through the role's signature."""
+    return ConvergenceTerminator(objective_metrics=objectives).assess_objective_reached(candidates)
 
 
 def test_a_solved_objective_stops_the_run() -> None:
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_proposer_contract.py b/plugins/nemo-experimentalist/tests/experimentalist/test_proposer_contract.py
index 74bbdb910e..505d0a2157 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_proposer_contract.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_proposer_contract.py
@@ -3,7 +3,7 @@
 
 """Pin the half of type reuse that lives in the prompt rather than the validator.
 
-`Proposer._run_with_context` is a CodeAct prompt, so its docstring is the
+`CodeChangeProposer._run_with_context` is a CodeAct prompt, so its docstring is the
 instruction the model follows. `_filter_improvements` accepting a repeated
 `optimization_type` only stops the run from dying on one; if the prompt still
 requires every type to be untried, the model never proposes one and the
@@ -14,13 +14,13 @@
 
 import inspect
 
-from nemo_experimentalist_plugin.experimentalist.components.proposer import Proposer
+from nemo_experimentalist_plugin.experimentalist.components.proposer import CodeChangeProposer
 
 
 def _proposal_contract() -> str:
     """The prompt with whitespace collapsed, so assertions do not hinge on where it wraps."""
-    doc = inspect.getdoc(Proposer._run_with_context)
-    assert doc is not None, "Proposer._run_with_context must keep its docstring; it is the prompt"
+    doc = inspect.getdoc(CodeChangeProposer._run_with_context)
+    assert doc is not None, "CodeChangeProposer._run_with_context must keep its docstring; it is the prompt"
     return " ".join(doc.lower().split())
 
 
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_proposer_validation.py b/plugins/nemo-experimentalist/tests/experimentalist/test_proposer_validation.py
index 20a1ef2479..606ed94aac 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_proposer_validation.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_proposer_validation.py
@@ -1,135 +1,130 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-"""Pin what `Proposer._filter_improvements` keeps, drops, and refuses.
+"""What the Proposer must reject before its output reaches a Builder.
 
-Imperfect output is salvaged: an unusable improvement is dropped on its own and
-the round continues with fewer candidates. Only an empty result is fatal.
+`ancestor` became a candidate id rather than a display handle, and survivors are handed
+to the model carrying both — so a plausible-looking `"agent-2"` is exactly what comes
+back. One rejected batch costs a retry; an unvalidated one costs the run, because the
+fork that resolves it happens outside the per-proposal error handling.
 """
 
-from __future__ import annotations
-
-import logging
-
 import pytest
-from nemo_experimentalist_plugin.experimentalist.components.proposer import Improvement, Proposer
-
-ALLOWED = {"edit_concrete_method", "edit_config", "add_concrete_method"}
+from nemo_experimentalist_plugin.experimentalist.components.proposer import CodeChangeProposer, Improvement
 
 
-def _improvement(optimization_type: str, optimization: str, ancestor: str = "agent-0") -> Improvement:
+def _improvement(ancestor: str, optimization_type: str = "add_method") -> Improvement:
     return Improvement(
         ancestor=ancestor,
-        root_cause="the agent underperforms because a handler is missing",
-        optimization=optimization,
+        optimization="add a retrieval step",
+        root_cause="the agent never retrieves",
         optimization_type=optimization_type,
+        task_ids=["task-1"],
     )
 
 
-def _filter(improvements: list[Improvement], max_candidates: int = 3) -> list[Improvement]:
-    return Proposer._filter_improvements(
-        improvements=improvements,
-        max_candidates=max_candidates,
-        allowed_types=ALLOWED,
+def test_an_ancestor_that_is_not_a_survivor_id_is_dropped_not_fatal() -> None:
+    """A label where an id belongs is one bad proposal, not a reason to end the run.
+
+    This check runs after the CodeAct loop, so raising buys no retry — it unwinds through
+    the strategy and fails a run that may have spent hours. The survivors carry both `id`
+    and `label`, so "agent-2" is exactly what a model returns.
+    """
+    usable = CodeChangeProposer._usable_improvements(
+        [_improvement("agent-2"), _improvement("id-agent-2", optimization_type="add_tool")],
+        known_ancestors={"id-agent-2"},
+        allowed_types={"add_method", "add_tool"},
     )
 
+    assert [improvement.ancestor for improvement in usable] == ["id-agent-2"]
+
 
-def test_repeated_optimization_type_is_kept() -> None:
-    """Two candidates may legitimately need the same kind of edit in different places."""
-    kept = _filter(
-        [
-            _improvement("edit_concrete_method", "widen the name pattern"),
-            _improvement("edit_concrete_method", "reorder the dispatch chain"),
-        ]
+def test_a_real_survivor_id_passes() -> None:
+    usable = CodeChangeProposer._usable_improvements(
+        [_improvement("id-agent-2")], known_ancestors={"id-agent-2"}, allowed_types={"add_method"}
     )
-    assert len(kept) == 2
 
+    assert len(usable) == 1
+    CodeChangeProposer._validate_improvements(improvements=usable, max_candidates=3)
 
-def test_every_candidate_may_share_one_type() -> None:
-    """The degenerate case: late rounds often have only one kind of work left."""
-    kept = _filter(
-        [
-            _improvement("edit_config", "raise the input limit"),
-            _improvement("edit_config", "raise the retry budget"),
-            _improvement("edit_config", "raise the timeout"),
-        ]
-    )
-    assert len(kept) == 3
 
+def test_a_batch_where_every_ancestor_is_unknown_still_fails_loudly() -> None:
+    """Dropping them all would leave the round silently proposing nothing."""
+    with pytest.raises(ValueError, match="None of the Proposer's 1 improvements were usable"):
+        CodeChangeProposer._usable_improvements(
+            [_improvement("agent-2")], known_ancestors={"id-agent-2"}, allowed_types={"add_method"}
+        )
 
-def test_surplus_improvements_are_truncated() -> None:
-    """Keeping the first N assumes the Proposer ordered them by priority."""
-    kept = _filter(
-        [
-            _improvement("edit_config", "first"),
-            _improvement("edit_concrete_method", "second"),
-            _improvement("add_concrete_method", "third"),
-        ],
-        max_candidates=2,
+
+def test_a_near_miss_optimization_type_is_dropped_not_fatal() -> None:
+    """`edit_method` for `edit_concrete_method` ended a real run at round two.
+
+    There are twenty valid types, so a near miss is as likely as a wrong ancestor, and
+    this check runs after the CodeAct loop where raising buys no retry.
+    """
+    usable = CodeChangeProposer._usable_improvements(
+        [_improvement("id-a", optimization_type="edit_method"), _improvement("id-a", optimization_type="add_method")],
+        known_ancestors={"id-a"},
+        allowed_types={"add_method", "edit_concrete_method"},
     )
-    assert [i.optimization for i in kept] == ["first", "second"]
+
+    assert [improvement.optimization_type for improvement in usable] == ["add_method"]
 
 
-def test_surplus_is_counted_after_the_unusable_are_dropped() -> None:
-    """Cutting first would discard the only usable improvement and make the round fatal."""
-    kept = _filter(
-        [
-            _improvement("add_subagent", "delegate to a new agent"),
-            _improvement("add_subagent", "delegate to another new agent"),
-            _improvement("edit_config", "raise the input limit"),
+def test_two_improvements_may_share_an_optimization_type() -> None:
+    """#1163: a repeated type is not evidence of a malformed batch.
+
+    There are twenty optimization types and two genuinely different edits to the same
+    method share one, so raising here ends a paid-for round over nothing. A real
+    duplicate is caught by the text check below instead. This killed a live
+    generalization run, where the Proposer returned two distinct fixes both typed
+    `edit_concrete_method`.
+    """
+    kept = CodeChangeProposer._validate_improvements(
+        improvements=[
+            _improvement("id-agent-0", optimization_type="edit_concrete_method"),
+            Improvement(
+                ancestor="id-agent-0",
+                optimization="reorder the dispatch chain",
+                root_cause="the list handler shadows the count handler",
+                optimization_type="edit_concrete_method",
+                task_ids=["task-2"],
+            ),
         ],
         max_candidates=2,
     )
-    assert [i.optimization for i in kept] == ["raise the input limit"]
 
+    assert [improvement.optimization for improvement in kept] == [
+        "add a retrieval step",
+        "reorder the dispatch chain",
+    ]
 
-def test_type_outside_the_allowed_set_is_dropped() -> None:
-    """A valid OptimizationType the caller did not permit for this run.
 
-    `add_subagent` is a real member of the literal -- an invented string is
-    rejected by Pydantic at construction and never reaches this filter.
-    """
-    kept = _filter(
-        [
-            _improvement("edit_config", "raise the input limit"),
-            _improvement("add_subagent", "delegate to a new agent"),
-        ]
+def test_the_same_optimization_text_twice_is_dropped_to_one() -> None:
+    """Identical text is a real duplicate: building it twice buys nothing."""
+    kept = CodeChangeProposer._validate_improvements(
+        improvements=[_improvement("id-agent-0"), _improvement("id-agent-0", optimization_type="add_tool")],
+        max_candidates=2,
     )
-    assert [i.optimization for i in kept] == ["raise the input limit"]
 
+    assert len(kept) == 1
 
-def test_duplicate_optimization_text_is_dropped() -> None:
-    """Identical proposals are genuinely redundant; the first one survives."""
-    kept = _filter(
-        [
-            _improvement("edit_config", "raise the input limit"),
-            _improvement("edit_concrete_method", "raise the input limit"),
-            _improvement("add_concrete_method", "add a totals handler"),
-        ]
-    )
-    assert [i.optimization for i in kept] == ["raise the input limit", "add a totals handler"]
-
-
-def test_drops_are_logged(caplog: pytest.LogCaptureFixture) -> None:
-    """Silent degradation would let a consistently bad Proposer look healthy."""
-    with caplog.at_level(logging.WARNING):
-        _filter(
-            [
-                _improvement("edit_config", "raise the input limit"),
-                _improvement("add_subagent", "delegate to a new agent"),
-                _improvement("edit_concrete_method", "raise the input limit"),
-            ]
-        )
-    assert "disallowed optimization_type" in caplog.text
-    assert "duplicate optimization text" in caplog.text
 
+def test_a_type_used_in_an_earlier_round_may_be_used_again() -> None:
+    """#1163: novelty is a preference in the prompt, never an allowlist in the validator.
 
-def test_empty_input_is_fatal() -> None:
-    with pytest.raises(ValueError, match="no improvements"):
-        _filter([])
+    `available_types` is `all_types - tried_types`, so enforcing it would forbid a type
+    the moment it worked. A real multi-round run died on exactly that: rounds 1 and 2
+    took the agent from 0.333 to 1.000 with `edit_concrete_method`, round 3 proposed
+    refining it, and the only proposal was rejected as unusable -- which raises and ends
+    a run mid-flight, precisely when the loop is succeeding.
+    """
+    all_types = {"add_method", "edit_concrete_method"}
 
+    usable = CodeChangeProposer._usable_improvements(
+        [_improvement("id-agent-0", optimization_type="edit_concrete_method")],
+        known_ancestors={"id-agent-0"},
+        allowed_types=all_types,  # the full vocabulary, not the untried remainder
+    )
 
-def test_everything_dropped_is_fatal() -> None:
-    """Nothing usable means nothing to build, so the round cannot continue."""
-    with pytest.raises(ValueError, match="none of them usable"):
-        _filter([_improvement("add_subagent", "delegate to a new agent")])
+    assert [improvement.optimization_type for improvement in usable] == ["edit_concrete_method"]
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_registry.py b/plugins/nemo-experimentalist/tests/experimentalist/test_registry.py
new file mode 100644
index 0000000000..f3a28254f8
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_registry.py
@@ -0,0 +1,310 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""The plugin mechanism: components are found by ``(role, name)``.
+
+This is what a developer relies on when they ``pip install`` their own package beside
+ours and select it by name, so the two behaviours that differ are pinned here: resolving
+a name never falls back, and enumerating never lets one broken package take down a run
+that does not use it.
+"""
+
+import types
+from typing import ClassVar
+
+import pytest
+from nemo_experimentalist_plugin.experimentalist import registry as registry_module
+from nemo_experimentalist_plugin.experimentalist.registry import (
+    Component,
+    get_component,
+    load_plugins,
+    registered,
+    resolve,
+)
+from nemo_experimentalist_plugin.experimentalist.roles import Builder, Strategy
+
+
+def test_our_own_components_are_discovered_through_the_entry_point_group() -> None:
+    """No privileged built-ins: ours ship an entry point exactly like a third party's.
+
+    If this breaks, the mechanism a plugin developer depends on is broken too — which is
+    the point of registering ours the same way rather than importing them directly.
+    """
+    assert "evolutionary" in registered("strategy")
+    assert "code-edit" in registered("builder")
+
+
+def test_resolving_an_unknown_name_raises_and_says_what_is_known() -> None:
+    """Never skip, never fall back. A run configured for a strategy that is not installed
+    must not quietly run a different one and report a result for a question nobody asked."""
+    with pytest.raises(LookupError) as excinfo:
+        resolve("strategy", "not-installed")
+
+    message = str(excinfo.value)
+    assert "not-installed" in message
+    assert "evolutionary" in message, "the error should list what is available"
+
+
+def test_a_role_base_class_does_not_register_itself() -> None:
+    """``Strategy`` and ``Builder`` declare a slot; they are not implementations of one."""
+    assert ("strategy", "") not in Component._registry
+    assert ("builder", "") not in Component._registry
+    assert Strategy.name == ""
+    assert Builder.name == ""
+
+
+def test_two_different_classes_claiming_one_name_is_an_error() -> None:
+    """Last-win is the wrong semantics for a named component that must exist."""
+    with pytest.raises(RuntimeError, match="duplicate component builder.code-edit"):
+
+        class Clashing(Builder):
+            name = "code-edit"
+
+
+def test_re_executing_a_component_module_is_not_a_duplicate() -> None:
+    """A module reachable twice — reloaded, or importable by two paths — re-registers.
+
+    Comparing by object identity reported a class as a duplicate of itself, with both
+    sides of the message naming the same class.
+
+    Built by hand rather than with ``importlib.reload`` on the real module: reloading
+    rebinds every class in it, so the config tree's ``CodeEditBuilderConfig`` would stop being the
+    same object as the freshly imported one and unrelated tests would fail.
+    """
+    from nemo_experimentalist_plugin.experimentalist.components.coder import CodeEditBuilder
+
+    def _same_identity(namespace: dict[str, object]) -> None:
+        namespace["name"] = "code-edit"
+        namespace["__module__"] = CodeEditBuilder.__module__
+        namespace["__qualname__"] = CodeEditBuilder.__qualname__
+
+    try:
+        stand_in = types.new_class("CodeEditBuilder", (Builder,), exec_body=_same_identity)  # must not raise
+
+        # It really did re-register: the entry now points at the stand-in, not the real
+        # CodeEditBuilder. Asserting the qualname instead would only re-read what was just written.
+        assert resolve("builder", "code-edit") is stand_in
+        assert stand_in is not CodeEditBuilder
+    finally:
+        # Restore, or every later resolution of the builder gets a class with no build().
+        Component._registry[("builder", "code-edit")] = CodeEditBuilder
+
+    assert resolve("builder", "code-edit") is CodeEditBuilder
+
+
+def test_a_broken_third_party_package_does_not_break_unrelated_runs(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Enumeration degrades; resolution still raises, and says why the name is missing."""
+
+    class _BrokenEntryPoint:
+        name = "strategy.broken"
+        value = "acme_broken.strategy"
+
+        def load(self) -> object:
+            raise ImportError("no module named 'acme_broken'")
+
+    monkeypatch.setattr(registry_module, "entry_points", lambda group: [_BrokenEntryPoint()])
+    monkeypatch.setattr(registry_module, "_LOAD_FAILURES", {})
+    # Restored by monkeypatch: forcing a reload with only the broken entry point visible
+    # would otherwise leave discovery marked done, and every later enumeration in this
+    # process would short-circuit over a registry that never saw the real components.
+    monkeypatch.setattr(registry_module, "_loaded", False)
+
+    load_plugins(force=True)  # must not raise
+
+    with pytest.raises(LookupError, match="failed to import"):
+        resolve("strategy", "broken")
+
+
+def test_get_constructs_with_the_arguments_the_resolver_was_given() -> None:
+    """Construction arguments are the consuming strategy's business, not the registry's."""
+    seen: dict[str, object] = {}
+
+    class Recording(Builder):
+        name = "recording-builder-for-test"
+        accepts: ClassVar[frozenset[str]] = frozenset({"code-change"})
+
+        def __init__(self, **kwargs: object) -> None:
+            seen.update(kwargs)
+
+    try:
+        instance = get_component("builder", "recording-builder-for-test", workspace="/tmp", config=None)
+
+        assert isinstance(instance, Recording)
+        assert seen == {"workspace": "/tmp", "config": None}
+    finally:
+        Component._registry.pop(("builder", "recording-builder-for-test"), None)
+
+
+def test_a_builder_declares_which_proposal_kinds_it_accepts() -> None:
+    """Routing by ``Proposal.kind`` is what lets one run mix candidate kinds later."""
+    from nemo_experimentalist_plugin.experimentalist.components.coder import CodeEditBuilder
+    from nemo_experimentalist_plugin.experimentalist.components.proposer import CODE_CHANGE
+
+    assert CODE_CHANGE in CodeEditBuilder.accepts
+    assert "parameters" not in CodeEditBuilder.accepts
+
+
+@pytest.mark.asyncio
+async def test_the_context_actually_satisfies_the_protocols_it_is_typed_against(tmp_path) -> None:
+    """Otherwise the seam is decoration.
+
+    ``roles`` types ``Strategy.run`` and ``Builder.build`` against these Protocols rather
+    than the concrete context — naming the implementation there closes an import cycle
+    through every component config slice. That indirection is only sound if the real
+    context still provides what they name.
+
+    Scope, precisely: ``isinstance`` against a ``runtime_checkable`` Protocol compares
+    *attribute names only*. It catches a renamed or deleted verb, which is the drift this
+    guards against; it does not catch a changed signature, return type, or sync-vs-async
+    flip. ``ty`` covers those at the call sites.
+    """
+    from doubles import make_context
+    from nemo_experimentalist_plugin.experimentalist.seam import BuilderContext, StrategyContext
+
+    ctx = make_context(root=tmp_path)
+
+    assert isinstance(ctx, BuilderContext)
+    assert isinstance(ctx, StrategyContext)
+
+
+def test_agent_class_docstrings_stay_prompt_shaped() -> None:
+    """A component Agent's class docstring IS its system prompt.
+
+    nooa's ``_resolve_system_prompt`` walks the MRO and installs the nearest class
+    docstring verbatim, so it is spent on the model at every call. Explaining the host's
+    design there — Fork, Candidate, ctx.evaluate, reST markup — hands a coding agent
+    vocabulary it cannot act on, and nothing else in the suite would notice. Design notes
+    belong in comments above the class.
+    """
+    from nemo_experimentalist_plugin.experimentalist.components.analyzer import TraceRootCauseAnalyzer
+    from nemo_experimentalist_plugin.experimentalist.components.coder import CodeEditBuilder
+    from nemo_experimentalist_plugin.experimentalist.components.proposer import CodeChangeProposer
+    from nemo_experimentalist_plugin.experimentalist.components.selector import ParetoDiversitySelector
+    from nemo_experimentalist_plugin.experimentalist.components.terminator import ConvergenceTerminator
+    from nemo_experimentalist_plugin.experimentalist.components.trace_scorer import GoalTreeTrajectoryScorer
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    agents = (
+        CodeEditBuilder,
+        EvolutionaryStrategy,
+        CodeChangeProposer,
+        ConvergenceTerminator,
+        TraceRootCauseAnalyzer,
+        GoalTreeTrajectoryScorer,
+        ParetoDiversitySelector,
+    )
+    for agent in agents:
+        prompt = (agent.__doc__ or "").strip()
+        assert prompt, f"{agent.__name__} has no system prompt"
+        # Length is the blunt guard that catches what a keyword list will not: a prompt
+        # that has grown into design documentation is spent on the model at every call.
+        assert len(prompt.splitlines()) <= 3, (
+            f"{agent.__name__}'s system prompt is {len(prompt.splitlines())} lines; "
+            "design notes belong in a comment above the class"
+        )
+        assert ":class:" not in prompt, f"{agent.__name__}'s prompt carries Sphinx markup"
+        for leaked in ("ctx.", "commit_candidate", "BuilderContext", "ExperimentContext", "Candidate", "AAD"):
+            assert leaked not in prompt, f"{agent.__name__}'s prompt leaks host vocabulary: {leaked}"
+
+
+def test_subclassing_a_registered_component_is_allowed() -> None:
+    """Extending the built-in CodeEditBuilder is the most obvious way to customise a builder.
+
+    `name` must come from the subclass alone. Inheriting it made `class MyCoder(CodeEditBuilder)`
+    look like a second claim on "code-edit" and raise at class-definition time — and because
+    `load_plugins` swallows entry-point import errors, the author's whole package would
+    have been recorded as a load failure with every component in it unresolvable.
+    """
+    from nemo_experimentalist_plugin.experimentalist.components.coder import CodeEditBuilder
+
+    class UnnamedSubclass(CodeEditBuilder):  # must not raise
+        pass
+
+    assert ("builder", "code-edit") not in {
+        (role, name) for (role, name), cls in Component._registry.items() if cls is UnnamedSubclass
+    }
+    assert resolve("builder", "code-edit") is CodeEditBuilder, "the subclass must not have taken over the name"
+
+    try:
+
+        class NamedSubclass(CodeEditBuilder):
+            name = "coder-plus"
+
+        assert resolve("builder", "coder-plus") is NamedSubclass
+        assert NamedSubclass.role == "builder", "role is inherited; only name is not"
+    finally:
+        Component._registry.pop(("builder", "coder-plus"), None)
+
+
+def test_repeated_metadata_lookups_do_not_re_read_the_whole_store(tmp_path) -> None:
+    """The prompts call `get_metadata` once per agent, in a loop.
+
+    Each record carries its full trial list including traces, so re-globbing and
+    re-parsing the store per lookup made one report pass quadratic in the population.
+    """
+    from doubles import make_candidate
+    from nemo_experimentalist_plugin.experimentalist.components.tools import WorkspaceTool
+
+    candidates_root = tmp_path / "eval-and-optimize" / "candidates"
+    candidates_root.mkdir(parents=True)
+    for index in range(5):
+        candidate = make_candidate(label=f"agent-{index}", candidate_id=f"id-{index}")
+        (candidates_root / f"id-{index}.json").write_text(candidate.model_dump_json())
+
+    from nemo_experimentalist_plugin.experimentalist import experimentalist_backend as backend_module
+
+    loads = 0
+    real_load = backend_module.load_candidate
+
+    def _counting_load(path):
+        nonlocal loads
+        loads += 1
+        return real_load(path)
+
+    tool = WorkspaceTool(workspace=tmp_path)
+    import unittest.mock
+
+    with unittest.mock.patch.object(backend_module, "load_candidate", _counting_load):
+        for index in range(5):
+            tool.get_metadata(f"agent-{index}")
+
+    assert loads == 5, f"one pass over the store, not one per lookup; got {loads} reads for 5 lookups"
+
+
+def test_a_components_class_name_is_its_component_name_plus_its_role() -> None:
+    """`<Component><Role>` — `code-edit` + `builder` is `CodeEditBuilder`.
+
+    Derived rather than listed, so a component added later is covered without anyone
+    remembering to extend this. The rule earns its strictness twice over:
+
+    * It is reversible. A reader holding `builder: code-edit` from a config file can name
+      the class without grepping, and someone reading a traceback can name the config
+      value that selected it.
+    * It keeps role and implementation apart. The component classes were called
+      `Proposer` and `Terminator` -- the same names as `roles.Proposer` and
+      `roles.Terminator`, distinguishable only by import path, which reads as though each
+      role has exactly one possible implementation. That is the opposite of what this
+      registry is for.
+
+    Shortening is what makes a convention decorative, so there are no exceptions:
+    `harbor` + `outcome-evaluator` is `HarborNativeOutcomeEvaluator`, not `HarborEvaluator`.
+    """
+    from nemo_experimentalist_plugin.experimentalist.registry import Component, load_plugins
+
+    load_plugins()
+    assert Component._registry, "nothing registered; the check would pass vacuously"
+
+    def expected(component: str, role: str) -> str:
+        parts = component.split("-") + role.split("-")
+        return "".join(part[:1].upper() + part[1:] for part in parts)
+
+    # Shipped components only. The registry is global and other tests register doubles
+    # into it, so an unfiltered sweep fails on whichever of those ran first.
+    wrong = {
+        f"{role}:{name}": f"{cls.__name__} (expected {expected(name, role)})"
+        for (role, name), cls in Component._registry.items()
+        if cls.__module__.startswith("nemo_experimentalist_plugin.") and cls.__name__ != expected(name, role)
+    }
+    assert len(Component._registry) >= 9, "fewer components than this package ships; the filter is too tight"
+
+    assert not wrong, f"class names that do not follow <Component><Role>: {wrong}"
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_reporting.py b/plugins/nemo-experimentalist/tests/experimentalist/test_reporting.py
index 678e634de5..faa418a0bc 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_reporting.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_reporting.py
@@ -8,8 +8,13 @@
 import io
 from pathlib import Path
 
-from nemo_experimentalist_plugin.config import MetricTarget
-from nemo_experimentalist_plugin.experimentalist.reporting import RunReporter, Verbosity
+import pytest
+from doubles import make_context
+from nemo_experimentalist_plugin.entities import MetricTarget
+from nemo_experimentalist_plugin.experimentalist.reporting import (
+    RunReporter,
+    Verbosity,
+)
 
 OBJECTIVES = [
     MetricTarget(name="success", direction="maximize"),
@@ -255,17 +260,37 @@ def test_build_run_reporter_emits_header_and_is_reusable() -> None:
     assert "baseline" in sink.getvalue()
 
 
-def test_deps_accepts_a_reporter() -> None:
-    from nemo_experimentalist_plugin.entities import DatasetRef
-    from nemo_experimentalist_plugin.experimentalist.deps import ExperimentalistDeps
+@pytest.mark.asyncio
+async def test_report_progress_narrates_and_records_the_counter(tmp_path: Path) -> None:
+    """One verb feeds both the human narration and the run entity."""
+    sink = io.StringIO()
+    ctx = make_context(root=tmp_path, reporter=RunReporter(sink=sink))
 
-    reporter = RunReporter(sink=io.StringIO())
-    deps = ExperimentalistDeps(
-        workspace="w",
-        reporter=reporter,
-        insight=Path("/test/insight"),
-        train_dataset=DatasetRef(uri="test-train"),
-        validation_dataset=DatasetRef(uri="test-val"),
-        task_template=DatasetRef(uri="test-task"),
-    )
-    assert deps.reporter is reporter
+    await ctx.report_progress(completed=7, total=15, unit="round", note="evaluating candidates")
+
+    assert "round 7/≤15" in sink.getvalue()
+    assert "evaluating candidates" in sink.getvalue()
+    assert (ctx._run.progress_completed, ctx._run.progress_total, ctx._run.progress_unit) == (7, 15, "round")
+
+
+@pytest.mark.asyncio
+async def test_report_progress_without_a_total_is_still_honest(tmp_path: Path) -> None:
+    """An opaque strategy has no denominator, so it reports a bare counter."""
+    sink = io.StringIO()
+    ctx = make_context(root=tmp_path, reporter=RunReporter(sink=sink))
+
+    await ctx.report_progress(completed=340, unit="trial", note="bootstrapping demos")
+
+    assert "trial 340" in sink.getvalue()
+    assert "≤" not in sink.getvalue()
+    assert ctx._run.progress_total is None
+
+
+def test_note_narrates_without_touching_the_run(tmp_path: Path) -> None:
+    sink = io.StringIO()
+    ctx = make_context(root=tmp_path, reporter=RunReporter(sink=sink))
+
+    ctx.note("agent-3 (1/2): add a retrieval step")
+
+    assert "agent-3 (1/2): add a retrieval step" in sink.getvalue()
+    assert ctx._run.progress_completed == 0
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_repository.py b/plugins/nemo-experimentalist/tests/experimentalist/test_repository.py
index 43e5ecf26e..2695572ebf 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_repository.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_repository.py
@@ -593,7 +593,7 @@ def test_snapshot_subtree_recreates_removed_nested_destination_with_real_git(tmp
     _git(checkout, "add", "pkg/agent/old.py")
     stale = checkout / "pkg" / "agent" / "local-secret.txt"
     stale.write_text("must not survive\n", encoding="utf-8")
-    (checkout / "pkg" / "agent" / "metadata.json").write_text("must not survive\n", encoding="utf-8")
+    (checkout / "pkg" / "agent" / "architecture.md").write_text("must not survive\n", encoding="utf-8")
 
     PRPublisher(agent_dir=checkout)._snapshot_subtree(_winner(tmp_path), "pkg/agent")
 
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_resume_e2e.py b/plugins/nemo-experimentalist/tests/experimentalist/test_resume_e2e.py
new file mode 100644
index 0000000000..0b89dad7a3
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_resume_e2e.py
@@ -0,0 +1,262 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Interrupt a run, start it again over the same directory, and check what survives.
+
+Everything here is real except the model and the evaluator: a real ``ExperimentRunner``,
+a real ``ExperimentContext``, and a real ``LocalExperimentalistBackend`` writing to a real
+directory. The strategy is scripted rather than the evolutionary loop, because the loop
+needs an LLM for every step — but it is scripted to make the same calls in the same order,
+so the host-side half of resume is exercised end to end.
+
+Three failures are reproduced below: a fresh run silently minted over a populated
+candidate store, a run stranded in ``status="running"`` when finalizing threw, and a torn
+``run.json``. Each test states the failure it pins.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, ClassVar
+
+import pytest
+from doubles import FakeEvaluator
+from nemo_experimentalist_plugin.config import CandidateStorageConfig, EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.entities import Candidate, Dataset, DatasetRef, RewardRecord, Task
+from nemo_experimentalist_plugin.experimentalist import runner as runner_module
+from nemo_experimentalist_plugin.experimentalist.context import ExperimentContext
+from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import LocalExperimentalistBackend
+from nemo_experimentalist_plugin.experimentalist.runner import ExperimentRunner
+
+
+class ScriptedStrategy:
+    """Stands in for the loop, calling the context the way the loop does.
+
+    ``fail_after`` names the step to raise on, so a test can cut the run at the point a
+    crash would realistically land: after the baseline is committed, after it is scored,
+    or not at all.
+    """
+
+    supports_resume: ClassVar[bool] = True
+
+    def __init__(self, fail_after: str | None = None) -> None:
+        self.fail_after = fail_after
+        self.saw_resuming: bool | None = None
+        self.population_at_start: list[Candidate] = []
+        self.run_id: str | None = None
+
+    async def run(self, ctx: ExperimentContext) -> Candidate | None:
+        self.saw_resuming = ctx.resuming
+        self.run_id = ctx.run_id
+        self.population_at_start = await ctx.candidates()
+
+        baseline = next((c for c in self.population_at_start if c.is_baseline), None)
+        if baseline is None:
+            baseline = await _import_baseline(ctx)
+        if self.fail_after == "baseline":
+            raise RuntimeError("interrupted right after committing the baseline")
+
+        if "validation" not in baseline.rewards:
+            await ctx.record_reward(baseline, channel="validation", result=RewardRecord(metrics={"reward": 0.25}))
+        await ctx.report_progress(completed=1, total=2, unit="round")
+        if self.fail_after == "scored":
+            raise RuntimeError("interrupted after the baseline was scored")
+
+        return baseline
+
+
+def _make_runner(tmp_path: Path, strategy: Any, monkeypatch: pytest.MonkeyPatch) -> ExperimentRunner:
+    """A runner over a real local backend, with only the model and evaluator faked."""
+    agent_dir = tmp_path / "agent"
+    agent_dir.mkdir(exist_ok=True)
+    (agent_dir / "main.py").write_text("print('agent')\n")
+    experiment_dir = tmp_path / "experiment"
+    experiment_dir.mkdir(exist_ok=True)
+
+    dataset_path = tmp_path / "dataset.jsonl"
+    dataset_path.write_text('{"id": "task-a"}\n')
+
+    # Only the two things that would otherwise need Harbor and a live endpoint.
+    monkeypatch.setattr(
+        runner_module,
+        "EvaluatorFactory",
+        lambda: type("F", (), {"build_evaluator": staticmethod(lambda *a, **k: FakeEvaluator())})(),
+    )
+    monkeypatch.setattr(
+        runner_module,
+        "DatasetFactory",
+        lambda: type(
+            "F",
+            (),
+            {
+                "build_dataset": staticmethod(lambda _type, ref, **_options: Dataset(id=ref.uri)),
+                "build_task_template": staticmethod(lambda _type, ref, **_options: Task(id="template", uri=ref.uri)),
+            },
+        )(),
+    )
+
+    config = EvolutionaryOptimizerConfig(storage=CandidateStorageConfig(archive_candidates=False, publish_winner=False))
+    return ExperimentRunner(
+        backend=LocalExperimentalistBackend(path=experiment_dir),
+        strategy=strategy,
+        config=config,
+        workspace="default",
+        root=experiment_dir,
+        agent=agent_dir,
+        train_dataset=DatasetRef(uri=str(dataset_path), description="train"),
+        validation_dataset=DatasetRef(uri=str(dataset_path), description="validation"),
+    )
+
+
+async def _import_baseline(ctx, description: str = "baseline") -> Candidate:
+    """Build the baseline the way a strategy does: an import Proposal through its Builder."""
+    from nemo_experimentalist_plugin.experimentalist.components.importer import ImportBuilder, import_proposal
+
+    return await ImportBuilder().build(ctx, import_proposal(description))
+
+
+@pytest.mark.asyncio
+async def test_a_second_start_reopens_the_run_and_sees_the_population(tmp_path, monkeypatch) -> None:
+    """The whole point of resume: hours of committed work stay reachable."""
+    first = ScriptedStrategy(fail_after="scored")
+    with pytest.raises(RuntimeError, match="after the baseline was scored"):
+        await _make_runner(tmp_path, first, monkeypatch).run()
+
+    second = ScriptedStrategy()
+    result = await _make_runner(tmp_path, second, monkeypatch).run()
+
+    assert second.saw_resuming is True, "the runner should have re-opened, not started over"
+    assert second.run_id == first.run_id, "a new run id would orphan every candidate already on disk"
+    assert [c.label for c in second.population_at_start] == ["agent-0"]
+    assert second.population_at_start[0].rewards["validation"].metrics == {"reward": 0.25}
+    assert result.winner is not None
+
+
+@pytest.mark.asyncio
+async def test_an_interrupted_first_round_does_not_mint_a_second_baseline(tmp_path, monkeypatch) -> None:
+    """Crashing between committing the baseline and scoring it is the likeliest cut point.
+
+    A second baseline would be re-evaluated, offered to the Proposer and published, and
+    discarding either would delete the artifact the other still addresses.
+    """
+    with pytest.raises(RuntimeError, match="after committing the baseline"):
+        await _make_runner(tmp_path, ScriptedStrategy(fail_after="baseline"), monkeypatch).run()
+
+    second = ScriptedStrategy()
+    await _make_runner(tmp_path, second, monkeypatch).run()
+
+    records = list((tmp_path / "experiment" / "eval-and-optimize" / "candidates").glob("*.json"))
+    assert len(records) == 1, f"expected one baseline, found {[p.name for p in records]}"
+
+
+@pytest.mark.asyncio
+async def test_a_failed_run_is_marked_failed_not_left_running(tmp_path, monkeypatch) -> None:
+    """Including when it is *finalizing* that throws, not the strategy.
+
+    Finalizing resolves the winner's artifact, copies it out and persists the result. When
+    that ran outside the failure handler, a run whose work had actually finished stayed
+    `running` forever with no result written.
+    """
+
+    class _WinnerWithNoArtifact(ScriptedStrategy):
+        async def run(self, ctx: ExperimentContext) -> Candidate | None:
+            winner = await super().run(ctx)
+            assert winner is not None
+            import shutil
+
+            shutil.rmtree(ctx.candidate_dir(winner))  # the artifact goes missing mid-run
+            return winner
+
+    with pytest.raises(ValueError, match="has no artifact at"):
+        await _make_runner(tmp_path, _WinnerWithNoArtifact(), monkeypatch).run()
+
+    run = json.loads((tmp_path / "experiment" / "eval-and-optimize" / "run.json").read_text())
+    assert run["status"] == "failed", "a run that could not be closed out must not read as still running"
+
+
+@pytest.mark.asyncio
+async def test_a_torn_run_json_refuses_rather_than_orphaning_the_population(tmp_path, monkeypatch) -> None:
+    """run.json is rewritten on every progress report, so a kill can truncate it.
+
+    Starting fresh would mint a new run id, and `ctx.candidates()` filters by it — every
+    candidate already built would be on disk and invisible. Refusing is recoverable;
+    silently starting over is not.
+    """
+    with pytest.raises(RuntimeError, match="after the baseline was scored"):
+        await _make_runner(tmp_path, ScriptedStrategy(fail_after="scored"), monkeypatch).run()
+
+    run_path = tmp_path / "experiment" / "eval-and-optimize" / "run.json"
+    run_path.write_text(run_path.read_text()[: len(run_path.read_text()) // 2])  # a torn write
+
+    with pytest.raises(ValueError, match="still.*holds candidate records"):
+        await _make_runner(tmp_path, ScriptedStrategy(), monkeypatch).run()
+
+
+@pytest.mark.asyncio
+async def test_run_json_appears_by_rename_not_by_truncating_in_place(tmp_path, monkeypatch) -> None:
+    """The guard above is a backstop; this is the fix that keeps it from being needed.
+
+    Asserting on the mechanism rather than the outcome, because the outcome is identical
+    either way: a plain `write_text` also leaves valid JSON when nothing interrupts it.
+    What matters is that a reader interrupting this can only ever see the old file or the
+    new one, which is what `os.replace` buys and truncate-then-write does not.
+    """
+    from nemo_experimentalist_plugin.experimentalist import experimentalist_backend as backend_module
+
+    renamed: list[str] = []
+    real_replace = backend_module.os.replace
+
+    def _recording_replace(src: object, dst: object) -> None:
+        renamed.append(Path(str(dst)).name)
+        real_replace(src, dst)
+
+    monkeypatch.setattr(backend_module.os, "replace", _recording_replace)
+
+    await _make_runner(tmp_path, ScriptedStrategy(), monkeypatch).run()
+
+    eo = tmp_path / "experiment" / "eval-and-optimize"
+    assert "run.json" in renamed, "run.json was written in place, so a kill mid-write can tear it"
+    assert json.loads((eo / "run.json").read_text())["status"] == "completed"
+    assert not list(eo.glob(".run.json.tmp")), "the temp file must be renamed away, not left behind"
+
+
+@pytest.mark.asyncio
+async def test_a_round_zero_resume_records_no_baseline_reward_and_does_not_raise(tmp_path) -> None:
+    """The narrowest cut point of all: crash after the baseline was scored, before round-0's analysis.
+
+    `_detect_last_round` finds no `round-0.md`, so the loop takes its *fresh* branch — but
+    `_ensure_baseline` keeps the already-scored baseline and `_evaluate_validation_candidates`
+    returns nothing pending. Indexing that empty map by label raised `KeyError: 'agent-0'`
+    and failed the run on restart.
+    """
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    baseline = await _import_baseline(ctx)
+    await ctx.record_reward(baseline, channel="validation", result=RewardRecord(metrics={"reward": 0.4}))
+
+    await EvolutionaryStrategy._record_baseline_validation(ctx=ctx, baseline=baseline, results={})
+
+    (stored,) = await ctx.candidates()
+    assert stored.rewards["validation"].metrics == {"reward": 0.4}, "the earlier measurement must survive"
+
+
+@pytest.mark.asyncio
+async def test_a_completed_run_is_not_reopened(tmp_path, monkeypatch) -> None:
+    """Resume is for a run that was interrupted, not one that finished.
+
+    A completed run has its winner chosen, its report written and possibly a PR opened.
+    Re-opening set its status back to `running` and let the strategy rewrite all of it,
+    so pointing `--experiment-dir` at a finished run silently destroyed its result. It
+    now refuses and says where to point instead.
+    """
+    await _make_runner(tmp_path, ScriptedStrategy(), monkeypatch).run()
+
+    run = json.loads((tmp_path / "experiment" / "eval-and-optimize" / "run.json").read_text())
+    assert run["status"] == "completed", "the first run did not finish; this test needs it to"
+
+    with pytest.raises(ValueError, match="already completed"):
+        await _make_runner(tmp_path, ScriptedStrategy(), monkeypatch).run()
+
+    after = json.loads((tmp_path / "experiment" / "eval-and-optimize" / "run.json").read_text())
+    assert after["status"] == "completed", "the refused run still reopened the record"
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_role_swap.py b/plugins/nemo-experimentalist/tests/experimentalist/test_role_swap.py
new file mode 100644
index 0000000000..8d52040909
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_role_swap.py
@@ -0,0 +1,849 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""M1's acceptance bar: every seam is swappable from config, with no code change.
+
+The milestone claims the core is done. The test of that claim is that a new
+optimization paradigm — HPO next — needs no edit to the strategy or to any existing
+component. If a role cannot be named in config and resolved, that claim is false, and
+this file says so rather than leaving it to be discovered when HPO is written.
+
+Resolution alone is not the bar: a component that resolves and then fails on its
+constructor is not swappable, so construction through the context is asserted too.
+"""
+
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any, ClassVar, cast
+
+import pytest
+from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.entities import Candidate, EvaluationResult, Proposal, RewardRecord
+from nemo_experimentalist_plugin.experimentalist.registry import (
+    Component,
+    get_component,
+    load_plugins,
+    registered,
+    resolve,
+)
+from nemo_experimentalist_plugin.experimentalist.roles import (
+    Analyzer,
+    Builder,
+    OutcomeEvaluator,
+    Proposer,
+    Selector,
+    Strategy,
+    Terminator,
+    TrajectoryScorer,
+)
+
+#: Every role the evolutionary strategy delegates to, and the config key naming it.
+ROLES = {
+    "strategy": "strategy",
+    "builder": "builder",
+    "outcome-evaluator": "outcome_evaluator",
+    "proposer": "proposer",
+    "selector": "selector",
+    "terminator": "terminator",
+    "root-cause-analyzer": "analyzer",
+    "trajectory-scorer": "trajectory_scorer",
+}
+
+
+async def _no_evaluations(*_args: Any, **_kwargs: Any) -> dict[str, EvaluationResult]:
+    """Stand in for an evaluation step that needs a model."""
+    return {}
+
+
+async def _no_analysis(*_args: Any, **_kwargs: Any) -> str:
+    """Stand in for the round analysis, which needs a model."""
+    return ""
+
+
+async def _nothing(*_args: Any, **_kwargs: Any) -> None:
+    """Stand in for a per-round step whose result nothing here reads."""
+    return None
+
+
+async def _no_proposals(*_args: Any, **_kwargs: Any) -> list[Proposal]:
+    """One proposal that builds nothing.
+
+    An *empty* list ends the loop -- there is nothing to build, so another round would
+    re-analyze the same population and pay for it again. These tests want a round that
+    runs and produces no candidate, which is a different thing, so they pair this with
+    `_builds_nothing`.
+    """
+    return [Proposal(ancestor=None, description="proposed", kind="code-change", payload={})]
+
+
+async def _builds_nothing(*_args: Any, **_kwargs: Any) -> list[Any]:
+    """Accept the proposal and produce no candidate."""
+    return []
+
+
+async def _one_baseline(*, ctx: Any, config: Any) -> None:
+    proposal = Proposal(ancestor=None, description="baseline", kind="import", payload={})
+    await ctx.component("builder", "import").build(ctx, proposal, generation=0)
+
+
+@pytest.fixture
+def isolated_registry() -> Iterator[None]:
+    """Register stand-ins without leaking them into other tests.
+
+    Two hazards, both of which have bitten:
+
+    Restore the mapping's *contents*, never the object. Entry-point discovery writes into
+    whichever dict is bound at the time and runs once per process, so replacing the object
+    sends the real components into a copy that is then discarded.
+
+    And discover *before* snapshotting. Taking the snapshot first captures an empty
+    registry, and the teardown then restores that emptiness over the real components.
+    """
+    load_plugins()
+    before = dict(Component._registry)
+    yield
+    Component._registry.clear()
+    Component._registry.update(before)
+
+
+def test_the_defaults_name_a_component_that_exists(isolated_registry: None) -> None:
+    """A default that does not resolve is a run that dies after the user waits for it."""
+    config = EvolutionaryOptimizerConfig()
+    for role, key in ROLES.items():
+        name = getattr(config, key)
+        assert name is not None, f"{key} has no default"
+        assert resolve(role, name) is not None, f"default {key}={name!r} does not resolve"
+
+
+def test_every_role_can_be_swapped_for_one_this_repo_does_not_know(isolated_registry: None) -> None:
+    """The whole milestone in one assertion.
+
+    Each stand-in registers the way a `pip install`ed package's would, and config names
+    it. Nothing in the strategy or in any existing component changes.
+    """
+
+    class Swapped:
+        """Marks a class as the replacement, so resolution can be told from a default."""
+
+    class SwappedStrategy(Swapped, Strategy):
+        name = "acme-bandit"
+        supports_resume: ClassVar[bool] = False
+
+    class SwappedBuilder(Swapped, Builder):
+        name = "acme-overlay"
+        accepts: ClassVar[frozenset[str]] = frozenset({"parameters"})
+
+    class SwappedEvaluation(Swapped, OutcomeEvaluator):
+        name = "acme-scorer"
+
+    class SwappedProposer(Swapped, Proposer):
+        name = "acme-hpo"
+        produces: ClassVar[frozenset[str]] = frozenset({"parameters"})
+
+    class SwappedSelector(Swapped, Selector):
+        name = "acme-crowding"
+
+    class SwappedTerminator(Swapped, Terminator):
+        name = "acme-budget"
+
+    class SwappedAnalyzer(Swapped, Analyzer):
+        name = "acme-blind"
+
+    class SwappedScorer(Swapped, TrajectoryScorer):
+        name = "acme-steps"
+
+    config = EvolutionaryOptimizerConfig(
+        strategy="acme-bandit",
+        builder="acme-overlay",
+        outcome_evaluator="acme-scorer",
+        proposer="acme-hpo",
+        selector="acme-crowding",
+        terminator="acme-budget",
+        analyzer="acme-blind",
+        trajectory_scorer="acme-steps",
+    )
+
+    for role, key in ROLES.items():
+        resolved = resolve(role, getattr(config, key))
+        assert issubclass(resolved, Swapped), f"{role} resolved to {resolved.__name__}, not the configured one"
+
+
+@pytest.mark.asyncio
+async def test_turning_off_the_analyzer_skips_the_work_that_feeds_it(
+    tmp_path, isolated_registry: None, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """`analyzer: null` must skip the train evaluation, which is the expensive half.
+
+    Driven through the loop: the config echoing back what it was handed says nothing
+    about whether the loop reads it.
+    """
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    trained: list[int] = []
+
+    async def train_eval(**kwargs: Any) -> dict[str, Any]:
+        trained.append(kwargs["round_num"])
+        return {}
+
+    config = EvolutionaryOptimizerConfig(max_rounds=1, analyzer=None, terminator=None, trajectory_scorer=None)
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+    monkeypatch.setattr(loop, "_ensure_baseline", _one_baseline)
+    monkeypatch.setattr(loop, "_evaluate_train_candidates", train_eval)
+    monkeypatch.setattr(loop, "_evaluate_validation_candidates", _no_evaluations)
+    monkeypatch.setattr(loop, "_record_baseline_validation", _nothing)
+    monkeypatch.setattr(loop, "_analyze_round", _no_analysis)
+    monkeypatch.setattr(loop, "_propose_improvements", _no_proposals)
+    monkeypatch.setattr(loop, "_build_candidates", _builds_nothing)
+
+    await loop._run(make_context(root=tmp_path, backend=FakeBackend()))
+
+    assert trained == [], "the train evaluation ran even though nothing consumes it"
+
+
+def test_resolution_constructs_with_what_the_caller_passes(isolated_registry: None) -> None:
+    """A replacement is built by the strategy that resolves it, on that strategy's terms."""
+    seen: dict[str, Any] = {}
+
+    class RecordingBuilder(Builder):
+        name = "acme-recording"
+        accepts: ClassVar[frozenset[str]] = frozenset({"code-change"})
+
+        def __init__(self, **kwargs: Any) -> None:
+            seen.update(kwargs)
+
+        async def build(self, ctx: Any, proposal: Proposal, *, generation: int) -> Candidate:
+            raise NotImplementedError
+
+    get_component("builder", "acme-recording", workspace="/tmp", config=None, models=None)
+
+    assert seen == {"workspace": "/tmp", "config": None, "models": None}
+
+
+def test_the_installed_defaults_are_discoverable_without_importing_them() -> None:
+    """What `nemo agents experimentalist components` reads, and what a plugin author
+    checks their package against."""
+    for role in ROLES:
+        assert registered(role), f"no component registered for {role}"
+
+
+def test_an_installed_out_of_tree_package_is_discovered() -> None:
+    """The developer journey of §1, checked rather than described.
+
+    `examples/acme-strategies` is a separate package with its own pyproject and one entry
+    point. When it is installed, its strategy resolves by name here with no change to this
+    repository — which is the only evidence that both discovery levels work for someone
+    who is not us.
+
+    This one does not skip when the package is missing, unlike the two below. It is the
+    canary for the wiring itself: the package is a locked dev dependency, so absent means
+    someone unwired it, and three tests quietly skipping is how a broken one survived
+    unnoticed before.
+    """
+    import acme_strategies  # noqa: F401 - importing is the assertion
+
+    resolved = resolve("strategy", "random-search")
+
+    assert resolved.__module__.startswith("acme_strategies"), "resolved to something in this repo"
+    assert issubclass(resolved, Strategy)
+    assert "random-search" in registered("strategy")
+
+
+@pytest.mark.asyncio
+async def test_an_out_of_tree_strategy_runs_and_produces_a_winner(tmp_path: Path, isolated_registry: None) -> None:
+    """Discovery is half of it. This drives the installed package end to end — it imports
+    a baseline, builds through `ctx.component`, scores, and returns a winner — because
+    resolving without running is what let a Builder that raised on construction pass.
+    """
+    pytest.importorskip("acme_strategies", reason="out-of-tree example package is not installed")
+    from doubles import FakeBackend, make_context
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+
+    class NoopBuilder(Builder):
+        name = "acme-noop-build"
+        accepts: ClassVar[frozenset[str]] = frozenset({"code-change"})
+
+        def __init__(self, **kwargs: Any) -> None:
+            pass
+
+        async def build(self, ctx: Any, proposal: Proposal, *, generation: int = 0) -> Candidate:
+            fork = await ctx.fork(proposal)
+            return await ctx.commit_candidate(proposal=proposal, artifact=fork.workdir, generation=generation)
+
+    config = EvolutionaryOptimizerConfig(max_rounds=1, max_candidates=1, builder="acme-noop-build")
+    # resolve() is typed to the role protocol, which is the point: the host knows a
+    # Strategy, not this package's class. The role declares no __init__, so the
+    # constructor's arguments are the resolving strategy's contract, not the role's --
+    # hence the cast to build it.
+    strategy_class = cast(Any, resolve("strategy", "random-search"))
+    strategy = cast("Strategy", strategy_class(working_dir=tmp_path, config=config))
+
+    winner = await strategy.run(ctx)
+
+    assert winner is not None
+    assert len(await ctx.candidates()) == 2, "a baseline and one variant"
+
+
+@pytest.mark.asyncio
+async def test_the_round_budget_bounds_the_loop_without_a_terminator(
+    tmp_path, isolated_registry: None, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """`max_rounds` must hold even when no terminator is selected.
+
+    A component's opinion must not be the only thing between a config and an unbounded
+    run, so the loop is driven here with `terminator: null` and every per-round step
+    stubbed: it has to stop on the budget alone, and the count has to be exact.
+    """
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    config = EvolutionaryOptimizerConfig(max_rounds=3, terminator=None, analyzer=None, trajectory_scorer=None)
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    rounds = 0
+
+    async def one_round(*_args: Any, **kwargs: Any) -> list[Proposal]:
+        nonlocal rounds
+        rounds += 1
+        if rounds > config.max_rounds:  # the bound is broken; stop rather than spin
+            raise AssertionError(f"loop ran round {rounds} with max_rounds={config.max_rounds}")
+        # Proposing nothing would end the loop on its own, which would pass this test
+        # without the budget doing any work.
+        return [Proposal(ancestor=None, description="proposed", kind="code-change", payload={})]
+
+    monkeypatch.setattr(loop, "_ensure_baseline", _one_baseline)
+    monkeypatch.setattr(loop, "_propose_improvements", one_round)
+    monkeypatch.setattr(loop, "_build_candidates", _builds_nothing)
+    monkeypatch.setattr(loop, "_evaluate_validation_candidates", _no_evaluations)
+    monkeypatch.setattr(loop, "_record_baseline_validation", _nothing)
+    monkeypatch.setattr(loop, "_analyze_round", _no_analysis)
+
+    await loop._run(ctx)
+
+    assert rounds == config.max_rounds
+
+
+@pytest.mark.asyncio
+async def test_every_default_constructs_through_the_context(tmp_path, isolated_registry: None) -> None:
+    """Resolution is not the bar; construction is."""
+    from doubles import FakeBackend, make_context
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+
+    for role, key in ROLES.items():
+        if role == "strategy":
+            continue  # built by the runner, not by a strategy through the context
+        name = getattr(EvolutionaryOptimizerConfig(), key)
+        built = ctx.component(role, name)
+        assert built is not None, f"{role}={name!r} resolved but could not be constructed"
+
+
+def test_the_context_supplies_every_run_scoped_argument(tmp_path, isolated_registry: None) -> None:
+    """A component cannot know these for itself, so the context is the only thing that
+    can supply them — and a default that quietly falls back hides their absence."""
+    from doubles import FakeBackend, make_context
+
+    seen: dict[str, Any] = {}
+
+    class Greedy(Builder):
+        name = "acme-greedy"
+
+        def __init__(self, workspace, working_dir, evaluator, dataset, **kwargs: Any) -> None:
+            seen.update(workspace=workspace, working_dir=working_dir, evaluator=evaluator, dataset=dataset)
+
+        async def build(self, ctx: Any, proposal: Proposal, *, generation: int) -> Candidate:
+            raise NotImplementedError
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+
+    ctx.component("builder", "acme-greedy")
+
+    assert seen == {
+        "workspace": ctx.root,
+        "working_dir": ctx.root,
+        "evaluator": ctx.outcome_evaluator,
+        "dataset": ctx.datasets["train"],
+    }
+
+
+def test_the_built_in_coder_gets_what_it_needs_to_verify_a_build(tmp_path, isolated_registry: None) -> None:
+    """The out-of-tree example builds through `ctx.component`, and a CodeEditBuilder without an
+    evaluator or a dataset raises on its first build rather than at construction."""
+    from doubles import FakeBackend, make_context
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+
+    coder = ctx.component("builder", "code-edit")
+
+    assert coder._evaluator is ctx.outcome_evaluator
+    # Train, never validation: a Builder repairs against what it is handed, and the
+    # winner is chosen on validation.
+    assert coder._dataset is ctx.datasets["train"]
+
+
+@pytest.mark.asyncio
+async def test_a_swapped_builder_runs_through_the_context(tmp_path, isolated_registry: None) -> None:
+    """The narrowest end-to-end check of the seam: config names it, the context builds
+    it, and it produces a Candidate through the same verbs the built-in CodeEditBuilder uses."""
+    from doubles import FakeBackend, make_context
+
+    class StubBuilder(Builder):
+        name = "acme-noop"
+        accepts: ClassVar[frozenset[str]] = frozenset({"code-change"})
+
+        def __init__(self, **kwargs: Any) -> None:
+            pass
+
+        async def build(self, ctx: Any, proposal: Proposal, *, generation: int = 0) -> Candidate:
+            fork = await ctx.fork(proposal)
+            (fork.workdir / "changed.py").write_text("# built by an out-of-tree builder\n")
+            return await ctx.commit_candidate(proposal=proposal, artifact=fork.workdir, generation=generation)
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    baseline = await ctx.component("builder", "import").build(
+        ctx, Proposal(ancestor=None, description="baseline", kind="import", payload={}), generation=0
+    )
+    proposal = Proposal(ancestor=baseline.id, description="a change", kind="code-change", payload={})
+
+    candidate = await ctx.component("builder", "acme-noop").build(ctx, proposal, generation=1)
+
+    assert candidate.ancestor == baseline.id
+    assert (ctx.candidate_dir(candidate) / "changed.py").exists()
+
+
+def test_registering_a_component_in_a_test_does_not_leak(isolated_registry: None) -> None:
+    """The registry is global mutable state, and every leak from it has been invisible to
+    the full suite — visible only in isolation or in reverse order."""
+    before = set(Component._registry)
+
+    class Ephemeral(Terminator):
+        name = "acme-ephemeral"
+
+    assert ("terminator", "acme-ephemeral") in Component._registry
+    # The fixture's teardown is what must remove it; this records the contract.
+    assert set(Component._registry) - before == {("terminator", "acme-ephemeral")}
+
+
+@pytest.mark.asyncio
+async def test_a_proposer_and_builder_that_cannot_work_together_fail_before_the_run(
+    tmp_path, isolated_registry: None
+) -> None:
+    """A Proposer emitting only kinds the Builder rejects produces empty rounds that look
+    like a run doing work. Hours later it finishes with the baseline as winner."""
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    class ParameterProposer(Proposer):
+        name = "acme-hpo-only"
+        produces: ClassVar[frozenset[str]] = frozenset({"parameters"})
+
+    config = EvolutionaryOptimizerConfig(proposer="acme-hpo-only", builder="code-edit")
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+
+    with pytest.raises(ValueError, match="no proposal could be built"):
+        await loop._run(make_context(root=tmp_path, backend=FakeBackend()))
+
+
+@pytest.mark.asyncio
+async def test_a_proposal_no_builder_accepts_is_dropped_not_raised(tmp_path, isolated_registry: None) -> None:
+    """One unbuildable proposal must not end a run that has already spent hours."""
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    config = EvolutionaryOptimizerConfig(builder="code-edit")
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    unbuildable = Proposal(ancestor=None, description="tune a knob", kind="parameters", payload={})
+
+    built = await loop._build_candidates(
+        ctx=ctx, dataset=ctx.datasets["train"], proposals=[unbuildable], generation=1, config=config
+    )
+
+    assert built == []
+
+
+@pytest.mark.asyncio
+async def test_naming_a_trajectory_scorer_reaches_it(
+    tmp_path, isolated_registry: None, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A gate that skips the scoring step is indistinguishable from `trajectory_scorer:
+    null`, so the run silently loses a reward channel it was configured to measure."""
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    reached: list[str] = []
+
+    class StepCountScorer(TrajectoryScorer):
+        name = "acme-steps"
+
+        def __init__(self, **kwargs: Any) -> None:
+            pass
+
+        async def run(self, ctx: Any, *, candidates: list[Candidate], **kwargs: Any) -> dict[str, RewardRecord]:
+            reached.append("acme-steps")
+            # A real record, not an empty dict: returning {} never exercises the key type,
+            # which is how `dict[Candidate, ...]` shipped despite Candidate being unhashable.
+            return {c.id: RewardRecord(metrics={"aggregate": 0.5}) for c in candidates}
+
+    config = EvolutionaryOptimizerConfig(max_rounds=1, analyzer=None, terminator=None, trajectory_scorer="acme-steps")
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+
+    monkeypatch.setattr(loop, "_ensure_baseline", _one_baseline)
+    monkeypatch.setattr(loop, "_evaluate_validation_candidates", _no_evaluations)
+    monkeypatch.setattr(loop, "_record_baseline_validation", _nothing)
+    monkeypatch.setattr(loop, "_analyze_round", _no_analysis)
+    monkeypatch.setattr(loop, "_propose_improvements", _no_proposals)
+    monkeypatch.setattr(loop, "_build_candidates", _builds_nothing)
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    await loop._run(ctx)
+
+    assert reached == ["acme-steps"]
+    scored = [c for c in await ctx.candidates() if c.rewards["validation-trajectory"].metrics]
+    assert scored, "the scorer's records never reached the candidates"
+
+
+@pytest.mark.asyncio
+async def test_the_architecture_doc_comes_from_the_configured_builder(tmp_path, isolated_registry: None) -> None:
+    """Not from the CodeEditBuilder: a builder that writes no architecture doc must not have one
+    written for it by a component the config never named."""
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    described: list[Path] = []
+
+    class DescribingBuilder(Builder):
+        name = "acme-describes"
+        accepts: ClassVar[frozenset[str]] = frozenset({"code-change"})
+
+        def __init__(self, **kwargs: Any) -> None:
+            pass
+
+        async def build(self, ctx: Any, proposal: Proposal, *, generation: int) -> Candidate:
+            raise NotImplementedError
+
+        async def describe(self, artifact: Path) -> None:
+            described.append(artifact)
+
+    config = EvolutionaryOptimizerConfig(builder="acme-describes")
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+
+    await loop._generate_architecture_doc(ctx=ctx, agent_dir=tmp_path / "candidate", config=config)
+
+    assert described == [tmp_path / "candidate"]
+
+
+@pytest.mark.asyncio
+async def test_the_loop_carries_full_candidates_forward_not_the_selectors_slim_copies(
+    tmp_path, isolated_registry: None, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The selector is handed `slim()` copies so trials never reach a prompt. What it
+    returns are those same copies, and persisting one empties every channel's trials.
+    """
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    class KeepEverything(Selector):
+        name = "acme-keep-all"
+
+        def __init__(self, **kwargs: Any) -> None:
+            pass
+
+        async def survivors(self, candidates: list[Candidate], *, k: int) -> list[Candidate]:
+            return list(candidates)
+
+        def winner(self, candidates: list[Candidate]) -> Candidate | None:
+            return candidates[0] if candidates else None
+
+    config = EvolutionaryOptimizerConfig(
+        max_rounds=1, selector="acme-keep-all", terminator=None, analyzer=None, trajectory_scorer=None
+    )
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+
+    async def two_candidates(*, ctx: Any, config: Any) -> None:
+        for description in ("baseline", "a sibling"):
+            proposal = Proposal(ancestor=None, description=description, kind="import", payload={})
+            await ctx.component("builder", "import").build(ctx, proposal, generation=0)
+
+    async def scored(*, ctx: Any, candidates: list[Candidate]) -> dict[str, Any]:
+        from nemo_experimentalist_plugin.entities import RewardRecord
+
+        return {c.label: RewardRecord(metrics={"reward": 0.5}) for c in candidates}
+
+    monkeypatch.setattr(loop, "_ensure_baseline", two_candidates)
+    monkeypatch.setattr(loop, "_evaluate_validation_candidates", scored)
+    monkeypatch.setattr(loop, "_record_baseline_validation", _nothing)
+    monkeypatch.setattr(loop, "_analyze_round", _no_analysis)
+    monkeypatch.setattr(loop, "_propose_improvements", _no_proposals)
+    monkeypatch.setattr(loop, "_build_candidates", _builds_nothing)
+
+    await loop._run(ctx)
+
+    assert all(c.rewards["validation"].metrics for c in await ctx.candidates())
+
+
+@pytest.mark.asyncio
+async def test_the_analyzer_is_built_with_the_runs_trace_loader(tmp_path, isolated_registry: None) -> None:
+    """Without them the analyzer cannot load `intake://` traces, and a trace-starved
+    diagnosis reads as a finding about the agent rather than about the analyzer.
+
+    Observed: it reported the agent's root cause as "the analyzer lacks the Intake
+    client/workspace configuration", and the round built a candidate against that.
+    """
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    seen: dict[str, Any] = {}
+
+    class RecordingAnalyzer(Analyzer):
+        name = "acme-recording-analyzer"
+
+        def __init__(self, **kwargs: Any) -> None:
+            seen.update(kwargs)
+
+        async def run(self, **kwargs: Any) -> Any:
+            raise AssertionError("construction is what this pins")
+
+    config = EvolutionaryOptimizerConfig(analyzer="acme-recording-analyzer")
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+
+    baseline = await _one(ctx)
+    with pytest.raises(AssertionError):
+        await loop._analyze_round(
+            analysis_dir=tmp_path,
+            dataset=ctx.datasets["train"],
+            evaluations={baseline.label: cast(Any, object())},
+            survivors=[baseline],
+            round_num=0,
+            config=config,
+            load_trace=ctx.load_trace,
+            agent_spec_path=None,
+        )
+
+    assert "load_trace" in seen, "analyzer built without a trace loader; intake traces are unreadable"
+    assert seen["load_trace"] == ctx.load_trace
+
+
+async def _one(ctx: Any) -> Any:
+    proposal = Proposal(ancestor=None, description="baseline", kind="import", payload={})
+    return await ctx.component("builder", "import").build(ctx, proposal, generation=0)
+
+
+@pytest.mark.asyncio
+async def test_the_builtin_scorer_returns_records_keyed_by_candidate_id(
+    tmp_path, isolated_registry: None, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """`Candidate` is a pydantic model and unhashable, so a dict keyed by one raises at
+    the moment of return — after the round has already paid for the scoring."""
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.components.trace_scorer import GoalTreeTrajectoryScorer
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    baseline = await _one(ctx)
+    scorer = GoalTreeTrajectoryScorer(workspace=tmp_path)
+
+    async def scored(**_: Any) -> dict[str, Any]:
+        return {baseline.label: {"details": {"n1": {}}, "reward": {"aggregate": 0.5}}}
+
+    monkeypatch.setattr(scorer, "_ensure_goal_tree", _nothing)
+    monkeypatch.setattr(scorer, "_update_goal_tree", _nothing)
+    monkeypatch.setattr(scorer, "_reward_trajectories", scored)
+
+    result = await scorer.run(ctx, candidates=[baseline], round_num=0, analysis="x")
+
+    assert list(result) == [baseline.id], "records must be keyed by candidate id, not by the Candidate"
+    assert baseline.trajectory_detail == {"n1": {}}
+
+
+@pytest.mark.asyncio
+async def test_the_scorer_is_told_the_round_its_analysis_describes(
+    tmp_path, isolated_registry: None, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The loop's counter has already advanced when the scorer is called, and the scorer
+    names its persisted state after the round — so passing the raw counter skips a number
+    (observed: a round-1 goal tree written as `round-2-goal.json`)."""
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    rounds: list[int] = []
+
+    class RecordingScorer(TrajectoryScorer):
+        name = "acme-round-recorder"
+
+        def __init__(self, **kwargs: Any) -> None:
+            pass
+
+        async def run(self, ctx: Any, *, candidates: list[Candidate], round_num: int = 0, **kw: Any) -> dict[str, Any]:
+            rounds.append(round_num)
+            return {}
+
+    config = EvolutionaryOptimizerConfig(
+        max_rounds=1, analyzer=None, terminator=None, trajectory_scorer="acme-round-recorder"
+    )
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+    monkeypatch.setattr(loop, "_ensure_baseline", _one_baseline)
+    monkeypatch.setattr(loop, "_evaluate_validation_candidates", _no_evaluations)
+    monkeypatch.setattr(loop, "_record_baseline_validation", _nothing)
+    monkeypatch.setattr(loop, "_analyze_round", _no_analysis)
+    monkeypatch.setattr(loop, "_propose_improvements", _no_proposals)
+    monkeypatch.setattr(loop, "_build_candidates", _builds_nothing)
+
+    await loop._run(make_context(root=tmp_path, backend=FakeBackend()))
+
+    assert rounds == [0], f"scorer told round {rounds}, but it scored round 0's analysis"
+
+
+@pytest.mark.asyncio
+async def test_the_terminator_sees_eliminated_candidates_too(
+    tmp_path, isolated_registry: None, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Convergence reads the whole history, not this round's working set.
+
+    It counts distinct generations and compares an older Pareto front against the
+    current one. `candidates` inside the loop holds only survivors plus the previous
+    round's builds, so passing that hides every eliminated candidate: the generation
+    window can never fill, and an otherwise converged run pays for every remaining
+    round. Driven through the loop, because the call site is what was wrong.
+    """
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+    seen: list[list[str]] = []
+
+    from nemo_experimentalist_plugin.experimentalist.components.terminator import TerminationDecision
+
+    class RecordingTerminator(Terminator):
+        name = "acme-recording-terminator"
+
+        def __init__(self, **kwargs: Any) -> None: ...
+
+        async def run(self, *, round_num: int, candidates: list[Any], prior_analysis: Any = None) -> Any:
+            seen.append([c.label for c in candidates])
+            return TerminationDecision(stop=False)
+
+    async def baseline_plus_an_eliminated_one(*, ctx: Any, config: Any) -> None:
+        """Two candidates, one already eliminated — the case the working set hides."""
+        for description in ("baseline", "killed in an earlier round"):
+            proposal = Proposal(ancestor=None, description=description, kind="import", payload={})
+            candidate = await ctx.component("builder", "import").build(ctx, proposal, generation=0)
+            if description != "baseline":
+                await ctx.update_candidate(candidate, killed_generation=0)
+
+    config = EvolutionaryOptimizerConfig(
+        max_rounds=1, analyzer=None, trajectory_scorer=None, terminator="acme-recording-terminator"
+    )
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+    monkeypatch.setattr(loop, "_ensure_baseline", baseline_plus_an_eliminated_one)
+    monkeypatch.setattr(loop, "_evaluate_validation_candidates", _no_evaluations)
+    monkeypatch.setattr(loop, "_record_baseline_validation", _nothing)
+    monkeypatch.setattr(loop, "_analyze_round", _no_analysis)
+    monkeypatch.setattr(loop, "_propose_improvements", _no_proposals)
+    monkeypatch.setattr(loop, "_build_candidates", _builds_nothing)
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    await loop._run(ctx)
+
+    committed = {c.label for c in await ctx.candidates(include_discarded=True)}
+    assert seen, "the terminator was never consulted"
+    assert set(seen[0]) == committed, (
+        f"terminator saw {seen[0]}, but the run has {sorted(committed)} — "
+        "eliminated candidates must still count toward convergence"
+    )
+
+
+def test_no_component_constructor_names_a_platform_type(isolated_registry: None) -> None:
+    """A component must be constructible by anyone holding a context, and nothing else.
+
+    Trace readers used to take an `AsyncNeMoPlatform` client plus a workspace name, which
+    put a platform type in the public signature of a role a third party is meant to
+    implement: to write one you had to obtain a platform client, and the host had to hand
+    its client to a component. They take `load_trace` from the context instead.
+
+    The check is over the registry rather than a list of files, so a component added later
+    is covered without anyone remembering to add it here.
+    """
+    import inspect
+
+    from nemo_experimentalist_plugin.experimentalist.registry import Component, load_plugins
+
+    load_plugins()
+    assert Component._registry, "nothing registered; the check would pass vacuously"
+
+    offenders = {
+        f"{role}:{name}": [
+            parameter
+            for parameter, value in inspect.signature(cls.__init__).parameters.items()
+            if "NeMoPlatform" in str(value.annotation)
+        ]
+        for (role, name), cls in Component._registry.items()
+    }
+    named = {key: value for key, value in offenders.items() if value}
+
+    assert not named, f"components naming a platform type in their constructor: {named}"
+
+
+async def test_the_context_loads_a_trace_by_reference(tmp_path, isolated_registry: None) -> None:
+    """The verb that replaced the client: a `file://` ref resolves without a platform."""
+    import json
+
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.entities import ResourceRef
+
+    span = {"spanId": "abc", "traceId": "def", "name": "llm", "attributes": {"openinference.span.kind": "LLM"}}
+    trace = tmp_path / "trace.jsonl"
+    trace.write_text(json.dumps({"resourceSpans": [{"scopeSpans": [{"spans": [span]}]}]}) + "\n", encoding="utf-8")
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+
+    explorer = await ctx.load_trace(
+        ResourceRef(uri=f"file://{trace}", description="", metadata={"trace_format": "otlp"})
+    )
+
+    assert explorer is not None
+
+
+@pytest.mark.asyncio
+async def test_the_example_strategy_resumes_where_the_store_left_off(
+    tmp_path: Path, isolated_registry: None, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The out-of-tree example declares `supports_resume`, so it must honour it.
+
+    Restarting at generation 1 would rebuild finished work and report progress that goes
+    backwards. It is the package a third party copies, so the resume contract has to be
+    demonstrated rather than merely declared.
+    """
+    pytest.importorskip("acme_strategies", reason="out-of-tree example package is not installed")
+    import importlib
+
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+
+    # Imported by name: the package is optional here, so a static import would make the
+    # type checker resolve something that is not installed.
+    strategy_class = cast(Any, importlib.import_module("acme_strategies.random_search").RandomSearch)
+
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    baseline = await _one(ctx)
+    assert baseline.generation == 0
+
+    # A run whose configured rounds are already in the store returns its winner and
+    # builds nothing more.
+    built: list[str] = []
+    original = ctx.component
+
+    def _recording_component(role: str, name: str, **kwargs: Any) -> Any:
+        component = original(role, name, **kwargs)
+        if role == "builder":
+            built.append(name)
+        return component
+
+    monkeypatch.setattr(ctx, "component", _recording_component)
+    strategy = strategy_class(working_dir=tmp_path, config=EvolutionaryOptimizerConfig(max_rounds=0))
+
+    winner = await strategy.run(ctx)
+
+    assert winner is not None, "a resumed run with nothing left to do still has a winner"
+    assert built == [], f"a completed run rebuilt candidates: {built}"
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_run_config_reaches_components.py b/plugins/nemo-experimentalist/tests/experimentalist/test_run_config_reaches_components.py
new file mode 100644
index 0000000000..9eb5a03a6b
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_run_config_reaches_components.py
@@ -0,0 +1,112 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Every run-config value must reach the component that reads it.
+
+A value declared on the run config and read by nobody is the worst kind of defect here:
+the run completes, reports and picks a winner, just against settings other than the ones
+the file states -- while `config_snapshot` records it as correct. Review found four of
+these at once, so each construction site is named rather than covered by one general
+assertion.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import pytest
+from doubles import FakeBackend, make_context
+from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig, with_insight_objective
+from nemo_experimentalist_plugin.entities import MetricTarget
+from nemo_experimentalist_plugin.experimentalist.components.selector import ParetoDiversitySelector
+from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+OBJECTIVES = [MetricTarget(name="pass_rate", direction="maximize")]
+REGRESSIONS = [MetricTarget(name="latency", direction="minimize")]
+
+
+def _capturing_context(tmp_path: Path, captured: dict[str, Any]):
+    """A context whose `component()` records the kwargs instead of building anything."""
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+
+    def _component(role: str, name: str, **kwargs: Any) -> Any:
+        captured[role] = kwargs
+        return object()
+
+    ctx.component = _component  # type: ignore[method-assign]
+    return ctx
+
+
+def test_the_selector_is_built_with_the_configured_targets(tmp_path: Path) -> None:
+    """Without this the winner is chosen against 'reward', whatever the run configured."""
+    config = EvolutionaryOptimizerConfig(objective_function=OBJECTIVES, regression_metrics=REGRESSIONS)
+    selector = EvolutionaryStrategy(working_dir=tmp_path, config=config)._selector(config)
+
+    assert isinstance(selector, ParetoDiversitySelector)
+    assert selector._objective_metrics == OBJECTIVES
+    assert selector._regression_metrics == REGRESSIONS
+
+
+def test_the_terminator_is_built_with_the_runs_convergence_window(tmp_path: Path) -> None:
+    """`min_rounds_before_stopping` sits on the run config beside `max_rounds`.
+
+    It had a second home on `TerminatorConfig` with an independent default of 3, and the
+    component read *that* one — so a run asking to stop after 2 rounds was accepted,
+    recorded in `config_snapshot`, and ignored.
+    """
+    config = EvolutionaryOptimizerConfig(min_rounds_before_stopping=2)
+    captured: dict[str, Any] = {}
+
+    EvolutionaryStrategy(working_dir=tmp_path, config=config)._terminator(
+        _capturing_context(tmp_path, captured), config
+    )
+
+    assert captured["terminator"]["min_rounds_before_stopping"] == 2
+
+
+def test_the_trajectory_scorer_is_built_with_the_runs_task_cap(tmp_path: Path) -> None:
+    """Same shape: the cap defaulted to None inside the component, so every complete
+    trace group was scored however small a cap the run asked for."""
+    config = EvolutionaryOptimizerConfig(max_trajectory_tasks=6)
+    captured: dict[str, Any] = {}
+
+    EvolutionaryStrategy(working_dir=tmp_path, config=config)._trajectory_scorer(
+        _capturing_context(tmp_path, captured), config
+    )
+
+    assert captured["trajectory-scorer"]["max_trajectory_tasks"] == 6
+
+
+def test_the_context_carries_the_runs_metric_contract(tmp_path: Path) -> None:
+    """The strategy is built before the host settles the objective, so it reads the
+    contract off the context. That is also what progress lines and `run_finished`
+    report — without it they fall back to `reward` and omit the winner's real scores."""
+    ctx = make_context(
+        root=tmp_path, backend=FakeBackend(), objective_metrics=OBJECTIVES, regression_metrics=REGRESSIONS
+    )
+
+    assert ctx.objective_metrics == OBJECTIVES
+    assert ctx.regression_metrics == REGRESSIONS
+
+
+def test_authored_metric_keys_become_the_objective_and_demote_the_rest() -> None:
+    """What the host computes: authored keys are the objective, configured targets
+    survive as guardrails rather than being dropped."""
+    config = EvolutionaryOptimizerConfig(objective_function=OBJECTIVES, regression_metrics=REGRESSIONS)
+
+    effective = with_insight_objective(config, ("cites_source",))
+
+    assert [t.name for t in effective.objective_function] == ["cites_source"]
+    assert {t.name for t in effective.regression_metrics} == {"pass_rate", "latency"}
+
+
+@pytest.mark.parametrize("field", ["min_rounds_before_stopping", "max_trajectory_tasks"])
+def test_the_value_has_exactly_one_home(field: str) -> None:
+    """Two homes for one value is what made these silently ignorable."""
+    from nemo_experimentalist_plugin.experimentalist.components.goal_tree import GoalTreeConfig
+    from nemo_experimentalist_plugin.experimentalist.components.terminator import TerminatorConfig
+
+    assert field in EvolutionaryOptimizerConfig.model_fields
+    assert field not in TerminatorConfig.model_fields
+    assert field not in GoalTreeConfig.model_fields
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_runner.py b/plugins/nemo-experimentalist/tests/experimentalist/test_runner.py
new file mode 100644
index 0000000000..fd99849e10
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_runner.py
@@ -0,0 +1,519 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""The runner's own contract: prepare inputs, run one strategy, persist and publish."""
+
+import json
+from pathlib import Path
+from types import SimpleNamespace
+from typing import ClassVar
+
+import pytest
+from doubles import FakeBackend, FakeEvaluator, fake_client, make_candidate
+from nemo_experimentalist_plugin.config import CandidateStorageConfig, EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.entities import (
+    Candidate,
+    Dataset,
+    DatasetRef,
+    ExperimentRun,
+    MetricTarget,
+    ResourceRef,
+    RewardRecord,
+    Task,
+)
+from nemo_experimentalist_plugin.experimentalist import runner as runner_module
+from nemo_experimentalist_plugin.experimentalist.context import ExperimentContext
+from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import LocalExperimentalistBackend
+from nemo_experimentalist_plugin.experimentalist.runner import ExperimentRunner
+from nemo_insights_plugin.entities import Insight
+from nemo_platform_plugin.config import Configuration
+
+
+class RecordingStrategy:
+    """Keeps the context it was handed, then returns (or raises) what it was told to."""
+
+    supports_resume: ClassVar[bool] = True
+
+    def __init__(self, winner: Candidate | None = None, error: Exception | None = None) -> None:
+        self.winner = winner
+        self.error = error
+        self.ctx: ExperimentContext | None = None
+
+    async def run(self, ctx: ExperimentContext) -> Candidate | None:
+        self.ctx = ctx
+        if self.error is not None:
+            raise self.error
+        if self.winner is not None:
+            await ctx.update_candidate(self.winner)
+        return self.winner
+
+
+class NonResumableStrategy(RecordingStrategy):
+    supports_resume: ClassVar[bool] = False
+
+
+def _stub_factories(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Replace evaluator/dataset construction, which would otherwise need Harbor."""
+    monkeypatch.setattr(
+        runner_module,
+        "EvaluatorFactory",
+        lambda: type("F", (), {"build_evaluator": staticmethod(lambda *a, **k: FakeEvaluator())})(),
+    )
+    monkeypatch.setattr(
+        runner_module,
+        "DatasetFactory",
+        lambda: type(
+            "F",
+            (),
+            {
+                "build_dataset": staticmethod(lambda _type, ref, **_options: Dataset(id=ref.uri)),
+                "build_task_template": staticmethod(lambda _type, ref: Task(id="template", uri=ref.uri)),
+            },
+        )(),
+    )
+
+
+def _make_runner(
+    tmp_path: Path,
+    *,
+    strategy: RecordingStrategy,
+    monkeypatch: pytest.MonkeyPatch,
+    backend: FakeBackend | None = None,
+    config: EvolutionaryOptimizerConfig | None = None,
+) -> tuple[ExperimentRunner, FakeBackend]:
+    backend = backend or FakeBackend()
+    agent_dir = tmp_path / "agent"
+    agent_dir.mkdir(exist_ok=True)
+    _stub_factories(monkeypatch)
+    return (
+        ExperimentRunner(
+            backend=backend,
+            strategy=strategy,
+            config=config or EvolutionaryOptimizerConfig(),
+            workspace="default",
+            root=tmp_path / "experiment",
+            agent=agent_dir,
+            train_dataset=DatasetRef(uri="train"),
+            validation_dataset=DatasetRef(uri="validation"),
+        ),
+        backend,
+    )
+
+
+@pytest.mark.asyncio
+async def test_strategy_failure_marks_the_run_failed(monkeypatch, tmp_path) -> None:
+    strategy = RecordingStrategy(error=ValueError("baseline failed"))
+    runner, _ = _make_runner(tmp_path, strategy=strategy, monkeypatch=monkeypatch)
+
+    with pytest.raises(ValueError, match="baseline failed"):
+        await runner.run()
+
+    assert strategy.ctx is not None
+    assert strategy.ctx._run.status == "failed"
+
+
+@pytest.mark.asyncio
+async def test_a_completed_run_persists_its_result_and_winner(monkeypatch, tmp_path) -> None:
+    winner = make_candidate(
+        run_id="run-1",
+        label="agent-1",
+        ancestor="agent-0",
+        generation=1,
+        description="add a tool",
+        rewards={"validation": RewardRecord(metrics={"reward": 0.75})},
+    )
+    (tmp_path / "experiment" / "eval-and-optimize" / "agents" / "agent-1").mkdir(parents=True)
+    runner, backend = _make_runner(tmp_path, strategy=RecordingStrategy(winner=winner), monkeypatch=monkeypatch)
+
+    result = await runner.run()
+
+    assert result.winner is winner
+    assert "winner=agent-1" in result.summary
+    assert backend.results == [result]
+    # publish_winner defaults to True upstream, so the winner is published.
+    assert backend.published == ["agent-1"]
+    # run.json names the winner by label, because every artifact path is built from
+    # the label -- 'agents/agent-1', 'results/agent-1-validation'. Writing the id here
+    # yields a reference that resolves to nothing, and an empty lookup downstream reads
+    # as "the winner has no results" rather than as a broken reference.
+    assert backend.runs[-1].winner_agent == "agent-1"
+    assert backend.runs[-1].winner_agent != winner.id
+
+
+@pytest.mark.asyncio
+async def test_the_winner_is_published_when_storage_asks_for_it(monkeypatch, tmp_path) -> None:
+    winner = make_candidate(run_id="run-1", label="agent-1", ancestor="agent-0", generation=1, description="add a tool")
+    (tmp_path / "experiment" / "eval-and-optimize" / "agents" / "agent-1").mkdir(parents=True)
+    config = EvolutionaryOptimizerConfig(storage=CandidateStorageConfig(publish_winner=True))
+    runner, backend = _make_runner(
+        tmp_path, strategy=RecordingStrategy(winner=winner), config=config, monkeypatch=monkeypatch
+    )
+
+    await runner.run()
+
+    assert backend.published == ["agent-1"]
+
+
+@pytest.mark.asyncio
+async def test_the_baseline_is_never_published(monkeypatch, tmp_path) -> None:
+    """``ancestor is None`` means the baseline — there is nothing to open a PR against."""
+    baseline = make_candidate(run_id="run-1", label="agent-0", ancestor=None, generation=0, description="baseline")
+    (tmp_path / "experiment" / "eval-and-optimize" / "agents" / "agent-0").mkdir(parents=True)
+    config = EvolutionaryOptimizerConfig(storage=CandidateStorageConfig(publish_winner=True))
+    runner, backend = _make_runner(
+        tmp_path, strategy=RecordingStrategy(winner=baseline), config=config, monkeypatch=monkeypatch
+    )
+
+    await runner.run()
+
+    assert backend.published == []
+
+
+@pytest.mark.asyncio
+async def test_the_winner_is_copied_out_without_any_owners_scaffolding(monkeypatch, tmp_path) -> None:
+    winner_dir = tmp_path / "experiment" / "eval-and-optimize" / "agents" / "agent-1"
+    winner_dir.mkdir(parents=True)
+    winner = make_candidate(
+        run_id="run-1",
+        label="agent-1",
+        ancestor="agent-0",
+        generation=1,
+        description="add a tool",
+        artifact=winner_dir.as_uri(),
+    )
+    (winner_dir / "main.py").write_text("print('hello')\n")
+    (winner_dir / "architecture.md").write_text("# arch")  # the strategy's
+    (winner_dir / "harbor_wrapper.py").write_text("# harness")  # the evaluator's
+    (winner_dir / "metadata.json").write_text("{}")  # a third-party strategy's real output
+    runner, _ = _make_runner(tmp_path, strategy=RecordingStrategy(winner=winner), monkeypatch=monkeypatch)
+
+    await runner.run()
+
+    root = tmp_path / "experiment"
+    assert (root / "main.py").read_text() == "print('hello')\n"
+    for scaffolding in ("architecture.md", "harbor_wrapper.py"):
+        assert not (root / scaffolding).exists(), scaffolding
+    # Candidate metadata lives in its own store, so this name is not the host's
+    # to strip — a strategy that writes one has produced real output.
+    assert (root / "metadata.json").exists()
+
+
+@pytest.mark.asyncio
+async def test_a_run_with_no_winner_still_completes(monkeypatch, tmp_path) -> None:
+    runner, backend = _make_runner(tmp_path, strategy=RecordingStrategy(winner=None), monkeypatch=monkeypatch)
+
+    result = await runner.run()
+
+    assert result.winner is None
+    assert "winner=none" in result.summary
+    assert backend.results == [result]
+
+
+@pytest.mark.asyncio
+async def test_a_missing_strategy_report_falls_back_to_the_compact_summary(monkeypatch, tmp_path) -> None:
+    runner, _ = _make_runner(tmp_path, strategy=RecordingStrategy(winner=None), monkeypatch=monkeypatch)
+
+    await runner.run()
+
+    report = (tmp_path / "experiment" / "eval-and-optimize" / "OPTIMIZATION.md").read_text()
+    assert "Compact Run Summary" in report
+    assert "Optimization complete" in report
+
+
+@pytest.mark.asyncio
+async def test_an_existing_report_is_left_alone(monkeypatch, tmp_path) -> None:
+    eo = tmp_path / "experiment" / "eval-and-optimize"
+    eo.mkdir(parents=True)
+    (eo / "OPTIMIZATION.md").write_text("# The strategy's own report\n")
+    runner, _ = _make_runner(tmp_path, strategy=RecordingStrategy(winner=None), monkeypatch=monkeypatch)
+
+    await runner.run()
+
+    assert (eo / "OPTIMIZATION.md").read_text() == "# The strategy's own report\n"
+
+
+@pytest.mark.asyncio
+async def test_resume_refuses_loudly_for_a_strategy_that_cannot(monkeypatch, tmp_path) -> None:
+    """These runs cost hours, so a silent restart is the expensive failure."""
+    eo = tmp_path / "experiment" / "eval-and-optimize"
+    eo.mkdir(parents=True)
+    (eo / "run.json").write_text(
+        json.dumps(
+            {"id": "run-existing", "name": "run-existing", "workspace": "default", "agent": "a", "status": "running"}
+        )
+    )
+    runner, _ = _make_runner(tmp_path, strategy=NonResumableStrategy(), monkeypatch=monkeypatch)
+
+    with pytest.raises(ValueError, match="does not support resume"):
+        await runner.run()
+
+
+@pytest.mark.asyncio
+async def test_resume_reopens_the_existing_run_rather_than_creating_one(monkeypatch, tmp_path) -> None:
+    eo = tmp_path / "experiment" / "eval-and-optimize"
+    eo.mkdir(parents=True)
+    (eo / "run.json").write_text(
+        json.dumps(
+            {"id": "run-existing", "name": "run-existing", "workspace": "default", "agent": "a", "status": "failed"}
+        )
+    )
+    strategy = RecordingStrategy()
+    runner, backend = _make_runner(tmp_path, strategy=strategy, monkeypatch=monkeypatch)
+
+    await runner.run()
+
+    assert strategy.ctx is not None
+    assert strategy.ctx.run_id == "run-existing"
+    assert strategy.ctx.resuming is True
+    assert backend.runs == []  # nothing was created
+
+
+@pytest.mark.asyncio
+async def test_persistence_without_git_fails_before_any_work(monkeypatch, tmp_path) -> None:
+    monkeypatch.setattr(runner_module.shutil, "which", lambda _: None)
+    config = EvolutionaryOptimizerConfig(storage=CandidateStorageConfig(archive_candidates=True))
+    strategy = RecordingStrategy()
+    runner, _ = _make_runner(tmp_path, strategy=strategy, config=config, monkeypatch=monkeypatch)
+
+    with pytest.raises(ValueError, match="'git' is not on PATH"):
+        await runner.run()
+
+    assert strategy.ctx is None
+
+
+@pytest.mark.asyncio
+async def test_a_failed_run_is_visible_on_disk(monkeypatch, tmp_path) -> None:
+    """The local backend writes run.json, so a failed run survives the process."""
+    _stub_factories(monkeypatch)
+    agent_dir = tmp_path / "agent"
+    agent_dir.mkdir()
+    runner = ExperimentRunner(
+        backend=LocalExperimentalistBackend(path=tmp_path / "experiment"),
+        strategy=RecordingStrategy(error=ValueError("baseline failed")),
+        config=EvolutionaryOptimizerConfig(),
+        workspace="default",
+        root=tmp_path / "experiment",
+        agent=agent_dir,
+        train_dataset=DatasetRef(uri="train"),
+        validation_dataset=DatasetRef(uri="validation"),
+    )
+
+    with pytest.raises(ValueError, match="baseline failed"):
+        await runner.run()
+
+    saved = json.loads((tmp_path / "experiment" / "eval-and-optimize" / "run.json").read_text(encoding="utf-8"))
+    assert saved["status"] == "failed"
+
+
+def _insight_dataset(identity_char: str = "a") -> Dataset:
+    suite = Path("/experiment/eval-and-optimize/eval_author/insight-1/insight-suite")
+    task = Task(id="task-a", uri=(suite / "task-a").as_uri())
+    return Dataset(
+        id="insight",
+        source=ResourceRef(uri=suite.as_uri()),
+        tasks=[task],
+        metadata={
+            "insight_suite_identity": f"sha256:{identity_char * 64}",
+            "insight_suite_scorer_identity": f"sha256:{'b' * 64}",
+            "insight_suite_task_hashes": {
+                "task-a": {"content_hash": f"sha256:{'c' * 64}", "verifier_hash": f"sha256:{'d' * 64}"}
+            },
+        },
+    )
+
+
+def _insight_candidate(label: str, *, round_num: int, insight: float, validation: float) -> Candidate:
+    return make_candidate(
+        run_id="run-1",
+        label=label,
+        ancestor=None if round_num == 0 else "agent-0",
+        generation=round_num,
+        description="baseline" if round_num == 0 else "improve required tool use",
+        rewards={
+            "insight": RewardRecord(
+                metrics={"reward": validation, "uses_required_tool": insight},
+                metadata={
+                    "suite_identity": f"sha256:{'a' * 64}",
+                    "metric_keys": ["reward", "uses_required_tool"],
+                },
+            ),
+            "validation": RewardRecord(metrics={"reward": validation}),
+        },
+    )
+
+
+async def _run_with_insight_suite(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    dataset: Dataset,
+    candidates: list[Candidate],
+) -> None:
+    """Drive a run whose Eval Author authored *dataset*, with *candidates* already scored."""
+    backend = FakeBackend(
+        client=fake_client(),  # an Insight run needs a platform client to load traces
+        insight=Insight(
+            workspace="default",
+            agent="agent-source",
+            title="tool use",
+            description="the agent skips the required tool",
+        ),
+    )
+    for candidate in candidates:
+        await backend.create_candidate(workspace="default", candidate=candidate)
+    winner = candidates[-1]
+    (tmp_path / "experiment" / "eval-and-optimize" / "agents" / winner.label).mkdir(parents=True)
+
+    _stub_factories(monkeypatch)
+    monkeypatch.setattr(
+        runner_module,
+        "stage_eval_author_inputs",
+        _async(lambda _root, **refs: SimpleNamespace(**refs)),
+    )
+    monkeypatch.setattr(
+        "nemo_eval_author_plugin.eval_author.agent.EvalAuthor",
+        lambda **_: SimpleNamespace(
+            run=_async(
+                lambda **kwargs: SimpleNamespace(
+                    train_dataset=kwargs["train_dataset"],
+                    validation_dataset=kwargs["validation_dataset"],
+                    insight_suite=dataset,
+                )
+            )
+        ),
+    )
+    agent_dir = tmp_path / "agent"
+    agent_dir.mkdir(exist_ok=True)
+    await ExperimentRunner(
+        backend=backend,
+        strategy=RecordingStrategy(winner=winner),
+        config=EvolutionaryOptimizerConfig(),
+        workspace="default",
+        root=tmp_path / "experiment",
+        agent=agent_dir,
+        insight="insight-1",
+        train_dataset=DatasetRef(uri="train"),
+        validation_dataset=DatasetRef(uri="validation"),
+        task_template=DatasetRef(uri="template"),
+    ).run()
+
+
+def _async(fn):
+    async def wrapper(*args, **kwargs):
+        return fn(*args, **kwargs)
+
+    return wrapper
+
+
+def test_a_run_needs_either_an_agent_or_an_insight(tmp_path) -> None:
+    with pytest.raises(ValueError, match="One of 'insight' or 'agent'"):
+        ExperimentRunner(
+            backend=FakeBackend(),
+            strategy=RecordingStrategy(),
+            config=EvolutionaryOptimizerConfig(),
+            workspace="default",
+            root=tmp_path,
+            agent=None,
+            train_dataset=DatasetRef(uri="train"),
+            validation_dataset=DatasetRef(uri="validation"),
+        )
+
+
+def test_an_insight_run_needs_a_task_template(tmp_path) -> None:
+    with pytest.raises(ValueError, match="'task_template' is required"):
+        ExperimentRunner(
+            backend=FakeBackend(),
+            strategy=RecordingStrategy(),
+            config=EvolutionaryOptimizerConfig(),
+            workspace="default",
+            root=tmp_path,
+            agent=None,
+            insight="insight-1",
+            train_dataset=DatasetRef(uri="train"),
+            validation_dataset=DatasetRef(uri="validation"),
+        )
+
+
+def test_the_run_entity_carries_a_progress_counter_not_a_round_count() -> None:
+    """Not every strategy has rounds, so the entity counts units and names the unit."""
+    run = ExperimentRun(workspace="default", agent="a")
+    assert (run.progress_completed, run.progress_total, run.progress_unit) == (0, None, "step")
+
+
+@pytest.mark.asyncio
+async def test_the_run_record_never_carries_the_credential(monkeypatch, tmp_path) -> None:
+    """It is written to run.json on disk and mirrored to the platform."""
+    monkeypatch.setenv("NEMO_EXPERIMENTALIST_API_BASE", "https://example.test/v1")
+    monkeypatch.setenv("NEMO_EXPERIMENTALIST_API_KEY", "super-secret-key")
+    for tier in ("SMART", "MID", "FAST"):
+        monkeypatch.setenv(f"NEMO_EXPERIMENTALIST_MODELS_{tier}", "vendor/m")
+    Configuration.clear_cache()
+
+    strategy = RecordingStrategy()
+    runner, _ = _make_runner(tmp_path, strategy=strategy, monkeypatch=monkeypatch)
+    await runner.run()
+
+    assert strategy.ctx is not None
+    assert "super-secret-key" not in json.dumps(strategy.ctx._run.config_snapshot)
+
+
+@pytest.mark.asyncio
+async def test_the_strategy_receives_the_runs_metric_contract(monkeypatch, tmp_path) -> None:
+    """A strategy reads the run's objectives off the context it was handed.
+
+    Reading them from a module-level getter instead would make a run report metrics other
+    than the ones it optimized, and `config_snapshot` would record the config's while the
+    loop used something else.
+    """
+    objectives = [MetricTarget(name="pass_rate", direction="maximize")]
+    guardrails = [MetricTarget(name="latency", direction="minimize")]
+    strategy = RecordingStrategy()
+    runner, _ = _make_runner(
+        tmp_path,
+        strategy=strategy,
+        monkeypatch=monkeypatch,
+        config=EvolutionaryOptimizerConfig(objective_function=objectives, regression_metrics=guardrails),
+    )
+
+    await runner.run()
+
+    assert strategy.ctx is not None
+    assert strategy.ctx.objective_metrics == objectives, "the strategy was handed different objectives"
+    assert strategy.ctx.regression_metrics == guardrails
+
+
+@pytest.mark.asyncio
+async def test_the_winner_copy_out_never_overwrites_the_runs_own_layout(monkeypatch, tmp_path) -> None:
+    """A winner artifact containing `eval-and-optimize` must not delete the run.
+
+    `fork` strips the run layout on the way in, but `commit_candidate` accepts any
+    artifact under the candidate root, so a strategy that builds without forking -- the
+    documented extension point -- can commit one that carries it. The copy-out `rmtree`s
+    each destination first, so without this the run deletes its own records while
+    finalizing, and there is nothing left to resume.
+    """
+    artifact = tmp_path / "artifact" / "agent-1"
+    (artifact / "eval-and-optimize").mkdir(parents=True)
+    # the winner carries a directory named like the run's own
+    (artifact / "eval-and-optimize" / "planted.txt").write_text("from the candidate", encoding="utf-8")
+    (artifact / "agent.py").write_text("real source", encoding="utf-8")
+    winner = make_candidate(
+        run_id="run-1",
+        label="agent-1",
+        ancestor="agent-0",
+        generation=1,
+        description="x",
+        artifact=artifact.as_uri(),
+    )
+
+    runner, _ = _make_runner(tmp_path, strategy=RecordingStrategy(winner=winner), monkeypatch=monkeypatch)
+
+    await runner.run()
+
+    # The run's own directory is left alone; had it been copied, rmtree would have taken
+    # the live one with it and this file would be sitting inside the result.
+    assert not (tmp_path / "experiment" / "eval-and-optimize" / "planted.txt").exists(), (
+        "the winner's eval-and-optimize was copied over the run's own"
+    )
+    # ...and the rest of the winner still copies, so the guard is not simply skipping.
+    assert (tmp_path / "experiment" / "agent.py").read_text(encoding="utf-8") == "real source"
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_smoke_agent_assets.py b/plugins/nemo-experimentalist/tests/experimentalist/test_smoke_agent_assets.py
index f784a13fed..3462184d6c 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_smoke_agent_assets.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_smoke_agent_assets.py
@@ -338,3 +338,73 @@ def test_combined_group_matches_its_sources(tmp_path: Path) -> None:
             assert (actual[rel] / name).read_bytes() == (src / name).read_bytes(), (
                 f"combined {rel}/{name} differs from its source; run scripts/build_all_group.py"
             )
+
+
+def test_every_shipped_config_validates() -> None:
+    """A shipped config the schema rejects fails here, not minutes into a run.
+
+    This refactor renamed run-config keys. `main` still carries the old spelling, so
+    every merge re-introduces it, and the failure surfaces only after the sandbox, the
+    image build and a 271-package resolve have already happened.
+
+    The two files need *different* migrations, which is why this is a test rather than a
+    one-time fix: `short.yaml` had the convergence check off, so its terminator becomes
+    null; `full.yaml` had it on, so the key is dropped and the terminator keeps its
+    default. Translating both the same way silently disables the one thing the combined
+    scenario exists to exercise.
+    """
+    import yaml
+    from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+
+    configs = sorted((_EXAMPLE_DIR / "configs").glob("*.yaml"))
+    assert configs, "no shipped configs found; the glob is wrong"
+
+    for path in configs:
+        data = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+        EvolutionaryOptimizerConfig(**data)  # raises with the offending key named
+
+
+def test_the_combined_scenario_keeps_its_terminator() -> None:
+    """`full.yaml` is the only scenario that exercises early stopping.
+
+    Pinned separately from the validation check above because the mistake it guards
+    against -- turning the terminator off while migrating the key -- produces a config
+    that still validates.
+    """
+    import yaml
+    from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+
+    full = EvolutionaryOptimizerConfig(
+        **(yaml.safe_load((_EXAMPLE_DIR / "configs" / "full.yaml").read_text(encoding="utf-8")) or {})
+    )
+    short = EvolutionaryOptimizerConfig(
+        **(yaml.safe_load((_EXAMPLE_DIR / "configs" / "short.yaml").read_text(encoding="utf-8")) or {})
+    )
+
+    assert full.terminator is not None, "the combined scenario lost the terminator it exists to test"
+    assert short.terminator is None, "the per-group gates want a fixed round count, not early stopping"
+
+
+def test_every_source_file_opens_with_its_licence_header() -> None:
+    """The header must be the first thing in the file, not merely present somewhere.
+
+    `script/copyright_fixer.py` checks presence, so a header that drifts into the middle
+    of a file passes every local hook. One did: an import rewrite detached it from the
+    import block and isort reordered around it, leaving it stranded at line 3 between two
+    imports, green the whole way.
+    """
+    package = _REPO_ROOT / "plugins" / "nemo-experimentalist"
+    sources = [
+        path
+        for path in package.rglob("*.py")
+        if "/tmp/" not in str(path) and "__pycache__" not in str(path) and ".venv" not in str(path)
+    ]
+    assert sources, "found no python files; the glob is wrong"
+
+    misplaced = [
+        str(path.relative_to(package))
+        for path in sources
+        if "SPDX-FileCopyrightText" not in "".join(path.read_text(encoding="utf-8").splitlines(keepends=True)[:2])
+    ]
+
+    assert not misplaced, f"licence header is not in the first two lines of: {misplaced}"
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_survivor_resolution.py b/plugins/nemo-experimentalist/tests/experimentalist/test_survivor_resolution.py
new file mode 100644
index 0000000000..33bab8c28c
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_survivor_resolution.py
@@ -0,0 +1,174 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Survivors chosen by the selector must resolve back to the live population.
+
+The selector is handed `slim()` copies so per-trial detail never reaches a model
+prompt, and the loop then looks the real records back up: carrying a slim copy forward
+would erase every other channel's trials the next time one is persisted.
+
+What that lookup is keyed on decides whether the run survives a generated method.
+`survivors` can answer either by passing the objects or by re-specifying them as JSON,
+and a candidate's id is a computed property over a private attribute -- not a model
+field -- so the JSON route cannot carry it and validation mints a fresh one. `label` is
+an ordinary field, unique within a run, and survives both routes.
+
+Keyed on id, a JSON answer resolves to nothing. The loop cannot distinguish that from
+"the selector chose to keep nothing", so it kills the entire population; every proposal
+is then rejected for naming an ancestor outside an empty survivor set, and a run holding
+a candidate that had already scored 1.000 ends with no winner. Seen on a real run.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+from doubles import FakeBackend, make_candidate, make_context
+from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.entities import Candidate, Proposal
+from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryStrategy
+
+
+def _forget_identity(candidate: Candidate) -> Candidate:
+    """A candidate as it comes back from a JSON answer: same values, new id."""
+    return Candidate.model_validate(json.loads(candidate.model_dump_json(exclude={"id"})))
+
+
+class _SelectorReturningJson:
+    """A selector whose answer crossed the tool-call boundary."""
+
+    def __init__(self) -> None:
+        self.seen: list[str] = []
+
+    def rank(self, candidates: list[Candidate]) -> list[Candidate]:
+        return list(candidates)
+
+    async def survivors(self, candidates: list[Candidate], *, k: int) -> list[Candidate]:
+        self.seen = [c.label for c in candidates]
+        return [_forget_identity(c) for c in candidates[:k]]
+
+    def winner(self, candidates: list[Candidate]) -> Candidate | None:
+        return candidates[0] if candidates else None
+
+
+async def _two_candidates(*, ctx: Any, config: Any) -> None:
+    """Two candidates, because the loop only consults the selector when it has a choice.
+
+    With a single candidate it short-circuits to `list(candidates)` and the resolution
+    under test never runs -- which is how a first version of this test passed against
+    the very code it was written to catch.
+    """
+    builder = ctx.component("builder", "import")
+    for index in range(2):
+        proposal = Proposal(ancestor=None, description=f"candidate {index}", kind="import", payload={})
+        await builder.build(ctx, proposal, generation=0)
+
+
+@pytest.mark.asyncio
+async def test_a_survivor_that_lost_its_id_still_resolves(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """The regression: keyed on id, this killed the population and lost the run."""
+    config = EvolutionaryOptimizerConfig(
+        max_rounds=1, max_survivors=1, terminator=None, analyzer=None, trajectory_scorer=None
+    )
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+    selector = _SelectorReturningJson()
+
+    async def _no_evaluations(*_a: Any, **_k: Any) -> dict[str, Any]:
+        return {}
+
+    async def _no_analysis(*_a: Any, **_k: Any) -> str:
+        return ""
+
+    async def _nothing(*_a: Any, **_k: Any) -> None:
+        return None
+
+    async def _no_proposals(*_a: Any, **_k: Any) -> list[Proposal]:
+        return []
+
+    monkeypatch.setattr(loop, "_ensure_baseline", _two_candidates)
+    monkeypatch.setattr(loop, "_selector", lambda *_a, **_k: selector)
+    monkeypatch.setattr(loop, "_evaluate_validation_candidates", _no_evaluations)
+    monkeypatch.setattr(loop, "_evaluate_train_candidates", _no_evaluations)
+    monkeypatch.setattr(loop, "_record_baseline_validation", _nothing)
+    monkeypatch.setattr(loop, "_analyze_round", _no_analysis)
+    monkeypatch.setattr(loop, "_propose_improvements", _no_proposals)
+
+    await loop._run(ctx)
+
+    survived = [c for c in await ctx.candidates() if c.killed_generation is None]
+    assert survived, (
+        "every candidate was killed: the selector's answer did not resolve back to the "
+        "population, and 'resolved to nothing' was treated as 'keep nothing'"
+    )
+
+
+def test_the_label_is_what_survives_a_json_answer() -> None:
+    """The property the resolution key relies on, pinned directly.
+
+    If a future change makes `id` serialize, this stops being load-bearing -- but until
+    then, a lookup keyed on id is keyed on the one thing the boundary drops.
+    """
+    from doubles import make_candidate
+
+    original = make_candidate(label="agent-1", generation=1)
+    returned = _forget_identity(original)
+
+    assert returned.label == original.label, "label is a model field and must survive"
+    assert returned.id != original.id, "id is not a model field and cannot survive"
+
+
+@pytest.mark.asyncio
+async def test_an_unresolvable_selection_keeps_the_population(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """If nothing the selector names exists here, keep everyone rather than kill everyone.
+
+    Killing is durable. An empty survivor set writes `killed_generation` on the whole
+    population, so the run spends its remaining rounds with nothing alive and cannot
+    recover -- not even on resume, because the tombstones are on disk. A selection that
+    resolves to nothing says nothing about which candidates are worth keeping, so the
+    round keeps them and the next one asks again.
+    """
+
+    class _SelectorNamingStrangers:
+        def rank(self, candidates: list[Candidate]) -> list[Candidate]:
+            return list(candidates)
+
+        async def survivors(self, candidates: list[Candidate], *, k: int) -> list[Candidate]:
+            return [make_candidate(label="agent-does-not-exist", generation=99)]
+
+        def winner(self, candidates: list[Candidate]) -> Candidate | None:
+            return candidates[0] if candidates else None
+
+    config = EvolutionaryOptimizerConfig(
+        max_rounds=1, max_survivors=1, terminator=None, analyzer=None, trajectory_scorer=None
+    )
+    loop = EvolutionaryStrategy(working_dir=tmp_path, config=config)
+    ctx = make_context(root=tmp_path, backend=FakeBackend())
+
+    async def _none(*_a: Any, **_k: Any) -> Any:
+        return {}
+
+    async def _nothing(*_a: Any, **_k: Any) -> None:
+        return None
+
+    async def _no_analysis(*_a: Any, **_k: Any) -> str:
+        return ""
+
+    async def _no_proposals(*_a: Any, **_k: Any) -> list[Proposal]:
+        return []
+
+    monkeypatch.setattr(loop, "_ensure_baseline", _two_candidates)
+    monkeypatch.setattr(loop, "_selector", lambda *_a, **_k: _SelectorNamingStrangers())
+    monkeypatch.setattr(loop, "_evaluate_validation_candidates", _none)
+    monkeypatch.setattr(loop, "_evaluate_train_candidates", _none)
+    monkeypatch.setattr(loop, "_record_baseline_validation", _nothing)
+    monkeypatch.setattr(loop, "_analyze_round", _no_analysis)
+    monkeypatch.setattr(loop, "_propose_improvements", _no_proposals)
+
+    await loop._run(ctx)
+
+    alive = [c for c in await ctx.candidates() if c.killed_generation is None]
+    assert len(alive) == 2, "an unresolvable selection killed the population it could not name"
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_terminator.py b/plugins/nemo-experimentalist/tests/experimentalist/test_terminator.py
index f6f24e3837..da736534b5 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_terminator.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_terminator.py
@@ -3,38 +3,33 @@
 
 """Unit tests for the Terminator step.
 
-These guard the behavior-preserving extraction of the termination logic
-(``_has_converged`` + ``qualitative_stop_check`` + ``max_rounds``) out of the
-loop and into :mod:`terminator`. Every Terminator is constructed with an injected
-``FakeLLMClient`` so the tests need no configured provider credentials and make no
-network calls.
+Early stopping only: the round budget belongs to the loop, so a terminator cannot be
+the only thing standing between a config and an unbounded run. Every Terminator is
+constructed with an injected ``FakeLLMClient`` so the tests need no
+``NEMO_EXPERIMENTALIST_API_*`` env vars and make no network calls.
 """
 
 import json
-from dataclasses import dataclass, field
-from types import SimpleNamespace
 
-from nemo_experimentalist_plugin.config import MetricTarget
-from nemo_experimentalist_plugin.experimentalist.components.loop import EvolutionaryOptimizerConfig
+from doubles import make_candidate, seed_reward
+from nemo_experimentalist_plugin.entities import Candidate, MetricTarget, RewardRecord
 from nemo_experimentalist_plugin.experimentalist.components.terminator import (
+    ConvergenceTerminator,
     TerminationDecision,
-    Terminator,
 )
 from nooa.unifiedllm import FakeLLMClient, LLMResponse, ToolCall
 
 
-@dataclass
-class _FakeNode:
-    """Stand-in for EvolutionNode exposing only what _has_converged reads."""
+def _candidate(label: str, generation: int, val_reward: dict[str, float] | None = None) -> Candidate:
+    """A committed candidate carrying only what convergence reads."""
+    c = make_candidate(label=label, candidate_id=label, generation=generation)
+    if val_reward:
+        seed_reward(c, "validation", RewardRecord(metrics=val_reward))
+    return c
 
-    label: str
-    round: int
-    val_reward: dict[str, float] = field(default_factory=dict)
 
-
-def _tree(*nodes: _FakeNode) -> SimpleNamespace:
-    """Build a stand-in EvolutionTree: an object with a ``.nodes`` dict."""
-    return SimpleNamespace(nodes={n.label: n for n in nodes})
+def _candidates(*cands: Candidate) -> list[Candidate]:
+    return list(cands)
 
 
 def _exec_response(code: str) -> LLMResponse:
@@ -48,7 +43,9 @@ def _exec_response(code: str) -> LLMResponse:
     )
 
 
-def _terminator(*, stop_verdict: bool | None = None) -> Terminator:
+def _terminator(
+    *, stop_verdict: bool | None = None, objectives: list[MetricTarget] | None = None
+) -> ConvergenceTerminator:
     """Build a Terminator with an injected fake LLM.
 
     When ``stop_verdict`` is None the fake makes no scripted response (used by tests
@@ -56,64 +53,23 @@ def _terminator(*, stop_verdict: bool | None = None) -> Terminator:
     strategy resolves to that boolean via a scripted ``return_result``.
     """
     if stop_verdict is None:
-        return Terminator(llm=FakeLLMClient())
+        return ConvergenceTerminator(llm=FakeLLMClient(), objective_metrics=objectives)
     fake = FakeLLMClient(scripted_responses=[_exec_response(f"return_result(result={stop_verdict})")])
-    return Terminator(llm=fake)
-
-
-# ---------------------------------------------------------------------------
-# assess_round_budget
-# ---------------------------------------------------------------------------
-
-
-def test_assess_round_budget_stops_at_max_rounds() -> None:
-    term = _terminator()
-    config = EvolutionaryOptimizerConfig(max_rounds=3)
-
-    assert term.assess_round_budget(round_num=2, config=config) == TerminationDecision(stop=False)
-
-    at_limit = term.assess_round_budget(round_num=3, config=config)
-    assert at_limit.stop is True
-    assert "max_rounds" in at_limit.reason
-
-    assert term.assess_round_budget(round_num=4, config=config).stop is True
-
-
-# ---------------------------------------------------------------------------
-# run() — unified entry point (budget first, then convergence)
-# ---------------------------------------------------------------------------
-
-
-async def test_run_stops_on_budget() -> None:
-    term = _terminator()
-    config = EvolutionaryOptimizerConfig(max_rounds=2)
-    decision = await term.run(
-        round_num=2,
-        evolution_tree=_tree(),
-        prior_analysis=None,
-        config=config,
-    )
-    assert decision.stop is True
-    assert "max_rounds" in decision.reason
+    return ConvergenceTerminator(llm=fake, objective_metrics=objectives)
 
 
 async def test_run_stops_on_convergence_when_budget_not_hit() -> None:
-    term = _terminator()
+    term = _terminator(objectives=[MetricTarget(name="score", direction="maximize")])
     # Budget not exhausted (round 2 < max_rounds 15), but the front has stagnated.
-    tree = _tree(
-        _FakeNode("a0", 0, {"score": 0.9}),
-        _FakeNode("a1", 1, {"score": 0.5}),
-        _FakeNode("a2", 2, {"score": 0.6}),
+    tree = _candidates(
+        _candidate("a0", 0, {"score": 0.9}),
+        _candidate("a1", 1, {"score": 0.5}),
+        _candidate("a2", 2, {"score": 0.6}),
     )
     decision = await term.run(
         round_num=2,
-        evolution_tree=tree,
+        candidates=tree,
         prior_analysis="prior analysis",
-        config=EvolutionaryOptimizerConfig(
-            max_rounds=15,
-            min_rounds_before_stopping=2,
-            objective_function=[MetricTarget(name="score", direction="maximize")],
-        ),
     )
     assert decision.stop is True
     assert "converged" in decision.reason
@@ -123,9 +79,8 @@ async def test_run_continues_when_neither_triggers() -> None:
     term = _terminator()
     decision = await term.run(
         round_num=0,
-        evolution_tree=_tree(),
+        candidates=_candidates(),
         prior_analysis=None,  # round 0: no convergence check
-        config=EvolutionaryOptimizerConfig(max_rounds=15),
     )
     assert decision == TerminationDecision(stop=False)
 
@@ -137,49 +92,27 @@ async def test_run_continues_when_neither_triggers() -> None:
 
 async def test_assess_convergence_no_prior_analysis_does_not_stop() -> None:
     term = _terminator()
-    config = EvolutionaryOptimizerConfig()
     decision = await term.assess_convergence(
-        evolution_tree=_tree(),
+        candidates=_candidates(),
         prior_analysis=None,
-        config=config,
     )
     assert decision == TerminationDecision(stop=False)
 
 
-async def test_assess_convergence_disabled_does_not_stop() -> None:
-    term = _terminator()
-    config = EvolutionaryOptimizerConfig(disable_convergence_check=True)
-    # A tree that WOULD converge — proves the disable flag short-circuits first.
-    tree = _tree(
-        _FakeNode("a0", 0, {"score": 0.9}),
-        _FakeNode("a1", 1, {"score": 0.5}),
-        _FakeNode("a2", 2, {"score": 0.6}),
-    )
-    decision = await term.assess_convergence(
-        evolution_tree=tree,
-        prior_analysis="some analysis",
-        config=config,
-    )
-    assert decision == TerminationDecision(stop=False)
-
-
-# ---------------------------------------------------------------------------
-# _has_converged deterministic paths
-# ---------------------------------------------------------------------------
-
-
 async def test_has_converged_false_when_too_few_rounds() -> None:
     term = _terminator()
-    tree = _tree(
-        _FakeNode("a0", 0, {"score": 0.5}),
-        _FakeNode("a1", 1, {"score": 0.6}),
+    tree = _candidates(
+        _candidate("a0", 0, {"score": 0.5}),
+        _candidate("a1", 1, {"score": 0.6}),
     )
     # Only 2 distinct scored rounds < min_rounds_before_stopping=3 -> False, no LLM.
     assert (
         await term._has_converged(
-            evolution_tree=tree,
+            candidates=tree,
             prior_analysis="ignored",
             min_rounds_before_stopping=3,
+            objective_metrics=[MetricTarget(name="score", direction="maximize")],
+            regression_metrics=[],
         )
         is False
     )
@@ -190,16 +123,18 @@ async def test_has_converged_ignores_unscored_nodes() -> None:
     # Two scored rounds + an unscored ({}) node. The unscored node must NOT count toward the
     # round set (val_reward is {} for unscored, so a truthy filter excludes it); with only two
     # scored rounds < min_rounds_before_stopping=3 the check returns False.
-    tree = _tree(
-        _FakeNode("a0", 0, {"score": 0.5}),
-        _FakeNode("a1", 1, {"score": 0.6}),
-        _FakeNode("a2", 2, {}),  # unscored — must be ignored
+    tree = _candidates(
+        _candidate("a0", 0, {"score": 0.5}),
+        _candidate("a1", 1, {"score": 0.6}),
+        _candidate("a2", 2, {}),  # unscored — must be ignored
     )
     assert (
         await term._has_converged(
-            evolution_tree=tree,
+            candidates=tree,
             prior_analysis="ignored",
             min_rounds_before_stopping=3,
+            objective_metrics=[MetricTarget(name="score", direction="maximize")],
+            regression_metrics=[],
         )
         is False
     )
@@ -209,17 +144,18 @@ async def test_has_converged_true_when_front_stagnates() -> None:
     term = _terminator()
     # Best candidate is the round-0 baseline; later rounds never beat it, so the
     # full Pareto front (a0) is a subset of the old front (a0) -> converged.
-    tree = _tree(
-        _FakeNode("a0", 0, {"score": 0.9}),
-        _FakeNode("a1", 1, {"score": 0.5}),
-        _FakeNode("a2", 2, {"score": 0.6}),
+    tree = _candidates(
+        _candidate("a0", 0, {"score": 0.9}),
+        _candidate("a1", 1, {"score": 0.5}),
+        _candidate("a2", 2, {"score": 0.6}),
     )
     assert (
         await term._has_converged(
-            evolution_tree=tree,
+            candidates=tree,
             prior_analysis="ignored",
             min_rounds_before_stopping=2,
             objective_metrics=[MetricTarget(name="score", direction="maximize")],
+            regression_metrics=[],
         )
         is True
     )
@@ -234,17 +170,18 @@ async def test_qualitative_fallback_true() -> None:
     term = _terminator(stop_verdict=True)
     # Newest round (a2=0.7) is the unique front, NOT in the old front -> not a
     # deterministic stop, so the qualitative check is consulted.
-    tree = _tree(
-        _FakeNode("a0", 0, {"score": 0.5}),
-        _FakeNode("a1", 1, {"score": 0.6}),
-        _FakeNode("a2", 2, {"score": 0.7}),
+    tree = _candidates(
+        _candidate("a0", 0, {"score": 0.5}),
+        _candidate("a1", 1, {"score": 0.6}),
+        _candidate("a2", 2, {"score": 0.7}),
     )
     assert (
         await term._has_converged(
-            evolution_tree=tree,
+            candidates=tree,
             prior_analysis="plateaued: same root cause every round",
             min_rounds_before_stopping=2,
             objective_metrics=[MetricTarget(name="score", direction="maximize")],
+            regression_metrics=[],
         )
         is True
     )
@@ -252,15 +189,14 @@ async def test_qualitative_fallback_true() -> None:
 
 async def test_qualitative_fallback_false_propagates_through_assess_convergence() -> None:
     term = _terminator(stop_verdict=False)
-    tree = _tree(
-        _FakeNode("a0", 0, {"score": 0.5}),
-        _FakeNode("a1", 1, {"score": 0.6}),
-        _FakeNode("a2", 2, {"score": 0.7}),
+    tree = _candidates(
+        _candidate("a0", 0, {"score": 0.5}),
+        _candidate("a1", 1, {"score": 0.6}),
+        _candidate("a2", 2, {"score": 0.7}),
     )
     decision = await term.assess_convergence(
-        evolution_tree=tree,
+        candidates=tree,
         prior_analysis="still improving",
-        config=EvolutionaryOptimizerConfig(min_rounds_before_stopping=2),
     )
     assert decision == TerminationDecision(stop=False)
 
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_tools.py b/plugins/nemo-experimentalist/tests/experimentalist/test_tools.py
index 99984b95b4..946c59e5f1 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_tools.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_tools.py
@@ -4,7 +4,7 @@
 from pathlib import Path
 from typing import cast
 
-from nemo_experimentalist_plugin.experimentalist.components.coder import Coder, CoderConfig
+from nemo_experimentalist_plugin.experimentalist.components.coder import CodeEditBuilder, CodeEditBuilderConfig
 from nemo_experimentalist_plugin.experimentalist.components.holdout_utils import BLOCKED_MESSAGE
 from nemo_experimentalist_plugin.experimentalist.components.tools import GuardedShellTools
 from nemo_platform_plugin.nooa_model_client import ConfiguredModelClients, ConfiguredModelRefs, activate_model_clients
@@ -41,7 +41,7 @@ async def test_guarded_shell_tools_returns_failure_for_blocked_paths(tmp_path):
 
 def test_coder_hides_skill_registry_that_can_replace_guarded_shell(tmp_path):
     nooa_skill = Path(__file__).resolve().parents[2] / "framework-skills" / "nooa"
-    coder = Coder(workspace=tmp_path, framework_skills_dirs=[nooa_skill])
+    coder = CodeEditBuilder(workspace=tmp_path, framework_skills_dirs=[nooa_skill])
 
     rendered = pformat(coder)
 
@@ -60,7 +60,7 @@ def test_coder_uses_default_model_for_architecture_docs(tmp_path: Path) -> None:
     )
 
     with activate_model_clients(clients):
-        coder = Coder(workspace=tmp_path)
+        coder = CodeEditBuilder(workspace=tmp_path)
 
     assert coder._architecture_model is default
 
@@ -84,6 +84,6 @@ async def test_coder_lists_agent_mutation_models_from_catalog(tmp_path: Path) ->
 """,
         encoding="utf-8",
     )
-    coder = Coder(workspace=tmp_path, config=CoderConfig(model_catalog_path=catalog))
+    coder = CodeEditBuilder(workspace=tmp_path, config=CodeEditBuilderConfig(model_catalog_path=catalog))
 
     assert await coder.list_available_models() == ["provider/quality", "provider/fast"]
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_trace_scorer_contract.py b/plugins/nemo-experimentalist/tests/experimentalist/test_trace_scorer_contract.py
index ca90cf7593..e8d056a540 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_trace_scorer_contract.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_trace_scorer_contract.py
@@ -3,7 +3,7 @@
 
 """Pin the parts of the scorer's contract that a turn-less trace depends on.
 
-`GroupLeafScorer.run` is a CodeAct prompt, so its docstring is the instruction the
+`GoalTreeTrajectoryScorer.score_group` is a CodeAct prompt, so its docstring is the instruction the
 model follows. The only sanctioned evidence lookups are indexed by turn, so a trace
 with zero turns needs the contract to name that case, permit an empty `span_ids`,
 and point at evidence the scorer can actually reach. These tests keep that escape
@@ -15,15 +15,15 @@
 import inspect
 
 from nemo_experimentalist_plugin.experimentalist.components.trace_scorer import (
+    GoalTreeTrajectoryScorer,
     GroupLeafScore,
-    GroupLeafScorer,
 )
 
 
 def _run_contract() -> str:
     """The prompt with whitespace collapsed, so assertions do not hinge on where it wraps."""
-    doc = inspect.getdoc(GroupLeafScorer.run)
-    assert doc is not None, "GroupLeafScorer.run must keep its docstring; it is the prompt"
+    doc = inspect.getdoc(GoalTreeTrajectoryScorer.score_group)
+    assert doc is not None, "GoalTreeTrajectoryScorer.score_group must keep its docstring; it is the prompt"
     return " ".join(doc.lower().split())
 
 
diff --git a/plugins/nemo-experimentalist/tests/experimentalist/test_winner_selection.py b/plugins/nemo-experimentalist/tests/experimentalist/test_winner_selection.py
index d02657dbe4..5e2390e2a2 100644
--- a/plugins/nemo-experimentalist/tests/experimentalist/test_winner_selection.py
+++ b/plugins/nemo-experimentalist/tests/experimentalist/test_winner_selection.py
@@ -4,23 +4,26 @@
 """Pin how the run's winner is chosen at finalization.
 
 This had no coverage, and a regression shipped through the gap: finalization was
-routed through ``select_diverse_survivors``, whose prompt requires including a
-candidate created in the current round. At ``k=1`` that rule takes the only slot,
-so the round-0 baseline could never win and every run shipped a diff -- including
-runs where nothing measured better than doing nothing.
-
-The rule these tests encode: a candidate that regresses a protected metric is
-dropped, the winner is non-dominated on the objectives, and among candidates
-nothing dominates, the oldest wins. A real improvement dominates its ancestor and
-removes it from the front, so the age preference only ever decides ties.
+routed through survivor selection, whose prompt requires including a candidate
+created in the current round. At ``k=1`` that rule takes the only slot, so the
+generation-0 baseline could never win and every run shipped a diff -- including runs
+where nothing measured better than doing nothing.
+
+M1 makes that structurally impossible by giving the selector two separate methods:
+``survivors`` is the LLM judgement that must favour new blood, ``winner`` is
+arithmetic that must not. These tests pin ``winner``.
+
+The rule they encode: a candidate that regresses a protected metric is dropped, the
+winner is non-dominated on the objectives, and among candidates nothing dominates,
+the oldest wins. A real improvement dominates its ancestor and removes it from the
+front, so the age preference only ever decides ties.
 """
 
 from __future__ import annotations
 
-from nemo_experimentalist_plugin.config import MetricTarget
-from nemo_experimentalist_plugin.entities import Candidate, RewardRecord
-from nemo_experimentalist_plugin.experimentalist.components.loop import finalization_pool, select_winner_node
-from nemo_experimentalist_plugin.experimentalist.components.models import EvolutionNode, EvolutionTree
+import pytest
+from nemo_experimentalist_plugin.entities import Candidate, MetricTarget, Proposal, ResourceRef, RewardRecord
+from nemo_experimentalist_plugin.experimentalist.components.selector import ParetoDiversitySelector
 
 MAXIMIZE = [MetricTarget(name="reward", direction="maximize")]
 TWO_OBJECTIVES = [
@@ -31,64 +34,68 @@
 SHAPE_MUST_NOT_FALL = [MetricTarget(name="shape_ok", direction="maximize")]
 
 
-def _node(label: str, round_: int, **metrics: float) -> EvolutionNode:
-    return EvolutionNode(
-        candidate=Candidate(
-            run_id="run-1",
-            label=label,
-            round=round_,
-            optimization="baseline" if round_ == 0 else "some change",
-            rewards={"validation": RewardRecord(metrics=dict(metrics))},
-        )
+def _candidate(label: str, generation: int, **metrics: float) -> Candidate:
+    description = "baseline" if generation == 0 else "some change"
+    return Candidate(
+        run_id="run-1",
+        label=label,
+        generation=generation,
+        description=description,
+        generated_from=Proposal(ancestor=None, description=description, kind="import"),
+        artifact=ResourceRef(uri=f"file:///tmp/{label}"),
+        rewards={"validation": RewardRecord(metrics=dict(metrics))},
     )
 
 
+def _killed(candidate: Candidate, generation: int) -> Candidate:
+    candidate.killed_generation = generation
+    return candidate
+
+
+def _winner(
+    candidates: list[Candidate],
+    objectives: list[MetricTarget],
+    regressions: list[MetricTarget] | None = None,
+) -> Candidate | None:
+    """Ask a real selector, so the wiring from config to component is covered too."""
+    selector = ParetoDiversitySelector(objective_metrics=objectives, regression_metrics=regressions or [])
+    return selector.winner(candidates)
+
+
 def test_baseline_wins_a_tie() -> None:
     """The regression this file exists for: equal score means the diff bought nothing."""
-    winner = select_winner_node(
-        [_node("agent-0", 0, reward=0.5), _node("agent-1", 1, reward=0.5)],
-        MAXIMIZE,
-    )
+    winner = _winner([_candidate("agent-0", 0, reward=0.5), _candidate("agent-1", 1, reward=0.5)], MAXIMIZE)
     assert winner is not None
     assert winner.label == "agent-0"
 
 
 def test_baseline_wins_a_tie_regardless_of_input_order() -> None:
     """The old behaviour was correct only because agent-0 happened to be inserted first."""
-    winner = select_winner_node(
-        [_node("agent-1", 1, reward=0.5), _node("agent-0", 0, reward=0.5)],
-        MAXIMIZE,
-    )
+    winner = _winner([_candidate("agent-1", 1, reward=0.5), _candidate("agent-0", 0, reward=0.5)], MAXIMIZE)
     assert winner is not None
     assert winner.label == "agent-0"
 
 
 def test_a_real_improvement_wins() -> None:
     """Age must never block a candidate that actually scored better."""
-    winner = select_winner_node(
-        [_node("agent-0", 0, reward=0.5), _node("agent-1", 1, reward=0.7)],
-        MAXIMIZE,
-    )
+    winner = _winner([_candidate("agent-0", 0, reward=0.5), _candidate("agent-1", 1, reward=0.7)], MAXIMIZE)
     assert winner is not None
     assert winner.label == "agent-1"
 
 
 def test_a_regression_loses() -> None:
-    winner = select_winner_node(
-        [_node("agent-0", 0, reward=0.5), _node("agent-1", 1, reward=0.3)],
-        MAXIMIZE,
-    )
+    winner = _winner([_candidate("agent-0", 0, reward=0.5), _candidate("agent-1", 1, reward=0.3)], MAXIMIZE)
     assert winner is not None
     assert winner.label == "agent-0"
 
 
 def test_oldest_ancestor_wins_among_tied_descendants() -> None:
     """Not just the baseline: an ancestor carried forward unchanged also outranks a tie."""
-    winner = select_winner_node(
+    winner = _winner(
         [
-            _node("agent-3", 3, reward=0.8),
-            _node("agent-1", 1, reward=0.8),
-            _node("agent-2", 2, reward=0.8),
+            _candidate("agent-3", 3, reward=0.8),
+            _candidate("agent-1", 1, reward=0.8),
+            _candidate("agent-2", 2, reward=0.8),
         ],
         MAXIMIZE,
     )
@@ -98,75 +105,70 @@ def test_oldest_ancestor_wins_among_tied_descendants() -> None:
 
 def test_incomparable_multi_objective_candidate_does_not_displace_the_baseline() -> None:
     """Better on one objective and worse on another is not an improvement, it is a trade."""
-    objectives = [
-        MetricTarget(name="reward", direction="maximize"),
-        MetricTarget(name="shape_ok", direction="maximize"),
-    ]
-    winner = select_winner_node(
+    winner = _winner(
         [
-            _node("agent-0", 0, reward=0.5, shape_ok=0.9),
-            _node("agent-1", 1, reward=0.7, shape_ok=0.4),
+            _candidate("agent-0", 0, reward=0.5, shape_ok=0.9),
+            _candidate("agent-1", 1, reward=0.7, shape_ok=0.4),
         ],
-        objectives,
+        TWO_OBJECTIVES,
     )
     assert winner is not None
     assert winner.label == "agent-0"
 
 
 def test_dominating_on_every_objective_wins() -> None:
-    objectives = [
-        MetricTarget(name="reward", direction="maximize"),
-        MetricTarget(name="shape_ok", direction="maximize"),
-    ]
-    winner = select_winner_node(
+    winner = _winner(
         [
-            _node("agent-0", 0, reward=0.5, shape_ok=0.5),
-            _node("agent-1", 1, reward=0.7, shape_ok=0.9),
+            _candidate("agent-0", 0, reward=0.5, shape_ok=0.5),
+            _candidate("agent-1", 1, reward=0.7, shape_ok=0.9),
         ],
-        objectives,
+        TWO_OBJECTIVES,
     )
     assert winner is not None
     assert winner.label == "agent-1"
 
 
 def test_minimized_objective_direction_is_respected() -> None:
-    """Lower is better here, so the baseline's higher cost must lose."""
-    winner = select_winner_node(
-        [_node("agent-0", 0, cost=0.9), _node("agent-1", 1, cost=0.2)],
-        [MetricTarget(name="cost", direction="minimize")],
+    winner = _winner(
+        [_candidate("agent-0", 0, latency=2.0), _candidate("agent-1", 1, latency=1.0)],
+        [MetricTarget(name="latency", direction="minimize")],
     )
     assert winner is not None
     assert winner.label == "agent-1"
 
 
 def test_no_eligible_candidates_returns_none() -> None:
-    assert select_winner_node([], MAXIMIZE) is None
+    assert _winner([], MAXIMIZE) is None
+
+
+def test_a_candidate_without_the_objective_dimensions_is_not_eligible() -> None:
+    """It cannot be ranked, so it cannot win -- and must not crash the finalizer."""
+    assert _winner([_candidate("agent-0", 0, unrelated=1.0)], MAXIMIZE) is None
 
 
 def test_single_candidate_is_the_winner() -> None:
-    winner = select_winner_node([_node("agent-0", 0, reward=0.4)], MAXIMIZE)
+    winner = _winner([_candidate("agent-1", 1, reward=0.7)], MAXIMIZE)
     assert winner is not None
-    assert winner.label == "agent-0"
+    assert winner.label == "agent-1"
 
 
-def test_same_round_ties_are_stable_under_input_order() -> None:
-    """Two same-round candidates nothing dominates must not depend on caller ordering."""
-    forward = select_winner_node(
-        [_node("agent-1", 1, reward=0.7), _node("agent-2", 1, reward=0.7)],
+def test_same_generation_ties_are_stable_under_input_order() -> None:
+    forward = _winner(
+        [_candidate("agent-1", 1, reward=0.7), _candidate("agent-2", 1, reward=0.7)],
         MAXIMIZE,
     )
-    reversed_ = select_winner_node(
-        [_node("agent-2", 1, reward=0.7), _node("agent-1", 1, reward=0.7)],
+    backward = _winner(
+        [_candidate("agent-2", 1, reward=0.7), _candidate("agent-1", 1, reward=0.7)],
         MAXIMIZE,
     )
-    assert forward is not None and reversed_ is not None
-    assert forward.label == reversed_.label == "agent-1"
+    assert forward is not None and backward is not None
+    assert forward.label == backward.label == "agent-1"
 
 
 def test_creation_order_is_numeric_not_lexicographic() -> None:
-    """`agent-9` was created before `agent-10`; a string sort would invert that."""
-    winner = select_winner_node(
-        [_node("agent-10", 2, reward=0.6), _node("agent-9", 2, reward=0.6)],
+    """``agent-10`` sorts before ``agent-9`` as text, and after it as a sequence."""
+    winner = _winner(
+        [_candidate("agent-10", 1, reward=0.7), _candidate("agent-9", 1, reward=0.7)],
         MAXIMIZE,
     )
     assert winner is not None
@@ -175,10 +177,10 @@ def test_creation_order_is_numeric_not_lexicographic() -> None:
 
 def test_objective_gain_cannot_pay_for_a_regression() -> None:
     """A protected metric that worsens disqualifies the candidate however good the objective."""
-    winner = select_winner_node(
+    winner = _winner(
         [
-            _node("agent-0", 0, reward=0.5, latency=1.0),
-            _node("agent-1", 1, reward=0.9, latency=2.5),
+            _candidate("agent-0", 0, reward=0.5, latency=1.0),
+            _candidate("agent-1", 1, reward=0.9, latency=2.5),
         ],
         MAXIMIZE,
         LATENCY_MUST_NOT_RISE,
@@ -188,10 +190,10 @@ def test_objective_gain_cannot_pay_for_a_regression() -> None:
 
 
 def test_improvement_that_holds_the_protected_metric_still_wins() -> None:
-    winner = select_winner_node(
+    winner = _winner(
         [
-            _node("agent-0", 0, reward=0.5, latency=1.0),
-            _node("agent-1", 1, reward=0.9, latency=1.0),
+            _candidate("agent-0", 0, reward=0.5, latency=1.0),
+            _candidate("agent-1", 1, reward=0.9, latency=1.0),
         ],
         MAXIMIZE,
         LATENCY_MUST_NOT_RISE,
@@ -201,11 +203,11 @@ def test_improvement_that_holds_the_protected_metric_still_wins() -> None:
 
 
 def test_maximized_regression_metric_uses_the_opposite_direction() -> None:
-    """`shape_ok` must not *fall*; a candidate that improves reward but drops it is out."""
-    winner = select_winner_node(
+    """``shape_ok`` must not *fall*; a candidate that improves reward but drops it is out."""
+    winner = _winner(
         [
-            _node("agent-0", 0, reward=0.5, shape_ok=1.0),
-            _node("agent-1", 1, reward=0.9, shape_ok=0.6),
+            _candidate("agent-0", 0, reward=0.5, shape_ok=1.0),
+            _candidate("agent-1", 1, reward=0.9, shape_ok=0.6),
         ],
         MAXIMIZE,
         SHAPE_MUST_NOT_FALL,
@@ -216,11 +218,11 @@ def test_maximized_regression_metric_uses_the_opposite_direction() -> None:
 
 def test_multiple_objectives_and_a_regression_metric_together() -> None:
     """agent-1 dominates on both objectives but regresses latency; agent-2 is the honest win."""
-    winner = select_winner_node(
+    winner = _winner(
         [
-            _node("agent-0", 0, reward=0.5, shape_ok=0.5, latency=1.0),
-            _node("agent-1", 1, reward=0.9, shape_ok=0.9, latency=3.0),
-            _node("agent-2", 1, reward=0.7, shape_ok=0.7, latency=0.8),
+            _candidate("agent-0", 0, reward=0.5, shape_ok=0.5, latency=1.0),
+            _candidate("agent-1", 1, reward=0.9, shape_ok=0.9, latency=3.0),
+            _candidate("agent-2", 1, reward=0.7, shape_ok=0.7, latency=0.8),
         ],
         TWO_OBJECTIVES,
         LATENCY_MUST_NOT_RISE,
@@ -230,11 +232,11 @@ def test_multiple_objectives_and_a_regression_metric_together() -> None:
 
 
 def test_every_candidate_regressing_falls_back_to_the_baseline() -> None:
-    winner = select_winner_node(
+    winner = _winner(
         [
-            _node("agent-0", 0, reward=0.5, latency=1.0),
-            _node("agent-1", 1, reward=0.9, latency=2.0),
-            _node("agent-2", 1, reward=0.8, latency=1.5),
+            _candidate("agent-0", 0, reward=0.5, latency=1.0),
+            _candidate("agent-1", 1, reward=0.9, latency=2.0),
+            _candidate("agent-2", 1, reward=0.8, latency=1.5),
         ],
         MAXIMIZE,
         LATENCY_MUST_NOT_RISE,
@@ -245,10 +247,10 @@ def test_every_candidate_regressing_falls_back_to_the_baseline() -> None:
 
 def test_a_regression_metric_missing_from_a_candidate_is_not_a_regression() -> None:
     """Absent evidence must not disqualify: the evaluator simply did not report it."""
-    winner = select_winner_node(
+    winner = _winner(
         [
-            _node("agent-0", 0, reward=0.5, latency=1.0),
-            _node("agent-1", 1, reward=0.9),
+            _candidate("agent-0", 0, reward=0.5, latency=1.0),
+            _candidate("agent-1", 1, reward=0.9),
         ],
         MAXIMIZE,
         LATENCY_MUST_NOT_RISE,
@@ -257,92 +259,80 @@ def test_a_regression_metric_missing_from_a_candidate_is_not_a_regression() -> N
     assert winner.label == "agent-1"
 
 
-def _tree(*nodes: EvolutionNode) -> EvolutionTree:
-    tree = EvolutionTree()
-    for node in nodes:
-        tree.add(node.candidate)
-    return tree
-
-
-def _killed(node: EvolutionNode, round_: int) -> EvolutionNode:
-    node.candidate.killed_round = round_
-    return node
-
-
 def test_a_baseline_killed_mid_loop_can_still_win() -> None:
     """Survivor selection may kill agent-0; deciding to ship nothing must survive that.
 
-    `_finalize` filters on `is_survivor`, so without re-admitting the baseline a run
-    whose baseline was killed could only choose among diffs -- reintroducing the very
+    ``winner`` filters on ``killed_generation``, so without re-admitting the baseline a
+    run whose baseline was killed could only choose among diffs -- reintroducing the very
     bug this module exists to prevent, one level down.
     """
-    eligible, baseline = finalization_pool(
-        _tree(
-            _killed(_node("agent-0", 0, reward=0.5), 1),
-            _node("agent-1", 1, reward=0.5),
-        ),
+    winner = _winner(
+        [
+            _killed(_candidate("agent-0", 0, reward=0.5), 1),
+            _candidate("agent-1", 1, reward=0.5),
+        ],
         MAXIMIZE,
     )
-    assert baseline is not None and baseline.label == "agent-0"
-    assert "agent-0" in {node.label for node in eligible}
-
-    winner = select_winner_node(eligible, MAXIMIZE, [], baseline)
     assert winner is not None
     assert winner.label == "agent-0"
 
 
 def test_regression_is_measured_against_the_real_baseline_not_the_oldest_survivor() -> None:
-    """A killed baseline must still anchor the regression comparison."""
-    eligible, baseline = finalization_pool(
-        _tree(
-            _killed(_node("agent-0", 0, reward=0.5, latency=1.0), 1),
-            _node("agent-1", 1, reward=0.7, latency=2.0),
-            _node("agent-2", 2, reward=0.9, latency=2.5),
-        ),
+    """A killed baseline must still anchor the regression comparison.
+
+    Against agent-1 (the oldest *survivor*) agent-2's latency of 2.5 is only a little
+    worse; against the real baseline at 1.0 both candidates plainly regress.
+    """
+    winner = _winner(
+        [
+            _killed(_candidate("agent-0", 0, reward=0.5, latency=1.0), 1),
+            _candidate("agent-1", 1, reward=0.7, latency=2.0),
+            _candidate("agent-2", 2, reward=0.9, latency=2.5),
+        ],
         MAXIMIZE,
+        LATENCY_MUST_NOT_RISE,
     )
-    assert baseline is not None and baseline.label == "agent-0"
-
-    # Against agent-1 (the oldest *survivor*) agent-2 looks fine on latency at 2.5 > 2.0
-    # only by a little; against the real baseline at 1.0 both candidates regress.
-    winner = select_winner_node(eligible, MAXIMIZE, LATENCY_MUST_NOT_RISE, baseline)
     assert winner is not None
     assert winner.label == "agent-0"
 
 
-def test_surviving_candidates_are_all_eligible() -> None:
-    eligible, baseline = finalization_pool(
-        _tree(
-            _node("agent-0", 0, reward=0.5),
-            _node("agent-1", 1, reward=0.7),
-            _killed(_node("agent-2", 1, reward=0.9), 1),
-        ),
+def test_a_killed_non_baseline_candidate_cannot_win() -> None:
+    """Only the baseline is re-admitted; an eliminated diff stays eliminated."""
+    winner = _winner(
+        [
+            _candidate("agent-0", 0, reward=0.5),
+            _candidate("agent-1", 1, reward=0.7),
+            _killed(_candidate("agent-2", 1, reward=0.9), 1),
+        ],
         MAXIMIZE,
     )
-    assert baseline is not None and baseline.label == "agent-0"
-    assert {node.label for node in eligible} == {"agent-0", "agent-1"}
+    assert winner is not None
+    assert winner.label == "agent-1"
 
 
 def test_a_baseline_missing_the_objective_dimensions_is_not_used_as_reference() -> None:
     """It cannot be ranked, so it cannot anchor; the selector falls back rather than crash."""
-    eligible, baseline = finalization_pool(
-        _tree(
-            _node("agent-0", 0, unrelated=1.0),
-            _node("agent-1", 1, reward=0.7),
-        ),
+    winner = _winner(
+        [
+            _candidate("agent-0", 0, unrelated=1.0),
+            _candidate("agent-1", 1, reward=0.7),
+        ],
         MAXIMIZE,
     )
-    assert baseline is None
-    assert {node.label for node in eligible} == {"agent-1"}
-
-    winner = select_winner_node(eligible, MAXIMIZE, [], baseline)
     assert winner is not None
     assert winner.label == "agent-1"
 
 
 def test_a_run_with_no_baseline_result_still_finalizes() -> None:
-    eligible, baseline = finalization_pool(_tree(_node("agent-1", 1, reward=0.7)), MAXIMIZE)
-    assert baseline is None
-    winner = select_winner_node(eligible, MAXIMIZE, [], baseline)
+    winner = _winner([_candidate("agent-1", 1, reward=0.7)], MAXIMIZE)
+    assert winner is not None
+    assert winner.label == "agent-1"
+
+
+@pytest.mark.parametrize("regressions", [None, LATENCY_MUST_NOT_RISE])
+def test_the_default_objective_is_reward(regressions: list[MetricTarget] | None) -> None:
+    """A selector built with no targets still ranks, so an unconfigured run finalizes."""
+    selector = ParetoDiversitySelector(regression_metrics=regressions or [])
+    winner = selector.winner([_candidate("agent-0", 0, reward=0.5), _candidate("agent-1", 1, reward=0.9)])
     assert winner is not None
     assert winner.label == "agent-1"
diff --git a/plugins/nemo-experimentalist/tests/test_deps.py b/plugins/nemo-experimentalist/tests/test_deps.py
deleted file mode 100644
index 16017eed70..0000000000
--- a/plugins/nemo-experimentalist/tests/test_deps.py
+++ /dev/null
@@ -1,67 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-"""ExperimentalistDeps validation: insight and/or agent may be set (or combined)."""
-
-from pathlib import Path
-
-import pytest
-from nemo_experimentalist_plugin.entities import DatasetRef
-from nemo_experimentalist_plugin.experimentalist.deps import ExperimentalistDeps
-from pydantic import ValidationError
-
-
-def _datasets(tmp_path: Path) -> dict:
-    # DatasetRef is a lazy URI handle resolved at evaluation time, so the paths
-    # need not exist here.
-    return {
-        "train_dataset": DatasetRef(uri=str(tmp_path / "train")),
-        "validation_dataset": DatasetRef(uri=str(tmp_path / "val")),
-    }
-
-
-def _task_template(tmp_path: Path) -> DatasetRef:
-    return DatasetRef(uri=str(tmp_path / "template"))
-
-
-def test_agent_only_ok(tmp_path: Path) -> None:
-    ExperimentalistDeps(agent="ssh://git@h/g/r.git@main", **_datasets(tmp_path))
-
-
-def test_insight_only_ok(tmp_path: Path) -> None:
-    ExperimentalistDeps(insight="ins-1", task_template=_task_template(tmp_path), **_datasets(tmp_path))
-
-
-def test_insight_and_agent_combined_ok(tmp_path: Path) -> None:
-    # The Mode-1 PR workflow: an insight guides optimization while a git agent
-    # supplies the code + PR target. Both set together is now valid.
-    deps = ExperimentalistDeps(
-        insight="ins-1",
-        agent="ssh://git@h/g/r.git@main",
-        task_template=_task_template(tmp_path),
-        **_datasets(tmp_path),
-    )
-    assert deps.insight == "ins-1"
-    assert deps.agent == "ssh://git@h/g/r.git@main"
-
-
-def test_insight_without_task_template_raises(tmp_path: Path) -> None:
-    # Mode 1 needs a task template to fill from production traces.
-    with pytest.raises(ValueError, match="task_template"):
-        ExperimentalistDeps(insight="ins-1", **_datasets(tmp_path))
-
-
-def test_neither_raises(tmp_path: Path) -> None:
-    with pytest.raises(ValueError, match="must be set"):
-        ExperimentalistDeps(**_datasets(tmp_path))
-
-
-def test_deprecated_evaluator_alias_is_rejected(tmp_path: Path) -> None:
-    with pytest.raises(ValidationError):
-        ExperimentalistDeps.model_validate(
-            {
-                "agent": "ssh://git@h/g/r.git@main",
-                "evaluator_type": "harbor",
-                **_datasets(tmp_path),
-            }
-        )
diff --git a/plugins/nemo-experimentalist/tests/test_eval_author_config.py b/plugins/nemo-experimentalist/tests/test_eval_author_config.py
index 23eb45b8aa..997cf65ae0 100644
--- a/plugins/nemo-experimentalist/tests/test_eval_author_config.py
+++ b/plugins/nemo-experimentalist/tests/test_eval_author_config.py
@@ -5,7 +5,7 @@
 
 import pytest
 from nemo_eval_author_plugin.eval_author.models import EvalAuthorConfig
-from nemo_experimentalist_plugin.experimentalist.components.loop import EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryOptimizerConfig
 
 
 def test_evolutionary_optimizer_uses_top_level_eval_author_config() -> None:
diff --git a/plugins/nemo-experimentalist/tests/test_experiment_cli.py b/plugins/nemo-experimentalist/tests/test_experiment_cli.py
index 83a0ec8e4a..cbf933a197 100644
--- a/plugins/nemo-experimentalist/tests/test_experiment_cli.py
+++ b/plugins/nemo-experimentalist/tests/test_experiment_cli.py
@@ -9,7 +9,7 @@
 from click.testing import Result
 from nemo_experimentalist_plugin import cli
 from nemo_experimentalist_plugin.entities import DatasetRef
-from nemo_experimentalist_plugin.experimentalist.components.loop import EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryOptimizerConfig
 from nemo_experimentalist_plugin.preflight import Probes
 from nemo_platform import AsyncNeMoPlatform
 from typer.testing import CliRunner
@@ -172,8 +172,10 @@ def test_cli_help_exposes_only_run_and_doctor() -> None:
     ("config_body", "expected_config", "expected_output"),
     [
         pytest.param(
-            "max_rounds: 2\nevaluator:\n  max_attempts: 3\n",
-            EvolutionaryOptimizerConfig.model_validate({"max_rounds": 2, "evaluator": {"max_attempts": 3}}),
+            "max_rounds: 2\noutcome_evaluator_config:\n  max_attempts: 3\n",
+            EvolutionaryOptimizerConfig.model_validate(
+                {"max_rounds": 2, "outcome_evaluator_config": {"max_attempts": 3}}
+            ),
             "configured-summary",
             id="with-config",
         ),
diff --git a/plugins/nemo-experimentalist/tests/test_experiment_mirror.py b/plugins/nemo-experimentalist/tests/test_experiment_mirror.py
index 559517159c..c2da1b4678 100644
--- a/plugins/nemo-experimentalist/tests/test_experiment_mirror.py
+++ b/plugins/nemo-experimentalist/tests/test_experiment_mirror.py
@@ -6,6 +6,7 @@
 
 import httpx
 import pytest
+from doubles import make_candidate
 from nemo_experimentalist_plugin.entities import Candidate, ExperimentRun, RewardRecord
 from nemo_experimentalist_plugin.experimentalist.experiment_mirror import ExperimentMirror, group_metadata
 from nemo_platform import AsyncNeMoPlatform, ConflictError, NotFoundError, omit
@@ -70,9 +71,9 @@ def _run(**kw: Any) -> ExperimentRun:
 
 
 def _cand(**kw: Any) -> Candidate:
-    base: dict[str, Any] = dict(run_id="run-1", label="agent-0", round=0, optimization="baseline")
+    base: dict[str, Any] = dict(run_id="run-1", label="agent-0", generation=0, description="baseline")
     base.update(kw)
-    return Candidate(**base)
+    return make_candidate(**base)
 
 
 async def test_ensure_group_creates_with_insight_and_metadata():
@@ -98,13 +99,18 @@ async def test_project_candidate_upserts_experiment_per_evaluated_split():
     experiments = AsyncMock()
     experiments.create.return_value = SimpleNamespace(id="exp-train")
     mirror = ExperimentMirror(_client(AsyncMock(), experiments), workspace="default")
-    cand = _cand(round=0, rewards={"train": RewardRecord(metrics={"reward": 1.0}, trials=[])})
+    cand = _cand(generation=0, rewards={"train": RewardRecord(metrics={"reward": 1.0}, trials=[])})
     await mirror.project_candidate(cand)
     kwargs = experiments.create.await_args.kwargs
     assert kwargs["name"] == "opt-run-1-agent-0-train"
     assert kwargs["status"] == "baseline"
     # metadata is identity-only — reward/trials are NOT copied (§4.3)
-    assert kwargs["metadata"] == {"round": "0", "candidate_id": "agent-0", "split": "train"}
+    assert kwargs["metadata"] == {
+        "generation": "0",
+        "candidate_id": "id-agent-0",
+        "candidate_label": "agent-0",
+        "split": "train",
+    }
     assert "aggregate_metrics" not in kwargs["metadata"] and "trials" not in kwargs["metadata"]
     # validation not evaluated → not created
     assert experiments.create.await_count == 1
@@ -128,7 +134,12 @@ async def test_project_candidate_creates_experiment_for_custom_reward_channel():
     kwargs = experiments.create.await_args.kwargs
     assert kwargs["name"] == "opt-run-1-agent-0-custom"
     assert kwargs["dataset_name"] == "custom"
-    assert kwargs["metadata"] == {"round": "0", "candidate_id": "agent-0", "split": "custom"}
+    assert kwargs["metadata"] == {
+        "generation": "0",
+        "candidate_id": "id-agent-0",
+        "candidate_label": "agent-0",
+        "split": "custom",
+    }
 
 
 async def test_project_candidate_conflict_updates_experiment():
@@ -138,13 +149,18 @@ async def test_project_candidate_conflict_updates_experiment():
     experiments.create.side_effect = _CONFLICT
     experiments.update.return_value = SimpleNamespace(id="exp-train")
     mirror = ExperimentMirror(_client(groups, experiments), workspace="default")
-    cand = _cand(round=0, rewards={"train": RewardRecord(metrics={"reward": 1.0}, trials=[])})
+    cand = _cand(generation=0, rewards={"train": RewardRecord(metrics={"reward": 1.0}, trials=[])})
     await mirror.project_candidate(cand)
     experiments.update.assert_awaited_once()
     # update is a full-replace: dataset_version must be re-supplied (symmetric with create)
     kwargs = experiments.update.await_args.kwargs
     assert kwargs["dataset_version"] == "v1"
-    assert kwargs["metadata"] == {"round": "0", "candidate_id": "agent-0", "split": "train"}
+    assert kwargs["metadata"] == {
+        "generation": "0",
+        "candidate_id": "id-agent-0",
+        "candidate_label": "agent-0",
+        "split": "train",
+    }
 
 
 async def test_parent_experiment_id_cache_hit():
@@ -156,12 +172,12 @@ async def test_parent_experiment_id_cache_hit():
         SimpleNamespace(id="exp-child-train"),  # child train experiment
     ]
     mirror = ExperimentMirror(_client(groups, experiments), workspace="default")
-    ancestor = _cand(label="agent-0", round=0, rewards={"train": RewardRecord(metrics={"reward": 1.0}, trials=[])})
+    ancestor = _cand(label="agent-0", generation=0, rewards={"train": RewardRecord(metrics={"reward": 1.0}, trials=[])})
     await mirror.project_candidate(ancestor)
     child = _cand(
         label="agent-1",
-        ancestor="agent-0",
-        round=1,
+        ancestor="id-agent-0",
+        generation=1,
         rewards={"train": RewardRecord(metrics={"reward": 1.0}, trials=[])},
     )
     await mirror.project_candidate(child)
@@ -170,23 +186,28 @@ async def test_parent_experiment_id_cache_hit():
     experiments.retrieve.assert_not_awaited()  # resolved from cache, no lookup
 
 
-async def test_parent_experiment_id_fallback_retrieve():
+async def test_parent_experiment_id_omits_the_link_for_an_unprojected_ancestor():
+    """``ancestor`` is an id and Experiment names are built from labels.
+
+    Without having projected the ancestor, this mirror cannot name its Experiment, so it
+    omits the lineage link rather than composing a name from an id that was never used
+    to build one. Projection is best-effort and one-way, so a missing link is the
+    honest outcome.
+    """
     groups = AsyncMock()
     groups.retrieve.return_value = SimpleNamespace(id="grp-1", name="opt-run-1")
     experiments = AsyncMock()
-    experiments.retrieve.return_value = SimpleNamespace(id="exp-ancestor-train")
     experiments.create.return_value = SimpleNamespace(id="exp-child-train")
     mirror = ExperimentMirror(_client(groups, experiments), workspace="default")
     child = _cand(
         label="agent-1",
-        ancestor="agent-0",
-        round=1,
+        ancestor="id-agent-0",
+        generation=1,
         rewards={"train": RewardRecord(metrics={"reward": 1.0}, trials=[])},
     )
     await mirror.project_candidate(child)
-    experiments.retrieve.assert_awaited()
-    kwargs = experiments.create.await_args.kwargs
-    assert kwargs["parent_evaluation_id"] == "exp-ancestor-train"
+    experiments.retrieve.assert_not_awaited()
+    assert isinstance(experiments.create.await_args.kwargs["parent_evaluation_id"], type(omit))
 
 
 async def test_parent_experiment_id_not_found_omits():
@@ -198,8 +219,8 @@ async def test_parent_experiment_id_not_found_omits():
     mirror = ExperimentMirror(_client(groups, experiments), workspace="default")
     child = _cand(
         label="agent-1",
-        ancestor="agent-0",
-        round=1,
+        ancestor="id-agent-0",
+        generation=1,
         rewards={"train": RewardRecord(metrics={"reward": 1.0}, trials=[])},
     )
     await mirror.project_candidate(child)
@@ -216,7 +237,7 @@ async def test_finalize_round0_winner_preserves_existing_source_link():
     experiments.retrieve.return_value = SimpleNamespace(id="exp-w", source_link="https://git/repo.git@main")
     experiments.create.return_value = SimpleNamespace(id="exp-w")
     mirror = ExperimentMirror(_client(groups, experiments), workspace="default")
-    winner = _cand(label="agent-0", round=0, rewards={"train": RewardRecord(metrics={"reward": 1.0}, trials=[])})
+    winner = _cand(label="agent-0", generation=0, rewards={"train": RewardRecord(metrics={"reward": 1.0}, trials=[])})
     await mirror.finalize(run_id="run-1", summary="done", winner=winner, pr_url=None)
     kwargs = experiments.create.await_args.kwargs
     assert kwargs["source_link"] == "https://git/repo.git@main"  # preserved, not pseudo
@@ -260,4 +281,4 @@ async def test_mirror_projects_every_measured_channel_without_an_allowlist() ->
     # entity alone would pass even if project_candidate went back to a fixed allowlist.
     projected = {call.kwargs["metadata"]["split"] for call in experiments.create.await_args_list}
     assert projected == {"validation", "some-new-channel"}
-    assert candidate.reward("never-measured").metrics == {}
+    assert candidate.rewards["never-measured"].metrics == {}
diff --git a/plugins/nemo-experimentalist/tests/test_experiment_mirror_mapping.py b/plugins/nemo-experimentalist/tests/test_experiment_mirror_mapping.py
index 24bc342e5a..841ccc8bfd 100644
--- a/plugins/nemo-experimentalist/tests/test_experiment_mirror_mapping.py
+++ b/plugins/nemo-experimentalist/tests/test_experiment_mirror_mapping.py
@@ -1,13 +1,14 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
+from typing import Any
+
+from doubles import make_candidate
 from nemo_experimentalist_plugin.entities import Candidate, ExperimentRun
 from nemo_experimentalist_plugin.experimentalist import experiment_mirror as m
 
 
-def _cand(**kw):
-    base = dict(run_id="run-1", label="agent-0", round=0, optimization="baseline")
-    base.update(kw)
-    return Candidate(**base)
+def _cand(**kw: Any) -> Candidate:
+    return make_candidate(run_id="run-1", label="agent-0", description="baseline", **kw)
 
 
 def test_group_name_is_sanitized_and_bounded():
@@ -20,9 +21,12 @@ def test_experiment_name_deterministic():
 
 
 def test_status_derivation():
-    assert m.experiment_status(_cand(round=0)) == "baseline"
-    assert m.experiment_status(_cand(round=2, killed_round=3)) == "killed"
-    assert m.experiment_status(_cand(round=2)) == "survived"
+    # Baseline is ``ancestor is None``, not a generation-0 sentinel: a strategy that
+    # leaves generation at 0 must not have every candidate read as the baseline.
+    assert m.experiment_status(_cand(generation=0)) == "baseline"
+    assert m.experiment_status(_cand(generation=2, ancestor="agent-0", killed_generation=3)) == "killed"
+    assert m.experiment_status(_cand(generation=2, ancestor="agent-0")) == "survived"
+    assert m.experiment_status(_cand(generation=2)) == "baseline"
 
 
 def test_group_metadata_carries_run_fields():
@@ -32,17 +36,21 @@ def test_group_metadata_carries_run_fields():
         insight=None,
         config_snapshot={"k": 1},
         status="running",
-        rounds_completed=2,
+        progress_completed=2,
+        progress_total=5,
+        progress_unit="round",
         winner_agent="agent-3",
     )
     md = m.group_metadata(run)
     # Platform metadata is dict[str, str]: config_snapshot is JSON-serialized and the
-    # round counter is stringified, so the create/update body passes server validation.
+    # progress counter is stringified, so the create/update body passes server validation.
     assert md == {
         "agent": "a",
         "config_snapshot": '{"k": 1}',
         "status": "running",
-        "rounds_completed": "2",
+        "progress_completed": "2",
+        "progress_total": "5",
+        "progress_unit": "round",
         "winner_candidate": "agent-3",
     }
 
@@ -54,7 +62,7 @@ def test_group_metadata_omits_winner_until_present():
         insight=None,
         config_snapshot={"k": 1},
         status="running",
-        rounds_completed=0,
+        progress_completed=0,
         winner_agent=None,
     )
     md = m.group_metadata(run)
@@ -64,9 +72,15 @@ def test_group_metadata_omits_winner_until_present():
 
 
 def test_experiment_metadata_is_identity_only():
-    md = m.experiment_metadata(_cand(round=1), "train")
-    # round stringified for dict[str, str] metadata; no reward/trials copied
-    assert md == {"round": "1", "candidate_id": "agent-0", "split": "train"}
+    md = m.experiment_metadata(_cand(generation=1), "train")
+    # generation stringified for dict[str, str] metadata; no reward/trials copied.
+    # Both id and label: ancestor references are ids, Experiment names use labels.
+    assert md == {
+        "generation": "1",
+        "candidate_id": "id-agent-0",
+        "candidate_label": "agent-0",
+        "split": "train",
+    }
 
 
 def test_pseudo_source_link_is_a_url():
diff --git a/plugins/nemo-experimentalist/tests/test_experimentalist_analyzer.py b/plugins/nemo-experimentalist/tests/test_experimentalist_analyzer.py
index 7f766e5599..97db44ece6 100644
--- a/plugins/nemo-experimentalist/tests/test_experimentalist_analyzer.py
+++ b/plugins/nemo-experimentalist/tests/test_experimentalist_analyzer.py
@@ -1,15 +1,19 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-"""Regression tests for AgentAnalyzer client/workspace plumbing.
+"""Regression tests for TraceRootCauseAnalyzer trace-loading plumbing.
 
-The Experimentalist round-N analysis path used to silently skip every
-``intake://`` trial trace because ``AgentAnalyzer`` never received (and never
-forwarded) a platform ``client`` or the Intake ``workspace`` name. These tests
-pin the plumbing: ``AgentAnalyzer.run`` must accept ``client`` / ``nmp_workspace``
-and thread them into ``TraceAnalyzer.run``.
+The round-N analysis path silently skips every ``intake://`` trial trace if the
+analyzer cannot load one, and a skipped trace is invisible: the round still
+produces a diagnosis, just one blind to the trajectory. These tests pin the
+plumbing: ``TraceRootCauseAnalyzer`` takes a ``load_trace`` from the context and threads it
+into ``TraceAnalyzer.run``.
 
-``AgentAnalyzer`` is built via ``object.__new__`` to skip its LLM-heavy
+It takes a loader rather than a platform client so no component signature names a
+platform type -- an analyzer shipped by another package reads traces through the
+same seam.
+
+``TraceRootCauseAnalyzer`` is built via ``object.__new__`` to skip its LLM-heavy
 ``__init__``, and the LLM-driven strategy methods (``select_trials``,
 ``classify_failures``, ``compare_with_peers``) are replaced by callable
 *objects* — the agent framework's method guard rejects attaching plain
@@ -21,13 +25,15 @@
 from typing import Any, ClassVar, cast
 
 import pytest
+from doubles import make_candidate
+from nemo_experimentalist_plugin.entities import MetricTarget
 from nemo_experimentalist_plugin.experimentalist.components import analyzer as analyzer_module
 from nemo_experimentalist_plugin.experimentalist.components import cache
 from nemo_experimentalist_plugin.experimentalist.components.analyzer import (
-    AgentAnalyzer,
     AnalyzerConfig,
     FailureClassification,
     PeerComparison,
+    TraceRootCauseAnalyzer,
     TrialSelection,
 )
 from nemo_experimentalist_plugin.experimentalist.components.rationalizer import Rationale
@@ -75,7 +81,14 @@ class _RecordingTraceAnalyzer:
 
     calls: ClassVar[list[dict[str, Any]]] = []
 
-    def __init__(self, *, experiment_dir: Path, config: Any, framework_skills_dirs: list[Path] | None = None) -> None:
+    def __init__(
+        self,
+        *,
+        experiment_dir: Path,
+        config: Any,
+        framework_skills_dirs: list[Path] | None = None,
+        models: Any = None,
+    ) -> None:
         self.experiment_dir = experiment_dir
         self.config = config
         self.framework_skills_dirs = framework_skills_dirs or []
@@ -91,12 +104,12 @@ async def run(
         selection_reason: str = "",
         objective_metrics: list[dict[str, Any]] | None = None,
         regression_metrics: list[dict[str, Any]] | None = None,
-        client: Any = None,
+        load_trace: Any = None,
         workspace: Any = None,
     ) -> Diagnostic:
         type(self).calls.append(
             {
-                "client": client,
+                "load_trace": load_trace,
                 "workspace": workspace,
                 "selection_reason": selection_reason,
                 "objective_metrics": objective_metrics,
@@ -107,7 +120,14 @@ async def run(
 
 
 class _FakeRationalizer:
-    def __init__(self, *, workspace: Path, config: Any, framework_skills_dirs: list[Path] | None = None) -> None:
+    def __init__(
+        self,
+        *,
+        workspace: Path,
+        config: Any,
+        framework_skills_dirs: list[Path] | None = None,
+        models: Any = None,
+    ) -> None:
         self.workspace = workspace
         self.config = config
         self.framework_skills_dirs = framework_skills_dirs or []
@@ -160,12 +180,25 @@ async def __call__(
         return PeerComparison(divergent_trials=[], complementary_patterns=[])
 
 
-def _make_analyzer(tmp_path: Path, trials: list[Any]) -> AgentAnalyzer:
-    """Build an AgentAnalyzer without the LLM-heavy __init__ and stub its strategies."""
-    analyzer = object.__new__(AgentAnalyzer)
+def _a_loader() -> Any:
+    """A distinct loader object; identity is what these tests assert on."""
+
+    async def _load(ref: Any) -> Any:  # pragma: no cover - never awaited here
+        raise AssertionError("not expected to load in this test")
+
+    return _load
+
+
+def _make_analyzer(tmp_path: Path, trials: list[Any], *, load_trace: Any = None) -> TraceRootCauseAnalyzer:
+    """Build an TraceRootCauseAnalyzer without the LLM-heavy __init__ and stub its strategies."""
+    analyzer = object.__new__(TraceRootCauseAnalyzer)
     analyzer._workspace_path = tmp_path
+    analyzer._load_trace = load_trace
+    analyzer._objective_metrics = []
+    analyzer._regression_metrics = []
     analyzer._config = AnalyzerConfig()
     analyzer._framework_skills_dirs = []
+    # sub-components it builds.
     analyzer.select_trials = _SelectTrials(trials)  # type: ignore[method-assign,assignment]
     analyzer.classify_failures = _ClassifyFailures()  # type: ignore[method-assign,assignment]
     analyzer.compare_with_peers = _CompareWithPeers()  # type: ignore[method-assign,assignment]
@@ -215,46 +248,52 @@ def test_peer_comparison_respects_minimize_metric_directions(tmp_path: Path) ->
 
 
 @pytest.mark.asyncio
-async def test_run_threads_client_and_workspace_into_trace_analyzer(
+async def test_run_threads_the_trace_loader_into_trace_analyzer(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    """AgentAnalyzer.run forwards client and nmp_workspace to TraceAnalyzer.run."""
+    """The platform handles the analyzer was built with reach TraceAnalyzer.run.
+
+    Taken at construction rather than per call, so the ``root-cause-analyzer`` role's
+    own signature names no platform types.
+    """
     calls: list[dict[str, Any]] = []
     _install_fakes(monkeypatch, calls)
     trial, dataset, evaluation = _fixtures()
-    analyzer = _make_analyzer(tmp_path, [trial])
+    sentinel_loader = _a_loader()
+    analyzer = _make_analyzer(tmp_path, [trial], load_trace=sentinel_loader)
 
-    sentinel_client = object()
     result = await analyzer.run(
-        agent="agent-a",
+        candidate=make_candidate(label="agent-a"),
         dataset=cast(Any, dataset),
         evaluation=cast(Any, evaluation),
-        round=0,
-        client=cast(Any, sentinel_client),
-        nmp_workspace="tau2-airline-ws",
+        round_num=0,
     )
 
     assert result.agent_id == "agent-a"
     assert len(calls) == 1
-    assert calls[0]["client"] is sentinel_client
-    assert calls[0]["workspace"] == "tau2-airline-ws"
+    assert calls[0]["load_trace"] is sentinel_loader
     assert calls[0]["selection_reason"] == "Analyze trial-1 for this test."
     assert calls[0]["objective_metrics"] == []
     assert calls[0]["regression_metrics"] == []
 
 
 @pytest.mark.asyncio
-async def test_run_defaults_client_and_workspace_to_none(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    """Omitting client/nmp_workspace still runs and forwards None (backward compat)."""
+async def test_run_defaults_the_trace_loader_to_none(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """Omitting the loader still runs and forwards None, so a run without traces works."""
     calls: list[dict[str, Any]] = []
     _install_fakes(monkeypatch, calls)
     trial, dataset, evaluation = _fixtures()
     analyzer = _make_analyzer(tmp_path, [trial])
 
-    await analyzer.run(agent="agent-a", dataset=cast(Any, dataset), evaluation=cast(Any, evaluation), round=0)
+    await analyzer.run(
+        candidate=make_candidate(label="agent-a"),
+        dataset=cast(Any, dataset),
+        evaluation=cast(Any, evaluation),
+        round_num=0,
+    )
 
     assert len(calls) == 1
-    assert calls[0]["client"] is None
+    assert calls[0]["load_trace"] is None
     assert calls[0]["workspace"] is None
 
 
@@ -264,68 +303,72 @@ async def test_run_threads_metric_contract_into_trace_analyzer(tmp_path: Path, m
     calls: list[dict[str, Any]] = []
     _install_fakes(monkeypatch, calls)
     trial, dataset, evaluation = _fixtures()
+    objective_metrics = [MetricTarget(name="success_rate", direction="maximize")]
+    regression_metrics = [MetricTarget(name="tokens", direction="minimize")]
     analyzer = _make_analyzer(tmp_path, [trial])
-    objective_metrics = [{"name": "success_rate", "direction": "maximize"}]
-    regression_metrics = [{"name": "tokens", "direction": "minimize"}]
+    # Objectives arrive at construction, so the role's own signature names no run config.
+    analyzer._objective_metrics = objective_metrics
+    analyzer._regression_metrics = regression_metrics
 
     await analyzer.run(
-        agent="agent-a",
+        candidate=make_candidate(label="agent-a"),
         dataset=cast(Any, dataset),
         evaluation=cast(Any, evaluation),
-        round=0,
-        objective_metrics=objective_metrics,
-        regression_metrics=regression_metrics,
+        round_num=0,
     )
 
-    assert calls[0]["objective_metrics"] == objective_metrics
-    assert calls[0]["regression_metrics"] == regression_metrics
+    assert calls[0]["objective_metrics"] == [t.model_dump() for t in objective_metrics]
+    assert calls[0]["regression_metrics"] == [t.model_dump() for t in regression_metrics]
 
 
 @pytest.mark.asyncio
 async def test_run_threads_numeric_objective_targets_into_trace_analyzer(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    """Check that trace analysis receives a numeric objective target."""
+    """The `target` travels too, so the analyzer can say how far short a run fell."""
     calls: list[dict[str, Any]] = []
     _install_fakes(monkeypatch, calls)
     trial, dataset, evaluation = _fixtures()
+    objective_metrics = [MetricTarget(name="reward", direction="maximize", target=1.0)]
     analyzer = _make_analyzer(tmp_path, [trial])
-    objective_metrics = [{"name": "reward", "direction": "maximize", "target": 1.0}]
+    analyzer._objective_metrics = objective_metrics
 
     await analyzer.run(
-        agent="agent-a",
+        candidate=make_candidate(label="agent-a"),
         dataset=cast(Any, dataset),
         evaluation=cast(Any, evaluation),
-        round=0,
-        objective_metrics=objective_metrics,
+        round_num=0,
     )
 
-    assert calls[0]["objective_metrics"] == objective_metrics
+    assert calls[0]["objective_metrics"] == [{"name": "reward", "direction": "maximize", "target": 1.0}]
 
 
 @pytest.mark.asyncio
 async def test_intake_availability_is_part_of_cache_key(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-    """A trace-skipped (no client) result must not be replayed once a client is available."""
+    """A trace-skipped result must not be replayed once a loader is available."""
     calls: list[dict[str, Any]] = []
     _install_fakes(monkeypatch, calls)
     trial, dataset, evaluation = _fixtures()
 
     # Same workspace/tmp_path across both runs, so the on-disk cache persists.
-    analyzer_no_client = _make_analyzer(tmp_path, [trial])
-    await analyzer_no_client.run(agent="agent-a", dataset=cast(Any, dataset), evaluation=cast(Any, evaluation), round=0)
+    analyzer_without_loader = _make_analyzer(tmp_path, [trial])
+    await analyzer_without_loader.run(
+        candidate=make_candidate(label="agent-a"),
+        dataset=cast(Any, dataset),
+        evaluation=cast(Any, evaluation),
+        round_num=0,
+    )
 
-    analyzer_with_client = _make_analyzer(tmp_path, [trial])
-    await analyzer_with_client.run(
-        agent="agent-a",
+    analyzer_with_loader = _make_analyzer(tmp_path, [trial], load_trace=_a_loader())
+    await analyzer_with_loader.run(
+        candidate=make_candidate(label="agent-a"),
         dataset=cast(Any, dataset),
         evaluation=cast(Any, evaluation),
-        round=0,
-        client=cast(Any, object()),
-        nmp_workspace="ws-1",
+        round_num=0,
     )
 
     # The second (intake-available) run must recompute rather than reuse the
     # trace-skipped cache entry from the first run.
     assert len(calls) == 2
-    assert calls[0]["client"] is None
-    assert calls[1]["client"] is not None
+    assert calls[0]["load_trace"] is None
+    assert calls[1]["load_trace"] is not None
diff --git a/plugins/nemo-experimentalist/tests/test_experimentalist_backend.py b/plugins/nemo-experimentalist/tests/test_experimentalist_backend.py
index 22275bb0b8..22624b8390 100644
--- a/plugins/nemo-experimentalist/tests/test_experimentalist_backend.py
+++ b/plugins/nemo-experimentalist/tests/test_experimentalist_backend.py
@@ -17,6 +17,7 @@
 
 import httpx
 import pytest
+from doubles import make_candidate
 from nemo_experimentalist_plugin.entities import Candidate
 from nemo_experimentalist_plugin.experimentalist import experimentalist_backend as beim
 from nemo_experimentalist_plugin.experimentalist.components.repository import AgentCloneError, AgentSource
@@ -250,7 +251,7 @@ async def test_get_agent_spec_remote_delegates_to_files(tmp_path: Path) -> None:
 
 
 def _cand(label: str = "agent-2", run_id: str = "run-1") -> Candidate:
-    return Candidate(name=label, label=label, run_id=run_id, round=1, optimization="edit")
+    return make_candidate(label=label, run_id=run_id, generation=1, ancestor="agent-0", description="edit")
 
 
 def _git_backend(tmp_path: Path, storage: CandidateStorageConfig | None = None) -> LocalExperimentalistBackend:
@@ -334,7 +335,7 @@ async def test_persist_result_writes_run_summary(tmp_path: Path) -> None:
     run._id = "run-1"  # type: ignore[attr-defined]
     (backend._eo / "run.json").write_text(run.model_dump_json(indent=2))
 
-    result = ExperimentalistResult(summary="the real run summary", run_id="run-1", rounds_completed=2, winner=None)
+    result = ExperimentalistResult(summary="the real run summary", run_id="run-1", progress_completed=2, winner=None)
     await backend.persist_result(workspace="w", result=result)
 
     saved = json.loads((backend._eo / "run.json").read_text())
@@ -342,6 +343,34 @@ async def test_persist_result_writes_run_summary(tmp_path: Path) -> None:
     assert (backend._eo / "OPTIMIZATION.md").read_text() == "the real run summary"
 
 
+async def test_persist_result_names_the_winner_by_label(tmp_path: Path) -> None:
+    """``winner_agent`` must hold 'agent-1', not the candidate id.
+
+    Everything a run writes is filed under the label -- ``agents/agent-1``,
+    ``results/agent-1-validation`` -- so this field exists to be used as a path
+    component. Writing the id gives a reference that resolves to nothing, and the
+    empty lookup downstream reads as "the winner has no results" rather than as a
+    broken reference; a smoke-agent gate reported a passing control as a regression
+    on exactly that.
+    """
+    from doubles import make_candidate
+    from nemo_experimentalist_plugin.entities import ExperimentRun
+    from nemo_experimentalist_plugin.experimentalist.result import ExperimentalistResult
+
+    backend = _local_backend(tmp_path)
+    run = ExperimentRun(workspace="w", agent="a")
+    run._id = "run-1"  # type: ignore[attr-defined]
+    (backend._eo / "run.json").write_text(run.model_dump_json(indent=2))
+
+    winner = make_candidate(label="agent-1", generation=1, ancestor="agent-0")
+    result = ExperimentalistResult(summary="s", run_id="run-1", progress_completed=1, winner=winner)
+    await backend.persist_result(workspace="w", result=result)
+
+    saved = json.loads((backend._eo / "run.json").read_text())
+    assert saved["winner_agent"] == "agent-1"
+    assert saved["winner_agent"] != winner.id
+
+
 async def test_persist_result_preserves_generated_optimization_report(tmp_path: Path) -> None:
     from nemo_experimentalist_plugin.experimentalist.result import ExperimentalistResult
 
@@ -349,7 +378,7 @@ async def test_persist_result_preserves_generated_optimization_report(tmp_path:
     report_path = backend._eo / "OPTIMIZATION.md"
     report_path.write_text("# Full optimization report\n\nAdditional Metrics")
 
-    result = ExperimentalistResult(summary="compact run summary", run_id="run-1", rounds_completed=2, winner=None)
+    result = ExperimentalistResult(summary="compact run summary", run_id="run-1", progress_completed=2, winner=None)
     await backend.persist_result(workspace="w", result=result)
 
     assert report_path.read_text() == "# Full optimization report\n\nAdditional Metrics"
@@ -419,3 +448,28 @@ async def test_upload_trace_atif_sends_json_not_protobuf(tmp_path):
     await _upload_trace_atif(cast(Any, client), "ws-1", _atif_ref(tmp_path), evaluation_name="exp-1", task_id="case-a")
     assert client.posts[0]["content"] is None
     assert client.posts[0]["body"] is not None
+
+
+@pytest.mark.parametrize("bad_id", ["../run", "a/b", "..", ".", "nested/../../run"])
+async def test_a_candidate_id_that_is_not_one_name_is_refused(tmp_path: Path, bad_id: str) -> None:
+    """The id is interpolated into a path, so a separator escapes the candidates directory.
+
+    `../run` lands exactly on `eval-and-optimize/run.json`, so writing that candidate would
+    overwrite the run record and make the whole run unresumable. Ids are minted as uuids
+    here, but a Candidate can arrive from a component this repo did not write -- which is
+    what the registry is for -- so the check belongs at the path.
+    """
+    backend = _local_backend(tmp_path)
+
+    with pytest.raises(ValueError, match="single path component|required"):
+        backend._candidate_path(bad_id)
+
+
+async def test_a_normal_candidate_id_still_resolves(tmp_path: Path) -> None:
+    """The refusal must not fire on the ids the backend actually mints."""
+    backend = _local_backend(tmp_path)
+
+    path = backend._candidate_path("8374a3ea-f04d-4203-9f6e-21b56e64f1fc")
+
+    assert path.parent.name == "candidates"
+    assert path.name.endswith(".json")
diff --git a/plugins/nemo-experimentalist/tests/test_experimentalist_benchmark.py b/plugins/nemo-experimentalist/tests/test_experimentalist_benchmark.py
index 4da38b4e23..501252edd0 100644
--- a/plugins/nemo-experimentalist/tests/test_experimentalist_benchmark.py
+++ b/plugins/nemo-experimentalist/tests/test_experimentalist_benchmark.py
@@ -85,7 +85,7 @@ def test_shipped_benchmark_configs_use_current_contracts(name: str) -> None:
 
     config = runner.load_benchmark_config(BENCHMARK_ROOT / "configs" / name)
 
-    assert config.optimizer.evaluator["n_attempts"] >= 1
+    assert config.optimizer.outcome_evaluator_config["n_attempts"] >= 1
     assert config.optimizer.eval_author.max_validation_repair_attempts >= 0
 
 
diff --git a/plugins/nemo-experimentalist/tests/test_experimentalist_run.py b/plugins/nemo-experimentalist/tests/test_experimentalist_run.py
index 682a95035c..78adc2a8b5 100644
--- a/plugins/nemo-experimentalist/tests/test_experimentalist_run.py
+++ b/plugins/nemo-experimentalist/tests/test_experimentalist_run.py
@@ -1,19 +1,22 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-import logging
-from dataclasses import dataclass
+"""``run_experimentalist`` wires the CLI's inputs into one :class:`ExperimentRunner`.
+
+What the runner then does with them is covered by the runner's own tests; these check
+the hand-off, and that the caller keeps ownership of its platform client.
+"""
+
+from dataclasses import dataclass, field
 from pathlib import Path
-from typing import cast
+from typing import Any, cast
 
 import pytest
 from nemo_experimentalist_plugin.entities import DatasetRef
 from nemo_experimentalist_plugin.experimentalist import run as experimentalist_run
-from nemo_experimentalist_plugin.experimentalist.components import loop as loop_module
-from nemo_experimentalist_plugin.experimentalist.components.loop import EvolutionaryOptimizerConfig
-from nemo_experimentalist_plugin.experimentalist.deps import ExperimentalistDeps
 from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import LocalExperimentalistBackend
 from nemo_experimentalist_plugin.experimentalist.result import ExperimentalistResult
+from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryOptimizerConfig
 from nemo_platform import AsyncNeMoPlatform
 from nemo_platform_plugin.nooa_model_client import ConfiguredModelRefs
 
@@ -28,6 +31,8 @@ async def close(self) -> None:
 
 @dataclass
 class ClosingModelClients:
+    """Stands in for the resolved Model Entity clients (#1159)."""
+
     default: object = "default"
     fast: object = "fast"
     refs: ConfiguredModelRefs = ConfiguredModelRefs(default="default/quality", fast="default/fast")
@@ -69,24 +74,17 @@ class AgentFactoryCall:
 
 
 @dataclass
-class FakeExperimentalist:
-    deps: ExperimentalistDeps | None = None
+class RecordingRunner:
+    """Stands in for the real runner and keeps the kwargs it was constructed with."""
 
-    async def run(self, deps: ExperimentalistDeps) -> ExperimentalistResult:
-        self.deps = deps
-        return ExperimentalistResult(summary="optimization complete", run_id="run-1", rounds_completed=1)
+    calls: list[dict[str, Any]] = field(default_factory=list)
 
+    def __call__(self, **kwargs: Any) -> "RecordingRunner":
+        self.calls.append(kwargs)
+        return self
 
-def test_persistence_warning_includes_exception_message(
-    caplog: pytest.LogCaptureFixture,
-) -> None:
-    caplog.set_level(logging.WARNING, logger=loop_module.__name__)
-
-    loop_module._warn_persistence_failure("archive", "agent-2", RuntimeError("push rejected by remote"))
-
-    assert "archive" in caplog.text
-    assert "agent-2" in caplog.text
-    assert "push rejected by remote" in caplog.text
+    async def run(self) -> ExperimentalistResult:
+        return ExperimentalistResult(summary="optimization complete", run_id="run-1", progress_completed=1)
 
 
 def _make_run_paths(tmp_path: Path) -> ExperimentRunPaths:
@@ -105,15 +103,16 @@ def _make_run_paths(tmp_path: Path) -> ExperimentRunPaths:
 
 @pytest.mark.asyncio
 async def test_run_experimentalist_builds_and_runs_complete_local_contract(
-    monkeypatch: pytest.MonkeyPatch,
     model_clients: ClosingModelClients,
+    monkeypatch: pytest.MonkeyPatch,
     tmp_path: Path,
 ) -> None:
     paths = _make_run_paths(tmp_path)
     client = ClosingClient()
     backend = LocalExperimentalistBackend(path=tmp_path / "backend")
     optimizer_config = EvolutionaryOptimizerConfig(max_rounds=2)
-    experimentalist = FakeExperimentalist()
+    strategy = object()
+    runner = RecordingRunner()
     backend_calls: list[BackendFactoryCall] = []
     agent_calls: list[AgentFactoryCall] = []
 
@@ -123,23 +122,22 @@ def make_backend(
         experiments_output: str,
         storage: object = None,
     ) -> LocalExperimentalistBackend:
-        backend_calls.append(
-            BackendFactoryCall(
-                client=client,
-                experiments_output=experiments_output,
-            )
-        )
+        backend_calls.append(BackendFactoryCall(client=client, experiments_output=experiments_output))
         return backend
 
     def build_agent(
-        *, working_dir: Path, config: EvolutionaryOptimizerConfig, framework_skills_dirs: list[Path] | None
-    ) -> FakeExperimentalist:
+        *,
+        working_dir: Path,
+        config: EvolutionaryOptimizerConfig,
+        framework_skills_dirs: list[Path] | None,
+    ) -> object:
         assert framework_skills_dirs is None
         agent_calls.append(AgentFactoryCall(working_dir=working_dir, config=config))
-        return experimentalist
+        return strategy
 
     monkeypatch.setattr(experimentalist_run, "make_experimentalist_backend", make_backend)
     monkeypatch.setattr(experimentalist_run, "build_experimentalist_agent", build_agent)
+    monkeypatch.setattr(experimentalist_run, "ExperimentRunner", runner)
 
     train_dataset = DatasetRef(uri=str(paths.train))
     validation_dataset = DatasetRef(uri=str(paths.validation))
@@ -157,48 +155,36 @@ def build_agent(
 
     assert summary == "optimization complete"
     assert paths.experiment.is_dir()
-    assert backend_calls == [
-        BackendFactoryCall(
-            client=client,
-            experiments_output=str(paths.experiment.resolve()),
-        )
-    ]
-    assert agent_calls == [AgentFactoryCall(working_dir=paths.experiment.resolve(), config=optimizer_config)]
+    assert backend_calls == [BackendFactoryCall(client=client, experiments_output=str(paths.experiment.resolve()))]
+    assert [(c.working_dir, c.config) for c in agent_calls] == [(paths.experiment.resolve(), optimizer_config)]
     assert not client.closed
-    assert model_clients.closed
-    assert experimentalist.deps is not None
-    assert experimentalist.deps.workspace == "workspace-a"
-    # ``agent`` is forwarded verbatim (it may be a git url@ref); the loop resolves it.
-    assert experimentalist.deps.agent == paths.agent
-    assert experimentalist.deps.insight is None
-    assert experimentalist.deps.train_dataset == train_dataset
-    assert experimentalist.deps.validation_dataset == validation_dataset
-    assert experimentalist.deps.backend is backend
-    assert experimentalist.deps.config is optimizer_config
-    assert experimentalist.deps.agent_spec is None
+
+    (call,) = runner.calls
+    assert call["backend"] is backend
+    assert call["strategy"] is strategy
+    assert call["config"] is optimizer_config
+    assert call["workspace"] == "workspace-a"
+    assert call["root"] == paths.experiment.resolve()
+    # ``agent`` is forwarded verbatim (it may be a git url@ref); the runner resolves it.
+    assert call["agent"] == paths.agent
+    assert call["insight"] is None
+    assert call["train_dataset"] == train_dataset
+    assert call["validation_dataset"] == validation_dataset
+    assert call["agent_spec"] is None
 
 
 @pytest.mark.asyncio
 async def test_run_experimentalist_forwards_platform_insight_id_verbatim(
-    monkeypatch: pytest.MonkeyPatch,
     model_clients: ClosingModelClients,
+    monkeypatch: pytest.MonkeyPatch,
     tmp_path: Path,
 ) -> None:
     paths = _make_run_paths(tmp_path)
-    client = ClosingClient()
-    backend = LocalExperimentalistBackend(path=tmp_path / "backend")
-    experimentalist = FakeExperimentalist()
+    runner = RecordingRunner()
 
-    monkeypatch.setattr(
-        experimentalist_run,
-        "make_experimentalist_backend",
-        lambda **_: backend,
-    )
-    monkeypatch.setattr(
-        experimentalist_run,
-        "build_experimentalist_agent",
-        lambda **_: experimentalist,
-    )
+    monkeypatch.setattr(experimentalist_run, "make_experimentalist_backend", lambda **_: object())
+    monkeypatch.setattr(experimentalist_run, "build_experimentalist_agent", lambda **_: object())
+    monkeypatch.setattr(experimentalist_run, "ExperimentRunner", runner)
 
     await experimentalist_run.run_experimentalist(
         insight="insight-remote-123",
@@ -207,29 +193,26 @@ async def test_run_experimentalist_forwards_platform_insight_id_verbatim(
         task_template=DatasetRef(uri=str(paths.train)),
         experiment_dir=paths.experiment,
         workspace="workspace-a",
-        client=cast(AsyncNeMoPlatform, client),
+        client=cast(AsyncNeMoPlatform, ClosingClient()),
         config=EvolutionaryOptimizerConfig(),
     )
 
-    assert experimentalist.deps is not None
     # A str id is not resolved to a Path — it flows through untouched to the backend.
-    assert experimentalist.deps.insight == "insight-remote-123"
-    assert model_clients.closed
+    assert runner.calls[0]["insight"] == "insight-remote-123"
 
 
 @pytest.mark.asyncio
-async def test_run_experimentalist_forwards_agent_spec_uri_to_deps(
-    monkeypatch: pytest.MonkeyPatch,
+async def test_run_experimentalist_forwards_agent_spec_uri(
     model_clients: ClosingModelClients,
+    monkeypatch: pytest.MonkeyPatch,
     tmp_path: Path,
 ) -> None:
     paths = _make_run_paths(tmp_path)
-    backend = LocalExperimentalistBackend(path=tmp_path / "backend")
-    experimentalist = FakeExperimentalist()
-    client = ClosingClient()
+    runner = RecordingRunner()
 
-    monkeypatch.setattr(experimentalist_run, "make_experimentalist_backend", lambda **_: backend)
-    monkeypatch.setattr(experimentalist_run, "build_experimentalist_agent", lambda **_: experimentalist)
+    monkeypatch.setattr(experimentalist_run, "make_experimentalist_backend", lambda **_: object())
+    monkeypatch.setattr(experimentalist_run, "build_experimentalist_agent", lambda **_: object())
+    monkeypatch.setattr(experimentalist_run, "ExperimentRunner", runner)
 
     spec_uri = "/path/to/AGENT-SPEC.md"
     await experimentalist_run.run_experimentalist(
@@ -240,19 +223,17 @@ async def test_run_experimentalist_forwards_agent_spec_uri_to_deps(
         validation_dataset=DatasetRef(uri=str(paths.validation)),
         experiment_dir=paths.experiment,
         workspace="default",
-        client=cast(AsyncNeMoPlatform, client),
+        client=None,
         config=EvolutionaryOptimizerConfig(),
     )
 
-    assert experimentalist.deps is not None
-    assert experimentalist.deps.agent_spec == spec_uri
-    assert model_clients.closed
+    assert runner.calls[0]["agent_spec"] == spec_uri
 
 
 @pytest.mark.asyncio
 async def test_run_experimentalist_does_not_close_caller_client_when_backend_creation_fails(
-    monkeypatch: pytest.MonkeyPatch,
     model_clients: ClosingModelClients,
+    monkeypatch: pytest.MonkeyPatch,
     tmp_path: Path,
 ) -> None:
     paths = _make_run_paths(tmp_path)
@@ -276,4 +257,3 @@ def fail_backend_creation(**_: object) -> object:
         )
 
     assert not client.closed
-    assert not model_clients.closed
diff --git a/plugins/nemo-experimentalist/tests/test_legacy_config_keys.py b/plugins/nemo-experimentalist/tests/test_legacy_config_keys.py
new file mode 100644
index 0000000000..cdc1a0b074
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/test_legacy_config_keys.py
@@ -0,0 +1,154 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Every key this refactor removed must be rejected, by name, with its replacement.
+
+The config tolerates unknown keys, so a removed one is otherwise accepted and ignored
+-- and the run then does something other than what the file says. That is the worst
+kind of failure here: it is silent, and `config_snapshot` records the run as correct.
+
+Two distinct migrations are covered, because they read differently to whoever hits
+them. A `disable_*` flag became "choose no implementation of the role". A config block
+moved under `<role>_config` so the bare role key could name the component -- which
+means a *string* there is still valid and must keep working.
+"""
+
+from __future__ import annotations
+
+import pytest
+from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
+
+
+@pytest.mark.parametrize(
+    ("key", "replacement"),
+    [("disable_convergence_check", "terminator: null"), ("disable_trajectory_scoring", "trajectory_scorer: null")],
+)
+def test_a_disable_flag_names_the_role_to_null(key: str, replacement: str) -> None:
+    with pytest.raises(ValueError, match=replacement):
+        EvolutionaryOptimizerConfig.model_validate({key: True})
+
+
+@pytest.mark.parametrize(("key", "replacement"), [("analyzer", "analyzer_config"), ("proposer", "proposer_config")])
+def test_a_config_block_under_a_role_key_names_the_config_key(key: str, replacement: str) -> None:
+    with pytest.raises(ValueError, match=replacement):
+        EvolutionaryOptimizerConfig.model_validate({key: {"some": "setting"}})
+
+
+@pytest.mark.parametrize(("key", "value"), [("analyzer", "trace"), ("proposer", "code-change")])
+def test_a_component_name_under_the_same_key_is_still_valid(key: str, value: str) -> None:
+    """The whole point of the move: the bare key now selects the component."""
+    config = EvolutionaryOptimizerConfig.model_validate({key: value})
+
+    assert getattr(config, key) == value
+
+
+@pytest.mark.parametrize(
+    ("key", "role", "config_key"),
+    [
+        ("evaluator", "outcome_evaluator", "outcome_evaluator_config"),
+        ("evaluation", "outcome_evaluator", "outcome_evaluator_config"),
+        ("coder", "builder", "builder_config"),
+        ("goal_config", "trajectory_scorer", "trajectory_scorer_config"),
+    ],
+)
+def test_a_renamed_role_names_both_the_role_and_its_config(key: str, role: str, config_key: str) -> None:
+    """These are not fields at all, so any value would otherwise be dropped in silence."""
+    with pytest.raises(ValueError, match=f"{role}.*{config_key}"):
+        EvolutionaryOptimizerConfig.model_validate({key: {"n_attempts": 1}})
+
+
+@pytest.mark.parametrize("value", ["harbor", {"n_attempts": 1}, None, 3])
+def test_a_renamed_role_is_rejected_whatever_the_value(value: object) -> None:
+    """A string under `evaluator` reads as "use this component" and would be ignored."""
+    with pytest.raises(ValueError, match="outcome_evaluator"):
+        EvolutionaryOptimizerConfig.model_validate({"evaluator": value})
+
+
+def test_models_points_at_nemo_setup() -> None:
+    """Model selection left the run config entirely in #1159; say where it went."""
+    with pytest.raises(ValueError, match="nemo setup"):
+        EvolutionaryOptimizerConfig.model_validate({"models": {"smart": "gpt-5"}})
+
+
+def test_curator_names_eval_author() -> None:
+    with pytest.raises(ValueError, match="'curator' was renamed to 'eval_author'"):
+        EvolutionaryOptimizerConfig.model_validate({"curator": {"max_traces": 1}})
+
+
+def test_a_config_using_the_current_keys_is_accepted() -> None:
+    """The rejections must not fire on the spelling they are steering people towards."""
+    config = EvolutionaryOptimizerConfig.model_validate(
+        {
+            "terminator": None,
+            "trajectory_scorer": None,
+            "outcome_evaluator": "harbor-native",
+            "outcome_evaluator_config": {"n_attempts": 1},
+            "builder": "code-edit",
+            "analyzer_config": {},
+            "proposer_config": {},
+        }
+    )
+
+    assert config.terminator is None
+    assert config.outcome_evaluator == "harbor-native"
+    assert config.outcome_evaluator_config == {"n_attempts": 1}
+
+
+def test_the_skill_documents_only_live_config_keys() -> None:
+    """The skill's example config is what users copy, so a key rejected above is a
+    defect that reaches every reader rather than only the person who wrote it.
+
+    The rejections and the documentation drifted apart once already: the skill still
+    taught `disable_convergence_check`, `coder` and `evaluator` after all three had
+    become errors, so following it produced a run that died at config validation.
+    """
+    import re
+    from pathlib import Path
+
+    import yaml
+
+    skill = (
+        Path(__file__).resolve().parents[1]
+        / "src"
+        / "nemo_experimentalist_plugin"
+        / "skills"
+        / "nemo-experimentalist"
+        / "SKILL.md"
+    ).read_text(encoding="utf-8")
+
+    fields = set(EvolutionaryOptimizerConfig.model_fields)
+    checked = 0
+    for block in re.findall(r"```yaml\n(.*?)```", skill, re.DOTALL):
+        data = yaml.safe_load(block)
+        if not isinstance(data, dict) or "max_rounds" not in data:
+            continue  # not a run config
+        checked += 1
+        unknown = sorted(set(data) - fields)
+        assert not unknown, f"SKILL.md documents keys the schema does not have: {unknown}"
+        EvolutionaryOptimizerConfig.model_validate(data)
+
+    assert checked, "found no run-config example in SKILL.md; the block matcher is wrong"
+
+
+def test_every_default_component_resolves() -> None:
+    """A default naming a component nothing registers is a run that dies at round 0.
+
+    Checked over the config's own defaults rather than a hardcoded list, so a role added
+    later is covered without anyone remembering to extend this.
+    """
+    from nemo_experimentalist_plugin.experimentalist.registry import resolve
+
+    config = EvolutionaryOptimizerConfig()
+    roles = {
+        "strategy": config.strategy,
+        "builder": config.builder,
+        "proposer": config.proposer,
+        "outcome-evaluator": config.outcome_evaluator,
+        "selector": config.selector,
+        "root-cause-analyzer": config.analyzer,
+        "terminator": config.terminator,
+        "trajectory-scorer": config.trajectory_scorer,
+    }
+    unresolvable = {role: name for role, name in roles.items() if name is not None and resolve(role, name) is None}
+
+    assert not unresolvable, f"defaults naming components nothing registers: {unresolvable}"
diff --git a/plugins/nemo-experimentalist/tests/test_local_backend_projection.py b/plugins/nemo-experimentalist/tests/test_local_backend_projection.py
index f815b6407d..db23fe39e8 100644
--- a/plugins/nemo-experimentalist/tests/test_local_backend_projection.py
+++ b/plugins/nemo-experimentalist/tests/test_local_backend_projection.py
@@ -8,11 +8,13 @@
 """
 
 from pathlib import Path
-from types import SimpleNamespace
+from typing import cast
 from unittest.mock import AsyncMock
 
 import pytest
-from nemo_experimentalist_plugin.entities import Candidate, ExperimentRun
+from doubles import fake_client, make_candidate
+from nemo_experimentalist_plugin.entities import ExperimentRun
+from nemo_experimentalist_plugin.experimentalist.experiment_mirror import ExperimentMirror
 from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import LocalExperimentalistBackend
 from nemo_experimentalist_plugin.experimentalist.result import ExperimentalistResult
 
@@ -20,7 +22,7 @@
 
 
 def _run() -> ExperimentRun:
-    return ExperimentRun(workspace="default", agent="a", config_snapshot={}, status="running", rounds_completed=0)
+    return ExperimentRun(workspace="default", agent="a", config_snapshot={}, status="running", progress_completed=0)
 
 
 async def test_no_projection_without_client(tmp_path: Path) -> None:
@@ -34,7 +36,7 @@ async def test_no_projection_without_client(tmp_path: Path) -> None:
 
 async def test_create_run_projects_when_client_present(tmp_path: Path) -> None:
     # A platform client is present → create_run best-effort projects (ensure_group).
-    be = LocalExperimentalistBackend(client=SimpleNamespace(), path=tmp_path)
+    be = LocalExperimentalistBackend(client=fake_client(), path=tmp_path)
     be._mirrors["default"] = AsyncMock()  # injected so no real SDK call is made
     await be.create_run(workspace="default", run=_run())
     be._mirrors["default"].ensure_group.assert_awaited_once()
@@ -42,21 +44,21 @@ async def test_create_run_projects_when_client_present(tmp_path: Path) -> None:
 
 
 async def test_create_candidate_projects_when_client_present(tmp_path: Path) -> None:
-    be = LocalExperimentalistBackend(client=SimpleNamespace(), path=tmp_path)
+    be = LocalExperimentalistBackend(client=fake_client(), path=tmp_path)
     be._mirrors["default"] = AsyncMock()
     await be.create_candidate(
         workspace="default",
-        candidate=Candidate(run_id="run-1", label="agent-0", round=0, optimization="baseline"),
+        candidate=make_candidate(run_id="run-1", label="agent-0", generation=0, description="baseline"),
     )
     be._mirrors["default"].project_candidate.assert_awaited_once()
 
 
 async def test_persist_result_projects_finalize(tmp_path: Path) -> None:
-    be = LocalExperimentalistBackend(client=SimpleNamespace(), path=tmp_path)
+    be = LocalExperimentalistBackend(client=fake_client(), path=tmp_path)
     be._mirrors["default"] = AsyncMock()
     await be.persist_result(
         workspace="default",
-        result=ExperimentalistResult(summary="done", run_id="run-1", rounds_completed=1, winner=None),
+        result=ExperimentalistResult(summary="done", run_id="run-1", progress_completed=1, winner=None),
     )
     be._mirrors["default"].finalize.assert_awaited_once()
 
@@ -67,8 +69,8 @@ class _BoomMirror:
         async def ensure_group(self, _run: ExperimentRun) -> None:
             raise RuntimeError("platform down")
 
-    be = LocalExperimentalistBackend(client=SimpleNamespace(), path=tmp_path)
-    be._mirrors["default"] = _BoomMirror()
+    be = LocalExperimentalistBackend(client=fake_client(), path=tmp_path)
+    be._mirrors["default"] = cast(ExperimentMirror, _BoomMirror())
     out = await be.create_run(workspace="default", run=_run())  # must NOT raise
     assert out.id
     assert (tmp_path / "eval-and-optimize" / "run.json").exists()
diff --git a/plugins/nemo-experimentalist/tests/test_metric_contract.py b/plugins/nemo-experimentalist/tests/test_metric_contract.py
index 753967a869..1b5f0f424a 100644
--- a/plugins/nemo-experimentalist/tests/test_metric_contract.py
+++ b/plugins/nemo-experimentalist/tests/test_metric_contract.py
@@ -4,11 +4,11 @@
 import pytest
 from nemo_experimentalist_plugin.config import (
     EvolutionaryOptimizerConfig,
-    MetricTarget,
     has_metric_dimensions,
     pareto_objectives,
+    with_insight_objective,
 )
-from nemo_experimentalist_plugin.experimentalist.components.loop import _with_insight_objective
+from nemo_experimentalist_plugin.entities import MetricTarget
 
 
 def test_metric_contract_supports_multiple_objective_metrics() -> None:
@@ -93,7 +93,7 @@ def test_insight_metrics_become_objectives_and_existing_targets_become_guardrail
         }
     )
 
-    effective = _with_insight_objective(config, ("uses_required_tool", "cites_source"))
+    effective = with_insight_objective(config, ("uses_required_tool", "cites_source"))
 
     assert [target.name for target in effective.objective_function] == ["uses_required_tool", "cites_source"]
     assert all(target.direction == "maximize" for target in effective.objective_function)
diff --git a/plugins/nemo-experimentalist/tests/test_resolve.py b/plugins/nemo-experimentalist/tests/test_resolve.py
index f216d90cd3..14f5833e36 100644
--- a/plugins/nemo-experimentalist/tests/test_resolve.py
+++ b/plugins/nemo-experimentalist/tests/test_resolve.py
@@ -9,7 +9,7 @@
 
 import pytest
 import yaml
-from nemo_experimentalist_plugin.experimentalist.components.loop import EvolutionaryOptimizerConfig
+from nemo_experimentalist_plugin.experimentalist.strategies.evolutionary import EvolutionaryOptimizerConfig
 from nemo_experimentalist_plugin.profile import load_profile
 from nemo_experimentalist_plugin.resolve import (
     ResolveError,
@@ -814,11 +814,8 @@ def test_config_unknown_top_level_key_is_tolerated(tmp_path: Path) -> None:
     [
         {"storage": {"publish_winer": True}},
         {"source": {"clone_dept": 1}},
-        {"coder": {"max_fix_atempts": 1}},
-        {"analyzer": {"rationalizer": {"max_summary_token": 100}}},
-        {"goal_config": {"max_dept": 2}},
     ],
-    ids=["storage", "source", "coder", "deep-analyzer", "goal-config"],
+    ids=["storage", "source"],
 )
 def test_config_unknown_typed_nested_key_is_tolerated(tmp_path: Path, config_payload: dict) -> None:
     profile = load_profile(make_profile_tree(tmp_path))
@@ -843,11 +840,11 @@ def test_evaluator_payload_remains_intentionally_open(tmp_path: Path) -> None:
             profile=profile,
             scratch_dir=tmp_path / "s",
             insight="ins-1",
-            config_payload={"evaluator": {"plugin_specific_option": {"nested": True}}},
+            config_payload={"outcome_evaluator_config": {"plugin_specific_option": {"nested": True}}},
         )
     )
 
-    assert inputs.config.evaluator == {"plugin_specific_option": {"nested": True}}
+    assert inputs.config.outcome_evaluator_config == {"plugin_specific_option": {"nested": True}}
 
 
 def test_config_invalid_value_is_wrapped_with_source(tmp_path: Path) -> None:
@@ -932,16 +929,103 @@ def test_run_config_takes_no_environment_override(monkeypatch) -> None:
     assert EvolutionaryOptimizerConfig.model_validate({"max_rounds": 15}).max_rounds == 15
 
 
-def test_component_configs_are_the_component_owned_classes() -> None:
-    """The tree must hold the components' own classes, not re-declared twins."""
+def test_a_components_settings_are_validated_against_its_own_model() -> None:
+    """Each `<role>_config` is a plain mapping, validated by the component that reads it.
+
+    Pinning these fields to first-party classes made a third-party component selectable
+    but not configurable: `builder: acme-random` resolved, and there was no way to pass
+    acme's settings, because the run-config schema decided the type. The component owns
+    its schema instead, and declares it as `config_type`.
+    """
     from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
-    from nemo_experimentalist_plugin.experimentalist.components.analyzer import AnalyzerConfig
-    from nemo_experimentalist_plugin.experimentalist.components.coder import CoderConfig
-    from nemo_experimentalist_plugin.experimentalist.components.goal_tree import GoalTreeConfig
-    from nemo_experimentalist_plugin.experimentalist.components.proposer import ProposerConfig
-
-    cfg = EvolutionaryOptimizerConfig()
-    assert type(cfg.coder) is CoderConfig
-    assert type(cfg.analyzer) is AnalyzerConfig
-    assert type(cfg.proposer) is ProposerConfig
-    assert type(cfg.goal_config) is GoalTreeConfig
+    from nemo_experimentalist_plugin.experimentalist.registry import Component, load_plugins
+
+    load_plugins()
+    config = EvolutionaryOptimizerConfig()
+    for field in (
+        "builder_config",
+        "analyzer_config",
+        "proposer_config",
+        "trajectory_scorer_config",
+        "selector_config",
+        "terminator_config",
+        "outcome_evaluator_config",
+    ):
+        assert isinstance(getattr(config, field), dict), f"{field} must stay open for a third-party component"
+
+    undeclared = {
+        f"{role}:{name}"
+        for (role, name), cls in Component._registry.items()
+        if cls.__module__.startswith("nemo_experimentalist_plugin.") and cls.config_type is None
+    }
+    # `import` is the one component that genuinely takes no settings: it forks the agent
+    # under test and commits it unchanged.
+    assert undeclared == {"builder:import"}, f"components with settings but no config_type: {undeclared}"
+
+
+def test_a_third_party_components_settings_reach_it_unchanged() -> None:
+    """The point of the mapping: a component this schema has never heard of is configurable."""
+    from nemo_experimentalist_plugin.experimentalist.registry import Component, get_component
+    from pydantic import BaseModel
+
+    class AcmeSettings(BaseModel):
+        beam_width: int = 1
+
+    class AcmeSelector(Component):
+        role = "selector"
+        name = "acme-beam"
+        config_type = AcmeSettings
+
+        def __init__(self, config: AcmeSettings | None = None) -> None:
+            self.config = config
+
+    try:
+        built = get_component("selector", "acme-beam", config={"beam_width": 7})
+        assert isinstance(built.config, AcmeSettings), "settings were not validated by the component's own model"
+        assert built.config.beam_width == 7
+    finally:
+        Component._registry.pop(("selector", "acme-beam"), None)
+
+
+def test_both_construction_paths_validate_a_components_settings(tmp_path: Path) -> None:
+    """`get_component` and `ctx.component` must agree, or the check is decorative.
+
+    The context builds components its own way -- it narrows the run-scoped arguments to
+    those the constructor names -- so validation added to one path silently skipped the
+    other. The terminator and trajectory-scorer are built through the context, so their
+    settings reached them as raw mappings and a misspelled option was never rejected.
+    """
+    import pytest
+    from doubles import FakeBackend, make_context
+    from nemo_experimentalist_plugin.experimentalist.registry import Component, get_component
+    from pydantic import BaseModel
+
+    class Strict(BaseModel):
+        model_config = {"extra": "forbid"}
+        depth: int = 1
+
+    class Probe(Component):
+        role = "terminator"
+        name = "probe-strict"
+        config_type = Strict
+
+        def __init__(self, config: Strict | None = None, **_: object) -> None:
+            self.config = config
+
+    try:
+        ctx = make_context(root=tmp_path, backend=FakeBackend())
+
+        direct = get_component("terminator", "probe-strict", config={"depth": 3})
+        through_context = ctx.component("terminator", "probe-strict", config={"depth": 3})
+
+        assert isinstance(direct.config, Strict), "get_component did not validate"
+        assert isinstance(through_context.config, Strict), "ctx.component did not validate"
+
+        for build in (
+            lambda: get_component("terminator", "probe-strict", config={"depht": 3}),
+            lambda: ctx.component("terminator", "probe-strict", config={"depht": 3}),
+        ):
+            with pytest.raises(Exception, match="depht|extra"):
+                build()
+    finally:
+        Component._registry.pop(("terminator", "probe-strict"), None)
diff --git a/plugins/nemo-experimentalist/tests/test_winner_record.py b/plugins/nemo-experimentalist/tests/test_winner_record.py
new file mode 100644
index 0000000000..338a24be35
--- /dev/null
+++ b/plugins/nemo-experimentalist/tests/test_winner_record.py
@@ -0,0 +1,123 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""``run.json``'s ``winner_agent`` is the winner's label, and it must stay that way.
+
+Every artifact a run writes is filed under the label -- ``agents/agent-3/``,
+``results/agent-3-validation/`` -- so a consumer that reads ``winner_agent`` is
+reading it to build one of those paths. Writing the candidate id there instead
+produces a value that resolves to nothing: no error, just an empty lookup, which
+downstream reads as "the winner has no results" rather than as a broken reference.
+
+That is not hypothetical. The field held the id for one revision of this branch,
+and the failure it produced was a smoke-agent gate reporting a *regression* on a
+control task the baseline answers perfectly.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+from doubles import make_candidate
+from nemo_experimentalist_plugin.experimentalist.components.models import Candidate
+from nemo_experimentalist_plugin.experimentalist.experimentalist_backend import load_winner
+
+
+def _write_run(root: Path, *, winner_agent: str | None, candidates: list[Candidate]) -> Path:
+    """Lay out a finished run the way the runner does: records by id, run.json by label."""
+    eo = root / "eval-and-optimize"
+    (eo / "candidates").mkdir(parents=True)
+    for candidate in candidates:
+        payload = json.loads(candidate.model_dump_json())
+        payload["id"] = candidate.id
+        (eo / "candidates" / f"{candidate.id}.json").write_text(json.dumps(payload), encoding="utf-8")
+    (eo / "run.json").write_text(json.dumps({"status": "completed", "winner_agent": winner_agent}), encoding="utf-8")
+    return eo
+
+
+def _candidate(label: str, generation: int) -> Candidate:
+    """`make_candidate` gives id and label different strings, which is the whole point here."""
+    return make_candidate(label=label, generation=generation)
+
+
+def test_load_winner_resolves_the_label_to_its_record(tmp_path: Path) -> None:
+    """The records are filed by id, so the label has to be resolved rather than joined."""
+    winner = _candidate("agent-1", 1)
+    eo = _write_run(tmp_path, winner_agent="agent-1", candidates=[_candidate("agent-0", 0), winner])
+
+    assert load_winner(eo).label == "agent-1"
+
+
+def test_load_winner_rejects_a_label_no_candidate_carries(tmp_path: Path) -> None:
+    """A dangling reference must say so rather than resolving to nothing."""
+    eo = _write_run(tmp_path, winner_agent="agent-9", candidates=[_candidate("agent-0", 0)])
+
+    with pytest.raises(FileNotFoundError, match="agent-9"):
+        load_winner(eo)
+
+
+def test_load_winner_rejects_a_candidate_id(tmp_path: Path) -> None:
+    """The regression this file exists for: an id in the field resolves to nothing.
+
+    Writing the id is what a caller does when it reaches for the obvious attribute,
+    so the failure must be loud rather than an empty result set.
+    """
+    winner = _candidate("agent-1", 1)
+    eo = _write_run(tmp_path, winner_agent=winner.id, candidates=[winner])
+
+    with pytest.raises(FileNotFoundError):
+        load_winner(eo)
+
+
+def test_a_run_with_no_winner_is_an_error_not_a_none(tmp_path: Path) -> None:
+    eo = _write_run(tmp_path, winner_agent=None, candidates=[_candidate("agent-0", 0)])
+
+    with pytest.raises(ValueError, match="without a selected winner"):
+        load_winner(eo)
+
+
+def test_the_label_is_usable_as_a_path_component(tmp_path: Path) -> None:
+    """What the field is *for*: the smoke-agent gate and the loop e2e suites read it
+    and index `agents/` and `results/` with the result."""
+    winner = _candidate("agent-1", 1)
+    eo = _write_run(tmp_path, winner_agent="agent-1", candidates=[winner])
+    for name in ("agents/agent-1", "results/agent-1-validation"):
+        (eo / name).mkdir(parents=True)
+
+    label = json.loads((eo / "run.json").read_text())["winner_agent"]
+
+    assert (eo / "agents" / label).is_dir()
+    assert (eo / "results" / f"{label}-validation").is_dir()
+
+
+def test_every_run_critical_write_is_atomic() -> None:
+    """`run.json` and `candidates/<id>.json` decide whether a run can resume.
+
+    A plain `write_text` truncates before writing, so a process killed mid-write leaves a
+    half-written file: `run.json` stops parsing and `list_candidates` raises, which loses
+    the whole run rather than one record. `_atomic_write` writes a sibling and renames.
+
+    Checked over the source rather than by killing a process, because the failure needs a
+    crash at one specific instant to reproduce.
+    """
+    import re
+
+    backend = (
+        Path(__file__).resolve().parents[1]
+        / "src"
+        / "nemo_experimentalist_plugin"
+        / "experimentalist"
+        / "experimentalist_backend.py"
+    ).read_text(encoding="utf-8")
+
+    plain = [
+        line.strip()
+        for line in backend.splitlines()
+        if re.search(r"\.write_text\(", line)
+        and "temporary.write_text" not in line  # _atomic_write's own write
+        and "report_path" not in line  # OPTIMIZATION.md: regenerated, never read back
+    ]
+
+    assert not plain, f"run-critical writes that truncate in place: {plain}"
diff --git a/pyproject.toml b/pyproject.toml
index 7e29686bd1..439dbc3b21 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -100,6 +100,9 @@ dev = [
   "nvidia-nat-atif>=1.9.0a20260811,<1.10", # ATIF schema models for agentic-use trajectory validation
   "nemo-platform-sdk-tools",       # Include SDK/license tool migration target for testing
   "nmp-build-tools",               # Build hook helpers imported by package-local hatch_build.py files
+  # Out-of-tree Experimentalist strategy. Without it installed, the tests proving a third-party
+  # package can ship a component skip silently -- which is how a broken one went unnoticed.
+  "acme-strategies ; python_full_version < '3.14'",
   "nmp-dev-mcp",                   # Include MCP dev tools
   # These are the dev dependencies from `sdk/python/nemo-platform`.
   # Including here until we find a better way to include them.
@@ -369,6 +372,7 @@ models = { workspace = true }
 nemo-platform-sdk = { workspace = true }
 nemo-platform = { workspace = true }
 nemo-platform-ext = { workspace = true }
+acme-strategies = { workspace = true }
 nemo-platform-sdk-tools = { workspace = true }
 nmp-core-mcp = { workspace = true }
 nemo-nb = { workspace = true }
@@ -476,6 +480,9 @@ members = [
   "plugins/nemo-insights",
   "plugins/nemo-eval-author",
   "plugins/nemo-experimentalist",
+  # Not shipped. An out-of-tree component package, installed so the tests that prove the
+  # plugin mechanism actually run instead of being skipped by `importorskip`.
+  "plugins/nemo-experimentalist/examples/acme-strategies",
   "plugins/nemo-agents/examples/calculator-agent",
   "plugins/nemo-agents/examples/email-phishing-analyzer",
   "plugins/nemo-agents/examples/email-security-analyst",
diff --git a/uv.lock b/uv.lock
index 4975a7713c..34aee0e1c8 100644
--- a/uv.lock
+++ b/uv.lock
@@ -17,6 +17,7 @@ supported-markers = [
 
 [manifest]
 members = [
+    "acme-strategies",
     "data-designer-nemo",
     "filesets",
     "garak-api",
@@ -176,6 +177,17 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a8/db/253133d7e7cb40d3af384bb2f5c0b4a2b7fdcffbc95c688cc67a20a3c103/accelerate-1.14.0-py3-none-any.whl", hash = "sha256:e94390c2863b873be18f623f9df48a0d8fe5eff13ea7f1a00092b0a7904888c6", size = 389246, upload-time = "2026-06-11T13:45:50.477Z" },
 ]
 
+[[package]]
+name = "acme-strategies"
+version = "0.1.0"
+source = { editable = "plugins/nemo-experimentalist/examples/acme-strategies" }
+dependencies = [
+    { name = "nemo-experimentalist-plugin", marker = "(platform_machine == 'arm64' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "nemo-experimentalist-plugin" }]
+
 [[package]]
 name = "aioboto3"
 version = "15.5.0"
@@ -6595,6 +6607,7 @@ cpu-tasks = [
     { name = "nmp-platform", marker = "(platform_machine == 'arm64' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
 ]
 dev = [
+    { name = "acme-strategies", marker = "(platform_machine == 'arm64' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
     { name = "aiohttp", marker = "(platform_machine == 'arm64' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
     { name = "aioresponses", marker = "(platform_machine == 'arm64' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
     { name = "aiosqlite", marker = "(platform_machine == 'arm64' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },
@@ -6816,6 +6829,7 @@ cpu-tasks = [
     { name = "nmp-platform", editable = "packages/nmp_platform" },
 ]
 dev = [
+    { name = "acme-strategies", marker = "python_full_version < '3.14'", editable = "plugins/nemo-experimentalist/examples/acme-strategies" },
     { name = "aiohttp", specifier = ">=3.14.1" },
     { name = "aioresponses", specifier = ">=0.7.8" },
     { name = "aiosqlite", specifier = ">=0.20.0" },