fix(experimentalist): finalize when no improvements remain

Signed-off-by: Gaia Di Lorenzo <gdilorenzo@ethz.ch>

Author: Gaia Di Lorenzo

plugins/nemo-experimentalist/src/nemo_experimentalist_plugin/experimentalist/components/loop.py

@@ -810,6 +810,9 @@ async def _run(self, deps: ExperimentalistDeps) -> ExperimentalistResult:
                     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,

plugins/nemo-experimentalist/tests/experimentalist/test_loop_failure.py

@@ -8,9 +8,11 @@
 
 import pytest
 from nemo_experimentalist_plugin.config import EvolutionaryOptimizerConfig
-from nemo_experimentalist_plugin.entities import Candidate, ExperimentRun
+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
 
 
@@ -127,3 +129,80 @@ async def run(self, *args, **kwargs):
             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(
+        id="run-1",
+        workspace="default",
+        agent="agent",
+        config_snapshot={},
+        status="running",
+        rounds_completed=0,
+    )
+    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()