Evolution Layer

┌─────────────────────────────────────────────────────────────────┐
│                    Allternit Evolution Layer                    │
├─────────────┬─────────────┬─────────────┬───────────┬───────────┤
│     MEE     │     SEE     │     CRL     │    OEE    │    TOE    │
│   Memory    │    Skill    │  Confidence │    Org    │ Trajectory│
│  Evolution  │  Evolution  │   Routing   │ Evolution │Optimization│
└──────┬──────┴──────┬──────┴──────┬──────┴─────┬─────┴─────┬─────┘
       │             │             │            │           │
       ▼             ▼             ▼            ▼           ▼
┌─────────────────────────────────────────────────────────────────┐
│                        Unified Status Surface                    │
│  memory_schemas  skills  routing_decisions  workflows  trajectories│
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│              System Law Engine  +  Harness Engineering           │
│              (policy guardrails, safety evaluation)              │
└─────────────────────────────────────────────────────────────────┘

[dependencies]
allternit-evolution-layer = { workspace = true }

use std::sync::Arc;
use allternit_evolution_layer::EvolutionLayer;
use allternit_system_law::SystemLawEngine;
use allternit_harness_engineering::HarnessEngineeringEngine;

let system_law = Arc::new(SystemLawEngine::new());
let harness = Arc::new(HarnessEngineeringEngine::new(system_law.clone()));

let layer = EvolutionLayer::new(system_law, harness);

use allternit_evolution_layer::{
    MemoryEvolutionEngine, MemorySchema, SchemaPerformanceMetrics,
};
use chrono::Utc;

let engine = MemoryEvolutionEngine::new();

let schema = MemorySchema {
    schema_id: "schema_001".to_string(),
    name: "Codebase Context".to_string(),
    domain: "code".to_string(),
    retrieval_strategy: "hybrid_vector".to_string(),
    update_strategy: "append_with_decay".to_string(),
    version: "1.0.0".to_string(),
    performance_metrics: SchemaPerformanceMetrics::default(),
    created_at: Utc::now(),
    last_evaluated: None,
};

engine.register_schema(schema).await;
engine.evaluate_schema("schema_001", 0.92, 0.74, 0.88).await.unwrap();

use allternit_evolution_layer::{
    SkillEvolutionEngine, Trajectory, TrajectoryStep,
};
use chrono::Utc;

let engine = SkillEvolutionEngine::new();

let trajectory = Trajectory {
    trajectory_id: "traj_001".to_string(),
    task_id: "TASK-42".to_string(),
    steps: vec![
        TrajectoryStep {
            step_id: "s1".to_string(),
            action: "read_routing_config".to_string(),
            tool_used: Some("fs.read".to_string()),
            observation: "Found REST endpoint list".to_string(),
        },
        TrajectoryStep {
            step_id: "s2".to_string(),
            action: "add_health_check".to_string(),
            tool_used: Some("fs.write".to_string()),
            observation: "Wrote /health route".to_string(),
        },
    ],
    outcome: "API health endpoint added".to_string(),
    success: true,
    timestamp: Utc::now(),
};

engine.record_trajectory(trajectory).await;
let skill_id = engine.extract_skill("traj_001").await.unwrap();
engine.update_skill_performance(&skill_id, true).await.unwrap();

use allternit_evolution_layer::ConfidenceRoutingLayer;

let router = ConfidenceRoutingLayer::new();

let decision = router.route_task("summarize_ticket", 0.3).await;
println!("selected tier: {:?}", decision.selected_tier);

router.record_outcome("summarize_ticket", true, decision.selected_tier).await;

// After repeated failures, escalate to a larger tier
let escalated = router.escalate("refactor_module").await;

use allternit_evolution_layer::{
    AgentRole, OrganizationalEvolutionEngine, WorkflowConfig, WorkflowMutation,
};

let engine = OrganizationalEvolutionEngine::new();

let workflow = WorkflowConfig {
    workflow_id: "wf_secure_feature".to_string(),
    name: "Secure Feature Pipeline".to_string(),
    roles: vec![AgentRole::Engineer, AgentRole::Reviewer],
    iteration_cycles: 3,
    escalation_threshold: 2,
    parallel_allowed: false,
};

engine.register_workflow(workflow).await;
engine.assign_role("agent_7", AgentRole::Engineer).await;

// Add a security role after observing policy-heavy tasks
engine.mutate_workflow("wf_secure_feature", WorkflowMutation::AddRole(AgentRole::Security))
    .await
    .unwrap();

let optimal = engine.get_optimal_workflow(0.5).await;

use allternit_evolution_layer::TrajectoryOptimizationEngine;

let engine = TrajectoryOptimizationEngine::new();
let state_id = engine.create_state().await;

engine.add_chunk(&state_id, "Search vector index for related work", 0.9).await.unwrap();
engine.add_chunk(&state_id, "Draft code changes with tool calls", 0.85).await.unwrap();

if engine.should_continue(&state_id).await {
    // Continue reasoning...
} else {
    let summary = engine.summarize(&state_id).await.unwrap();
    println!("compressed trajectory: {}", summary);
}

let status = layer.get_status().await;
println!("{:?}", status);