Upload main.py

main.py

@@ -0,0 +1,1185 @@
+"""
+AETHER v0.3.0 — Autonomous Self-Evolving Architecture (HF Space)
+==================================================================
+Runs continuously in a Docker Space. Background evolution thread persists
+memory, knowledge graph, and architecture checkpoints to the HF Hub via
+CommitScheduler. Executes tasks via REST API even when browser tabs are closed.
+
+Endpoints:
+  GET  /         → Gradio monitoring dashboard
+  GET  /status   → Live system state (JSON)
+  POST /task     → Submit a reasoning task (async)
+  GET  /task/{id}→ Get task result
+  POST /evolve   → Trigger one-shot evolution
+  GET  /history  → Evolution trajectory
+  GET  /kg       → Knowledge graph stats
+"""
+
+import os, sys, time, json, hashlib, copy, random, warnings, asyncio, threading
+from pathlib import Path
+from dataclasses import dataclass, asdict
+from typing import Dict, List, Any, Optional, Tuple, Callable
+from collections import deque
+from contextlib import asynccontextmanager
+
+import numpy as np
+import networkx as nx
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from fastapi import FastAPI, BackgroundTasks
+from pydantic import BaseModel
+import uvicorn
+
+import gradio as gr
+
+from huggingface_hub import CommitScheduler, HfApi, hf_hub_download
+
+warnings.filterwarnings("ignore")
+
+STATE_DIR = Path("/tmp/aether_state")
+STATE_DIR.mkdir(parents=True, exist_ok=True)
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+STATE_REPO = os.environ.get("AETHER_STATE_REPO", "camdog920/aether-state")
+
+scheduler = None
+
+def init_scheduler():
+    global scheduler
+    if scheduler is None and HF_TOKEN:
+        scheduler = CommitScheduler(
+            repo_id=STATE_REPO, repo_type="model", folder_path=STATE_DIR,
+            path_in_repo="state", every=5,
+        )
+        print(f"[PERSISTENCE] CommitScheduler initialized for {STATE_REPO}")
+
+def save_state(state_dict, name="latest"):
+    path = STATE_DIR / f"{name}.json"
+    with open(path, "w") as f:
+        json.dump(state_dict, f, indent=2, default=str)
+    print(f"[PERSISTENCE] State saved to {path}")
+
+def load_state(name="latest"):
+    path = STATE_DIR / f"{name}.json"
+    if path.exists():
+        with open(path) as f:
+            return json.load(f)
+    if HF_TOKEN:
+        try:
+            downloaded = hf_hub_download(
+                repo_id=STATE_REPO, filename=f"state/{name}.json",
+                repo_type="model", local_dir=str(STATE_DIR), token=HF_TOKEN,
+            )
+            with open(downloaded) as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"[PERSISTENCE] No remote state found: {e}")
+    return None
+
+@dataclass
+class AetherConfig:
+    population_size: int = 6; generations: int = 5; mutation_rate: float = 0.12
+    macro_policy_dim: int = 128; micro_policy_dim: int = 64; num_agents: int = 4
+    working_memory_capacity: int = 16; episodic_buffer_size: int = 500
+    kg_embedding_dim: int = 64; kg_num_relations: int = 10
+    learning_rate: float = 2e-5; batch_size: int = 4
+    enable_self_modification: bool = True
+    max_mutation_rate: float = 0.50; max_agents: int = 16
+    max_memory_mb: float = 8192.0; rollback_fitness_drop: float = 0.15
+    risk_threshold: float = 0.70
+    archive_dims: Tuple[int, int] = (10, 10)
+
+    def to_vector(self):
+        return np.array([self.population_size, self.mutation_rate, self.learning_rate * 1e5,
+                         self.macro_policy_dim, self.micro_policy_dim, self.num_agents,
+                         self.kg_embedding_dim], dtype=np.float32)
+    @classmethod
+    def from_vector(cls, vec):
+        return cls(
+            population_size=int(np.clip(vec[0], 2, 64)),
+            mutation_rate=float(np.clip(vec[1], 0.01, 0.5)),
+            learning_rate=float(np.clip(vec[2] / 1e5, 1e-6, 1e-3)),
+            macro_policy_dim=int(np.clip(vec[3], 64, 512)),
+            micro_policy_dim=int(np.clip(vec[4], 32, 256)),
+            num_agents=int(np.clip(vec[5], 1, 16)),
+            kg_embedding_dim=int(np.clip(vec[6], 32, 512)),
+        )
+
+class WorkingMemory:
+    def __init__(self, capacity=16):
+        self.buffer = deque(maxlen=capacity)
+        self.attention = nn.Parameter(torch.ones(capacity))
+    def store(self, item):
+        item["_t"] = time.time()
+        self.buffer.append(item)
+    def retrieve(self, query, top_k=3):
+        if not self.buffer: return []
+        buf = list(self.buffer)
+        scores = []
+        for i, item in enumerate(buf):
+            text = json.dumps(item)
+            score = sum(1 for w in query.lower().split() if w in text.lower())
+            attn = torch.sigmoid(self.attention[i % self.capacity]).item()
+            scores.append(score * attn)
+        indices = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)[:top_k]
+        return [buf[i] for i in indices]
+    def export(self):
+        return list(self.buffer)
+
+class EpisodicMemory:
+    def __init__(self, buffer_size=1000):
+        self.buffer = deque(maxlen=buffer_size)
+    def store(self, episode):
+        episode["_t"] = time.time()
+        self.buffer.append(episode)
+    def retrieve_similar(self, query, top_k=5):
+        if not self.buffer: return []
+        buf = list(self.buffer)
+        scores = [sum(1 for w in query.lower().split() if w in json.dumps(item).lower()) for item in buf]
+        indices = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)[:top_k]
+        return [buf[i] for i in indices]
+    def export(self):
+        return list(self.buffer)
+
+class SemanticMemory:
+    def __init__(self):
+        self.facts = {}
+    def store_fact(self, key, value, confidence=1.0):
+        self.facts[key] = {"value": value, "confidence": confidence, "t": time.time()}
+    def query(self, query):
+        return [v for k, v in self.facts.items() if query.lower() in k.lower()]
+    def export(self):
+        return self.facts
+
+class ProceduralMemory:
+    def __init__(self):
+        self.tools = {}
+        self.usage = {}
+    def register_tool(self, name, code, description, tags=None):
+        self.tools[name] = {"code": code, "description": description,
+                            "tags": tags or [], "registered_at": time.time(), "version": 1}
+        self.usage[name] = 0
+    def search_tools(self, query):
+        out = []
+        for name, tool in self.tools.items():
+            text = f"{name} {tool['description']} {' '.join(tool['tags'])}"
+            if query.lower() in text.lower():
+                out.append({"name": name, **tool})
+        return out
+    def export(self):
+        return {"tools": self.tools, "usage": self.usage}
+
+class CoALAMemory:
+    def __init__(self, capacity=16):
+        self.working = WorkingMemory(capacity=capacity)
+        self.episodic = EpisodicMemory(buffer_size=1000)
+        self.semantic = SemanticMemory()
+        self.procedural = ProceduralMemory()
+    def store(self, item, memory_type="working"):
+        if memory_type == "working":
+            self.working.store(item)
+        elif memory_type == "episodic":
+            self.episodic.store(item)
+        elif memory_type == "semantic":
+            for k, v in item.items():
+                self.semantic.store_fact(k, v)
+        elif memory_type == "procedural":
+            if "name" in item and "code" in item:
+                self.procedural.register_tool(item["name"], item["code"],
+                                               item.get("description", ""), item.get("tags", []))
+    def retrieve(self, query, memory_type="all", top_k=5):
+        if memory_type == "all":
+            out = self.working.retrieve(query, top_k=top_k // 2)
+            out += self.episodic.retrieve_similar(query, top_k=top_k)
+            out += self.semantic.query(query)[:top_k]
+            return out[:top_k]
+        elif memory_type == "working":
+            return self.working.retrieve(query, top_k)
+        elif memory_type == "episodic":
+            return self.episodic.retrieve_similar(query, top_k)
+        elif memory_type == "semantic":
+            return self.semantic.query(query)[:top_k]
+        elif memory_type == "procedural":
+            return self.procedural.search_tools(query)
+        return []
+    def export(self):
+        return {"working": self.working.export(), "episodic": self.episodic.export(),
+                "semantic": self.semantic.export(), "procedural": self.procedural.export()}
+
+class TemporalMemory(nn.Module):
+    def __init__(self, buffer_size=1000, hidden_dim=64):
+        super().__init__()
+        self.buffer = deque(maxlen=buffer_size)
+        self.temporal_gate = nn.Sequential(
+            nn.Linear(2, hidden_dim), nn.ReLU(),
+            nn.Linear(hidden_dim, 1), nn.Sigmoid(),
+        )
+    def store(self, event):
+        event["_t"] = time.time()
+        self.buffer.append(event)
+    def retrieve_context(self, current_time=None, lookback=3600.0):
+        current_time = current_time or time.time()
+        relevant = []
+        for event in self.buffer:
+            age = current_time - event.get("_t", current_time)
+            if age <= lookback:
+                recency = torch.exp(torch.tensor(-age / lookback)).item()
+                relevant.append({**event, "recency": recency, "age": age})
+        relevant.sort(key=lambda x: x["recency"], reverse=True)
+        return relevant
+    def export(self):
+        return list(self.buffer)
+
+class RGCNLayer(nn.Module):
+    def __init__(self, in_dim, out_dim, num_relations, num_bases=4):
+        super().__init__()
+        self.num_relations = num_relations
+        self.bases = nn.Parameter(torch.Tensor(num_bases, in_dim, out_dim))
+        self.comp = nn.Parameter(torch.Tensor(num_relations, num_bases))
+        self.self_loop = nn.Parameter(torch.Tensor(in_dim, out_dim))
+        self.bias = nn.Parameter(torch.Tensor(out_dim))
+        nn.init.xavier_uniform_(self.bases)
+        nn.init.xavier_uniform_(self.comp)
+        nn.init.xavier_uniform_(self.self_loop)
+        nn.init.zeros_(self.bias)
+    def forward(self, x, edge_index, edge_type):
+        num_nodes = int(edge_index.max().item()) + 1 if x is None else x.size(0)
+        if x is None:
+            x = torch.eye(num_nodes, self.bases.size(1), device=edge_index.device)
+        weight = torch.einsum("rb,bio->rio", self.comp, self.bases)
+        out = torch.zeros(num_nodes, weight.size(2), device=x.device)
+        for rid in range(self.num_relations):
+            mask = edge_type == rid
+            if mask.sum() == 0: continue
+            ei = edge_index[:, mask]
+            messages = torch.mm(x[ei[0]], weight[rid])
+            out.index_add_(0, ei[1], messages)
+        out = out + torch.mm(x, self.self_loop) + self.bias
+        return out
+
+class KnowledgeGraphEncoder(nn.Module):
+    def __init__(self, num_nodes, hidden_dim, num_relations, num_layers=2, num_bases=4):
+        super().__init__()
+        self.node_embeddings = nn.Embedding(num_nodes, hidden_dim)
+        self.layers = nn.ModuleList([
+            RGCNLayer(hidden_dim, hidden_dim, num_relations, num_bases) for _ in range(num_layers)
+        ])
+        self.norms = nn.ModuleList([nn.LayerNorm(hidden_dim) for _ in range(num_layers)])
+    def forward(self, edge_index, edge_type):
+        num_nodes = int(edge_index.max().item()) + 1
+        x = self.node_embeddings(torch.arange(num_nodes, device=edge_index.device))
+        for layer, norm in zip(self.layers, self.norms):
+            x = F.relu(norm(layer(x, edge_index, edge_type)))
+        return x
+
+class ComplExScorer(nn.Module):
+    def __init__(self, num_nodes, num_relations, hidden_dim=50):
+        super().__init__()
+        self.head_real = nn.Embedding(num_nodes, hidden_dim)
+        self.head_imag = nn.Embedding(num_nodes, hidden_dim)
+        self.tail_real = nn.Embedding(num_nodes, hidden_dim)
+        self.tail_imag = nn.Embedding(num_nodes, hidden_dim)
+        self.rel_real = nn.Embedding(num_relations, hidden_dim)
+        self.rel_imag = nn.Embedding(num_relations, hidden_dim)
+        for p in self.parameters():
+            nn.init.xavier_uniform_(p)
+    def forward(self, h, r, t):
+        hr, hi = self.head_real(h), self.head_imag(h)
+        tr, ti = self.tail_real(t), self.tail_imag(t)
+        rr, ri = self.rel_real(r), self.rel_imag(r)
+        return torch.sum(hr * rr * tr + hr * ri * ti + hi * rr * ti - hi * ri * tr, dim=-1)
+    def loss(self, h, r, t, neg_t=None):
+        pos = self.forward(h, r, t)
+        if neg_t is None:
+            neg_t = torch.randint(0, self.tail_real.num_embeddings, t.size(), device=t.device)
+        neg = self.forward(h, r, neg_t)
+        return (F.softplus(-pos) + F.softplus(neg)).mean()
+
+class KnowledgeGraphEngine(nn.Module):
+    def __init__(self, embedding_dim=128, num_relations=20, max_nodes=10000):
+        super().__init__()
+        self.embedding_dim = embedding_dim
+        self.num_relations = num_relations
+        self.max_nodes = max_nodes
+        self.graph = nx.DiGraph()
+        self.node_id_map = {}
+        self.relation_map = {}
+        self.next_node_id = 0
+        self.next_rel_id = 0
+        self.encoder = None
+        self.scorer = None
+        self.symbolic_attention = nn.Parameter(torch.ones(num_relations))
+        self.rules = []
+
+    def _get_or_create_node(self, name):
+        if name not in self.node_id_map:
+            self.node_id_map[name] = self.next_node_id
+            self.graph.add_node(self.next_node_id, name=name)
+            self.next_node_id += 1
+        return self.node_id_map[name]
+
+    def _get_or_create_relation(self, name):
+        if name not in self.relation_map:
+            self.relation_map[name] = self.next_rel_id
+            self.next_rel_id += 1
+        return self.relation_map[name]
+
+    def add_fact(self, head, relation, tail, confidence=1.0):
+        h = self._get_or_create_node(head)
+        t = self._get_or_create_node(tail)
+        r = self._get_or_create_relation(relation)
+        self.graph.add_edge(h, t, relation=r, name=relation, confidence=confidence)
+        self._ensure_capacity()
+
+    def add_rule(self, premise, conclusion):
+        self.rules.append((premise, conclusion))
+
+    def _ensure_capacity(self):
+        if self.encoder is None and self.next_node_id > 0:
+            n = min(self.next_node_id, self.max_nodes)
+            r = max(self.next_rel_id, self.num_relations)
+            self.encoder = KnowledgeGraphEncoder(n, self.embedding_dim, r)
+            self.scorer = ComplExScorer(n, r, self.embedding_dim // 2)
+
+    def _check_fact(self, fact):
+        h, r, t = fact
+        if h not in self.node_id_map or t not in self.node_id_map or r not in self.relation_map:
+            return False
+        h_id, t_id, r_id = self.node_id_map[h], self.node_id_map[t], self.relation_map[r]
+        return self.graph.has_edge(h_id, t_id) and self.graph.edges[h_id, t_id].get("relation") == r_id
+
+    def reason_symbolic(self, query_head, query_relation):
+        results = []
+        if query_head not in self.node_id_map:
+            return results
+        h_id = self.node_id_map[query_head]
+        r_name = query_relation
+        if r_name in self.relation_map:
+            r_id = self.relation_map[r_name]
+            for _, target, data in self.graph.out_edges(h_id, data=True):
+                if data.get("relation") == r_id:
+                    results.append({
+                        "head": query_head, "relation": r_name,
+                        "tail": self.graph.nodes[target].get("name", str(target)),
+                        "confidence": data.get("confidence", 1.0), "path": "direct",
+                    })
+        for premise, conclusion in self.rules:
+            p_head, _, _ = premise
+            c_head, c_rel, c_tail = conclusion
+            if p_head == query_head and self._check_fact(premise):
+                results.append({
+                    "head": c_head if c_head != "?" else query_head,
+                    "relation": c_rel, "tail": c_tail,
+                    "confidence": 0.8, "path": "inferred",
+                    "rule": f"{premise} -> {conclusion}",
+                })
+        for neighbor in nx.bfs_tree(self.graph, h_id, depth_limit=2).nodes():
+            if neighbor != h_id:
+                for path in nx.all_simple_paths(self.graph, h_id, neighbor, cutoff=2):
+                    if len(path) > 1:
+                        ed = self.graph.edges[path[0], path[1]]
+                        results.append({
+                            "head": query_head,
+                            "relation": f"multi-hop via {ed.get('name', 'unknown')}",
+                            "tail": self.graph.nodes[neighbor].get("name", str(neighbor)),
+                            "confidence": 0.6 ** (len(path) - 1),
+                            "path": "->".join(str(n) for n in path),
+                        })
+        return sorted(results, key=lambda x: x.get("confidence", 0), reverse=True)
+
+    def reason_learned(self, query_head, query_relation, top_k=5):
+        if self.scorer is None or query_head not in self.node_id_map:
+            return []
+        h_id = self.node_id_map[query_head]
+        r_id = self.relation_map.get(query_relation)
+        if r_id is None:
+            return []
+        h_t = torch.tensor([h_id])
+        r_t = torch.tensor([r_id])
+        all_t = torch.arange(self.scorer.tail_real.num_embeddings)
+        scores = []
+        for i in range(0, len(all_t), 1000):
+            batch = all_t[i:i + 1000]
+            scores.extend(self.scorer(h_t.repeat(len(batch)), r_t.repeat(len(batch)), batch).tolist())
+        scores_t = torch.tensor(scores)
+        top_scores, top_idx = torch.topk(scores_t, min(top_k, len(scores_t)))
+        results = []
+        for idx, sc in zip(top_idx, top_scores):
+            node_name = self.graph.nodes[idx.item()].get("name", str(idx.item()))
+            results.append({
+                "head": query_head, "relation": query_relation,
+                "tail": node_name, "confidence": torch.sigmoid(sc).item(), "path": "learned",
+            })
+        return results
+
+    def query(self, text_query, top_k=5):
+        parts = text_query.lower().split()
+        head = parts[0].capitalize() if parts else text_query.capitalize()
+        relation = " ".join(parts[1:]) if len(parts) > 1 else "related_to"
+        sym = self.reason_symbolic(head, relation)[:top_k]
+        learned = self.reason_learned(head, relation, top_k)
+        rel_id = self.relation_map.get(relation, 0)
+        sym_w = torch.sigmoid(self.symbolic_attention[rel_id % self.num_relations]).item()
+        learned_w = 1.0 - sym_w
+        for r in sym:
+            r["source"] = "symbolic"
+            r["fusion_weight"] = sym_w
+        for r in learned:
+            r["source"] = "learned"
+            r["fusion_weight"] = learned_w
+        all_r = sorted(sym + learned, key=lambda x: x.get("confidence", 0), reverse=True)
+        return {
+            "query": text_query, "results": all_r[:top_k],
+            "symbolic_weight": sym_w, "learned_weight": learned_w,
+            "num_symbolic": len(sym), "num_learned": len(learned),
+        }
+
+    def stats(self):
+        return {"num_nodes": self.graph.number_of_nodes(),
+                "num_edges": self.graph.number_of_edges(),
+                "num_relations": len(self.relation_map), "num_rules": len(self.rules)}
+
+    def export(self):
+        edges = []
+        for u, v, d in self.graph.edges(data=True):
+            edges.append({"source": u, "target": v, "relation": d.get("name"), "confidence": d.get("confidence")})
+        return {
+            "nodes": {n: self.graph.nodes[n].get("name", str(n)) for n in self.graph.nodes()},
+            "edges": edges, "rules": self.rules,
+            "node_id_map": self.node_id_map, "relation_map": self.relation_map,
+            "next_node_id": self.next_node_id, "next_rel_id": self.next_rel_id,
+        }
+
+    @classmethod
+    def from_export(cls, data, embedding_dim=64, num_relations=10):
+        kg = cls(embedding_dim=embedding_dim, num_relations=num_relations)
+        kg.node_id_map = data.get("node_id_map", {})
+        kg.relation_map = data.get("relation_map", {})
+        kg.next_node_id = data.get("next_node_id", 0)
+        kg.next_rel_id = data.get("next_rel_id", 0)
+        kg.rules = [tuple(r) for r in data.get("rules", [])]
+        for n, name in data.get("nodes", {}).items():
+            kg.graph.add_node(int(n), name=name)
+        for e in data.get("edges", []):
+            kg.graph.add_edge(int(e["source"]), int(e["target"]),
+                             relation=e.get("relation"), name=e.get("relation"), confidence=e.get("confidence", 1.0))
+        kg._ensure_capacity()
+        return kg
+
+class AgentRole:
+    RESEARCHER = "researcher"; ENGINEER = "engineer"; ANALYZER = "analyzer"; INTEGRATOR = "integrator"
+
+class BaseAgent(nn.Module):
+    def __init__(self, role, hidden_dim=128, vocab_size=32000):
+        super().__init__()
+        self.role = role
+        self.hidden_dim = hidden_dim
+        self.encoder = nn.Sequential(nn.Embedding(vocab_size, hidden_dim),
+                                      nn.LSTM(hidden_dim, hidden_dim, batch_first=True))
+        self.policy_head = nn.Linear(hidden_dim, hidden_dim)
+        self.value_head = nn.Linear(hidden_dim, 1)
+        self.task_history = deque(maxlen=100)
+        self.performance_log = []
+    def forward(self, input_ids):
+        embeds = self.encoder[0](input_ids)
+        lstm_out, _ = self.encoder[1](embeds)
+        hidden = lstm_out[:, -1, :]
+        return {"policy_logits": self.policy_head(hidden), "value": self.value_head(hidden), "hidden": hidden}
+    def act(self, observation):
+        self.task_history.append({"observation": observation, "t": time.time()})
+        actions = {
+            AgentRole.RESEARCHER: f"[RESEARCHER] Exploring knowledge for: '{observation[:50]}...'",
+            AgentRole.ENGINEER: f"[ENGINEER] Synthesizing tool for: '{observation[:50]}...'",
+            AgentRole.ANALYZER: f"[ANALYZER] Evaluating solution for: '{observation[:50]}...'",
+            AgentRole.INTEGRATOR: f"[INTEGRATOR] Merging components for: '{observation[:50]}...'",
+        }
+        return actions.get(self.role, f"[{self.role.upper()}] Processing: '{observation}'")
+    def update(self, reward):
+        self.performance_log.append(reward)
+
+class HierarchicalAgent(nn.Module):
+    def __init__(self, macro_dim=256, micro_dim=128, num_subgoals=5):
+        super().__init__()
+        self.macro_dim = macro_dim
+        self.micro_dim = micro_dim
+        self.num_subgoals = num_subgoals
+        self.macro_decoder = nn.LSTM(macro_dim, macro_dim, batch_first=True)
+        self.subgoal_head = nn.Linear(macro_dim, num_subgoals)
+        self.termination_token = nn.Parameter(torch.randn(macro_dim))
+        self.micro_encoder = nn.LSTM(micro_dim + macro_dim, micro_dim, batch_first=True)
+        self.action_head = nn.Linear(micro_dim, 50)
+        self.current_blueprint = None
+        self.active_subgoal_idx = 0
+    def generate_blueprint(self, task_embedding):
+        batch_size = task_embedding.size(0)
+        hidden = (torch.zeros(1, batch_size, self.macro_dim), torch.zeros(1, batch_size, self.macro_dim))
+        input_tok = task_embedding.unsqueeze(1)
+        blueprints = []
+        for _ in range(self.num_subgoals):
+            out, hidden = self.macro_decoder(input_tok, hidden)
+            sg_logits = self.subgoal_head(out.squeeze(1))
+            sg_id = torch.argmax(sg_logits, dim=-1)
+            sim = torch.cosine_similarity(out.squeeze(1), self.termination_token.unsqueeze(0))
+            if sim.item() > 0.9:
+                break
+            blueprints.append(f"subgoal_{sg_id.item()}")
+            input_tok = out
+        self.current_blueprint = blueprints
+        self.active_subgoal_idx = 0
+        return blueprints
+    def execute_action(self, observation, blueprint=None):
+        if blueprint is not None:
+            self.current_blueprint = blueprint
+        if not self.current_blueprint:
+            return torch.zeros(1, 50)
+        active = self.current_blueprint[min(self.active_subgoal_idx, len(self.current_blueprint) - 1)]
+        subgoal_embed = torch.randn(1, self.macro_dim)
+        combined = torch.cat([observation, subgoal_embed], dim=-1)
+        out, _ = self.micro_encoder(combined.unsqueeze(1))
+        return self.action_head(out.squeeze(1))
+    def advance_subgoal(self):
+        self.active_subgoal_idx += 1
+    def reset(self):
+        self.current_blueprint = None
+        self.active_subgoal_idx = 0
+
+class AetherAgentOrchestrator(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.agents = nn.ModuleDict({
+            "researcher": BaseAgent(AgentRole.RESEARCHER, hidden_dim=config.macro_policy_dim),
+            "engineer": BaseAgent(AgentRole.ENGINEER, hidden_dim=config.micro_policy_dim),
+            "analyzer": BaseAgent(AgentRole.ANALYZER, hidden_dim=config.micro_policy_dim),
+            "integrator": BaseAgent(AgentRole.INTEGRATOR, hidden_dim=config.micro_policy_dim),
+        })
+        self.leader = BaseAgent("leader", hidden_dim=config.macro_policy_dim)
+        self.hierarchical = HierarchicalAgent(macro_dim=config.macro_policy_dim, micro_dim=config.micro_policy_dim)
+        self.routing_weights = nn.Parameter(torch.ones(len(self.agents)))
+        self.aggregation_gate = nn.Softmax(dim=0)
+        self.interactions = []
+        self.task_count = 0
+    def forward(self, task, context):
+        task_embed = torch.randn(1, self.config.macro_policy_dim)
+        blueprint = self.hierarchical.generate_blueprint(task_embed)
+        routing_probs = self.aggregation_gate(self.routing_weights)
+        agent_outputs = {}
+        for i, (name, agent) in enumerate(self.agents.items()):
+            weight = routing_probs[i].item()
+            if weight < 0.10:
+                continue
+            sub_task = blueprint[min(i, len(blueprint) - 1)] if blueprint else task
+            output = agent.act(f"[{name}] {sub_task}")
+            agent_outputs[name] = {"output": output, "weight": weight, "sub_task": sub_task}
+        synthesis = self.leader.act(f"Synthesize: {task} with inputs: {list(agent_outputs.keys())}")
+        self.interactions.append({
+            "task": task, "blueprint": blueprint,
+            "agent_outputs": agent_outputs, "leader_synthesis": synthesis,
+            "routing_probs": routing_probs.detach().cpu().tolist(),
+            "t": time.time(),
+        })
+        self.task_count += 1
+        return {"output": synthesis, "blueprint": blueprint,
+                "agent_outputs": agent_outputs,
+                "routing_weights": routing_probs.detach().cpu().tolist()}
+    def execute(self, task, kg_context, context):
+        return self.forward(task, context)
+    def stats(self):
+        return {"total_tasks": self.task_count, "num_agents": len(self.agents),
+                "total_interactions": len(self.interactions),
+                "routing_weights": self.routing_weights.detach().cpu().tolist()}
+
+class AutoOversight:
+    def __init__(self, config):
+        self.config = config
+        self.audit_log = []
+        self.baseline_fitness = 0.0
+        self.last_good_config = None
+        self.last_good_fitness = -float("inf")
+        self.consecutive_rejections = 0
+    def risk_score(self, candidate):
+        risks = []
+        risks.append(min(1.0, candidate.mutation_rate / self.config.max_mutation_rate))
+        risks.append(min(1.0, candidate.num_agents / self.config.max_agents))
+        est_mem = (candidate.macro_policy_dim * candidate.micro_policy_dim * candidate.num_agents * 4) / 1e6
+        risks.append(min(1.0, est_mem / self.config.max_memory_mb))
+        risks.append(1.0 if candidate.micro_policy_dim > candidate.macro_policy_dim else 0.0)
+        return float(np.mean(risks))
+    def validate_stability(self, candidate):
+        checks = {"population_size": (2, 64), "mutation_rate": (0.0, self.config.max_mutation_rate),
+                  "learning_rate": (1e-6, 1e-3), "num_agents": (1, self.config.max_agents),
+                  "macro_policy_dim": (32, 512), "micro_policy_dim": (16, 256)}
+        violations = []
+        for field_name, (lo, hi) in checks.items():
+            val = getattr(candidate, field_name, None)
+            if val is not None and not (lo <= val <= hi):
+                violations.append(f"{field_name}={val} not in [{lo},{hi}]")
+        if candidate.micro_policy_dim > candidate.macro_policy_dim:
+            violations.append("micro > macro")
+        return (False, "; ".join(violations)) if violations else (True, "ok")
+    def regression_suite(self, candidate, core):
+        scores = []
+        try:
+            wm = WorkingMemory(capacity=candidate.working_memory_capacity)
+            for i in range(100):
+                wm.store({"idx": i, "data": torch.randn(16)})
+            retrieved = wm.retrieve("idx", top_k=5)
+            scores.append(len(retrieved) / 5.0)
+            kg = KnowledgeGraphEngine(embedding_dim=candidate.kg_embedding_dim, num_relations=candidate.kg_num_relations)
+            for i in range(20):
+                kg.add_fact(f"Node{i}", "relates_to", f"Node{i+1}")
+            q = kg.query("Node0 relates_to", top_k=3)
+            scores.append(min(1.0, len(q["results"]) / 3.0))
+            orch = AetherAgentOrchestrator(candidate)
+            task_embed = torch.randn(1, candidate.macro_policy_dim)
+            blueprint = orch.hierarchical.generate_blueprint(task_embed)
+            scores.append(min(1.0, len(blueprint) / 3.0))
+        except Exception:
+            return False, 0.0
+        composite = float(np.mean(scores))
+        if self.baseline_fitness > 0 and composite < self.baseline_fitness * (1 - self.config.rollback_fitness_drop):
+            return False, composite
+        return True, composite
+    def should_rollback(self, current_fitness):
+        if self.last_good_fitness == -float("inf"):
+            return False
+        drop = (self.last_good_fitness - current_fitness) / (abs(self.last_good_fitness) + 1e-8)
+        return drop > self.config.rollback_fitness_drop
+    def decide(self, candidate, core):
+        risk = self.risk_score(candidate)
+        if risk > self.config.risk_threshold:
+            self._log(candidate, False, f"risk={risk:.2f} > threshold")
+            self.consecutive_rejections += 1
+            return False, risk, "auto-rejected: high risk"
+        stable, reason = self.validate_stability(candidate)
+        if not stable:
+            self._log(candidate, False, reason)
+            self.consecutive_rejections += 1
+            return False, risk, f"auto-rejected: unstable ({reason})"
+        reg_pass, reg_score = self.regression_suite(candidate, core)
+        if not reg_pass:
+            self._log(candidate, False, f"regression fail score={reg_score:.3f}")
+            self.consecutive_rejections += 1
+            return False, reg_score, "auto-rejected: regression failure"
+        self._log(candidate, True, f"risk={risk:.2f} reg={reg_score:.3f}")
+        self.consecutive_rejections = 0
+        self.baseline_fitness = max(self.baseline_fitness, reg_score)
+        return True, reg_score, "auto-approved"
+    def _log(self, candidate, approved, reason):
+        self.audit_log.append({"timestamp": time.time(), "approved": approved,
+                                "hash": hashlib.sha256(json.dumps(asdict(candidate), sort_keys=True).encode()).hexdigest()[:16],
+                                "reason": reason})
+    def update_good_checkpoint(self, config, fitness):
+        self.last_good_config = copy.deepcopy(config)
+        self.last_good_fitness = fitness
+    def summary(self):
+        total = len(self.audit_log)
+        approved = sum(1 for m in self.audit_log if m["approved"])
+        return {"total_attempted": total, "approved": approved, "rejected": total - approved,
+                "consecutive_rejections": self.consecutive_rejections,
+                "baseline_fitness": self.baseline_fitness, "last_good_fitness": self.last_good_fitness}
+
+class MAPelitesArchive:
+    def __init__(self, dims=(10, 10), ranges=None):
+        self.dims = dims
+        self.ranges = ranges or [(0, 1), (0, 1)]
+        self.archive = {}
+    def _index(self, measures):
+        indices = []
+        for m, (lo, hi), dim in zip(measures, self.ranges, self.dims):
+            norm = (m - lo) / (hi - lo + 1e-8)
+            idx = int(np.clip(norm * dim, 0, dim - 1))
+            indices.append(idx)
+        return tuple(indices)
+    def add(self, config, fitness, measures):
+        idx = self._index(measures)
+        if idx not in self.archive or self.archive[idx][1] < fitness:
+            self.archive[idx] = (config, fitness)
+            return True
+        return False
+    def sample(self, n=1):
+        if not self.archive: return []
+        items = list(self.archive.values())
+        selected = random.sample(items, min(n, len(items)))
+        return [cfg for cfg, _ in selected]
+    def get_best(self):
+        if not self.archive: return None
+        return max(self.archive.values(), key=lambda x: x[1])
+    def stats(self):
+        total_cells = self.dims[0] * self.dims[1]
+        return {"coverage": len(self.archive) / total_cells,
+                "qd_score": sum(f for _, f in self.archive.values()),
+                "max_fitness": max((f for _, f in self.archive.values()), default=0)}
+
+class AetherEvolutionEngine:
+    def __init__(self, config):
+        self.config = config
+        self.archive = MAPelitesArchive(dims=config.archive_dims, ranges=[(0, 1), (0, 1)])
+        self.generation = 0
+    def generate_candidates(self, base_config, population_size=8):
+        candidates = [base_config]
+        archive_seeds = self.archive.sample(n=min(2, len(self.archive)))
+        for _ in range(population_size - len(archive_seeds) - 1):
+            candidates.append(self._mutate(base_config))
+        for cfg in archive_seeds:
+            candidates.append(cfg)
+        return candidates
+    def _mutate(self, config):
+        vec = config.to_vector()
+        noise = np.random.normal(0, config.mutation_rate, size=vec.shape)
+        mutated = vec + noise * vec
+        new_cfg = AetherConfig.from_vector(mutated)
+        new_cfg.generations = config.generations
+        new_cfg.enable_self_modification = config.enable_self_modification
+        new_cfg.archive_dims = config.archive_dims
+        return new_cfg
+    def select(self, candidates, fitness_scores):
+        if not candidates or not fitness_scores:
+            return candidates[:2] if len(candidates) >= 2 else candidates
+        vectors = np.array([c.to_vector() for c in candidates])
+        f = np.array(fitness_scores)
+        f_norm = (f - f.min()) / (f.max() - f.min() + 1e-8)
+        k = min(4, len(candidates) - 1)
+        novelties = []
+        for i, v in enumerate(vectors):
+            dists = np.linalg.norm(vectors - v, axis=1)
+            dists[i] = np.inf
+            knn = np.partition(dists, k)[:k]
+            novelties.append(np.mean(knn))
+        nov_norm = np.array(novelties) / (max(novelties) + 1e-8)
+        scores = f_norm * np.sqrt(nov_norm + 1e-8)
+        n_select = max(1, len(candidates) // 2)
+        top_indices = np.argsort(scores)[-n_select:]
+        return [candidates[i] for i in top_indices]
+    def mutate(self, candidates):
+        mutated = []
+        for cfg in candidates:
+            new_cfg = self._mutate(cfg)
+            if new_cfg.macro_policy_dim > 512:
+                new_cfg.macro_policy_dim = 512
+            if new_cfg.micro_policy_dim > new_cfg.macro_policy_dim:
+                new_cfg.micro_policy_dim = new_cfg.macro_policy_dim // 2
+            mutated.append(new_cfg)
+        return mutated
+    def update_archive(self, candidates, fitness_scores):
+        for cfg, fitness in zip(candidates, fitness_scores):
+            if fitness == -float("inf"):
+                continue
+            sym_proxy = cfg.num_agents / cfg.max_agents
+            measures = np.array([sym_proxy, np.clip(fitness, 0, 1)])
+            self.archive.add(cfg, fitness, measures)
+    def get_diversity_stats(self):
+        return self.archive.stats()
+
+class AetherCore(nn.Module):
+    def __init__(self, config=None):
+        super().__init__()
+        self.config = config or AetherConfig()
+        self.generation = 0
+        self.architecture_history = []
+        self.fitness_log = []
+        self.metadata = {"birth": time.time(), "version": "0.3.0-space"}
+        self._memory = None
+        self._temporal = None
+        self._evolution = None
+        self._agents = None
+        self._knowledge = None
+        self._oversight = None
+        self.symbolic_gate = nn.Parameter(torch.tensor(0.0))
+        self.neural_gate = nn.Parameter(torch.tensor(0.0))
+    @property
+    def memory(self):
+        if self._memory is None:
+            self._memory = CoALAMemory(capacity=self.config.working_memory_capacity)
+        return self._memory
+    @property
+    def temporal(self):
+        if self._temporal is None:
+            self._temporal = TemporalMemory(buffer_size=self.config.episodic_buffer_size)
+        return self._temporal
+    @property
+    def evolution(self):
+        if self._evolution is None:
+            self._evolution = AetherEvolutionEngine(self.config)
+        return self._evolution
+    @property
+    def agents(self):
+        if self._agents is None:
+            self._agents = AetherAgentOrchestrator(self.config)
+        return self._agents
+    @property
+    def knowledge(self):
+        if self._knowledge is None:
+            self._knowledge = KnowledgeGraphEngine(
+                embedding_dim=self.config.kg_embedding_dim,
+                num_relations=self.config.kg_num_relations,
+            )
+        return self._knowledge
+    @property
+    def oversight(self):
+        if self._oversight is None:
+            self._oversight = AutoOversight(self.config)
+        return self._oversight
+    def forward(self, task, context=None):
+        context = context or {}
+        kg_context = self.knowledge.query(task, top_k=5)
+        self.memory.store({"task": task, "kg_context": kg_context, "t": time.time()})
+        result = self.agents.execute(task, kg_context, context)
+        sym_w = torch.sigmoid(self.symbolic_gate)
+        neu_w = torch.sigmoid(self.neural_gate)
+        total = sym_w + neu_w + 1e-8
+        sym_w, neu_w = sym_w / total, neu_w / total
+        self.temporal.store({
+            "task": task, "result": result,
+            "weights": {"symbolic": sym_w.item(), "neural": neu_w.item()},
+        })
+        return {"output": result, "symbolic_weight": sym_w.item(),
+                "neural_weight": neu_w.item(), "kg_context": kg_context,
+                "generation": self.generation}
+    def _default_evaluator(self, candidate):
+        scores = []
+        try:
+            orch = AetherAgentOrchestrator(candidate)
+            task_embed = torch.randn(1, candidate.macro_policy_dim)
+            blueprint = orch.hierarchical.generate_blueprint(task_embed)
+            scores.append(min(1.0, len(blueprint) / 4.0))
+            kg = KnowledgeGraphEngine(embedding_dim=candidate.kg_embedding_dim, num_relations=candidate.kg_num_relations)
+            for i in range(15):
+                kg.add_fact(f"Entity{i}", "connects_to", f"Entity{i+1}")
+            q = kg.query("Entity0 connects_to", top_k=5)
+            scores.append(min(1.0, len(q["results"]) / 3.0))
+            mem = WorkingMemory(capacity=candidate.working_memory_capacity)
+            for i in range(50):
+                mem.store({"idx": i, "data": list(range(10))})
+            retrieved = mem.retrieve("idx", top_k=5)
+            scores.append(min(1.0, len(retrieved) / 5.0))
+            balance = 1.0 - abs(candidate.macro_policy_dim - 256) / 256.0
+            scores.append(max(0.0, balance))
+        except Exception:
+            return -float("inf")
+        return float(np.mean(scores))
+    def evolve(self, num_generations=None, evaluator=None):
+        num_generations = num_generations or self.config.generations
+        evaluator = evaluator or self._default_evaluator
+        best_fitness = -float("inf")
+        best_config = None
+        for gen in range(num_generations):
+            self.generation = gen
+            candidates = self.evolution.generate_candidates(self.config, self.config.population_size)
+            fitness_scores = []
+            for candidate in candidates:
+                approved, score, reason = self.oversight.decide(candidate, self)
+                if approved:
+                    fitness = evaluator(candidate)
+                    fitness_scores.append(fitness)
+                else:
+                    fitness_scores.append(-float("inf"))
+            current_best = max((f for f in fitness_scores if f > -float("inf")), default=-float("inf"))
+            if self.oversight.should_rollback(current_best):
+                if self.oversight.last_good_config is not None:
+                    self.config = copy.deepcopy(self.oversight.last_good_config)
+                continue
+            selected = self.evolution.select(candidates, fitness_scores)
+            mutated = self.evolution.mutate(selected)
+            validated = []
+            validated_scores = []
+            for m in mutated:
+                ok, _, reason = self.oversight.decide(m, self)
+                if ok:
+                    validated.append(m)
+                    validated_scores.append(evaluator(m))
+            if validated and validated_scores:
+                best_idx = int(np.argmax(validated_scores))
+                best_mutated = validated[best_idx]
+                current_fitness = validated_scores[best_idx]
+                if current_fitness > best_fitness:
+                    best_fitness = current_fitness
+                    best_config = best_mutated
+                    self.config = best_mutated
+                    self.oversight.update_good_checkpoint(best_mutated, best_fitness)
+                    arch_hash = hashlib.sha256(json.dumps(asdict(best_mutated), sort_keys=True).encode()).hexdigest()[:16]
+                    self.architecture_history.append({
+                        "generation": gen, "hash": arch_hash,
+                        "fitness": best_fitness, "config": asdict(best_mutated),
+                    })
+            self.evolution.update_archive(candidates, fitness_scores)
+            self.fitness_log.append(best_fitness)
+        return {"best_fitness": best_fitness, "best_config": asdict(best_config) if best_config else None,
+                "generations": num_generations, "history": self.architecture_history,
+                "oversight_summary": self.oversight.summary(),
+                "archive_stats": self.evolution.get_diversity_stats()}
+    def self_reflect(self):
+        recs = []
+        if len(self.fitness_log) > 5:
+            recent = self.fitness_log[-5:]
+            if max(recent) - min(recent) < 0.01:
+                recs.append("Fitness plateau detected.")
+            if recent[-1] < recent[0]:
+                recs.append("Declining trend. Rollback or expand search.")
+        sym = torch.sigmoid(self.symbolic_gate).item()
+        if sym < 0.3:
+            recs.append("Symbolic reasoning underutilized.")
+        elif sym > 0.7:
+            recs.append("Symbolic dominance. Increase neural flexibility.")
+        return {"generation": self.generation,
+                "architectures_tested": len(self.architecture_history),
+                "fitness_trend": self.fitness_log,
+                "neuro_symbolic_balance": {"symbolic": sym, "neural": 1.0 - sym},
+                "recommendations": recs,
+                "oversight": self.oversight.summary()}
+    def export_state(self):
+        return {"config": asdict(self.config), "generation": self.generation,
+                "architecture_history": self.architecture_history,
+                "fitness_log": self.fitness_log, "metadata": self.metadata,
+                "knowledge": self.knowledge.export(),
+                "memory": self.memory.export(),
+                "model_state_dict": {k: v.cpu().tolist() for k, v in self.state_dict().items()}}
+    @classmethod
+    def from_state(cls, state):
+        cfg = AetherConfig(**state["config"])
+        core = cls(config=cfg)
+        core.generation = state["generation"]
+        core.architecture_history = state["architecture_history"]
+        core.fitness_log = state["fitness_log"]
+        core.metadata = state["metadata"]
+        core._knowledge = KnowledgeGraphEngine.from_export(
+            state.get("knowledge", {}),
+            embedding_dim=cfg.kg_embedding_dim,
+            num_relations=cfg.kg_num_relations,
+        )
+        return core
+
+aether_core = None
+stop_event = threading.Event()
+task_results = {}
+task_counter = 0
+
+def background_evolution():
+    global aether_core
+    gen_since_save = 0
+    SAVE_EVERY = 3
+    while not stop_event.is_set():
+        try:
+            if aether_core is not None:
+                print("[EVOLUTION] Running generation batch...")
+                result = aether_core.evolve(num_generations=1)
+                gen_since_save += 1
+                if gen_since_save >= SAVE_EVERY:
+                    save_state(aether_core.export_state(), name="latest")
+                    gen_since_save = 0
+                if result["best_fitness"] > 0.9:
+                    aether_core.knowledge.add_fact(
+                        f"Gen_{aether_core.generation}", "achieved", f"fitness_{result['best_fitness']:.4f}"
+                    )
+            time.sleep(30)
+        except Exception as e:
+            print(f"[EVOLUTION] Error: {e}")
+            time.sleep(10)
+
+def seed_knowledge(core):
+    facts = [
+        ("Intelligence", "requires", "Reasoning"),
+        ("Reasoning", "requires", "Memory"),
+        ("Memory", "enables", "Learning"),
+        ("Learning", "produces", "Intelligence"),
+        ("Agent", "has_role", "Researcher"),
+        ("Agent", "has_role", "Engineer"),
+        ("Agent", "has_role", "Analyzer"),
+        ("Agent", "has_role", "Integrator"),
+    ]
+    for h, r, t in facts:
+        core.knowledge.add_fact(h, r, t)
+
+@asynccontextmanager
+async def lifespan(app):
+    global aether_core
+    print("[STARTUP] Restoring AETHER state...")
+    saved = load_state("latest")
+    if saved:
+        try:
+            aether_core = AetherCore.from_state(saved)
+            print("[STARTUP] State restored from Hub")
+        except Exception as e:
+            print(f"[STARTUP] Restore failed: {e}, initializing fresh")
+            aether_core = AetherCore(AetherConfig())
+            seed_knowledge(aether_core)
+    else:
+        aether_core = AetherCore(AetherConfig())
+        seed_knowledge(aether_core)
+        print("[STARTUP] Fresh AETHER initialized")
+    init_scheduler()
+    thread = threading.Thread(target=background_evolution, daemon=True)
+    thread.start()
+    print("[STARTUP] Background evolution thread started")
+    yield
+    print("[SHUTDOWN] Stopping evolution thread...")
+    stop_event.set()
+    thread.join(timeout=5)
+    if aether_core:
+        save_state(aether_core.export_state(), name="latest")
+    print("[SHUTDOWN] State saved, exiting")
+
+app = FastAPI(title="AETHER Autonomous API", lifespan=lifespan)
+
+class TaskRequest(BaseModel):
+    task: str
+    context: Optional[Dict[str, Any]] = {}
+
+class ConfigUpdate(BaseModel):
+    mutation_rate: Optional[float] = None
+    population_size: Optional[int] = None
+    num_agents: Optional[int] = None
+
+@app.get("/status")
+async def get_status():
+    if aether_core is None:
+        return {"status": "initializing"}
+    ref = aether_core.self_reflect()
+    return {
+        "status": "running",
+        "generation": aether_core.generation,
+        "best_fitness": aether_core.fitness_log[-1] if aether_core.fitness_log else None,
+        "fitness_history": aether_core.fitness_log,
+        "architecture_changes": len(aether_core.architecture_history),
+        "kg_stats": aether_core.knowledge.stats(),
+        "agent_stats": aether_core.agents.stats(),
+        "reflection": ref,
+    }
+
+@app.post("/task")
+async def submit_task(req: TaskRequest, background: BackgroundTasks):
+    global task_counter
+    task_id = f"task_{task_counter}_{int(time.time())}"
+    task_counter += 1
+    def execute_task(tid, task, ctx):
+        try:
+            result = aether_core.forward(task, ctx)
+            task_results[tid] = {"status": "complete", "result": result, "timestamp": time.time()}
+        except Exception as e:
+            task_results[tid] = {"status": "error", "error": str(e), "timestamp": time.time()}
+    background.add_task(execute_task, task_id, req.task, req.context)
+    return {"task_id": task_id, "status": "queued"}
+
+@app.get("/task/{task_id}")
+async def get_task(task_id: str):
+    return task_results.get(task_id, {"status": "not_found"})
+
+@app.post("/evolve")
+async def trigger_evolve():
+    if aether_core is None:
+        return {"status": "error", "message": "AETHER not initialized"}
+    result = aether_core.evolve(num_generations=1)
+    save_state(aether_core.export_state(), name="latest")
+    return {"status": "evolved", "result": result}
+
+@app.get("/history")
+async def get_history():
+    if aether_core is None:
+        return {"history": []}
+    return {"history": aether_core.architecture_history}
+
+@app.get("/kg")
+async def get_kg():
+    if aether_core is None:
+        return {"kg": {}}
+    return {"kg": aether_core.knowledge.export()}
+
+@app.post("/kg/fact")
+async def add_kg_fact(head: str, relation: str, tail: str, confidence: float = 1.0):
+    if aether_core is None:
+        return {"status": "error"}
+    aether_core.knowledge.add_fact(head, relation, tail, confidence)
+    return {"status": "added", "kg_stats": aether_core.knowledge.stats()}
+
+@app.post("/config")
+async def update_config(update: ConfigUpdate):
+    if aether_core is None:
+        return {"status": "error"}
+    if update.mutation_rate is not None:
+        aether_core.config.mutation_rate = update.mutation_rate
+    if update.population_size is not None:
+        aether_core.config.population_size = update.population_size
+    if update.num_agents is not None:
+        aether_core.config.num_agents = update.num_agents
+    save_state(aether_core.export_state(), name="latest")
+    return {"status": "updated", "config": asdict(aether_core.config)}
+
+@app.get("/snapshot")
+async def get_snapshot():
+    if aether_core is None:
+        return {}
+    save_state(aether_core.export_state(), name="latest")
+    return {"status": "saved", "snapshot_path": str(STATE_DIR / "latest.json")}
+
+def get_live_status():
+    if aether_core is None:
+        return "Initializing..."
+    ref = aether_core.self_reflect()
+    lines = [
+        f"Generation: {aether_core.generation}",
+        f"Best Fitness: {aether_core.fitness_log[-1]:.4f}" if aether_core.fitness_log else "N/A",
+        f"Arch Changes: {len(aether_core.architecture_history)}",
+        f"KG Nodes: {aether_core.knowledge.stats()['num_nodes']}",
+        f"KG Edges: {aether_core.knowledge.stats()['num_edges']}",
+        f"Symbolic Gate: {ref['neuro_symbolic_balance']['symbolic']:.3f}",
+        f"Neural Gate: {ref['neuro_symbolic_balance']['neural']:.3f}",
+        "---",
+        "Recommendations:",
+    ]
+    lines.extend(ref["recommendations"] or ["No recommendations at this time"])
+    return "\n".join(lines)
+
+def get_history_text():
+    if aether_core is None:
+        return "No history"
+    lines = ["Generation | Hash | Fitness | Agents | Macro-Dim | Mut-Rate"]
+    for entry in aether_core.architecture_history:
+        lines.append(
+            f"  {entry['generation']:02d} | {entry['hash']} | {entry['fitness']:.4f} | "
+            f"{entry['config']['num_agents']} | {entry['config']['macro_policy_dim']} | {entry['config']['mutation_rate']:.3f}"
+        )
+    return "\n".join(lines)
+
+def execute_gradio_task(task_text):
+    if aether_core is None:
+        return "AETHER not ready"
+    result = aether_core.forward(task_text)
+    out_lines = [
+        f"Task: {task_text}",
+        f"Symbolic Weight: {result['symbolic_weight']:.3f}",
+        f"Neural Weight: {result['neural_weight']:.3f}",
+        f"Output: {result['output']['output'][:200]}...",
+        f"Agents: {list(result['output']['agent_outputs'].keys())}",
+    ]
+    return "\n".join(out_lines)
+
+with gr.Blocks(title="AETHER Monitor") as demo:
+    gr.Markdown("## 🧠 AETHER v0.3.0 — Autonomous Self-Evolving Architecture")
+    gr.Markdown("Runs 24/7. Evolves in background. State auto-persisted to Hub. REST API accessible at `/status`, `/task`, `/evolve`, etc.")
+    with gr.Row():
+        with gr.Column():
+            status_box = gr.Textbox(label="Live System Status", value=get_live_status, lines=12, every=5)
+            refresh_btn = gr.Button("🔄 Refresh")
+        with gr.Column():
+            history_box = gr.Textbox(label="Evolution History", value=get_history_text, lines=12, every=10)
+    with gr.Row():
+        with gr.Column():
+            task_input = gr.Textbox(label="Submit a Task", placeholder="e.g., Intelligence requires...")
+            task_btn = gr.Button("⚡ Execute")
+            task_output = gr.Textbox(label="Task Result", lines=6)
+        with gr.Column():
+            gr.Markdown("### Quick Actions")
+            evolve_btn = gr.Button("🧬 Trigger 1 Evolution Cycle")
+            evolve_out = gr.Textbox(label="Evolution Result", lines=4)
+            snapshot_btn = gr.Button("💾 Force Save Snapshot")
+            snapshot_out = gr.Textbox(label="Save Status", lines=2)
+    refresh_btn.click(get_live_status, outputs=status_box)
+    task_btn.click(execute_gradio_task, inputs=task_input, outputs=task_output)
+    evolve_btn.click(lambda: "Evolution triggered via API" if aether_core else "Not ready", outputs=evolve_out)
+    snapshot_btn.click(lambda: "Snapshot saved" if aether_core else "Not ready", outputs=snapshot_out)
+
+app = gr.mount_gradio_app(app, demo, path="/")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)