| """Controlled evolution pipeline over compact structured experiences.""" | |
| from datetime import datetime, timezone | |
| import json | |
| import sqlite3 | |
| from ..config import settings | |
| from ..memory.store import Store | |
| from ..skills.registry import Skill, SkillRegistry | |
| from .evaluator import evaluate_outcome | |
| from .pattern_extractor import extract_pattern | |
| class EvolutionEngine: | |
| def __init__(self, store: Store, skills: SkillRegistry): | |
| self.store = store | |
| self.skills = skills | |
| with self.store.connection() as conn: | |
| conn.execute('''CREATE TABLE IF NOT EXISTS evolution_patterns( | |
| content_hash TEXT PRIMARY KEY, pattern_json TEXT NOT NULL, | |
| observations INTEGER NOT NULL DEFAULT 1, successes INTEGER NOT NULL DEFAULT 0, | |
| failures INTEGER NOT NULL DEFAULT 0, confidence REAL NOT NULL DEFAULT .5, | |
| status TEXT NOT NULL DEFAULT 'candidate', created_at TEXT NOT NULL, | |
| updated_at TEXT NOT NULL)''') | |
| def observe(self, experience: dict, quality_score: float) -> dict: | |
| """Record a compact pattern and evaluate it; raw task content is never accepted.""" | |
| pattern = extract_pattern(experience) | |
| now = datetime.now(timezone.utc).isoformat() | |
| success = pattern['result'] == 'success' | |
| with self.store.connection() as conn: | |
| row = conn.execute( | |
| 'SELECT observations,successes,failures FROM evolution_patterns WHERE content_hash=?', | |
| (pattern['content_hash'],), | |
| ).fetchone() | |
| observations = int(row['observations']) + 1 if row else 1 | |
| successes = int(row['successes']) + int(success) if row else int(success) | |
| failures = int(row['failures']) + int(not success) if row else int(not success) | |
| evaluation = evaluate_outcome( | |
| success=success, | |
| verified=pattern['verified'], | |
| quality_score=float(quality_score), | |
| observations=observations, | |
| min_quality=settings.evolution_min_confidence, | |
| ) | |
| status = 'validated' if evaluation.accepted else 'candidate' | |
| conn.execute('''INSERT OR REPLACE INTO evolution_patterns( | |
| content_hash,pattern_json,observations,successes,failures,confidence,status,created_at,updated_at) | |
| VALUES(?,?,?,?,?,?,?,?,?)''', ( | |
| pattern['content_hash'], json.dumps(pattern, sort_keys=True), observations, | |
| successes, failures, evaluation.confidence, status, | |
| row['created_at'] if row and 'created_at' in row.keys() else now, now, | |
| )) | |
| return { | |
| 'pattern_hash': pattern['content_hash'], 'observations': observations, | |
| 'status': status, 'confidence': evaluation.confidence, | |
| 'reasons': list(evaluation.reasons), | |
| } | |
| def build_skill_candidate(self, pattern_hash: str) -> Skill: | |
| with self.store.connection() as conn: | |
| row = conn.execute( | |
| 'SELECT * FROM evolution_patterns WHERE content_hash=?', (pattern_hash,) | |
| ).fetchone() | |
| if not row or row['status'] != 'validated': | |
| raise ValueError('only validated patterns can become skill candidates') | |
| pattern = json.loads(row['pattern_json']) | |
| skill_id = f"evolved-{pattern['task_class']}-{pattern_hash[:10]}" | |
| return Skill( | |
| skill_id=skill_id, | |
| name=f"Validated {pattern['task_class']} pattern", | |
| version='0.1.0', | |
| description='Candidate derived from repeated verified outcomes.', | |
| capabilities=(pattern['task_class'],), | |
| instructions=( | |
| f"Use the verified {pattern['task_class']} route pattern. " | |
| "All tool calls remain subject to MCP permission and approval policy." | |
| ), | |
| tool_requirements=(), | |
| confidence=float(row['confidence']), | |
| source='evolution', | |
| trust_state='untrusted', | |
| ).normalized() | |
| def register_validated_skill(self, candidate: Skill, *, approved: bool = False) -> Skill: | |
| if not approved or candidate.source != 'evolution': | |
| raise PermissionError('evolved skills require explicit validation approval') | |
| verified = Skill(**{**candidate.to_dict(), 'trust_state': 'verified'}).normalized() | |
| return self.skills.register(verified, replace=True) | |
| def create_training_candidate(self, pattern_hash: str) -> str: | |
| """Create a future dataset candidate; this never mutates model weights.""" | |
| with self.store.connection() as conn: | |
| row = conn.execute( | |
| 'SELECT pattern_json,status FROM evolution_patterns WHERE content_hash=?', | |
| (pattern_hash,), | |
| ).fetchone() | |
| if not row or row['status'] != 'validated': | |
| raise ValueError('training candidates require a validated pattern') | |
| now = datetime.now(timezone.utc).isoformat() | |
| conn.execute('''INSERT OR IGNORE INTO training_candidates( | |
| candidate_type,payload_json,content_hash,privacy_status,evaluation_status,created_at,updated_at) | |
| VALUES('validated_pattern',?,?, 'pending','validated',?,?)''', | |
| (row['pattern_json'], pattern_hash, now, now), | |
| ) | |
| return pattern_hash | |
| def status(self) -> dict: | |
| with self.store.connection() as conn: | |
| counts = {} | |
| for table in ('structured_experiences', 'evolution_patterns', 'training_candidates'): | |
| counts[table] = conn.execute(f'SELECT COUNT(*) FROM {table}').fetchone()[0] | |
| counts['validated_patterns'] = conn.execute( | |
| "SELECT COUNT(*) FROM evolution_patterns WHERE status='validated'" | |
| ).fetchone()[0] | |
| return { | |
| 'enabled': settings.evolution_enabled, | |
| 'knowledge_evolution': 'enabled' if settings.evolution_enabled else 'disabled', | |
| 'skill_evolution': 'validation_required', | |
| 'model_evolution': 'dataset_candidates_only', | |
| **counts, | |
| } | |