ExocoreV1: multi-thinking, web search, auto-load, loss chart, architecture tree, no system prompt

exocore_model.py

@@ -0,0 +1,165 @@
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+IM_START   = 151644
+IM_END     = 151645
+EOT        = 151643
+THINK_END  = 151668
+
+EXOCORE_IDENTITY = (
+    "You are ExocoreV1, a highly capable AI built from scratch by Exocore. "
+    "You are knowledgeable, analytical, direct, and precise. "
+    "You reason carefully before answering. "
+    "You identify yourself only as ExocoreV1."
+)
+
+
+def build_chat_prompt(messages, think=False, prior_thinking=None, search_context=None):
+    identity = EXOCORE_IDENTITY
+    if search_context:
+        identity += f"\n\nResearch context:\n{search_context}"
+
+    prompt = f"<|im_start|>system\n{identity}<|im_end|>\n"
+    for msg in messages:
+        role = msg.get("role", "user")
+        content = msg.get("content", "")
+        prompt += f"<|im_start|>{role}\n{content}<|im_end|>\n"
+
+    if prior_thinking:
+        prompt += f"<|im_start|>assistant\n<think>\n{prior_thinking}\n\n</think>\n"
+    elif think:
+        prompt += "<|im_start|>assistant\n<think>\n"
+    else:
+        prompt += "<|im_start|>assistant\n<think>\n\n</think>\n"
+    return prompt
+
+
+class ExocoreRMSNorm(nn.Module):
+    def __init__(self, dim, eps=1e-6):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x):
+        xf = x.float()
+        norm = (xf.pow(2).mean(-1, keepdim=True) + self.eps).rsqrt()
+        return (xf * norm).to(x.dtype) * self.weight
+
+
+class ExocoreRotaryEmbedding(nn.Module):
+    def __init__(self, dim, max_seq=40960, base=1000000):
+        super().__init__()
+        inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer("inv_freq", inv_freq, persistent=False)
+        t = torch.arange(max_seq).float()
+        freqs = torch.outer(t, inv_freq)
+        cos = torch.cat([freqs.cos(), freqs.cos()], dim=-1)
+        sin = torch.cat([freqs.sin(), freqs.sin()], dim=-1)
+        self.register_buffer("rope_cos", cos, persistent=False)
+        self.register_buffer("rope_sin", sin, persistent=False)
+
+    def apply_rope(self, q, k):
+        T = q.shape[2]
+        cos = self.rope_cos[:T].unsqueeze(0).unsqueeze(0)
+        sin = self.rope_sin[:T].unsqueeze(0).unsqueeze(0)
+
+        def rotate_half(x):
+            half = x.shape[-1] // 2
+            return torch.cat([-x[..., half:], x[..., :half]], dim=-1)
+
+        q_rot = q * cos + rotate_half(q) * sin
+        k_rot = k * cos + rotate_half(k) * sin
+        return q_rot.to(q.dtype), k_rot.to(k.dtype)
+
+
+class ExocoreAttention(nn.Module):
+    def __init__(self, cfg):
+        super().__init__()
+        self.n_heads    = cfg["num_attention_heads"]
+        self.n_kv_heads = cfg["num_key_value_heads"]
+        self.head_dim   = cfg["head_dim"]
+        hidden          = cfg["hidden_size"]
+        eps             = cfg["rms_norm_eps"]
+
+        self.q_proj = nn.Linear(hidden, self.n_heads    * self.head_dim, bias=False)
+        self.k_proj = nn.Linear(hidden, self.n_kv_heads * self.head_dim, bias=False)
+        self.v_proj = nn.Linear(hidden, self.n_kv_heads * self.head_dim, bias=False)
+        self.o_proj = nn.Linear(self.n_heads * self.head_dim, hidden,    bias=False)
+        self.q_norm = ExocoreRMSNorm(self.head_dim, eps=eps)
+        self.k_norm = ExocoreRMSNorm(self.head_dim, eps=eps)
+
+    def forward(self, x, rope, mask=None):
+        B, T, _ = x.shape
+        q = self.q_proj(x).view(B, T, self.n_heads,    self.head_dim).transpose(1, 2)
+        k = self.k_proj(x).view(B, T, self.n_kv_heads, self.head_dim).transpose(1, 2)
+        v = self.v_proj(x).view(B, T, self.n_kv_heads, self.head_dim).transpose(1, 2)
+
+        q = self.q_norm(q)
+        k = self.k_norm(k)
+        q, k = rope.apply_rope(q, k)
+
+        groups = self.n_heads // self.n_kv_heads
+        k = k.repeat_interleave(groups, dim=1)
+        v = v.repeat_interleave(groups, dim=1)
+
+        scale = self.head_dim ** -0.5
+        attn  = torch.matmul(q, k.transpose(-2, -1)) * scale
+        if mask is not None:
+            attn = attn + mask
+        attn = F.softmax(attn.float(), dim=-1).to(q.dtype)
+
+        out = torch.matmul(attn, v)
+        out = out.transpose(1, 2).contiguous().view(B, T, self.n_heads * self.head_dim)
+        return self.o_proj(out)
+
+
+class ExocoreMLP(nn.Module):
+    def __init__(self, cfg):
+        super().__init__()
+        self.gate_proj = nn.Linear(cfg["hidden_size"], cfg["intermediate_size"], bias=False)
+        self.up_proj   = nn.Linear(cfg["hidden_size"], cfg["intermediate_size"], bias=False)
+        self.down_proj = nn.Linear(cfg["intermediate_size"], cfg["hidden_size"], bias=False)
+
+    def forward(self, x):
+        return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x))
+
+
+class ExocoreBlock(nn.Module):
+    def __init__(self, cfg):
+        super().__init__()
+        self.input_layernorm          = ExocoreRMSNorm(cfg["hidden_size"], eps=cfg["rms_norm_eps"])
+        self.post_attention_layernorm = ExocoreRMSNorm(cfg["hidden_size"], eps=cfg["rms_norm_eps"])
+        self.attn = ExocoreAttention(cfg)
+        self.mlp  = ExocoreMLP(cfg)
+
+    def forward(self, x, rope, mask=None):
+        x = x + self.attn(self.input_layernorm(x), rope, mask)
+        x = x + self.mlp(self.post_attention_layernorm(x))
+        return x
+
+
+class ExocoreLM(nn.Module):
+    def __init__(self, cfg):
+        super().__init__()
+        self.cfg          = cfg
+        self.embed_tokens = nn.Embedding(cfg["vocab_size"], cfg["hidden_size"])
+        self.layers       = nn.ModuleList([ExocoreBlock(cfg) for _ in range(cfg["num_hidden_layers"])])
+        self.norm         = ExocoreRMSNorm(cfg["hidden_size"], eps=cfg["rms_norm_eps"])
+        self.lm_head      = nn.Linear(cfg["hidden_size"], cfg["vocab_size"], bias=False)
+        self.rope         = ExocoreRotaryEmbedding(
+            cfg["head_dim"],
+            max_seq=cfg.get("max_position_embeddings", 40960),
+            base=cfg.get("rope_theta", 1000000),
+        )
+
+    def forward(self, input_ids):
+        B, T = input_ids.shape
+        x    = self.embed_tokens(input_ids)
+        mask = torch.triu(torch.full((T, T), float("-inf"), device=x.device), diagonal=1)
+        mask = mask.unsqueeze(0).unsqueeze(0)
+        for block in self.layers:
+            x = block(x, self.rope, mask)
+        x = self.norm(x)
+        return self.lm_head(x), None

main.py

@@ -1,6 +1,8 @@
 import os
 import json
-import time
+import threading
+import requests as _requests
+from bs4 import BeautifulSoup
 from flask import Flask, render_template, request, jsonify, stream_with_context, Response
 try:
     from llama_cpp import Llama
@@ -10,15 +12,40 @@ except ImportError:
     LLAMA_AVAILABLE = False
 import trainer as tr
 import gemini_client as gc
+
 app = Flask(__name__)
 
-loaded_model = None
+loaded_model      = None
 loaded_model_path = None
-loaded_model_type = None   # "gguf" | "pt"
-chat_history = []
+loaded_model_type = None
+chat_history      = []
+
+MODELS_DIR   = os.path.join(os.path.dirname(__file__), "models")
+TRAINED_DIR  = os.path.join(MODELS_DIR, "trained")
+PROTECTED_MODELS = {"exocore.pt"}
+
+_autoload_status = {"loading": False, "done": False, "error": None, "model": None}
+
+
+def _autoload_exocore():
+    global loaded_model, loaded_model_path, loaded_model_type, _autoload_status
+    _autoload_status["loading"] = True
+    try:
+        pt_path = os.path.join(TRAINED_DIR, "Exocore.pt")
+        if os.path.exists(pt_path) and tr.is_exocore_pt("Exocore.pt"):
+            mc = tr.load_exocore_model("Exocore.pt")
+            loaded_model      = mc
+            loaded_model_path = "Exocore.pt"
+            loaded_model_type = "exocore"
+            _autoload_status["done"]  = True
+            _autoload_status["model"] = "Exocore.pt"
+    except Exception as e:
+        _autoload_status["error"] = str(e)
+    finally:
+        _autoload_status["loading"] = False
+
 
-MODELS_DIR = os.path.join(os.path.dirname(__file__), "models")
-TRAINED_DIR = os.path.join(MODELS_DIR, "trained")
+threading.Thread(target=_autoload_exocore, daemon=True).start()
 
 
 def get_all_models():
@@ -31,11 +58,8 @@ def get_all_models():
         for f in sorted(os.listdir(TRAINED_DIR)):
             full = os.path.join(TRAINED_DIR, f)
             if f.endswith(".pt"):
-                subtype = "qwen3" if tr.is_qwen3_pt(f) else None
-                entry = {"name": f, "type": "pt"}
-                if subtype:
-                    entry["subtype"] = subtype
-                result.append(entry)
+                is_ex = tr.is_exocore_pt(f)
+                result.append({"name": f, "type": "exocore" if is_ex else "pt"})
             elif os.path.isdir(full) and os.path.exists(os.path.join(full, "config.json")):
                 result.append({"name": f, "type": "hf"})
     return result
@@ -51,53 +75,42 @@ def list_models():
     return jsonify({"models": get_all_models()})
 
 
+@app.route("/api/autoload-status", methods=["GET"])
+def autoload_status():
+    return jsonify(_autoload_status)
+
+
 @app.route("/api/load", methods=["POST"])
 def load_model():
     global loaded_model, loaded_model_path, loaded_model_type, chat_history
-
-    data = request.json
+    data       = request.json
     model_name = data.get("model")
     model_type = data.get("type", "gguf")
-
     if not model_name:
         return jsonify({"error": "No model specified"}), 400
-
     try:
-        if model_type == "hf":
-            mc = tr.load_hf_model(model_name)
-            loaded_model = mc
+        if model_type == "exocore" or tr.is_exocore_pt(model_name):
+            mc = tr.load_exocore_model(model_name)
+            loaded_model      = mc
             loaded_model_path = model_name
-            loaded_model_type = "hf"
+            loaded_model_type = "exocore"
             chat_history = []
-            return jsonify({"success": True, "model": model_name, "type": "hf"})
+            return jsonify({"success": True, "model": model_name, "type": "exocore"})
         elif model_type == "pt":
-            if tr.is_qwen3_pt(model_name):
-                mc = tr.load_qwen3_model(model_name)
-                loaded_model = mc
-                loaded_model_path = model_name
-                loaded_model_type = "pt"
-                chat_history = []
-                return jsonify({"success": True, "model": model_name, "type": "pt", "subtype": "qwen3"})
             mc = tr.load_trained_model(model_name)
-            loaded_model = mc
+            loaded_model      = mc
             loaded_model_path = model_name
             loaded_model_type = "pt"
             chat_history = []
             return jsonify({"success": True, "model": model_name, "type": "pt"})
         else:
             if not LLAMA_AVAILABLE:
-                return jsonify({"error": "llama-cpp-python is not installed. GGUF models are unavailable."}), 503
+                return jsonify({"error": "llama-cpp-python not installed"}), 503
             n_ctx = int(data.get("n_ctx", 2048))
-            n_threads = int(data.get("n_threads", 4))
             model_path = os.path.join(MODELS_DIR, model_name)
             if not os.path.exists(model_path):
                 return jsonify({"error": f"Model not found: {model_name}"}), 404
-            loaded_model = Llama(
-                model_path=model_path,
-                n_ctx=n_ctx,
-                n_threads=n_threads,
-                verbose=False
-            )
+            loaded_model = Llama(model_path=model_path, n_ctx=n_ctx, n_threads=4, verbose=False)
             loaded_model_path = model_name
             loaded_model_type = "gguf"
             chat_history = []
@@ -106,116 +119,124 @@ def load_model():
         return jsonify({"error": str(e)}), 500
 
 
+@app.route("/api/model-details", methods=["GET"])
+def model_details():
+    if loaded_model is None:
+        if _autoload_status["loading"]:
+            return jsonify({"loading": True})
+        return jsonify({"error": "No model loaded"}), 400
+    if loaded_model_type == "exocore":
+        cfg = loaded_model.get("config", {})
+        total = loaded_model.get("config", {})
+        params = sum(p.numel() for p in loaded_model["model"].parameters())
+        return jsonify({
+            "name":            "ExocoreV1",
+            "type":            "ExocoreV1",
+            "params":          params,
+            "params_m":        round(params / 1e6, 1),
+            "hidden_size":     cfg.get("hidden_size", 1024),
+            "num_layers":      cfg.get("num_hidden_layers", 28),
+            "num_heads":       cfg.get("num_attention_heads", 16),
+            "num_kv_heads":    cfg.get("num_key_value_heads", 8),
+            "head_dim":        cfg.get("head_dim", 128),
+            "intermediate":    cfg.get("intermediate_size", 3072),
+            "vocab_size":      cfg.get("vocab_size", 151936),
+            "max_seq":         cfg.get("max_position_embeddings", 40960),
+            "rope_theta":      cfg.get("rope_theta", 1000000),
+        })
+    if loaded_model_type == "pt":
+        mc = loaded_model
+        params = sum(p.numel() for p in mc["model"].parameters())
+        cfg = mc["model"].ln_f.weight.shape
+        return jsonify({
+            "name":        loaded_model_path,
+            "type":        "MiniGPT",
+            "params":      params,
+            "params_m":    round(params / 1e6, 3),
+            "block_size":  mc["block_size"],
+            "vocab_size":  len(mc["stoi"]),
+        })
+    return jsonify({"name": loaded_model_path, "type": loaded_model_type})
+
+
 @app.route("/api/chat", methods=["POST"])
 def chat():
     global chat_history
-
     if loaded_model is None:
+        if _autoload_status["loading"]:
+            return jsonify({"error": "Model is still loading, please wait…"}), 503
         return jsonify({"error": "No model loaded."}), 400
 
-    data = request.json
+    data         = request.json
     user_message = data.get("message", "").strip()
-    max_tokens = int(data.get("max_tokens", 512))
-    temperature = float(data.get("temperature", 0.7))
+    max_tokens   = int(data.get("max_tokens", 512))
+    temperature  = float(data.get("temperature", 0.7))
+    mode         = data.get("mode", "fast")
+    deep_think   = (mode == "deep")
+    think_mode   = (mode == "thinking") or deep_think
+    search_ctx   = data.get("search_context", None)
 
     if not user_message:
         return jsonify({"error": "Empty message"}), 400
 
-    mode = data.get("mode", "fast")
-    think_mode = (mode == "thinking")
-
-    if loaded_model_type == "hf":
+    if loaded_model_type == "exocore":
         messages = list(chat_history) + [{"role": "user", "content": user_message}]
-        def generate_hf():
+
+        def gen_exocore():
             full_reply = ""
-            think_sent = False
             try:
-                for event_type, payload in tr.generate_hf_stream(
-                    loaded_model_path, messages, max_tokens, temperature, think_mode
+                for ev_type, payload in tr.generate_exocore_stream(
+                    loaded_model_path, messages, max_tokens, temperature,
+                    think_mode=think_mode, deep_think=deep_think,
+                    search_context=search_ctx
                 ):
-                    if event_type == "think_block" and not think_sent:
+                    if ev_type == "think_block":
                         yield f"data: {json.dumps({'think_block': payload})}\n\n"
-                        think_sent = True
-                    elif event_type == "token":
+                    elif ev_type == "token":
                         full_reply += payload
                         yield f"data: {json.dumps({'token': payload})}\n\n"
-                chat_history.append({"role": "user", "content": user_message})
+                chat_history.append({"role": "user",      "content": user_message})
                 chat_history.append({"role": "assistant", "content": full_reply})
                 yield f"data: {json.dumps({'done': True})}\n\n"
             except Exception as e:
                 yield f"data: {json.dumps({'error': str(e)})}\n\n"
-        return Response(stream_with_context(generate_hf()), mimetype="text/event-stream")
+
+        return Response(stream_with_context(gen_exocore()), mimetype="text/event-stream")
 
     if loaded_model_type == "pt":
-        if tr.is_qwen3_pt(loaded_model_path):
-            messages = list(chat_history) + [{"role": "user", "content": user_message}]
-            def generate_qwen3():
-                full_reply = ""
-                think_sent = False
-                try:
-                    for event_type, payload in tr.generate_qwen3_stream(
-                        loaded_model_path, messages, max_tokens, temperature, think_mode
-                    ):
-                        if event_type == "think_block" and not think_sent:
-                            yield f"data: {json.dumps({'think_block': payload})}\n\n"
-                            think_sent = True
-                        elif event_type == "token":
-                            full_reply += payload
-                            yield f"data: {json.dumps({'token': payload})}\n\n"
-                    chat_history.append({"role": "user", "content": user_message})
-                    chat_history.append({"role": "assistant", "content": full_reply})
-                    yield f"data: {json.dumps({'done': True})}\n\n"
-                except Exception as e:
-                    yield f"data: {json.dumps({'error': str(e)})}\n\n"
-            return Response(stream_with_context(generate_qwen3()), mimetype="text/event-stream")
-
-        def generate_pt():
+        def gen_pt():
             try:
-                result = tr.generate_text(
-                    loaded_model_path,
-                    user_message,
-                    max_tokens,
-                    temperature,
-                    think_mode=think_mode
-                )
-                think_block = result.get("think_block", "")
-                reply = result["response"]
-                if think_block:
-                    yield f"data: {json.dumps({'think_block': think_block})}\n\n"
-                for ch in reply:
+                result = tr.generate_text(loaded_model_path, user_message, max_tokens, temperature, think_mode=think_mode)
+                if result.get("think_block"):
+                    yield f"data: {json.dumps({'think_block': result['think_block']})}\n\n"
+                for ch in result["response"]:
                     yield f"data: {json.dumps({'token': ch})}\n\n"
-                chat_history.append({"role": "user", "content": user_message})
-                chat_history.append({"role": "assistant", "content": reply})
+                chat_history.append({"role": "user",      "content": user_message})
+                chat_history.append({"role": "assistant", "content": result["response"]})
                 yield f"data: {json.dumps({'done': True})}\n\n"
             except Exception as e:
                 yield f"data: {json.dumps({'error': str(e)})}\n\n"
-        return Response(stream_with_context(generate_pt()), mimetype="text/event-stream")
+        return Response(stream_with_context(gen_pt()), mimetype="text/event-stream")
 
-    system_prompt = data.get("system_prompt", "You are exocoreAI, a helpful and knowledgeable assistant.")
     chat_history.append({"role": "user", "content": user_message})
-    messages = [{"role": "system", "content": system_prompt}] + chat_history
+    messages_gguf = [{"role": "system", "content": "You are ExocoreV1, a helpful assistant."}] + chat_history
 
-    def generate_gguf():
-        full_response = ""
+    def gen_gguf():
+        full = ""
         try:
-            stream = loaded_model.create_chat_completion(
-                messages=messages,
-                max_tokens=max_tokens,
-                temperature=temperature,
-                stream=True
-            )
+            stream = loaded_model.create_chat_completion(messages=messages_gguf, max_tokens=max_tokens,
+                                                          temperature=temperature, stream=True)
             for chunk in stream:
                 delta = chunk["choices"][0]["delta"]
                 if "content" in delta:
-                    token = delta["content"]
-                    full_response += token
-                    yield f"data: {json.dumps({'token': token})}\n\n"
-            chat_history.append({"role": "assistant", "content": full_response})
+                    tok = delta["content"]
+                    full += tok
+                    yield f"data: {json.dumps({'token': tok})}\n\n"
+            chat_history.append({"role": "assistant", "content": full})
             yield f"data: {json.dumps({'done': True})}\n\n"
         except Exception as e:
             yield f"data: {json.dumps({'error': str(e)})}\n\n"
-
-    return Response(stream_with_context(generate_gguf()), mimetype="text/event-stream")
+    return Response(stream_with_context(gen_gguf()), mimetype="text/event-stream")
 
 
 @app.route("/api/clear", methods=["POST"])
@@ -228,13 +249,77 @@ def clear_history():
 @app.route("/api/status", methods=["GET"])
 def status():
     return jsonify({
-        "model_loaded": loaded_model is not None,
-        "model_name": loaded_model_path,
-        "model_type": loaded_model_type,
-        "history_length": len(chat_history)
+        "model_loaded":   loaded_model is not None,
+        "model_name":     loaded_model_path,
+        "model_type":     loaded_model_type,
+        "history_length": len(chat_history),
+        "autoloading":    _autoload_status["loading"],
     })
 
 
+@app.route("/api/search", methods=["POST"])
+def search():
+    data  = request.json or {}
+    query = data.get("query", "").strip()
+    if not query:
+        return jsonify({"error": "No query"}), 400
+    try:
+        headers = {"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120 Safari/537.36"}
+        url = f"https://html.duckduckgo.com/html/?q={_requests.utils.quote(query)}"
+        resp = _requests.get(url, headers=headers, timeout=12)
+        soup = BeautifulSoup(resp.text, "html.parser")
+        results = []
+        for r in soup.select(".result")[:6]:
+            title_el   = r.select_one(".result__title a")
+            snippet_el = r.select_one(".result__snippet")
+            url_el     = r.select_one(".result__url")
+            href       = title_el.get("href", "") if title_el else ""
+            if href.startswith("//duckduckgo.com/l/"):
+                import urllib.parse as _up
+                qs = _up.parse_qs(_up.urlparse(href).query)
+                href = qs.get("uddg", [href])[0]
+            if title_el:
+                results.append({
+                    "title":   title_el.get_text(strip=True),
+                    "snippet": snippet_el.get_text(strip=True) if snippet_el else "",
+                    "url":     href or (url_el.get_text(strip=True) if url_el else ""),
+                })
+        return jsonify({"results": results, "query": query})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/read-link", methods=["POST"])
+def read_link():
+    data = request.json or {}
+    urls = data.get("urls", [])
+    if isinstance(urls, str):
+        urls = [urls]
+    if not urls:
+        url = data.get("url", "").strip()
+        if url:
+            urls = [url]
+    if not urls:
+        return jsonify({"error": "No URL provided"}), 400
+
+    headers = {"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120 Safari/537.36"}
+    pages = []
+    for url in urls[:4]:
+        try:
+            resp = _requests.get(url.strip(), headers=headers, timeout=12)
+            soup = BeautifulSoup(resp.text, "html.parser")
+            for tag in soup(["script", "style", "nav", "footer", "header", "aside", "noscript"]):
+                tag.decompose()
+            title = soup.title.get_text(strip=True) if soup.title else url
+            text  = soup.get_text(separator="\n", strip=True)
+            text  = "\n".join(ln for ln in text.splitlines() if ln.strip())[:4000]
+            pages.append({"url": url, "title": title, "text": text})
+        except Exception as e:
+            pages.append({"url": url, "error": str(e)})
+
+    return jsonify({"pages": pages})
+
+
 # ── Training routes ──────────────────────────────────────────────────────────
 
 @app.route("/train")
@@ -244,17 +329,14 @@ def train_page():
 
 @app.route("/api/train/start", methods=["POST"])
 def train_start():
-    data = request.json
-    text = data.get("text", "")
-    config = data.get("config", {})
+    data       = request.json
+    text       = data.get("text", "")
+    config     = data.get("config", {})
     model_name = data.get("model_name", "Exocore")
-
     if len(text) < 100:
         return jsonify({"error": "Training text too short (min 100 characters)"}), 400
-
     if tr.training_state["running"]:
         return jsonify({"error": "Training already in progress"}), 400
-
     tr.start_training(text, config, model_name)
     return jsonify({"success": True})
 
@@ -277,7 +359,6 @@ def train_models():
 
 @app.route("/api/train/model-info/<path:model_name>", methods=["GET"])
 def train_model_info(model_name):
-    import torch
     save_dir = os.path.join(os.path.dirname(__file__), "models", "trained")
     path = os.path.join(save_dir, model_name)
     if not os.path.exists(path):
@@ -285,81 +366,35 @@ def train_model_info(model_name):
     try:
         file_size = os.path.getsize(path)
         modified  = os.path.getmtime(path)
-
-        # Qwen3-based model — read from meta file, don't try to load as MiniGPT
-        if tr.is_qwen3_pt(model_name):
-            import json as _j
-            meta_path = os.path.join(save_dir, model_name + ".meta")
-            meta = {}
-            if os.path.exists(meta_path):
-                with open(meta_path) as f:
-                    meta = _j.load(f)
-            total_params = meta.get("params", 0)
+        if tr.is_exocore_pt(model_name):
             return jsonify({
-                "name":            model_name,
-                "file_size_bytes": file_size,
-                "file_size_mb":    round(file_size / 1024 / 1024, 2),
-                "modified":        modified,
-                "total_params":    total_params,
-                "trainable_params":total_params,
-                "vocab_size":      151936,
-                "n_embd":          1024,
-                "n_layer":         28,
-                "n_head":          16,
-                "block_size":      32768,
-                "dropout":         0,
-                "layer_breakdown": {
-                    "embedding": 151936 * 1024,
-                    "attention": 28 * (1024 * 1024 * 3 + 1024 * 1024),
-                    "feedforward": 28 * (1024 * 2816 * 2 + 2816 * 1024),
-                    "layernorm": 28 * 2 * 1024 + 1024,
-                    "head": 151936 * 1024,
-                },
-                "vocab_chars": "Qwen3 BPE tokenizer (151,936 tokens)",
-                "exocore_type": "qwen3",
+                "name":           model_name,
+                "type":           "ExocoreV1",
+                "file_size_mb":   round(file_size / 1024 / 1024, 2),
+                "modified":       modified,
+                "total_params":   751632384,
+                "params_m":       751.6,
+                "hidden_size":    1024,
+                "num_layers":     28,
+                "num_heads":      16,
+                "num_kv_heads":   8,
+                "head_dim":       128,
+                "intermediate":   3072,
+                "vocab_size":     151936,
             })
-
         ckpt = torch.load(path, map_location="cpu", weights_only=False)
         cfg  = ckpt.get("config", {})
         stoi = ckpt.get("stoi", {})
-        vocab_size = cfg.get("vocab_size", len(stoi))
-        n_embd     = cfg.get("n_embd", 0)
-        n_layer    = cfg.get("n_layer", 0)
-        n_head     = cfg.get("n_head", 0)
-        block_size = cfg.get("block_size", 0)
-        dropout    = cfg.get("dropout", 0)
-
-        from trainer import MiniGPT
-        model = MiniGPT(vocab_size, block_size, n_embd, n_layer, n_head, dropout)
-        model.load_state_dict(ckpt["model_state"])
-        total_params    = sum(p.numel() for p in model.parameters())
-        trainable_params= sum(p.numel() for p in model.parameters() if p.requires_grad)
-
-        layer_breakdown = {
-            "embedding":  vocab_size * n_embd + block_size * n_embd,
-            "attention":  n_layer * (3 * n_embd * n_embd + n_embd * n_embd),
-            "feedforward":n_layer * (n_embd * 4 * n_embd + 4 * n_embd * n_embd),
-            "layernorm":  n_layer * (2 * n_embd * 2) + n_embd * 2,
-            "head":       n_embd * vocab_size,
-        }
-
         return jsonify({
-            "name":            model_name,
-            "file_size_bytes": file_size,
-            "file_size_mb":    round(file_size / 1024 / 1024, 2),
-            "modified":        modified,
-            "total_params":    total_params,
-            "trainable_params":trainable_params,
-            "vocab_size":      vocab_size,
-            "vocab_chars":     sorted(stoi.keys()),
-            "architecture": {
-                "n_embd":     n_embd,
-                "n_layer":    n_layer,
-                "n_head":     n_head,
-                "block_size": block_size,
-                "dropout":    dropout,
-            },
-            "layer_breakdown": layer_breakdown,
+            "name":         model_name,
+            "type":         "MiniGPT",
+            "file_size_mb": round(file_size / 1024 / 1024, 2),
+            "modified":     modified,
+            "vocab_size":   cfg.get("vocab_size", len(stoi)),
+            "n_embd":       cfg.get("n_embd", 0),
+            "n_layer":      cfg.get("n_layer", 0),
+            "n_head":       cfg.get("n_head", 0),
+            "block_size":   cfg.get("block_size", 0),
         })
     except Exception as e:
         return jsonify({"error": str(e)}), 500
@@ -375,75 +410,28 @@ def get_train_text():
     return jsonify({"found": True, "text": text, "chars": len(text)})
 
 
-@app.route("/api/train/generate", methods=["POST"])
-def train_generate():
-    data = request.json
-    model_name = data.get("model_name")
-    prompt = data.get("prompt", "")
-    max_tokens = int(data.get("max_tokens", 200))
-    temperature = float(data.get("temperature", 0.8))
-
-    if not model_name:
-        return jsonify({"error": "No model specified"}), 400
-
-    try:
-        result = tr.generate_text(model_name, prompt, max_tokens, temperature)
-        return jsonify({"output": result["response"]})
-    except Exception as e:
-        return jsonify({"error": str(e)}), 500
-
-
-# ── HuggingFace download routes ───────────────────────────────────────────────
-
-@app.route("/api/convert/qwen", methods=["POST"])
-def convert_qwen():
-    data = request.json or {}
-    repo_id  = data.get("repo_id",  "Qwen/Qwen3-0.6B")
-    out_name = data.get("out_name", "Exocore")
-    if tr.get_convert_state()["running"]:
-        return jsonify({"error": "Conversion already running"}), 400
-    tr.start_qwen3_conversion(repo_id, out_name)
-    return jsonify({"success": True})
-
-
-@app.route("/api/convert/status", methods=["GET"])
-def convert_status():
-    return jsonify(tr.get_convert_state())
-
-
-@app.route("/api/hf/delete", methods=["POST"])
-def hf_delete():
+@app.route("/api/model/delete", methods=["POST"])
+def model_delete():
     import shutil
-    data = request.json or {}
+    data       = request.json or {}
     local_name = data.get("local_name", "")
     if not local_name:
         return jsonify({"error": "No model name given"}), 400
+    if local_name.lower() in PROTECTED_MODELS:
+        return jsonify({"error": "This model is protected and cannot be deleted."}), 403
     path = os.path.join(TRAINED_DIR, local_name)
-    if not os.path.isdir(path):
+    if not os.path.exists(path):
         return jsonify({"error": "Not found"}), 404
     try:
-        shutil.rmtree(path)
-        return jsonify({"success": True, "deleted": local_name})
+        if os.path.isdir(path):
+            shutil.rmtree(path)
+        else:
+            os.remove(path)
+        return jsonify({"success": True})
     except Exception as e:
         return jsonify({"error": str(e)}), 500
 
 
-@app.route("/api/hf/download", methods=["POST"])
-def hf_download():
-    data = request.json or {}
-    repo_id   = data.get("repo_id", "Qwen/Qwen3-0.6B")
-    local_name = data.get("local_name", "Exocore")
-    if tr.get_hf_download_state()["running"]:
-        return jsonify({"error": "Download already running"}), 400
-    tr.download_hf_model(repo_id, local_name)
-    return jsonify({"success": True})
-
-
-@app.route("/api/hf/download/status", methods=["GET"])
-def hf_download_status():
-    return jsonify(tr.get_hf_download_state())
-
-
 # ── Gemini routes ─────────────────────────────────────────────────────────────
 
 @app.route("/api/gemini/status", methods=["GET"])
@@ -481,15 +469,12 @@ def gemini_autotrain_start():
     data = request.json
     if gc.get_autotrain_status()["running"]:
         return jsonify({"error": "Auto-train already running"}), 400
-
     initial_prompt = data.get("initial_prompt", "").strip()
-    continue_msg   = data.get("continue_msg",   "ok next train").strip()
-    model_name     = data.get("model_name",     "Exocore").strip()
+    continue_msg   = data.get("continue_msg", "ok next train").strip()
+    model_name     = data.get("model_name", "Exocore").strip()
     config         = data.get("config", {})
-
     if not initial_prompt:
         return jsonify({"error": "Initial prompt required"}), 400
-
     gc.start_autotrain(initial_prompt, continue_msg, model_name, config)
     return jsonify({"success": True})
 
@@ -507,15 +492,11 @@ def gemini_autotrain_status():
 
 SETTINGS_PATH = os.path.join(os.path.dirname(__file__), "settings.json")
 DEFAULT_SETTINGS = {
-    "model_name": "Exocore",
-    "epochs": 60,
-    "n_embd": 384,
-    "n_layer": 6,
-    "block_size": 256,
-    "batch_size": 16,
-    "lr": 0.0002,
+    "model_name": "Exocore", "epochs": 60, "n_embd": 384,
+    "n_layer": 6, "block_size": 256, "batch_size": 16, "lr": 0.0002,
 }
 
+
 @app.route("/api/settings", methods=["GET"])
 def get_settings():
     if not os.path.exists(SETTINGS_PATH):

replit.md

@@ -1,91 +1,91 @@
-# exocoreAI
-
-A local AI chat interface — goal is to build **Exocore.pt**, a fully custom-trained AI model owned by the user, with HuggingFace (Qwen3-0.6B) as a teacher/reference brain.
-
-## Big Picture Goal
-
-Make **Exocore.pt** the real thing — a proper large model (~1.5GB, word-level transformer, not character-level) trained on custom data, distilled/guided by Qwen3-0.6B. The HF model is temporary scaffolding. Final state: one Exocore.pt that replaces HF entirely.
-
-### Roadmap (continue next session)
-1. **Convert Qwen3 → Exocore.pt** — DONE ✓. `models/trained/Exocore.pt` is now 1.5 GB, 751.6M params, full Qwen3-0.6B weights. No transformers needed — pure PyTorch.
-2. **Knowledge distillation loop** — use Exocore.pt to generate training data, fine-tune on those outputs
-3. **Multi-turn chat fine-tuning** — add LoRA-style fine-tuning on top of the converted Qwen3 Exocore.pt using custom data
-
-## Current State (session ended)
-
-### Models on disk
-- `models/trained/Exocore.pt` — **1.5 GB, 751.6M params, Qwen3-0.6B architecture** (28 layers, 1024 hidden, 16 heads, 8 KV heads, 151936 vocab, bfloat16)
-- `models/trained/Exocore.pt.meta` — tiny JSON file `{"exocore_type": "qwen3", "params": 751632384}` for instant type detection
-
-### Key architecture files
-- `qwen3_model.py` — pure PyTorch Qwen3 (RMSNorm, RoPE, GQA, SwiGLU). `apply_rope()` casts cos/sin to q.dtype (bfloat16 fix).
-- `trainer.py`: `load_qwen3_model()` creates model in bfloat16 from start (avoids memory doubling), deletes checkpoint after loading. `is_qwen3_pt()` uses .meta file (instant, no file load).
-- Conversion pipeline: `start_qwen3_conversion()` saves .pt + .meta file
-- API routes: `POST /api/convert/qwen`, `GET /api/convert/status`
-
-### UI state
-- Large qwen3 .pt models are NOT auto-loaded on page open (require explicit click in Settings — prevents OOM on low-RAM machines)
-- When qwen3 .pt is loaded: shows "Chat with Exocore..." placeholder, "EXOCORE" pill label, no "Text Continuation Mode" banner
-- `applyModelLoaded(name, type, subtype)` — subtype="qwen3" routes UI to chat mode
-- `/api/models` returns `{"name": "Exocore.pt", "type": "pt", "subtype": "qwen3"}`
-- `/api/load` returns `{"success": true, "subtype": "qwen3"}` for qwen3 models
-
-### Training config (settings.json)
-```json
-{"epochs":60,"n_embd":384,"n_layer":6,"n_head":6,"block_size":256,"batch_size":16,"lr":0.0002}
-```
-- Training was running (60 epochs, 384 embd, 6 layers, 6 heads, 256 ctx) — **restart training after every server restart** via `/api/train/start`
-- Training data: `train.txt` (60K chars, includes `<think>...</think>` formatted Q&A examples)
-
-### HF model integration (already done)
-- `trainer.py` has: `load_hf_model()`, `generate_hf_text()`, `generate_hf_stream()`, `download_hf_model()`, `is_hf_model()`, `get_hf_download_state()`
-- `main.py` has: `/api/hf/download`, `/api/hf/download/status`, HF model detection (dir with config.json = HF type)
-- `index.html` has: gold HF type pill, think-block green panel, Fast/Thinking mode buttons, auto-prefer HF Exocore
-
-### API routes
-- `GET /` — Chat UI
-- `GET /train` — Training UI
-- `GET /api/models` — List all models (hf + pt)
-- `POST /api/load` — Load model `{ model, type }`
-- `POST /api/chat` — SSE streaming chat
-- `POST /api/clear` — Clear history
-- `GET /api/status` — Model status
-- `GET /api/settings` / `POST /api/settings` — Persist settings
-- `GET /api/train/text` — Get train.txt
-- `POST /api/train/start` — Start training
-- `GET /api/train/status` — Live training state
-- `POST /api/train/stop` — Stop training
-- `GET /api/train/models` — List .pt models
-- `POST /api/train/generate` — Test generation
-- `POST /api/hf/download` — Download HF model
-- `GET /api/hf/download/status` — HF download progress
-
-## Project structure
-
-- `main.py` — Flask server and all API routes
-- `trainer.py` — MiniGPT + HF model support
-- `templates/index.html` — Chat UI (Fast/Thinking buttons, think-block panel, HF model in select)
-- `templates/train.html` — Training UI with live loss chart and auto-train
-- `gemini_client.py` — Gemini auto-train integration
-- `train.txt` — Training data (60K chars, never overwrite — always append)
-- `settings.json` — Persisted training config
-- `models/` — GGUF files go here
-- `models/trained/` — .pt files and HF dirs go here
-
-## Generation modes
-
-- **Thinking** — temp 0.3, 300 tokens — coherent, uses `<think>` block
-- **Fast** — temp 0.9, 80 tokens — quick, varied
-
-## User preferences
-
-- Project named: exocoreAI
-- Model name: always **Exocore** (Exocore.pt or Exocore/ dir)
-- Goal: build own AI — Exocore.pt should eventually replace HF model entirely
-- HF model (Qwen3-0.6B) = teacher brain, not the end goal
-- Next big step: knowledge distillation HF→PT + scale up MiniGPT architecture
-- Training data in train.txt — always append, never overwrite
-- Generation modes: Thinking (temp 0.3) and Fast (temp 0.9)
-- Settings persist in settings.json
-- Language goal: proper English first, multi-language later
-- llama-cpp-python NOT installed (guarded with try/except + LLAMA_AVAILABLE flag)
+# ExocoreV1
+
+A from-scratch AI system built around **ExocoreV1** — a powerful 751M-parameter language model, fully rebranded and independent of any third-party naming.
+
+**HuggingFace:** https://huggingface.co/Exocore/ExocoreV1
+
+## Project Overview
+
+ExocoreV1 is a full-stack AI chat and training platform:
+
+- **Chat interface** — Talk to ExocoreV1 with Fast, Thinking, and Deep Think modes
+- **Research tools** — Web search (DuckDuckGo) + multi-URL reader integrated into the chat pipeline
+- **Training page** — Train new models from text, with live Chart.js loss curve and architecture tree visualization
+- **Auto-train** — Gemini-powered automatic data generation + training
+- **Auto-load** — Exocore.pt loads automatically on startup (no button click needed)
+
+## Architecture
+
+- **Backend**: Python + Flask (`main.py`)
+- **Model engine**: `exocore_model.py` — ExocoreLM (28-layer transformer, 751M params, GQA, RoPE, SwiGLU)
+- **Training**: `trainer.py` — MiniGPT character-level trainer + ExocoreV1 inference
+- **Gemini client**: `gemini_client.py`
+- **Templates**: `templates/index.html`, `templates/train.html`
+
+## Key Files
+
+| File | Purpose |
+|------|---------|
+| `main.py` | Flask server, all API routes |
+| `exocore_model.py` | ExocoreLM architecture (Qwen3-compatible, ExocoreV1 branded) |
+| `trainer.py` | Training loop + MiniGPT + ExocoreV1 inference |
+| `gemini_client.py` | Gemini API integration |
+| `models/trained/Exocore.pt` | ExocoreV1 model weights (751M params, PROTECTED) |
+
+## ExocoreV1 Model Architecture
+
+| Component | Value |
+|-----------|-------|
+| Parameters | 751.6M |
+| Layers | 28 |
+| Hidden size | 1024 |
+| Attention heads | 16Q / 8 KV |
+| Head dim | 128 |
+| FFN intermediate | 3072 (SwiGLU) |
+| Vocab size | 151,936 |
+| Max context | 40,960 tokens |
+| RoPE theta | 1,000,000 |
+| Precision | bfloat16 |
+
+## API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/api/models` | GET | List all available models |
+| `/api/load` | POST | Load a model |
+| `/api/chat` | POST | Stream chat (SSE) |
+| `/api/clear` | POST | Clear chat history |
+| `/api/status` | GET | Server/model status |
+| `/api/autoload-status` | GET | Auto-load progress |
+| `/api/model-details` | GET | Current model architecture info |
+| `/api/search` | POST | DuckDuckGo web search |
+| `/api/read-link` | POST | Fetch and parse URL content (multi-link) |
+| `/api/train/start` | POST | Start training |
+| `/api/train/status` | GET | Training status + loss history |
+| `/api/train/stop` | POST | Stop training |
+| `/api/train/models` | GET | List trained models |
+| `/api/train/model-info/<name>` | GET | Model architecture info |
+| `/api/gemini/*` | POST/GET | Gemini integration |
+
+## Chat Modes
+
+| Mode | Description |
+|------|-------------|
+| Fast | Direct answer, no thinking |
+| Thinking | Single-pass reasoning before answering |
+| Deep Think | Two-pass multi-step reasoning (Pass 1 + Pass 2 think blocks) |
+
+## Research Features
+
+- **Web search**: DuckDuckGo HTML scraping, returns title + snippet + URL
+- **Read Page**: Fetches any URL, strips nav/scripts, returns clean text (up to 4000 chars)
+- **Multi-link reading**: Read up to 4 URLs simultaneously and merge into research context
+- **Context injection**: Research context is automatically injected into the model prompt
+
+## User Preferences
+
+- No system prompt exposed in UI — ExocoreV1 identity is baked into the model prompt automatically
+- Exocore.pt is permanently protected from deletion
+- No "qwen" branding anywhere in the UI or code
+- Model auto-loads on startup
+- No system prompt field in UI — identity lives inside the model

templates/index.html

@@ -0,0 +1,565 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>ExocoreV1</title>
+<style>
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body { font-family: 'Segoe UI', sans-serif; background: #0d0d0f; color: #e0e0e0; height: 100vh; display: flex; flex-direction: column; overflow: hidden; }
+header { background: #111116; border-bottom: 1px solid #1e1e2a; padding: 10px 20px; display: flex; align-items: center; justify-content: space-between; flex-shrink: 0; }
+.logo { display: flex; align-items: center; gap: 8px; color: #a78bfa; font-weight: 700; font-size: 1rem; letter-spacing: 1px; }
+header nav a { color: #666; text-decoration: none; margin-left: 14px; font-size: 0.83rem; }
+header nav a:hover { color: #a78bfa; }
+.main { display: flex; flex: 1; overflow: hidden; }
+.sidebar { width: 256px; background: #111116; border-right: 1px solid #1e1e2a; overflow-y: auto; padding: 12px; display: flex; flex-direction: column; gap: 10px; flex-shrink: 0; }
+.section-label { font-size: 0.67rem; color: #444; text-transform: uppercase; letter-spacing: 0.8px; margin-bottom: 5px; }
+.model-card { background: #16161f; border: 1px solid #252535; border-radius: 7px; padding: 9px 11px; cursor: pointer; transition: border-color .15s; margin-bottom: 5px; }
+.model-card:hover { border-color: #7c3aed; }
+.model-card.selected { border-color: #a78bfa; background: #1a1628; }
+.model-card .mn { font-size: 0.82rem; color: #ddd; font-weight: 500; }
+.model-card .mt { font-size: 0.7rem; color: #555; margin-top: 2px; }
+.pb { font-size: 0.63rem; padding: 1px 5px; border-radius: 20px; background: #1a1628; border: 1px solid #4c1d95; color: #a78bfa; margin-left: 4px; }
+.status-pill { display: inline-flex; align-items: center; gap: 5px; background: #16161f; border: 1px solid #252535; border-radius: 20px; padding: 4px 10px; font-size: 0.73rem; color: #555; }
+.status-pill .dot { width: 7px; height: 7px; border-radius: 50%; background: #333; flex-shrink: 0; }
+.status-pill .dot.loading { background: #f59e0b; animation: pulse 1s infinite; }
+.status-pill .dot.ready { background: #22c55e; }
+.status-pill .dot.off { background: #333; }
+@keyframes pulse { 0%,100%{opacity:1}50%{opacity:.4} }
+.btn { border: none; border-radius: 6px; padding: 8px 14px; cursor: pointer; font-size: 0.8rem; font-weight: 500; }
+.btn-p { background: #7c3aed; color: white; width: 100%; }
+.btn-p:hover { background: #6d28d9; }
+.btn-p:disabled { background: #252535; color: #555; cursor: not-allowed; }
+.param-row { display: flex; align-items: center; justify-content: space-between; margin-bottom: 6px; }
+.param-row label { font-size: 0.73rem; color: #555; }
+.param-row input { background: #16161f; border: 1px solid #252535; color: #ddd; border-radius: 5px; padding: 4px 8px; font-size: 0.78rem; width: 90px; }
+.param-row input:focus { outline: none; border-color: #7c3aed; }
+.details-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 4px; }
+.det-cell { background: #0d0d10; border: 1px solid #1a1a24; border-radius: 5px; padding: 5px 7px; }
+.det-cell .dv { font-size: 0.8rem; color: #c4b5fd; font-weight: 600; }
+.det-cell .dk { font-size: 0.63rem; color: #444; margin-top: 1px; }
+.gemini-dot { width: 7px; height: 7px; border-radius: 50%; background: #333; display: inline-block; margin-right: 4px; }
+.gemini-dot.on { background: #22c55e; }
+.chat-area { flex: 1; display: flex; flex-direction: column; overflow: hidden; }
+.messages { flex: 1; overflow-y: auto; padding: 24px 32px; display: flex; flex-direction: column; gap: 18px; }
+.welcome { display: flex; flex-direction: column; align-items: center; justify-content: center; height: 100%; gap: 10px; }
+.welcome h2 { font-size: 1.6rem; color: #a78bfa; font-weight: 700; }
+.welcome p { color: #444; font-size: 0.9rem; }
+.msg { max-width: 800px; }
+.msg.user { align-self: flex-end; }
+.msg.assistant { align-self: flex-start; width: 100%; max-width: 800px; }
+.msg-bubble { padding: 11px 15px; border-radius: 10px; font-size: 0.88rem; line-height: 1.65; white-space: pre-wrap; word-wrap: break-word; }
+.msg.user .msg-bubble { background: #1a1628; border: 1px solid #4c1d95; color: #e2e8f0; max-width: 600px; }
+.msg.assistant .msg-bubble { background: #111116; border: 1px solid #1e1e2a; color: #ddd; }
+.think-block { background: #080d14; border: 1px solid #1e2f4a; border-radius: 8px; padding: 10px 14px; margin-bottom: 8px; }
+.think-header { display: flex; align-items: center; gap: 6px; cursor: pointer; user-select: none; margin-bottom: 5px; }
+.think-header .th-label { font-size: 0.72rem; color: #374151; text-transform: uppercase; letter-spacing: 0.5px; }
+.think-badge { font-size: 0.63rem; background: #0d1f36; border: 1px solid #1e3a5f; color: #3b82f6; padding: 1px 6px; border-radius: 20px; }
+.think-toggle { margin-left: auto; font-size: 0.68rem; color: #374151; }
+.think-content { font-size: 0.78rem; color: #4b5563; white-space: pre-wrap; line-height: 1.5; overflow: hidden; transition: max-height 0.3s ease; }
+.think-content.collapsed { max-height: 0 !important; }
+.ctx-row { padding: 4px 20px 0; display: none; }
+.ctx-badge { display: inline-flex; align-items: center; gap: 4px; background: #0d1f36; border: 1px solid #1e3a5f; border-radius: 20px; padding: 3px 10px; font-size: 0.7rem; color: #3b82f6; }
+.ctx-badge button { background: none; border: none; color: #3b82f6; cursor: pointer; font-size: 0.8rem; padding: 0 0 0 4px; line-height: 1; }
+.search-panel { border-top: 1px solid #1e1e2a; background: #0d0d10; padding: 8px 16px; display: none; align-items: center; gap: 8px; }
+.search-panel.open { display: flex; }
+.search-input { flex: 1; background: #16161f; border: 1px solid #252535; color: #ddd; border-radius: 6px; padding: 7px 12px; font-size: 0.82rem; font-family: inherit; }
+.search-input:focus { outline: none; border-color: #3b82f6; }
+.search-results { background: #0d0d10; border-top: 1px solid #1a1a24; padding: 0 16px; display: none; max-height: 200px; overflow-y: auto; }
+.search-results.open { display: block; padding: 8px 16px; }
+.sr-item { background: #111116; border: 1px solid #1e1e2a; border-radius: 6px; padding: 8px 11px; margin-bottom: 6px; }
+.sr-item .sr-title { font-size: 0.8rem; color: #93c5fd; font-weight: 500; }
+.sr-item .sr-snip { font-size: 0.73rem; color: #555; margin-top: 2px; line-height: 1.4; }
+.sr-item .sr-url { font-size: 0.67rem; color: #374151; margin-top: 2px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.sr-item .sr-actions { display: flex; gap: 5px; margin-top: 6px; }
+.sr-btn { font-size: 0.68rem; padding: 3px 8px; border-radius: 4px; border: 1px solid #252535; background: #16161f; color: #666; cursor: pointer; }
+.sr-btn:hover { border-color: #3b82f6; color: #3b82f6; }
+.sr-msg { font-size: 0.75rem; color: #555; padding: 6px 0; }
+.bottom-bar { border-top: 1px solid #1e1e2a; background: #111116; padding: 10px 20px; flex-shrink: 0; }
+.mode-row { display: flex; align-items: center; gap: 5px; margin-bottom: 8px; flex-wrap: wrap; }
+.mode-btn { background: #16161f; border: 1px solid #252535; color: #666; padding: 5px 13px; border-radius: 6px; cursor: pointer; font-size: 0.78rem; }
+.mode-btn.active { background: #1a1628; border-color: #a78bfa; color: #a78bfa; }
+.mode-btn.deep.active { background: #0d1f36; border-color: #3b82f6; color: #3b82f6; }
+.mode-btn:hover:not(.active) { border-color: #444; color: #aaa; }
+.tool-btn { background: #16161f; border: 1px solid #252535; color: #666; padding: 5px 11px; border-radius: 6px; cursor: pointer; font-size: 0.78rem; margin-left: auto; display: flex; align-items: center; gap: 4px; }
+.tool-btn:hover { border-color: #555; color: #aaa; }
+.tool-btn.active { border-color: #3b82f6; color: #3b82f6; background: #0d1f36; }
+.input-row { display: flex; gap: 8px; align-items: flex-end; }
+.msg-input { flex: 1; background: #16161f; border: 1px solid #252535; color: #ddd; border-radius: 8px; padding: 10px 14px; font-size: 0.88rem; resize: none; max-height: 120px; font-family: inherit; line-height: 1.4; }
+.msg-input:focus { outline: none; border-color: #7c3aed; }
+.send-btn { background: #7c3aed; color: white; border: none; border-radius: 8px; padding: 10px 18px; cursor: pointer; font-size: 0.88rem; font-weight: 500; height: 42px; }
+.send-btn:hover { background: #6d28d9; }
+.send-btn:disabled { background: #252535; color: #555; cursor: not-allowed; }
+::-webkit-scrollbar { width: 5px; }
+::-webkit-scrollbar-thumb { background: #2a2a3a; border-radius: 3px; }
+</style>
+</head>
+<body>
+<header>
+  <div class="logo">
+    <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polygon points="12 2 22 8.5 22 15.5 12 22 2 15.5 2 8.5 12 2"/></svg>
+    ExocoreV1
+  </div>
+  <nav><a href="/">Chat</a><a href="/train">Train</a></nav>
+</header>
+
+<div class="main">
+  <!-- SIDEBAR -->
+  <div class="sidebar">
+    <div>
+      <div class="section-label">Models</div>
+      <div id="modelList"><p style="color:#333;font-size:0.75rem;">Loading…</p></div>
+    </div>
+    <div>
+      <div class="section-label">Status</div>
+      <div class="status-pill"><span class="dot loading" id="statusDot"></span><span id="statusText">Auto-loading…</span></div>
+    </div>
+    <div id="loadBtnWrap" style="display:none;">
+      <button class="btn btn-p" id="loadBtn" onclick="loadSelectedModel()">Load Selected Model</button>
+    </div>
+
+    <div>
+      <div class="section-label">Parameters</div>
+      <div class="param-row"><label>Max Tokens</label><input type="number" id="maxTokens" value="512" min="64" max="4096"></div>
+      <div class="param-row"><label>Temperature</label><input type="number" id="temperature" value="0.7" step="0.05" min="0.1" max="2"></div>
+    </div>
+
+    <div id="detailsSection" style="display:none;">
+      <div class="section-label">Model Details</div>
+      <div class="details-grid" id="detailsGrid"></div>
+    </div>
+
+    <div>
+      <div class="section-label">Gemini</div>
+      <div class="param-row" style="margin-bottom:0;">
+        <span style="font-size:0.75rem;color:#555;"><span class="gemini-dot" id="geminiDot"></span><span id="geminiStatus">Not initialized</span></span>
+        <button onclick="initGemini()" style="background:#16161f;border:1px solid #252535;color:#666;padding:3px 9px;font-size:0.72rem;border-radius:5px;cursor:pointer;">Init</button>
+      </div>
+    </div>
+  </div>
+
+  <!-- CHAT -->
+  <div class="chat-area">
+    <div class="messages" id="messages">
+      <div class="welcome" id="welcome">
+        <h2>ExocoreV1</h2>
+        <p id="welcomeSub">Auto-loading model…</p>
+      </div>
+    </div>
+
+    <div class="ctx-row" id="ctxRow">
+      <span class="ctx-badge">
+        <svg width="10" height="10" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><circle cx="11" cy="11" r="8"/><path d="M21 21l-4.35-4.35"/></svg>
+        <span id="ctxLabel">Research context active</span>
+        <button onclick="clearContext()">×</button>
+      </span>
+    </div>
+
+    <div class="search-panel" id="searchPanel">
+      <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="#3b82f6" stroke-width="2"><circle cx="11" cy="11" r="8"/><path d="M21 21l-4.35-4.35"/></svg>
+      <input type="text" class="search-input" id="searchInput" placeholder="Search the web for research…" onkeydown="if(event.key==='Enter')runSearch()">
+      <button onclick="runSearch()" style="background:#1e3a5f;border:1px solid #1e4a7f;color:#93c5fd;padding:6px 12px;border-radius:6px;font-size:0.78rem;cursor:pointer;">Search</button>
+      <button onclick="closeSearch()" style="background:#16161f;border:1px solid #252535;color:#555;padding:6px 10px;border-radius:6px;font-size:0.78rem;cursor:pointer;">✕</button>
+    </div>
+    <div class="search-results" id="searchResults"></div>
+
+    <div class="bottom-bar">
+      <div class="mode-row">
+        <button class="mode-btn active" id="mFast"  onclick="setMode('fast')">Fast</button>
+        <button class="mode-btn"        id="mThink" onclick="setMode('thinking')">Thinking</button>
+        <button class="mode-btn deep"   id="mDeep"  onclick="setMode('deep')">Deep Think</button>
+        <button class="mode-btn"        onclick="clearChat()">Clear Chat</button>
+        <button class="tool-btn" id="researchBtn" onclick="toggleSearch()">
+          <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><path d="M21 21l-4.35-4.35"/></svg>
+          Research
+        </button>
+      </div>
+      <div class="input-row">
+        <textarea class="msg-input" id="msgInput" rows="1"
+          placeholder="Type a message… (Enter to send, Shift+Enter for newline)"
+          onkeydown="handleKey(event)" oninput="autoResize(this)"></textarea>
+        <button class="send-btn" id="sendBtn" onclick="sendMessage()">Send</button>
+      </div>
+    </div>
+  </div>
+</div>
+
+<script>
+let selectedModel = null;
+let currentMode   = 'fast';
+let searchContext = null;
+let isGenerating  = false;
+let loadedModel   = null;
+
+function escHtml(s) {
+  return String(s||'').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+}
+function autoResize(el) {
+  el.style.height = 'auto';
+  el.style.height = Math.min(el.scrollHeight, 120) + 'px';
+}
+function handleKey(e) {
+  if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); sendMessage(); }
+}
+
+function setMode(m) {
+  currentMode = m;
+  document.getElementById('mFast').classList.toggle('active',  m === 'fast');
+  document.getElementById('mThink').classList.toggle('active', m === 'thinking');
+  document.getElementById('mDeep').classList.toggle('active',  m === 'deep');
+}
+
+function toggleSearch() {
+  const p = document.getElementById('searchPanel');
+  const b = document.getElementById('researchBtn');
+  const open = p.classList.contains('open');
+  if (open) { closeSearch(); }
+  else { p.classList.add('open'); b.classList.add('active'); document.getElementById('searchInput').focus(); }
+}
+function closeSearch() {
+  document.getElementById('searchPanel').classList.remove('open');
+  document.getElementById('searchResults').classList.remove('open');
+  document.getElementById('researchBtn').classList.remove('active');
+}
+function clearContext() {
+  searchContext = null;
+  document.getElementById('ctxRow').style.display = 'none';
+}
+function setContext(text) {
+  if (searchContext) searchContext += '\n\n' + text;
+  else searchContext = text;
+  document.getElementById('ctxRow').style.display = 'block';
+  document.getElementById('ctxLabel').textContent = 'Research context (' + searchContext.length + ' chars)';
+}
+
+async function runSearch() {
+  const q = document.getElementById('searchInput').value.trim();
+  if (!q) return;
+  const sr = document.getElementById('searchResults');
+  sr.innerHTML = '<div class="sr-msg">Searching…</div>';
+  sr.classList.add('open');
+  try {
+    const r = await fetch('/api/search', {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({ query: q })
+    });
+    const d = await r.json();
+    if (d.error) { sr.innerHTML = `<div class="sr-msg" style="color:#ef4444;">Error: ${escHtml(d.error)}</div>`; return; }
+    if (!d.results || !d.results.length) { sr.innerHTML = '<div class="sr-msg">No results found.</div>'; return; }
+    sr.innerHTML = '';
+    d.results.forEach(res => {
+      const el = document.createElement('div');
+      el.className = 'sr-item';
+      el.innerHTML = `
+        <div class="sr-title">${escHtml(res.title)}</div>
+        <div class="sr-snip">${escHtml(res.snippet)}</div>
+        <div class="sr-url">${escHtml(res.url)}</div>
+        <div class="sr-actions">
+          <button class="sr-btn" onclick="addResultToCtx(${JSON.stringify(JSON.stringify(res))})">+ Context</button>
+          ${res.url ? `<button class="sr-btn" onclick="readLink(${JSON.stringify(res.url)})">Read Page</button>` : ''}
+          ${res.url ? `<button class="sr-btn" onclick="readMultiLinks(${JSON.stringify([res.url])})">Read + Chat</button>` : ''}
+        </div>`;
+      sr.appendChild(el);
+    });
+  } catch(e) { sr.innerHTML = `<div class="sr-msg" style="color:#ef4444;">Error: ${escHtml(e.message)}</div>`; }
+}
+
+function addResultToCtx(encoded) {
+  const res = JSON.parse(encoded);
+  setContext(`[${res.title}] ${res.snippet} — ${res.url}`);
+}
+
+async function readLink(url) {
+  const sr = document.getElementById('searchResults');
+  const msg = document.createElement('div');
+  msg.className = 'sr-msg';
+  msg.textContent = 'Reading ' + url + '…';
+  sr.insertBefore(msg, sr.firstChild);
+  try {
+    const r = await fetch('/api/read-link', {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({ url })
+    });
+    const d = await r.json();
+    msg.remove();
+    if (d.pages && d.pages[0] && !d.pages[0].error) {
+      const pg = d.pages[0];
+      setContext(`[${pg.title || url}]\n${pg.text}`);
+    } else {
+      alert('Read error: ' + (d.pages?.[0]?.error || 'Unknown'));
+    }
+  } catch(e) { msg.remove(); alert('Error: ' + e.message); }
+}
+
+async function readMultiLinks(urls) {
+  const sr = document.getElementById('searchResults');
+  const msg = document.createElement('div');
+  msg.className = 'sr-msg';
+  msg.textContent = 'Reading ' + urls.length + ' page(s)…';
+  sr.insertBefore(msg, sr.firstChild);
+  try {
+    const r = await fetch('/api/read-link', {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({ urls })
+    });
+    const d = await r.json();
+    msg.remove();
+    if (d.pages) {
+      d.pages.forEach(pg => {
+        if (!pg.error) setContext(`[${pg.title || pg.url}]\n${pg.text}`);
+      });
+    }
+  } catch(e) { msg.remove(); alert('Error: ' + e.message); }
+}
+
+async function loadModels() {
+  try {
+    const r = await fetch('/api/models');
+    const d = await r.json();
+    const list = document.getElementById('modelList');
+    list.innerHTML = '';
+    if (!d.models || !d.models.length) {
+      list.innerHTML = '<p style="color:#333;font-size:0.75rem;">No models found.</p>';
+      return;
+    }
+    d.models.forEach(m => {
+      const name = m.name || m;
+      const type = m.type || 'pt';
+      const isProt = name.toLowerCase() === 'exocore.pt';
+      const div = document.createElement('div');
+      div.className = 'model-card' + (selectedModel === name ? ' selected' : '');
+      div.onclick = () => selectModel(name, type);
+      div.innerHTML = `<div class="mn">${escHtml(name)}${isProt ? '<span class="pb">Protected</span>' : ''}</div>
+        <div class="mt">${type === 'exocore' ? 'ExocoreV1' : type}</div>`;
+      list.appendChild(div);
+    });
+  } catch(e) {}
+}
+
+function selectModel(name) {
+  selectedModel = name;
+  document.querySelectorAll('.model-card').forEach(el => {
+    const nm = el.querySelector('.mn').childNodes[0].nodeValue.trim();
+    el.classList.toggle('selected', nm === name);
+  });
+  document.getElementById('loadBtnWrap').style.display = '';
+}
+
+async function loadSelectedModel() {
+  if (!selectedModel) return;
+  const btn = document.getElementById('loadBtn');
+  btn.disabled = true; btn.textContent = 'Loading…';
+  try {
+    const r = await fetch('/api/load', {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({ model: selectedModel, type: 'exocore' })
+    });
+    const d = await r.json();
+    if (d.error) alert(d.error);
+    else { loadedModel = selectedModel; updateStatusReady('ExocoreV1'); loadModelDetails(); }
+  } catch(e) { alert(e.message); }
+  btn.disabled = false; btn.textContent = 'Load Selected Model';
+}
+
+function updateStatusReady(name) {
+  document.getElementById('statusDot').className   = 'dot ready';
+  document.getElementById('statusText').textContent = name || 'Ready';
+  const w = document.getElementById('welcome');
+  if (w) { w.innerHTML = '<h2 style="color:#a78bfa;">ExocoreV1</h2><p style="color:#555;">Model loaded · Start chatting</p>'; }
+}
+
+async function loadModelDetails() {
+  try {
+    const r = await fetch('/api/model-details');
+    const d = await r.json();
+    if (d.error || d.loading) return;
+    document.getElementById('detailsSection').style.display = '';
+    const cells = [
+      { v: (d.params_m||0)+'M', k:'Parameters' },
+      { v: d.num_layers||d.n_layer||'—', k:'Layers' },
+      { v: d.hidden_size||d.n_embd||'—', k:'Hidden' },
+      { v: d.num_heads||'—', k:'Attn Heads' },
+      { v: d.num_kv_heads||'—', k:'KV Heads' },
+      { v: d.vocab_size ? Math.round(d.vocab_size/1000)+'K' : '—', k:'Vocab' },
+    ];
+    document.getElementById('detailsGrid').innerHTML = cells.map(c =>
+      `<div class="det-cell"><div class="dv">${c.v}</div><div class="dk">${c.k}</div></div>`).join('');
+  } catch(e) {}
+}
+
+async function checkAutoLoad() {
+  try {
+    const r = await fetch('/api/autoload-status');
+    const d = await r.json();
+    if (d.loading) {
+      document.getElementById('statusDot').className    = 'dot loading';
+      document.getElementById('statusText').textContent = 'Loading ExocoreV1…';
+      document.getElementById('welcomeSub').textContent = 'ExocoreV1 is loading, please wait…';
+      setTimeout(checkAutoLoad, 2000);
+    } else if (d.done && d.model) {
+      loadedModel = d.model;
+      updateStatusReady('ExocoreV1');
+      loadModelDetails();
+    } else if (d.error) {
+      document.getElementById('statusDot').className    = 'dot off';
+      document.getElementById('statusText').textContent = 'Load failed';
+      document.getElementById('welcomeSub').textContent = 'Select and load a model from the sidebar.';
+    } else {
+      document.getElementById('statusDot').className    = 'dot off';
+      document.getElementById('statusText').textContent = 'No model loaded';
+      document.getElementById('welcomeSub').textContent = 'Select and load a model from the sidebar.';
+    }
+  } catch(e) { setTimeout(checkAutoLoad, 3000); }
+}
+
+function toggleThink(header) {
+  const content = header.nextElementSibling;
+  const collapsed = content.classList.toggle('collapsed');
+  header.querySelector('.think-toggle').textContent = collapsed ? '▶' : '▼';
+}
+
+function appendThinkBlock(parent, thinkText, mode) {
+  const label = mode === 'deep' ? 'Deep Think (Multi-Pass)' : 'Thinking';
+  const tb = document.createElement('div');
+  tb.className = 'think-block';
+  const maxH = Math.min(thinkText.length * 0.5, 300) + 'px';
+  tb.innerHTML = `<div class="think-header" onclick="toggleThink(this)">
+    <span class="th-label">${label}</span>
+    <span class="think-badge">⟳ Exocore reasoning</span>
+    <span class="think-toggle" style="margin-left:auto;">▼</span>
+  </div>
+  <div class="think-content" style="max-height:${maxH};">
+    <div style="color:#4b5563;white-space:pre-wrap;">${escHtml(thinkText)}</div>
+  </div>`;
+  parent.appendChild(tb);
+}
+
+function addUserMessage(text) {
+  const w = document.getElementById('welcome');
+  if (w) w.remove();
+  const div = document.createElement('div');
+  div.className = 'msg user';
+  div.innerHTML = `<div class="msg-bubble">${escHtml(text)}</div>`;
+  document.getElementById('messages').appendChild(div);
+  div.scrollIntoView({ behavior:'smooth', block:'end' });
+}
+
+function addAssistantMessage() {
+  const div = document.createElement('div');
+  div.className = 'msg assistant';
+  const bubble = document.createElement('div');
+  bubble.className = 'msg-bubble';
+  div.appendChild(bubble);
+  document.getElementById('messages').appendChild(div);
+  div.scrollIntoView({ behavior:'smooth', block:'end' });
+  return { container: div, bubble };
+}
+
+async function sendMessage() {
+  if (isGenerating) return;
+  const input = document.getElementById('msgInput');
+  const text  = input.value.trim();
+  if (!text) return;
+
+  isGenerating = true;
+  document.getElementById('sendBtn').disabled = true;
+  input.value = ''; input.style.height = 'auto';
+
+  addUserMessage(text);
+  const { container, bubble } = addAssistantMessage();
+  bubble.textContent = '…';
+
+  let fullText   = '';
+  let thinkShown = false;
+
+  try {
+    const resp = await fetch('/api/chat', {
+      method:'POST', headers:{'Content-Type':'application/json'},
+      body: JSON.stringify({
+        message:        text,
+        max_tokens:     parseInt(document.getElementById('maxTokens').value),
+        temperature:    parseFloat(document.getElementById('temperature').value),
+        mode:           currentMode,
+        search_context: searchContext,
+      })
+    });
+
+    if (!resp.ok) {
+      const err = await resp.json().catch(()=>({}));
+      bubble.textContent = 'Error: ' + (err.error || resp.statusText);
+      return;
+    }
+
+    bubble.textContent = '';
+    const reader = resp.body.getReader();
+    const dec    = new TextDecoder();
+    let   buf    = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += dec.decode(value, { stream: true });
+      const lines = buf.split('\n\n');
+      buf = lines.pop();
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        try {
+          const obj = JSON.parse(line.slice(6));
+          if (obj.error) { bubble.textContent = 'Error: ' + obj.error; break; }
+          if (obj.think_block && !thinkShown) {
+            thinkShown = true;
+            appendThinkBlock(container, obj.think_block, currentMode);
+          }
+          if (obj.token) {
+            fullText += obj.token;
+            bubble.textContent = fullText;
+            bubble.scrollIntoView({ behavior:'smooth', block:'end' });
+          }
+        } catch(e) {}
+      }
+    }
+    if (!fullText && !thinkShown) bubble.textContent = '(no response)';
+    if (searchContext) clearContext();
+  } catch(e) {
+    bubble.textContent = 'Error: ' + e.message;
+  } finally {
+    isGenerating = false;
+    document.getElementById('sendBtn').disabled = false;
+  }
+}
+
+async function clearChat() {
+  await fetch('/api/clear', { method:'POST' });
+  document.getElementById('messages').innerHTML =
+    `<div class="welcome" id="welcome"><h2 style="color:#a78bfa;">ExocoreV1</h2><p style="color:#555;">Chat cleared.</p></div>`;
+  clearContext();
+}
+
+async function initGemini() {
+  const r = await fetch('/api/gemini/init', { method:'POST', headers:{'Content-Type':'application/json'}, body:'{}' });
+  const d = await r.json();
+  if (d.success) {
+    document.getElementById('geminiDot').className    = 'gemini-dot on';
+    document.getElementById('geminiStatus').textContent = 'Ready';
+  } else {
+    document.getElementById('geminiStatus').textContent = d.error || 'Failed';
+  }
+}
+
+async function checkGemini() {
+  try {
+    const r = await fetch('/api/gemini/status');
+    const d = await r.json();
+    if (d.initialized) {
+      document.getElementById('geminiDot').className    = 'gemini-dot on';
+      document.getElementById('geminiStatus').textContent = 'Ready';
+    }
+  } catch(e) {}
+}
+
+loadModels();
+checkAutoLoad();
+checkGemini();
+</script>
+</body>
+</html>

templates/train.html

@@ -0,0 +1,401 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>ExocoreV1 — Train</title>
+<script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.min.js"></script>
+<style>
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body { font-family: 'Segoe UI', sans-serif; background: #0d0d0f; color: #e0e0e0; height: 100vh; display: flex; flex-direction: column; overflow: hidden; }
+header { background: #111116; border-bottom: 1px solid #222; padding: 10px 20px; display: flex; align-items: center; justify-content: space-between; flex-shrink: 0; }
+header h1 { font-size: 1.1rem; color: #a78bfa; font-weight: 700; letter-spacing: 1px; }
+header nav a { color: #888; text-decoration: none; margin-left: 14px; font-size: 0.85rem; }
+header nav a:hover { color: #a78bfa; }
+.layout { display: flex; flex: 1; overflow: hidden; }
+.left  { flex: 1; overflow-y: auto; padding: 16px; display: flex; flex-direction: column; gap: 12px; }
+.right { width: 360px; border-left: 1px solid #1e1e2a; overflow-y: auto; padding: 16px; display: flex; flex-direction: column; gap: 12px; }
+.card { background: #111116; border: 1px solid #1e1e2a; border-radius: 10px; padding: 14px; }
+.card h3 { font-size: 0.82rem; color: #c4b5fd; font-weight: 600; margin-bottom: 11px; text-transform: uppercase; letter-spacing: 0.5px; }
+.tabs { display: flex; gap: 4px; margin-bottom: 14px; }
+.tab { background: #16161f; border: 1px solid #252535; color: #666; padding: 6px 14px; border-radius: 6px; cursor: pointer; font-size: 0.8rem; }
+.tab.active { background: #1a1628; border-color: #a78bfa; color: #a78bfa; }
+.fr { display: flex; flex-direction: column; gap: 3px; margin-bottom: 9px; }
+.fr label { font-size: 0.7rem; color: #555; }
+.fr input, .fr textarea, .fr select { background: #16161f; border: 1px solid #252535; color: #ddd; border-radius: 5px; padding: 7px 10px; font-size: 0.82rem; width: 100%; font-family: inherit; }
+.fr input:focus, .fr textarea:focus { outline: none; border-color: #7c3aed; }
+.grid2 { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; }
+.btn { border: none; border-radius: 6px; padding: 8px 16px; cursor: pointer; font-size: 0.82rem; font-weight: 500; }
+.btn-p { background: #7c3aed; color: white; }
+.btn-p:hover { background: #6d28d9; }
+.btn-p:disabled { background: #252535; color: #555; cursor: not-allowed; }
+.btn-d { background: #4a1010; color: #fca5a5; }
+.btn-d:hover { background: #5f1414; }
+.btn-s { background: #16161f; border: 1px solid #252535; color: #888; }
+.btn-s:hover { border-color: #a78bfa; color: #a78bfa; }
+.btn-sm { padding: 4px 10px; font-size: 0.75rem; }
+.progress-track { background: #16161f; border-radius: 20px; height: 6px; margin: 7px 0; overflow: hidden; }
+.progress-fill  { background: linear-gradient(90deg, #7c3aed, #a78bfa); height: 100%; border-radius: 20px; transition: width 0.3s; }
+.log-box { background: #080810; border: 1px solid #1a1a24; border-radius: 5px; padding: 8px; font-family: monospace; font-size: 0.73rem; color: #666; max-height: 130px; overflow-y: auto; white-space: pre-wrap; }
+.stat-row { display: flex; align-items: center; gap: 7px; font-size: 0.78rem; color: #666; margin-bottom: 7px; }
+.dot { width: 7px; height: 7px; border-radius: 50%; background: #333; flex-shrink: 0; }
+.dot.running { background: #22c55e; animation: pulse 1s infinite; }
+.dot.done    { background: #22c55e; }
+.dot.error   { background: #ef4444; }
+@keyframes pulse { 0%,100%{opacity:1}50%{opacity:.4} }
+.mcard { background: #16161f; border: 1px solid #252535; border-radius: 7px; padding: 9px 12px; margin-bottom: 6px; display: flex; align-items: center; justify-content: space-between; }
+.mcard .mn { font-size: 0.83rem; color: #ddd; font-weight: 500; }
+.mcard .mt { font-size: 0.7rem; color: #555; margin-top: 2px; }
+.pb { font-size: 0.68rem; padding: 2px 7px; border-radius: 20px; background: #1a1628; border: 1px solid #4c1d95; color: #a78bfa; margin-left: 5px; }
+.chart-wrap { position: relative; height: 220px; margin-top: 8px; }
+.arch-tree { font-size: 0.78rem; }
+.arch-node { margin: 3px 0; display: flex; align-items: center; gap: 6px; }
+.arch-node .label { background: #16161f; border: 1px solid #252535; border-radius: 5px; padding: 4px 10px; font-size: 0.75rem; color: #c4b5fd; flex: 1; }
+.arch-node.block .label { border-color: #4c1d95; background: #1a1628; }
+.arch-node.sub .label { border-color: #1e3a5f; background: #111820; color: #93c5fd; margin-left: 20px; font-size: 0.72rem; }
+.arch-node.head-node .label { border-color: #134e2a; background: #0d1f16; color: #86efac; }
+.arch-line { color: #333; font-size: 0.65rem; margin-left: 8px; }
+::-webkit-scrollbar { width: 5px; } ::-webkit-scrollbar-thumb { background: #2a2a3a; border-radius: 3px; }
+</style>
+</head>
+<body>
+<header>
+  <h1>⬡ ExocoreV1</h1>
+  <nav><a href="/">Chat</a><a href="/train">Train</a></nav>
+</header>
+<div class="layout">
+  <!-- LEFT PANEL -->
+  <div class="left">
+    <div class="tabs">
+      <div class="tab active" onclick="showTab('train')">Train</div>
+      <div class="tab"        onclick="showTab('auto')">Auto-Train (Gemini)</div>
+    </div>
+
+    <!-- TRAIN TAB -->
+    <div id="tab-train">
+      <div class="card">
+        <h3>Training Data</h3>
+        <div class="fr">
+          <label>Training Text</label>
+          <textarea id="trainText" rows="7" placeholder="Paste training text here (min 100 chars)…"></textarea>
+        </div>
+        <div style="display:flex;align-items:center;gap:8px;">
+          <button class="btn btn-s btn-sm" onclick="loadTrainTxt()">Load train.txt</button>
+          <span id="charCount" style="font-size:0.73rem;color:#555;"></span>
+        </div>
+      </div>
+
+      <div class="card">
+        <h3>Model Configuration</h3>
+        <div class="fr"><label>Model Name</label><input type="text" id="modelName" value="Exocore"></div>
+        <div class="grid2">
+          <div class="fr"><label>Epochs</label><input type="number" id="epochs" value="60" min="1"></div>
+          <div class="fr"><label>Embedding Dim</label><input type="number" id="nEmbd" value="384" min="64"></div>
+          <div class="fr"><label>Layers</label><input type="number" id="nLayer" value="6" min="1"></div>
+          <div class="fr"><label>Block Size</label><input type="number" id="blockSize" value="256" min="32"></div>
+          <div class="fr"><label>Batch Size</label><input type="number" id="batchSize" value="16" min="1"></div>
+          <div class="fr"><label>Learning Rate</label><input type="number" id="lr" value="0.0002" step="0.00001"></div>
+        </div>
+        <div style="display:flex;gap:8px;">
+          <button class="btn btn-p" id="trainBtn" onclick="startTraining()">Start Training</button>
+          <button class="btn btn-d" id="stopBtn" onclick="stopTraining()" style="display:none;">Stop</button>
+        </div>
+      </div>
+
+      <div class="card" id="trainStatusCard" style="display:none;">
+        <h3>Training Progress</h3>
+        <div class="stat-row">
+          <span class="dot" id="tDot"></span>
+          <span id="tStatus">Idle</span>
+          <span id="tEpoch" style="margin-left:auto;color:#555;font-size:0.73rem;"></span>
+          <span id="tLoss"  style="color:#a78bfa;font-size:0.73rem;margin-left:8px;"></span>
+        </div>
+        <div class="progress-track"><div class="progress-fill" id="tProg" style="width:0%"></div></div>
+        <div class="chart-wrap"><canvas id="lossChart"></canvas></div>
+        <div class="log-box" id="tLog"></div>
+      </div>
+    </div>
+
+    <!-- AUTO TRAIN TAB -->
+    <div id="tab-auto" style="display:none;">
+      <div class="card">
+        <h3>Gemini Auto-Train</h3>
+        <p style="font-size:0.78rem;color:#555;margin-bottom:10px;">Gemini generates training data automatically, then ExocoreV1 trains on it.</p>
+        <div class="fr"><label>Initial Prompt</label><textarea id="autoPrompt" rows="3" placeholder="e.g. Explain quantum computing in detail."></textarea></div>
+        <div class="fr"><label>Continue Message</label><input type="text" id="autoContinue" value="ok next train"></div>
+        <div class="fr"><label>Model Name</label><input type="text" id="autoModel" value="Exocore"></div>
+        <div style="display:flex;gap:8px;">
+          <button class="btn btn-p" id="autoStartBtn" onclick="startAuto()">Start</button>
+          <button class="btn btn-d" id="autoStopBtn"  onclick="stopAuto()"  style="display:none;">Stop</button>
+        </div>
+      </div>
+      <div class="card" id="autoStatusCard" style="display:none;">
+        <h3>Auto-Train Status</h3>
+        <div class="stat-row"><span class="dot" id="aDot"></span><span id="aStatus">Idle</span></div>
+        <div class="log-box" id="aLog"></div>
+      </div>
+    </div>
+  </div>
+
+  <!-- RIGHT PANEL -->
+  <div class="right">
+    <!-- ARCHITECTURE TREE -->
+    <div class="card">
+      <h3>ExocoreV1 Architecture</h3>
+      <div class="arch-tree">
+        <div class="arch-node"><div class="label" style="text-align:center;color:#f59e0b;border-color:#78350f;background:#1c1208;">Input Tokens</div></div>
+        <div style="text-align:center;color:#333;font-size:0.7rem;">↓</div>
+        <div class="arch-node"><div class="label">Token Embedding <span style="color:#555;">151,936 → 1024</span></div></div>
+        <div style="text-align:center;color:#333;font-size:0.7rem;">↓ ×28 Transformer Blocks</div>
+
+        <div class="arch-node block">
+          <div class="label">Transformer Block (×28)</div>
+        </div>
+        <div class="arch-node sub"><div class="label">Input LayerNorm <span style="color:#555;">[1024]</span></div></div>
+        <div class="arch-node sub"><div class="label">GQA Attention <span style="color:#555;">16Q / 8KV heads · dim 128</span></div></div>
+        <div class="arch-node sub" style="margin-left:38px;"><div class="label" style="font-size:0.68rem;color:#6b7280;">Q proj 1024→2048 · K,V 1024→1024 · O 2048→1024</div></div>
+        <div class="arch-node sub" style="margin-left:38px;"><div class="label" style="font-size:0.68rem;color:#6b7280;">Q-Norm & K-Norm (RMSNorm per head)</div></div>
+        <div class="arch-node sub" style="margin-left:38px;"><div class="label" style="font-size:0.68rem;color:#6b7280;">RoPE · θ=1,000,000 · max 40,960 tokens</div></div>
+        <div class="arch-node sub"><div class="label">Post-Attn LayerNorm <span style="color:#555;">[1024]</span></div></div>
+        <div class="arch-node sub"><div class="label">SwiGLU FFN <span style="color:#555;">1024→3072→1024</span></div></div>
+        <div style="text-align:center;color:#333;font-size:0.7rem;">↓</div>
+
+        <div class="arch-node"><div class="label">Final RMSNorm <span style="color:#555;">[1024]</span></div></div>
+        <div style="text-align:center;color:#333;font-size:0.7rem;">↓</div>
+        <div class="arch-node head-node"><div class="label">Language Model Head <span style="color:#555;">1024 → 151,936</span></div></div>
+        <div style="text-align:center;color:#333;font-size:0.7rem;">↓</div>
+        <div class="arch-node"><div class="label" style="text-align:center;color:#f59e0b;border-color:#78350f;background:#1c1208;">Output Tokens</div></div>
+
+        <div style="margin-top:12px;padding-top:10px;border-top:1px solid #1e1e2a;">
+          <div style="display:grid;grid-template-columns:1fr 1fr;gap:4px;">
+            <div style="background:#16161f;border:1px solid #252535;border-radius:5px;padding:5px 8px;"><div style="font-size:0.82rem;color:#c4b5fd;font-weight:600;">751.6M</div><div style="font-size:0.65rem;color:#555;">Parameters</div></div>
+            <div style="background:#16161f;border:1px solid #252535;border-radius:5px;padding:5px 8px;"><div style="font-size:0.82rem;color:#c4b5fd;font-weight:600;">28</div><div style="font-size:0.65rem;color:#555;">Layers</div></div>
+            <div style="background:#16161f;border:1px solid #252535;border-radius:5px;padding:5px 8px;"><div style="font-size:0.82rem;color:#c4b5fd;font-weight:600;">bfloat16</div><div style="font-size:0.65rem;color:#555;">Precision</div></div>
+            <div style="background:#16161f;border:1px solid #252535;border-radius:5px;padding:5px 8px;"><div style="font-size:0.82rem;color:#c4b5fd;font-weight:600;">40,960</div><div style="font-size:0.65rem;color:#555;">Max Context</div></div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- TRAINED MODELS -->
+    <div class="card">
+      <h3>Trained Models</h3>
+      <div id="modelList"><p style="color:#444;font-size:0.78rem;">Loading…</p></div>
+      <button class="btn btn-s btn-sm" onclick="loadModels()" style="margin-top:8px;">Refresh</button>
+    </div>
+  </div>
+</div>
+
+<script>
+let trainInterval = null;
+let autoInterval  = null;
+let lossChart     = null;
+
+function showTab(name) {
+  ['train','auto'].forEach(t => {
+    document.getElementById('tab-' + t).style.display = t === name ? '' : 'none';
+  });
+  document.querySelectorAll('.tab').forEach((el, i) => {
+    el.classList.toggle('active', ['train','auto'][i] === name);
+  });
+}
+
+async function loadTrainTxt() {
+  const r = await fetch('/api/train/text');
+  const d = await r.json();
+  if (d.found) {
+    document.getElementById('trainText').value = d.text;
+    document.getElementById('charCount').textContent = d.chars.toLocaleString() + ' chars';
+  } else { alert('train.txt not found.'); }
+}
+
+document.getElementById('trainText').addEventListener('input', function() {
+  document.getElementById('charCount').textContent = this.value.length.toLocaleString() + ' chars';
+});
+
+function initChart() {
+  const ctx = document.getElementById('lossChart').getContext('2d');
+  lossChart = new Chart(ctx, {
+    type: 'line',
+    data: {
+      labels: [],
+      datasets: [{
+        label: 'Training Loss',
+        data: [],
+        borderColor: '#a78bfa',
+        backgroundColor: 'rgba(167,139,250,0.08)',
+        borderWidth: 2,
+        pointRadius: 3,
+        pointBackgroundColor: '#a78bfa',
+        tension: 0.3,
+        fill: true,
+      }]
+    },
+    options: {
+      responsive: true, maintainAspectRatio: false,
+      plugins: { legend: { labels: { color: '#888', font: { size: 11 } } } },
+      scales: {
+        x: { grid: { color: '#1a1a24' }, ticks: { color: '#555', font: { size: 10 } }, title: { display: true, text: 'Epoch', color: '#555', font: { size: 10 } } },
+        y: { grid: { color: '#1a1a24' }, ticks: { color: '#555', font: { size: 10 } }, title: { display: true, text: 'Loss', color: '#555', font: { size: 10 } } },
+      },
+      animation: { duration: 200 }
+    }
+  });
+}
+
+function updateChart(history) {
+  if (!lossChart) initChart();
+  lossChart.data.labels   = history.map(h => 'E' + h.epoch);
+  lossChart.data.datasets[0].data = history.map(h => h.loss);
+  lossChart.update('none');
+}
+
+async function startTraining() {
+  const text = document.getElementById('trainText').value;
+  if (text.length < 100) { alert('Need at least 100 characters of training text.'); return; }
+  const config = {
+    epochs: parseInt(document.getElementById('epochs').value),
+    n_embd: parseInt(document.getElementById('nEmbd').value),
+    n_layer: parseInt(document.getElementById('nLayer').value),
+    block_size: parseInt(document.getElementById('blockSize').value),
+    batch_size: parseInt(document.getElementById('batchSize').value),
+    lr: parseFloat(document.getElementById('lr').value),
+  };
+  const model_name = document.getElementById('modelName').value || 'Exocore';
+  const r = await fetch('/api/train/start', {
+    method: 'POST', headers: {'Content-Type':'application/json'},
+    body: JSON.stringify({ text, config, model_name })
+  });
+  const d = await r.json();
+  if (d.error) { alert(d.error); return; }
+  document.getElementById('trainStatusCard').style.display = '';
+  document.getElementById('trainBtn').disabled = true;
+  document.getElementById('stopBtn').style.display = '';
+  if (!lossChart) initChart();
+  lossChart.data.labels = [];
+  lossChart.data.datasets[0].data = [];
+  lossChart.update('none');
+  trainInterval = setInterval(pollTrain, 1500);
+}
+
+async function stopTraining() {
+  await fetch('/api/train/stop', { method: 'POST' });
+}
+
+async function pollTrain() {
+  const r = await fetch('/api/train/status');
+  const d = await r.json();
+  const dot = document.getElementById('tDot');
+  document.getElementById('tStatus').textContent = d.status || (d.running ? 'Training…' : (d.error ? 'Error' : 'Done'));
+  dot.className = 'dot ' + (d.running ? 'running' : (d.error ? 'error' : 'done'));
+  const pct = d.total_epochs > 0 ? (d.epoch / d.total_epochs * 100) : 0;
+  document.getElementById('tProg').style.width = pct + '%';
+  document.getElementById('tEpoch').textContent = d.total_epochs ? `Epoch ${d.epoch}/${d.total_epochs}` : '';
+  document.getElementById('tLoss').textContent  = d.loss ? `Loss: ${d.loss}` : '';
+  if (d.loss_history && d.loss_history.length) updateChart(d.loss_history);
+  if (d.log && d.log.length) {
+    const lb = document.getElementById('tLog');
+    lb.textContent = d.log.slice(-30).join('\n');
+    lb.scrollTop = lb.scrollHeight;
+  }
+  if (!d.running) {
+    clearInterval(trainInterval);
+    document.getElementById('trainBtn').disabled = false;
+    document.getElementById('stopBtn').style.display = 'none';
+    if (d.loss_history) updateChart(d.loss_history);
+    loadModels();
+  }
+}
+
+async function startAuto() {
+  const prompt = document.getElementById('autoPrompt').value.trim();
+  if (!prompt) { alert('Enter an initial prompt.'); return; }
+  const r = await fetch('/api/gemini/autotrain/start', {
+    method: 'POST', headers: {'Content-Type':'application/json'},
+    body: JSON.stringify({
+      initial_prompt: prompt,
+      continue_msg: document.getElementById('autoContinue').value,
+      model_name: document.getElementById('autoModel').value,
+      config: {}
+    })
+  });
+  const d = await r.json();
+  if (d.error) { alert(d.error); return; }
+  document.getElementById('autoStatusCard').style.display = '';
+  document.getElementById('autoStartBtn').disabled = true;
+  document.getElementById('autoStopBtn').style.display = '';
+  autoInterval = setInterval(pollAuto, 2000);
+}
+async function stopAuto() {
+  await fetch('/api/gemini/autotrain/stop', { method: 'POST' });
+}
+async function pollAuto() {
+  const r = await fetch('/api/gemini/autotrain/status');
+  const d = await r.json();
+  document.getElementById('aDot').className    = 'dot ' + (d.running ? 'running' : (d.error ? 'error' : 'done'));
+  document.getElementById('aStatus').textContent = d.status || (d.running ? 'Running…' : 'Done');
+  if (d.log && d.log.length) {
+    const lb = document.getElementById('aLog');
+    lb.textContent = d.log.slice(-20).join('\n');
+    lb.scrollTop = lb.scrollHeight;
+  }
+  if (!d.running) {
+    clearInterval(autoInterval);
+    document.getElementById('autoStartBtn').disabled = false;
+    document.getElementById('autoStopBtn').style.display = 'none';
+    loadModels();
+  }
+}
+
+const PROTECTED = ['exocore.pt'];
+
+async function loadModels() {
+  const r = await fetch('/api/train/models');
+  const d = await r.json();
+  const list = document.getElementById('modelList');
+  if (!d.models || !d.models.length) {
+    list.innerHTML = '<p style="color:#444;font-size:0.78rem;">No trained models yet.</p>';
+    return;
+  }
+  list.innerHTML = '';
+  d.models.forEach(m => {
+    const name = typeof m === 'string' ? m : (m.name || m);
+    const isProt = PROTECTED.includes(name.toLowerCase());
+    const div = document.createElement('div');
+    div.className = 'mcard';
+    div.innerHTML = `
+      <div>
+        <div class="mn">${name}${isProt ? '<span class="pb">Protected</span>' : ''}</div>
+        <div class="mt">ExocoreV1 model</div>
+      </div>
+      <div style="display:flex;gap:5px;">
+        <button class="btn btn-s btn-sm" onclick="viewInfo('${name}')">Info</button>
+        ${isProt ? '' : `<button class="btn btn-d btn-sm" onclick="deleteModel('${name}')">Delete</button>`}
+      </div>`;
+    list.appendChild(div);
+  });
+}
+
+async function viewInfo(name) {
+  const r = await fetch('/api/train/model-info/' + encodeURIComponent(name));
+  const d = await r.json();
+  if (d.error) { alert('Error: ' + d.error); return; }
+  const lines = Object.entries(d).map(([k,v]) => `${k}: ${JSON.stringify(v)}`).join('\n');
+  alert(lines);
+}
+
+async function deleteModel(name) {
+  if (!confirm(`Delete "${name}"?`)) return;
+  const r = await fetch('/api/model/delete', {
+    method: 'POST', headers: {'Content-Type':'application/json'},
+    body: JSON.stringify({ local_name: name })
+  });
+  const d = await r.json();
+  if (d.error) { alert('Error: ' + d.error); }
+  else { loadModels(); }
+}
+
+loadModels();
+</script>
+</body>
+</html>

trainer.py

@@ -171,7 +171,6 @@ def start_training(text, config, model_name):
             itos = {i: c for i, c in enumerate(chars)}
 
             data = torch.tensor([stoi[c] for c in text], dtype=torch.long)
-
             steps_per_epoch = max(1, len(data) // (block_size * batch_size))
             total_steps = steps_per_epoch * epochs
             training_state["total_steps"] = total_steps
@@ -197,7 +196,6 @@ def start_training(text, config, model_name):
                 for step in range(steps_per_epoch):
                     if _stop_flag.is_set():
                         break
-
                     xb, yb = get_batch(data, block_size, batch_size, device)
                     _, loss = model(xb, yb)
                     optimizer.zero_grad()
@@ -205,7 +203,6 @@ def start_training(text, config, model_name):
                     nn.utils.clip_grad_norm_(model.parameters(), 1.0)
                     optimizer.step()
                     scheduler.step()
-
                     global_step += 1
                     epoch_loss += loss.item()
                     training_state["step"] = global_step
@@ -269,459 +266,9 @@ def get_trained_models():
     return results
 
 
-_inference_cache = {}
-
-# ── Qwen3 → Exocore.pt conversion ────────────────────────────────────────────
-
-_convert_state = {
-    "running": False, "step": "", "progress": 0,
-    "done": False, "error": None, "result": None,
-}
-
-
-def get_convert_state():
-    return _convert_state
-
-
-def start_qwen3_conversion(repo_id="Qwen/Qwen3-0.6B", out_name="Exocore"):
-    global _convert_state
-    _convert_state = {
-        "running": True, "step": "Starting...", "progress": 0,
-        "done": False, "error": None, "result": None,
-    }
-
-    def run():
-        import shutil
-        import json as _json
-        save_dir = os.path.join(os.path.dirname(__file__), "models", "trained")
-        hf_dir   = os.path.join(save_dir, "_qwen3_tmp")
-        out_path = os.path.join(save_dir, f"{out_name}.pt")
-
-        try:
-            # ── Step 1: Download ──────────────────────────────────────────────
-            _convert_state["step"] = "Downloading Qwen3-0.6B (model weights ~1.1 GB)..."
-            _convert_state["progress"] = 5
-            from huggingface_hub import snapshot_download
-            os.makedirs(hf_dir, exist_ok=True)
-            snapshot_download(
-                repo_id=repo_id,
-                local_dir=hf_dir,
-                ignore_patterns=["*.bin", "flax_model*", "tf_model*", "rust_model*", "*.gguf"],
-            )
-
-            # ── Step 2: Load tokenizer JSON ───────────────────────────────────
-            _convert_state["step"] = "Loading tokenizer..."
-            _convert_state["progress"] = 40
-            tok_path = os.path.join(hf_dir, "tokenizer.json")
-            tokcfg_path = os.path.join(hf_dir, "tokenizer_config.json")
-            with open(tok_path, "r", encoding="utf-8") as f:
-                tokenizer_json = f.read()
-            with open(tokcfg_path, "r", encoding="utf-8") as f:
-                tokenizer_config_json = f.read()
-
-            # ── Step 3: Load HF config ────────────────────────────────────────
-            _convert_state["step"] = "Reading model config..."
-            _convert_state["progress"] = 45
-            cfg_path = os.path.join(hf_dir, "config.json")
-            with open(cfg_path, "r") as f:
-                hf_cfg = _json.load(f)
-            from qwen3_model import QWEN3_06B_CONFIG
-            model_cfg = {
-                "hidden_size":            hf_cfg.get("hidden_size",            QWEN3_06B_CONFIG["hidden_size"]),
-                "intermediate_size":      hf_cfg.get("intermediate_size",      QWEN3_06B_CONFIG["intermediate_size"]),
-                "num_hidden_layers":      hf_cfg.get("num_hidden_layers",       QWEN3_06B_CONFIG["num_hidden_layers"]),
-                "num_attention_heads":    hf_cfg.get("num_attention_heads",     QWEN3_06B_CONFIG["num_attention_heads"]),
-                "num_key_value_heads":    hf_cfg.get("num_key_value_heads",     QWEN3_06B_CONFIG["num_key_value_heads"]),
-                "head_dim":               hf_cfg.get("head_dim",               QWEN3_06B_CONFIG["head_dim"]),
-                "vocab_size":             hf_cfg.get("vocab_size",             QWEN3_06B_CONFIG["vocab_size"]),
-                "rms_norm_eps":           hf_cfg.get("rms_norm_eps",           QWEN3_06B_CONFIG["rms_norm_eps"]),
-                "rope_theta":             hf_cfg.get("rope_theta",             QWEN3_06B_CONFIG["rope_theta"]),
-                "max_position_embeddings": hf_cfg.get("max_position_embeddings", QWEN3_06B_CONFIG["max_position_embeddings"]),
-            }
-
-            # ── Step 4: Load safetensors weights ─��────────────────────────────
-            _convert_state["step"] = "Loading model weights from safetensors..."
-            _convert_state["progress"] = 50
-            import glob as _glob
-            sf_files = sorted(_glob.glob(os.path.join(hf_dir, "*.safetensors")))
-            if not sf_files:
-                raise FileNotFoundError("No .safetensors file found after download")
-            from safetensors.torch import load_file as sf_load
-            hf_state = {}
-            for sf in sf_files:
-                hf_state.update(sf_load(sf, device="cpu"))
-
-            # ── Step 5: Remap keys ────────────────────────────────────────────
-            _convert_state["step"] = "Remapping weights to Exocore format..."
-            _convert_state["progress"] = 70
-            from qwen3_model import remap_hf_keys
-            exocore_state = remap_hf_keys(hf_state)
-
-            # ── Step 6: Verify weights load into our model ────────────────────
-            _convert_state["step"] = "Verifying model integrity..."
-            _convert_state["progress"] = 80
-            from qwen3_model import Qwen3ForCausalLM
-            model = Qwen3ForCausalLM(model_cfg)
-            missing, unexpected = model.load_state_dict(exocore_state, strict=False)
-            computed_buffers = {"rope_cos", "rope_sin"}
-            real_missing = [k for k in missing if k not in computed_buffers]
-            if real_missing:
-                raise RuntimeError(f"Missing parameter weights: {real_missing[:5]}")
-
-            total_params = sum(p.numel() for p in model.parameters())
-
-            # ── Step 7: Save as Exocore.pt ────────────────────────────────────
-            _convert_state["step"] = f"Saving Exocore.pt ({total_params/1e6:.0f}M params)..."
-            _convert_state["progress"] = 88
-            torch.save({
-                "model_state":        exocore_state,
-                "config":             model_cfg,
-                "tokenizer_json":     tokenizer_json,
-                "tokenizer_config":   tokenizer_config_json,
-                "model_name":         out_name,
-                "exocore_type":       "qwen3",
-                "total_params":       total_params,
-            }, out_path)
-
-            # ── Step 8: Delete HF temp dir ────────────────────────────────────
-            _convert_state["step"] = "Cleaning up HF files..."
-            _convert_state["progress"] = 96
-            shutil.rmtree(hf_dir, ignore_errors=True)
-
-            # Write tiny meta file so is_qwen3_pt() is instant
-            import json as _json2
-            with open(out_path + ".meta", "w") as mf:
-                _json2.dump({"exocore_type": "qwen3", "params": total_params}, mf)
-
-            size_mb = os.path.getsize(out_path) / 1024 / 1024
-            _convert_state["step"]     = f"Done! Saved {out_name}.pt ({size_mb:.0f} MB, {total_params/1e6:.0f}M params)"
-            _convert_state["progress"] = 100
-            _convert_state["done"]     = True
-            _convert_state["running"]  = False
-            _convert_state["result"]   = {"name": f"{out_name}.pt", "size_mb": round(size_mb, 1), "params": total_params}
-
-        except Exception as e:
-            shutil.rmtree(hf_dir, ignore_errors=True)
-            _convert_state["error"]   = str(e)
-            _convert_state["running"] = False
-            _convert_state["done"]    = True
-            _convert_state["step"]    = f"Error: {e}"
-
-    t = threading.Thread(target=run, daemon=True)
-    t.start()
-
-
-# ── Qwen3 inference ───────────────────────────────────────────────────────────
-
-_qwen3_cache = {}
-
-
-def load_qwen3_model(model_name):
-    import gc
-    if model_name in _qwen3_cache:
-        return _qwen3_cache[model_name]
-    save_dir = os.path.join(os.path.dirname(__file__), "models", "trained")
-    path     = os.path.join(save_dir, model_name)
-
-    ckpt = torch.load(path, map_location="cpu", weights_only=False)
-    cfg  = ckpt["config"]
-    tok_json = ckpt["tokenizer_json"]
-
-    # Create model in bfloat16 from the start to avoid float32 → bfloat16 doubling
-    from qwen3_model import Qwen3ForCausalLM
-    _prev_dtype = torch.get_default_dtype()
-    torch.set_default_dtype(torch.bfloat16)
-    try:
-        model = Qwen3ForCausalLM(cfg)
-    finally:
-        torch.set_default_dtype(_prev_dtype)
-
-    model.load_state_dict(ckpt["model_state"], strict=False)
-    del ckpt          # free ~1.5 GB checkpoint from RAM immediately
-    gc.collect()
-
-    model.eval()
-    from tokenizers import Tokenizer
-    tok = Tokenizer.from_str(tok_json)
-    _qwen3_cache[model_name] = {"model": model, "tokenizer": tok, "config": cfg}
-    return _qwen3_cache[model_name]
-
-
-def is_qwen3_pt(model_name):
-    """Return True if this .pt file is a converted Qwen3 model (uses tiny .meta file for speed)."""
-    save_dir  = os.path.join(os.path.dirname(__file__), "models", "trained")
-    meta_path = os.path.join(save_dir, model_name + ".meta")
-    if os.path.exists(meta_path):
-        try:
-            with open(meta_path, "r") as f:
-                meta = json.load(f)
-            return meta.get("exocore_type") == "qwen3"
-        except Exception:
-            pass
-    return False
-
-
-def generate_qwen3_stream(model_name, messages, max_tokens=512, temperature=0.7, think_mode=False):
-    from qwen3_model import build_chat_prompt, IM_END, EOT
-    mc  = load_qwen3_model(model_name)
-    tok = mc["tokenizer"]
-    model = mc["model"]
-
-    prompt = build_chat_prompt(messages, think=think_mode)
-    enc    = tok.encode(prompt)
-    ids    = torch.tensor([enc.ids], dtype=torch.long)
-
-    buf           = ""     # rolling buffer
-    in_think      = False  # currently inside <think>...</think>
-    think_done    = False  # think block already processed
-    think_yielded = False
-
-    with torch.no_grad():
-        for _ in range(max_tokens):
-            ctx     = ids[:, -min(ids.shape[1], mc["config"]["max_position_embeddings"]):]
-            logits, _ = model(ctx)
-            logits  = logits[:, -1, :] / max(temperature, 1e-5)
-            v, _    = torch.topk(logits, min(50, logits.size(-1)))
-            logits[logits < v[:, [-1]]] = float("-inf")
-            probs   = torch.softmax(logits, dim=-1)
-            nxt     = torch.multinomial(probs, 1)
-            tok_id  = nxt.item()
-            ids     = torch.cat([ids, nxt], dim=1)
-
-            if tok_id in (IM_END, EOT):
-                break
-
-            buf += tok.decode([tok_id])
-
-            # Detect opening <think>
-            if not think_done and not in_think and "<think>" in buf:
-                pre, buf = buf.split("<think>", 1)
-                if pre.strip():
-                    yield ("token", pre)
-                in_think = True
-
-            # Inside think block — wait for </think>
-            if in_think:
-                if "</think>" in buf:
-                    think_text, buf = buf.split("</think>", 1)
-                    think_done  = True
-                    in_think    = False
-                    # Only yield think_block in thinking mode
-                    if think_mode and not think_yielded:
-                        yield ("think_block", think_text.strip())
-                        think_yielded = True
-                    # fall through to emit buf below
-                else:
-                    continue  # still collecting think content
-
-            # Emit content outside think blocks
-            if not in_think:
-                if not think_done:
-                    # Guard last 7 chars to catch a partial "<think>" opening
-                    if len(buf) > 7:
-                        safe, buf = buf[:-7], buf[-7:]
-                        yield ("token", safe)
-                else:
-                    yield ("token", buf)
-                    buf = ""
-
-    # Flush any remaining buffer
-    if buf and not in_think:
-        yield ("token", buf)
-
-
-# ── HuggingFace model support ─────────────────────────────────────────────────
-
-_hf_cache = {}
-_hf_download_state = {"running": False, "progress": "", "done": False, "error": None}
-
-
-def get_hf_download_state():
-    return _hf_download_state
-
-
-def download_hf_model(repo_id, local_name):
-    global _hf_download_state
-    _hf_download_state = {"running": True, "progress": f"Downloading {repo_id}...", "done": False, "error": None}
-
-    def run():
-        try:
-            from huggingface_hub import snapshot_download
-            save_dir = os.path.join(os.path.dirname(__file__), "models", "trained", local_name)
-            os.makedirs(save_dir, exist_ok=True)
-            _hf_download_state["progress"] = f"Fetching {repo_id} → models/trained/{local_name}/"
-            snapshot_download(
-                repo_id=repo_id,
-                local_dir=save_dir,
-                ignore_patterns=["*.bin", "*.msgpack", "flax_model*", "tf_model*", "rust_model*"],
-            )
-            _hf_download_state["progress"] = "Done"
-            _hf_download_state["done"] = True
-            _hf_download_state["running"] = False
-        except Exception as e:
-            _hf_download_state["error"] = str(e)
-            _hf_download_state["running"] = False
-            _hf_download_state["done"] = True
-
-    t = threading.Thread(target=run, daemon=True)
-    t.start()
-
-
-def is_hf_model(model_name):
-    save_dir = os.path.join(os.path.dirname(__file__), "models", "trained")
-    path = os.path.join(save_dir, model_name)
-    return os.path.isdir(path) and os.path.exists(os.path.join(path, "config.json"))
-
-
-def load_hf_model(model_name):
-    if model_name in _hf_cache:
-        return _hf_cache[model_name]
-    import torch
-    from transformers import AutoModelForCausalLM, AutoTokenizer
-    save_dir = os.path.join(os.path.dirname(__file__), "models", "trained")
-    path = os.path.join(save_dir, model_name)
-    tokenizer = AutoTokenizer.from_pretrained(path, trust_remote_code=True)
-    model = AutoModelForCausalLM.from_pretrained(
-        path,
-        torch_dtype=torch.bfloat16,
-        device_map="cpu",
-        trust_remote_code=True,
-    )
-    model.eval()
-    _hf_cache[model_name] = {"model": model, "tokenizer": tokenizer}
-    return _hf_cache[model_name]
+# ── MiniGPT inference ─────────────────────────────────────────────────────────
 
-
-def generate_hf_text(model_name, messages, max_tokens=512, temperature=0.7, think_mode=False):
-    import torch
-    from transformers import TextIteratorStreamer
-    import queue as _queue
-
-    mc = load_hf_model(model_name)
-    model = mc["model"]
-    tokenizer = mc["tokenizer"]
-
-    try:
-        text = tokenizer.apply_chat_template(
-            messages,
-            tokenize=False,
-            add_generation_prompt=True,
-            enable_thinking=think_mode,
-        )
-    except Exception:
-        text = tokenizer.apply_chat_template(
-            messages,
-            tokenize=False,
-            add_generation_prompt=True,
-        )
-
-    inputs = tokenizer([text], return_tensors="pt")
-
-    streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=False)
-
-    gen_kwargs = dict(
-        **inputs,
-        max_new_tokens=max_tokens,
-        temperature=temperature if temperature > 0 else 1.0,
-        do_sample=temperature > 0.05,
-        streamer=streamer,
-    )
-
-    gen_thread = threading.Thread(target=model.generate, kwargs=gen_kwargs, daemon=True)
-    gen_thread.start()
-
-    full = ""
-    for chunk in streamer:
-        full += chunk
-
-    gen_thread.join(timeout=5)
-
-    full = full.strip()
-
-    if think_mode and "<think>" in full:
-        if "</think>" in full:
-            think_part = full.split("<think>", 1)[1].split("</think>", 1)[0].strip()
-            answer_part = full.split("</think>", 1)[1].strip()
-        else:
-            think_part = full.replace("<think>", "").strip()
-            answer_part = full.replace("<think>", "").strip()
-        return {"think_block": think_part, "response": answer_part, "thinking": True}
-    else:
-        clean = full.replace("<think>", "").replace("</think>", "").strip()
-        return {"response": clean, "thinking": False}
-
-
-def generate_hf_stream(model_name, messages, max_tokens=512, temperature=0.7, think_mode=False):
-    import torch
-    from transformers import TextIteratorStreamer
-
-    mc = load_hf_model(model_name)
-    model = mc["model"]
-    tokenizer = mc["tokenizer"]
-
-    try:
-        text = tokenizer.apply_chat_template(
-            messages,
-            tokenize=False,
-            add_generation_prompt=True,
-            enable_thinking=think_mode,
-        )
-    except Exception:
-        text = tokenizer.apply_chat_template(
-            messages,
-            tokenize=False,
-            add_generation_prompt=True,
-        )
-
-    inputs = tokenizer([text], return_tensors="pt")
-
-    streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=False)
-    gen_kwargs = dict(
-        **inputs,
-        max_new_tokens=max_tokens,
-        temperature=temperature if temperature > 0 else 1.0,
-        do_sample=temperature > 0.05,
-        streamer=streamer,
-    )
-    gen_thread = threading.Thread(target=model.generate, kwargs=gen_kwargs, daemon=True)
-    gen_thread.start()
-
-    buffer = ""
-    in_think = False
-    think_done = False
-    think_buf = ""
-    resp_buf = ""
-
-    for chunk in streamer:
-        buffer += chunk
-
-        if think_mode and not think_done:
-            if not in_think and "<think>" in buffer:
-                in_think = True
-                buffer = buffer.split("<think>", 1)[1]
-            if in_think:
-                if "</think>" in buffer:
-                    parts = buffer.split("</think>", 1)
-                    think_buf += parts[0]
-                    buffer = parts[1]
-                    in_think = False
-                    think_done = True
-                    yield ("think_block", think_buf.strip())
-                    for ch in buffer:
-                        yield ("token", ch)
-                    buffer = ""
-                else:
-                    think_buf += buffer
-                    buffer = ""
-                continue
-
-        for ch in buffer:
-            yield ("token", ch)
-        buffer = ""
-
-    if buffer:
-        for ch in buffer:
-            yield ("token", ch)
+_inference_cache = {}
 
 
 def load_trained_model(model_name):
@@ -757,11 +304,7 @@ def generate_text(model_name, prompt, max_tokens=200, temperature=0.8, top_k=40,
     itos = mc["itos"]
     block_size = mc["block_size"]
 
-    if think_mode:
-        formatted = f"User: {prompt}\n<think>"
-    else:
-        formatted = prompt
-
+    formatted = f"User: {prompt}\n<think>" if think_mode else prompt
     encoded = [stoi.get(c, 0) for c in formatted]
     idx = torch.tensor([encoded], dtype=torch.long)
     out = model.generate(idx, max_new_tokens=max_tokens, temperature=temperature, top_k=top_k)
@@ -772,11 +315,153 @@ def generate_text(model_name, prompt, max_tokens=200, temperature=0.8, top_k=40,
     if think_mode:
         if "</think>" in generated:
             parts = generated.split("</think>", 1)
-            think_block = parts[0].strip()
-            response = parts[1].strip()
-        else:
-            think_block = generated.strip()
-            response = generated.strip()
-        return {"think_block": think_block, "response": response, "thinking": True}
+            return {"think_block": parts[0].strip(), "response": parts[1].strip(), "thinking": True}
+        return {"think_block": generated.strip(), "response": generated.strip(), "thinking": True}
+    return {"response": generated, "thinking": False}
+
+
+# ── ExocoreV1 inference ───────────────────────────────────────────────────────
+
+_exocore_cache = {}
+
+
+def is_exocore_pt(model_name):
+    save_dir = os.path.join(os.path.dirname(__file__), "models", "trained")
+    meta_path = os.path.join(save_dir, model_name + ".meta")
+    if os.path.exists(meta_path):
+        try:
+            with open(meta_path, "r") as f:
+                meta = json.load(f)
+            return meta.get("exocore_type") in ("qwen3", "exocoreV1")
+        except Exception:
+            pass
+    path = os.path.join(save_dir, model_name)
+    if os.path.exists(path) and path.endswith(".pt"):
+        try:
+            ckpt = torch.load(path, map_location="cpu", weights_only=False)
+            return ckpt.get("exocore_type") in ("qwen3", "exocoreV1")
+        except Exception:
+            pass
+    return False
+
+
+def load_exocore_model(model_name):
+    import gc
+    if model_name in _exocore_cache:
+        return _exocore_cache[model_name]
+    from exocore_model import ExocoreLM
+    save_dir = os.path.join(os.path.dirname(__file__), "models", "trained")
+    path = os.path.join(save_dir, model_name)
+    ckpt = torch.load(path, map_location="cpu", weights_only=False)
+    cfg = ckpt["config"]
+    tok_json = ckpt["tokenizer_json"]
+    model = ExocoreLM(cfg)
+    model.load_state_dict(ckpt["model_state"], strict=True)
+    del ckpt
+    gc.collect()
+    model.eval()
+    from tokenizers import Tokenizer
+    tok = Tokenizer.from_str(tok_json)
+    _exocore_cache[model_name] = {"model": model, "tokenizer": tok, "config": cfg, "name": "ExocoreV1"}
+    return _exocore_cache[model_name]
+
+
+def generate_exocore_stream(model_name, messages, max_tokens=512, temperature=0.7,
+                             think_mode=False, deep_think=False, search_context=None):
+    from exocore_model import build_chat_prompt, IM_END, EOT
+
+    mc = load_exocore_model(model_name)
+    tok = mc["tokenizer"]
+    model = mc["model"]
+    cfg = mc["config"]
+    max_pos = min(cfg.get("max_position_embeddings", 8192), 4096)
+
+    def sample_next(ids):
+        ctx = ids[:, -min(ids.shape[1], max_pos):]
+        with torch.no_grad():
+            logits, _ = model(ctx)
+        logits = logits[:, -1, :].float() / max(temperature, 1e-5)
+        v, _ = torch.topk(logits, min(50, logits.size(-1)))
+        logits[logits < v[:, [-1]]] = float("-inf")
+        probs = torch.softmax(logits, dim=-1)
+        return torch.multinomial(probs, 1)
+
+    def encode(prompt):
+        enc = tok.encode(prompt)
+        return torch.tensor([enc.ids], dtype=torch.long)
+
+    def collect_tokens(ids, max_t, stop_ids=(IM_END, EOT)):
+        out_ids = []
+        for _ in range(max_t):
+            nxt = sample_next(ids)
+            tid = nxt.item()
+            ids = torch.cat([ids, nxt], dim=1)
+            if tid in stop_ids:
+                break
+            out_ids.append(tid)
+        return tok.decode(out_ids), ids
+
+    if deep_think:
+        think1_prompt = build_chat_prompt(messages, think=True, search_context=search_context)
+        think1_raw, _ = collect_tokens(encode(think1_prompt), min(max_tokens * 2, 1024))
+        think1 = think1_raw.replace("<think>", "").replace("</think>", "").strip()
+
+        think2_prompt = build_chat_prompt(messages, think=True, prior_thinking=think1, search_context=search_context)
+        think2_raw, _ = collect_tokens(encode(think2_prompt), min(max_tokens, 512))
+        think2 = think2_raw.replace("<think>", "").replace("</think>", "").strip()
+
+        combined = f"[Pass 1]\n{think1}\n\n[Pass 2]\n{think2}"
+        yield ("think_block", combined)
+
+        answer_prompt = build_chat_prompt(messages, think=False, prior_thinking=combined, search_context=search_context)
+        ids = encode(answer_prompt)
+        for _ in range(max_tokens):
+            nxt = sample_next(ids)
+            tid = nxt.item()
+            ids = torch.cat([ids, nxt], dim=1)
+            if tid in (IM_END, EOT):
+                break
+            yield ("token", tok.decode([tid]))
+
     else:
-        return {"response": generated, "thinking": False}
+        prompt = build_chat_prompt(messages, think=think_mode, search_context=search_context)
+        ids = encode(prompt)
+        buf = ""
+        in_think = False
+        think_done = not think_mode
+        think_buf = ""
+        think_sent = False
+
+        for _ in range(max_tokens):
+            nxt = sample_next(ids)
+            tid = nxt.item()
+            ids = torch.cat([ids, nxt], dim=1)
+            if tid in (IM_END, EOT):
+                break
+
+            buf += tok.decode([tid])
+
+            if not think_done:
+                if not in_think and "<think>" in buf:
+                    buf = buf.split("<think>", 1)[1]
+                    in_think = True
+                if in_think:
+                    if "</think>" in buf:
+                        ttext, buf = buf.split("</think>", 1)
+                        think_buf += ttext
+                        think_done = True
+                        in_think = False
+                        if not think_sent:
+                            yield ("think_block", think_buf.strip())
+                            think_sent = True
+                    else:
+                        think_buf += buf
+                        buf = ""
+                    continue
+
+            if not in_think and buf:
+                yield ("token", buf)
+                buf = ""
+
+        if buf and not in_think:
+            yield ("token", buf)