primocode 10.14.1 → 10.15.1

package/voz/primo_voz/__main__.py

@@ -31,6 +31,8 @@ from __future__ import annotations
 import json
 import os
 import queue
+import re
+import shutil
 import subprocess
 import sys
 import tempfile
@@ -41,7 +43,34 @@ from pathlib import Path
 AQUI = Path(__file__).resolve().parent
 sys.path.insert(0, str(AQUI.parent))
 
-from primo_voz import escuta, transcrever  # noqa: E402
+from primo_voz import conversa, escuta, fala, identidade, painel, transcrever  # noqa: E402
+from primo_voz import tela as dados_tela  # noqa: E402
+from primo_voz.luz import Luz  # noqa: E402
+from primo_voz.sons import Sons  # noqa: E402
+
+
+class _PonteHud:
+    """No modo app o painel mora no processo-pai (app.py): as mensagens dele vão pelo stdout do protocolo."""
+
+    class _Entrada:
+        def write(self, linha: str) -> None:
+            try:
+                falar_para_o_node({"tipo": "hud", "msg": json.loads(linha)})
+            except ValueError:
+                pass
+
+        def flush(self) -> None:
+            pass
+
+        def close(self) -> None:
+            pass
+
+    def __init__(self) -> None:
+        self.stdin = self._Entrada()
+        self.stdout = iter(())
+
+    def poll(self):
+        return None
 
 
 class Bolinha:
@@ -57,13 +86,60 @@ class Bolinha:
         self.quando = 0.0
         if os.environ.get("PRIMOCODE_SEM_ORB") == "1":
             return
+        self.ao_acao = None
+        if os.environ.get("PRIMOCODE_HUD_PONTE") == "1":
+            self.modulo, self.p = "primo_voz.hud", _PonteHud()
+            return
+        # No Mac com PyObjC o rosto é o HUD (hud.py); senão, a orbe de antes.
+        modulo = "primo_voz.orbe"
+        if sys.platform == "darwin" and os.environ.get("PRIMOCODE_HUD") != "0":
+            try:
+                import AppKit  # noqa: F401
+                modulo = "primo_voz.hud"
+            except ImportError:
+                pass
+        self.modulo = modulo
         try:
-            self.p = subprocess.Popen([sys.executable, "-m", "primo_voz.orbe"], cwd=str(AQUI.parent),
-                                      stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
-                                      env={**os.environ, "PYTHONPATH": str(AQUI.parent)}, text=True)
+            cmd = [sys.executable, "-m", modulo]
+            env_extra = {"PYTHONPATH": str(AQUI.parent)}
+            if modulo.endswith("hud"):
+                from primo_voz import appmac          # Primo.app: nome e ícone no Dock; cai no python se não der
+                exe = appmac.preparar()
+                if exe:
+                    cmd = [exe, "-m", "primo_voz.hud"]
+                    env_extra = {"PYTHONPATH": appmac.pythonpath()}
+            self.p = subprocess.Popen(cmd, cwd=str(AQUI.parent),
+                                      stdin=subprocess.PIPE,
+                                      stdout=subprocess.PIPE if modulo.endswith("hud") else subprocess.DEVNULL,
+                                      stderr=subprocess.DEVNULL,
+                                      env={**os.environ, **env_extra}, text=True)
+            if modulo.endswith("hud"):
+                threading.Thread(target=self._ler_acoes, daemon=True).start()
         except Exception:
             self.p = None
 
+    def _ler_acoes(self) -> None:
+        """O HUD manda {"acao":"ptt"} quando a pessoa clica nos anéis."""
+        try:
+            for linha in self.p.stdout:
+                try:
+                    a = json.loads(linha).get("acao")
+                except ValueError:
+                    continue
+                if a and self.ao_acao:
+                    self.ao_acao(a)
+        except Exception:
+            pass
+
+    def enviar(self, obj: dict) -> None:
+        if not self.p or self.p.poll() is not None or not self.modulo.endswith("hud"):
+            return
+        try:
+            self.p.stdin.write(json.dumps(obj, ensure_ascii=False) + "\n")
+            self.p.stdin.flush()
+        except Exception:
+            pass
+
     def estado(self, estado: str, nivel: float = None) -> None:
         if not self.p or self.p.poll() is not None:
             return
@@ -71,6 +147,8 @@ class Bolinha:
         if estado == self.ultimo and (nivel is None or agora - self.quando < 1 / 15):
             return
         self.ultimo, self.quando = estado, agora
+        if not self.modulo.endswith("hud"):
+            estado = {"executando": "pensando", "interrompido": "ouvindo", "dormindo": "esperando"}.get(estado, estado)
         msg = {"estado": estado}
         if nivel is not None:
             msg["nivel"] = round(min(1.0, nivel), 3)
@@ -131,25 +209,68 @@ PS_TOCAR_MP3 = (
 
 
 class Voz:
-    """Microfone → transcrição → terminal. Terminal → voz."""
+    """Microfone → transcrição → terminal. Terminal → voz. O Primo.
+
+    A conversa (estados, frases, resumo, comandos) é conversa.py, puro e testado;
+    o painel é hud.py; luz.py e sons.py são o resto do corpo."""
 
     def __init__(self, servidor: str, token: str, voz_escolhida: str = "antonio"):
         self.servidor = servidor
         self.token = token
         self.voz = voz_escolhida
-        # O Whisper local carrega em segundo plano desde já: senão a primeira
-        # frase esperaria o modelo inteiro subir.
+        self.cfg = identidade.ler()
+        self.nome = self.cfg["nome"]
+        # nome = só responde se começar pelo nome · sempre = sem palavra · tecla = só ao clicar no painel
+        self.modo = os.environ.get("PRIMOCODE_ATIVACAO", "nome")
         self.local = transcrever.disponivel()
         if self.local:
             transcrever.aquecer()
+        self.edge = fala.Edge()
+        self.voz_id = self.cfg.get("voz") if self.cfg.get("voz") in fala.VOZES else "francisca"
+        self._t_acabou = None
+        threading.Thread(target=self._pre_aquecer_frases, daemon=True).start()
         self.gravador = escuta.Gravador()
+        self.gravador.vad = escuta.criar_vad()
         self.corte = escuta.Corte()
         self.bolinha = Bolinha()
+        self.bolinha.ao_acao = self._acao_do_painel
+        self.luz = Luz(bool(self.cfg.get("luz", True)))
+        self.sons = Sons(bool(self.cfg.get("sons", True)))
+        self.maquina = conversa.Maquina("ouvindo")
         self._blocos: "queue.Queue" = queue.Queue()
-        self._falas: "queue.Queue" = queue.Queue()
+        self._falas: "queue.Queue" = queue.Queue()      # frases de texto
+        self._audios: "queue.Queue" = queue.Queue(maxsize=2)   # mp3 já pronto
         self._vivo = True
         self._falando = False
         self._parar_fala = threading.Event()
+        self._acordado_ate = 0.0       # janela de conversa: sem repetir o nome
+        self._ptt_ate = 0.0
+        self._ultima_conf = 0.0
+        self._ultimo_ok = ""
+        self.bolinha.enviar({"nome": self.nome})
+
+    def lat(self, texto: str) -> None:
+        if os.environ.get("PRIMOCODE_LAT") == "1":
+            avisar("lat: " + texto)
+
+    # ── o corpo: painel, luz e som reagem ao mesmo estado ───────────────
+
+    def _estado(self, estado: str, nivel: float = None) -> None:
+        mudou = estado != self.bolinha.ultimo
+        self.bolinha.estado(estado, nivel)
+        self.luz.mudar(estado, nivel)
+        if mudou and estado in ("ouvindo", "pensando"):
+            self.sons.tocar(estado, falando=self._falando)
+
+    def _acao_do_painel(self, acao: str) -> None:
+        if acao == "ptt":                      # clique nos anéis = falar agora
+            self._ptt_ate = time.time() + 10
+            self.sons.tocar("acordou", falando=self._falando)
+
+    def _erro(self, texto: str) -> None:
+        self.luz.erro()
+        self.sons.tocar("erro")
+        self.bolinha.enviar({"resposta": texto})
 
     # ── o ouvido ─────────────────────────────────────────────────────────
 
@@ -157,16 +278,33 @@ class Voz:
         if not self._vivo:
             return
         nivel = escuta.rms(bloco)
-        # Enquanto ele fala, o microfone só serve para uma coisa: saber se a
-        # pessoa falou POR CIMA. O que entra aqui é a voz dele saindo da
-        # caixa de som, e não pode virar pedido.
+        if not self._falando and self.bolinha.ultimo:      # o volume REAL do mic vai para as barras da tela
+            self.bolinha.estado(self.bolinha.ultimo, dados_tela.nivel_do_mic(nivel))
+        # Enquanto ele fala, o microfone só serve para saber se a pessoa falou
+        # POR CIMA (interrupção). A voz dele na caixa de som não vira pedido.
         if self._falando:
             self.corte.ele_falou(nivel)
-            if self.corte.alguem_cortou(nivel):
-                self._parar_fala.set()
+            if self.maquina.pode_cortar and self.corte.alguem_cortou(nivel):
+                self._interromper()
             return
         self._blocos.put(bloco)
 
+    def _interromper(self) -> None:
+        self.maquina.mandar("cortou")
+        self._parar_fala.set()
+        self._limpar_falas()
+        self._acordado_ate = time.time() + 20   # falou por cima: já está conversando
+        self.maquina.mandar("escutar")
+        self._estado("ouvindo")
+
+    def _limpar_falas(self) -> None:
+        for fila in (self._falas, self._audios):
+            while True:
+                try:
+                    fila.get_nowait()
+                except queue.Empty:
+                    break
+
     def _esvaziar_blocos(self) -> None:
         while True:
             try:
@@ -174,6 +312,34 @@ class Voz:
             except queue.Empty:
                 return
 
+    def _parcial(self) -> None:
+        """Transcrição ao vivo: a cada ~1,6 s de fala, uma passada no que já foi dito."""
+        if not self.local or getattr(self, "_parcial_rodando", False) or os.environ.get("PRIMOCODE_SEM_PARCIAL") == "1":
+            return
+        copia = list(self.gravador._blocos)
+        if not copia:
+            return
+        self._parcial_rodando = True
+
+        def trabalho():
+            try:
+                import numpy as np
+                import wave as _w
+                arq = Path(tempfile.gettempdir()) / "primo-voz-parcial.wav"
+                with _w.open(str(arq), "wb") as w:
+                    w.setnchannels(1)
+                    w.setsampwidth(2)
+                    w.setframerate(escuta.TAXA)
+                    w.writeframes(np.concatenate(copia).astype(np.int16).tobytes())
+                t = transcrever.limpar(transcrever.transcrever(arq))
+                if t and self.gravador._falando:
+                    self.bolinha.enviar({"transcricao": t, "parcial": True})
+            except Exception:
+                pass
+            finally:
+                self._parcial_rodando = False
+        threading.Thread(target=trabalho, daemon=True).start()
+
     def _ouvir(self) -> None:
         mic = escuta.Microfone(self._ao_receber)
         try:
@@ -183,20 +349,26 @@ class Voz:
             self.parar()
             return
         falar_para_o_node({"tipo": "pronto"})
-        self.bolinha.estado("esperando")
+        self._estado("ouvindo" if self.modo == "sempre" else "dormindo")
+        self.sons.tocar("acordou")
+        self._saudar()
         while self._vivo:
             self.gravador.comecar()
             acabou = False
+            ultimo_parcial = 0.0
             while self._vivo and not acabou:
                 try:
                     bloco = self._blocos.get(timeout=0.3)
                 except queue.Empty:
                     continue
                 acabou = self.gravador.alimentar(bloco)
-                # A bolinha acende com a voz da pessoa, no tamanho da voz.
                 if self.gravador._falando and not self._falando:
                     lim = max(1e-6, self.gravador._limiar())
+                    self.luz.mudar("ouvindo", min(1.0, escuta.rms(bloco) / lim * 0.35))
                     self.bolinha.estado("ouvindo", min(1.0, escuta.rms(bloco) / lim * 0.35))
+                    if time.time() - ultimo_parcial > 1.6 and self.gravador.segundos > 1.0:
+                        ultimo_parcial = time.time()
+                        self._parcial()
             if not self._vivo:
                 break
             if self.gravador.encerrou_por == "ninguem-falou" or self.gravador.segundos < 0.4:
@@ -204,16 +376,83 @@ class Voz:
             wav = self.gravador.gravar_wav(Path(tempfile.gettempdir()) / "primo-voz-fala.wav")
             if not wav:
                 continue
-            self.bolinha.estado("pensando")
+            self._t_acabou = time.time()
             texto = transcrever.limpar(self._transcrever(wav))
-            if texto:
-                # Pensando até o terminal dizer o contrário (a resposta em
-                # voz, ou {"tipo":"estado"} quando ele termina sem falar).
-                falar_para_o_node({"tipo": "ouvi", "texto": texto})
-            else:
-                self.bolinha.estado("esperando")
+            self.lat(f"transcrição {time.time() - self._t_acabou:.2f}s (a frase fechou após {escuta.RABO_VAD if self.gravador.vad else escuta.RABO_SILENCIO:.1f}s de silêncio) -> {texto!r}")
+            self._tratar(texto)
         mic.fechar()
 
+    def _tratar(self, texto: str) -> None:
+        """O que foi dito: ativação, apresentação, comando local ou pedido ao terminal."""
+        if not texto:
+            self._estado(self.maquina.estado if self.maquina.estado != "pensando" else "ouvindo")
+            return
+        agora = time.time()
+        acordado = (self.modo == "sempre" or agora < self._acordado_ate or agora < self._ptt_ate)
+        chamou, resto = conversa.ativacao(texto, self.nome)
+        if not acordado and not chamou:
+            self._estado("dormindo")          # não era comigo: não vira pedido
+            return
+        texto = resto if chamou else texto
+        self._acordado_ate = agora + 25
+        self.bolinha.enviar({"transcricao": texto or f"({self.nome}?)", "parcial": False})
+        if not texto:                          # só chamou pelo nome
+            self.sons.tocar("entendeu")
+            self._dizer(identidade.variar(["Oi! Fala.", "Pois não?", "Tô aqui."], self._ultimo_ok))
+            self.maquina.mandar("ativar")
+            return
+        novo = identidade.aprender(texto)
+        if novo:
+            self.cfg = identidade.salvar(**novo)
+            if "nome" in novo:
+                self.nome = novo["nome"]
+                self.bolinha.enviar({"nome": self.nome})
+                self._dizer(f"Fechado. Agora eu me chamo {self.nome}.")
+            else:
+                self._dizer(f"Prazer, {novo['pessoa']}! Vou lembrar.")
+            return
+        nova = fala.voz_pedida(texto, self.voz_id)
+        if nova:
+            self.voz_id = nova
+            self.cfg = identidade.salvar(voz=nova)
+            self._dizer("Fechado. Agora estou com a voz do Antonio." if nova == "antonio" else f"Fechado. Agora estou com a voz da {nova.capitalize()}.")
+            return
+        cmd = conversa.comando(texto)
+        if cmd == "esconder":
+            self.bolinha.enviar({"painel": "esconder"})
+            self.sons.tocar("painel_fecha")
+            return
+        if cmd == "mostrar":
+            self.bolinha.enviar({"painel": "mostrar"})
+            self.sons.tocar("painel_abre")
+            return
+        if cmd == "parar":
+            self._parar_fala.set()
+            self._limpar_falas()
+            self.maquina.mandar("parar")
+            falar_para_o_node({"tipo": "parar"})
+            self._estado("ouvindo")
+            return
+        if cmd == "olhar":
+            texto = "Tire um print da minha tela agora, olhe e me diga em uma ou duas frases o que está acontecendo."
+        elif cmd == "resumo_dia":
+            texto = ("Faça o resumo do meu dia no projeto atual, em poucas frases faladas: PRs abertos (gh pr list), "
+                     "se os testes passam e o que mudou hoje no git. O detalhe vai no painel.")
+        self.sons.tocar("entendeu", falando=self._falando)
+        self.maquina.mandar("ouviu")
+        self._estado("pensando")
+        falar_para_o_node({"tipo": "ouvi", "texto": texto})
+
+    def _saudar(self) -> None:
+        if self.cfg.get("pessoa") or True:
+            self._dizer(identidade.saudacao(time.localtime().tm_hour, self.cfg.get("pessoa", ""), self.nome))
+
+    def _dizer(self, texto: str) -> None:
+        """Fala uma frase curta já pronta (sem passar pelo resumo)."""
+        self._ultimo_ok = texto
+        self.bolinha.enviar({"resposta": texto})
+        self._falas.put(texto)
+
     def _transcrever(self, wav: Path) -> str:
         """Primeiro aqui, com o Whisper local. O servidor só entra se o local
         não estiver instalado ou falhar — e diz que caiu."""
@@ -242,45 +481,141 @@ class Voz:
             avisar(f"não deu para transcrever: {e}")
             return ""
 
-    # ── a boca ───────────────────────────────────────────────────────────
+    # ── a boca: frase a frase, a próxima já sendo gerada enquanto a atual toca ──
 
     def _falar_em_fila(self) -> None:
+        """Sintetiza a próxima frase enquanto a anterior toca (o 1º áudio sai
+        depois de UMA frase, não do texto inteiro)."""
+        threading.Thread(target=self._tocar_em_fila, daemon=True).start()
         while self._vivo:
             try:
                 texto = self._falas.get(timeout=0.3)
             except queue.Empty:
                 continue
-            self._falar(texto)
-
-    def _falar(self, texto: str) -> None:
-        limpo = " ".join(str(texto).split())
+            for frase in conversa.dividir_frases(texto):
+                mp3 = self._sintetizar(frase)
+                if mp3:
+                    while self._vivo:
+                        try:
+                            self._audios.put(mp3, timeout=0.3)
+                            break
+                        except queue.Full:
+                            continue
+
+    def _cache_de(self, frase: str) -> "Path | None":
+        """Onde fica a versão em cache de uma frase curta (None se for longa demais para valer a pena)."""
+        if len(frase) > 90 or self.cfg.get("tts", "edge") == "elevenlabs":
+            return None
+        import hashlib
+        pasta = Path.home() / ".primocode" / "voz-cache"
+        pasta.mkdir(parents=True, exist_ok=True)
+        if re.match(r"^São \d+ (?:e \d\d|horas em ponto)\.$", frase):
+            return pasta / ("hora-" + self.voz_id + "-" + hashlib.sha1(frase.encode("utf-8")).hexdigest()[:10] + ".mp3")
+        return pasta / (self.voz_id + "-" + hashlib.sha1(frase.encode("utf-8")).hexdigest()[:16] + ".mp3")
+
+    def _cache_horas(self) -> None:
+        agora = time.time()
+        for dm in (0, 1, 2):
+            f = fala.hora_falada(time.localtime(agora + 60 * dm))
+            c = self._cache_de(f)
+            if c is not None and not c.exists():
+                self.edge.sintetizar(f, self.voz_id, c)
+
+    def _pre_aquecer_frases(self) -> None:
+        """As frases que o Primo mais diz entram no cache em segundo plano: a confirmação sai na hora."""
+        self.edge.aquecer()
+        self._cache_horas()
+        for f in ("Já vejo.", "Deixa eu ver.", "Um instante.", "Pode deixar.", "Feito.", "Aumentei.", "Abaixei.", "Pulei.", "Voltei.",
+                  "Oi! Fala.", "Pois não?", "Tô aqui.", "Não consegui uma resposta agora."):
+            c = self._cache_de(f)
+            if c is not None and not c.exists():
+                self.edge.sintetizar(f, self.voz_id, c)
+        while self._vivo:                       # a hora do minuto atual e dos próximos: "que horas são?" sai sem esperar a rede
+            self._cache_horas()
+            for velho in (Path.home() / ".primocode" / "voz-cache").glob("hora-*.mp3"):     # só os minutos que já passaram
+                try:
+                    if time.time() - velho.stat().st_mtime > 600:
+                        velho.unlink()
+                except OSError:
+                    pass
+            time.sleep(20)
+
+    def _sintetizar(self, frase: str) -> "Path | None":
+        limpo = " ".join(str(frase).split())[:600]
         if not limpo:
-            return
-        if len(limpo) > 900:
-            limpo = limpo[:880].rsplit(" ", 1)[0] + "…"
+            return None
+        t0 = time.time()
         mp3 = Path(tempfile.gettempdir()) / f"primo-voz-{int(time.time() * 1000)}.mp3"
+        # 0. frase curta já dita antes (ou pré-aquecida): sai do cache, sem rede
+        guardada = self._cache_de(limpo)
+        if guardada is not None and guardada.exists():
+            shutil.copyfile(guardada, mp3)
+            self.lat(f"voz do cache ({self.voz_id}): {time.time() - t0:.3f}s")
+            return mp3
+        # 1. Edge TTS neural pt-BR, no próprio processo (sem subprocesso por frase)
+        if self.cfg.get("tts", "edge") != "elevenlabs" and self.edge.sintetizar(limpo, self.voz_id, mp3) and mp3.exists():
+            self.lat(f"voz edge/{self.voz_id}: {time.time() - t0:.2f}s para {len(limpo)} caracteres")
+            if guardada is not None:
+                try:
+                    shutil.copyfile(mp3, guardada)
+                except OSError:
+                    pass
+            return mp3
+        # 2. ElevenLabs, só se a pessoa pediu
         narrar = AQUI.parent.parent / "studio" / "narrar.py"
-        r = subprocess.run(
-            [sys.executable, str(narrar), "falar", "--texto", limpo, "--saida", str(mp3), "--voz", self.voz],
-            capture_output=True, timeout=180)
-        if r.returncode != 0 or not mp3.exists():
-            avisar(motivo_da_narracao(r))
-            return
-        self._falando = True
-        self._parar_fala.clear()
-        self.bolinha.estado("falando", 0.6)
-        try:
-            self._tocar(mp3)
-        finally:
-            self._falando = False
-            self.bolinha.estado("esperando")
-            self.corte.nivel_dele = 0.0
-            # O que o microfone pegou enquanto ele falava é a voz dele.
-            self._esvaziar_blocos()
+        r = None
+        if self.cfg.get("tts") == "elevenlabs":
             try:
-                mp3.unlink()
-            except OSError:
-                pass
+                r = subprocess.run([sys.executable, str(narrar), "falar", "--texto", limpo, "--saida", str(mp3), "--voz", self.voz_id],
+                                   capture_output=True, timeout=60)
+            except Exception as e:
+                avisar(f"não deu para gerar a voz: {e}")
+        if r is not None and r.returncode == 0 and mp3.exists():
+            return mp3
+        # 3. offline: a voz do sistema
+        if sys.platform == "darwin" and shutil.which("say"):
+            aiff = mp3.with_suffix(".aiff")
+            if subprocess.run(["say", "-v", "Luciana", "-o", str(aiff), limpo], capture_output=True).returncode == 0 or \
+                    subprocess.run(["say", "-o", str(aiff), limpo], capture_output=True).returncode == 0:
+                self.lat(f"voz offline (say): {time.time() - t0:.2f}s")
+                return aiff
+        avisar("não deu para gerar a voz (sem internet e sem voz do sistema). O texto está no painel.")
+        self._erro("Não consegui gerar a voz. O texto está no painel.")
+        return None
+
+    def _tocar_em_fila(self) -> None:
+        while self._vivo:
+            try:
+                arq = self._audios.get(timeout=0.3)
+            except queue.Empty:
+                if self._falando and self._falas.empty():
+                    self._acabou_de_falar()
+                continue
+            if not self._falando:
+                self._falando = True
+                self._parar_fala.clear()
+                self.maquina.mandar("resposta")
+                self._estado("falando", 0.6)
+            try:
+                self._tocar(arq)
+            finally:
+                try:
+                    arq.unlink()
+                except OSError:
+                    pass
+                if self._parar_fala.is_set():
+                    self._acabou_de_falar()
+
+    def _acabou_de_falar(self) -> None:
+        if not self._falando:
+            return
+        self._falando = False
+        self.maquina.mandar("fim_fala")
+        self._estado("ouvindo" if self.modo == "sempre" or time.time() < self._acordado_ate else "dormindo")
+        self._acordado_ate = max(self._acordado_ate, time.time() + 20)
+        self.sons.tocar("pronto")
+        self.corte.nivel_dele = 0.0
+        self._esvaziar_blocos()      # o que o microfone pegou era a voz dele
 
     def _tocar(self, arquivo: Path) -> None:
         """Toca o mp3 com o que a máquina tiver — interrompível, porque falar
@@ -296,12 +631,24 @@ class Voz:
             ["mpv", "--no-video", "--really-quiet", str(arquivo)],
             ["cvlc", "--play-and-exit", "--intf", "dummy", str(arquivo)],
         ]
+        env = dados_tela.envelope(arquivo)        # volume real da fala dele: barras da tela e luz do teclado seguem
         for cmd in tentativas:
             try:
                 p = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
             except (FileNotFoundError, OSError):
                 continue
+            t0 = time.time()
+            if self._t_acabou:
+                self.lat(f"fim da fala -> primeira palavra falada: {t0 - self._t_acabou:.2f}s (+ o silêncio que fechou a frase)")
+                self._t_acabou = None
+            if os.environ.get("PRIMOCODE_HUD_PONTE") == "1":
+                avisar(f"falando ({cmd[0]}): {arquivo.name}")
             while p.poll() is None:
+                if env:
+                    i = int((time.time() - t0) / 0.05)
+                    nv = env[i] if i < len(env) else 0.0
+                    self.bolinha.estado("falando", nv)
+                    self.luz.mudar("falando", nv)
                 if self._parar_fala.is_set() or not self._vivo:
                     try:
                         p.terminate()
@@ -309,6 +656,8 @@ class Voz:
                         pass
                     return
                 time.sleep(0.05)
+            if os.environ.get("PRIMOCODE_HUD_PONTE") == "1":
+                avisar(f"falou por {time.time() - t0:.1f}s (saída {p.returncode})")
             if p.returncode == 0:
                 return
             # INICIAR não é TOCAR: o tocador que abriu e morreu não conta, e o
@@ -332,16 +681,38 @@ class Voz:
                 continue
             tipo = msg.get("tipo")
             if tipo == "falar":
-                self._falas.put(str(msg.get("texto") or ""))
+                texto = str(msg.get("texto") or "")
+                if msg.get("bruto"):
+                    # a voz resume; o texto inteiro (código, listas) vai ao painel
+                    fala, tela = conversa.resumo(texto)
+                    self.bolinha.enviar({"resposta": tela[:700]})
+                    texto = conversa.frase_final(fala)
+                    self._acordado_ate = time.time() + 25
+                self._falas.put(texto)
+            elif tipo == "ferramenta":
+                self.maquina.mandar("ferramenta")
+                self._estado("executando")
+                conf = conversa.confirmacao(msg.get("nome", ""), msg.get("args"))
+                if conf and time.time() - self._ultima_conf > 8 and not self._falando:
+                    self._ultima_conf = time.time()
+                    self._falas.put(conf)
             elif tipo == "calar":
                 self._parar_fala.set()
-                while not self._falas.empty():
-                    try:
-                        self._falas.get_nowait()
-                    except queue.Empty:
-                        break
+                self._limpar_falas()
             elif tipo == "estado":
-                self.bolinha.estado(str(msg.get("estado") or "esperando"))
+                est = str(msg.get("estado") or "esperando")
+                if est == "erro":
+                    self._erro("Deu ruim. O detalhe está no terminal.")
+                    est = "ouvindo"
+                self.maquina.mandar("sem_fala")
+                self._estado("ouvindo" if est == "esperando" and time.time() < self._acordado_ate else
+                             ("dormindo" if est == "esperando" else est))
+                if est == "esperando":
+                    self.sons.tocar("pronto", falando=self._falando)
+            elif tipo == "acao":
+                self._acao_do_painel(str(msg.get("acao") or ""))
+            elif tipo == "painel":
+                self.bolinha.enviar({"painel": msg.get("acao", "alternar")})
             elif tipo == "fim":
                 break
         self.parar()
@@ -351,6 +722,7 @@ class Voz:
             return
         self._vivo = False
         self._parar_fala.set()
+        self.luz.fechar()
         self.bolinha.fechar()
         falar_para_o_node({"tipo": "fim"})