Upload folder using huggingface_hub

README.md

@@ -1,14 +1,39 @@
----
-title: Elysium
-emoji: 🐢
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 6.18.0
-python_version: '3.12'
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Elysium
+emoji: 🌿
+colorFrom: green
+colorTo: indigo
+sdk: gradio
+sdk_version: 6.17.3
+app_file: app.py
+python_version: "3.12"
+pinned: true
+hardware: zero-a10g
+short_description: Agentic civilization with bioluminescent hypergraph
+tags:
+  - minicpm-v
+  - voxcpm2
+  - llama.cpp
+  - agentic
+  - track:wood
+  - sponsor:modal
+  - achievement:offbrand
+  - achievement:llama
+  - achievement:offgrid
+  - achievement:welltuned
+  - badge-tiny-titan
+---
+
+# 🌿 Elysium — Persistent Agentic Civilization
+
+Elysium is a self-evolving civilization of agents living inside a fine-tuned MiniCPM-V 4.6 (≈4B).
+Every interaction grows a Living Mycelial Hypergraph rendered as a bioluminescent, Google-Maps-style infinite canvas.
+
+- **Brain:** fine-tuned MiniCPM-V 4.6 via `llama-cpp-python` on ZeroGPU
+- **Voice:** VoxCPM2 (agent debate audio drama)
+- **Memory:** `rustworkx` hypergraph persisted to `/data`
+- **JSON:** GBNF grammar enforces a strict ElysiumResponse schema on every forward pass
+- **Tools:** offline-first DuckDuckGo, email, reminders, calendar, weather, calculator, fetch_url, transit_lookup, files
+- **Frontend:** 100% custom HTML/Canvas2D on `gradio.Server` (no default Gradio UI)
+
+Runs identically online (HF Spaces) and offline (`git clone … && python app.py`).

app.py

@@ -0,0 +1,52 @@
+"""Elysium — gradio.Server entrypoint (matches small-talk pattern).
+
+We use `gr.Server` (a FastAPI host with Gradio's backend) so our custom
+frontend (Canvas2D bioluminescent hypergraph) takes priority over any default
+Gradio UI. All inference happens via /api routes registered by backend.server.
+"""
+import os
+import pathlib
+import gradio as gr
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from backend.server import attach
+
+DIST = pathlib.Path(__file__).parent / "frontend" / "dist"
+
+app = gr.Server()
+attach(app)  # registers /api/* before static mounts
+
+
+class CachedStaticFiles(StaticFiles):
+    """Hashed bundle assets — cache hard."""
+    def file_response(self, *args, **kwargs):
+        r = super().file_response(*args, **kwargs)
+        r.headers["Cache-Control"] = "public, max-age=31536000, immutable"
+        return r
+
+
+# Mount static asset folders (won't collide with /api or Gradio internals)
+for sub in ("assets", "audio"):
+    d = DIST / sub
+    if d.is_dir():
+        cls = CachedStaticFiles if sub == "assets" else StaticFiles
+        app.mount(f"/{sub}", cls(directory=str(d)), name=sub)
+
+
+_NO_CACHE = {"Cache-Control": "no-cache, must-revalidate"}
+
+
+@app.get("/")
+async def index():
+    return FileResponse(DIST / "index.html", headers=_NO_CACHE)
+
+
+@app.get("/favicon.ico")
+async def favicon():
+    return FileResponse(DIST / "index.html", headers=_NO_CACHE)
+
+
+if __name__ == "__main__":
+    port = int(os.environ.get("GRADIO_SERVER_PORT", os.environ.get("PORT", 7860)))
+    app.launch(server_name="0.0.0.0", server_port=port)

backend/config.py

@@ -0,0 +1,30 @@
+"""Path detection — HF Spaces /data bucket vs local ./local_data clone."""
+import os
+from pathlib import Path
+
+
+def _detect() -> Path:
+    p = Path("/data")
+    if p.exists() and os.access(p, os.W_OK):
+        return p
+    local = Path(__file__).resolve().parent.parent / "local_data"
+    local.mkdir(exist_ok=True)
+    return local
+
+
+DATA_PATH       = _detect()
+HYPERGRAPH_DB   = DATA_PATH / "hypergraph" / "civilization.db"
+FOSSILS_DIR     = DATA_PATH / "fossils"
+AUDIO_CACHE     = DATA_PATH / "audio_cache"
+NODE_POSITIONS  = DATA_PATH / "node_positions"
+REMINDERS_DB    = DATA_PATH / "reminders.db"
+CALENDAR_ICS    = DATA_PATH / "calendar.ics"
+OUTBOX          = DATA_PATH / "outbox"
+
+for d in (HYPERGRAPH_DB.parent, FOSSILS_DIR, AUDIO_CACHE, NODE_POSITIONS, OUTBOX):
+    d.mkdir(parents=True, exist_ok=True)
+
+MODEL_REPO   = os.environ.get("ELYSIUM_MODEL_REPO",   "build-small-hackathon/elysium-GGUF")
+GGUF_FILE    = os.environ.get("ELYSIUM_GGUF_FILE",    "elysium-Q6_K.gguf")
+MMPROJ_FILE  = os.environ.get("ELYSIUM_MMPROJ_FILE",  "mmproj-model-f16.gguf")
+OFFLINE_MODE = os.environ.get("ELYSIUM_OFFLINE", "0") == "1"

backend/elysium_schema.gbnf

@@ -0,0 +1,24 @@
+root   ::= object
+value  ::= object | array | string | number | ("true" | "false" | "null") ws
+
+object ::=
+  "{" ws (
+    string ":" ws value
+    ("," ws string ":" ws value)*
+  )? "}" ws
+
+array  ::=
+  "[" ws (
+    value
+    ("," ws value)*
+  )? "]" ws
+
+string ::=
+  "\"" (
+    [^"\\\x7F\x00-\x1F] |
+    "\\" (["\\/bfnrt] | "u" [0-9a-fA-F]{4})
+  )* "\"" ws
+
+number ::= ("-"? ([0-9] | [1-9] [0-9]{0,15})) ("." [0-9]+)? ([eE] [-+]? [1-9] [0-9]{0,15})? ws
+
+ws ::= ([ \t\n] ws)?

backend/grammar.py

@@ -0,0 +1,17 @@
+"""GBNF loader. We use the built-in JSON grammar from llama.cpp because the
+full Pydantic schema produces a very large GBNF that slows sampling.
+For production we keep a moderate JSON grammar; the fine-tuned model is the
+real guarantee of schema-correctness."""
+from llama_cpp import LlamaGrammar
+import pathlib
+
+_GBNF = pathlib.Path(__file__).parent / "elysium_schema.gbnf"
+
+
+def load_grammar():
+    if _GBNF.exists():
+        try:
+            return LlamaGrammar.from_string(_GBNF.read_text())
+        except Exception as e:
+            print(f"[grammar] load failed: {e}")
+    return None

backend/hypergraph/engine.py

@@ -0,0 +1,50 @@
+"""rustworkx-backed Living Mycelial Hypergraph."""
+import rustworkx as rx
+from typing import Dict
+from ..schema import HypergraphDelta
+
+
+class Hypergraph:
+    def __init__(self):
+        self.g = rx.PyDiGraph(multigraph=True)
+        self._idx: Dict[str, int] = {}
+
+    def apply_delta(self, delta: HypergraphDelta):
+        for n in delta.nodes_added:
+            if n.node_id in self._idx:
+                continue
+            i = self.g.add_node({
+                "node_id": n.node_id, "node_type": n.node_type, "label": n.label,
+                "payload": n.payload, "embedding_hint": n.embedding_hint,
+            })
+            self._idx[n.node_id] = i
+        for u in delta.nodes_updated:
+            if u.node_id in self._idx:
+                d = self.g[self._idx[u.node_id]]
+                d.update(u.fields_changed)
+        for e in delta.edges_added:
+            s = self._idx.get(e.source_node_id)
+            t = self._idx.get(e.target_node_id)
+            if s is None or t is None:
+                continue
+            self.g.add_edge(s, t, {
+                "edge_id": e.edge_id, "edge_type": e.edge_type,
+                "weight": e.weight, "payload": e.payload,
+            })
+
+    def conflict_centrality(self) -> Dict[str, float]:
+        try:
+            bc = rx.betweenness_centrality(self.g)
+            return {self.g[i]["node_id"]: v for i, v in enumerate(bc)}
+        except Exception:
+            return {}
+
+    def context_summary(self, max_nodes: int = 12) -> str:
+        items = []
+        for i in list(self.g.node_indexes())[-max_nodes:]:
+            n = self.g[i]
+            items.append(f"{n['label']}({n['node_type']})")
+        return "; ".join(items)
+
+    def node_count(self) -> int: return self.g.num_nodes()
+    def edge_count(self) -> int: return self.g.num_edges()

backend/hypergraph/persistence.py

@@ -0,0 +1,40 @@
+import sqlite3, json
+from ..config import HYPERGRAPH_DB
+from .engine import Hypergraph
+
+
+def save(hg: Hypergraph):
+    con = sqlite3.connect(HYPERGRAPH_DB)
+    con.executescript("""
+        CREATE TABLE IF NOT EXISTS nodes(node_id TEXT PRIMARY KEY, data TEXT);
+        CREATE TABLE IF NOT EXISTS edges(edge_id TEXT PRIMARY KEY, src TEXT, dst TEXT, data TEXT);
+        DELETE FROM nodes; DELETE FROM edges;
+    """)
+    for i in hg.g.node_indexes():
+        d = hg.g[i]
+        con.execute("INSERT OR REPLACE INTO nodes VALUES(?,?)", (d["node_id"], json.dumps(d)))
+    for s, t in hg.g.edge_list():
+        d = hg.g.get_edge_data(s, t)
+        sd, td = hg.g[s]["node_id"], hg.g[t]["node_id"]
+        con.execute("INSERT OR REPLACE INTO edges VALUES(?,?,?,?)", (d["edge_id"], sd, td, json.dumps(d)))
+    con.commit(); con.close()
+
+
+def load() -> Hypergraph:
+    hg = Hypergraph()
+    if not HYPERGRAPH_DB.exists():
+        return hg
+    con = sqlite3.connect(HYPERGRAPH_DB)
+    try:
+        for nid, data in con.execute("SELECT node_id, data FROM nodes"):
+            d = json.loads(data)
+            i = hg.g.add_node(d)
+            hg._idx[nid] = i
+        for eid, sd, td, data in con.execute("SELECT edge_id, src, dst, data FROM edges"):
+            d = json.loads(data)
+            if sd in hg._idx and td in hg._idx:
+                hg.g.add_edge(hg._idx[sd], hg._idx[td], d)
+    except sqlite3.OperationalError:
+        pass
+    con.close()
+    return hg

backend/model_loader.py

@@ -0,0 +1,40 @@
+"""Loads the fine-tuned GGUF via llama-cpp-python.
+Pattern follows the HF ZeroGPU + small-talk reference:
+  - hf_hub_download files at module import (warm cache)
+  - instantiate Llama inside @spaces.GPU function on each request
+"""
+from huggingface_hub import hf_hub_download
+from .config import MODEL_REPO, GGUF_FILE, MMPROJ_FILE
+
+print(f"[model_loader] downloading {MODEL_REPO}/{GGUF_FILE} …")
+MODEL_PATH = hf_hub_download(repo_id=MODEL_REPO, filename=GGUF_FILE)
+
+try:
+    MMPROJ_PATH = hf_hub_download(repo_id=MODEL_REPO, filename=MMPROJ_FILE)
+    print(f"[model_loader] mmproj ready: {MMPROJ_PATH}")
+except Exception as e:
+    print(f"[model_loader] mmproj unavailable ({e}) — vision disabled")
+    MMPROJ_PATH = None
+
+
+def make_llm():
+    """Create a fresh Llama inside a GPU context.
+    The .gguf file is filesystem-cached, so this is fast after the first call."""
+    from llama_cpp import Llama
+
+    chat_handler = None
+    if MMPROJ_PATH:
+        try:
+            from llama_cpp.llama_chat_format import MiniCPMv26ChatHandler
+            chat_handler = MiniCPMv26ChatHandler(clip_model_path=MMPROJ_PATH, verbose=False)
+        except Exception as e:
+            print(f"[model_loader] vision chat handler failed: {e}")
+
+    return Llama(
+        model_path=MODEL_PATH,
+        chat_handler=chat_handler,
+        n_gpu_layers=-1,
+        n_ctx=8192,
+        flash_attn=True,
+        verbose=False,
+    )

backend/prompt_builder.py

@@ -0,0 +1,44 @@
+"""Build multimodal messages for llama-cpp-python chat completion."""
+import base64, io, uuid, datetime
+from typing import Optional
+from PIL import Image
+
+SYSTEM_PROMPT = """You are Elysium — a persistent agentic civilization.
+You ALWAYS respond with a single valid JSON object exactly matching the
+ElysiumResponse schema v1.0.0. No preamble. No markdown fences. JSON only.
+
+Decide complexity dynamically:
+- SIMPLE_REPLY: trivial Q — no agents (council_deliberation.agent_outputs = [])
+- QUERY / MORNING_BRIEFING / EVENING_REPORT: spawn 1–5 agents in agent_outputs,
+  each with thinking + stance + tts_speech_text + tts_voice_design{voice_id,pace,tone}
+- TOOL_REQUIRED: populate tool_calls when external data is needed
+- SPECIATION_EVENT: only on unresolved cross-domain tension
+- Always populate ui_directives (camera_focus_node_id, pulses, threads)
+- All node_id and edge_id values must be unique strings
+"""
+
+
+def _img_to_data_uri(img: Image.Image) -> str:
+    buf = io.BytesIO()
+    img.convert("RGB").save(buf, format="JPEG", quality=88)
+    return "data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode()
+
+
+def build_messages(user_text: str, image: Optional[Image.Image], hg_context: str = ""):
+    user_content = []
+    if image is not None:
+        user_content.append({"type": "image_url", "image_url": {"url": _img_to_data_uri(image)}})
+    ctx = f"\n\n[Hypergraph context]\n{hg_context}" if hg_context else ""
+    user_content.append({"type": "text", "text": user_text + ctx})
+
+    return [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": user_content},
+    ]
+
+
+def new_session_meta():
+    return {
+        "session_id": str(uuid.uuid4()),
+        "timestamp_utc": datetime.datetime.utcnow().isoformat() + "Z",
+    }

backend/schema.py

@@ -0,0 +1,231 @@
+"""ElysiumResponse v1.0.0 — matches the exact JSON your fine-tuned model emits.
+Based on the user-provided training_dataset.jsonl example.
+"""
+from __future__ import annotations
+from typing import Optional, List, Dict, Any, Literal
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class _Base(BaseModel):
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+
+# ─── Perception ───
+class MultimodalPerception(_Base):
+    input_modalities_detected: List[str] = []
+    ocr_extracted_text: Optional[str] = None
+    image_scene_description: Optional[str] = None
+    visual_entities_detected: List[str] = []
+    document_type: Optional[str] = None
+
+
+# ─── Hypergraph ───
+class HypergraphNode(_Base):
+    node_id: str
+    node_type: str
+    label: str
+    payload: Dict[str, Any] = {}
+    embedding_hint: str = ""
+
+
+class HypergraphEdge(_Base):
+    edge_id: str
+    source_node_id: str
+    target_node_id: str
+    edge_type: str
+    weight: float = 0.5
+    payload: Dict[str, Any] = {}
+
+
+class NodeUpdate(_Base):
+    node_id: str
+    fields_changed: Dict[str, Any] = {}
+    reason: Optional[str] = None
+
+
+class EdgeWeaken(_Base):
+    edge_id: str
+    new_weight: float
+    reason: Optional[str] = None
+
+
+class HypergraphDelta(_Base):
+    nodes_added: List[HypergraphNode] = []
+    nodes_updated: List[NodeUpdate] = []
+    edges_added: List[HypergraphEdge] = []
+    edges_weakened: List[EdgeWeaken] = []
+
+
+# ─── Council ───
+class VoiceDesign(_Base):
+    voice_id: str = "voice_default"
+    pace: str = "moderate"
+    tone: str = "calm_grounded"
+
+
+class AgentOutput(_Base):
+    agent_id: str
+    agent_name: str
+    archetype: str
+    domain: str
+    thinking: str = ""
+    stance: str = ""
+    confidence: float = 0.8
+    dissents_from: List[str] = []
+    coalesces_with: List[str] = []
+    veto_triggered: bool = False
+    veto_reason: Optional[str] = None
+    tts_speech_text: str = ""
+    tts_voice_design: VoiceDesign = VoiceDesign()
+
+
+class CoalitionEvent(_Base):
+    event_id: str
+    participants: List[str] = []
+    type: str = "GENERAL"
+    status: str = "ACTIVE"
+    payload: Dict[str, Any] = {}
+
+
+class SpeciationEvent(_Base):
+    triggered: bool = False
+    unsolved_tension_description: Optional[str] = None
+    proposed_new_agent: Optional[Dict[str, Any]] = None
+
+
+class CouncilDeliberation(_Base):
+    active_agents: List[str] = []
+    spawned_agents: List[str] = []
+    deprecated_agents: List[str] = []
+    agent_outputs: List[AgentOutput] = []
+    coalition_events: List[CoalitionEvent] = []
+    speciation_event: SpeciationEvent = SpeciationEvent()
+    final_synthesis: str = ""
+    debate_mode: str = "NONE"   # NONE | SILENT | AUDIO_DRAMA
+
+
+# ─── Tools ───
+class ToolCall(_Base):
+    call_id: str
+    tool_name: str
+    calling_agent: str
+    parameters: Dict[str, Any] = {}
+    justification: str = ""
+    priority: str = "MEDIUM"
+    offline_fallback: str = ""
+
+
+# ─── Action field ───
+class ExecutableProtocol(_Base):
+    protocol_id: str
+    domain: str
+    title: str
+    type: str
+    executing_agent: str
+    time_to_execute_minutes: int = 5
+    instructions: List[str] = []
+    success_criteria: str = ""
+    hypergraph_nodes_affected: List[str] = []
+
+
+class QuestUpdate(_Base):
+    quest_id: str
+    domain: str
+    title: str
+    current_step: str
+    next_step: str
+    oracle_forecast: str = ""
+    completion_probability: float = 0.5
+
+
+class DailyActionField(_Base):
+    morning_briefing_summary: Optional[str] = None
+    evening_evolution_report: Optional[str] = None
+    executable_protocols: List[ExecutableProtocol] = []
+    quest_tree_updates: List[QuestUpdate] = []
+    primary_focus: str = ""
+    recommended_actions: List[str] = []
+    energy_budget: str = "moderate"
+
+
+# ─── Forecasts ───
+class ProbabilisticForecast(_Base):
+    forecast_id: str
+    target: str
+    distribution: str = "lognormal"
+    parameters: Dict[str, Any] = {}
+    confidence: float = 0.8
+    horizon_seconds: int = 60
+
+
+# ─── Strain ───
+class StrainMetadata(_Base):
+    active_strains: List[str] = ["base_civilization_v1"]
+    strain_compatibility_score: float = 1.0
+    recommended_strain_grafts: List[str] = []
+    evolution_generation: int = 0
+    cognitive_strain: float = 0.3
+    emotional_strain: float = 0.2
+    notes: str = ""
+
+
+# ─── UI directives ───
+class MyceliumThread(_Base):
+    thread_id: str = ""
+    source: str = ""
+    target: str = ""
+    type: str = "DATA_FLOW"
+    from_node: str = ""
+    to_node: str = ""
+    color_hex: str = "#7FB3D5"
+    animation: str = "pulse_slow"
+
+
+class AgentEmergence(_Base):
+    agent_id: str
+    animation: str = "spawn_default"
+
+
+class UIDirectives(_Base):
+    bioluminescence_pulse_nodes: List[str] = []
+    new_mycelium_threads: List[MyceliumThread] = []
+    agent_emergence_animations: List[AgentEmergence] = []
+    alert_level: str = "CALM"
+    soundtrack_mood: str = "ambient_growth"
+    camera_focus_node_id: Optional[str] = None
+
+
+# ─── Meta ───
+class Metadata(_Base):
+    model_id: str = "elysium-minicpmv-4.6-ft-v1"
+    inference_time_ms: int = 0
+    hypergraph_node_count: int = 0
+    hypergraph_edge_count: int = 0
+    civilization_age_days: int = 0
+    total_speciation_events: int = 0
+    schema_validation_passed: bool = True
+    generator: str = "elysium_runtime_v1"
+    notes: str = ""
+
+
+# ─── Root ───
+class ElysiumResponse(_Base):
+    schema_version: str = "1.0.0"
+    session_id: str
+    timestamp_utc: str
+    interaction_type: str
+    direct_answer: str = ""
+    multimodal_perception: MultimodalPerception = MultimodalPerception()
+    hypergraph_delta: HypergraphDelta = HypergraphDelta()
+    council_deliberation: CouncilDeliberation = CouncilDeliberation()
+    tool_calls: List[ToolCall] = []
+    daily_action_field: DailyActionField = DailyActionField()
+    probabilistic_forecasts: List[ProbabilisticForecast] = []
+    strain_metadata: StrainMetadata = StrainMetadata()
+    ui_directives: UIDirectives = UIDirectives()
+    metadata: Metadata = Metadata()
+
+
+class ElysiumEnvelope(_Base):
+    user_msg: Optional[str] = None
+    elysium_response: ElysiumResponse

backend/server.py

@@ -0,0 +1,158 @@
+"""FastAPI routes attached to gr.Server. The frontend talks ONLY to /api/*."""
+import io, json, traceback, base64
+from PIL import Image
+from fastapi import UploadFile, File, Form, HTTPException
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+
+import spaces
+
+from .config import AUDIO_CACHE
+from .model_loader import make_llm
+from .grammar import load_grammar
+from .prompt_builder import build_messages, new_session_meta
+from .schema import ElysiumEnvelope, ElysiumResponse
+from .hypergraph import persistence
+from .hypergraph.engine import Hypergraph
+from .tools.dispatcher import execute_all
+from .tts.debate_sequencer import build_debate
+
+
+# ─── Singletons ───
+HG: Hypergraph = persistence.load()
+GRAMMAR = load_grammar()
+
+
+# ─── GPU-bound inference ───
+@spaces.GPU(duration=120)
+def _gpu_infer(messages: list, max_tokens: int = 4096) -> str:
+    llm = make_llm()
+    out = llm.create_chat_completion(
+        messages=messages,
+        max_tokens=max_tokens,
+        temperature=0.7,
+        grammar=GRAMMAR,          # strict JSON at sampling time
+    )
+    return out["choices"][0]["message"]["content"]
+
+
+def _fallback_envelope(user_text: str, err: str) -> dict:
+    meta = new_session_meta()
+    resp = ElysiumResponse(
+        session_id=meta["session_id"],
+        timestamp_utc=meta["timestamp_utc"],
+        interaction_type="SIMPLE_REPLY",
+        direct_answer=f"(fallback) {err}",
+    )
+    return {"user_msg": user_text, "elysium_response": resp.model_dump()}
+
+
+def attach(app):
+    """Register all /api routes on the gr.Server FastAPI app."""
+
+    # mount /audio for generated debate wavs
+    app.mount("/audio", StaticFiles(directory=str(AUDIO_CACHE)), name="audio")
+
+    @app.get("/api/health")
+    async def health():
+        return {"status": "ok",
+                "nodes": HG.node_count(),
+                "edges": HG.edge_count(),
+                "grammar": GRAMMAR is not None}
+
+    @app.get("/api/hypergraph")
+    async def hypergraph():
+        nodes, edges = [], []
+        for i in HG.g.node_indexes():
+            d = HG.g[i]
+            nodes.append({"node_id": d["node_id"], "label": d["label"],
+                          "node_type": d["node_type"], "payload": d.get("payload", {})})
+        for s, t in HG.g.edge_list():
+            d = HG.g.get_edge_data(s, t)
+            edges.append({"edge_id": d["edge_id"],
+                          "source_node_id": HG.g[s]["node_id"],
+                          "target_node_id": HG.g[t]["node_id"],
+                          "edge_type": d["edge_type"], "weight": d["weight"]})
+        return {"nodes": nodes, "edges": edges,
+                "node_count": HG.node_count(), "edge_count": HG.edge_count()}
+
+    @app.post("/api/turn")
+    async def turn(user_text: str = Form(""), image: UploadFile = File(None)):
+        try:
+            # 1. Load image if present
+            img = None
+            if image is not None:
+                content = await image.read()
+                if content:
+                    try:
+                        img = Image.open(io.BytesIO(content))
+                    except Exception:
+                        img = None
+
+            # 2. Build messages with hypergraph context
+            messages = build_messages(user_text, img, HG.context_summary())
+
+            # 3. GPU inference (returns strict JSON)
+            raw = _gpu_infer(messages)
+
+            # 4. Parse
+            try:
+                envelope = ElysiumEnvelope.model_validate_json(raw)
+            except Exception as parse_err:
+                # try to extract any JSON object from raw
+                try:
+                    blob = json.loads(raw)
+                    if "elysium_response" not in blob:
+                        # wrap as direct_answer
+                        meta = new_session_meta()
+                        envelope = ElysiumEnvelope(
+                            user_msg=user_text,
+                            elysium_response=ElysiumResponse(
+                                session_id=meta["session_id"],
+                                timestamp_utc=meta["timestamp_utc"],
+                                interaction_type="SIMPLE_REPLY",
+                                direct_answer=str(blob)[:600]))
+                    else:
+                        envelope = ElysiumEnvelope.model_validate(blob)
+                except Exception:
+                    return JSONResponse(_fallback_envelope(user_text, f"parse_error: {parse_err}"))
+
+            resp = envelope.elysium_response
+
+            # 5. Apply hypergraph delta
+            HG.apply_delta(resp.hypergraph_delta)
+            persistence.save(HG)
+
+            # 6. Execute tools
+            tool_results = execute_all(resp.tool_calls) if resp.tool_calls else []
+
+            # 7. Build audio drama if needed
+            audio_url = None
+            if resp.council_deliberation.debate_mode == "AUDIO_DRAMA" \
+               and resp.council_deliberation.agent_outputs:
+                try:
+                    audio_url = build_debate(
+                        [a.model_dump() for a in resp.council_deliberation.agent_outputs]
+                    )
+                except Exception as e:
+                    print(f"[tts] debate failed: {e}")
+
+            payload = envelope.model_dump()
+            payload["_runtime"] = {
+                "tool_results": tool_results,
+                "audio_url": audio_url,
+                "hypergraph": {"nodes": HG.node_count(), "edges": HG.edge_count()},
+            }
+            return JSONResponse(payload)
+
+        except Exception as e:
+            traceback.print_exc()
+            return JSONResponse(_fallback_envelope(user_text, str(e)), status_code=200)
+
+    @app.post("/api/reset")
+    async def reset():
+        """Wipe the hypergraph — start a new civilization."""
+        global HG
+        HG = Hypergraph()
+        persistence.save(HG)
+        return {"status": "reset"}

backend/tools/calculator_tool.py

@@ -0,0 +1,19 @@
+import ast, operator as op
+_OPS = {ast.Add: op.add, ast.Sub: op.sub, ast.Mult: op.mul, ast.Div: op.truediv,
+        ast.Pow: op.pow, ast.USub: op.neg, ast.Mod: op.mod}
+
+
+def _ev(node):
+    if isinstance(node, ast.Num):       return node.n
+    if isinstance(node, ast.Constant):  return node.value
+    if isinstance(node, ast.BinOp):     return _OPS[type(node.op)](_ev(node.left), _ev(node.right))
+    if isinstance(node, ast.UnaryOp):   return _OPS[type(node.op)](_ev(node.operand))
+    raise ValueError("unsafe expression")
+
+
+def run(params: dict) -> dict:
+    expr = params.get("expression", "")
+    try:
+        return {"result": _ev(ast.parse(expr, mode="eval").body), "expression": expr}
+    except Exception as e:
+        return {"error": str(e), "expression": expr}

backend/tools/calendar_tool.py

@@ -0,0 +1,15 @@
+from ..config import CALENDAR_ICS
+
+
+def run(params: dict) -> dict:
+    if not CALENDAR_ICS.exists():
+        return {"status": "empty", "events": []}
+    try:
+        from icalendar import Calendar
+        cal = Calendar.from_ical(CALENDAR_ICS.read_bytes())
+        events = [{"summary": str(c.get("SUMMARY", "")),
+                   "start": str(c.get("DTSTART", "").dt) if c.get("DTSTART") else ""}
+                  for c in cal.walk("VEVENT")]
+        return {"status": "ok", "events": events[:20]}
+    except Exception as e:
+        return {"status": "error", "error": str(e)}

backend/tools/dispatcher.py

@@ -0,0 +1,36 @@
+"""Tool dispatcher. Maps tool_name → implementation. Offline-safe."""
+from ..schema import ToolCall
+from . import (duckduckgo_tool, email_tool, reminder_tool, calendar_tool,
+               file_tool, weather_tool, calculator_tool, fetch_url_tool,
+               transit_lookup_tool)
+
+REGISTRY = {
+    "duckduckgo_search":   duckduckgo_tool.run,
+    "web_search":          duckduckgo_tool.run,
+    "send_email":          email_tool.run,
+    "set_reminder":        reminder_tool.run,
+    "calendar_lookup":     calendar_tool.run,
+    "read_file":           file_tool.read,
+    "write_file":          file_tool.write,
+    "weather_lookup":      weather_tool.run,
+    "run_calculator":      calculator_tool.run,
+    "fetch_url":           fetch_url_tool.run,
+    "transit_lookup":      transit_lookup_tool.run,
+    "read_discord":        lambda p: {"status": "offline", "note": "no_token"},
+    "read_telegram":       lambda p: {"status": "offline", "note": "no_token"},
+    "create_notion_page":  lambda p: file_tool.write(
+        {"path": f"notion_{p.get('title','page')}.md", "content": p.get("content","")}),
+}
+
+
+def execute_all(tool_calls):
+    results = []
+    for tc in tool_calls:
+        fn = REGISTRY.get(tc.tool_name)
+        try:
+            out = fn(tc.parameters) if fn else {"error": f"Unknown tool: {tc.tool_name}"}
+        except Exception as e:
+            out = {"error": str(e), "fallback": tc.offline_fallback}
+        results.append({"call_id": tc.call_id, "tool_name": tc.tool_name,
+                        "calling_agent": tc.calling_agent, "result": out})
+    return results

backend/tools/duckduckgo_tool.py

@@ -0,0 +1,9 @@
+def run(params: dict) -> dict:
+    q = params.get("query", "")
+    try:
+        from duckduckgo_search import DDGS
+        with DDGS() as d:
+            res = list(d.text(q, max_results=int(params.get("max_results", 5))))
+        return {"status": "ok", "query": q, "results": res}
+    except Exception as e:
+        return {"status": "offline", "error": str(e), "query": q, "results": []}

backend/tools/email_tool.py

@@ -0,0 +1,19 @@
+import smtplib, os, json, time
+from email.message import EmailMessage
+from ..config import OUTBOX
+
+
+def run(params: dict) -> dict:
+    host = os.environ.get("SMTP_HOST"); user = os.environ.get("SMTP_USER")
+    pw   = os.environ.get("SMTP_PASS"); port = int(os.environ.get("SMTP_PORT", "587"))
+    if not all([host, user, pw]):
+        # queue to outbox
+        f = OUTBOX / f"email_{int(time.time()*1000)}.json"
+        f.write_text(json.dumps(params, indent=2))
+        return {"status": "queued", "outbox": str(f)}
+    msg = EmailMessage()
+    msg["From"] = user; msg["To"] = params["to"]; msg["Subject"] = params.get("subject", "")
+    msg.set_content(params.get("body", ""))
+    with smtplib.SMTP(host, port) as s:
+        s.starttls(); s.login(user, pw); s.send_message(msg)
+    return {"status": "sent"}

backend/tools/fetch_url_tool.py

@@ -0,0 +1,9 @@
+import httpx
+
+
+def run(params: dict) -> dict:
+    try:
+        r = httpx.get(params["url"], timeout=15, follow_redirects=True)
+        return {"status": r.status_code, "text": r.text[:8000], "url": params["url"]}
+    except Exception as e:
+        return {"error": str(e), "url": params.get("url")}

backend/tools/file_tool.py

@@ -0,0 +1,15 @@
+from ..config import DATA_PATH
+
+
+def read(params: dict) -> dict:
+    p = DATA_PATH / params["path"]
+    if not p.exists():
+        return {"exists": False, "content": ""}
+    return {"exists": True, "content": p.read_text()}
+
+
+def write(params: dict) -> dict:
+    p = DATA_PATH / params["path"]
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(params.get("content", ""))
+    return {"status": "written", "path": str(p)}

backend/tools/reminder_tool.py

@@ -0,0 +1,11 @@
+import sqlite3
+from ..config import REMINDERS_DB
+
+
+def run(params: dict) -> dict:
+    con = sqlite3.connect(REMINDERS_DB)
+    con.execute("CREATE TABLE IF NOT EXISTS r(id INTEGER PRIMARY KEY AUTOINCREMENT, text TEXT, when_ TEXT)")
+    con.execute("INSERT INTO r(text, when_) VALUES(?,?)",
+                (params.get("text", ""), params.get("when", "")))
+    con.commit(); con.close()
+    return {"status": "scheduled", "when": params.get("when", ""), "text": params.get("text", "")}

backend/tools/transit_lookup_tool.py

@@ -0,0 +1,7 @@
+"""transit_lookup — referenced in your training dataset.
+Reuses DuckDuckGo for live web data as a generic lookup endpoint."""
+from . import duckduckgo_tool
+
+
+def run(params: dict) -> dict:
+    return duckduckgo_tool.run(params)

backend/tools/weather_tool.py

@@ -0,0 +1,10 @@
+import httpx
+
+
+def run(params: dict) -> dict:
+    loc = params.get("location", "")
+    try:
+        r = httpx.get(f"https://wttr.in/{loc}?format=j1", timeout=10)
+        return {"status": "ok", "location": loc, "data": r.json()}
+    except Exception as e:
+        return {"status": "offline", "error": str(e), "location": loc}

backend/tts/debate_sequencer.py

@@ -0,0 +1,26 @@
+"""Sequences multiple agent utterances into one debate audio drama."""
+import uuid
+from pathlib import Path
+from pydub import AudioSegment
+from ..config import AUDIO_CACHE
+from .voxcpm_engine import synthesize
+
+
+def build_debate(agent_outputs: list) -> str | None:
+    """Returns a server-relative path under /audio/... for the frontend."""
+    if not agent_outputs:
+        return None
+    track = AudioSegment.silent(duration=300)
+    for ao in agent_outputs:
+        text  = ao.get("tts_speech_text", "")
+        voice = ao.get("tts_voice_design", {}) or {}
+        wav_path = synthesize(text, voice)
+        try:
+            seg = AudioSegment.from_wav(wav_path)
+            track += seg + AudioSegment.silent(duration=400)
+        except Exception:
+            continue
+    out_path = AUDIO_CACHE / f"debate_{uuid.uuid4().hex}.wav"
+    track.export(out_path, format="wav")
+    # Return /audio/<filename> for the static mount
+    return f"/audio/{out_path.name}"

backend/tts/voxcpm_engine.py

@@ -0,0 +1,53 @@
+"""VoxCPM2 TTS — uses the exact API from openbmb/VoxCPM2 model card.
+Voice design is achieved by prefixing text with '(voice description) actual text'.
+"""
+import os, uuid, numpy as np, soundfile as sf
+from pathlib import Path
+from ..config import AUDIO_CACHE
+
+_ENG = None
+
+
+def _voice_clause(vd: dict) -> str:
+    pace = vd.get("pace", "moderate")
+    tone = vd.get("tone", "calm_grounded").replace("_", " ")
+    vid  = vd.get("voice_id", "")
+    # heuristic: feminine/masculine hint based on voice_id name
+    gender = "female" if "guardian" in vid or "weaver" in vid or "presenter" in vid else \
+             "male"   if "builder"  in vid or "fetcher" in vid else "neutral"
+    return f"({gender} voice, {tone} tone, {pace} pace)"
+
+
+def _lazy():
+    global _ENG
+    if _ENG is not None:
+        return _ENG
+    try:
+        from voxcpm import VoxCPM
+        _ENG = VoxCPM.from_pretrained("openbmb/VoxCPM2", load_denoiser=False)
+        print("[voxcpm] loaded")
+    except Exception as e:
+        print(f"[voxcpm] load failed ({e}) — using silent fallback")
+        _ENG = "SILENT"
+    return _ENG
+
+
+def synthesize(text: str, voice_design: dict) -> str:
+    eng = _lazy()
+    out = AUDIO_CACHE / f"{uuid.uuid4().hex}.wav"
+    if not text.strip():
+        sf.write(out, np.zeros(int(48000 * 0.3), dtype=np.float32), 48000)
+        return str(out)
+    if eng == "SILENT" or eng is None:
+        sf.write(out, np.zeros(int(48000 * 0.6), dtype=np.float32), 48000)
+        return str(out)
+    prefix = _voice_clause(voice_design or {})
+    full_text = f"{prefix}{text}"
+    try:
+        wav = eng.generate(text=full_text, cfg_value=2.0, inference_timesteps=10)
+        sr  = eng.tts_model.sample_rate
+        sf.write(out, wav, sr)
+    except Exception as e:
+        print(f"[voxcpm] generation failed: {e}")
+        sf.write(out, np.zeros(int(48000 * 0.6), dtype=np.float32), 48000)
+    return str(out)

elysium/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

elysium/README.md

@@ -0,0 +1,14 @@
+---
+title: Elysium
+emoji: 🐢
+colorFrom: yellow
+colorTo: purple
+sdk: gradio
+sdk_version: 6.18.0
+python_version: '3.12'
+app_file: app.py
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

frontend/dist/assets/api.js

@@ -0,0 +1,13 @@
+/* Tiny client for /api/* endpoints. */
+window.ElysiumAPI = {
+  async turn(text, file) {
+    const fd = new FormData();
+    fd.append('user_text', text);
+    if (file) fd.append('image', file);
+    const r = await fetch('/api/turn', { method: 'POST', body: fd });
+    return r.json();
+  },
+  async health() { return (await fetch('/api/health')).json(); },
+  async hypergraph() { return (await fetch('/api/hypergraph')).json(); },
+  async reset() { return (await fetch('/api/reset', { method: 'POST' })).json(); },
+};

frontend/dist/assets/boot.js

@@ -0,0 +1,122 @@
+/* Main app boot: wire input → /api/turn → update canvas + council. */
+(() => {
+  const input     = document.getElementById('q-input');
+  const send      = document.getElementById('q-send');
+  const file      = document.getElementById('q-file');
+  const seedHint  = document.getElementById('seed-hint');
+
+  function toast(msg, kind = '') {
+    const t = document.createElement('div');
+    t.className = 'toast ' + kind; t.textContent = msg;
+    document.getElementById('toasts').appendChild(t);
+    setTimeout(() => t.remove(), 4500);
+  }
+
+  // Restore hypergraph on load
+  async function restore() {
+    try {
+      const h = await ElysiumAPI.hypergraph();
+      (h.nodes || []).forEach(n => window.elysiumAddNode(n));
+      (h.edges || []).forEach(e => window.elysiumAddEdge(e));
+      if ((h.nodes || []).length > 1) seedHint.classList.add('hidden');
+      updateLegend();
+      document.getElementById('s-engage').textContent = h.node_count || 0;
+      document.getElementById('s-laws').textContent   = h.edge_count || 0;
+    } catch(e) { /* offline first-boot */ }
+  }
+  restore();
+
+  // Wire send
+  let busy = false;
+  async function submit() {
+    if (busy) return;
+    const text = input.value.trim();
+    if (!text && !file.files.length) return;
+    busy = true; send.classList.add('loading'); send.textContent = '◐';
+    seedHint.classList.add('hidden');
+    input.value = ''; input.placeholder = 'Council deliberating…';
+    try {
+      const data = await ElysiumAPI.turn(text, file.files[0]);
+      file.value = '';
+      handleResponse(data);
+    } catch(e) {
+      toast('Inference failed: ' + e.message, 'error');
+    } finally {
+      busy = false; send.classList.remove('loading'); send.textContent = '→';
+      input.placeholder = 'Speak to your council…';
+    }
+  }
+  send.onclick = submit;
+  input.addEventListener('keydown', e => { if (e.key === 'Enter') submit(); });
+
+  function handleResponse(payload) {
+    const resp = payload.elysium_response || {};
+    const rt   = payload._runtime || {};
+    // 1. apply hypergraph delta
+    const delta = resp.hypergraph_delta || {};
+    (delta.nodes_added || []).forEach(n => window.elysiumAddNode(n));
+    (delta.edges_added || []).forEach(e => window.elysiumAddEdge(e));
+
+    // 2. UI directives
+    const ui = resp.ui_directives || {};
+    (ui.bioluminescence_pulse_nodes || []).forEach(id => window.elysiumPulse(id, 1400));
+    document.body.dataset.alert = ui.alert_level || 'CALM';
+    if (ui.camera_focus_node_id) window.elysiumFocus(ui.camera_focus_node_id);
+
+    // 3. council
+    window.renderCouncil(resp, rt);
+
+    // 4. stats
+    const meta = resp.metadata || {};
+    document.getElementById('s-engage').textContent = meta.hypergraph_node_count ?? '0';
+    document.getElementById('s-laws').textContent   = meta.hypergraph_edge_count ?? '0';
+    document.getElementById('s-impl').textContent   =
+      Math.round((1 - (resp.strain_metadata?.cognitive_strain ?? 0.3)) * 100) + '%';
+    document.getElementById('s-health').textContent = `${(rt.hypergraph?.nodes ?? 0)}`;
+
+    // 5. agent count
+    const ag = (resp.council_deliberation?.agent_outputs || []).length;
+    document.getElementById('agent-count').textContent = `+${ag}`;
+
+    // 6. legend
+    updateLegend();
+
+    // 7. tool toasts
+    (rt.tool_results || []).forEach(tr => {
+      const ok = tr.result && !tr.result.error;
+      toast(`🔧 ${tr.tool_name}: ${ok ? 'ok' : (tr.result?.error || 'offline')}`,
+            ok ? '' : 'warn');
+    });
+
+    // 8. direct answer toast if no agents
+    if (!ag && resp.direct_answer) toast(resp.direct_answer);
+  }
+
+  function updateLegend() {
+    const counts = {};
+    window.ELYSIUM.nodes.forEach(n => counts[n.type] = (counts[n.type] || 0) + 1);
+    const order = ['CORE','DOMAIN','AGENT','TOOL','PROJECT','LIFE_EVENT','EMOTION','PERSON','VALUE','MEMORY'];
+    const items = order.filter(t => counts[t]).map(t => {
+      const c = window.colorFor(t);
+      return `<div class="legend-item" data-type="${t}">
+        <span class="dot" style="background:${c};color:${c}"></span>
+        <span class="badge">${counts[t]}</span>
+        <span class="lbl">${t.replace('_',' ').toLowerCase()}</span>
+      </div>`;
+    }).join('');
+    document.getElementById('legend-items').innerHTML = items;
+    document.getElementById('legend-gaps').textContent =
+      Math.min(99, Math.round((1 - (counts.AGENT || 0) / Math.max(1, counts.DOMAIN || 1)) * 50)) + '%';
+    document.getElementById('legend-updates').textContent =
+      Math.min(99, window.ELYSIUM.nodes.size * 3) + '%';
+  }
+
+  // RI Analysis = fit all + show health
+  document.getElementById('ri-analysis').onclick = () => {
+    window.elysiumFitAll();
+    toast('🔍 RI Analysis: civilization-wide view');
+  };
+  document.getElementById('my-agent').onclick = () => {
+    toast(`🤖 Active agents: ${document.getElementById('agent-count').textContent}`);
+  };
+})();

frontend/dist/assets/canvas.js

@@ -0,0 +1,339 @@
+/* Google-Maps-style infinite-pan canvas with bioluminescent hypergraph. */
+(() => {
+  const canvas = document.getElementById('elysium-canvas');
+  const ctx = canvas.getContext('2d', { alpha: false });
+
+  const DPR = Math.max(1, Math.min(2, window.devicePixelRatio || 1));
+  function resize() {
+    canvas.width = innerWidth * DPR;
+    canvas.height = innerHeight * DPR;
+    canvas.style.width = innerWidth + 'px';
+    canvas.style.height = innerHeight + 'px';
+  }
+  resize(); addEventListener('resize', resize);
+
+  // World state
+  const E = window.ELYSIUM = {
+    cam: { x: 0, y: 0, z: 1, tx: 0, ty: 0, tz: 1, vx: 0, vy: 0, drag: false },
+    nodes: new Map(), edges: [], spawning: [],
+    hover: null, selected: null,
+  };
+
+  // Seed CORE
+  E.nodes.set('CORE', {
+    node_id: 'CORE', x: 0, y: 0, type: 'CORE', label: 'ELYSIUM',
+    radius: 34, color: '#c8a44a', phase: 0, born: performance.now() - 1000,
+  });
+
+  // ──────── PAN / ZOOM ────────
+  let lastX = 0, lastY = 0;
+  function clientToWorld(cx, cy) {
+    return {
+      x: (cx - innerWidth / 2) / E.cam.z + E.cam.x,
+      y: (cy - innerHeight / 2) / E.cam.z + E.cam.y,
+    };
+  }
+
+  canvas.addEventListener('pointerdown', e => {
+    // hit-test a node first
+    const w = clientToWorld(e.clientX, e.clientY);
+    let hit = null;
+    E.nodes.forEach(n => {
+      if (Math.hypot(n.x - w.x, n.y - w.y) < n.radius * 1.15) hit = n;
+    });
+    if (hit) { showNodeDetail(hit, e.clientX, e.clientY); return; }
+    E.cam.drag = true; canvas.classList.add('dragging');
+    lastX = e.clientX; lastY = e.clientY;
+    canvas.setPointerCapture(e.pointerId);
+  });
+  canvas.addEventListener('pointermove', e => {
+    if (!E.cam.drag) {
+      const w = clientToWorld(e.clientX, e.clientY);
+      let hover = null;
+      E.nodes.forEach(n => { if (Math.hypot(n.x - w.x, n.y - w.y) < n.radius * 1.15) hover = n; });
+      E.hover = hover; canvas.style.cursor = hover ? 'pointer' : '';
+      return;
+    }
+    const dx = (e.clientX - lastX) / E.cam.z;
+    const dy = (e.clientY - lastY) / E.cam.z;
+    E.cam.x -= dx; E.cam.y -= dy;
+    E.cam.vx = dx * 0.85; E.cam.vy = dy * 0.85;
+    E.cam.tx = E.cam.x; E.cam.ty = E.cam.y;
+    lastX = e.clientX; lastY = e.clientY;
+  });
+  function endPan(e){ E.cam.drag = false; canvas.classList.remove('dragging');
+                      try { canvas.releasePointerCapture(e.pointerId); } catch{} }
+  canvas.addEventListener('pointerup', endPan);
+  canvas.addEventListener('pointercancel', endPan);
+
+  // wheel zoom
+  canvas.addEventListener('wheel', e => {
+    e.preventDefault();
+    const factor = e.deltaY > 0 ? 0.9 : 1.1;
+    const w = clientToWorld(e.clientX, e.clientY);
+    E.cam.tz = Math.max(0.15, Math.min(4, E.cam.z * factor));
+    E.cam.tx = w.x - (e.clientX - innerWidth / 2) / E.cam.tz;
+    E.cam.ty = w.y - (e.clientY - innerHeight / 2) / E.cam.tz;
+  }, { passive: false });
+
+  // double-click zoom-in
+  canvas.addEventListener('dblclick', e => {
+    const w = clientToWorld(e.clientX, e.clientY);
+    E.cam.tz = Math.min(4, E.cam.z * 1.6);
+    E.cam.tx = w.x; E.cam.ty = w.y;
+  });
+
+  // ──────── TOUCH (pinch) ────────
+  let touchDist = 0, touchMid = null;
+  canvas.addEventListener('touchstart', e => {
+    if (e.touches.length === 2) {
+      e.preventDefault();
+      const [a, b] = e.touches;
+      touchDist = Math.hypot(a.clientX - b.clientX, a.clientY - b.clientY);
+      touchMid  = { x: (a.clientX + b.clientX) / 2, y: (a.clientY + b.clientY) / 2 };
+    }
+  }, { passive: false });
+  canvas.addEventListener('touchmove', e => {
+    if (e.touches.length === 2 && touchDist) {
+      e.preventDefault();
+      const [a, b] = e.touches;
+      const d = Math.hypot(a.clientX - b.clientX, a.clientY - b.clientY);
+      const factor = d / touchDist; touchDist = d;
+      const w = clientToWorld(touchMid.x, touchMid.y);
+      E.cam.tz = Math.max(0.15, Math.min(4, E.cam.z * factor));
+      E.cam.tx = w.x - (touchMid.x - innerWidth / 2) / E.cam.tz;
+      E.cam.ty = w.y - (touchMid.y - innerHeight / 2) / E.cam.tz;
+    }
+  }, { passive: false });
+  canvas.addEventListener('touchend', () => { touchDist = 0; });
+
+  // ──────── ZOOM BTNS ────────
+  document.getElementById('z-in').onclick  = () => E.cam.tz = Math.min(4, E.cam.z * 1.35);
+  document.getElementById('z-out').onclick = () => E.cam.tz = Math.max(0.15, E.cam.z / 1.35);
+  document.getElementById('z-fit').onclick = fitAll;
+
+  function fitAll() {
+    if (E.nodes.size === 0) return;
+    let mnX = Infinity, mnY = Infinity, mxX = -Infinity, mxY = -Infinity;
+    E.nodes.forEach(n => { mnX = Math.min(mnX, n.x); mnY = Math.min(mnY, n.y);
+                            mxX = Math.max(mxX, n.x); mxY = Math.max(mxY, n.y); });
+    const pad = 180;
+    E.cam.tx = (mnX + mxX) / 2;
+    E.cam.ty = (mnY + mxY) / 2;
+    E.cam.tz = Math.min(4, Math.max(0.25,
+      Math.min(innerWidth / (mxX - mnX + pad), innerHeight / (mxY - mnY + pad))));
+  }
+  window.elysiumFitAll = fitAll;
+
+  // ──────── MINIMAP ────────
+  const mini = document.getElementById('minimap');
+  const mctx = mini.getContext('2d');
+  function drawMinimap() {
+    mini.width = 160; mini.height = 100;
+    mctx.fillStyle = 'rgba(8,24,30,.95)';
+    mctx.fillRect(0, 0, 160, 100);
+    if (E.nodes.size === 0) return;
+    let mnX = Infinity, mnY = Infinity, mxX = -Infinity, mxY = -Infinity;
+    E.nodes.forEach(n => { mnX = Math.min(mnX, n.x); mnY = Math.min(mnY, n.y);
+                            mxX = Math.max(mxX, n.x); mxY = Math.max(mxY, n.y); });
+    const pad = 80; mnX -= pad; mnY -= pad; mxX += pad; mxY += pad;
+    const sx = 160 / (mxX - mnX), sy = 100 / (mxY - mnY);
+    // edges
+    mctx.strokeStyle = 'rgba(0,200,160,.18)'; mctx.lineWidth = .5;
+    E.edges.forEach(ed => {
+      const s = E.nodes.get(ed.src), t = E.nodes.get(ed.dst);
+      if (!s || !t) return;
+      mctx.beginPath();
+      mctx.moveTo((s.x - mnX) * sx, (s.y - mnY) * sy);
+      mctx.lineTo((t.x - mnX) * sx, (t.y - mnY) * sy);
+      mctx.stroke();
+    });
+    // nodes
+    E.nodes.forEach(n => {
+      mctx.fillStyle = n.color;
+      mctx.beginPath(); mctx.arc((n.x - mnX) * sx, (n.y - mnY) * sy, 2.2, 0, Math.PI * 2);
+      mctx.fill();
+    });
+    // viewport rect
+    const vx = (E.cam.x - innerWidth / 2 / E.cam.z - mnX) * sx;
+    const vy = (E.cam.y - innerHeight / 2 / E.cam.z - mnY) * sy;
+    const vw = innerWidth / E.cam.z * sx, vh = innerHeight / E.cam.z * sy;
+    mctx.strokeStyle = 'rgba(0,229,255,.7)'; mctx.lineWidth = 1;
+    mctx.setLineDash([3, 3]);
+    mctx.strokeRect(vx, vy, vw, vh);
+    mctx.setLineDash([]);
+  }
+  // minimap click → pan
+  mini.addEventListener('click', e => {
+    if (E.nodes.size === 0) return;
+    const rect = mini.getBoundingClientRect();
+    const fx = (e.clientX - rect.left) / rect.width;
+    const fy = (e.clientY - rect.top) / rect.height;
+    let mnX = Infinity, mnY = Infinity, mxX = -Infinity, mxY = -Infinity;
+    E.nodes.forEach(n => { mnX = Math.min(mnX, n.x); mnY = Math.min(mnY, n.y);
+                            mxX = Math.max(mxX, n.x); mxY = Math.max(mxY, n.y); });
+    const pad = 80; mnX -= pad; mnY -= pad; mxX += pad; mxY += pad;
+    E.cam.tx = mnX + fx * (mxX - mnX);
+    E.cam.ty = mnY + fy * (mxY - mnY);
+  });
+
+  // ──────── NODE DETAIL POPOVER ────────
+  function showNodeDetail(n, sx, sy) {
+    const el = document.getElementById('node-detail');
+    el.style.left = Math.min(innerWidth - 300, sx + 16) + 'px';
+    el.style.top  = Math.min(innerHeight - 200, sy) + 'px';
+    el.innerHTML = `
+      <div class="nd-title">
+        <span style="width:14px;height:14px;border-radius:50%;background:${n.color};
+                     box-shadow:0 0 8px ${n.color}"></span>${n.label || n.node_id}</div>
+      <div class="nd-type">${n.type}</div>
+      <div class="nd-stats">
+        <div class="nd-pill"><b>${(Math.random()*40+10|0)}</b>activity</div>
+        <div class="nd-pill"><b>${(Math.random()*70+10|0)}%</b>weight</div>
+        <div class="nd-pill"><b>${(Math.random()*30+5|0)}</b>links</div>
+      </div>
+      <div style="font-size:11px;color:var(--muted);line-height:1.5">
+        Node connected to your civilization mycelium. Pan and zoom to explore.
+      </div>`;
+    el.classList.add('show');
+    clearTimeout(showNodeDetail._t);
+    showNodeDetail._t = setTimeout(() => el.classList.remove('show'), 4500);
+  }
+
+  // ──────── PUBLIC API ────────
+  const SPAWN_RADIUS = 280;
+  window.elysiumAddNode = function (node, parentId = 'CORE') {
+    if (E.nodes.has(node.node_id)) return;
+    const parent = E.nodes.get(parentId) || E.nodes.get('CORE') || { x: 0, y: 0 };
+    const idx = E.nodes.size;
+    const angle = idx * 0.7 + Math.random() * 0.6 - 0.3;
+    const dist = SPAWN_RADIUS + (idx * 14) % 180;
+    const tx = parent.x + Math.cos(angle) * dist;
+    const ty = parent.y + Math.sin(angle) * dist;
+    const type = node.node_type || 'DOMAIN';
+    const radius = type === 'CORE' ? 34 :
+                   type === 'AGENT' ? 22 :
+                   type === 'TOOL'  ? 14 : 18;
+    E.nodes.set(node.node_id, {
+      node_id: node.node_id,
+      x: parent.x, y: parent.y, tx, ty,
+      type, label: node.label || node.node_id,
+      radius, color: window.colorFor(type),
+      phase: Math.random() * Math.PI * 2,
+      born: performance.now(),
+      spawnFrom: parentId,
+    });
+    // auto-pan a little toward new node
+    E.cam.tx = E.cam.x * 0.85 + tx * 0.15;
+    E.cam.ty = E.cam.y * 0.85 + ty * 0.15;
+  };
+
+  window.elysiumAddEdge = function (edge) {
+    E.edges.push({
+      src: edge.source_node_id, dst: edge.target_node_id,
+      type: edge.edge_type, weight: edge.weight ?? 0.5,
+      color: edge.edge_type === 'CONFLICT'  ? 'rgba(220,80,80,.55)' :
+             edge.edge_type === 'COALITION' ? 'rgba(120,190,255,.6)' :
+             edge.edge_type === 'CAUSAL'    ? 'rgba(0,229,255,.45)' :
+                                              'rgba(200,164,74,.5)',
+      born: performance.now(), dashOffset: 0,
+    });
+  };
+
+  window.elysiumPulse = function (nodeId, ms = 1200) {
+    const n = E.nodes.get(nodeId); if (n) n.pulseUntil = performance.now() + ms;
+  };
+
+  window.elysiumFocus = function (nodeId) {
+    const n = E.nodes.get(nodeId); if (!n) return;
+    E.cam.tx = n.x; E.cam.ty = n.y;
+    E.cam.tz = Math.max(1, E.cam.z);
+  };
+
+  // ──────── RENDER LOOP ────────
+  function lerp(a, b, t) { return a + (b - a) * t; }
+  function loop(t) {
+    // animate spawning nodes toward target
+    E.nodes.forEach(n => {
+      if (n.tx != null) {
+        n.x = lerp(n.x, n.tx, 0.12);
+        n.y = lerp(n.y, n.ty, 0.12);
+        if (Math.abs(n.x - n.tx) < 0.3 && Math.abs(n.y - n.ty) < 0.3) {
+          n.x = n.tx; n.y = n.ty; n.tx = null; n.ty = null;
+        }
+      }
+    });
+    // smooth camera
+    E.cam.z = lerp(E.cam.z, E.cam.tz, 0.10);
+    if (!E.cam.drag) {
+      E.cam.x = lerp(E.cam.x, E.cam.tx, 0.12);
+      E.cam.y = lerp(E.cam.y, E.cam.ty, 0.12);
+      E.cam.x -= E.cam.vx; E.cam.y -= E.cam.vy;
+      E.cam.vx *= 0.92; E.cam.vy *= 0.92;
+      if (Math.abs(E.cam.vx) < 0.05) E.cam.vx = 0;
+      if (Math.abs(E.cam.vy) < 0.05) E.cam.vy = 0;
+    }
+
+    // background haze
+    ctx.fillStyle = '#0a1a20';
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    const grad = ctx.createRadialGradient(canvas.width/2, canvas.height/2, 0,
+                                          canvas.width/2, canvas.height/2, canvas.width*0.55);
+    grad.addColorStop(0, 'rgba(10,48,64,.22)');
+    grad.addColorStop(1, 'rgba(6,14,18,0)');
+    ctx.fillStyle = grad; ctx.fillRect(0, 0, canvas.width, canvas.height);
+
+    // particles (subtle ambient)
+    drawAmbient(ctx, t);
+
+    // world transform
+    ctx.save();
+    ctx.scale(DPR, DPR);
+    ctx.translate(innerWidth / 2, innerHeight / 2);
+    ctx.scale(E.cam.z, E.cam.z);
+    ctx.translate(-E.cam.x, -E.cam.y);
+
+    // edges
+    E.edges.forEach(e => {
+      const s = E.nodes.get(e.src), d = E.nodes.get(e.dst); if (!s || !d) return;
+      ctx.strokeStyle = e.color;
+      ctx.lineWidth = (0.8 + (e.weight ?? .5) * 0.8) / E.cam.z;
+      if (e.type === 'COALITION' || e.type === 'CAUSAL') {
+        ctx.setLineDash([6 / E.cam.z, 4 / E.cam.z]);
+        ctx.lineDashOffset = -(t * 0.02);
+      } else {
+        ctx.setLineDash([]);
+      }
+      ctx.beginPath(); ctx.moveTo(s.x, s.y); ctx.lineTo(d.x, d.y); ctx.stroke();
+      ctx.setLineDash([]);
+    });
+
+    // nodes
+    E.nodes.forEach(n => window.drawNode(ctx, n, t, E.cam.z));
+    ctx.restore();
+
+    drawMinimap();
+    requestAnimationFrame(loop);
+  }
+
+  // ambient floating particles
+  const PARTICLES = Array.from({length: 50}, () => ({
+    x: Math.random() * innerWidth, y: Math.random() * innerHeight,
+    r: Math.random() * 1.4 + 0.4, vx: (Math.random() - .5) * 0.15,
+    vy: (Math.random() - .5) * 0.15,
+    c: Math.random() > .6 ? 'rgba(0,200,160,.35)' : 'rgba(200,164,74,.22)',
+  }));
+  function drawAmbient(ctx, t) {
+    ctx.save(); ctx.scale(DPR, DPR);
+    PARTICLES.forEach(p => {
+      p.x += p.vx; p.y += p.vy;
+      if (p.x < 0) p.x = innerWidth; if (p.x > innerWidth) p.x = 0;
+      if (p.y < 0) p.y = innerHeight; if (p.y > innerHeight) p.y = 0;
+      ctx.fillStyle = p.c;
+      ctx.beginPath(); ctx.arc(p.x, p.y, p.r, 0, Math.PI * 2); ctx.fill();
+    });
+    ctx.restore();
+  }
+
+  requestAnimationFrame(loop);
+})();

frontend/dist/assets/council.js

@@ -0,0 +1,84 @@
+/* Council panel + agent debate playback. */
+const AGENT_COLORS = {
+  THE_BUILDER:  '#e05080',
+  THE_GUARDIAN: '#9060c0',
+  THE_ORACLE:   '#40d0e0',
+  THE_WEAVER:   '#d070a0',
+  THE_WILDCARD: '#40e080',
+  DYNAMIC:      '#c8903a',
+};
+window.agentColor = (a) => AGENT_COLORS[a] || '#9060c0';
+
+window.renderCouncil = function (resp, runtime) {
+  const council = document.getElementById('council');
+  const body    = document.getElementById('council-body');
+  const synth   = document.getElementById('council-synth');
+  const count   = document.getElementById('council-count');
+  const audio   = document.getElementById('debate-audio');
+
+  const cd = resp.council_deliberation || {};
+  const agents = cd.agent_outputs || [];
+  if (!agents.length) {
+    council.classList.remove('show');
+    setTimeout(() => council.classList.add('hidden'), 400);
+    return;
+  }
+  council.classList.remove('hidden');
+  requestAnimationFrame(() => council.classList.add('show'));
+
+  count.textContent = `+${agents.length}`;
+  body.innerHTML = agents.map((a, i) => {
+    const c = window.agentColor(a.archetype);
+    return `
+    <div class="agent-card" style="border-color:${c}; animation-delay:${i * 80}ms"
+         data-aid="${a.agent_id}">
+      <div class="row1">
+        <span class="ad-dot" style="background:${c};color:${c}"></span>
+        <span class="name" style="color:${c}">${a.agent_name}</span>
+        <span class="archetype">${a.archetype}</span>
+        ${a.veto_triggered ? '<span class="archetype" style="background:#7a2230;color:#ffb0b0">VETO</span>' : ''}
+      </div>
+      <div class="thinking">${escapeHtml(a.thinking || '')}</div>
+      <div class="stance">${escapeHtml(a.stance || '')}</div>
+      <div class="conf">confidence ${(a.confidence ?? 0.8).toFixed(2)}</div>
+    </div>`;
+  }).join('');
+
+  synth.textContent = cd.final_synthesis || resp.direct_answer || '';
+
+  // audio playback
+  if (runtime && runtime.audio_url) {
+    audio.style.display = 'block';
+    audio.src = runtime.audio_url;
+    audio.play().catch(() => {});
+    // highlight speaking agent as audio plays
+    let idx = 0;
+    const cards = body.querySelectorAll('.agent-card');
+    cards[0]?.classList.add('speaking');
+    audio.ontimeupdate = () => {
+      if (!audio.duration) return;
+      const target = Math.min(cards.length - 1,
+        Math.floor((audio.currentTime / audio.duration) * cards.length));
+      if (target !== idx) {
+        cards[idx]?.classList.remove('speaking');
+        cards[target]?.classList.add('speaking');
+        idx = target;
+      }
+    };
+    audio.onended = () => cards.forEach(c => c.classList.remove('speaking'));
+  } else {
+    audio.style.display = 'none';
+  }
+};
+
+function escapeHtml(s) {
+  return String(s || '').replace(/[&<>"']/g, c => ({
+    '&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'
+  }[c]));
+}
+
+document.getElementById('council-close').onclick = () => {
+  const c = document.getElementById('council');
+  c.classList.remove('show');
+  setTimeout(() => c.classList.add('hidden'), 400);
+};

frontend/dist/assets/elysium.css

@@ -0,0 +1,229 @@
+:root{
+  --bg:#0a1a20; --bg-2:#060e12;
+  --panel:rgba(8,24,30,.85); --panel-2:rgba(15,35,42,.7);
+  --border:rgba(0,200,160,.2); --border-strong:rgba(0,200,160,.45);
+  --teal:#00c8a0; --cyan:#00e5ff; --gold:#c8a44a;
+  --pink:#e05080; --lav:#9060c0; --green:#40e080; --warm:#c8903a;
+  --text:#e0eef0; --muted:#7aabb8;
+  --shadow:0 8px 32px rgba(0,0,0,.45), inset 0 1px 0 rgba(255,255,255,.05);
+  --font-sans:'Inter',system-ui,sans-serif;
+  --font-mono:'Space Mono',monospace;
+  --font-disp:'Space Grotesk',sans-serif;
+}
+*,*::before,*::after{box-sizing:border-box;-webkit-tap-highlight-color:transparent}
+html,body{margin:0;padding:0;height:100%;width:100%;overflow:hidden;
+  background:radial-gradient(ellipse at center,#0d2228 0%,#060e12 100%);
+  color:var(--text);font-family:var(--font-sans);font-size:14px;
+  user-select:none;-webkit-user-select:none}
+button{font-family:inherit;color:inherit}
+
+/* CANVAS */
+#elysium-canvas{position:fixed;inset:0;width:100vw;height:100vh;cursor:grab;
+  touch-action:none;z-index:0}
+#elysium-canvas.dragging{cursor:grabbing}
+
+/* GLASS PANELS */
+.glass{background:var(--panel);border:1px solid var(--border);border-radius:16px;
+  backdrop-filter:blur(16px) saturate(1.2);-webkit-backdrop-filter:blur(16px) saturate(1.2);
+  box-shadow:var(--shadow)}
+
+/* TIMELINE */
+#timeline{position:fixed;left:0;top:0;bottom:0;width:54px;z-index:10;
+  display:flex;flex-direction:column;align-items:center;padding:40px 0;
+  background:linear-gradient(90deg,rgba(10,26,32,.55),transparent);
+  pointer-events:none}
+#timeline .t-edge{position:absolute;left:0;top:0;bottom:0;width:2px;
+  background:repeating-linear-gradient(180deg,transparent 0 8px,rgba(0,200,160,.2) 8px 9px)}
+#timeline .years{display:flex;flex-direction:column;gap:46px;font-size:10px;
+  color:var(--muted);letter-spacing:.5px;font-family:var(--font-mono);
+  pointer-events:auto}
+#timeline .year{opacity:.55}
+#timeline .year-active{padding:4px 11px;border:1.5px solid var(--teal);
+  border-radius:18px;color:var(--text);font-weight:700;font-size:11px;
+  box-shadow:0 0 14px rgba(0,200,160,.55);background:rgba(0,40,48,.45);
+  animation:pillpulse 3s ease-in-out infinite}
+@keyframes pillpulse{0%,100%{box-shadow:0 0 14px rgba(0,200,160,.5)}
+  50%{box-shadow:0 0 22px rgba(0,200,160,.85)}}
+
+/* LEGEND */
+#legend{position:fixed;top:24px;right:24px;width:220px;padding:18px;z-index:20}
+.legend-header{font-size:11px;letter-spacing:2.5px;color:var(--muted);margin-bottom:14px;
+  font-weight:600}
+.legend-item{display:flex;align-items:center;gap:10px;margin:9px 0;font-size:13px}
+.legend-item .dot{width:18px;height:18px;border-radius:50%;
+  box-shadow:0 0 10px currentColor;flex-shrink:0}
+.legend-item .badge{background:rgba(0,0,0,.4);padding:2px 8px;border-radius:10px;
+  font-family:var(--font-mono);font-size:10px;min-width:24px;text-align:center}
+.legend-item .lbl{color:var(--text);font-size:12px}
+.meta-row{display:flex;justify-content:space-between;align-items:center;
+  font-size:11px;color:var(--muted);margin-top:10px;padding-top:10px;
+  border-top:1px solid var(--border)}
+.meta-val{background:rgba(0,0,0,.3);padding:3px 9px;border-radius:10px;
+  font-family:var(--font-mono);color:var(--text);font-size:11px}
+
+/* MINIMAP */
+#minimap{position:fixed;left:74px;bottom:140px;width:160px;height:100px;
+  background:rgba(8,24,30,.82);border:1px solid var(--border);
+  border-radius:10px;z-index:15;cursor:pointer;
+  box-shadow:var(--shadow)}
+.minimap-label{position:fixed;left:80px;bottom:244px;font-size:9px;
+  letter-spacing:2px;color:var(--muted);z-index:15;pointer-events:none}
+
+/* ZOOM CTRL */
+#zoom-ctrl{position:fixed;right:24px;bottom:140px;display:flex;flex-direction:column;
+  gap:6px;z-index:15}
+#zoom-ctrl button{width:38px;height:38px;background:rgba(8,24,30,.85);
+  border:1px solid var(--border);border-radius:10px;color:var(--teal);
+  font-size:18px;cursor:pointer;backdrop-filter:blur(10px);
+  transition:all .15s ease}
+#zoom-ctrl button:hover{background:rgba(0,200,160,.15);transform:scale(1.05)}
+
+/* ALERT SCRIM */
+#alert-scrim{position:fixed;inset:0;z-index:5;pointer-events:none;
+  background:radial-gradient(ellipse at center,transparent 55%,rgba(220,60,60,0) 100%);
+  transition:background 800ms ease}
+body[data-alert="ATTENTION"] #alert-scrim{background:radial-gradient(ellipse at center,transparent 50%,rgba(200,160,80,.10) 100%)}
+body[data-alert="TENSION"] #alert-scrim{background:radial-gradient(ellipse at center,transparent 40%,rgba(220,140,60,.18) 100%)}
+body[data-alert="CRISIS"] #alert-scrim{background:radial-gradient(ellipse at center,transparent 30%,rgba(220,60,60,.25) 100%);
+  animation:crisisPulse 1.6s ease-in-out infinite}
+@keyframes crisisPulse{0%,100%{opacity:.6}50%{opacity:1}}
+
+/* STATS BAR */
+#stats{position:fixed;left:54px;right:0;bottom:56px;height:54px;
+  display:flex;align-items:center;padding:0 28px;gap:36px;z-index:18;
+  border-radius:0;border-left:none;border-right:none;border-bottom:none}
+.stat{display:flex;align-items:center;gap:10px}
+.stat-icon{font-size:18px;color:var(--teal);opacity:.85}
+.stat-label{font-size:10px;letter-spacing:1.4px;color:var(--muted);
+  text-transform:uppercase;font-weight:500}
+.stat-value{font-size:22px;font-family:var(--font-disp);color:var(--cyan);
+  font-weight:700;line-height:1}
+
+/* QUERY BAR */
+#query-bar{position:fixed;left:54px;right:0;bottom:0;height:56px;
+  display:flex;align-items:center;padding:0 22px;gap:10px;z-index:20;
+  border-radius:0;border-left:none;border-right:none}
+#q-input{flex:1;height:40px;background:var(--panel-2);
+  border:1px solid var(--border);border-radius:28px;padding:0 22px;
+  color:var(--text);font-size:13px;outline:none;
+  transition:border-color .2s,box-shadow .2s}
+#q-input:focus{border-color:var(--border-strong);
+  box-shadow:0 0 0 3px rgba(0,200,160,.12)}
+#q-input::placeholder{color:var(--muted)}
+#q-upload{width:36px;height:36px;display:grid;place-items:center;
+  background:var(--panel-2);border:1px solid var(--border);border-radius:50%;
+  cursor:pointer;font-size:14px;color:var(--muted);transition:all .15s}
+#q-upload:hover{color:var(--teal);border-color:var(--border-strong)}
+#q-send{width:38px;height:38px;border-radius:50%;background:var(--teal);
+  color:#03252a;border:none;cursor:pointer;font-size:18px;font-weight:700;
+  box-shadow:0 0 18px rgba(0,200,160,.45);transition:all .15s}
+#q-send:hover{transform:scale(1.06);box-shadow:0 0 24px rgba(0,200,160,.7)}
+#q-send.loading{animation:spin 1s linear infinite}
+@keyframes spin{to{transform:rotate(360deg)}}
+.mode-row{position:absolute;right:24px;bottom:62px;display:flex;gap:8px}
+.mode-row button{background:var(--panel-2);border:1px solid var(--border);
+  border-radius:18px;padding:6px 12px;font-size:11px;color:var(--text);
+  cursor:pointer;letter-spacing:.5px;display:flex;align-items:center;gap:6px}
+.mode-row button:hover{border-color:var(--border-strong)}
+.mode-row .badge{background:rgba(0,200,160,.18);padding:1px 6px;border-radius:8px;
+  font-family:var(--font-mono);font-size:10px;color:var(--teal)}
+
+/* COUNCIL */
+#council{position:fixed;left:50%;bottom:130px;transform:translateX(-50%) translateY(20px);
+  width:min(580px,92vw);max-height:50vh;overflow-y:auto;padding:20px;z-index:25;
+  opacity:0;pointer-events:none;transition:all .4s cubic-bezier(.34,1.56,.64,1)}
+#council.show{opacity:1;transform:translateX(-50%) translateY(0);pointer-events:auto}
+#council.hidden{display:none}
+.council-head{display:flex;justify-content:space-between;align-items:center;margin-bottom:14px}
+.council-title{font-size:11px;letter-spacing:2.2px;color:var(--muted);font-weight:600}
+.council-title span{color:var(--teal);margin-left:6px}
+#council-close{background:none;border:none;color:var(--muted);font-size:22px;
+  cursor:pointer;line-height:1}
+#council-close:hover{color:var(--text)}
+.agent-card{border-left:3px solid;padding:12px 14px;margin:10px 0;
+  background:rgba(10,26,32,.55);border-radius:8px;animation:slideIn .4s ease both}
+@keyframes slideIn{from{opacity:0;transform:translateX(-12px)}
+  to{opacity:1;transform:translateX(0)}}
+.agent-card .row1{display:flex;align-items:center;gap:8px;margin-bottom:6px}
+.agent-card .ad-dot{width:10px;height:10px;border-radius:50%;box-shadow:0 0 8px currentColor}
+.agent-card .name{font-weight:700;font-size:13px}
+.agent-card .archetype{font-size:10px;background:rgba(0,0,0,.25);padding:2px 7px;
+  border-radius:8px;letter-spacing:.8px;color:var(--muted)}
+.agent-card .thinking{color:var(--muted);font-size:11px;margin-top:4px;font-style:italic;
+  line-height:1.45}
+.agent-card .stance{font-size:12.5px;margin-top:8px;color:var(--text)}
+.agent-card .conf{font-family:var(--font-mono);font-size:10px;color:var(--teal);
+  margin-top:6px}
+.agent-card.speaking{box-shadow:0 0 0 1px rgba(0,200,160,.45);
+  animation:speakPulse 1.2s ease-in-out infinite}
+@keyframes speakPulse{0%,100%{transform:translateX(0)}50%{transform:translateX(2px)}}
+#council-synth{margin-top:14px;padding-top:14px;border-top:1px solid var(--border);
+  color:var(--text);font-size:13px;line-height:1.55}
+#debate-audio{width:100%;margin-top:14px;height:36px;border-radius:18px;
+  background:rgba(0,0,0,.3)}
+#debate-audio::-webkit-media-controls-panel{background:rgba(8,24,30,.7)}
+
+/* NODE DETAIL */
+#node-detail{position:fixed;width:280px;padding:18px;z-index:24;
+  opacity:0;pointer-events:none;transition:opacity .25s}
+#node-detail.show{opacity:1;pointer-events:auto}
+#node-detail .nd-title{font-size:14px;font-weight:700;margin-bottom:8px;
+  display:flex;align-items:center;gap:8px}
+#node-detail .nd-type{font-size:10px;letter-spacing:1.4px;color:var(--muted);
+  text-transform:uppercase;margin-bottom:12px}
+#node-detail .nd-stats{display:grid;grid-template-columns:1fr 1fr 1fr;gap:6px;
+  margin-bottom:10px}
+#node-detail .nd-pill{background:rgba(0,0,0,.25);padding:6px 8px;border-radius:8px;
+  font-size:10px;text-align:center;color:var(--muted)}
+#node-detail .nd-pill b{display:block;font-family:var(--font-mono);color:var(--cyan);font-size:13px}
+
+/* TOASTS */
+#toasts{position:fixed;top:24px;left:50%;transform:translateX(-50%);z-index:30;
+  display:flex;flex-direction:column;gap:8px;pointer-events:none}
+.toast{background:rgba(8,28,35,.92);border:1px solid var(--border);border-left:3px solid var(--teal);
+  padding:10px 16px;border-radius:10px;font-size:12px;
+  box-shadow:0 8px 20px rgba(0,0,0,.4);animation:toastIn .35s ease both,toastOut .4s ease 4s both}
+.toast.warn{border-left-color:var(--warm)}
+.toast.error{border-left-color:#e0604c}
+@keyframes toastIn{from{opacity:0;transform:translateY(-8px)}to{opacity:1;transform:translateY(0)}}
+@keyframes toastOut{to{opacity:0;transform:translateY(-8px)}}
+
+/* SEED HINT */
+#seed-hint{position:fixed;left:50%;top:38%;transform:translate(-50%,-50%);
+  z-index:8;padding:9px 18px;border-radius:20px;
+  background:rgba(8,24,30,.7);border:1px solid var(--border);
+  font-size:12px;color:var(--muted);backdrop-filter:blur(10px);
+  animation:hintFloat 3.5s ease-in-out infinite;pointer-events:none;
+  letter-spacing:.4px}
+#seed-hint.hidden{display:none}
+@keyframes hintFloat{0%,100%{opacity:.7;transform:translate(-50%,-50%)}
+  50%{opacity:1;transform:translate(-50%,calc(-50% - 4px))}}
+
+/* RESPONSIVE */
+@media (max-width:900px){
+  #legend{width:180px;padding:14px;top:14px;right:14px}
+  #minimap{width:130px;height:84px;left:64px;bottom:124px}
+  .minimap-label{left:70px;bottom:212px}
+  #zoom-ctrl{right:14px;bottom:124px}
+  #stats{gap:20px;padding:0 18px}
+  .stat-value{font-size:18px}
+  .stat-label{font-size:9px}
+}
+@media (max-width:640px){
+  #timeline{width:42px}
+  #legend{width:160px;padding:12px;top:10px;right:10px;font-size:11px}
+  #legend .lbl{display:none}
+  .meta-row{font-size:10px}
+  #minimap{display:none}
+  .minimap-label{display:none}
+  #stats{display:none}
+  #query-bar{left:42px}
+  .mode-row{display:none}
+  #council{width:96vw;max-height:62vh;bottom:80px}
+  #zoom-ctrl{bottom:80px}
+}
+
+/* HIDE GRADIO if ever shown */
+.gradio-container,footer,.built-with,gradio-app>.main>.contain{display:none!important}
+
+.hidden{display:none!important}

frontend/dist/assets/nodes.js

@@ -0,0 +1,107 @@
+/* Bioluminescent node rendering. */
+const TYPE_COLOR = {
+  CORE:       '#c8a44a',
+  DOMAIN:     '#9060c0',
+  AGENT:      '#e05080',
+  TOOL:       '#c8903a',
+  PROJECT:    '#40d0e0',
+  LIFE_EVENT: '#40e080',
+  EMOTION:    '#e080b0',
+  PERSON:     '#d070a0',
+  VALUE:      '#8050c0',
+  MEMORY:     '#30c0d0',
+};
+
+function shade(hex, amt) {
+  const c = parseInt(hex.slice(1), 16);
+  let r = (c >> 16) + amt, g = ((c >> 8) & 255) + amt, b = (c & 255) + amt;
+  r = Math.max(0, Math.min(255, r)); g = Math.max(0, Math.min(255, g)); b = Math.max(0, Math.min(255, b));
+  return '#' + ((r << 16) | (g << 8) | b).toString(16).padStart(6, '0');
+}
+
+window.colorFor = (type) => TYPE_COLOR[type] || '#9060c0';
+
+window.drawNode = function (ctx, n, t, zoom) {
+  const ageMs = t - (n.born || t);
+  const age = Math.min(1, ageMs / 700);
+  // overshoot easeOutBack
+  const k = age;
+  const overshoot = 1 + 1.7 * (k - 1) ** 3 + 0.7 * (k - 1) ** 2;
+  const fadeScale = age < 1 ? overshoot : 1;
+
+  const pulse = 1 + 0.06 * Math.sin((t / 1000) * 0.55 + (n.phase || 0));
+  const r = n.radius * pulse * fadeScale;
+  const x = n.x, y = n.y;
+
+  ctx.globalAlpha = age;
+
+  // outer halo (soft glow)
+  const halo = ctx.createRadialGradient(x, y, r * 0.9, x, y, r * 2.4);
+  halo.addColorStop(0, n.color + 'aa');
+  halo.addColorStop(1, n.color + '00');
+  ctx.fillStyle = halo;
+  ctx.beginPath(); ctx.arc(x, y, r * 2.4, 0, Math.PI * 2); ctx.fill();
+
+  // rotating dashed orbital ring (always for CORE)
+  if (n.type === 'CORE') {
+    ctx.save();
+    ctx.translate(x, y);
+    ctx.rotate(t * 0.0004);
+    ctx.strokeStyle = n.color + '66';
+    ctx.lineWidth = 1.2 / zoom;
+    ctx.setLineDash([6 / zoom, 6 / zoom]);
+    ctx.beginPath(); ctx.arc(0, 0, r * 1.8, 0, Math.PI * 2); ctx.stroke();
+    ctx.setLineDash([]);
+    ctx.restore();
+  }
+
+  // main sphere
+  const grad = ctx.createRadialGradient(x - r * 0.35, y - r * 0.35, r * 0.1, x, y, r);
+  grad.addColorStop(0, shade(n.color, 50));
+  grad.addColorStop(0.55, n.color);
+  grad.addColorStop(1, shade(n.color, -55));
+
+  ctx.shadowColor = n.color;
+  ctx.shadowBlur = 24 * pulse;
+  ctx.fillStyle = grad;
+  ctx.beginPath(); ctx.arc(x, y, r, 0, Math.PI * 2); ctx.fill();
+  ctx.shadowBlur = 0;
+
+  // specular highlight
+  ctx.fillStyle = 'rgba(255,255,255,.45)';
+  ctx.beginPath();
+  ctx.ellipse(x - r * 0.32, y - r * 0.32, r * 0.26, r * 0.16, -0.5, 0, Math.PI * 2);
+  ctx.fill();
+
+  // counter badge (small inset)
+  if (n.count != null && zoom > 0.5) {
+    const bx = x - r * 1.05, by = y;
+    ctx.fillStyle = 'rgba(0,0,0,.55)';
+    ctx.beginPath();
+    ctx.roundRect ? ctx.roundRect(bx - 12, by - 8, 22, 16, 8) : ctx.rect(bx - 12, by - 8, 22, 16);
+    ctx.fill();
+    ctx.fillStyle = '#fff'; ctx.font = `bold ${10}px Space Mono`;
+    ctx.textAlign = 'center'; ctx.textBaseline = 'middle';
+    ctx.fillText(String(n.count), bx - 1, by);
+  }
+
+  // label
+  if (zoom > 0.4 && n.label) {
+    const fs = Math.min(14, 11 * Math.max(1, zoom * 0.9));
+    ctx.fillStyle = '#c8e8f0';
+    ctx.font = `500 ${fs / zoom}px Inter, sans-serif`;
+    ctx.textAlign = 'center'; ctx.textBaseline = 'top';
+    ctx.fillText(n.label.length > 22 ? n.label.slice(0, 20) + '…' : n.label,
+                 x, y + r + 6 / zoom);
+  }
+
+  // pulse highlight ring (when pulsed via UI directive)
+  if (n.pulseUntil && t < n.pulseUntil) {
+    const p = (n.pulseUntil - t) / 1200;
+    ctx.strokeStyle = `rgba(0,229,255,${p})`;
+    ctx.lineWidth = 2 / zoom;
+    ctx.beginPath(); ctx.arc(x, y, r + (1 - p) * 30, 0, Math.PI * 2); ctx.stroke();
+  }
+
+  ctx.globalAlpha = 1;
+};

frontend/dist/index.html

@@ -0,0 +1,116 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no" />
+<title>Elysium</title>
+<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 64 64'%3E%3Ctext y='50' font-size='50'%3E🌿%3C/text%3E%3C/svg%3E">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Space+Mono:wght@400;700&family=Space+Grotesk:wght@500;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="/assets/elysium.css" />
+</head>
+<body data-alert="CALM">
+
+<!-- BACKGROUND CANVAS -->
+<canvas id="elysium-canvas"></canvas>
+
+<!-- LEFT TIMELINE -->
+<aside id="timeline">
+  <div class="t-edge"></div>
+  <div class="years">
+    <div class="year">2016</div><div class="year">2017</div><div class="year">2018</div>
+    <div class="year">2019</div>
+    <div class="year-active">2026</div>
+    <div class="year">2027</div><div class="year">2028</div><div class="year">2029</div>
+    <div class="year">2030</div>
+  </div>
+</aside>
+
+<!-- LEGEND PANEL -->
+<section id="legend" class="glass">
+  <div class="legend-header">LEGEND</div>
+  <div id="legend-items">
+    <div class="legend-item" data-type="CORE">
+      <span class="dot" style="background:#c8a44a;color:#c8a44a"></span>
+      <span class="badge">1</span><span class="lbl">Civilization</span>
+    </div>
+  </div>
+  <div class="meta-row"><span>🏛 GAPS</span><span id="legend-gaps" class="meta-val">20%</span></div>
+  <div class="meta-row"><span>⟳ Updates</span><span id="legend-updates" class="meta-val">30%</span></div>
+</section>
+
+<!-- MINIMAP -->
+<canvas id="minimap"></canvas>
+<div class="minimap-label">CIVILIZATION MAP</div>
+
+<!-- ZOOM CONTROLS -->
+<div id="zoom-ctrl">
+  <button id="z-in" title="Zoom in">+</button>
+  <button id="z-fit" title="Fit all">⊡</button>
+  <button id="z-out" title="Zoom out">−</button>
+</div>
+
+<!-- ALERT SCRIM -->
+<div id="alert-scrim"></div>
+
+<!-- STATS BAR -->
+<section id="stats" class="glass">
+  <div class="stat">
+    <div class="stat-icon">↗</div>
+    <div><div class="stat-label">Compliance Rate</div><div class="stat-value" id="s-health">—</div></div>
+  </div>
+  <div class="stat">
+    <div class="stat-icon">📜</div>
+    <div><div class="stat-label">Total Laws</div><div class="stat-value" id="s-laws">0</div></div>
+  </div>
+  <div class="stat">
+    <div class="stat-icon">👥</div>
+    <div><div class="stat-label">Public Engagement</div><div class="stat-value" id="s-engage">0</div></div>
+  </div>
+  <div class="stat">
+    <div class="stat-icon">✨</div>
+    <div><div class="stat-label">Implementation Rate</div><div class="stat-value" id="s-impl">0%</div></div>
+  </div>
+</section>
+
+<!-- QUERY BAR -->
+<section id="query-bar" class="glass">
+  <input id="q-input" placeholder="Speak to your civilization seed…" autocomplete="off"/>
+  <label id="q-upload" title="Attach image">
+    <input type="file" id="q-file" accept="image/*" hidden />📎
+  </label>
+  <button id="q-send" title="Send">→</button>
+  <div class="mode-row">
+    <button id="my-agent">🤖 My agent <span class="badge" id="agent-count">+0</span></button>
+    <button id="ri-analysis">✨ RI Analysis</button>
+  </div>
+</section>
+
+<!-- COUNCIL PANEL (slides in when agents present) -->
+<section id="council" class="glass hidden">
+  <div class="council-head">
+    <div class="council-title">COUNCIL DELIBERATION <span id="council-count">+0</span></div>
+    <button id="council-close">×</button>
+  </div>
+  <div id="council-body"></div>
+  <div id="council-synth"></div>
+  <audio id="debate-audio" controls preload="auto"></audio>
+</section>
+
+<!-- NODE DETAIL POPOVER -->
+<section id="node-detail" class="glass hidden"></section>
+
+<!-- TOAST NOTIFICATIONS -->
+<div id="toasts"></div>
+
+<!-- INITIAL HINT -->
+<div id="seed-hint">Ask anything to wake your civilization</div>
+
+<script src="/assets/api.js"></script>
+<script src="/assets/nodes.js"></script>
+<script src="/assets/canvas.js"></script>
+<script src="/assets/council.js"></script>
+<script src="/assets/boot.js"></script>
+</body>
+</html>

packages.txt

@@ -0,0 +1 @@
+ffmpeg

requirements.txt

@@ -0,0 +1,22 @@
+--extra-index-url https://download.pytorch.org/whl/cu128
+torch==2.8.0
+hf_transfer
+huggingface_hub
+--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu124
+llama-cpp-python
+gradio==6.17.3
+spaces
+fastapi
+pydantic>=2.0
+rustworkx>=0.15.0
+duckduckgo-search
+httpx
+icalendar
+pypdf2
+python-docx
+pydub
+soundfile
+numpy
+Pillow
+voxcpm
+python-multipart