primocode 10.15.2 → 10.17.0

package/voz/primo_voz/app.py

@@ -86,6 +86,33 @@ def achar_projeto(nome: str) -> "Path | None":
 
 PEDIDO_PASTA = re.compile(r"^(?:(?:abre|abrir|abra|troca|trocar|muda|mudar|vai|ir)\s+(?:para|pra|pro|no|na|o|a)?\s*(?:o\s+|a\s+)?(?:projeto|pasta)\s+|trabalha(?:r)?\s+(?:no|na|em)\s+(?:o\s+|a\s+)?(?:projeto\s+|pasta\s+)?)(.+?)[.!?]*$", re.I)
 VERBO_ACAO = re.compile(r"^(?:e\s+|ent[aã]o\s+|agora\s+)?(?:cria|crie|criar|faz|fa[cç]a|fazer|monta|monte|gera|gere|escreve|escreva|edita|edite|muda|mude|corrige|corrija|conserta|conserte|instala|instale|roda|rode|executa|execute|abre|abra|apaga|apague|deleta|enxuga|enxugue|atualiza|atualize|adiciona|adicione|remove|remova|refatora|publica|publique|coloca|ponha|p[oõ]e|troca|continua|continue|pode ser|sim|isso|ok|beleza|manda|bora|vai)\b", re.I)
+# O 1º motion sem gosto salvo: o motor (em -p, PRIMOCODE_APP=1) escreve no stderr `primocode:abrir-gosto <url>` e espera.
+# O app bloqueia navegador por padrão (PRIMOCODE_SEM_NAVEGADOR=1); ESTA é a exceção explícita: a tela local do gosto abre
+# no navegador padrão. Só a tela local (127.0.0.1 + token hex) passa; qualquer outra coisa na linha é recusada.
+GOSTO_LINHA = re.compile(r"^primocode:abrir-gosto (http://127\.0\.0\.1:\d{2,5}/\?t=[0-9a-f]{32})$")
+
+
+def url_gosto(linha: str) -> "str | None":
+    m = GOSTO_LINHA.match(str(linha or "").strip())
+    return m.group(1) if m else None
+
+
+def abrir_gosto(linha: str, abrir=None) -> bool:
+    """True se a linha era do gosto (aberta ou recusada); False se é outra linha qualquer."""
+    if not str(linha or "").startswith("primocode:abrir-gosto"):
+        return False
+    url = url_gosto(linha)
+    if not url:
+        log("gosto: linha recusada")
+        return True
+    log("gosto: abrindo a tela do gosto no navegador padrão")
+    try:
+        (abrir or (lambda u: subprocess.Popen(["open", u], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)))(url)
+    except Exception as e:
+        log(f"gosto: não abriu: {e}")
+    return True
+
+
 PEDE_NAVEGADOR = re.compile(r"\babr(?:e|a|ir)\b|\bmostr(?:a|e|ar)\b|navegador|visualiz|preview|pr[eé]-?visualiza", re.I)
 
 
@@ -147,6 +174,8 @@ class App:
         self.vivo = True
         self.trava = threading.Lock()
         self.cache_clima: dict = {}
+        self.ao_ouvir = lambda: None
+        self.desligando = False          # a voz foi fechada de propósito: o motor sair não derruba o app
 
     # ── entrada do painel (iterável de linhas JSON) ──
     def __iter__(self):
@@ -182,6 +211,13 @@ class App:
             self.painel({"login": logado()})
         threading.Thread(target=trabalho, daemon=True).start()
 
+    def entrar_e_esperar(self, limite: float = 600) -> None:
+        """O chat espera o login terminar para mostrar a conta e as conversas."""
+        self.entrar()
+        fim = time.time() + limite
+        while time.time() < fim and not logado():
+            time.sleep(1)
+
     def ambiente(self) -> dict:
         env = dict(os.environ)
         extra = [str(Path(self.node).parent)] if self.node else []
@@ -230,10 +266,14 @@ class App:
             elif t == "parar":
                 self.matar_cerebro()
             elif t == "ouvi" and str(m.get("texto") or "").strip():
+                self.ao_ouvir()                     # pedido falado: a tela de voz vem pra frente
                 threading.Thread(target=self.pensar, args=(str(m["texto"]).strip(),), daemon=True).start()
             elif t == "fim":
                 break
         log("motor de voz: saiu")
+        if self.desligando:
+            self.desligando = False
+            return
         if self.vivo:
             self.vivo = False
             os._exit(0)
@@ -356,7 +396,19 @@ class App:
                 self.cerebro = subprocess.Popen(args, cwd=str(self.pasta), env=env, text=True,
                                                 stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                                                 start_new_session=True)          # grupo próprio: nada do que o agente faça com processos atinge o app
-                out, err = self.cerebro.communicate(timeout=900)
+                linhas_err: "list[str]" = []
+                cer = self.cerebro
+
+                def ler_err():                      # ao vivo: a linha do gosto tem que abrir a tela ENQUANTO o motor espera
+                    for l in cer.stderr:
+                        if not abrir_gosto(l):
+                            linhas_err.append(l)
+                th_err = threading.Thread(target=ler_err, daemon=True)
+                th_err.start()
+                out = cer.stdout.read()
+                cer.wait(timeout=900)
+                th_err.join(timeout=2)
+                err = "".join(linhas_err)
                 log(f"cérebro: saiu com código {self.cerebro.returncode}")
                 timer.cancel()
             except Exception as e:
@@ -423,12 +475,456 @@ class App:
                 self.motor.kill()
         log("app: encerrado")
 
-    def iniciar(self, js, p) -> None:
+    # ── a voz só liga pelo botão: com o chat na frente, o microfone fica fechado ──
+    def ligar_voz(self) -> None:
+        with self.trava:
+            if self.motor and self.motor.poll() is None:
+                return
+            self.desligando = False
+            self.subir_motor()
+
+    def desligar_voz(self) -> None:
+        with self.trava:
+            if not self.motor or self.motor.poll() is not None:
+                return
+            self.desligando = True
+            m, self.motor = self.motor, None
+        log("motor de voz: desligando (voltou pro chat)")
+        try:
+            m.stdin.write(json.dumps({"tipo": "fim"}) + "\n")
+            m.stdin.flush()
+            m.wait(timeout=2)
+        except Exception:
+            m.kill()
+
+    def iniciar(self, js, p, com_chat: bool = True) -> None:
         self.js = js
-        threading.Timer(0.5, self.subir_motor).start()
+        if not com_chat:                        # só o modo voz puro (sem chat) abre ouvindo
+            threading.Timer(0.5, self.subir_motor).start()
         threading.Timer(2.0, lambda: self.painel({"pasta": self.rotulo(), "login": logado()})).start()
 
 
+# ── o que aparece embaixo de uma mensagem: os arquivos citados, mostrados ali mesmo ──
+TIPOS = {"video": {".mp4", ".mov", ".webm", ".m4v"}, "imagem": {".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".avif"},
+         "audio": {".mp3", ".wav", ".m4a", ".aac", ".ogg", ".flac"}, "pdf": {".pdf"}, "html": {".html", ".htm"},
+         "codigo": {".js", ".jsx", ".ts", ".tsx", ".py", ".css", ".json", ".md", ".txt", ".sh", ".yml", ".yaml", ".toml",
+                    ".rs", ".go", ".java", ".kt", ".swift", ".rb", ".php", ".sql", ".csv", ".xml", ".env.example"}}
+CAMINHO_ABS = re.compile(r"(?<![\w/])(?:~|/(?:Users|Volumes|tmp|private|opt|var|Applications))(?:/[\w.@+\-()À-ÿ]+)+/?")
+CAMINHO_REL = re.compile(r"(?<![\w/~.])(?:[\w.@+\-À-ÿ]+/)+[\w.@+\-À-ÿ]+\.\w{1,5}\b")
+CRASE = re.compile(r"`([^`\n]{2,300})`")
+
+
+def tipo_de(c: Path) -> str:
+    if c.is_dir():
+        return "pasta"
+    ext = c.suffix.lower()
+    return next((t for t, exts in TIPOS.items() if ext in exts), "arquivo")
+
+
+def midias_do_texto(texto: str, pasta: Path, limite: int = 8) -> "list[dict]":
+    """Os arquivos e pastas que a mensagem cita e que EXISTEM: caminho absoluto, ~/..., ou relativo à pasta do
+    projeto (entre crases ou com barra). `achado` é o texto como apareceu, para a tela virar ele num botão."""
+    vistos, fora = set(), []
+    candidatos = [m.group(1).strip() for m in CRASE.finditer(texto or "")]
+    candidatos += [m.group(0) for m in CAMINHO_ABS.finditer(texto or "")] + [m.group(0) for m in CAMINHO_REL.finditer(texto or "")]
+    for achado in candidatos:
+        bruto = achado.rstrip(".,;:)!?").strip()
+        if not bruto or "\n" in bruto or bruto.startswith(("http://", "https://")):
+            continue
+        c = Path(os.path.expanduser(bruto))
+        if not c.is_absolute():
+            if "/" not in bruto and "." not in bruto:
+                continue
+            c = pasta / c
+        try:
+            c = c.resolve()
+            existe = c.exists()
+        except (OSError, RuntimeError):
+            continue
+        if not existe or str(c) in vistos or c == HOME or c == Path("/"):
+            continue
+        vistos.add(str(c))
+        tipo = tipo_de(c)
+        item = {"achado": bruto, "caminho": str(c), "nome": c.name, "tipo": tipo, "url": c.as_uri(),
+                "tamanho": c.stat().st_size if c.is_file() else 0}
+        if tipo == "codigo" and item["tamanho"] <= 200_000:
+            try:
+                item["trecho"] = "\n".join(c.read_text("utf-8", errors="replace").splitlines()[:40])[:4000]
+            except OSError:
+                pass
+        fora.append(item)
+        if len(fora) >= limite:
+            break
+    return fora
+
+
+# Os comandos de / no app. Os do terminal que viram ação da própria janela, e os que não se aplicam a ela.
+COMANDOS_DO_APP = {"/clear": "nova", "/chats": "buscar", "/login": "entrar", "/logout": "sair_conta", "/account": "conta",
+                   "/mode": "modo", "/api": "modelos", "/config": "ajustes", "/skills": "skills", "/marketplace": "skills",
+                   "/attach": "anexar", "/detach": "desanexar", "/copiar": "copiar", "/voice": "voz", "/voice nome": "voz_nome",
+                   "/dir": "pasta", "/help": "ajuda", "/effort": "effort", "/permissoes": "permissoes"}
+# "perguntar" precisa de alguém no terminal para responder: no app (sem terminal) não se aplica.
+PERMISSOES_APP = [("auto", "roda tudo, mas pergunta antes do que não tem volta"), ("livre", "faz tudo sem perguntar"),
+                  ("plano", "só lê e planeja, não muda nada")]
+COMANDOS_FORA = {"/cls", "/exit", "/uninstall", "/atalhos", "/mascot", "/offline", "/files", "/voice painel", "/voice parar", "!comando"}
+
+
+def comandos_para_o_app(lista: list) -> list:
+    """A lista do terminal (`menu-comandos`) com o tipo de cada um: app (a janela faz), terminal (roda e mostra a
+    saída) ou pedido (comando da pessoa: vira um pedido ao agente)."""
+    fora = []
+    for c in lista:
+        nome = str(c.get("nome") or "")
+        if not nome or nome in COMANDOS_FORA:
+            continue
+        item = {"nome": nome, "descricao": str(c.get("descricao") or "")}
+        if nome in COMANDOS_DO_APP:
+            item.update(tipo="app", acao=COMANDOS_DO_APP[nome])
+        else:
+            item["tipo"] = "terminal" if c.get("embutido") else "pedido"
+        fora.append(item)
+    return fora
+
+
+class Chat:
+    """A tela do chat (chat.html): manda e recebe pela ponte `chat` do hud.py. O cérebro é o mesmo da voz
+    (`primocode -p ... --output-format json`), com `--resume <id>` para seguir a conversa da nuvem."""
+
+    MAX_ANEXO = 25 * 1024 * 1024
+
+    def __init__(self, app: App) -> None:
+        self.app = app
+        self.js = lambda m: None
+        self.mostrar_voz = lambda: None
+        self.parado = False
+        app.ao_ouvir = lambda: self.mostrar_voz()
+
+    def raiz(self) -> "Path | None":
+        r = Path(self.app.primocode).resolve().parent.parent if self.app.primocode else None
+        return r if r and (r / "lib").is_dir() else None
+
+    def node(self, codigo: str, timeout: int = 60) -> dict:
+        """Roda um pedaço de JS na raiz do PrimoCode e lê a última linha de JSON que ele imprimir."""
+        r = self.raiz()
+        if not (self.app.node and r):
+            return {"ok": False, "erro": "Não achei o PrimoCode instalado. Rode primocode voz instalar-app no terminal."}
+        try:
+            p = subprocess.run([self.app.node, "-e", codigo], cwd=str(r), env=self.app.ambiente(), capture_output=True, text=True, timeout=timeout)
+        except Exception as e:
+            return {"ok": False, "erro": str(e)}
+        for l in reversed(p.stdout.strip().splitlines()):
+            try:
+                return json.loads(l)
+            except ValueError:
+                continue
+        log("chat node: " + (p.stderr or "")[-300:])
+        return {"ok": False, "erro": "O PrimoCode não respondeu."}
+
+    def cli(self, *args: str, timeout: int = 60) -> dict:
+        if not (self.app.node and self.app.primocode):
+            return {"ok": False, "erro": "Não achei o PrimoCode instalado."}
+        try:
+            p = subprocess.run([self.app.node, self.app.primocode, *args], cwd=str(self.app.pasta), env=self.app.ambiente(),
+                               capture_output=True, text=True, timeout=timeout)
+        except Exception as e:
+            return {"ok": False, "erro": str(e)}
+        for l in reversed(p.stdout.strip().splitlines()):
+            try:
+                return json.loads(l)
+            except ValueError:
+                continue
+        return {"ok": False, "erro": "O PrimoCode não respondeu."}
+
+    # ── o que a tela mostra ──
+    def conta(self) -> dict:
+        c = _json(PASTA_PC / "conta.json")
+        ate = c.get("planoAte")
+        if isinstance(ate, (int, float)):
+            ate = time.strftime("%d/%m/%Y", time.localtime(ate / 1000 if ate > 1e11 else ate))
+        return {"logado": logado(), "email": c.get("email") or "", "plano": c.get("plano") or "", "planoAte": ate or ""}
+
+    def modo(self) -> str:
+        return "chat" if _json(PASTA_PC / "config.json").get("mode") == "chat" else "agent"
+
+    def ajustes(self) -> dict:
+        r = self.node("const P=require('./lib/local/provedor.js');const a=P.atual();"
+                      "console.log(JSON.stringify({ok:true,atual:a?{id:a.id,nome:a.nome,cli:a.cli,chave:a.chave?P.mascarar(a.chave):''}:null,"
+                      "lista:Object.entries(P.PROVEDORES).filter(([,p])=>!p.cli).map(([id,p])=>({id,nome:p.nome}))}))")
+        atual = r.get("atual") if r.get("ok") else None
+        voz = _json(PASTA_PC / "voz.json")
+        cfg = _json(PASTA_PC / "config.json")
+        ef = self.node("const E=require('./lib/effort.js');console.log(JSON.stringify({ok:true,niveis:E.NIVEIS.map(n=>({nome:n.nome,resumo:n.resumo}))}))")
+        perm = cfg.get("permissoes") if cfg.get("permissoes") in dict(PERMISSOES_APP) else "auto"
+        return {"modo": self.modo(),
+                "effort": {"atual": str(cfg.get("effort") or "medium"), "niveis": ef.get("niveis") or []},
+                "permissoes": {"atual": perm, "opcoes": [{"nome": n, "resumo": r} for n, r in PERMISSOES_APP]},
+                "provedor": {"id": atual["id"], "nome": atual["nome"], "chave_mascarada": atual.get("chave") or ""} if atual else {"id": "primo", "nome": "Primo", "chave_mascarada": ""},
+                "provedores_chave": r.get("lista") or [], "pasta": str(self.app.pasta), "voz": {"nome": voz.get("nome") or "Primo", "sons": voz.get("sons", True) is not False},
+                "conta": self.conta()}
+
+    def conversas(self) -> None:
+        r = self.cli("conversas", "--json", "--limite", "40")
+        self.js({"conversas": r.get("conversas") or []} if r.get("ok") else {"conversas_erro": r.get("erro") or "Não deu pra carregar as conversas."})
+
+    def skills(self) -> None:
+        r = self.node("const S=require('./lib/skills.js');"     # listar() já diz se cada skill está ligada
+                      "console.log(JSON.stringify({ok:true,skills:S.listar().map(s=>({nome:s.nome,descricao:s.descricao||'',ligada:s.ligada!==false}))}))")
+        self.js({"skills": r.get("skills") or []} if r.get("ok") else {"erro": r.get("erro")})
+
+    # ── a ponte ──
+    def receber(self, m: dict) -> None:
+        a = m.get("acao")
+        trab = None
+        if a == "pronto":
+            def trab():
+                self.js({"inicio": {**self.conta(), "pasta": str(self.app.pasta), "modo": self.modo()}})
+                r = self.cli("menu-comandos")
+                if r.get("ok"):
+                    self.js({"comandos": comandos_para_o_app(r.get("comandos") or [])})
+                if logado():
+                    self.conversas()
+        elif a == "enviar":
+            self.parado = False
+            trab = lambda: self.pensar(str(m.get("texto") or ""), m.get("conversa"), m.get("modo") or self.modo(), m.get("anexos") or [])
+        elif a == "comando" and str(m.get("texto") or "").startswith("/"):
+            self.parado = False
+            trab = lambda: self.pensar(str(m["texto"]), m.get("conversa"), self.modo(), [], comando=True)
+        elif a == "parar":
+            self.parado = True
+            self.app.matar_cerebro()
+        elif a == "conversas":
+            trab = self.conversas
+        elif a == "abrir" and m.get("id"):
+            def trab():
+                r = self.cli("conversa", str(m["id"]), "--json")
+                if not r.get("ok"):
+                    self.js({"erro": r.get("erro") or "Não abriu a conversa."})
+                    return
+                msgs = [{**x, "midias": midias_do_texto(x.get("texto", ""), self.app.pasta)} for x in (r.get("mensagens") or [])]
+                self.js({"conversa": {"id": r.get("id"), "titulo": r.get("titulo"), "mensagens": msgs}})
+        elif a == "entrar":
+            def trab():
+                self.app.entrar_e_esperar()
+                self.js({"login": self.conta()})
+                if logado():
+                    self.conversas()
+        elif a == "sair_conta":
+            def trab():
+                self.node("require('./lib/conta.js').sair();console.log('{\"ok\":true}')")
+                self.js({"login": self.conta()})
+                self.js({"conversas": []})
+        elif a == "excluir" and m.get("id"):
+            def trab():
+                r = self.cli("conversa", str(m["id"]), "--apagar", "--json", timeout=120)
+                if not r.get("ok"):
+                    self.js({"erro": "Não apaguei a conversa: " + str(r.get("erro") or "sem resposta")})
+                self.conversas()
+        elif a == "excluir_todas":
+            def trab():
+                r = self.cli("conversas", "--apagar-todas", "--json", timeout=600)
+                if not r.get("ok"):
+                    self.js({"erro": "Não apaguei todas: " + str(r.get("erro") or "sem resposta")})
+                self.conversas()
+        elif a == "skills":
+            trab = self.skills
+        elif a == "skill" and m.get("nome"):
+            def trab():
+                self.node(f"require('./lib/skills.js').ligar({json.dumps(str(m['nome']))},{'true' if m.get('ligada') else 'false'});console.log('{{\"ok\":true}}')")
+                self.skills()
+        elif a == "ajustes":
+            trab = lambda: self.js({"ajustes": self.ajustes()})
+        elif a == "ajuste":
+            trab = lambda: self.ajuste(str(m.get("chave") or ""), m.get("valor"))
+        elif a == "soltar":
+            trab = lambda: self.soltar(str(m.get("nome") or "arquivo"), str(m.get("base64") or ""))
+        if trab:
+            threading.Thread(target=trab, daemon=True).start()
+
+    def ajuste(self, chave: str, valor) -> None:
+        if chave in ("modo", "effort", "permissoes"):
+            cfg = _json(PASTA_PC / "config.json")
+            if chave == "modo":
+                cfg["mode"] = "chat" if valor == "chat" else "primocode"
+            elif chave == "effort" and str(valor) in ("low", "medium", "high", "xhigh", "max", "ultracode"):
+                cfg["effort"] = str(valor)
+            elif chave == "permissoes" and str(valor) in dict(PERMISSOES_APP):
+                cfg["permissoes"] = str(valor)
+            else:
+                self.js({"erro": f"Valor inválido para {chave}: {valor}"})
+            (PASTA_PC / "config.json").write_text(json.dumps(cfg, ensure_ascii=False, indent=2), "utf-8")
+        elif chave == "provedor" and isinstance(valor, dict):
+            pid = str(valor.get("provedor") or "")
+            if pid == "primo":
+                r = self.node("require('./lib/local/provedor.js').desligar();console.log('{\"ok\":true}')")
+            else:
+                r = self.node("const P=require('./lib/local/provedor.js');const p=P.PROVEDORES[" + json.dumps(pid) + "];"
+                              "if(!p){console.log(JSON.stringify({ok:false,erro:'Provedor desconhecido.'}));}else{"
+                              "P.salvar({provedor:" + json.dumps(pid) + ",chave:" + json.dumps(str(valor.get("chave") or "")) + ",modelo:p.modelos[0]});"
+                              "console.log(JSON.stringify({ok:true}))}")
+            if not r.get("ok"):
+                self.js({"erro": r.get("erro") or "Não deu pra trocar o modelo."})
+        elif chave == "voz_nome":
+            from primo_voz import identidade
+            nome = identidade._nome_valido(str(valor or ""))
+            if not nome:
+                self.js({"erro": "O nome precisa ter 1 ou 2 palavras, até 20 letras."})
+            else:
+                self.gravar_voz(nome=nome)
+                self.app.js({"nome": nome})
+        elif chave == "voz_sons":
+            self.gravar_voz(sons=bool(valor))
+        self.js({"ajustes": self.ajustes()})
+
+    def gravar_voz(self, **campos) -> None:
+        arq = PASTA_PC / "voz.json"
+        d = _json(arq)
+        d.update(campos)
+        arq.write_text(json.dumps(d, ensure_ascii=False, indent=2), "utf-8")
+
+    def escolher_pasta(self, caminho: str) -> None:
+        d = Path(caminho)
+        if d.is_dir():
+            self.app.pasta, self.app.pasta_modo = d, "/dir"
+            gravar_pasta(d)
+            self.app.painel({"pasta": self.app.rotulo()})
+            self.js({"pasta": str(d)})
+
+    # ── anexos: tudo vai para <pasta>/anexos e o caminho entra no pedido ──
+    def destino(self, nome: str) -> Path:
+        pasta = self.app.pasta / "anexos"
+        pasta.mkdir(parents=True, exist_ok=True)
+        base = re.sub(r"[^\w.\- ]", "_", Path(nome).name).strip() or "arquivo"
+        alvo, k = pasta / base, 1
+        while alvo.exists():
+            alvo = pasta / f"{Path(base).stem}-{k}{Path(base).suffix}"
+            k += 1
+        return alvo
+
+    def anexar_caminhos(self, caminhos: "list[str]") -> None:
+        import shutil
+        for c in caminhos:
+            o = Path(c)
+            if not o.is_file():
+                continue
+            if o.stat().st_size > self.MAX_ANEXO:
+                self.js({"erro": f"{o.name} passa de 25 MB."})
+                continue
+            alvo = self.destino(o.name)
+            shutil.copy2(o, alvo)
+            self.js({"anexo": {"nome": o.name, "caminho": str(alvo)}})
+
+    def soltar(self, nome: str, b64: str) -> None:
+        import base64
+        try:
+            dados = base64.b64decode(b64, validate=False)
+        except Exception:
+            self.js({"erro": f"Não li {nome}."})
+            return
+        if len(dados) > self.MAX_ANEXO:
+            self.js({"erro": f"{nome} passa de 25 MB."})
+            return
+        alvo = self.destino(nome)
+        alvo.write_bytes(dados)
+        self.js({"anexo": {"nome": nome, "caminho": str(alvo)}})
+
+    # ── o cérebro ──
+    def pensar(self, texto: str, conversa, modo: str, anexos: list, comando: bool = False) -> None:
+        """comando=True: `texto` é um /comando do terminal; a saída volta como {saida} (texto de terminal), não como resposta."""
+        texto = texto.strip()
+        if anexos:
+            texto = (texto or "Olha esses arquivos.") + "\n\nAnexos:\n" + "\n".join(f"- {a}" for a in anexos)
+        if not texto:
+            return
+        if not comando and not logado():              # /help, /doctor, /version… funcionam sem conta
+            self.js({"login": self.conta()})
+            self.js({"erro": "Entre na sua conta do PrimoCode pra conversar."})
+            return
+        if not (self.app.node and self.app.primocode and Path(self.app.primocode).exists()):
+            self.js({"erro": "Não achei o PrimoCode instalado. Rode primocode voz instalar-app no terminal."})
+            return
+        with self.app.trava:
+            env = self.app.ambiente()
+            env.update({"PRIMOCODE_APP": "1", "PRIMOCODE_RAIZ": str(RAIZ), "PRIMOCODE_LOG_FERRAMENTAS": "1",
+                        "PRIMOCODE_MODO": "chat" if modo == "chat" else "primocode"})
+            if comando and re.match(r"/(open|abrir)\b", texto):
+                env["PRIMOCODE_SEM_NAVEGADOR"] = "0"      # /open e /abrir existem para abrir o navegador
+            if self.app.pasta != RAIZ:
+                env["PRIMOCODE_PASTA"], env["PRIMOCODE_PASTA_ORIGEM"] = str(self.app.pasta), ("/dir" if self.app.pasta_modo == "/dir" else "projeto")
+            args = [self.app.node, self.app.primocode, "-p", texto, "--output-format", "json"] + (["--resume", str(conversa)] if conversa else [])
+            log(f"chat: modo={modo} cwd={self.app.pasta} conversa={conversa or 'nova'}")
+            t0 = time.time()
+            try:
+                p = subprocess.Popen(args, cwd=str(self.app.pasta), env=env, text=True, stdin=subprocess.DEVNULL,
+                                     stdout=subprocess.PIPE, stderr=subprocess.PIPE, start_new_session=True)
+                self.app.cerebro = p
+                resto: "list[str]" = []
+
+                def passos():              # cada ferramenta que o agente usa vira uma linha ao vivo no chat
+                    for l in p.stderr:
+                        if l.startswith("ferramenta:"):
+                            self.js({"passo": passo_legivel(l)})
+                        elif not abrir_gosto(l):
+                            resto.append(l)
+                th = threading.Thread(target=passos, daemon=True)
+                th.start()
+                out = p.stdout.read()
+                p.wait(timeout=900)
+                th.join(timeout=2)
+            except Exception as e:
+                log(f"chat: cérebro falhou: {e}")
+                self.js({"erro": "O PrimoCode não respondeu."})
+                return
+        if self.parado:
+            self.js({"erro": "Parei."})
+            return
+        res = {}
+        for l in reversed((out or "").strip().splitlines()):
+            try:
+                res = json.loads(l)
+                break
+            except ValueError:
+                continue
+        if comando:
+            saida = str(res.get("result") or "").strip()
+            if res.get("is_error"):
+                self.js({"erro": saida or "O comando falhou."})
+            else:
+                self.js({"saida": {"comando": texto.split()[0], "texto": saida or "(sem saída)", "conversa": conversa, "midias": midias_do_texto(saida, self.app.pasta)}})
+            return
+        # o markdown cru da resposta (o -p json manda); sem ele, o texto do terminal sem os enfeites
+        txt = str(res.get("markdown") or "").strip() or \
+            "\n".join(l for l in str(res.get("result") or "").splitlines() if not l.lstrip().startswith("⎿")).replace("●", "").strip()
+        log(f"chat: {time.time() - t0:.1f}s, {len(txt)} caracteres, erro={bool(res.get('is_error'))}")
+        if res.get("is_error") or not txt:
+            self.js({"erro": txt or ("".join(resto)[-300:].strip() or "Não consegui uma resposta agora.")})
+            return
+        self.js({"resposta": {"texto": txt, "conversa": res.get("conversa") or conversa, "midias": midias_do_texto(txt, self.app.pasta)}})
+
+
+FERRAMENTA_LEGIVEL = {"read_file": "Lendo", "write_file": "Escrevendo", "edit_file": "Editando", "multi_edit": "Editando",
+                      "run_shell": "Rodando", "run_in_new_terminal": "Abrindo um terminal:", "list_dir": "Olhando a pasta",
+                      "grep": "Procurando", "glob": "Procurando arquivos", "open_in_browser": "Abrindo no navegador",
+                      "pesquisar_referencia": "Pesquisando referências", "write_todos": "Organizando as etapas",
+                      "estudio_video": "Montando o vídeo", "estudio_motion": "Animando", "estudio_render": "Renderizando",
+                      "estudio_editar": "Editando o vídeo", "estudio_narrar": "Gravando a narração", "estudio_site": "Fazendo o site",
+                      "estudio_ae": "Animando no estilo After Effects", "estudio_midia": "Buscando mídia", "estudio_plano": "Planejando",
+                      "estudio_projeto": "Abrindo o projeto"}
+
+
+def passo_legivel(linha: str) -> str:
+    """`ferramenta: read_file {"path":"src/a.js"}` → `Lendo src/a.js`. O que não reconhece, mostra o nome."""
+    m = re.match(r"ferramenta:\s*(\S+)\s*(.*)", linha.strip())
+    if not m:
+        return linha.strip()[:120]
+    nome, resto = m.group(1), m.group(2)
+    try:
+        a = json.loads(resto) if resto else {}
+    except ValueError:
+        a = {}
+    alvo = next((str(a[k]) for k in ("path", "file_path", "file", "command", "cmd", "pattern", "query", "url", "dir") if isinstance(a, dict) and a.get(k)), "")
+    return (FERRAMENTA_LEGIVEL.get(nome, nome) + (" " + alvo if alvo else "")).strip()[:120]
+
+
 def main() -> int:
     import fcntl
     import atexit
@@ -444,7 +940,7 @@ def main() -> int:
     app = App()
     atexit.register(app.sair)
     from primo_voz import hud
-    return hud.main(entrada=iter(app), saida=app.saida_do_painel, ao_iniciar=app.iniciar, ao_sair=app.sair)
+    return hud.main(entrada=iter(app), saida=app.saida_do_painel, ao_iniciar=app.iniciar, ao_sair=app.sair, chat=Chat(app))
 
 
 if __name__ == "__main__":