Upload ΩFFΣLLIα_KΣrnΣl_₣ΔβLLΣ.py

ΩFFΣLLIα_KΣrnΣl_₣ΔβLLΣ.py

@@ -0,0 +1,1875 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+ΩFFΣLLIα Kernel — Text/Code Edition
+Proxy + login + UI unificada, focado 100% em texto e código.
+
+Recursos:
+  - chat/código → llama-server externo (:8080), streaming
+  - upload de .txt / .pdf  → extração de texto e injeção no contexto (ctx alto)
+  - LaTeX (KaTeX) + Markdown + emojis + highlight de código
+  - métricas em tempo real: ctx usado da janela, tokens/s ao vivo,
+    total de tokens e tempo total ao fim de cada resposta
+  - memória de conversas (persistência local em JSON) + sidebar para ver/excluir
+  - personas (persistência local em JSON) + sidebar para criar/ver/excluir,
+    injetadas como system prompt na conversa ativa (sem limite de caracteres)
+  - AGÊNTICA: 1 único agente real, roda em segundo plano (intervalo), memória
+    própria persistente e em tempo real, relatórios por ação em pasta dedicada,
+    ações reais (shell/python/http/escrita de arquivo/llm), permissão root opcional
+    via senha. Ativar/desativar/excluir/recriar — nunca mais de um.
+  - login, sessão assinada, rate-limit, TLS autoassinado
+  - ZERO telemetria, zero ping externo
+
+═══ v2 — UPGRADES CIRÚRGICOS (base intacta; tudo marcado com [UPGRADE]) ═══
+  - TUDO orquestrado num único llama-server externo (:8080)
+  - /api/health: ping no upstream LLM com pill na sidebar
+  - parar geração (AbortController) + regenerar última resposta
+  - detecção de stream robusta no proxy (parsing JSON, sem falso-positivo)
+  - TLS SAN ampliado (IPs LAN + 10.42.0.1 do hotspot kernel-local)
+  - exportar conversa em .md (frontend puro)
+
+Deps:
+  pip install "fastapi[standard]" uvicorn httpx itsdangerous "passlib[argon2]" \
+              cryptography pypdf
+
+Assets offline (1x — opcional; há fallback por CDN comentado):
+  Coloque em offsellia_data/static/:
+    marked.min.js, katex.min.js, katex.min.css, auto-render.min.js,
+    highlight.min.js, github-dark.min.css  (+ pasta de fonts do KaTeX)
+
+Rode:
+  python ΩFFΣLLIα_Kernel.py
+"""
+import os, sys, json, secrets, time, ipaddress, uuid, threading, subprocess, asyncio
+from pathlib import Path
+from contextlib import asynccontextmanager
+
+import httpx
+from fastapi import FastAPI, Request, Response, Form
+from fastapi.responses import (HTMLResponse, RedirectResponse, StreamingResponse,
+                               JSONResponse, FileResponse)
+from itsdangerous import URLSafeTimedSerializer, BadSignature
+from passlib.hash import argon2
+
+# ═══════════════════════════ Config local (sem telemetria) ═══════════════════════════
+BASE_DIR   = Path(__file__).resolve().parent
+DATA_DIR   = BASE_DIR / "offsellia_data"
+CONF_PATH  = DATA_DIR / "kernel.json"
+DATA_DIR.mkdir(exist_ok=True)
+
+STATIC_DIR   = DATA_DIR / "static"
+CHATS_DIR    = DATA_DIR / "chats"
+PERSONAS_DIR = DATA_DIR / "personas"
+AGENT_DIR    = DATA_DIR / "agent"
+AGENT_MEM_DIR    = AGENT_DIR / "memory"
+AGENT_REPORTS_DIR = AGENT_DIR / "reports"
+for d in (STATIC_DIR, CHATS_DIR, PERSONAS_DIR, AGENT_DIR, AGENT_MEM_DIR, AGENT_REPORTS_DIR):
+    d.mkdir(parents=True, exist_ok=True)
+
+AGENT_CONF_PATH = AGENT_DIR / "agent.json"
+AGENT_MEM_PATH  = AGENT_MEM_DIR / "memory.json"
+
+KERNEL_NAME = "ΩFFΣLLIα"
+SESSION_MAX_AGE = 60 * 60 * 8
+COOKIE = "offsellia_session"
+
+DEFAULTS = {
+    "port": 5000,
+    "bind": "0.0.0.0",
+    "use_tls": True,
+    "n_ctx": 50000,            # janela de contexto reportada na UI (ajuste ao seu llama-server)
+    "upstreams": {
+        "llm": "http://127.0.0.1:8080",   # único llama-server externo, tudo orquestrado aqui
+    },
+    "secret": secrets.token_hex(32),
+    "pwd_hash": None,
+}
+
+def load_conf() -> dict:
+    if CONF_PATH.exists():
+        conf = json.loads(CONF_PATH.read_text())
+        for k, v in DEFAULTS.items():
+            conf.setdefault(k, v)
+        for k, v in DEFAULTS["upstreams"].items():
+            conf["upstreams"].setdefault(k, v)
+        return conf
+    conf = dict(DEFAULTS)
+    pw = os.environ.get("OFFSELLIA_PASS")
+    if not pw:
+        print(f"\n[{KERNEL_NAME}] Primeiro boot — defina a senha de acesso.")
+        import getpass
+        while True:
+            pw = getpass.getpass("  Nova senha: ")
+            if pw and pw == getpass.getpass("  Confirme:   "):
+                break
+            print("  Não conferem, tente de novo.")
+    conf["pwd_hash"] = argon2.using(rounds=4, memory_cost=65536).hash(pw)
+    CONF_PATH.write_text(json.dumps(conf, indent=2))
+    print(f"[{KERNEL_NAME}] Config salva em {CONF_PATH}\n")
+    return conf
+
+CONF = load_conf()
+signer = URLSafeTimedSerializer(CONF["secret"], salt="offsellia-auth")
+
+# ═══════════════════════════ Auth ═══════════════════════════
+def issue_token() -> str:
+    return signer.dumps({"t": time.time()})
+
+def valid_session(req: Request) -> bool:
+    tok = req.cookies.get(COOKIE)
+    if not tok:
+        return False
+    try:
+        signer.loads(tok, max_age=SESSION_MAX_AGE)
+        return True
+    except BadSignature:
+        return False
+
+_login_hits: dict[str, list[float]] = {}
+def login_allowed(ip: str) -> bool:
+    now = time.time()
+    hits = [t for t in _login_hits.get(ip, []) if now - t < 300]
+    _login_hits[ip] = hits
+    return len(hits) < 8
+
+# ═══════════════════════════ Persistência de conversas ═══════════════════════════
+def _safe_id(cid: str) -> str:
+    return "".join(c for c in cid if c.isalnum() or c in "-_")[:64]
+
+def list_chats() -> list[dict]:
+    out = []
+    for f in CHATS_DIR.glob("*.json"):
+        try:
+            d = json.loads(f.read_text())
+            out.append({"id": d.get("id", f.stem),
+                        "title": d.get("title", "Sem título"),
+                        "updated": d.get("updated", 0)})
+        except Exception:
+            pass
+    out.sort(key=lambda x: x["updated"], reverse=True)
+    return out
+
+def load_chat(cid: str) -> dict | None:
+    f = CHATS_DIR / f"{_safe_id(cid)}.json"
+    if f.exists():
+        try:
+            return json.loads(f.read_text())
+        except Exception:
+            return None
+    return None
+
+def save_chat(cid: str, title: str, messages: list, persona_id=None) -> dict:
+    cid = _safe_id(cid) or uuid.uuid4().hex
+    data = {"id": cid, "title": title[:120] or "Sem título",
+            "updated": time.time(), "messages": messages,
+            "persona_id": persona_id}
+    (CHATS_DIR / f"{cid}.json").write_text(json.dumps(data, ensure_ascii=False, indent=1))
+    return data
+
+def delete_chat(cid: str) -> bool:
+    f = CHATS_DIR / f"{_safe_id(cid)}.json"
+    if f.exists():
+        f.unlink()
+        return True
+    return False
+
+# ═══════════════════════════ Persistência de personas ═══════════════════════════
+def list_personas() -> list[dict]:
+    out = []
+    for f in PERSONAS_DIR.glob("*.json"):
+        try:
+            d = json.loads(f.read_text())
+            out.append({"id": d.get("id", f.stem),
+                        "title": d.get("title", "Sem título"),
+                        "updated": d.get("updated", 0)})
+        except Exception:
+            pass
+    out.sort(key=lambda x: x["updated"], reverse=True)
+    return out
+
+def load_persona(pid: str) -> dict | None:
+    f = PERSONAS_DIR / f"{_safe_id(pid)}.json"
+    if f.exists():
+        try:
+            return json.loads(f.read_text())
+        except Exception:
+            return None
+    return None
+
+def save_persona(pid: str, title: str, description: str) -> dict:
+    pid = _safe_id(pid) or uuid.uuid4().hex
+    data = {"id": pid, "title": title[:120] or "Sem título",
+            "description": description, "updated": time.time()}
+    (PERSONAS_DIR / f"{pid}.json").write_text(json.dumps(data, ensure_ascii=False, indent=1))
+    return data
+
+def delete_persona(pid: str) -> bool:
+    f = PERSONAS_DIR / f"{_safe_id(pid)}.json"
+    if f.exists():
+        f.unlink()
+        return True
+    return False
+
+# ═══════════════════════════ AGÊNTICA — agente único, real, em segundo plano ═══════════════════════════
+# Estrutura local:
+#   offsellia_data/agent/agent.json          -> config do agente
+#   offsellia_data/agent/memory/memory.json  -> memória própria persistente (tempo real)
+#   offsellia_data/agent/reports/*.json      -> relatório por ação
+_agent_lock = threading.Lock()
+_agent_thread: threading.Thread | None = None
+_agent_stop = threading.Event()
+_agent_root_secret: str | None = None   # senha root em memória apenas (nunca em disco)
+
+AGENT_DEFAULT = {
+    "exists": False,
+    "name": "",
+    "function": "",          # descrição/objetivo do agente (system prompt agêntico)
+    "interval": 300,         # período de ação em segundos
+    "enabled": False,
+    # quais ações reais ele pode tomar:
+    "actions": {
+        "shell": False,      # executar comandos de shell
+        "python": False,     # executar código python
+        "http": False,       # requisições HTTP de saída
+        "file_write": False, # escrever arquivos no diretório de trabalho
+        "llm": True,         # raciocinar via llama-server
+    },
+    # configurações de última geração:
+    "workdir": str((AGENT_DIR / "workspace").resolve()),
+    "max_steps": 4,          # passos de raciocínio/ação por ciclo
+    "autonomy": "supervised",# supervised | autonomous
+    "allow_root": False,     # permissão de agir no sistema com senha root
+    "model": "",             # modelo opcional para o llama-server
+    "temperature": 0.4,
+    "memory_window": 40,     # nº de entradas de memória injetadas no contexto
+    "created": 0,
+    "last_run": 0,
+    "runs": 0,
+}
+
+def _ensure_agent_workspace():
+    try:
+        Path(AGENT_DEFAULT["workdir"]).mkdir(parents=True, exist_ok=True)
+    except Exception:
+        pass
+
+def load_agent() -> dict:
+    if AGENT_CONF_PATH.exists():
+        try:
+            d = json.loads(AGENT_CONF_PATH.read_text())
+        except Exception:
+            d = dict(AGENT_DEFAULT)
+    else:
+        d = dict(AGENT_DEFAULT)
+    # preenche campos faltantes
+    for k, v in AGENT_DEFAULT.items():
+        if k == "actions":
+            d.setdefault("actions", {})
+            for ak, av in AGENT_DEFAULT["actions"].items():
+                d["actions"].setdefault(ak, av)
+        else:
+            d.setdefault(k, v)
+    return d
+
+def save_agent(d: dict) -> dict:
+    AGENT_CONF_PATH.write_text(json.dumps(d, ensure_ascii=False, indent=1))
+    return d
+
+def agent_public(d: dict) -> dict:
+    # versão exposta à UI (sem segredo root; indica se root está armado em memória)
+    out = dict(d)
+    out["root_armed"] = bool(_agent_root_secret)
+    out["running"] = bool(_agent_thread and _agent_thread.is_alive())
+    return out
+
+def load_agent_memory() -> list:
+    if AGENT_MEM_PATH.exists():
+        try:
+            return json.loads(AGENT_MEM_PATH.read_text())
+        except Exception:
+            return []
+    return []
+
+def append_agent_memory(entry: dict):
+    mem = load_agent_memory()
+    entry = {"ts": time.time(), **entry}
+    mem.append(entry)
+    # mantém memória enxuta em disco (tempo real), preserva relatórios completos à parte
+    if len(mem) > 2000:
+        mem = mem[-2000:]
+    AGENT_MEM_PATH.write_text(json.dumps(mem, ensure_ascii=False, indent=1))
+
+def clear_agent_memory():
+    AGENT_MEM_PATH.write_text(json.dumps([], ensure_ascii=False, indent=1))
+
+def write_agent_report(report: dict) -> str:
+    ts = time.strftime("%Y%m%d-%H%M%S", time.localtime())
+    rid = f"{ts}-{uuid.uuid4().hex[:6]}"
+    report = {"id": rid, "ts": time.time(), **report}
+    (AGENT_REPORTS_DIR / f"{rid}.json").write_text(json.dumps(report, ensure_ascii=False, indent=1))
+    return rid
+
+def list_agent_reports(limit: int = 60) -> list[dict]:
+    out = []
+    for f in AGENT_REPORTS_DIR.glob("*.json"):
+        try:
+            d = json.loads(f.read_text())
+            out.append({"id": d.get("id", f.stem),
+                        "ts": d.get("ts", 0),
+                        "ok": d.get("ok", True),
+                        "summary": d.get("summary", "")[:160]})
+        except Exception:
+            pass
+    out.sort(key=lambda x: x["ts"], reverse=True)
+    return out[:limit]
+
+def load_agent_report(rid: str) -> dict | None:
+    f = AGENT_REPORTS_DIR / f"{_safe_id(rid)}.json"
+    if f.exists():
+        try:
+            return json.loads(f.read_text())
+        except Exception:
+            return None
+    return None
+
+# ---------- execução real de ações ----------
+def _root_prefix(use_root: bool) -> list[str]:
+    """Prefixo de elevação se root permitido e senha armada (Linux/macOS via sudo -S)."""
+    if use_root and _agent_root_secret:
+        return ["sudo", "-S", "-p", ""]
+    return []
+
+def _run_shell(cmd: str, agent: dict) -> dict:
+    use_root = agent.get("allow_root") and _agent_root_secret
+    workdir = agent.get("workdir") or str(AGENT_DIR)
+    try:
+        if use_root:
+            full = _root_prefix(True) + ["/bin/sh", "-c", cmd]
+            proc = subprocess.run(full, input=(_agent_root_secret or "") + "\n",
+                                  capture_output=True, text=True, timeout=120, cwd=workdir)
+        else:
+            proc = subprocess.run(cmd, shell=True, capture_output=True, text=True,
+                                  timeout=120, cwd=workdir)
+        return {"action": "shell", "cmd": cmd, "root": bool(use_root),
+                "code": proc.returncode,
+                "stdout": (proc.stdout or "")[-8000:],
+                "stderr": (proc.stderr or "")[-4000:], "ok": proc.returncode == 0}
+    except subprocess.TimeoutExpired:
+        return {"action": "shell", "cmd": cmd, "ok": False, "error": "timeout"}
+    except Exception as e:
+        return {"action": "shell", "cmd": cmd, "ok": False, "error": str(e)}
+
+def _run_python(code: str, agent: dict) -> dict:
+    workdir = agent.get("workdir") or str(AGENT_DIR)
+    try:
+        proc = subprocess.run([sys.executable, "-c", code], capture_output=True,
+                              text=True, timeout=120, cwd=workdir)
+        return {"action": "python", "code": code[:4000], "rc": proc.returncode,
+                "stdout": (proc.stdout or "")[-8000:],
+                "stderr": (proc.stderr or "")[-4000:], "ok": proc.returncode == 0}
+    except subprocess.TimeoutExpired:
+        return {"action": "python", "ok": False, "error": "timeout"}
+    except Exception as e:
+        return {"action": "python", "ok": False, "error": str(e)}
+
+def _run_http(url: str, method: str, body, agent: dict) -> dict:
+    try:
+        with httpx.Client(timeout=60) as c:
+            r = c.request(method or "GET", url,
+                          content=(json.dumps(body) if isinstance(body, (dict, list)) else body))
+            return {"action": "http", "url": url, "method": method or "GET",
+                    "status": r.status_code, "body": r.text[:8000], "ok": r.is_success}
+    except Exception as e:
+        return {"action": "http", "url": url, "ok": False, "error": str(e)}
+
+def _run_file_write(path: str, content: str, agent: dict) -> dict:
+    try:
+        base = Path(agent.get("workdir") or str(AGENT_DIR)).resolve()
+        target = (base / path).resolve()
+        if base not in target.parents and target != base:
+            return {"action": "file_write", "path": path, "ok": False,
+                    "error": "fora do workspace do agente"}
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(content, encoding="utf-8")
+        return {"action": "file_write", "path": str(target), "bytes": len(content), "ok": True}
+    except Exception as e:
+        return {"action": "file_write", "path": path, "ok": False, "error": str(e)}
+
+def _llm_complete(messages: list, agent: dict) -> str:
+    up = CONF["upstreams"]["llm"].rstrip("/") + "/v1/chat/completions"
+    payload = {"messages": messages, "stream": False,
+               "temperature": agent.get("temperature", 0.4)}
+    if agent.get("model"):
+        payload["model"] = agent["model"]
+    try:
+        with httpx.Client(timeout=300) as c:
+            r = c.post(up, json=payload)
+            j = r.json()
+            return j.get("choices", [{}])[0].get("message", {}).get("content", "") or ""
+    except Exception as e:
+        return f"[ERRO LLM: {e}]"
+
+def _allowed(agent: dict, name: str) -> bool:
+    return bool(agent.get("actions", {}).get(name))
+
+def _execute_action(act: dict, agent: dict) -> dict:
+    t = (act or {}).get("type")
+    if t == "shell" and _allowed(agent, "shell"):
+        return _run_shell(act.get("cmd", ""), agent)
+    if t == "python" and _allowed(agent, "python"):
+        return _run_python(act.get("code", ""), agent)
+    if t == "http" and _allowed(agent, "http"):
+        return _run_http(act.get("url", ""), act.get("method", "GET"), act.get("body"), agent)
+    if t == "file_write" and _allowed(agent, "file_write"):
+        return _run_file_write(act.get("path", "out.txt"), act.get("content", ""), agent)
+    if t == "note":
+        return {"action": "note", "text": act.get("text", ""), "ok": True}
+    return {"action": t or "desconhecida", "ok": False, "error": "ação não permitida ou inválida"}
+
+AGENT_SYS_TEMPLATE = """Você é {name}, um agente autônomo real executando em ciclos em segundo plano.
+Objetivo/Função: {function}
+
+Você decide as próximas ações e responde ESTRITAMENTE em JSON, sem markdown, no formato:
+{{"thoughts":"...", "actions":[{{"type":"shell|python|http|file_write|note", ...}}], "summary":"resumo curto do ciclo", "done": true|false}}
+
+Campos por tipo de ação:
+- shell: {{"type":"shell","cmd":"..."}}
+- python: {{"type":"python","code":"..."}}
+- http: {{"type":"http","url":"...","method":"GET|POST","body":{{}}}}
+- file_write: {{"type":"file_write","path":"relativo-ao-workspace","content":"..."}}
+- note: {{"type":"note","text":"observação a guardar na memória"}}
+
+Ações habilitadas neste agente: {allowed}
+Permissão root no sistema: {root}
+Use somente ações habilitadas. Seja objetivo. Responda apenas o JSON."""
+
+def _build_agent_messages(agent: dict) -> list:
+    allowed = [k for k, v in agent.get("actions", {}).items() if v]
+    sys = AGENT_SYS_TEMPLATE.format(
+        name=agent.get("name", "Agente"),
+        function=agent.get("function", ""),
+        allowed=", ".join(allowed) or "nenhuma",
+        root=("permitida" if (agent.get("allow_root") and _agent_root_secret) else "negada"),
+    )
+    mem = load_agent_memory()
+    win = agent.get("memory_window", 40)
+    recent = mem[-win:] if win else mem
+    mem_txt = "\n".join(
+        f"[{time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(m.get('ts',0)))}] "
+        f"{m.get('kind','')}: {json.dumps(m.get('data', m), ensure_ascii=False)[:600]}"
+        for m in recent
+    )
+    user = ("Estado da memória própria (recente):\n" + (mem_txt or "(vazia)") +
+            "\n\nInicie ou continue trabalhando em direção ao objetivo. "
+            "Decida as próximas ações para este ciclo.")
+    return [{"role": "system", "content": sys}, {"role": "user", "content": user}]
+
+def _parse_agent_json(text: str) -> dict:
+    s = text.strip()
+    if s.startswith("```"):
+        s = s.strip("`")
+        if s[:4].lower() == "json":
+            s = s[4:]
+    i, j = s.find("{"), s.rfind("}")
+    if i >= 0 and j > i:
+        s = s[i:j+1]
+    try:
+        return json.loads(s)
+    except Exception:
+        return {"thoughts": "", "actions": [], "summary": text[:200], "done": False, "_raw": text[:2000]}
+
+def _agent_cycle(agent: dict) -> dict:
+    _ensure_agent_workspace()
+    cycle_log = {"steps": [], "ok": True}
+    plan_text = ""
+    if _allowed(agent, "llm"):
+        plan_text = _llm_complete(_build_agent_messages(agent), agent)
+    else:
+        plan_text = '{"actions":[{"type":"note","text":"LLM desabilitado; ciclo sem raciocínio."}],"summary":"ciclo manual","done":false}'
+    plan = _parse_agent_json(plan_text)
+    cycle_log["plan"] = plan
+    append_agent_memory({"kind": "plan", "data": {"thoughts": plan.get("thoughts", ""),
+                                                   "summary": plan.get("summary", "")}})
+    actions = plan.get("actions", []) or []
+    max_steps = max(1, int(agent.get("max_steps", 4)))
+    for act in actions[:max_steps]:
+        res = _execute_action(act, agent)
+        cycle_log["steps"].append({"request": act, "result": res})
+        append_agent_memory({"kind": "action", "data": {"req": act, "ok": res.get("ok"),
+                                                         "summary": res.get("summary") or res.get("error") or res.get("stdout", "")[:300]}})
+        if not res.get("ok", True):
+            cycle_log["ok"] = False
+    cycle_log["summary"] = plan.get("summary", "")[:300]
+    cycle_log["done"] = bool(plan.get("done"))
+    return cycle_log
+
+def _agent_loop():
+    while not _agent_stop.is_set():
+        agent = load_agent()
+        if not (agent.get("exists") and agent.get("enabled")):
+            break
+        try:
+            log = _agent_cycle(agent)
+            rid = write_agent_report({"agent": agent.get("name"),
+                                      "ok": log.get("ok", True),
+                                      "summary": log.get("summary", ""),
+                                      "cycle": log})
+            agent = load_agent()
+            agent["last_run"] = time.time()
+            agent["runs"] = int(agent.get("runs", 0)) + 1
+            save_agent(agent)
+            append_agent_memory({"kind": "cycle_done", "data": {"report": rid,
+                                                                "ok": log.get("ok", True)}})
+        except Exception as e:
+            write_agent_report({"agent": agent.get("name"), "ok": False,
+                                "summary": f"erro no ciclo: {e}", "error": str(e)})
+        interval = max(5, int(load_agent().get("interval", 300)))
+        # espera responsiva ao stop
+        waited = 0
+        while waited < interval and not _agent_stop.is_set():
+            time.sleep(1)
+            waited += 1
+
+def start_agent_thread() -> bool:
+    global _agent_thread, _agent_stop
+    with _agent_lock:
+        if _agent_thread and _agent_thread.is_alive():
+            return True
+        _agent_stop = threading.Event()
+        _agent_thread = threading.Thread(target=_agent_loop, daemon=True)
+        _agent_thread.start()
+        return True
+
+def stop_agent_thread():
+    global _agent_thread
+    with _agent_lock:
+        _agent_stop.set()
+        _agent_thread = None
+
+# ═══════════════════════════ Extração de texto (.txt / .pdf) ═══════════════════════════
+def extract_pdf(raw: bytes) -> str:
+    try:
+        from pypdf import PdfReader
+    except ImportError:
+        return "[ERRO: pypdf não instalado — pip install pypdf]"
+    import io
+    try:
+        reader = PdfReader(io.BytesIO(raw))
+        parts = []
+        for i, page in enumerate(reader.pages):
+            txt = page.extract_text() or ""
+            parts.append(f"\n--- [página {i+1}] ---\n{txt.strip()}")
+        return "\n".join(parts).strip()
+    except Exception as e:
+        return f"[ERRO ao ler PDF: {e}]"
+
+def extract_txt(raw: bytes) -> str:
+    for enc in ("utf-8", "latin-1", "cp1252"):
+        try:
+            return raw.decode(enc)
+        except UnicodeDecodeError:
+            continue
+    return raw.decode("utf-8", errors="replace")
+
+# ═══════════════════════════ TLS autoassinado ═══════════════════════════
+# [UPGRADE] descobre IPs locais (sem tráfego externo) p/ incluir no SAN do cert.
+def _local_ips() -> set[str]:
+    ips: set[str] = set()
+    try:
+        import socket
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            s.connect(("10.255.255.255", 1))   # não envia pacote; só resolve a rota local
+            ips.add(s.getsockname()[0])
+        except Exception:
+            pass
+        finally:
+            s.close()
+    except Exception:
+        pass
+    try:
+        import socket
+        for info in socket.getaddrinfo(socket.gethostname(), None):
+            ip = info[4][0]
+            if ":" not in ip:                  # mantém só IPv4 por simplicidade
+                ips.add(ip)
+    except Exception:
+        pass
+    return ips
+
+def ensure_tls():
+    cert = DATA_DIR / "tls_cert.pem"
+    key  = DATA_DIR / "tls_key.pem"
+    if cert.exists() and key.exists():
+        return str(cert), str(key)
+    try:
+        from cryptography import x509
+        from cryptography.x509.oid import NameOID
+        from cryptography.hazmat.primitives import hashes, serialization
+        from cryptography.hazmat.primitives.asymmetric import rsa
+        import datetime
+        k = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+        name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "offsellia.local")])
+        # [UPGRADE] SAN ampliado: localhost + 127.0.0.1 + IPs LAN + gateway do hotspot (10.42.0.1).
+        san_entries = [
+            x509.DNSName("localhost"),
+            x509.IPAddress(ipaddress.ip_address("127.0.0.1")),
+        ]
+        extra = set(_local_ips())
+        extra.add("10.42.0.1")   # hotspot SSID kernel-local
+        for ip in sorted(extra):
+            try:
+                san_entries.append(x509.IPAddress(ipaddress.ip_address(ip)))
+            except Exception:
+                pass
+        san = x509.SubjectAlternativeName(san_entries)
+        now = datetime.datetime.now(datetime.timezone.utc)
+        cert_obj = (x509.CertificateBuilder()
+            .subject_name(name).issuer_name(name).public_key(k.public_key())
+            .serial_number(x509.random_serial_number())
+            .not_valid_before(now)
+            .not_valid_after(now + datetime.timedelta(days=3650))
+            .add_extension(san, critical=False)
+            .sign(k, hashes.SHA256()))
+        key.write_bytes(k.private_bytes(serialization.Encoding.PEM,
+            serialization.PrivateFormat.TraditionalOpenSSL, serialization.NoEncryption()))
+        cert.write_bytes(cert_obj.public_bytes(serialization.Encoding.PEM))
+        print(f"[{KERNEL_NAME}] TLS gerado: {cert}")
+        print(f"[{KERNEL_NAME}] SAN: localhost, 127.0.0.1, {', '.join(sorted(extra))}")
+        return str(cert), str(key)
+    except ImportError:
+        print(f"[{KERNEL_NAME}] AVISO: 'cryptography' ausente — HTTP. pip install cryptography")
+        return None
+
+# ═══════════════════════════ App + middleware ═══════════════════════════
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    app.state.client = httpx.AsyncClient(timeout=None)
+    print(f"[{KERNEL_NAME}] Kernel ativo em {CONF['bind']}:{CONF['port']}")
+    # retoma agente se estava habilitado
+    ag = load_agent()
+    if ag.get("exists") and ag.get("enabled"):
+        start_agent_thread()
+        print(f"[{KERNEL_NAME}] Agente '{ag.get('name')}' retomado em segundo plano.")
+    yield
+    stop_agent_thread()
+    await app.state.client.aclose()
+
+app = FastAPI(title=f"{KERNEL_NAME} Kernel", lifespan=lifespan, docs_url=None, redoc_url=None)
+
+@app.middleware("http")
+async def gate(request: Request, call_next):
+    p = request.url.path
+    if p == "/login" or p.startswith("/static"):
+        return await call_next(request)
+    if not valid_session(request):
+        if p.startswith(("/v1", "/api", "/proxy")):
+            return JSONResponse({"error": "unauthorized"}, status_code=401)
+        return RedirectResponse("/login")
+    resp = await call_next(request)
+    resp.headers["X-Content-Type-Options"] = "nosniff"
+    resp.headers["X-Frame-Options"] = "DENY"
+    resp.headers["Referrer-Policy"] = "no-referrer"
+    return resp
+
+# ═══════════════════════════ Login ═══════════════════════════
+LOGIN_HTML = """<!doctype html><html><head><meta charset=utf-8>
+<meta name=viewport content="width=device-width,initial-scale=1">
+<title>ΩFFΣLLIα</title><style>
+*{box-sizing:border-box;font-family:system-ui,sans-serif}
+body{margin:0;height:100vh;display:flex;align-items:center;justify-content:center;
+background:radial-gradient(1200px 600px at 50% -10%,#15151f,#0a0a0f);color:#e8e8ea}
+.card{background:#16161d;padding:40px;border-radius:18px;width:340px;
+box-shadow:0 8px 50px #000a;border:1px solid #26262e}
+h1{font-size:30px;margin:0 0 4px;letter-spacing:1px;
+background:linear-gradient(90deg,#fff,#9aa7ff);-webkit-background-clip:text;-webkit-text-fill-color:transparent}
+p{color:#8a8a93;margin:0 0 24px;font-size:13px}
+input{width:100%;padding:12px 14px;margin:8px 0;background:#0e0e14;
+border:1px solid #2a2a33;border-radius:10px;color:#fff;font-size:15px}
+button{width:100%;padding:12px;margin-top:14px;background:#fff;color:#000;
+border:0;border-radius:10px;font-size:15px;font-weight:600;cursor:pointer}
+.err{color:#ff6b6b;font-size:13px;min-height:18px;margin-top:8px}
+</style></head><body><form class=card method=post action=/login>
+<h1>ΩFFΣLLIα</h1><p>Kernel — acesso restrito</p>
+<input name=password type=password placeholder=Senha autofocus required>
+<button>Entrar</button><div class=err>__ERR__</div>
+</form></body></html>"""
+
+@app.get("/login", response_class=HTMLResponse)
+async def login_page():
+    return LOGIN_HTML.replace("__ERR__", "")
+
+@app.post("/login")
+async def login_submit(request: Request, password: str = Form(...)):
+    ip = request.client.host if request.client else "?"
+    if not login_allowed(ip):
+        return HTMLResponse(LOGIN_HTML.replace("__ERR__", "Muitas tentativas. Aguarde."), status_code=429)
+    _login_hits.setdefault(ip, []).append(time.time())
+    if argon2.verify(password, CONF["pwd_hash"]):
+        _login_hits[ip] = []
+        r = RedirectResponse("/", status_code=303)
+        r.set_cookie(COOKIE, issue_token(), max_age=SESSION_MAX_AGE,
+                     httponly=True, samesite="lax")
+        return r
+    return HTMLResponse(LOGIN_HTML.replace("__ERR__", "Senha incorreta."), status_code=401)
+
+@app.get("/logout")
+async def logout():
+    r = RedirectResponse("/login")
+    r.delete_cookie(COOKIE)
+    return r
+
+# ═══════════════════════════ Estáticos ═══════════════════════════
+@app.get("/static/{path:path}")
+async def serve_static(path: str):
+    f = (STATIC_DIR / path).resolve()
+    if STATIC_DIR.resolve() in f.parents and f.exists() and f.is_file():
+        return FileResponse(f)
+    return JSONResponse({"error": "not found"}, status_code=404)
+
+@app.get("/api/config")
+async def api_config():
+    return {"n_ctx": CONF.get("n_ctx", 32768), "kernel": KERNEL_NAME}
+
+# [UPGRADE] /api/health — ping no único upstream LLM (:8080) para a sidebar.
+@app.get("/api/health")
+async def api_health():
+    client: httpx.AsyncClient = app.state.client
+    base = CONF["upstreams"]["llm"]
+    try:
+        r = await client.get(base.rstrip("/") + "/health", timeout=3)
+        llm = {"configured": True, "online": r.status_code == 200,
+               "status": r.status_code, "url": base}
+    except Exception:
+        llm = {"configured": True, "online": False, "url": base}
+    return {"llm": llm}
+
+# ═══════════════════════════ Upload / extração ═══════════════════════════
+@app.post("/api/extract")
+async def api_extract(request: Request):
+    form = await request.form()
+    up = form.get("file")
+    if up is None:
+        return JSONResponse({"error": "sem arquivo"}, status_code=400)
+    raw = await up.read()
+    name = (getattr(up, "filename", "") or "").lower()
+    if name.endswith(".pdf") or raw[:5] == b"%PDF-":
+        text = extract_pdf(raw)
+    else:
+        text = extract_txt(raw)
+    return JSONResponse({"filename": getattr(up, "filename", "arquivo"),
+                         "chars": len(text), "text": text})
+
+# ═══════════════════════════ Conversas (CRUD) ═══════════════════════════
+@app.get("/api/chats")
+async def api_chats():
+    return {"chats": list_chats()}
+
+@app.get("/api/chats/{cid}")
+async def api_chat_get(cid: str):
+    d = load_chat(cid)
+    if not d:
+        return JSONResponse({"error": "não encontrada"}, status_code=404)
+    return d
+
+@app.post("/api/chats/{cid}")
+async def api_chat_save(cid: str, request: Request):
+    body = await request.json()
+    d = save_chat(cid, body.get("title", ""), body.get("messages", []),
+                  body.get("persona_id"))
+    return d
+
+@app.delete("/api/chats/{cid}")
+async def api_chat_delete(cid: str):
+    return {"deleted": delete_chat(cid)}
+
+# ═══════════════════════════ Personas (CRUD) ═══════════════════════════
+@app.get("/api/personas")
+async def api_personas():
+    return {"personas": list_personas()}
+
+@app.get("/api/personas/{pid}")
+async def api_persona_get(pid: str):
+    d = load_persona(pid)
+    if not d:
+        return JSONResponse({"error": "não encontrada"}, status_code=404)
+    return d
+
+@app.post("/api/personas/{pid}")
+async def api_persona_save(pid: str, request: Request):
+    body = await request.json()
+    d = save_persona(pid, body.get("title", ""), body.get("description", ""))
+    return d
+
+@app.delete("/api/personas/{pid}")
+async def api_persona_delete(pid: str):
+    return {"deleted": delete_persona(pid)}
+
+# ═══════════════════════════ AGÊNTICA (CRUD + controle) ═══════════════════════════
+@app.get("/api/agent")
+async def api_agent_get():
+    return agent_public(load_agent())
+
+@app.post("/api/agent")
+async def api_agent_save(request: Request):
+    body = await request.json()
+    cur = load_agent()
+    if cur.get("exists") and not body.get("_overwrite"):
+        # já existe: atualiza o único agente (nunca cria um segundo)
+        pass
+    new = dict(cur)
+    new["exists"] = True
+    if not new.get("created"):
+        new["created"] = time.time()
+    for k in ("name", "function", "interval", "max_steps", "autonomy",
+              "model", "temperature", "memory_window", "workdir", "allow_root"):
+        if k in body:
+            new[k] = body[k]
+    if "actions" in body and isinstance(body["actions"], dict):
+        acts = dict(AGENT_DEFAULT["actions"])
+        acts.update(new.get("actions", {}))
+        for ak in AGENT_DEFAULT["actions"]:
+            if ak in body["actions"]:
+                acts[ak] = bool(body["actions"][ak])
+        new["actions"] = acts
+    # normalizações
+    try: new["interval"] = max(5, int(new.get("interval", 300)))
+    except Exception: new["interval"] = 300
+    try: new["max_steps"] = max(1, int(new.get("max_steps", 4)))
+    except Exception: new["max_steps"] = 4
+    try: new["memory_window"] = max(0, int(new.get("memory_window", 40)))
+    except Exception: new["memory_window"] = 40
+    save_agent(new)
+    _ensure_agent_workspace()
+    return agent_public(new)
+
+@app.delete("/api/agent")
+async def api_agent_delete():
+    global _agent_root_secret
+    stop_agent_thread()
+    _agent_root_secret = None
+    save_agent(dict(AGENT_DEFAULT))
+    return {"deleted": True}
+
+@app.post("/api/agent/enable")
+async def api_agent_enable(request: Request):
+    body = await request.json()
+    en = bool(body.get("enabled"))
+    ag = load_agent()
+    if not ag.get("exists"):
+        return JSONResponse({"error": "nenhum agente criado"}, status_code=400)
+    ag["enabled"] = en
+    save_agent(ag)
+    if en:
+        start_agent_thread()
+    else:
+        stop_agent_thread()
+    return agent_public(load_agent())
+
+@app.post("/api/agent/root")
+async def api_agent_root(request: Request):
+    """Arma/desarma a senha root em memória (nunca gravada em disco)."""
+    global _agent_root_secret
+    body = await request.json()
+    if body.get("clear"):
+        _agent_root_secret = None
+        return {"root_armed": False}
+    pw = body.get("password") or ""
+    ag = load_agent()
+    if not ag.get("allow_root"):
+        return JSONResponse({"error": "permissão root desativada nas configurações do agente"}, status_code=400)
+    _agent_root_secret = pw if pw else None
+    return {"root_armed": bool(_agent_root_secret)}
+
+@app.post("/api/agent/run")
+async def api_agent_run():
+    """Dispara um ciclo imediato (não bloqueia o loop em segundo plano)."""
+    ag = load_agent()
+    if not ag.get("exists"):
+        return JSONResponse({"error": "nenhum agente criado"}, status_code=400)
+    def _one():
+        try:
+            log = _agent_cycle(load_agent())
+            rid = write_agent_report({"agent": ag.get("name"), "ok": log.get("ok", True),
+                                      "summary": log.get("summary", ""), "cycle": log})
+            a = load_agent(); a["last_run"] = time.time(); a["runs"] = int(a.get("runs", 0)) + 1
+            save_agent(a)
+        except Exception as e:
+            write_agent_report({"agent": ag.get("name"), "ok": False,
+                                "summary": f"erro: {e}", "error": str(e)})
+    threading.Thread(target=_one, daemon=True).start()
+    return {"started": True}
+
+@app.get("/api/agent/memory")
+async def api_agent_memory():
+    mem = load_agent_memory()
+    return {"memory": mem[-200:]}
+
+@app.delete("/api/agent/memory")
+async def api_agent_memory_clear():
+    clear_agent_memory()
+    return {"cleared": True}
+
+@app.get("/api/agent/reports")
+async def api_agent_reports():
+    return {"reports": list_agent_reports()}
+
+@app.get("/api/agent/reports/{rid}")
+async def api_agent_report_get(rid: str):
+    d = load_agent_report(rid)
+    if not d:
+        return JSONResponse({"error": "não encontrado"}, status_code=404)
+    return d
+
+# ═══════════════════════════ Token count (proxy p/ llama-server /tokenize) ═══════════════════════════
+@app.post("/api/tokenize")
+async def api_tokenize(request: Request):
+    body = await request.body()
+    up = CONF["upstreams"]["llm"].rstrip("/") + "/tokenize"
+    try:
+        r = await app.state.client.post(up, content=body,
+                headers={"content-type": "application/json"}, timeout=30)
+        return Response(content=r.content, status_code=r.status_code,
+                        media_type=r.headers.get("content-type"))
+    except httpx.ConnectError:
+        return JSONResponse({"error": "llama-server offline"}, status_code=502)
+
+# ═══════════════════════════ UI ═══════════════════════════
+UI_HTML = r"""<!doctype html><html lang=pt-br><head><meta charset=utf-8>
+<meta name=viewport content="width=device-width,initial-scale=1,viewport-fit=cover"><title>ΩFFΣLLIα</title>
+
+<!-- Assets locais (offline). Substitua por CDN se preferir:
+  https://cdn.jsdelivr.net/npm/marked/marked.min.js
+  https://cdn.jsdelivr.net/npm/katex/dist/katex.min.css
+  https://cdn.jsdelivr.net/npm/katex/dist/katex.min.js
+  https://cdn.jsdelivr.net/npm/katex/dist/contrib/auto-render.min.js
+  https://cdn.jsdelivr.net/gh/highlightjs/cdn-release/build/highlight.min.js
+  https://cdn.jsdelivr.net/gh/highlightjs/cdn-release/build/styles/github-dark.min.css
+-->
+<link rel="stylesheet" href="/static/katex.min.css">
+<link rel="stylesheet" href="/static/github-dark.min.css">
+<script src="/static/marked.min.js"></script>
+<script src="/static/katex.min.js"></script>
+<script src="/static/auto-render.min.js"></script>
+<script src="/static/highlight.min.js"></script>
+<style>
+:root{--bg:#0a0a0f;--panel:#0e0e14;--panel2:#16161d;--bd:#1e1e26;--bd2:#26262e;--fg:#e8e8ea;--mut:#7a7a83;--acc:#6d83ff}
+*{box-sizing:border-box;font-family:system-ui,-apple-system,sans-serif}
+html,body{height:100%}
+body{margin:0;height:100dvh;display:flex;background:var(--bg);color:var(--fg);overflow:hidden}
+.side{width:268px;background:var(--panel);border-right:1px solid var(--bd);padding:16px 12px;display:flex;flex-direction:column;gap:6px;flex:none}
+.side h1{font-size:22px;letter-spacing:1px;margin:6px 8px 14px;
+  background:linear-gradient(90deg,#fff,#9aa7ff);-webkit-background-clip:text;-webkit-text-fill-color:transparent}
+.btn-new{padding:11px 12px;border-radius:10px;cursor:pointer;color:var(--fg);font-size:14px;
+  border:1px solid var(--bd2);background:#13131a;text-align:left}
+.btn-new:hover{background:#1a1a22}
+.seclbl{font-size:11px;letter-spacing:1px;text-transform:uppercase;color:#5a5a63;margin:14px 8px 4px;display:flex;align-items:center;justify-content:space-between}
+.seclbl .add{cursor:pointer;color:#9aa7ff;font-size:15px;line-height:1}
+.seclbl .add:hover{color:#fff}
+.clist{overflow:auto;display:flex;flex-direction:column;gap:3px}
+.clist.chats{flex:1;min-height:60px}
+.clist.personas{max-height:24vh}
+.clist.agentic{max-height:30vh}
+.citem{display:flex;align-items:center;gap:6px;padding:9px 10px;border-radius:9px;cursor:pointer;color:#c7c7cf;font-size:13px}
+.citem:hover{background:#15151d}.citem.active{background:#1c1c26}
+.citem .t{flex:1;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.citem .del{opacity:0;color:#ff6b6b;font-size:15px;flex:none;border:0;background:none;cursor:pointer}
+.citem:hover .del{opacity:.7}.citem .del:hover{opacity:1}
+.citem.persona.active{background:#1c2436;border:1px solid #2c3a5c}
+.citem.agent{background:#161a2c;border:1px solid #2c3a5c}
+.citem.agent.on{background:#16261c;border:1px solid #2c5c3a}
+.citem.agent .dot{width:8px;height:8px;border-radius:50%;background:#777;flex:none}
+.citem.agent.on .dot{background:#4ade80;box-shadow:0 0 8px #4ade80}
+.agent-empty{font-size:12px;color:#6a6a73;padding:6px 10px}
+/* [UPGRADE] pill de saúde do upstream */
+.hpill{display:inline-flex;align-items:center;gap:6px;font-size:11px;color:var(--mut);font-family:ui-monospace,monospace;cursor:default}
+.hpill .hdot{width:8px;height:8px;border-radius:50%;background:#777;transition:background .2s}
+.hpill.on .hdot{background:#4ade80;box-shadow:0 0 6px #4ade80}
+.hpill.off .hdot{background:#ff6b6b}
+.hpill.na .hdot{background:#444}
+.foot{margin-top:auto;border-top:1px solid var(--bd);padding-top:10px}
+.foot a{color:#6a6a73;font-size:12px;text-decoration:none;padding:6px 8px;display:block}
+.foot a:hover{color:#9aa7ff}
+.main{flex:1;display:flex;flex-direction:column;min-width:0;min-height:0}
+.topbar{display:none;align-items:center;gap:10px;padding:10px 12px;border-bottom:1px solid var(--bd);background:var(--panel)}
+.topbar .hamb{width:38px;height:38px;border-radius:9px;border:1px solid var(--bd2);background:#13131a;color:#fff;font-size:18px;cursor:pointer}
+.topbar .tt{font-size:18px;letter-spacing:1px;background:linear-gradient(90deg,#fff,#9aa7ff);-webkit-background-clip:text;-webkit-text-fill-color:transparent}
+.backdrop{display:none;position:fixed;inset:0;background:#0009;z-index:40}
+.hello{flex:1;display:flex;flex-direction:column;align-items:center;justify-content:center;text-align:center;padding:20px}
+.hello h2{font-size:44px;margin:0;background:linear-gradient(90deg,#fff,#9aa7ff);-webkit-background-clip:text;-webkit-text-fill-color:transparent}
+.hello p{color:var(--mut)}
+.personatag{display:none;align-items:center;gap:7px;font-size:12px;color:#9aa7ff;
+  background:#15192a;border:1px solid #2c3a5c;border-radius:9px;padding:7px 12px;margin:10px 12% 0;align-self:flex-start;font-family:ui-monospace,monospace}
+.personatag .clr{cursor:pointer;color:#ff6b6b;font-weight:700}
+#log{flex:1;overflow:auto;padding:28px 12%;display:none;overflow-anchor:none}
+.msg{margin:16px 0;line-height:1.6}.msg.u{text-align:right}
+.bub{display:inline-block;padding:12px 16px;border-radius:14px;max-width:78%;text-align:left;word-wrap:break-word;overflow-wrap:anywhere}
+.u .bub{background:linear-gradient(135deg,#2563eb,#3b4fd6)}
+.a .bub{background:var(--panel2);white-space:normal;max-width:100%}
+.bub p{margin:.4em 0}.bub pre{background:#0c0c12;border:1px solid var(--bd2);border-radius:10px;padding:12px;overflow:auto;position:relative}
+.bub code{font-family:ui-monospace,Menlo,Consolas,monospace;font-size:13.5px}
+.bub :not(pre)>code{background:#0c0c12;padding:2px 6px;border-radius:6px;border:1px solid var(--bd2)}
+.bub table{border-collapse:collapse;margin:.5em 0}.bub th,.bub td{border:1px solid var(--bd2);padding:6px 10px}
+.copybtn{position:absolute;top:6px;right:6px;font-size:11px;padding:3px 8px;border-radius:6px;border:1px solid var(--bd2);background:#16161d;color:#aaa;cursor:pointer;opacity:0;transition:.15s}
+pre:hover .copybtn{opacity:1}
+.respmeta{font-size:11px;color:var(--mut);font-family:ui-monospace,monospace;margin-top:4px}
+.attach{display:inline-flex;align-items:center;gap:6px;background:#1c1c26;border:1px solid var(--bd2);border-radius:8px;padding:5px 9px;font-size:12px;margin:4px 6px 0 0;color:#c7c7cf}
+.attach .x{cursor:pointer;color:#ff6b6b;font-weight:700}
+.bar{padding:12px 12% 18px;border-top:1px solid var(--bd);position:relative}
+.attachrow{display:flex;flex-wrap:wrap;margin-bottom:6px}
+.box{display:flex;gap:10px;background:var(--panel2);border:1px solid var(--bd2);border-radius:18px;padding:11px;align-items:flex-end}
+.plus{width:38px;height:38px;border-radius:50%;border:0;background:#222;color:#fff;font-size:22px;cursor:pointer;flex:none;line-height:1}
+.plus:hover{background:#2c2c36}
+.plus.regen{font-size:18px}
+textarea{flex:1;background:none;border:0;color:#fff;resize:none;font-size:15px;outline:none;max-height:220px;line-height:1.5}
+.send{width:42px;height:42px;border-radius:50%;border:0;background:#fff;color:#000;font-size:18px;cursor:pointer;flex:none}
+.send:disabled{opacity:.4;cursor:default}
+.send[data-mode=stop]{background:#ff6b6b;color:#fff}
+.statusbar{display:flex;gap:18px;justify-content:center;font-size:11px;color:var(--mut);
+  font-family:ui-monospace,monospace;padding:6px 0 0}
+.statusbar b{color:#9aa7ff;font-weight:600}
+.ctxwrap{flex:1;max-width:220px;height:6px;background:#1c1c26;border-radius:4px;overflow:hidden;align-self:center}
+.ctxfill{height:100%;width:0;background:linear-gradient(90deg,#3b4fd6,#6d83ff);transition:width .2s}
+.spin{display:inline-block;width:13px;height:13px;border:2px solid #555;border-top-color:#fff;border-radius:50%;animation:r 1s linear infinite;vertical-align:middle}
+@keyframes r{to{transform:rotate(360deg)}}
+::-webkit-scrollbar{width:9px;height:9px}::-webkit-scrollbar-thumb{background:#2a2a33;border-radius:5px}
+.modal{position:fixed;inset:0;background:#000a;display:none;align-items:center;justify-content:center;z-index:50}
+.modal.open{display:flex}
+.modalcard{background:var(--panel2);border:1px solid var(--bd2);border-radius:16px;padding:24px;width:min(620px,92vw);max-height:90vh;display:flex;flex-direction:column;gap:12px;box-shadow:0 8px 50px #000a;overflow:auto}
+.modalcard h3{margin:0;font-size:20px;background:linear-gradient(90deg,#fff,#9aa7ff);-webkit-background-clip:text;-webkit-text-fill-color:transparent}
+.modalcard label{font-size:12px;color:var(--mut);margin-top:6px}
+.modalcard input,.modalcard textarea,.modalcard select{width:100%;background:#0e0e14;border:1px solid #2a2a33;border-radius:10px;color:#fff;font-size:14px;padding:11px 13px;outline:none}
+.modalcard textarea{resize:vertical;min-height:120px;max-height:40vh;line-height:1.5;font-family:ui-monospace,Menlo,Consolas,monospace}
+.modalrow{display:flex;gap:10px;justify-content:flex-end;margin-top:8px;flex-wrap:wrap}
+.modalrow button{padding:10px 18px;border-radius:10px;font-size:14px;cursor:pointer;border:1px solid var(--bd2)}
+.modalrow .cancel{background:#13131a;color:#c7c7cf}
+.modalrow .save{background:#fff;color:#000;font-weight:600;border:0}
+.modalrow .save:disabled{opacity:.4;cursor:default}
+.modalrow .danger{background:#2a1414;color:#ff8a8a;border:1px solid #4a2222}
+.grid2{display:grid;grid-template-columns:1fr 1fr;gap:10px}
+.chips{display:flex;flex-wrap:wrap;gap:8px}
+.chip{display:flex;align-items:center;gap:7px;background:#0e0e14;border:1px solid #2a2a33;border-radius:9px;padding:8px 11px;font-size:13px;cursor:pointer;user-select:none}
+.chip input{width:auto;margin:0}
+.tabs{display:flex;gap:6px;border-bottom:1px solid var(--bd2);margin-bottom:4px}
+.tab{padding:8px 12px;font-size:13px;color:var(--mut);cursor:pointer;border-bottom:2px solid transparent}
+.tab.active{color:#fff;border-bottom-color:var(--acc)}
+.tabpane{display:none}.tabpane.active{display:block}
+.logbox{background:#0c0c12;border:1px solid var(--bd2);border-radius:10px;padding:10px;font-family:ui-monospace,monospace;font-size:12px;max-height:46vh;overflow:auto;white-space:pre-wrap;word-break:break-word}
+.repitem{padding:8px 10px;border:1px solid var(--bd2);border-radius:9px;margin-bottom:6px;cursor:pointer;font-size:12.5px}
+.repitem:hover{background:#15151d}
+.repok{color:#4ade80}.reperr{color:#ff8a8a}
+.hint{font-size:11px;color:#6a6a73;margin-top:2px}
+
+/* ===== Responsivo: PC vs Smartphone ===== */
+@media (min-width:861px){
+  .side{position:relative !important;transform:none !important}
+}
+@media (max-width:860px){
+  body{flex-direction:column}
+  .topbar{display:flex}
+  .side{position:fixed;top:0;left:0;height:100dvh;width:84vw;max-width:320px;z-index:45;
+        transform:translateX(-105%);transition:transform .22s ease;box-shadow:0 0 40px #000a}
+  .side.open{transform:translateX(0)}
+  .backdrop.open{display:block}
+  .main{width:100%}
+  #log{padding:16px 14px}
+  .bub{max-width:90%}
+  .personatag{margin:10px 14px 0}
+  .bar{padding:10px 12px calc(12px + env(safe-area-inset-bottom))}
+  .hello h2{font-size:34px}
+  .statusbar{gap:12px;flex-wrap:wrap}
+  .grid2{grid-template-columns:1fr}
+  .modalcard{width:94vw;border-radius:16px;padding:18px;max-height:92dvh}
+  .modalcard textarea{max-height:30vh}
+}
+</style></head><body>
+<div class=backdrop id=backdrop onclick="closeSidebar()"></div>
+<div class=side id=sidebar>
+  <h1>ΩFFΣLLIα</h1>
+  <button class=btn-new onclick="newChat()">✎ Nova conversa</button>
+  <div class=seclbl>Conversas</div>
+  <div class="clist chats" id=clist></div>
+  <div class=seclbl>Agêntica <span class=add title="Criar/Configurar agente" onclick="openAgentModal()">⚙</span></div>
+  <div class="clist agentic" id=alist></div>
+  <div class=seclbl>Personas <span class=add title="Nova persona" onclick="openPersonaModal()">＋</span></div>
+  <div class="clist personas" id=plist></div>
+  <div class=foot>
+    <!-- [UPGRADE] saúde do upstream LLM (:8080) -->
+    <div class=statusbar id=healthbar style="justify-content:flex-start;gap:12px;padding:2px 8px 6px">
+      <span class="hpill na" id=hpill-llm><span class=hdot></span> LLM :8080</span>
+    </div>
+    <div class=statusbar style="justify-content:flex-start;gap:8px;padding:0 8px 6px">
+      <span>ctx <b id=ctxnum>0</b>/<span id=ctxmax>0</span></span>
+    </div>
+    <div class=ctxwrap style="max-width:none;margin:0 8px 8px"><div class=ctxfill id=ctxfill></div></div>
+    <a href="javascript:void(0)" onclick="exportChat()">⤓ Exportar conversa (.md)</a>
+    <a href=/logout>⤿ Sair</a>
+  </div>
+</div>
+<div class=main>
+  <div class=topbar>
+    <button class=hamb onclick="openSidebar()">☰</button>
+    <div class=tt>ΩFFΣLLIα</div>
+  </div>
+  <div class=hello id=hello><h2>Hello there</h2><p>Converse, cole código ou injete um .txt / .pdf com o botão +</p></div>
+  <div class=personatag id=personatag><span>● Persona Ativa: <b id=personatagname></b></span><span class=clr title="Remover persona desta conversa" onclick="clearPersona()">✕</span></div>
+  <div id=log></div>
+  <div class=bar>
+    <div class=statusbar id=livebar style="display:none">
+      <span><b id=tpsLive>0</b> tok/s</span>
+      <span><b id=tokLive>0</b> tokens</span>
+      <span><b id=timeLive>0.0</b>s</span>
+    </div>
+    <div class=attachrow id=attachrow></div>
+    <div class=box>
+      <button class=plus onclick="document.getElementById('fileinp').click()" title="Injetar .txt / .pdf">+</button>
+      <!-- [UPGRADE] regenerar última resposta -->
+      <button class="plus regen" id=regenbtn onclick="regen()" title="Regenerar última resposta" style="display:none">↻</button>
+      <input type=file id=fileinp accept=".txt,.md,.pdf,text/plain,application/pdf" multiple style=display:none>
+      <textarea id=inp rows=1 placeholder="Digite uma mensagem..."
+        onkeydown="if(event.key==='Enter'&&!event.shiftKey){event.preventDefault();go()}"
+        oninput="autoGrow(this)"></textarea>
+      <!-- [UPGRADE] botão enviar/parar -->
+      <button class=send id=sendbtn onclick=sendClick() title="Enviar">↑</button>
+    </div>
+  </div>
+</div>
+
+<!-- Modal criar persona -->
+<div class=modal id=personamodal>
+  <div class=modalcard>
+    <h3>Nova Persona</h3>
+    <label>Título Persona</label>
+    <input id=pmtitle placeholder="Ex.: Revisor de código sênior" oninput="pmValidate()">
+    <label>Descrição Persona ativa:</label>
+    <textarea id=pmdesc placeholder="Descreva o comportamento, tom, regras e identidade da persona. Sem limite de caracteres." oninput="pmValidate()"></textarea>
+    <div class=modalrow>
+      <button class=cancel onclick="closePersonaModal()">Cancelar</button>
+      <button class=save id=pmsave onclick="savePersona()" disabled>Salvar</button>
+    </div>
+  </div>
+</div>
+
+<!-- Modal Agêntica -->
+<div class=modal id=agentmodal>
+  <div class=modalcard>
+    <h3>Agêntica — Agente Único</h3>
+    <div class=tabs>
+      <div class="tab active" data-tab=cfg onclick="agentTab('cfg')">Configuração</div>
+      <div class=tab data-tab=mem onclick="agentTab('mem')">Memória</div>
+      <div class=tab data-tab=rep onclick="agentTab('rep')">Relatórios</div>
+    </div>
+
+    <div class="tabpane active" id=tab-cfg>
+      <div class=grid2>
+        <div><label>Nome do agente</label>
+          <input id=agname placeholder="Ex.: Sentinela" oninput="agValidate()"></div>
+        <div><label>Intervalo de ação (segundos)</label>
+          <input id=aginterval type=number min=5 value=300></div>
+      </div>
+      <label>Função / Objetivo (o que ele deve fazer)</label>
+      <textarea id=agfunction placeholder="Descreva a missão real do agente: o que monitorar, o que produzir, regras, limites..." oninput="agValidate()"></textarea>
+
+      <label>Ações reais permitidas</label>
+      <div class=chips id=agactions>
+        <label class=chip><input type=checkbox data-act=shell> Shell</label>
+        <label class=chip><input type=checkbox data-act=python> Python</label>
+        <label class=chip><input type=checkbox data-act=http> HTTP</label>
+        <label class=chip><input type=checkbox data-act=file_write> Escrever arquivo</label>
+        <label class=chip><input type=checkbox data-act=llm checked> Raciocínio (LLM)</label>
+      </div>
+
+      <div class=grid2>
+        <div><label>Passos por ciclo</label><input id=agmaxsteps type=number min=1 value=4></div>
+        <div><label>Janela de memória (entradas)</label><input id=agmemwin type=number min=0 value=40></div>
+      </div>
+      <div class=grid2>
+        <div><label>Autonomia</label>
+          <select id=agautonomy>
+            <option value=supervised>Supervisionado</option>
+            <option value=autonomous>Autônomo</option>
+          </select></div>
+        <div><label>Temperatura</label><input id=agtemp type=number step=0.1 min=0 max=2 value=0.4></div>
+      </div>
+      <div class=grid2>
+        <div><label>Modelo (opcional)</label><input id=agmodel placeholder="deixe vazio p/ padrão do llama-server"></div>
+        <div><label>Workspace (pasta de trabalho)</label><input id=agworkdir placeholder="auto"></div>
+      </div>
+
+      <label class=chip style="margin-top:8px"><input type=checkbox id=agallowroot onchange="agRootToggle()"> Permitir agir em todo o sistema (root)</label>
+      <div id=agrootbox style="display:none">
+        <label>Senha root (mantida só em memória, nunca gravada em disco)</label>
+        <input id=agrootpw type=password placeholder="senha sudo/root">
+        <div class=hint id=agrootstatus>root não armado</div>
+      </div>
+
+      <div class=modalrow>
+        <button class=danger id=agdelete onclick="deleteAgent()" style="display:none">Excluir agente</button>
+        <button class=cancel onclick="closeAgentModal()">Fechar</button>
+        <button class=save id=agtoggle onclick="toggleAgent()" style="display:none">Ativar</button>
+        <button class=save id=agrunnow onclick="runAgentNow()" style="display:none">Rodar agora</button>
+        <button class=save id=agsave onclick="saveAgent()" disabled>Salvar</button>
+      </div>
+      <div class=hint id=aginfo></div>
+    </div>
+
+    <div class=tabpane id=tab-mem>
+      <div class=modalrow style="justify-content:space-between">
+        <span class=hint>Memória própria persistente (tempo real)</span>
+        <button class=danger onclick="clearAgentMemory()">Limpar memória</button>
+      </div>
+      <div class=logbox id=agmemview>(vazia)</div>
+    </div>
+
+    <div class=tabpane id=tab-rep>
+      <div class=hint>Relatórios gerados a cada ação (pasta dedicada)</div>
+      <div id=agreplist></div>
+      <div class=logbox id=agrepview style="display:none"></div>
+    </div>
+  </div>
+</div>
+
+<script>
+// ---------- libs com fallback ----------
+const MD=(typeof marked!=='undefined')?(t)=>marked.parse(t,{breaks:true,gfm:true}):(t)=>esc(t);
+function esc(s){const d=document.createElement('div');d.textContent=s;return d.innerHTML;}
+if(typeof marked!=='undefined'){
+  marked.setOptions({highlight:function(code,lang){
+    try{ if(typeof hljs!=='undefined'){
+      return lang&&hljs.getLanguage(lang)?hljs.highlight(code,{language:lang}).value:hljs.highlightAuto(code).value;
+    }}catch(e){} return esc(code);
+  }});
+}
+function renderMath(el){
+  if(typeof renderMathInElement==='undefined')return;
+  try{renderMathInElement(el,{delimiters:[
+    {left:'$$',right:'$$',display:true},{left:'\\[',right:'\\]',display:true},
+    {left:'$',right:'$',display:false},{left:'\\(',right:'\\)',display:false}],
+    throwOnError:false});}catch(e){}
+}
+function decorate(el){
+  el.querySelectorAll('pre code').forEach(c=>{
+    try{if(typeof hljs!=='undefined')hljs.highlightElement(c);}catch(e){}
+    const pre=c.parentElement;
+    if(!pre.querySelector('.copybtn')){
+      const b=document.createElement('button');b.className='copybtn';b.textContent='copiar';
+      b.onclick=()=>{navigator.clipboard.writeText(c.textContent);b.textContent='copiado!';setTimeout(()=>b.textContent='copiar',1200);};
+      pre.appendChild(b);
+    }
+  });
+  renderMath(el);
+}
+
+// ---------- responsivo / sidebar ----------
+function openSidebar(){document.getElementById('sidebar').classList.add('open');document.getElementById('backdrop').classList.add('open');}
+function closeSidebar(){document.getElementById('sidebar').classList.remove('open');document.getElementById('backdrop').classList.remove('open');}
+function isMobile(){return window.matchMedia('(max-width:860px)').matches;}
+function maybeCloseSidebar(){if(isMobile())closeSidebar();}
+
+// ---------- estado ----------
+let hist=[];               // [{role,content}]
+let attachments=[];        // [{name,text}]
+let currentId=null;
+let N_CTX=32768;
+let busy=false;
+let activePersona=null;    // {id,title,description} ou null
+let agentState=null;       // estado do agente
+let abortCtrl=null;        // [UPGRADE] controle de aborto do stream
+
+fetch('/api/config').then(r=>r.json()).then(c=>{N_CTX=c.n_ctx||32768;
+  document.getElementById('ctxmax').textContent=N_CTX;updateCtxBar();});
+
+function autoGrow(t){t.style.height='auto';t.style.height=Math.min(t.scrollHeight,220)+'px';}
+function uid(){return Date.now().toString(36)+Math.random().toString(36).slice(2,7);}
+
+// ---------- [UPGRADE] saúde do upstream ----------
+function setPill(id,st){
+  const el=document.getElementById(id);if(!el)return;
+  if(!st||!st.configured){el.className='hpill na';el.title='não configurado';return;}
+  const on=!!st.online;
+  el.className='hpill '+(on?'on':'off');
+  el.title=(st.url||'')+' — '+(on?'online':('offline'+(st.status?(' ('+st.status+')'):'')));
+}
+async function refreshHealth(){
+  try{
+    const r=await fetch('/api/health');const j=await r.json();
+    setPill('hpill-llm',j.llm);
+  }catch(e){setPill('hpill-llm',null);}
+}
+
+// ---------- [UPGRADE] enviar / parar ----------
+function setBusyUI(b){
+  busy=b;
+  const btn=document.getElementById('sendbtn');
+  if(b){btn.disabled=false;btn.textContent='■';btn.dataset.mode='stop';btn.title='Parar geração';}
+  else{btn.disabled=false;btn.textContent='↑';btn.dataset.mode='';btn.title='Enviar';}
+  updateRegen();
+}
+function sendClick(){
+  const b=document.getElementById('sendbtn');
+  if(b.dataset.mode==='stop'){stopGen();}else{go();}
+}
+function stopGen(){if(abortCtrl){try{abortCtrl.abort();}catch(e){}}}
+
+// ---------- [UPGRADE] regenerar ----------
+function updateRegen(){
+  const b=document.getElementById('regenbtn');
+  const show=!busy&&hist.length&&hist[hist.length-1].role==='assistant';
+  b.style.display=show?'inline-flex':'none';
+}
+async function regen(){
+  if(busy)return;
+  if(!(hist.length&&hist[hist.length-1].role==='assistant'))return;
+  hist.pop();
+  const log=document.getElementById('log');
+  const msgs=log.querySelectorAll('.msg.a');
+  if(msgs.length)msgs[msgs.length-1].remove();
+  await stream();
+}
+
+// ---------- [UPGRADE] exportar conversa em markdown ----------
+function exportChat(){
+  if(!hist.length){alert('Conversa vazia.');return;}
+  const titleEl=document.querySelector('#clist .citem.active .t');
+  const title=titleEl?titleEl.textContent:'Conversa';
+  let md='# '+title+'\n\n';
+  if(activePersona)md+='> Persona: '+activePersona.title+'\n\n';
+  hist.forEach(m=>{
+    md+=(m.role==='user'?'## 🧑 Usuário\n\n':'## 🤖 '+(activePersona?activePersona.title:'Assistente')+'\n\n');
+    md+=m.content+'\n\n';
+  });
+  const blob=new Blob([md],{type:'text/markdown;charset=utf-8'});
+  const a=document.createElement('a');
+  a.href=URL.createObjectURL(blob);
+  a.download=(currentId||'conversa')+'.md';
+  document.body.appendChild(a);a.click();a.remove();
+  setTimeout(()=>URL.revokeObjectURL(a.href),2000);
+  maybeCloseSidebar();
+}
+
+// ---------- contexto (token count em tempo real) ----------
+async function countTokens(text){
+  try{const r=await fetch('/api/tokenize',{method:'POST',headers:{'Content-Type':'application/json'},
+    body:JSON.stringify({content:text})});
+    const j=await r.json();
+    if(Array.isArray(j.tokens))return j.tokens.length;
+  }catch(e){}
+  return Math.ceil((text||'').length/4); // fallback aproximado
+}
+async function updateCtxBar(){
+  const personaTxt=activePersona?activePersona.description:'';
+  const blob=personaTxt+'\n'+hist.map(m=>m.content).join('\n')+attachments.map(a=>a.text).join('\n');
+  const n=await countTokens(blob);
+  document.getElementById('ctxnum').textContent=n;
+  const pct=Math.min(100,Math.round(n/N_CTX*100));
+  document.getElementById('ctxfill').style.width=pct+'%';
+}
+
+// ---------- persona ativa (UI) ----------
+function renderPersonaTag(){
+  const tag=document.getElementById('personatag');
+  if(activePersona){
+    document.getElementById('personatagname').textContent=activePersona.title;
+    tag.style.display='flex';
+  }else{
+    tag.style.display='none';
+  }
+  refreshPersonas();
+}
+async function activatePersona(id){
+  const r=await fetch('/api/personas/'+id);if(!r.ok)return;
+  activePersona=await r.json();
+  renderPersonaTag();
+  updateCtxBar();
+  persist();
+  maybeCloseSidebar();
+}
+function clearPersona(){
+  activePersona=null;
+  renderPersonaTag();
+  updateCtxBar();
+  persist();
+}
+
+// ---------- sidebar / conversas ----------
+async function refreshChats(){
+  const r=await fetch('/api/chats');const j=await r.json();
+  const c=document.getElementById('clist');c.innerHTML='';
+  (j.chats||[]).forEach(ch=>{
+    const d=document.createElement('div');d.className='citem'+(ch.id===currentId?' active':'');
+    d.innerHTML='<span class=t></span><button class=del title=Excluir>✕</button>';
+    d.querySelector('.t').textContent=ch.title;
+    d.querySelector('.t').onclick=()=>openChat(ch.id);
+    d.querySelector('.del').onclick=(e)=>{e.stopPropagation();delChat(ch.id);};
+    c.appendChild(d);
+  });
+}
+async function openChat(id){
+  const r=await fetch('/api/chats/'+id);if(!r.ok)return;
+  const d=await r.json();currentId=d.id;hist=d.messages||[];attachments=[];
+  // restaura persona da conversa, se houver
+  activePersona=null;
+  if(d.persona_id){
+    try{const pr=await fetch('/api/personas/'+d.persona_id);
+      if(pr.ok)activePersona=await pr.json();}catch(e){}
+  }
+  renderAttachments();renderPersonaTag();document.getElementById('log').innerHTML='';
+  document.getElementById('hello').style.display='none';
+  document.getElementById('log').style.display='block';
+  hist.forEach(m=>renderMsg(m.role,m.content));
+  refreshChats();updateCtxBar();updateRegen();maybeCloseSidebar();
+}
+async function delChat(id){
+  if(!confirm('Excluir esta conversa?'))return;
+  await fetch('/api/chats/'+id,{method:'DELETE'});
+  if(id===currentId)newChat();
+  refreshChats();
+}
+async function persist(){
+  if(!currentId)currentId=uid();
+  let title=hist.find(m=>m.role==='user');
+  title=title?title.content.slice(0,60):'Nova conversa';
+  await fetch('/api/chats/'+currentId,{method:'POST',headers:{'Content-Type':'application/json'},
+    body:JSON.stringify({title,messages:hist,persona_id:activePersona?activePersona.id:null})});
+  refreshChats();
+}
+function newChat(){
+  hist=[];attachments=[];currentId=null;activePersona=null;
+  renderAttachments();renderPersonaTag();
+  document.getElementById('log').innerHTML='';
+  document.getElementById('log').style.display='none';
+  document.getElementById('hello').style.display='flex';
+  refreshChats();updateCtxBar();updateRegen();maybeCloseSidebar();
+}
+
+// ---------- sidebar / personas ----------
+async function refreshPersonas(){
+  const r=await fetch('/api/personas');const j=await r.json();
+  const c=document.getElementById('plist');c.innerHTML='';
+  (j.personas||[]).forEach(p=>{
+    const act=activePersona&&p.id===activePersona.id;
+    const d=document.createElement('div');d.className='citem persona'+(act?' active':'');
+    d.innerHTML='<span class=t></span><button class=del title=Excluir>✕</button>';
+    d.querySelector('.t').textContent=p.title;
+    d.querySelector('.t').onclick=()=>activatePersona(p.id);
+    d.querySelector('.del').onclick=(e)=>{e.stopPropagation();delPersona(p.id);};
+    c.appendChild(d);
+  });
+}
+async function delPersona(id){
+  if(!confirm('Excluir esta persona?'))return;
+  await fetch('/api/personas/'+id,{method:'DELETE'});
+  if(activePersona&&activePersona.id===id)clearPersona();
+  refreshPersonas();
+}
+
+// ---------- sidebar / agêntica ----------
+async function refreshAgent(){
+  const r=await fetch('/api/agent');const j=await r.json();agentState=j;
+  const c=document.getElementById('alist');c.innerHTML='';
+  if(j&&j.exists){
+    const on=j.enabled&&j.running;
+    const d=document.createElement('div');
+    d.className='citem agent'+(on?' on':'');
+    d.innerHTML='<span class=dot></span><span class=t></span><button class=del title=Excluir>✕</button>';
+    d.querySelector('.t').textContent=j.name||'Agente';
+    d.querySelector('.t').onclick=()=>openAgentModal();
+    d.querySelector('.del').onclick=(e)=>{e.stopPropagation();deleteAgent();};
+    c.appendChild(d);
+  }else{
+    const e=document.createElement('div');e.className='agent-empty';
+    e.textContent='Nenhum agente. Clique em ⚙ para criar.';
+    c.appendChild(e);
+  }
+}
+
+// ---------- modal persona ----------
+function openPersonaModal(){
+  document.getElementById('pmtitle').value='';
+  document.getElementById('pmdesc').value='';
+  document.getElementById('pmsave').disabled=true;
+  document.getElementById('personamodal').classList.add('open');
+  setTimeout(()=>document.getElementById('pmtitle').focus(),50);
+}
+function closePersonaModal(){
+  document.getElementById('personamodal').classList.remove('open');
+}
+function pmValidate(){
+  const t=document.getElementById('pmtitle').value.trim();
+  const d=document.getElementById('pmdesc').value.trim();
+  document.getElementById('pmsave').disabled=!(t&&d);
+}
+async function savePersona(){
+  const title=document.getElementById('pmtitle').value.trim();
+  const description=document.getElementById('pmdesc').value;
+  if(!title||!description.trim())return;
+  const id=uid();
+  await fetch('/api/personas/'+id,{method:'POST',headers:{'Content-Type':'application/json'},
+    body:JSON.stringify({title,description})});
+  closePersonaModal();
+  refreshPersonas();
+}
+document.getElementById('personamodal').addEventListener('click',(e)=>{
+  if(e.target.id==='personamodal')closePersonaModal();
+});
+
+// ---------- modal agêntica ----------
+function agentTab(name){
+  document.querySelectorAll('#agentmodal .tab').forEach(t=>t.classList.toggle('active',t.dataset.tab===name));
+  document.querySelectorAll('#agentmodal .tabpane').forEach(p=>p.classList.remove('active'));
+  document.getElementById('tab-'+name).classList.add('active');
+  if(name==='mem')loadAgentMemory();
+  if(name==='rep')loadAgentReports();
+}
+function agValidate(){
+  const n=document.getElementById('agname').value.trim();
+  const f=document.getElementById('agfunction').value.trim();
+  document.getElementById('agsave').disabled=!(n&&f);
+}
+function agRootToggle(){
+  const on=document.getElementById('agallowroot').checked;
+  document.getElementById('agrootbox').style.display=on?'block':'none';
+}
+function fillAgentForm(a){
+  document.getElementById('agname').value=a.name||'';
+  document.getElementById('aginterval').value=a.interval||300;
+  document.getElementById('agfunction').value=a.function||'';
+  document.querySelectorAll('#agactions input[data-act]').forEach(cb=>{
+    cb.checked=!!(a.actions&&a.actions[cb.dataset.act]);
+  });
+  document.getElementById('agmaxsteps').value=a.max_steps||4;
+  document.getElementById('agmemwin').value=(a.memory_window!=null?a.memory_window:40);
+  document.getElementById('agautonomy').value=a.autonomy||'supervised';
+  document.getElementById('agtemp').value=(a.temperature!=null?a.temperature:0.4);
+  document.getElementById('agmodel').value=a.model||'';
+  document.getElementById('agworkdir').value=a.workdir||'';
+  document.getElementById('agallowroot').checked=!!a.allow_root;
+  agRootToggle();
+  document.getElementById('agrootstatus').textContent=a.root_armed?'root ARMADO (em memória)':'root não armado';
+}
+function updateAgentButtons(a){
+  const exists=a&&a.exists;
+  document.getElementById('agdelete').style.display=exists?'inline-block':'none';
+  document.getElementById('agrunnow').style.display=exists?'inline-block':'none';
+  const tg=document.getElementById('agtoggle');
+  tg.style.display=exists?'inline-block':'none';
+  if(exists){
+    const on=a.enabled&&a.running;
+    tg.textContent=on?'Desativar':'Ativar';
+  }
+  let info='';
+  if(exists){
+    info='Criado · execuções: '+(a.runs||0);
+    if(a.last_run)info+=' · última: '+new Date(a.last_run*1000).toLocaleString();
+    info+=' · estado: '+((a.enabled&&a.running)?'ATIVO em segundo plano':'parado');
+  }
+  document.getElementById('aginfo').textContent=info;
+}
+async function openAgentModal(){
+  const r=await fetch('/api/agent');const a=await r.json();agentState=a;
+  fillAgentForm(a);updateAgentButtons(a);agValidate();
+  agentTab('cfg');
+  document.getElementById('agentmodal').classList.add('open');
+  maybeCloseSidebar();
+}
+function closeAgentModal(){document.getElementById('agentmodal').classList.remove('open');}
+document.getElementById('agentmodal').addEventListener('click',(e)=>{
+  if(e.target.id==='agentmodal')closeAgentModal();
+});
+function collectActions(){
+  const o={};
+  document.querySelectorAll('#agactions input[data-act]').forEach(cb=>{o[cb.dataset.act]=cb.checked;});
+  return o;
+}
+async function saveAgent(){
+  const allowRoot=document.getElementById('agallowroot').checked;
+  const body={
+    name:document.getElementById('agname').value.trim(),
+    function:document.getElementById('agfunction').value,
+    interval:parseInt(document.getElementById('aginterval').value)||300,
+    actions:collectActions(),
+    max_steps:parseInt(document.getElementById('agmaxsteps').value)||4,
+    memory_window:parseInt(document.getElementById('agmemwin').value)||0,
+    autonomy:document.getElementById('agautonomy').value,
+    temperature:parseFloat(document.getElementById('agtemp').value)||0.4,
+    model:document.getElementById('agmodel').value.trim(),
+    workdir:document.getElementById('agworkdir').value.trim(),
+    allow_root:allowRoot
+  };
+  const r=await fetch('/api/agent',{method:'POST',headers:{'Content-Type':'application/json'},
+    body:JSON.stringify(body)});
+  let a=await r.json();
+  // arma/desarma senha root
+  if(allowRoot){
+    const pw=document.getElementById('agrootpw').value;
+    if(pw){
+      const rr=await fetch('/api/agent/root',{method:'POST',headers:{'Content-Type':'application/json'},
+        body:JSON.stringify({password:pw})});
+      const j=await rr.json();a.root_armed=!!j.root_armed;
+    }
+  }else{
+    await fetch('/api/agent/root',{method:'POST',headers:{'Content-Type':'application/json'},
+      body:JSON.stringify({clear:true})});
+    a.root_armed=false;
+  }
+  agentState=a;fillAgentForm(a);updateAgentButtons(a);refreshAgent();
+}
+async function toggleAgent(){
+  const a=agentState||{};
+  const on=a.enabled&&a.running;
+  const r=await fetch('/api/agent/enable',{method:'POST',headers:{'Content-Type':'application/json'},
+    body:JSON.stringify({enabled:!on})});
+  const j=await r.json();agentState=j;updateAgentButtons(j);refreshAgent();
+}
+async function runAgentNow(){
+  await fetch('/api/agent/run',{method:'POST'});
+  document.getElementById('aginfo').textContent='Ciclo disparado em segundo plano...';
+  setTimeout(()=>{loadAgentReports();},1500);
+}
+async function deleteAgent(){
+  if(!confirm('Excluir o agente? Isso para a execução e zera a configuração.'))return;
+  await fetch('/api/agent',{method:'DELETE'});
+  closeAgentModal();refreshAgent();
+}
+async function loadAgentMemory(){
+  const r=await fetch('/api/agent/memory');const j=await r.json();
+  const box=document.getElementById('agmemview');
+  const mem=j.memory||[];
+  if(!mem.length){box.textContent='(vazia)';return;}
+  box.textContent=mem.map(m=>{
+    const t=new Date((m.ts||0)*1000).toLocaleString();
+    return '['+t+'] '+(m.kind||'')+': '+JSON.stringify(m.data!==undefined?m.data:m);
+  }).join('\n');
+  box.scrollTop=box.scrollHeight;
+}
+async function clearAgentMemory(){
+  if(!confirm('Limpar toda a memória do agente?'))return;
+  await fetch('/api/agent/memory',{method:'DELETE'});
+  loadAgentMemory();
+}
+async function loadAgentReports(){
+  const r=await fetch('/api/agent/reports');const j=await r.json();
+  const list=document.getElementById('agreplist');list.innerHTML='';
+  document.getElementById('agrepview').style.display='none';
+  (j.reports||[]).forEach(rep=>{
+    const d=document.createElement('div');d.className='repitem';
+    const t=new Date((rep.ts||0)*1000).toLocaleString();
+    d.innerHTML='<span class="'+(rep.ok?'repok':'reperr')+'">'+(rep.ok?'✓':'✕')+'</span> '+
+      esc(t)+' — '+esc(rep.summary||'(sem resumo)');
+    d.onclick=()=>openReport(rep.id);
+    list.appendChild(d);
+  });
+  if(!(j.reports||[]).length)list.innerHTML='<div class=hint>Nenhum relatório ainda.</div>';
+}
+async function openReport(rid){
+  const r=await fetch('/api/agent/reports/'+rid);if(!r.ok)return;
+  const j=await r.json();
+  const v=document.getElementById('agrepview');
+  v.style.display='block';
+  v.textContent=JSON.stringify(j,null,2);
+  v.scrollTop=0;
+}
+
+// ---------- anexos ----------
+document.getElementById('fileinp').addEventListener('change',async(e)=>{
+  for(const f of e.target.files){
+    const fd=new FormData();fd.append('file',f);
+    const ph={name:f.name,text:'',loading:true};attachments.push(ph);renderAttachments();
+    try{const r=await fetch('/api/extract',{method:'POST',body:fd});const j=await r.json();
+      ph.text=j.text||'';ph.chars=j.chars||0;ph.loading=false;
+    }catch(err){ph.text='';ph.loading=false;ph.err=true;}
+    renderAttachments();updateCtxBar();
+  }
+  e.target.value='';
+});
+function renderAttachments(){
+  const row=document.getElementById('attachrow');row.innerHTML='';
+  attachments.forEach((a,i)=>{
+    const d=document.createElement('span');d.className='attach';
+    d.innerHTML=(a.loading?'<span class=spin></span> ':'📄 ')+esc(a.name)+
+      (a.chars?(' · '+a.chars+' ch'):'')+' <span class=x>✕</span>';
+    d.querySelector('.x').onclick=()=>{attachments.splice(i,1);renderAttachments();updateCtxBar();};
+    row.appendChild(d);
+  });
+}
+
+// ---------- render de mensagens ----------
+function renderMsg(role,txt){
+  const l=document.getElementById('log');
+  document.getElementById('hello').style.display='none';l.style.display='block';
+  const d=document.createElement('div');d.className='msg '+(role==='user'?'u':'a');
+  const bub=document.createElement('span');bub.className='bub';
+  if(role==='user'){bub.textContent=txt;}else{bub.innerHTML=MD(txt);decorate(bub);}
+  d.appendChild(bub);l.appendChild(d);l.scrollTo({top:l.scrollHeight});
+  return bub;
+}
+
+// ---------- envio ----------
+async function go(){
+  if(busy)return;
+  const inp=document.getElementById('inp');let t=inp.value.trim();
+  if(!t&&attachments.length===0)return;
+
+  // monta conteúdo com anexos injetados
+  let full=t;
+  if(attachments.length){
+    const docs=attachments.map(a=>`\n\n[DOCUMENTO: ${a.name}]\n${a.text}\n[FIM DO DOCUMENTO]`).join('');
+    full=(t?t+'\n':'')+docs;
+  }
+  const displayText=t+(attachments.length?('\n\n'+attachments.map(a=>'📄 '+a.name).join('\n')):'');
+  inp.value='';autoGrow(inp);
+  renderMsg('user',displayText);
+  hist.push({role:'user',content:full});
+  attachments=[];renderAttachments();
+  await stream();
+}
+
+async function stream(){
+  setBusyUI(true);   // [UPGRADE] entra em modo "parar"
+  const bub=renderMsg('assistant','');
+  const live=document.getElementById('livebar');live.style.display='flex';
+  document.getElementById('tpsLive').textContent='0';
+  document.getElementById('tokLive').textContent='0';
+  document.getElementById('timeLive').textContent='0.0';
+
+  let acc='',tokCount=0,t0=performance.now(),firstTok=null,raf=null,aborted=false;
+  function tick(){
+    const el=(performance.now()-t0)/1000;
+    document.getElementById('timeLive').textContent=el.toFixed(1);
+    const genT=firstTok?(performance.now()-firstTok)/1000:0;
+    const tps=genT>0?(tokCount/genT):0;
+    document.getElementById('tpsLive').textContent=tps.toFixed(1);
+    document.getElementById('tokLive').textContent=tokCount;
+    raf=requestAnimationFrame(tick);
+  }
+  raf=requestAnimationFrame(tick);
+
+  // injeta persona ativa como system prompt (não exibida na tela)
+  const outMsgs = activePersona
+    ? [{role:'system',content:activePersona.description}, ...hist]
+    : hist;
+
+  let usage=null;
+  try{
+    abortCtrl=new AbortController();   // [UPGRADE]
+    const r=await fetch('/v1/chat/completions',{method:'POST',
+      headers:{'Content-Type':'application/json'},
+      body:JSON.stringify({messages:outMsgs,stream:true,cache_prompt:true}),
+      signal:abortCtrl.signal});
+    if(!r.ok){const e=await r.json().catch(()=>({}));bub.innerHTML='⚠ '+(e.error||r.status);}
+    else{
+      const rd=r.body.getReader();const dec=new TextDecoder();let buf='';
+      while(true){const{done,value}=await rd.read();if(done)break;
+        buf+=dec.decode(value,{stream:true});
+        let idx;while((idx=buf.indexOf('\n'))>=0){
+          const line=buf.slice(0,idx);buf=buf.slice(idx+1);
+          if(!line.startsWith('data:'))continue;
+          const p=line.slice(5).trim();if(p==='[DONE]')continue;
+          try{const j=JSON.parse(p);
+            const c=j.choices?.[0]?.delta?.content;
+            if(c){if(firstTok===null)firstTok=performance.now();acc+=c;tokCount++;
+              bub.innerHTML=MD(acc);
+              {const _l=document.getElementById('log');_l.scrollTo({top:_l.scrollHeight});}}
+            if(j.usage)usage=j.usage;
+            if(j.timings)usage={...(usage||{}),timings:j.timings};
+          }catch(e){}
+        }
+      }
+      decorate(bub);
+    }
+  }catch(e){
+    if(e&&e.name==='AbortError'){   // [UPGRADE] aborto limpo: preserva parcial
+      aborted=true;
+      bub.innerHTML=MD(acc||'_(sem conteúdo)_');decorate(bub);
+    }else{
+      bub.innerHTML='⚠ '+e;
+    }
+  }finally{
+    abortCtrl=null;
+  }
+
+  cancelAnimationFrame(raf);
+  const elapsed=(performance.now()-t0)/1000;
+  const genT=firstTok?(performance.now()-firstTok)/1000:elapsed;
+  // métricas finais: usa contagem do servidor se disponível
+  let outTok=tokCount, tps=genT>0?tokCount/genT:0;
+  if(usage){
+    if(usage.completion_tokens)outTok=usage.completion_tokens;
+    if(usage.timings&&usage.timings.predicted_per_second)tps=usage.timings.predicted_per_second;
+  }
+  document.getElementById('livebar').style.display='none';
+  const meta=document.createElement('div');meta.className='respmeta';
+  meta.textContent=(aborted?'⏹ interrompido · ':'✓ ')+outTok+' tokens · '+tps.toFixed(1)+' tok/s · '+elapsed.toFixed(2)+'s';
+  bub.parentElement.appendChild(meta);
+
+  hist.push({role:'assistant',content:acc});
+  setBusyUI(false);   // [UPGRADE] volta para modo "enviar"
+  document.getElementById('inp').focus();
+  await persist();await updateCtxBar();
+}
+
+refreshChats();
+refreshPersonas();
+refreshAgent();
+refreshHealth();                       // [UPGRADE]
+updateRegen();                         // [UPGRADE]
+setInterval(refreshAgent, 8000); // status do agente em tempo real na sidebar
+setInterval(refreshHealth, 8000);      // [UPGRADE] saúde do upstream
+</script></body></html>"""
+
+@app.get("/", response_class=HTMLResponse)
+async def ui_root():
+    return HTMLResponse(UI_HTML)
+
+# ═══════════════════════════ Proxy llama-server (catch-all) — único :8080 ═══════════════════════════
+PROXY_PREFIXES = ("/v1", "/props", "/health", "/slots", "/completion",
+                  "/tokenize", "/detokenize", "/embedding")
+
+# [UPGRADE] detecção de stream robusta (parsing JSON, sem falso-positivo com qualquer 'true').
+def _wants_stream(body: bytes) -> bool:
+    if not body:
+        return False
+    try:
+        return bool(json.loads(body).get("stream"))
+    except Exception:
+        return b'"stream"' in body and b'true' in body  # fallback conservador
+
+@app.api_route("/{path:path}", methods=["GET", "POST", "OPTIONS"])
+async def proxy(path: str, request: Request):
+    full = "/" + path
+    if not full.startswith(PROXY_PREFIXES):
+        return HTMLResponse(UI_HTML)
+    base = CONF["upstreams"]["llm"]                # único upstream orquestrado (:8080)
+    upstream = base.rstrip("/") + full
+    body = await request.body()
+    headers = {k: v for k, v in request.headers.items()
+               if k.lower() not in ("host", "cookie", "content-length")}
+    client: httpx.AsyncClient = app.state.client
+    is_stream = _wants_stream(body)                # [UPGRADE]
+    if is_stream:
+        async def gen():
+            async with client.stream(request.method, upstream, content=body,
+                                     headers=headers, params=request.query_params) as r:
+                async for chunk in r.aiter_raw():
+                    yield chunk
+        return StreamingResponse(gen(), media_type="text/event-stream")
+    try:
+        req = client.build_request(request.method, upstream, content=body,
+                                   headers=headers, params=request.query_params)
+        r = await client.send(req)
+    except httpx.ConnectError:
+        return JSONResponse({"error": f"llama-server offline em {base}"}, status_code=502)
+    return Response(content=r.content, status_code=r.status_code,
+                    media_type=r.headers.get("content-type"))
+
+# ═══════════════════════════ Entry ═══════════════════════════
+if __name__ == "__main__":
+    import uvicorn
+    tls = ensure_tls() if CONF.get("use_tls", True) else None
+    if tls:
+        cert, key = tls
+        print(f"[{KERNEL_NAME}] HTTPS — https://<seu-ip-local>:{CONF['port']}")
+        uvicorn.run(app, host=CONF["bind"], port=CONF["port"],
+                    ssl_certfile=cert, ssl_keyfile=key, log_level="info")
+    else:
+        uvicorn.run(app, host=CONF["bind"], port=CONF["port"], log_level="info")