primocode 10.15.0 → 10.15.2

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.15.0
+# PrimoCode v10.15.2
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v10.15.0
+ ▐▛███▜▌   Primo Code v10.15.2
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/bin/primocode.js

@@ -2519,6 +2519,7 @@ async function handleSlash(text) {
                 break;
             }
             for (const a of prep.avisos) console.log(c.dim(`  ${a}`));
+            if (process.platform === 'darwin') { try { vozModo.instalarApp({ python: prep.python }); } catch { /* o app é bônus */ } }
 
             const sessao = vozModo.abrir({
                 python: prep.python,
@@ -2922,7 +2923,14 @@ async function main() {
             r.processo.on('close', () => process.exit(0));
             return;
         }
-        console.log('Uso: primocode voz nome <Nome> | primocode voz painel (o resto é /voice dentro da sessão)');
+        if (sub === 'instalar-app') {
+            const py = vz.python();
+            if (!py) { console.log('O app precisa do Python 3 (rode /voice uma vez para preparar o ambiente).'); process.exit(1); }
+            const r = vz.instalarApp({ python: py, dock: resto.includes('--dock') });
+            console.log(r.ok ? `Primo.app instalado em ${r.app}. Abra pelo Launchpad, Spotlight ou Finder.` : `Não deu: ${r.erro || 'veja o log'}`);
+            process.exit(r.ok ? 0 : 1);
+        }
+        console.log('Uso: primocode voz nome <Nome> | primocode voz painel | primocode voz instalar-app [--dock] (o resto é /voice dentro da sessão)');
         process.exit(0);
     }
     if (['doutor', 'doctor', 'preparar'].includes(process.argv[2])) {
@@ -2953,7 +2961,11 @@ async function main() {
     state.workDirOrigem = 'padrao';
     // O projeto em que se estava na última sessão (até uma semana atrás): o
     // "continua o jogo" de amanhã cai nele, e não num projeto novo.
-    const lembrado = cfg.projetoLembrado();
+    // O app do Primo (voz) manda a pasta de cada pedido: PRIMOCODE_PASTA (+ ORIGEM) e nunca herda a última do terminal.
+    const lembrado = process.env.PRIMOCODE_APP === '1'
+        ? (process.env.PRIMOCODE_PASTA && fs.existsSync(process.env.PRIMOCODE_PASTA)
+            ? { dir: process.env.PRIMOCODE_PASTA, origem: process.env.PRIMOCODE_PASTA_ORIGEM === '/dir' ? '/dir' : 'projeto' } : null)
+        : cfg.projetoLembrado();
     if (lembrado && pastaSegura(lembrado.dir)) {
         state.workDir = lembrado.dir;
         state.currentProject = path.basename(lembrado.dir);
@@ -2962,7 +2974,7 @@ async function main() {
 
     // Modo guardado entre sessões. O padrão é auto: sem ele, um "oi" gasta o
     // mesmo que uma refatoração.
-    state.mode = ['primocode', 'chat', 'auto'].includes(state.config.mode) ? state.config.mode : 'auto';
+    state.mode = ['primocode', 'chat', 'auto'].includes(process.env.PRIMOCODE_MODO || state.config.mode) ? (process.env.PRIMOCODE_MODO || state.config.mode) : 'auto';
 
     // `-c` / `--continue` pode vir em qualquer posição e sai da lista: o
     // resto (one-shot, -f) segue sendo lido do jeito de sempre.
@@ -3007,6 +3019,9 @@ async function main() {
             if (typeof fl.resume === 'string') await retomarConversa(fl.resume);
             else if (continuar) await continuarUltima();
             state.semTerminal = true;
+            if (process.env.PRIMOCODE_LOG_FERRAMENTAS === '1') {     // o app do Primo registra cada ferramenta no log dele
+                require('../lib/voz-ponte').escutar((nome, a) => process.stderr.write(`ferramenta: ${nome} ${JSON.stringify(a || {}).slice(0, 220)}\n`));
+            }
             let erro = null;
             const texto = await H.capturar(async () => {
                 try { await sendPrompt(pedido); } catch (e) { erro = e.message || String(e); }

package/lib/config.js

@@ -16,7 +16,7 @@ const os = require('os');
 const { nomeCurto } = require('./nome-curto.js');
 
 const HOME = os.homedir();
-const ROOT_DIR = path.join(HOME, 'primocode');
+const ROOT_DIR = process.env.PRIMOCODE_RAIZ || path.join(HOME, 'primocode');   // o app do Primo usa ~/Primo
 const CONFIG_DIR = path.join(HOME, '.primocode');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 const HISTORY_FILE = path.join(CONFIG_DIR, 'history.jsonl');

package/lib/conta.js

@@ -213,6 +213,7 @@ async function entrar({ email, senha } = {}, op = {}) {
 }
 
 function abrirNoNavegador(url) {
+    if (process.env.PRIMOCODE_SEM_NAVEGADOR === '1') return false;   // app do Primo (voz): navegador só com clique explícito
     const [cmd, args] = process.platform === 'darwin' ? ['open', [url]]
         : process.platform === 'win32' ? ['cmd', ['/c', 'start', '""', url]]
             : ['xdg-open', [url]];

package/lib/estudio/exportar.js

@@ -156,6 +156,7 @@ function registrar({ id, assunto, caminho, formato, duracao, assinatura, entrega
 }
 const listar = (arq) => ler(arq).filter((v) => v.caminho && fs.existsSync(v.caminho)).sort((a, b) => String(b.data).localeCompare(String(a.data)));
 function abrirNoSistema(alvo) {
+    if (process.env.PRIMOCODE_SEM_NAVEGADOR === '1') return false;   // app do Primo (voz): navegador só com clique explícito
     const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
     const args = process.platform === 'win32' ? ['/c', 'start', '""', alvo] : [alvo];
     return spawnSync(cmd, args, { stdio: 'ignore' }).status === 0;

package/lib/mcp.js

@@ -204,6 +204,7 @@ function conectarHttp(def, { tetoMs = 60000, nome, buscar = globalThis.fetch } =
 const b64url = (b) => Buffer.from(b).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
 
 function abrirUrl(url) {
+    if (process.env.PRIMOCODE_SEM_NAVEGADOR === '1') return false;   // app do Primo (voz): navegador só com clique explícito
     const [cmd, args] = process.platform === 'darwin' ? ['open', [url]]
         : process.platform === 'win32' ? ['cmd', ['/c', 'start', '""', url]]
             : ['xdg-open', [url]];

package/lib/tools.js

@@ -304,6 +304,7 @@ async function runShell(command, timeout = 60000, cwd, env) {
 // UM argumento, não texto que um shell reinterpreta — sem isso, um valor tipo
 // `https://x/"; touch /tmp/pwned; echo "` injetava comando (achado de segurança).
 function openInBrowser(target) {
+    if (process.env.PRIMOCODE_SEM_NAVEGADOR === '1') return Promise.resolve({ ok: false, error: 'o navegador está bloqueado no modo voz: só abre quando a pessoa clica' });   // app do Primo (voz): navegador só com clique explícito
     const p = os.platform();
     const [cmd, args, opener] = p === 'darwin' ? ['open', [target], 'open']
         : p === 'win32' ? ['cmd.exe', ['/c', 'start', '', target], 'start']

package/lib/voz.js

@@ -322,6 +322,7 @@ function abrir({ python: py, servidor, token, voz, aoParar = () => {}, aoOuvir,
 const OPCIONAIS = () => [
     ['faster_whisper', 'faster-whisper', 'a transcrição local (Whisper)'],
     ['pysilero_vad', 'pysilero-vad', 'o fim de fala preciso (Silero VAD)'],
+    ['edge_tts', 'edge-tts', 'a voz neural pt-BR (Edge TTS)'],
     ...(process.platform === 'darwin' ? [
         ['WebKit', 'pyobjc-framework-WebKit', 'o painel em tela cheia do Primo'],
         ['EventKit', 'pyobjc-framework-EventKit', 'os compromissos de hoje do app Calendário'],
@@ -466,11 +467,34 @@ async function preparar(aoFalar = () => {}) {
     return { ok: true, python: py, avisos };
 }
 
+/** Primo.app em ~/Applications (Launchpad/Spotlight) + o primo-app.json com os caminhos ABSOLUTOS de node e primocode:
+ *  o app aberto pelo Finder não tem o PATH do terminal. Chamado no primeiro /voice e por `primocode voz instalar-app`. */
+function instalarApp({ python: py, dock = false } = {}) {
+    if (process.platform !== 'darwin') return { ok: false, erro: 'o app do Primo é só para macOS' };
+    try {
+        let cfg = {};
+        try { cfg = require('./config').loadConfig(); } catch { /* usa o padrão do app */ }
+        const arq = path.join(os.homedir(), '.primocode', 'primo-app.json');
+        fs.mkdirSync(path.dirname(arq), { recursive: true });
+        fs.writeFileSync(arq, JSON.stringify({
+            node: process.execPath, primocode: path.resolve(__dirname, '..', 'bin', 'primocode.js'),
+            servidor: cfg.server || '', path: process.env.PATH || '', voz: cfg.voz || 'antonio', versao: require('../package.json').version,
+        }, null, 2));
+        const env = { ...process.env, PYTHONPATH: PASTA, ...(dock ? { PRIMOCODE_APP_DOCK: '1' } : {}) };
+        const linhas = execFileSync(py, ['-m', 'primo_voz.appmac'], { cwd: PASTA, env, encoding: 'utf8', timeout: 60000, stdio: ['ignore', 'pipe', 'ignore'] }).trim().split('\n');
+        return { ok: !!linhas[0], exe: linhas[0] || null, pythonpath: linhas[1] || PASTA, app: path.join(os.homedir(), 'Applications', 'Primo.app') };
+    } catch (e) { return { ok: false, erro: e.message }; }
+}
+
 /** `/voice painel`: só o HUD (sem microfone). Mac com PyObjC = tela cheia; senão, o quadro no terminal. */
 function abrirPainel({ python: py }) {
     const mac = process.platform === 'darwin' && temModulo(py, 'WebKit');
-    const p = spawn(py, ['-m', mac ? 'primo_voz.hud' : 'primo_voz.painel_tui', ...(mac ? ['--livre'] : [])], {
-        cwd: PASTA, env: { ...process.env, PYTHONPATH: PASTA }, stdio: mac ? 'ignore' : ['pipe', 'inherit', 'inherit'],
+    // No Mac o painel roda pelo Primo.app (Dock e Cmd+Tab mostram "Primo" com o ícone); sem ele, o python direto.
+    let exe = null, pp = PASTA;
+    if (mac) { const r = instalarApp({ python: py }); if (r.exe) { exe = r.exe; pp = r.pythonpath; } }
+    const [cmd, args] = exe ? [exe, ['-m', 'primo_voz.hud', '--livre']] : [py, ['-m', mac ? 'primo_voz.hud' : 'primo_voz.painel_tui', ...(mac ? ['--livre'] : [])]];
+    const p = spawn(cmd, args, {
+        cwd: PASTA, env: { ...process.env, PYTHONPATH: exe ? pp : PASTA }, stdio: mac ? 'ignore' : ['pipe', 'inherit', 'inherit'],
     });
     return { processo: p, tela: mac };
 }
@@ -505,4 +529,4 @@ function linhasDoutor() {
     ];
 }
 
-module.exports = { definirNome, VENV, abrirPainel, linhasDoutor, DICA_COMPUTADOR, paraFalar, conferir, instalar, preparar, porqueOPipFalhou, abrir, python, PASTA };
+module.exports = { instalarApp, definirNome, VENV, abrirPainel, linhasDoutor, DICA_COMPUTADOR, paraFalar, conferir, instalar, preparar, porqueOPipFalhou, abrir, python, PASTA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "10.15.0",
+  "version": "10.15.2",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {

package/voz/primo_voz/__main__.py

@@ -31,6 +31,7 @@ from __future__ import annotations
 import json
 import os
 import queue
+import re
 import shutil
 import subprocess
 import sys
@@ -42,12 +43,36 @@ from pathlib import Path
 AQUI = Path(__file__).resolve().parent
 sys.path.insert(0, str(AQUI.parent))
 
-from primo_voz import conversa, escuta, identidade, painel, transcrever  # noqa: E402
+from primo_voz import conversa, escuta, fala, fala_pt, 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:
     """A orb (orbe.py) num processo à parte: este só diz o estado a ela.
 
@@ -62,6 +87,9 @@ class Bolinha:
         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":
@@ -72,11 +100,19 @@ class Bolinha:
                 pass
         self.modulo = modulo
         try:
-            self.p = subprocess.Popen([sys.executable, "-m", modulo], cwd=str(AQUI.parent),
+            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, "PYTHONPATH": str(AQUI.parent)}, text=True)
+                                      env={**os.environ, **env_extra}, text=True)
             if modulo.endswith("hud"):
                 threading.Thread(target=self._ler_acoes, daemon=True).start()
         except Exception:
@@ -189,6 +225,12 @@ class Voz:
         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
+        self._pend = ""
+        self._pend_ate = 0.0
+        threading.Thread(target=self._pre_aquecer_frases, daemon=True).start()
         self.gravador = escuta.Gravador()
         self.gravador.vad = escuta.criar_vad()
         self.corte = escuta.Corte()
@@ -209,6 +251,10 @@ class Voz:
         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:
@@ -270,7 +316,7 @@ class Voz:
 
     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):
+        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:
@@ -328,14 +374,64 @@ class Voz:
             if not self._vivo:
                 break
             if self.gravador.encerrou_por == "ninguem-falou" or self.gravador.segundos < 0.4:
+                if self._pend and time.time() >= self._pend_ate:      # ninguém continuou: agora sim vira pedido
+                    pend, self._pend = self._pend, ""
+                    self.gravador.espera = escuta.ESPERA_COMECAR
+                    self.lat(f"frase completa após a pausa extra: {pend!r}")
+                    self._tratar(pend)
                 continue
             wav = self.gravador.gravar_wav(Path(tempfile.gettempdir()) / "primo-voz-fala.wav")
             if not wav:
                 continue
+            self._t_acabou = time.time()
             texto = transcrever.limpar(self._transcrever(wav))
-            self._tratar(texto)
+            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._juntar_e_tratar(texto)
         mic.fechar()
 
+    # "espera": a pessoa segura a vez. Palavras que, sozinhas no fim, prometem continuação.
+    _SEGURA = re.compile(r"(?:^|[\s,.])(?:espera|espere|pera ai|perai|aguarda|aguarde|calma|deixa eu pensar)[\s.!?,]*$", re.I)
+    _CONTINUA = re.compile(r"\b(?:e|ou|mas|ent[aã]o|que|tipo|porque|pois|a[ií]|pra|para|de|do|da|no|na|com|como|se|quando|ent[aã]o|tamb[eé]m|a|o|um|uma|meu|minha)\W*$", re.I)
+
+    def _incompleta(self, texto: str) -> bool:
+        t = texto.strip()
+        if not t:
+            return False
+        if t[-1] in ".?!":
+            return False
+        if t[-1] in ",;:…-" or self._CONTINUA.search(t):
+            return True
+        return len(t.split()) >= 5    # sem pontuação de fim numa frase já longa: provavelmente vem mais; comando curto não espera
+
+    def _juntar_e_tratar(self, texto: str) -> None:
+        """Fim de fala ADAPTATIVO: 1,1 s de silêncio já fechou; se a frase soa incompleta ("e…", "então…", sem ponto)
+        ou a pessoa disse "espera", ele segura mais um pouco e junta com o que vier. Nunca corta no meio."""
+        if self._pend:
+            texto = (self._pend + " " + texto).strip()
+            self._pend = ""
+        if not texto:
+            self.gravador.espera = escuta.ESPERA_COMECAR
+            self._tratar(texto)
+            return
+        if self._SEGURA.search(texto):
+            resto = self._SEGURA.sub("", texto).strip(" ,")
+            self._pend, self._pend_ate = resto or " ", time.time() + 10
+            self.gravador.espera = 10.0
+            self.lat("a pessoa pediu para esperar: segurando até 10 s")
+            self.bolinha.enviar({"transcricao": (resto + " …") if resto else "…", "parcial": True})
+            self._estado("ouvindo")
+            return
+        if self._incompleta(texto):
+            self._pend, self._pend_ate = texto, time.time() + 1.6
+            self._acordado_ate = max(self._acordado_ate, time.time() + 30)
+            self.gravador.espera = 1.6
+            self.lat(f"frase incompleta, esperando mais 1,6 s: {texto!r}")
+            self.bolinha.enviar({"transcricao": texto + " …", "parcial": True})
+            self._estado("ouvindo")
+            return
+        self.gravador.espera = escuta.ESPERA_COMECAR
+        self._tratar(texto)
+
     def _tratar(self, texto: str) -> None:
         """O que foi dito: ativação, apresentação, comando local ou pedido ao terminal."""
         if not texto:
@@ -345,6 +441,8 @@ class Voz:
         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.lat(f"ignorado (sem o nome \"{self.nome}\" e fora da conversa): {texto!r}")
+            self.bolinha.enviar({"transcricao": f"(diga \"{self.nome}\" antes do pedido) {texto}", "parcial": False})
             self._estado("dormindo")          # não era comigo: não vira pedido
             return
         texto = resto if chamou else texto
@@ -365,6 +463,12 @@ class Voz:
             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"})
@@ -450,28 +554,89 @@ class Voz:
                         except queue.Full:
                             continue
 
+    def _cache_de(self, frase: str, hora: bool = False) -> "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 hora:
+            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 = " ".join(fala_pt.normalizar(fala.hora_falada(time.localtime(agora + 60 * dm))).split())
+            c = self._cache_de(f, hora=True)
+            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 ("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]
+        limpo = " ".join(fala_pt.normalizar(frase).split())[:900]      # números, unidades, siglas: por extenso, como se fala
         if not limpo:
             return None
+        t0 = time.time()
+        self.lat(f"vai falar: {limpo[:140]!r}")
         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 not guardada.exists():
+            guardada = self._cache_de(limpo, hora=True) if self._cache_de(limpo, hora=True).exists() else guardada
+        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"
-        try:
-            r = subprocess.run(
-                [sys.executable, str(narrar), "falar", "--texto", limpo, "--saida", str(mp3), "--voz", self.voz],
-                capture_output=True, timeout=180)
-        except Exception as e:
-            avisar(f"não deu para gerar a voz: {e}")
-            return None
-        if r.returncode != 0 or not mp3.exists():
-            if sys.platform == "darwin" and shutil.which("say"):   # reserva: a voz do sistema
-                aiff = mp3.with_suffix(".aiff")
-                if subprocess.run(["say", "-o", str(aiff), limpo], capture_output=True).returncode == 0:
-                    return aiff
-            avisar(motivo_da_narracao(r))
-            self._erro("Não consegui gerar a voz. O texto está no painel.")
-            return None
-        return mp3
+        r = None
+        if self.cfg.get("tts") == "elevenlabs":
+            try:
+                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:
@@ -502,7 +667,7 @@ class Voz:
         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._acordado_ate = max(self._acordado_ate, time.time() + 90)    # conversa em andamento: 90 s sem repetir o nome
         self.sons.tocar("pronto")
         self.corte.nivel_dele = 0.0
         self._esvaziar_blocos()      # o que o microfone pegou era a voz dele
@@ -528,6 +693,11 @@ class Voz:
             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)
@@ -541,6 +711,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
@@ -565,7 +737,10 @@ class Voz:
             tipo = msg.get("tipo")
             if tipo == "falar":
                 texto = str(msg.get("texto") or "")
-                if msg.get("bruto"):
+                if msg.get("painel"):                       # o cérebro já mandou o texto FALADO e o ESCRITO separados
+                    self.bolinha.enviar({"resposta": str(msg["painel"])[:1500]})
+                    self._acordado_ate = time.time() + 90
+                elif 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]})
@@ -592,6 +767,8 @@ class Voz:
                              ("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":