primocode 10.15.1 → 10.16.0

package/voz/primo_voz/app.py

@@ -51,12 +51,12 @@ def _sem_acento(t: str) -> str:
     return "".join(ch for ch in unicodedata.normalize("NFD", t.lower()) if unicodedata.category(ch) != "Mn")
 
 
+RAIZ = HOME / "Primo"          # a área do app: projetos novos por voz nascem em ~/Primo/<nome>
+
+
 def pasta_atual() -> Path:
-    d = _json(PASTA_PC / "projeto-ativo.json").get("dir")
-    if d and Path(d).is_dir():
-        return Path(d)
-    pc = HOME / "primocode"
-    return pc if pc.is_dir() else HOME
+    RAIZ.mkdir(exist_ok=True)
+    return RAIZ
 
 
 def gravar_pasta(d: Path) -> None:
@@ -72,7 +72,7 @@ def achar_projeto(nome: str) -> "Path | None":
     if not palavras:
         return None
     cand = [Path(x) for x in (_json(PASTA_PC / "projeto-ativo.json").get("recentes") or [])]
-    for base in (HOME / "primocode", HOME):
+    for base in (RAIZ, HOME / "primocode", HOME):
         try:
             cand += [c for c in base.iterdir() if c.is_dir() and not c.name.startswith(".")]
         except OSError:
@@ -84,7 +84,9 @@ def achar_projeto(nome: str) -> "Path | None":
     return 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+(.+?)[.!?]*$", re.I)
+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)
+PEDE_NAVEGADOR = re.compile(r"\babr(?:e|a|ir)\b|\bmostr(?:a|e|ar)\b|navegador|visualiz|preview|pr[eé]-?visualiza", re.I)
 
 
 def _hora_falada(t: "time.struct_time") -> str:
@@ -92,12 +94,51 @@ def _hora_falada(t: "time.struct_time") -> str:
     return hora_falada(t)
 
 
+_OBJETOS = {"site": "o site", "pagina": "a página", "landing": "a landing page", "app": "o app", "aplicativo": "o app", "video": "o vídeo",
+            "arquivo": "o arquivo", "pasta": "a pasta", "projeto": "o projeto", "script": "o script", "teste": "os testes", "testes": "os testes",
+            "bug": "o bug", "erro": "o erro", "commit": "o commit", "deploy": "o deploy", "codigo": "o código", "documento": "o documento",
+            "relatorio": "o relatório", "planilha": "a planilha", "logo": "a logo", "imagem": "a imagem", "motion": "o motion",
+            "servidor": "o servidor", "login": "o login", "cardapio": "o cardápio", "botao": "o botão", "layout": "o layout"}
+_ACKS = [  # (verbos, variações; {o} = "o site", {de} = "do site", {em} = "no site")
+    (r"cri|mont|ger|faz|fa[cç]|escrev|constru|desenh", ["Bora, vou criar {o}.", "Beleza, já começo {o}.", "Fechado, vou montar {o}.", "Pode deixar, vou fazer {o}.", "Show, vou criar {o} agora."]),
+    (r"abr|mostr|exib", ["Deixa eu abrir {o}.", "Já abro {o}.", "Vou abrir {o} pra você.", "Um segundo, abrindo {o}."]),
+    (r"rod|execut|test|ver(?:ific)", ["Vou rodar isso agora.", "Rodando, já te falo.", "Deixa eu rodar {o}.", "Já executo e te conto."]),
+    (r"corrig|conserta|arrum|resolv|debug", ["Vou dar uma olhada {em} e consertar.", "Já vou atrás desse problema.", "Deixa eu ver o que aconteceu {em}."]),
+    (r"edit|mud|troc|atualiz|ajust|coloc|pon|adicion|remov|apag", ["Vou ajustar {o} agora.", "Beleza, já mexo {em}.", "Pode deixar, já faço essa mudança.", "Já altero isso."]),
+    (r"instal|public|sub[ae]|deploy|mand", ["Vou cuidar disso agora.", "Já começo por aqui.", "Deixa comigo, já faço."]),
+    (r"procur|busc|pesquis|analis|olh|le[ia]|explor", ["Vou dar uma olhada {em}.", "Deixa eu procurar isso.", "Já vou investigar."]),
+]
+_ACK_PADRAO = ["Já cuido disso.", "Deixa comigo.", "Pode deixar, já começo.", "Beleza, vou resolver isso."]
+
+
+def ack_contextual(texto: str, ultimo: str = "", sorteio=None) -> str:
+    """O "já vou" de uma TAREFA demorada, escrito a partir do pedido (verbo e objeto) e nunca igual ao anterior."""
+    import random
+    sorte = sorteio or random.choice
+    t = _sem_acento(texto)
+    obj = next((_OBJETOS[w] for w in re.findall(r"[a-z]+", t) if w in _OBJETOS), "")
+    grupo = _ACK_PADRAO
+    primeira = re.findall(r"[a-z]+", t)[:4]
+    for rx, frases in _ACKS:
+        if any(re.match(rx, w) for w in primeira):
+            grupo = frases
+            break
+    pool = [f for f in grupo if f != ultimo and ("{" not in f or obj or True)] or grupo
+    f = sorte(pool)
+    if "{" in f and not obj:
+        f = sorte([x for x in grupo if "{" not in x and x != ultimo] or _ACK_PADRAO)
+    return f.format(o=obj, de=obj.replace("o ", "do ", 1).replace("a ", "da ", 1).replace("os ", "dos ", 1) if obj else "", em=("n" + obj) if obj else "disso")
+
+
 class App:
     def __init__(self) -> None:
         self.cfg = _json(PASTA_PC / "primo-app.json")
         self.node = self.cfg.get("node") or ""
         self.primocode = self.cfg.get("primocode") or ""
         self.pasta = pasta_atual()
+        self.pasta_modo = "raiz"          # raiz (~/Primo, projetos novos) | projeto (o do último pedido) | /dir (escolhida por voz)
+        self.acao_antes = False
+        self.ultimo_ack = ""
         self.motor: "subprocess.Popen | None" = None
         self.cerebro: "subprocess.Popen | None" = None
         self.entrada: "queue.Queue" = queue.Queue()
@@ -106,12 +147,17 @@ 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):
         while True:
             yield self.entrada.get()
 
+    def rotulo(self) -> str:
+        return "~/Primo" if self.pasta == RAIZ else self.pasta.name
+
     def painel(self, msg: dict) -> None:
         self.entrada.put(json.dumps(msg, ensure_ascii=False))
 
@@ -138,6 +184,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 []
@@ -179,17 +232,21 @@ class App:
                 self.painel(m.get("msg") or {})
             elif t == "pronto":
                 log("motor de voz: PRONTO (microfone aberto)")
-                self.painel({"pasta": self.pasta.name, "login": logado()})
+                self.painel({"pasta": "~/Primo", "login": logado()})
             elif t == "erro":
                 log("motor de voz: erro: " + str(m.get("texto")))
                 self.painel({"resposta": str(m.get("texto"))})
             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)
@@ -250,9 +307,8 @@ class App:
         if m:
             d = achar_projeto(m.group(1))
             if d:
-                self.pasta = d
+                self.pasta, self.pasta_modo = d, "/dir"
                 gravar_pasta(d)
-                self.turnos = 0
                 self.painel({"pasta": d.name})
                 log(f"pasta: {d}")
                 self.dizer(f"Fechado. Agora trabalho no {d.name}.")
@@ -269,8 +325,6 @@ class App:
             log(f"lat: resposta LOCAL em {time.time() - t_ini:.2f}s: {local!r}")
             self.dizer(local)
             return
-        if len(texto.split()) >= 3:                       # pedido que vai ao agente: confirma na hora, enquanto ele pensa
-            self.motor_envia({"tipo": "falar", "texto": ["Já vejo.", "Deixa eu ver.", "Um instante.", "Pode deixar."][self.turnos % 4]})
         if not (self.node and self.primocode and Path(self.primocode).exists()):
             log("cérebro: node/primocode não registrados em primo-app.json")
             self.dizer("Não achei o PrimoCode instalado. Rode primocode voz instalar-app no terminal.")
@@ -279,18 +333,58 @@ class App:
             self.painel({"login": False})
             self.dizer("Preciso que você entre na conta do PrimoCode. Clique em Entrar.")
             return
+        acao = bool(VERBO_ACAO.match(_sem_acento(texto).strip())) or bool(re.search(r"\b(?:site|pagina|landing|projeto|arquivo|pasta|codigo|bug|teste|commit|deploy|app|aplicativo|script)s?\b", _sem_acento(texto))) or (self.acao_antes and not re.match(r"^(?:o que|qual|quem|como|por ?que|quando|onde|quanto)\b", _sem_acento(texto).strip()))
+        self.acao_antes = acao
+        pedido = texto
+        pedido += ('\n\n(Modo voz. Termine SEMPRE com uma única linha de JSON: {"falar": "...", "painel": "..."}. '
+                   '"falar" é o que será DITO em voz alta: português natural de conversa, 1 a 4 frases curtas, sem markdown, sem código, '
+                   'sem caminhos de arquivo, sem siglas nem abreviações; números e unidades por extenso como se fala '
+                   '("trinta e dois segundos", "dez pixels", "noventa e nove reais", "versão dez ponto quinze"); nomes técnicos pronunciáveis; '
+                   'diga o que você fez de fato. "painel" é a resposta escrita completa, com markdown e detalhes.)')
+        if acao:
+            pedido += ("\n\n(Pedido por VOZ. Execute de verdade com as ferramentas, sem pedir confirmação, a menos que seja apagar, publicar ou enviar algo. "
+                       "Projetos novos ficam em ~/Primo/<nome curto>. Ao terminar, responda em português falado, 2 a 4 frases, dizendo o que fez DE FATO: "
+                       "pastas e arquivos criados, onde ficaram e o que abriu. Não use listas nem código na resposta.)")
         with self.trava:
-            args = [self.node, self.primocode, "-p", texto, "--output-format", "json"] + (["-c"] if self.turnos else [])
-            log("cérebro: " + " ".join(args[:3]) + " ... cwd=" + str(self.pasta))
+            env = self.ambiente()
+            env.update({"PRIMOCODE_APP": "1", "PRIMOCODE_RAIZ": str(RAIZ), "PRIMOCODE_LOG_FERRAMENTAS": "1",
+                        "PRIMOCODE_SEM_NAVEGADOR": "0" if (PEDE_NAVEGADOR.search(texto) or (acao and re.search(r"site|p[aá]gina|landing|html", texto, re.I))) else "1"})
+            if acao:
+                env["PRIMOCODE_MODO"] = "primocode"
+            if self.pasta != RAIZ:
+                env["PRIMOCODE_PASTA"], env["PRIMOCODE_PASTA_ORIGEM"] = str(self.pasta), ("/dir" if self.pasta_modo == "/dir" else "projeto")
+            args = [self.node, self.primocode, "-p", pedido, "--output-format", "json"] + (["-c"] if self.turnos else [])
+            log(f"cérebro: modo={'AÇÃO' if acao else 'conversa'} cwd={self.pasta} pasta_modo={self.pasta_modo} navegador={'sim' if env['PRIMOCODE_SEM_NAVEGADOR'] == '0' else 'não'} continua={bool(self.turnos)}")
             t0 = time.time()
+
+            def ack_tardio():                       # tarefa: se o agente passou de ~1,2 s, diz o que vai fazer (conversa e pergunta rápida não ganham ack)
+                if acao and self.cerebro and self.cerebro.poll() is None:
+                    a = ack_contextual(texto, self.ultimo_ack)
+                    self.ultimo_ack = a
+                    log(f"ack: {a!r}")
+                    self.motor_envia({"tipo": "falar", "texto": a})
+            timer = threading.Timer(1.2, ack_tardio)
+            timer.start()
             try:
-                self.cerebro = subprocess.Popen(args, cwd=str(self.pasta), env=self.ambiente(), text=True,
-                                                stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                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)
+                log(f"cérebro: saiu com código {self.cerebro.returncode}")
+                timer.cancel()
             except Exception as e:
+                timer.cancel()
                 log(f"cérebro: falhou: {e}")
                 self.dizer("O cérebro não respondeu.")
                 return
+        for l in (err or "").splitlines():
+            if l.startswith("ferramenta:"):
+                log(l[:300])
+        pj = _json(PASTA_PC / "projeto-ativo.json")          # o agente criou/trocou de projeto? o painel e o próximo pedido seguem nele
+        if pj.get("dir") and pj.get("quando", 0) / 1000 >= t0 and Path(pj["dir"]).is_dir() and Path(pj["dir"]) not in (self.pasta, RAIZ):
+            self.pasta, self.pasta_modo = Path(pj["dir"]), "projeto"
+            self.painel({"pasta": self.rotulo()})
+            log(f"pasta do projeto agora: {self.pasta}")
         self.turnos += 1
         resp = ""
         for l in reversed((out or "").strip().splitlines()):
@@ -300,17 +394,37 @@ class App:
                 break
             except ValueError:
                 continue
-        if err and err.strip():
-            log("cérebro stderr: " + err.strip()[-400:])
+        sobra = "\n".join(l for l in (err or "").splitlines() if not l.startswith("ferramenta:")).strip()
+        if sobra:
+            log("cérebro stderr: " + sobra[-400:])
         # tira os enfeites do terminal (⎿ linhas de status, ● marcador) — a voz fala só o texto
-        resp = "\n".join(l for l in resp.splitlines() if not l.lstrip().startswith("⎿")).replace("●", "").strip()
+        resp = "\n".join(l for l in resp.splitlines() if not l.lstrip().startswith("⎿") and not re.match(r"^\s*(?:Projeto novo:|[A-Z][A-Za-z_]{2,12}\s{2,}\S)", l)).replace("●", "").strip()
         log(f"lat: cérebro (agente) {time.time() - t0:.1f}s, {len(resp)} caracteres: {resp[:160]!r}")
         if not resp.strip():
             self.dizer("Não consegui uma resposta agora.")
             return
-        self.motor_envia({"tipo": "falar", "texto": resp, "bruto": True})
+        falar, painel = self.separar(resp)
+        self.motor_envia({"tipo": "falar", "texto": falar, "painel": painel})
         self.motor_envia({"tipo": "estado", "estado": "esperando"})
 
+    @staticmethod
+    def separar(resp: str) -> "tuple[str, str]":
+        """O cérebro devolve {"falar","painel"} (o terminal quebra a linha no meio do JSON: junta e lê). Sem JSON, vale o texto todo."""
+        corpo = re.sub(r"\s*\n\s*", " ", resp)
+        i, j = corpo.find('{"falar"'), corpo.rfind("}")
+        if i >= 0 and j > i:
+            try:
+                d = json.loads(corpo[i:j + 1], strict=False)
+                if str(d.get("falar") or "").strip():
+                    antes = resp[: resp.find('{"falar"')].strip() if '{"falar"' in resp else ""
+                    return str(d["falar"]).strip(), (str(d.get("painel") or "").strip() or antes or str(d["falar"]).strip())
+            except ValueError:
+                pass
+            m = re.search(r'"falar"\s*:\s*"(.*?)"\s*(?:,\s*"painel"|\})', corpo, re.S)
+            if m:
+                return m.group(1).strip(), corpo[:i].strip() or m.group(1).strip()
+        return resp, resp
+
     def sair(self) -> None:
         self.vivo = False
         self.matar_cerebro()
@@ -322,10 +436,454 @@ 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()
-        threading.Timer(2.0, lambda: self.painel({"pasta": self.pasta.name, "login": logado()})).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');const d=new Set((S.lerEstado().desligadas)||[]);"
+                      "console.log(JSON.stringify({ok:true,skills:S.listar().map(s=>({nome:s.nome,descricao:s.descricao||'',ligada:!d.has(s.nome)}))}))")
+        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)})
+                        else:
+                            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:
@@ -343,7 +901,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__":