Next Evolution

╔═══════════════════════════════════════════════════════════════════════════════════════════════╗
║                                    O M N I E V O L V E                                        ║
║                    Unified LLM-Powered Evolutionary Optimization Engine                        ║
╚═══════════════════════════════════════════════════════════════════════════════════════════════╝

                              ┌──────────────────────────────────┐
                              │         ORCHESTRATOR              │
                              │  (async event loop, budget guard)  │
                              └────────────┬─────────────────────┘
                                           │
          ┌────────────────────────────────┼────────────────────────────────┐
          │                               │                                  │
  ┌───────▼────────┐            ┌────────▼────────┐              ┌──────────▼──────────┐
  │  POPULATION    │            │  LLM MUTATION   │              │   EVALUATION        │
  │  MANAGER       │◄──────────►│  ENGINE         │◄────────────►│   PIPELINE          │
  │                │            │                 │              │                     │
  │ MAP-Elites     │            │ Diff / Full /   │              │ Sandbox Exec        │
  │ Island Model   │            │ Cross / Reflect │              │ Cascade Filter      │
  │ Pareto Front   │            │ Failure-Driven  │              │ ASI Diagnostics     │
  │ Archive        │            │ Runtime-Aware   │              │ Early Stopping      │
  └───────┬────────┘            └────────┬────────┘              └──────────┬──────────┘
          │                              │                                   │
          │              ┌───────────────▼──────────────────┐               │
          │              │         KNOWLEDGE LAYER           │               │
          │              │                                   │               │
          │              │  ┌──────────────┐ ┌────────────┐ │               │
          │              │  │ Learning Logs│ │  Prompt    │ │               │
          │              │  │ (cross-pop.) │ │  Archive   │ │               │
          │              │  └──────────────┘ └────────────┘ │               │
          │              │  ┌──────────────┐ ┌────────────┐ │               │
          │              │  │ Skill Store  │ │  Meta-Recs │ │               │
          │              │  └──────────────┘ └────────────┘ │               │
          │              └──────────────────────────────────┘               │
          │                              │                                   │
          │              ┌───────────────▼──────────────────┐               │
          │              │      LLM ORCHESTRATOR             │               │
          │              │                                   │               │
          │              │  Flash-Haiku  ┐                   │               │
          │              │  Flash-Pro    ├── UCB1 Bandit     │               │
          │              │  o3-mini      │   + Thompson      │               │
          │              │  Sonnet-4.x   │   Sampling        │               │
          │              │  local model ─┘                   │               │
          │              │                                   │               │
          │              │  Prompt Co-Evolver (v2 archive)   │               │
          │              └──────────────────────────────────┘               │
          │                              │                                   │
          └──────────────────────────────┼───────────────────────────────────┘
                                         │
                          ┌──────────────▼───────────────────┐
                          │      SEARCH STRATEGY ROUTER       │
                          │                                   │
                          │  Evolutionary Loop (default)      │
                          │  AB-MCTS Tree Search (deep refine)│
                          │  Hybrid (pop. → tree → pop.)      │
                          └──────────────────────────────────┘
                                         │
                          ┌──────────────▼───────────────────┐
                          │      SAFETY & COST LAYER          │
                          │                                   │
                          │  Committed Budget Guard           │
                          │  Sandbox (Docker / subprocess)    │
                          │  Snapshot Rollback                │
                          │  Immutability Enforcement         │
                          └──────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────────┐
 │                        SINGLE EVOLUTIONARY STEP                                  │
 │                                                                                  │
 │  1. SAMPLE PARENTS                                                               │
 │     Population DB → power-law rank selection (ShinkaEvolve)                     │
 │                    + novelty-adjusted weights (Darwinian Evolver)                │
 │                    + Pareto frontier candidates (GEPA)                           │
 │                                                                                  │
 │  2. PRE-MUTATION NOVELTY CHECK (ShinkaEvolve 2-tier)                            │
 │     Embedding similarity → cosine threshold → SKIP if too similar               │
 │     LLM-as-judge → semantic novelty → SKIP if not novel                         │
 │     [Cost: ~0.001$ per check, saves ~0.50$ per skipped evaluation]              │
 │                                                                                  │
 │  3. CONTEXT ASSEMBLY                                                              │
 │     Inject: parent code + best solutions + learning logs + ASI diagnostics      │
 │             + prompt from co-evolved archive + runtime REPL state (optional)    │
 │                                                                                  │
 │  4. LLM MUTATION (bandit-selected model)                                         │
 │     Mode A: Diff patch (targeted, cheap, fast)                                  │
 │     Mode B: Full rewrite (creative, expensive)                                  │
 │     Mode C: Crossover (two parents → child)                                     │
 │     Mode D: Reflection-driven (ASI feedback → targeted fix)                     │
 │     Mode E: Failure-case-driven (specific test failure → fix)                   │
 │                                                                                  │
 │  5. POST-GENERATION VERIFICATION (Darwinian Evolver)                             │
 │     Quick syntax check + type check + mini-eval → REJECT if clearly wrong       │
 │     [Cost: ~0.05$ per check, saves full evaluation cost]                        │
 │                                                                                  │
 │  6. CASCADE EVALUATION (AlphaEvolve / OpenEvolve)                               │
 │     Stage 1: Fast cheap test subset → REJECT if score < threshold               │
 │     Stage 2: Medium test set → REJECT if fails                                  │
 │     Stage 3: Full evaluation → ASI diagnostics returned                         │
 │     Early stopping (Bayesian / CI) → stop when confident in outcome             │
 │                                                                                  │
 │  7. POPULATION UPDATE                                                             │
 │     MAP-Elites: insert if dominates cell                                        │
 │     Island Archive: keep top-K per island                                       │
 │     Pareto Front: update if non-dominated                                       │
 │                                                                                  │
 │  8. KNOWLEDGE UPDATE                                                             │
 │     Learning log: append (mutation_type, parent_ids, ASI, outcome, delta_score) │
 │     Prompt evolver: if outcome positive → reinforce prompt; if negative → mutate│
 │     Bandit update: record (model, cost, quality) → update UCB1 arm              │
 │     Meta-recommendations: every N steps → LLM synthesizes pattern insights      │
 │                                                                                  │
 │  9. SEARCH ROUTER CHECK                                                           │
 │     If island is stagnant (N steps, no improvement) → spawn AB-MCTS tree        │
 │     If tree search finds improvement → reinject to population                   │
 └─────────────────────────────────────────────────────────────────────────────────┘

LAYER 1: MAP-ELITES QUALITY-DIVERSITY GRID
┌────────────────────────────────────────────────────────┐
│  Feature Dimension 1 (e.g., code length, complexity)    │
│  Feature Dimension 2 (e.g., score on subset A vs. B)    │
│                                                          │
│  Each cell: best program achieving that (f1, f2) combo  │
│  Resolution: 20×20 = 400 cells per island               │
│  Behavioral descriptors computed post-evaluation         │
└────────────────────────────────────────────────────────┘
         ↕  periodic migration (top-K from each)
LAYER 2: ISLAND MODEL (Isolated Populations)
┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐
│  Island 1  │ │  Island 2  │ │  Island 3  │ │  Island N  │
│ (exploit)  │ │ (explore)  │ │ (diversity)│ │ (specialist│
│ diff-heavy │ │ full+cross │ │ beam search│ │  per task) │
└────────────┘ └────────────┘ └────────────┘ └────────────┘
         ↕  ring topology migration every M steps
LAYER 3: GLOBAL ARCHIVE (non-culled)
┌────────────────────────────────────────────────────────┐
│  All programs ever accepted (DGM-style expanding)       │
│  Indexed by embedding vector for retrieval              │
│  Used for crossover parent selection across islands     │
│  Compressed after 10K entries (keep skeleton + score)  │
└────────────────────────────────────────────────────────┘

def check_stagnation(island: Island, window: int = 50) -> bool:
    """Detect stagnation using exponential moving average of delta-score."""
    recent_scores = island.score_history[-window:]
    if len(recent_scores) < window:
        return False
    ema_delta = 0.0
    alpha = 0.1
    for i in range(1, len(recent_scores)):
        delta = recent_scores[i] - recent_scores[i-1]
        ema_delta = alpha * delta + (1 - alpha) * ema_delta
    return abs(ema_delta) < island.config.stagnation_epsilon  # e.g., 1e-4

def spawn_new_island(population_db: PopulationDB) -> Island:
    """Spawn new island seeded from diverse global archive samples."""
    seeds = population_db.archive.sample_diverse(
        n=5,
        method="maximin_distance",  # maximize min pairwise embedding distance
        temperature=1.5             # higher = more random diversity
    )
    return Island(seed_programs=seeds, mutation_config=IslandConfig.random())

# Prompt template (abbreviated)
You are improving a program. Current score: {score}.
Generate a unified diff that improves performance.
Focus on: {top_3_insights_from_learning_logs}
<<< PARENT PROGRAM >>>
{parent_code}
<<< BEST KNOWN PROGRAM >>>
{best_code}
Output ONLY a unified diff, no explanations.

# Prompt template (abbreviated)
Implement a novel algorithm for: {problem_description}
Inspirational approaches (do not copy exactly):
{top_diverse_programs}
Constraints: {fitness_function_description}
Key insights from successful mutations:
{meta_recommendations}

# Parent selection for crossover:
parent_a = island_A.sample(strategy="best")
parent_b = archive.sample_dissimilar(parent_a, method="embedding")
# Embedding distance > threshold ensures genuine diversity
assert cosine_distance(embed(parent_a), embed(parent_b)) > 0.3

# ASI context injected:
{
  "score": 0.73,
  "failed_test_cases": [{input, expected, actual, error_type}],
  "performance_profile": {bottleneck_function, runtime_ms},
  "diagnostic_message": "Stack overflow on input size > 1000",
  "suggested_fix_category": "recursion_depth"
}

# Learning log provides failure patterns:
failure_patterns = learning_log.get_recurring_failures(
    program_id=parent.id,
    min_occurrences=3
)
# Inject most frequent failure for targeted fix

# Runtime context injected:
repl_session = RuntimeREPL(program=parent_code)
trace = repl_session.execute_with_trace(test_input)
# LLM sees: intermediate variable values,
#           branch decisions, recursion depth,
#           memory allocation patterns

class MutationBandit:
    def __init__(self, modes: list[MutationMode], c: float = 0.3):
        self.modes = modes
        self.c = c
        self.counts = {m: 0 for m in modes}     # n_i
        self.rewards = {m: 0.0 for m in modes}  # cumulative delta-score

    def select(self) -> MutationMode:
        t = sum(self.counts.values()) + 1
        ucb_scores = {}
        for mode in self.modes:
            n_i = self.counts[mode]
            if n_i == 0:
                return mode  # ensure each mode tried at least once
            mu_hat = self.rewards[mode] / n_i
            ucb_scores[mode] = mu_hat + self.c * math.sqrt(math.log(t) / n_i)
        return max(ucb_scores, key=ucb_scores.get)

    def update(self, mode: MutationMode, delta_score: float):
        self.counts[mode] += 1
        self.rewards[mode] += max(0.0, delta_score)  # only reward improvements

def composite_weight(programs: list[Program], alpha: float, beta: float) -> np.ndarray:
    n = len(programs)
    scores = np.array([p.fitness for p in programs])
    ranks = n + 1 - np.argsort(np.argsort(scores))  # rank 1 = best

    # Fitness weight
    w_fit = ranks.astype(float) ** (-alpha)

    # Novelty weight (anti-oversampling)
    select_counts = np.array([p.select_count for p in programs])
    mu_select = select_counts.mean()
    w_nov = 1.0 / (1.0 + np.exp(beta * (select_counts - mu_select)))

    # Recency weight
    ages = np.array([p.age for p in programs])
    w_rec = np.exp(-0.01 * ages)

    # Composite
    w = w_fit * w_nov * w_rec
    return w / w.sum()

def select_from_pareto(pareto_front: list[Program], epsilon: float = 0.1) -> Program:
    if random.random() < epsilon:
        return random.choice(pareto_front)  # explore random Pareto member
    # Exploit: select program with highest hypervolume contribution
    return max(pareto_front, key=lambda p: p.hypervolume_contribution)

GENERATED PROGRAM
        │
        ▼
┌───────────────────────────────┐
│  STAGE 1: Embedding Similarity │  Cost: ~$0.001
│  cosine_sim(embed(new), embed(k-NN)) > threshold?  → REJECT
│  threshold = 0.92 (tunable)   │
└───────────────┬───────────────┘
                │ PASS
                ▼
┌───────────────────────────────┐
│  STAGE 2: LLM Novelty Judge   │  Cost: ~$0.005
│  "Is this mutation algorithmically novel? [YES/NO]"
│  Judge sees: new + k most similar archived programs
└───────────────┬───────────────┘
                │ YES (novel)
                ▼
┌───────────────────────────────┐
│  STAGE 3: Behavioral Novelty  │  Cost: 0 (during evaluation)
│  Post-eval: compute behavioral descriptor vector
│  (e.g., test case pass pattern, branch frequencies)
│  MAP-Elites cell placement uses behavioral descriptors
└───────────────────────────────┘

class NoveltyPreFilter:
    def __init__(self, model="text-embedding-3-small", threshold=0.92, k=10):
        self.model = model
        self.threshold = threshold
        self.k = k
        self.index = FaissIndex(dimension=1536)  # or ChromaDB, Qdrant

    def is_novel(self, program_code: str) -> bool:
        embedding = embed(program_code, model=self.model)
        if self.index.size() < self.k:
            self.index.add(embedding)
            return True  # insufficient history, always novel
        neighbors, distances = self.index.knn_query(embedding, k=self.k)
        max_similarity = max(1.0 - d for d in distances)
        if max_similarity > self.threshold:
            return False  # too similar to existing program
        self.index.add(embedding)
        return True

class HierarchicalModelBandit:
    def __init__(self, tiers: dict[str, list[LLMModel]]):
        self.tier_bandit = UCB1Bandit(arms=list(tiers.keys()), c=0.5)
        self.model_bandits = {
            tier: ThompsonSamplingBandit(arms=models, prior_alpha=1, prior_beta=1)
            for tier, models in tiers.items()
        }

    def select(self, context: MutationContext) -> LLMModel:
        # Override: use cheap model when budget is low
        if context.remaining_budget < context.total_budget * 0.1:
            return self.model_bandits["fast"].select()

        tier = self.tier_bandit.select()
        return self.model_bandits[tier].select()

    def update(self, model: LLMModel, tier: str,
               delta_score: float, cost: float, quality: float):
        # Reward = quality / cost (efficiency-aware)
        efficiency = quality / (cost + 1e-8)
        self.tier_bandit.update(tier, efficiency)
        self.model_bandits[tier].update(model, efficiency)

@dataclass
class ActionableSideInfo:
    # Required fields
    score: float                          # Primary fitness metric

    # Diagnostic fields (all optional, but recommended)
    failed_tests: list[FailedTest]        # Specific failed inputs
    performance_profile: PerformanceProfile  # Runtime bottlenecks
    error_type: str | None               # "timeout", "wrong_answer", "crash", etc.
    error_message: str | None

    # Structural analysis
    complexity_estimate: str | None       # "O(n^2)", "O(n log n)", etc.
    memory_usage_mb: float | None
    bottleneck_function: str | None      # Function consuming most time

    # Custom fields (domain-specific)
    custom_metrics: dict[str, Any] = field(default_factory=dict)

    # For prompt evolution: what would help next mutation?
    suggested_fix_approach: str | None    # e.g., "memoize recursive calls"
    blocking_insight: str | None          # Key insight needed to improve

@dataclass
class FailedTest:
    input: Any
    expected: Any
    actual: Any
    error_type: str     # "wrong_answer", "timeout", "exception"
    traceback: str | None

REFLECTION_PROMPT = """
You are improving an algorithm. Analyze the diagnostic feedback carefully before proposing changes.

## Current Program
```python
{program_code}

## 10. Component: Knowledge Sharing & Learning Logs

**Sources:**
`Learning log systemDarwinian Evolver`
`Meta-recommendationsShinkaEvolve`
`Skill storeGEPA Skills`

### 10.1 Learning Log Schema

The learning log is a **shared, cross-population memory**. Every mutation — successful or not — generates a log entry. LLMs read compressed summaries of this log when proposing new mutations.

```python
@dataclass
class LearningLogEntry:
    # Identity
    entry_id: UUID
    timestamp: datetime
    generation: int
    island_id: str

    # What was tried
    mutation_mode: MutationMode            # diff/full/cross/reflect/failure
    parent_program_ids: list[UUID]
    mutation_description: str             # 1-2 sentence summary of what changed

    # What happened
    pre_score: float
    post_score: float
    delta_score: float
    asi_before: ActionableSideInfo
    asi_after: ActionableSideInfo

    # Meta
    llm_model_used: str
    llm_cost_usd: float
    evaluation_time_s: float

    # Pattern tags (auto-generated by LLM summarizer)
    pattern_tags: list[str]   # e.g., ["memoization", "recursion_to_iter", "O(n2)_to_O(nlogn)"]
    outcome: Literal["improvement", "neutral", "regression", "crash"]

RAW LOG ENTRIES (individual mutations)
         │  Every 100 entries
         ▼
COMPRESSED SUMMARIES (LLM-generated, ~100 tokens each)
         │  Every 10 summaries
         ▼
INSIGHT DIGESTS (pattern clusters, ~50 tokens each)
         │  At query time
         ▼
RETRIEVED CONTEXT (top-K relevant by embedding similarity to current mutation)

class LearningLogRetriever:
    def get_relevant_context(
        self,
        current_program: str,
        mutation_mode: MutationMode,
        max_tokens: int = 2000
    ) -> str:
        # Embed current program + mutation mode description
        query_embedding = embed(current_program + str(mutation_mode))

        # Retrieve top-K most similar entries by pattern
        relevant_summaries = self.vector_store.similarity_search(
            query=query_embedding, k=10
        )
        # Retrieve top-K failure patterns matching current ASI
        if self.current_asi:
            failure_patterns = self.failure_index.get_similar(
                self.current_asi.error_type, k=5
            )

        # Retrieve top-K successful mutation patterns
        successful_patterns = self.success_index.get_top(k=5)

        # Format and truncate to max_tokens
        return self._format_context(relevant_summaries, failure_patterns,
                                    successful_patterns, max_tokens)

META_REC_PROMPT = """
Analyze these {N} mutation outcomes and extract 3-5 high-level insights.
For each insight: (1) state the principle, (2) show 2 examples that support it,
(3) state when to apply it.

Focus on: what types of changes consistently improve performance?
What approaches consistently fail? What patterns emerge across successful mutations?

Mutation history summary:
{compressed_log_summary}

Output as JSON: [{{"insight": str, "examples": [str], "apply_when": str}}]
"""

@dataclass
class Skill:
    name: str                      # e.g., "sliding_window_for_substring_search"
    description: str               # natural language description
    template_code: str             # illustrative code pattern
    applicable_patterns: list[str] # patterns that suggest this skill
    success_evidence: list[str]    # programs where applying improved score
    transfer_count: int            # times successfully transferred across models

PROMPT POPULATION (one per mutation mode)
┌──────────────────────────────────────────────────────────┐
│  Prompt_1: score=0.34, uses=120, delta_avg=+0.021         │
│  Prompt_2: score=0.41, uses=85,  delta_avg=+0.038  ← best│
│  Prompt_3: score=0.29, uses=60,  delta_avg=+0.011         │
│  Prompt_4: score=0.22, uses=40,  delta_avg=-0.003         │
└──────────────────────────────────────────────────────────┘
        │                           │
   Prompt selection            Prompt mutation
   (power-law rank)            (LLM generates new variant)
        │                           │
        └──────────────────────────►│
                                    ▼
                           New prompt evaluated by
                           downstream mutation quality

PROMPT_MUTATION_TEMPLATE = """
This mutation prompt has been used {n_times} times with average delta-score {avg_delta:.4f}.

Here are the most common failure patterns it produces:
{top_failure_patterns}

Here is the current prompt:
---
{current_prompt}
---

Generate an improved version of this prompt that:
1. Addresses the most common failure: "{top_failure}"
2. Preserves what's working (the prompt works well when: {success_contexts})
3. Adds explicit guidance about: {suggested_addition}

Output ONLY the new prompt text, no explanations.
"""

class SelfImprovementModule:
    def propose_improvement(self, component: str, current_config: dict) -> dict:
        """LLM proposes new configuration for mutable component."""
        snapshot = self.take_snapshot(component)

        proposed_config = self.llm_propose(
            component=component,
            current_config=current_config,
            performance_history=self.get_history(component, n=100),
            meta_recommendations=self.meta_rec_store.get_relevant(component)
        )
        return proposed_config, snapshot

    def evaluate_improvement(
        self, snapshot_id: UUID, proposed_config: dict,
        component: str, n_trials: int = 50
    ) -> bool:
        """A/B test: run N mutations with proposed vs current config."""
        results_proposed = self.run_with_config(proposed_config, n_trials)
        results_current = self.run_with_config(self.current_config, n_trials)

        # Statistical test: t-test, p < 0.05
        t_stat, p_value = scipy.stats.ttest_ind(results_proposed, results_current)
        improvement = np.mean(results_proposed) - np.mean(results_current)

        if p_value < 0.05 and improvement > 0:
            self.apply_config(proposed_config, component)
            self.log_improvement(component, improvement, snapshot_id)
            return True
        else:
            self.rollback_to_snapshot(snapshot_id)
            return False

class CommittedBudgetGuard:
    def __init__(self, total_budget_usd: float):
        self.total = total_budget_usd
        self._realized = 0.0
        self._inflight: dict[UUID, float] = {}  # call_id → estimated_cost
        self._lock = asyncio.Lock()

    async def reserve(self, estimated_cost: float) -> UUID | None:
        async with self._lock:
            committed = self._realized + sum(self._inflight.values())
            if committed + estimated_cost > self.total:
                return None  # budget exceeded, reject call
            call_id = uuid4()
            self._inflight[call_id] = estimated_cost
            return call_id

    async def settle(self, call_id: UUID, actual_cost: float):
        async with self._lock:
            estimated = self._inflight.pop(call_id, 0.0)
            self._realized += actual_cost

    @property
    def remaining(self) -> float:
        return self.total - self._realized - sum(self._inflight.values())

BLOCKED_PATTERNS = [
    r"import\s+os", r"import\s+subprocess", r"import\s+sys",
    r"__import__", r"exec\s*\(", r"eval\s*\(",
    r"open\s*\(", r"socket\.", r"urllib\.", r"requests\.",
    r"ctypes\.", r"cffi\.", r"multiprocessing\."
]

def static_safety_check(code: str) -> tuple[bool, str]:
    """Return (is_safe, reason)."""
    for pattern in BLOCKED_PATTERNS:
        if re.search(pattern, code):
            return False, f"Blocked pattern: {pattern}"
    return True, ""

SEARCH ROUTER (runs every K generations)

Is the problem "narrow and deep"?              Is the problem "broad and shallow"?
(few good solutions, need fine-grained         (many local optima, need exploration,
 refinement, single known promising approach)   wide search space)
                 │                                              │
                 ▼                                              ▼
         AB-MCTS Tree Search                        Evolutionary Loop
         ─────────────────                          ─────────────────
         Start from best solution                   MAP-Elites + Islands
         Thompson Sampling for depth/width          Multi-modal mutation
         Refinement-focused prompts                 Diversity-preserving selection
         Inject improvements back to population     Tree search on stagnant islands

class AdaptiveBranchMCTS:
    def __init__(self, root_program: Program, llm_ensemble: LLMEnsemble):
        self.tree = SearchTree(root=SearchNode(root_program))
        self.branch_bandit = ThompsonSamplingBandit(["branch", "deepen"])
        self.llm = llm_ensemble

    def search(self, n_steps: int) -> Program:
        for _ in range(n_steps):
            node = self.select_node()  # UCT selection
            action = self.branch_bandit.select()

            if action == "deepen":
                child = self.refine(node)   # Diff patch mutation
            else:
                child = self.branch(node)   # Full rewrite from this node

            score = evaluate(child)
            delta = score - node.program.score
            self.branch_bandit.update(action, success=(delta > 0))
            self.backpropagate(node, delta)

        return self.tree.best_leaf().program

# omnievolve_config.yaml (Hydra)
evolution:
  n_islands: 8
  island_types: [exploit, explore, diversity, reflect, crossover]
  generations: 1000
  async: true
  max_concurrent_mutations: 16

population:
  map_elites_resolution: [20, 20]
  archive_max_size: 10000
  archive_compression_interval: 500
  migration_interval: 50
  migration_top_k: 3

mutation:
  modes: [diff, full, cross, reflect, failure, runtime]
  bandit_c: 0.3
  stagnation_window: 50
  stagnation_epsilon: 0.0001

novelty:
  embedding_model: text-embedding-3-small
  embedding_similarity_threshold: 0.92
  llm_novelty_judge: gemini-flash-2.0
  n_neighbors: 10

llm:
  provider: litellm
  models:
    tier1: [gemini/gemini-2.0-flash, claude-haiku-4-5]
    tier2: [claude-sonnet-4-6, gpt-4o]
    tier3: [claude-opus-4-6]
    tier4: [ollama/qwen2.5-coder:32b]
  bandit_c: 0.5
  thompson_prior_alpha: 1
  thompson_prior_beta: 1

cost:
  total_budget_usd: 100.0
  cascade_stages: [0.05, 0.30, 1.00]  # fraction of test suite per stage
  cascade_thresholds: [0.30, null]      # reject if below threshold
  early_stopping_alpha: 0.05
  early_stopping_beta: 0.05

prompt_evolution:
  enabled: true
  population_size: 10
  mutation_interval: 100  # mutate prompts every N mutations
  ema_alpha: 0.1

learning_log:
  enabled: true
  compression_interval: 100
  meta_rec_interval: 500
  retrieval_k: 10
  max_context_tokens: 2000

self_improvement:
  enabled: true
  trial_n: 50
  significance_threshold: 0.05
  snapshot_retention: 5  # keep last 5 snapshots

search:
  strategy: adaptive  # evolutionary | mcts | adaptive
  mcts_trigger_stagnation: 100
  mcts_steps: 50
  thompson_prior_alpha: 1
  thompson_prior_beta: 1

safety:
  sandbox: docker
  timeout_s: 30
  memory_limit_mb: 512
  network_disabled: true
  static_analysis: true