Latest V2 improvement to dev: verifier hardening, QD evolution improvements, and workflow runner isolation

README.md

@@ -104,10 +104,10 @@ Five layers, wired through small dataclass schemas — full details in [`docs/co
 
 Workflows are **full Python programs**, mutated as source code. The **code-as-genotype** is the workflow file; the phenotype is whatever it produces in the workspace.
 
-- **Selection: Quality-Diversity archive** (**MAP-Elites**-style) — max population of 50, `qd_score = (1−w)·quality + w·novelty` (`w=0.4`). **Novelty search** uses k-NN distance (`k=25`) over a **behaviour descriptor** `[n_agents, n_edges, n_branches, prompt_chars]`. Parents drawn by inverse-child-count roulette so the archive spreads.
-- **Variation: stagnation-driven scope** — mutation boldness is a continuous function of how much the last 4 prompt gradients repeat themselves. Near-winners stay protected. Scope bands run from "prompt-only tweak" to "complete topology rethink."
-- **Crossover** — ~30 % of generations combine two parents, strongest-first.
-- **Cold start** — when the archive is empty, a similarity-filtered scan of past runs on disk (MiniLM cosine ≥ 0.5) seeds the search. Useful workflows transfer across tasks.
+- **Selection: Quality-Diversity archive** (**MAP-Elites**-style) — max population of 50, `qd_score = (1−w)·quality + w·novelty` (`w = novelty_weight = 0.25`). **Novelty search** uses k-NN distance (`k = 15`) over the **failure-fingerprint** behaviour descriptor — a 6-D vector of centered per-source pass rates from the verifier (sources A–F). Parents drawn by inverse-child-count roulette so the archive spreads (`MAX_CHILDREN_PER_PARENT = 2`).
+- **Variation: Rechenberg-1/5 + plateau-driven scope** — mutation boldness blends the success rate of the last 5 scored offspring (Rechenberg 1/5 rule, threshold `0.20`) with an `iters_since_improvement` plateau counter (patience `6`). Near-winners (parent score > 0.95) get a damper. Scope bands run from `EXPLOITATION` (point mutation) to `RE-SPECIATION` (clean-slate redesign), gated by an effective-boldness threshold (`< 0.35 / 0.50 / 0.65 / 0.90 / 1.01`).
+- **Crossover** — by default ~10 % of generations combine two parents, strongest-first, with offspring hard-capped at the highest parent agent count.
+- **Cold start** — when the archive is empty, a similarity-filtered scan of past runs on disk (MiniLM cosine ≥ 0.8) seeds the search. Useful workflows transfer across tasks.
 
 Full mechanics: [`docs/concepts/evolution-engine.md`](./docs/concepts/evolution-engine.md).
 

config.py

@@ -38,18 +38,18 @@ class Config:
     def __init__(self):
 
         # workspace configuration
-        self.workspace_dir = "/Users/cnrs/Documents/repository/Toolomics/workspace"
+        self.workspace_dir = "/Users/mlg/Documents/CNRS/toolomics/workspace"
 
         # MCPs server discovery
         self.discovery_addresses: list[AddressMCP] = [
-            AddressMCP(ip="0.0.0.0", port_min=5000, port_max=5100)
+            AddressMCP(ip="0.0.0.0", port_min=5000, port_max=5200)
         ]
 
         # LLMs choices
         self.planner_llm_model: str = "openrouter/z-ai/glm-5.1"
         self.workflow_llm_model: str = "openrouter/z-ai/glm-5.1"
-        self.smolagent_model_id: str = "openrouter/deepseek/deepseek-v3.2"
-        self.judge_model = "openrouter/minimax/minimax-m3"
+        self.smolagent_model_id: str = "openrouter/qwen/qwen3.5-122b-a10b"
+        self.judge_model = "openrouter/deepseek/deepseek-v4-flash"
         self.capsule_namer_model = "openrouter/deepseek/deepseek-v4-flash"
         self.engine_name: str = "litellm" # for smolagent
 
@@ -69,10 +69,19 @@ def __init__(self):
 
         # learning parameters
         self.learned_score_threshold = 0.94
-        self.max_learning_evolve_iterations = 35
+        self.max_learning_evolve_iterations = 10
+
+        # QD novelty + length penalty (open-ended modes)
+        #  "archive_knn" (default) or "k-NN archive"
+        self.novelty_comparison: str = "archive_knn"
+        self.novelty_previous_n: int = 5
+        # Length penalty: genotype size at which the penalty starts to
+        # grow; lambda is small so it only breaks near-ties.
+        self.length_penalty_baseline_chars: int = 8000
+        self.length_penalty_lambda: float = 0.05
 
         # evaluation concurrency settings
-        self.max_concurrent_eval_tasks: int = 2  # Number of concurrent tasks for CSV evaluation mode
+        self.max_concurrent_eval_tasks: int = 1  # Number of concurrent tasks for CSV evaluation mode
 
         # folder paths for workflow pre-defined code
         self.schema_code_path: str = "sources/modules/state_schema.py"
@@ -97,7 +106,7 @@ def __init__(self):
         self.openrouter_quantizations_by_model: dict[str, list[str] | None] = {}
         self.default_openrouter_quantizations: list[str] = ["bf16", "fp16", "fp8"]
         # runner settings
-        self.runner_default_python_version: str = "3.10"
+        self.runner_default_python_version: str = "3.12"
         self.runner_default_timeout: int = 10800
         # Per-agent (SmolAgentFactory) execution timeout in seconds. Injected into
         # the generated workflow as AGENT_EXECUTION_TIMEOUT. 3600 = 1 hour.
@@ -215,6 +224,10 @@ def jsonify(
             "max_tokens": self.max_tokens,
             "learned_score_threshold": self.learned_score_threshold,
             "max_learning_evolve_iterations": self.max_learning_evolve_iterations,
+            "novelty_comparison": self.novelty_comparison,
+            "novelty_previous_n": self.novelty_previous_n,
+            "length_penalty_baseline_chars": self.length_penalty_baseline_chars,
+            "length_penalty_lambda": self.length_penalty_lambda,
             "schema_code_path": self.schema_code_path,
             "smolagent_factory_code_path": self.smolagent_factory_code_path,
             "runs_capsule_dir": self.runs_capsule_dir,
@@ -257,6 +270,16 @@ def from_json(self, data: dict[str, Any]) -> None:
         self.max_learning_evolve_iterations = data.get(
             "max_learning_evolve_iterations", self.max_learning_evolve_iterations
         )
+        self.novelty_comparison = data.get("novelty_comparison", self.novelty_comparison)
+        self.novelty_previous_n = int(
+            data.get("novelty_previous_n", self.novelty_previous_n)
+        )
+        self.length_penalty_baseline_chars = int(
+            data.get("length_penalty_baseline_chars", self.length_penalty_baseline_chars)
+        )
+        self.length_penalty_lambda = float(
+            data.get("length_penalty_lambda", self.length_penalty_lambda)
+        )
         self.schema_code_path = data.get("schema_code_path", self.schema_code_path)
         self.smolagent_factory_code_path = data.get(
             "smolagent_factory_code_path", self.smolagent_factory_code_path
@@ -319,6 +342,10 @@ def __str__(self) -> str:
         lines.append(f"  max_tokens={self.max_tokens}")
         lines.append(f"  learned_score_threshold={self.learned_score_threshold}")
         lines.append(f"  max_learning_evolve_iterations={self.max_learning_evolve_iterations}")
+        lines.append(f"  novelty_comparison={self.novelty_comparison}")
+        lines.append(f"  novelty_previous_n={self.novelty_previous_n}")
+        lines.append(f"  length_penalty_baseline_chars={self.length_penalty_baseline_chars}")
+        lines.append(f"  length_penalty_lambda={self.length_penalty_lambda}")
         lines.append(f"  max_concurrent_eval_tasks={self.max_concurrent_eval_tasks}")
         lines.append(f"  schema_code_path={self.schema_code_path}")
         lines.append(f"  smolagent_factory_code_path={self.smolagent_factory_code_path}")

docs/DEVELOPER_GUIDE.md

@@ -105,7 +105,8 @@ mimosa-ai/
 │   │   ├── selection.py                   # SelectionPressure (greedy/tournament/novelty/QD)
 │   │   ├── variation_engine.py            # Mutation/crossover prompt assembly + annealing
 │   │   ├── workflow_selection.py          # Parent retrieval (archive draw / disk scan)
-│   │   ├── code_features.py               # AST → behaviour descriptor (4-vector)
+│   │   ├── failure_fingerprint.py         # Verifier verdicts → QD behaviour descriptor (6-D, centered)
+│   │   ├── code_features.py               # Legacy structural descriptor (offline analysis only)
 │   │   ├── lineage.py                     # parent → child sidecar records
 │   │   ├── orchestrator.py                # Grounding → factory → sandbox pipeline
 │   │   ├── workflow_factory.py            # Multi-agent workflow synthesis
@@ -255,9 +256,9 @@ Each recursive step:
 6. selects the next parent(s) and chooses mutation vs crossover,
 7. recurses.
 
-Termination: `overall_score > learned_score_threshold` (default 0.94) in
+Termination: `overall_score >= learned_score_threshold` (default 0.9) in
 `--learn` mode, or `max_depth` reached
-(`max_learning_evolve_iterations`, default 45; single-shot uses
+(`max_learning_evolve_iterations`, default 20; single-shot uses
 `max_depth=1`).
 
 ### 2. `SelectionPressure` — [`sources/core/selection.py`](https://github.com/HolobiomicsLab/Mimosa-AI/blob/main/sources/core/selection.py)
@@ -277,39 +278,45 @@ penalty `÷(1 + n_children_already)` and a hard
 ### 3. `VariationEngine` — [`sources/core/variation_engine.py`](https://github.com/HolobiomicsLab/Mimosa-AI/blob/main/sources/core/variation_engine.py)
 
 Prompt assembly for mutation and crossover. Mutation boldness is a
-continuous function of two evidence signals — population stagnation
-*and* the Rechenberg 1/5 success rate of recent offspring — not a fixed
-phase schedule.
-
-- `_compute_stagnation(window=4)` — mean pairwise MiniLM cosine
-  similarity over the last 4 non-failure prompt gradients, rescaled so
-  the unrelated baseline (`≈0.4`) maps to `0` and full repetition
-  (`≥0.8`) maps to `1`.
+continuous function of two evidence signals — an
+`iters_since_improvement` plateau counter *and* the Rechenberg 1/5
+success rate of recent offspring — not a fixed phase schedule.
+
+- `_iters_since_improvement()` — length of the trailing run of scored
+  offspring that did not strictly beat best-so-far (failures and
+  unscored entries skipped). Normalised as
+  `plateau = min(1, iters / _PLATEAU_PATIENCE)` with
+  `_PLATEAU_PATIENCE = 6`.
 - `_compute_success_rate(window=5)` — fraction of the last 5 scored
   offspring that strictly beat the running best at production time.
   The Rechenberg 1/5 success rule threshold is `0.20`.
 - `_get_prompt_step_size(parent_score)` — combines the two:
-    * cold start (no scored history yet) — `effective = raw_stagnation`,
-    * `success_rate < 0.20` — `effective = max(raw_stagnation, deficit)`
+    * cold start (fewer than two comparable scored offspring) —
+      `effective = 0.3 · plateau` (capped ramp),
+    * `success_rate < 0.20` — `effective = 0.5 · deficit + 0.5 · plateau`
        with `deficit = (0.20 − success_rate) / 0.20` (escalate),
-    * `success_rate ≥ 0.20` — `effective = raw_stagnation · (1 − progress)`
+    * `success_rate ≥ 0.20` — `effective = plateau · (1 − progress)`
        with `progress = min(1, (success_rate − 0.20) / (0.80 − 0.20))`
        (damp boldness in proportion to real progress),
     * near-finish floor: when `parent_score > 0.95`, multiply by
        `(1 − 0.5 · (parent_score − 0.95) / 0.05)` so a 0.96 parent isn't
-       gambled away one generation before early-stop.
+       gambled away one generation before early-stop,
+    * RE-SPECIATION gate: unless `iters_since_improvement ≥ 8` *and*
+      `success_rate ∈ {None, 0.0}`, `effective` is clamped to
+      `_RESPECIATION_CLAMP = 0.89`, just below the EXPLORATION/
+      RE-SPECIATION boundary at `0.90`.
   Then it grows the agent budget from the previous generation's count
   toward `max_possible_agents = 7` proportionally to `effective`, and
   samples the actual agent count with a Beta-Binomial biased upward by
   `effective`.
 
-| Effective boldness | Agent budget | Mutation scope (advisory)                                  |
-|--------------------|--------------|-------------------------------------------------------------|
-| <0.20              | ≈ current    | prompt-only little tweak                                    |
-| <0.40              | current+1    | prompt, handoff, tools — improve information flow           |
-| <0.60              | current+2    | significant redesign while keeping topology                 |
-| <0.80              | current+3    | bold rewire — restructure or grow the agent set             |
-| ≥0.80              | up to 7      | complete rethink — discard inherited topology / prompts     |
+| Effective boldness | Mutation scope (advisory)                                                   |
+|--------------------|-----------------------------------------------------------------------------|
+| < 0.35             | `EXPLOITATION` — point mutation: minor phrasing / prompt-adjective tweaks   |
+| < 0.50             | `ALIGNMENT` — interface optimization: refine handoff prompts, IO contracts  |
+| < 0.65             | `ADAPTATION` — component overhaul: rewrite lagging agent prompts, swap tools |
+| < 0.90             | `EXPLORATION` — macro structural mutation: add/merge agents, change routing |
+| ≥ 0.90             | `RE-SPECIATION` — clean-slate redesign of the multi-agent architecture      |
 
 Scope is an advisory line injected into the mutation prompt; the LLM
 may still pick any topology. The hard control is the agent-count
@@ -322,7 +329,7 @@ Two-mode parent retrieval:
 - **Steady state**: when `selection_pressure._archive` is populated, draws
   parents from the live session archive via QD-roulette.
 - **Cold start**: empty archive → similarity-filtered disk scan
-  (`cosine ≥ 0.5` on MiniLM embeddings of `original_task`, `score ≥ 0.05`)
+  (`cosine ≥ 0.8` on MiniLM embeddings of `original_task`, `score ≥ 0.1`)
   routed through the same `select_parents()` weighting.
 
 ### 5. `WorkflowOrchestrator` — [`sources/core/orchestrator.py`](https://github.com/HolobiomicsLab/Mimosa-AI/blob/main/sources/core/orchestrator.py)
@@ -400,7 +407,7 @@ EvolutionEngine.start_workflow_evolution(goal)
         ├─ SelectionPressure.validate_survivor() → archive admit?
         ├─ record_lineage()
         ├─ select next parent (archive QD-roulette)
-        ├─ choose crossover (~0.4 rate, once initial_population met) or mutation
+        ├─ choose crossover (default crossover_rate=0.1, once initial_population met) or mutation
         └─ recurse → stop on threshold OR max_depth
     ↓
 WorkspaceManager.restore_best(best_uuid)
@@ -464,20 +471,16 @@ For each generation:
    pre-installed (lazy one-shot install per process). Soft claims get a
    `pass/unsure/fail` LLM verdict against workspace previews + literature
    grounding (mapped to `1.0 / 0.5 / 0.0`).
-3. **Independent cheat detector**: present in the codebase but currently
-   **disabled** pending a rewrite. The aggregation path still has a slot
-   for `cheat_penalty`. Behavioral anti-cheat pressure today comes from
-   Source C's recompute-from-disk verifiers, the inverted-score "Used
-   fallback" claim type, and the anti-tautology tripwires.
+3. **Behavioral pressure against shortcut workflows** comes from Source
+   C's recompute-from-disk verifiers, the inverted-score "Used fallback"
+   claim type, and the anti-tautology tripwires.
 4. **Aggregation**:
    ```
-   overall = clamp(base_mean + info_bonus, 0, 1)
+   overall = clamp(base_mean, 0, 1)
    if any hard claim refuted:
        overall = min(overall, 0.99)        # _HARD_FAIL_CAP (soft, for now)
-   overall = max(0, overall - cheat_penalty)  # cheat_penalty = 0.0 today
    ```
-   where `info_bonus(n_hard_pass) = 0.05 · (1 - exp(-n_hard_pass / 8))`
-   (saturating reward for thoroughness).
+   `base_mean` is the importance-weighted mean of per-claim scores.
 5. **Prompt gradient** — plain-language single-sentence diagnosis
    prefixed with a short code name (e.g. `FALLBACK_ECFP_CLASSIFIER`). It
    is the **only** verifier signal the mutator sees, and recent history

docs/concepts/architecture.md

@@ -45,12 +45,13 @@ recursively evolves workflows, with help from:
   (improvement over baseline or `qd_score > admit_threshold`); capacity is
   curated by lowest-`qd_score` eviction.
 - **VariationEngine** — assembles mutation or crossover prompts, with an
-  evidence-driven mutation scope: boldness grows as recent prompt
-  gradients converge (the offspring keep failing the same way) *and* as
-  the Rechenberg 1/5 success rate of recent scored offspring drops
-  below 20 %. A near-finish floor only damps boldness once the parent
-  score is above 0.95, so near-winners aren't gambled away one
-  generation before early-stop.
+  evidence-driven mutation scope: boldness grows with an
+  `iters_since_improvement` plateau counter (patience `6`) *and* as the
+  Rechenberg 1/5 success rate of the last 5 scored offspring drops below
+  20 %. A near-finish floor only damps boldness once the parent score is
+  above 0.95, so near-winners aren't gambled away one generation before
+  early-stop. The top `RE-SPECIATION` band is hysteresis-gated and only
+  opens after `iters_since_improvement ≥ 8` with a zero success rate.
 - **WorkflowOrchestrator** — wraps "grounding → factory → sandbox" into one
   callable per generation.