primocode 10.15.1 → 10.15.2

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.15.1
+# 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.1
+ ▐▛███▜▌   Primo Code v10.15.2
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/bin/primocode.js

@@ -2961,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);
@@ -2970,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.
@@ -3015,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "10.15.1",
+  "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

@@ -43,7 +43,7 @@ from pathlib import Path
 AQUI = Path(__file__).resolve().parent
 sys.path.insert(0, str(AQUI.parent))
 
-from primo_voz import conversa, escuta, fala, 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
@@ -228,6 +228,8 @@ class Voz:
         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()
@@ -372,6 +374,11 @@ 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:
@@ -379,9 +386,52 @@ class Voz:
             self._t_acabou = time.time()
             texto = transcrever.limpar(self._transcrever(wav))
             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)
+            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:
@@ -391,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
@@ -502,22 +554,22 @@ class Voz:
                         except queue.Full:
                             continue
 
-    def _cache_de(self, frase: str) -> "Path | None":
+    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 re.match(r"^São \d+ (?:e \d\d|horas em ponto)\.$", frase):
+        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 = fala.hora_falada(time.localtime(agora + 60 * dm))
-            c = self._cache_de(f)
+            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)
 
@@ -525,7 +577,7 @@ class Voz:
         """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.",
+        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():
@@ -541,13 +593,16 @@ class Voz:
             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")
@@ -612,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
@@ -682,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]})

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()
@@ -112,6 +153,9 @@ class App:
         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))
 
@@ -179,7 +223,7 @@ 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"))})
@@ -250,9 +294,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 +312,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 +320,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 +381,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()
@@ -325,7 +426,7 @@ class App:
     def iniciar(self, js, p) -> 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()
+        threading.Timer(2.0, lambda: self.painel({"pasta": self.rotulo(), "login": logado()})).start()
 
 
 def main() -> int:

package/voz/primo_voz/appmac.py

@@ -18,7 +18,7 @@ from pathlib import Path
 
 AQUI = Path(__file__).resolve().parent
 ICONE = AQUI / "vendor" / "primo-icone.png"
-VERSAO = "6"          # sobe quando o bundle muda: força regerar
+VERSAO = "7"          # sobe quando o bundle muda: força regerar
 
 
 def pasta_app() -> Path:
@@ -83,6 +83,7 @@ def preparar() -> str | None:
             "CFBundleExecutable": "Primo-iniciar", "CFBundleIconFile": "Primo", "CFBundlePackageType": "APPL",
             "CFBundleShortVersionString": "1.0", "CFBundleVersion": "1", "LSMinimumSystemVersion": "11.0",
             "NSHighResolutionCapable": True, "NSPrincipalClass": "NSApplication",
+            "NSSpeechRecognitionUsageDescription": "O Primo entende o que você fala usando o reconhecimento de voz do Mac, no próprio computador.",
             "NSMicrophoneUsageDescription": "O Primo ouve você pelo microfone para atender os seus pedidos por voz.",
             "NSCalendarsFullAccessUsageDescription": "O Primo mostra os compromissos de hoje no painel.",
             "NSCalendarsUsageDescription": "O Primo mostra os compromissos de hoje no painel.",

package/voz/primo_voz/conversa.py

@@ -136,10 +136,22 @@ def limpar_para_voz(texto: str) -> str:
     return re.sub(r"\s+", " ", t).strip()
 
 
-def resumo(texto: str, frases: int = 2, teto: int = 260) -> Tuple[str, str]:
-    """(fala, painel). A voz resume; o texto inteiro (código, listas) vai ao painel."""
+def resumo(texto: str, frases: int = 60, teto: int = 3000) -> Tuple[str, str]:
+    """(fala, painel). A voz diz a resposta COMPLETA (sem código, links nem caminhos); o painel guarda o texto
+    inteiro. Só código e lista enorme ficam fora da fala — e aí a prosa em volta já diz o que foi feito."""
     painel = str(texto or "").strip()
-    limpo = limpar_para_voz(painel)
+    sem_codigo = re.sub(r"```[\s\S]*?```", " ", painel)
+    # lista ENORME (mais de 8 itens seguidos) não é lida item a item
+    linhas, saida, run = sem_codigo.splitlines(), [], []
+    for l in linhas + [""]:
+        if re.match(r"^\s*(?:[-*•]|\d+[.)])\s+", l):
+            run.append(l)
+            continue
+        if run:
+            saida += run if len(run) <= 8 else [f"São {len(run)} itens, a lista completa está no painel."]
+            run = []
+        saida.append(l)
+    limpo = limpar_para_voz("\n".join(saida))
     partes = [p.strip() for p in re.findall(r"[^.!?…]+[.!?…]*", limpo) if p.strip()]
     fala = ""
     for p in partes[:frases]:
@@ -148,9 +160,8 @@ def resumo(texto: str, frases: int = 2, teto: int = 260) -> Tuple[str, str]:
         fala = (fala + " " + p).strip()
     if not fala:
         fala = limpo[:teto].strip()
-    tinha_mais = bool(re.search(r"```", painel)) or len(partes) > frases
-    if tinha_mais and fala and not re.search(r"painel|tela", fala, re.I):
-        fala += " O resto está no painel."
+    if not fala and re.search(r"```", painel):
+        fala = "Mandei o código para o painel."
     return fala, painel
 
 

package/voz/primo_voz/escuta.py

@@ -47,10 +47,10 @@ TETO_FALA = 700.0          # nunca exige mais que isso (não ficar surdo)
 FATOR_CONTINUAR = 0.5      # a histerese: depois de começar, o limiar cai
 PRE_ROLL = 4               # blocos guardados ANTES do início da fala
 
-RABO_SILENCIO = 1.0        # silêncio que encerra a frase
-RABO_SILENCIO_LONGA = 1.5  # …e quando a fala já vem longa
+RABO_SILENCIO = 1.4        # silêncio que encerra a frase
+RABO_SILENCIO_LONGA = 1.8  # …e quando a fala já vem longa
 FALA_LONGA = 6.0
-RABO_VAD = 0.5            # silêncio que encerra a frase quando o VAD confirma
+RABO_VAD = 1.1            # silêncio que encerra a frase quando o VAD confirma
 ESPERA_COMECAR = 8.0       # tempo para a pessoa começar a falar
 MAX_FRASE = 45.0
 MAX_FRASE_ESTENDIDA = 100.0
@@ -98,6 +98,7 @@ class Gravador:
         # VAD opcional (Silero, via pysilero-vad): bloco → True se for voz.
         # Com ele, a frase fecha em 0,9 s de silêncio em vez de 2 s.
         self.vad = None
+        self.espera = ESPERA_COMECAR   # quanto espera a fala começar (encurta quando há frase pendente)
 
     # O ambiente é medido ENQUANTO ele espera a pessoa começar. Medir antes de
     # abrir o microfone daria o silêncio do processo, não o do cômodo.
@@ -143,7 +144,7 @@ class Gravador:
                 self._falando = True
                 self._blocos = list(self._pre)
                 self._ultimo_som = agora
-            elif agora > ESPERA_COMECAR:
+            elif agora > self.espera:
                 self.encerrou_por = "ninguem-falou"
                 return True
             return False
@@ -237,14 +238,17 @@ class Microfone:
         import numpy as _np
 
         def alimentar():
-            with wave.open(caminho, "rb") as w:
-                dados = _np.frombuffer(w.readframes(w.getnframes()), dtype=_np.int16)
-            _t.sleep(float(os.environ.get("PRIMOCODE_TESTE_ATRASO", "12")))
+            # "a.wav@12;b.wav@90": cada arquivo entra N s depois do anterior (ou da abertura)
             silencio = _np.zeros(BLOCO, dtype=_np.int16)
-            for i in range(0, len(dados) + BLOCO * 20, BLOCO):
-                bloco = dados[i:i + BLOCO]
-                self._ao_receber(bloco if len(bloco) == BLOCO else (_np.concatenate([bloco, silencio])[:BLOCO]))
-                _t.sleep(BLOCO_MS / 1000)
+            for item in caminho.split(";"):
+                arq, _, espera = item.partition("@")
+                with wave.open(arq, "rb") as w:
+                    dados = _np.frombuffer(w.readframes(w.getnframes()), dtype=_np.int16)
+                _t.sleep(float(espera or os.environ.get("PRIMOCODE_TESTE_ATRASO", "12")))
+                for i in range(0, len(dados) + BLOCO * 20, BLOCO):
+                    bloco = dados[i:i + BLOCO]
+                    self._ao_receber(bloco if len(bloco) == BLOCO else (_np.concatenate([bloco, silencio])[:BLOCO]))
+                    _t.sleep(BLOCO_MS / 1000)
         threading.Thread(target=alimentar, daemon=True).start()
 
     def abrir(self) -> None:

package/voz/primo_voz/fala_pt.py

@@ -0,0 +1,151 @@
+"""fala_pt.py — o texto vira o que se FALA, em português do Brasil, antes de ir para a voz.
+
+Rede de segurança: o cérebro já devolve um `falar` escrito para ser ouvido (app.py), e isto limpa o resto —
+markdown, links, caminhos, código, emojis — e diz por extenso números, unidades, dinheiro, horas, datas,
+versões e siglas ("32 s" → "trinta e dois segundos", "R$ 99" → "noventa e nove reais", "PR" → "pê érre").
+Puro: sem rede, sem Mac. Python 3.9+.
+"""
+from __future__ import annotations
+
+import re
+from typing import List
+
+_UN = ["zero", "um", "dois", "três", "quatro", "cinco", "seis", "sete", "oito", "nove", "dez", "onze", "doze", "treze",
+       "catorze", "quinze", "dezesseis", "dezessete", "dezoito", "dezenove"]
+_DZ = ["", "", "vinte", "trinta", "quarenta", "cinquenta", "sessenta", "setenta", "oitenta", "noventa"]
+_CT = ["", "cento", "duzentos", "trezentos", "quatrocentos", "quinhentos", "seiscentos", "setecentos", "oitocentos", "novecentos"]
+
+
+def _ate_999(n: int) -> str:
+    if n < 20:
+        return _UN[n]
+    if n < 100:
+        d, u = divmod(n, 10)
+        return _DZ[d] + (" e " + _UN[u] if u else "")
+    if n == 100:
+        return "cem"
+    c, r = divmod(n, 100)
+    return _CT[c] + (" e " + _ate_999(r) if r else "")
+
+
+def extenso(n: int, feminino: bool = False) -> str:
+    """0..999.999.999.999 por extenso ("mil duzentos e trinta e quatro")."""
+    if n < 0:
+        return "menos " + extenso(-n, feminino)
+    if n < 1000:
+        t = _ate_999(n)
+        if feminino:
+            t = re.sub(r"\bum\b", "uma", t)
+            t = re.sub(r"\bdois\b", "duas", t)
+            t = re.sub(r"(\w+)entos\b", r"\1entas", t)
+        return t
+    partes: List[str] = []
+    for valor, sing, plur in ((10 ** 9, "bilhão", "bilhões"), (10 ** 6, "milhão", "milhões"), (1000, "mil", "mil")):
+        q, n = divmod(n, valor)
+        if not q:
+            continue
+        if valor == 1000:
+            partes.append("mil" if q == 1 else extenso(q, feminino) + " mil")
+        else:
+            partes.append(extenso(q) + " " + (sing if q == 1 else plur))
+    if n:
+        partes.append(("e " if n < 100 or n % 100 == 0 else "") + extenso(n, feminino))
+    return " ".join(partes).replace("  ", " ")
+
+
+def _inteiro(txt: str) -> int:
+    return int(txt.replace(".", "")) if re.fullmatch(r"\d{1,3}(?:\.\d{3})+", txt) else int(txt)
+
+
+def _decimal(parte_int: str, parte_dec: str) -> str:
+    return f"{extenso(_inteiro(parte_int))} vírgula " + " ".join(extenso(int(d)) for d in parte_dec) if parte_dec.startswith("0") \
+        else f"{extenso(_inteiro(parte_int))} vírgula {extenso(int(parte_dec))}"
+
+
+def _num(txt: str) -> str:
+    if "," in txt:
+        i, d = txt.split(",", 1)
+        return _decimal(i, d)
+    return extenso(_inteiro(txt))
+
+
+_UNIDADES = {
+    "ms": ("milissegundo", "milissegundos"), "s": ("segundo", "segundos"), "seg": ("segundo", "segundos"),
+    "min": ("minuto", "minutos"), "h": ("hora", "horas"), "px": ("pixel", "pixels"),
+    "kb": ("kilobyte", "kilobytes"), "mb": ("megabyte", "megabytes"), "gb": ("gigabyte", "gigabytes"), "tb": ("terabyte", "terabytes"),
+    "km": ("quilômetro", "quilômetros"), "kg": ("quilo", "quilos"), "g": ("grama", "gramas"), "cm": ("centímetro", "centímetros"),
+    "mm": ("milímetro", "milímetros"), "m": ("metro", "metros"), "fps": ("quadro por segundo", "quadros por segundo"),
+    "mhz": ("megahertz", "megahertz"), "ghz": ("gigahertz", "gigahertz"), "hz": ("hertz", "hertz"),
+    "kbps": ("kilobit por segundo", "kilobits por segundo"), "mbps": ("megabit por segundo", "megabits por segundo"),
+}
+_SIGLAS = {
+    "PR": "pê érre", "PRs": "pê érres", "npm": "ene pê eme", "CTA": "chamada", "API": "á pê í", "APIs": "á pê ís", "CSS": "cê ésse ésse",
+    "HTML": "agá tê eme éle", "JSON": "jêi són", "URL": "u érre éle", "CLI": "cê éle í", "CPU": "cê pê u", "RAM": "ram", "UI": "u í",
+    "UX": "u ékis", "SQL": "ésse quê éle", "SVG": "ésse vê gê", "PDF": "pê dê éfe", "MP3": "ême pê três", "MP4": "ême pê quatro",
+    "IA": "í á", "GPU": "gê pê u", "SSD": "ésse ésse dê", "TTS": "tê tê ésse", "STT": "ésse tê tê", "VAD": "vê á dê", "OK": "ôquei",
+    "TCC": "tê cê cê", "SDK": "ésse dê cá", "CI": "cê í", "CD": "cê dê", "ID": "í dê", "TI": "tê í", "QA": "quê á", "OKR": "ô cá érre",
+    "git": "guit", "GitHub": "guit rrâb", "README": "rídmi", "Spotify": "Spotifái", "WhatsApp": "uótsápi", "macOS": "mák ó ésse",
+}
+_LETRAS = dict(zip("ABCDEFGHIJKLMNOPQRSTUVWXYZ", "á bê cê dê é éfe gê agá í jota cá éle ême ene ó pê quê érre ésse tê u vê dáblio ékis ípsilon zê".split()))
+_MESES = ["janeiro", "fevereiro", "março", "abril", "maio", "junho", "julho", "agosto", "setembro", "outubro", "novembro", "dezembro"]
+
+
+def _dinheiro(m: "re.Match") -> str:
+    ints, cents = m.group(1), m.group(2)
+    n = _inteiro(ints)
+    t = extenso(n) + (" real" if n == 1 else " reais")
+    if cents and int(cents):
+        c = int(cents)
+        t += " e " + extenso(c) + (" centavo" if c == 1 else " centavos")
+    return t
+
+
+def _unidade(m: "re.Match") -> str:
+    num, un = m.group(1), m.group(2)
+    forma = _UNIDADES.get(un.lower())
+    if not forma or (len(un) == 1 and un not in "smhg" and un != "m"):
+        return m.group(0)
+    singular = num in ("1", "01") or num == "1,0"
+    return f"{_num(num)} {forma[0] if singular else forma[1]}"
+
+
+def normalizar(texto: str) -> str:
+    t = str(texto or "")
+    t = re.sub(r"```[\s\S]*?```", " ", t)                                    # bloco de código
+    t = re.sub(r"`([^`\n]*)`", lambda m: "" if re.search(r"[/\\.]|\(|\)", m.group(1)) else m.group(1), t)
+    t = re.sub(r"\[([^\]]+)\]\([^)]*\)", r"\1", t)                          # [texto](link) → texto
+    t = re.sub(r"https?://\S+|www\.\S+", "", t)
+    t = re.sub(r"(?<![\w])(?:~|\.{1,2})?/[\w.\-@%+/]+", " ", t)              # caminhos /a/b.js ~/Primo/x
+    t = re.sub(r"\b[\w\-]+(?:/[\w.\-]+)+\.\w+\b", " ", t)                    # a/b/c.js
+    t = re.sub(r"\b[\w\-]+\.(?:js|ts|tsx|jsx|py|html|css|json|md|sh|yml|yaml|png|jpg|svg|mp4|wav|mp3|pdf)\b", "um arquivo", t)
+    t = re.sub(r"^\s*(?:#{1,6}|[-*•]|\d+[.)])\s+", "", t, flags=re.M)        # títulos e marcadores
+    t = re.sub(r"[*_#>|~]+", " ", t)
+    t = re.sub(r"[\U0001F000-\U0001FAFF☀-➿⬀-⯿️‍←-⇿⌀-⏿●▸▪▣⎿]", " ", t)  # emojis e símbolos
+    # dinheiro
+    t = re.sub(r"R\$\s*(\d{1,3}(?:\.\d{3})*|\d+)(?:,(\d{1,2}))?", _dinheiro, t)
+    # versões: v10.15.2 / 10.15.2 / v10.15
+    t = re.sub(r"\bv(\d+(?:\.\d+){1,3})\b", lambda m: "versão " + " ponto ".join(extenso(int(x)) for x in m.group(1).split(".")), t)
+    t = re.sub(r"\b(\d+(?:\.\d+){2,3})\b", lambda m: " ponto ".join(extenso(int(x)) for x in m.group(1).split(".")), t)
+    # hora e data
+    t = re.sub(r"\b([01]?\d|2[0-3]):([0-5]\d)\b", lambda m: extenso(int(m.group(1))) + (" horas" if int(m.group(1)) != 1 else " hora") + (" e " + extenso(int(m.group(2))) if int(m.group(2)) else ""), t)
+    t = re.sub(r"\b(0?[1-9]|[12]\d|3[01])/(0?[1-9]|1[0-2])(?:/(\d{4}))?\b",
+               lambda m: extenso(int(m.group(1))) + " de " + _MESES[int(m.group(2)) - 1] + (" de " + extenso(int(m.group(3))) if m.group(3) else ""), t)
+    # porcentagem
+    t = re.sub(r"(\d+(?:,\d+)?)\s?%", lambda m: _num(m.group(1)) + " por cento", t)
+    # número + unidade ("32 s", "10px", "1,5 GB")
+    t = re.sub(r"(?<![\w.,])(\d{1,3}(?:\.\d{3})+|\d+(?:,\d+)?)\s?([A-Za-z]{1,4})\b(?!\w)", _unidade, t)
+    # siglas e nomes técnicos (palavra inteira)
+    for sig in sorted(_SIGLAS, key=len, reverse=True):
+        t = re.sub(r"(?<![\w])" + re.escape(sig) + r"(?![\w])", _SIGLAS[sig], t)
+    t = re.sub(r"(?<![\w])([A-Z]{2,4})(?![\w])", lambda m: " ".join(_LETRAS[c] for c in m.group(1)), t)   # sigla desconhecida: soletra
+    # números que sobraram
+    t = re.sub(r"(?<![\w.])(\d{1,3}(?:\.\d{3})+|\d+),(\d+)(?![\w])", lambda m: _decimal(m.group(1), m.group(2)), t)
+    t = re.sub(r"(?<![\w.,])(\d{1,3}(?:\.\d{3})+|\d+)(?![\w.,]\d)", lambda m: extenso(_inteiro(m.group(1))), t)
+    t = re.sub(r"\s*[()\[\]{}]\s*", ", ", t)
+    t = re.sub(r"\s*[—–]\s*", ", ", t)
+    t = re.sub(r"\s*[&]\s*", " e ", t)
+    t = re.sub(r"\s*\+\s*", " mais ", t)
+    t = re.sub(r"\s*=>?\s*", " ", t)
+    t = re.sub(r"\s+([,.!?;:])", r"\1", t)
+    t = re.sub(r"(,\s*){2,}", ", ", t)
+    return re.sub(r"\s+", " ", t).strip(" ,")

package/voz/primo_voz/hud.html

@@ -565,8 +565,8 @@ window.primo = (m) => {
   if (m.estado) setEstado(m.estado);
   if (m.barras) { S.quem = m.barras.quem; S.nivel = m.barras.nivel; R3.nivelFala(m.barras.quem === 'primo' ? m.barras.nivel : 0); }
   if (m.transcricao !== undefined || m.resposta !== undefined) { const t = m.resposta || m.transcricao || ''; $('fala').textContent = t.length > 160 ? t.slice(0, 157) + '…' : t; }
-  if (m.calendario) { S.perm = m.calendario.permissao; diasComEvento = m.calendario.dias || []; desenharCalendario(); desenharHoje(); }
-  if (m.hoje) { S.hoje = m.hoje; desenharHoje(); }
+  if (m.calendario) { const k = JSON.stringify(m.calendario); if (k !== S.calKey) { S.calKey = k; S.perm = m.calendario.permissao; diasComEvento = m.calendario.dias || []; desenharCalendario(); desenharHoje(); } }
+  if (m.hoje) { const k = JSON.stringify(m.hoje); S.perm = 'ok'; if (k !== S.hojeKey) { S.hojeKey = k; S.hoje = m.hoje; desenharHoje(); } }
   if (m.clima) desenharClima(m.clima);
   if (m.musica !== undefined) desenharMusica(m.musica);
   if (m.maquina) desenharMaquina(m.maquina);

package/voz/primo_voz/hud.py

@@ -17,6 +17,7 @@ import json
 import math
 import os
 import queue
+import subprocess
 import sys
 import threading
 import time
@@ -88,6 +89,18 @@ def main(demo: bool = False, entrada=None, saida=None, ao_iniciar=None, ao_sair=
             p.visivel = False
             return True
 
+        def applicationShouldTerminate_(self, _a):
+            try:                                          # quem pediu para sair? (vai para o log: ajuda a achar quem fecha o app)
+                from Foundation import NSAppleEventManager
+                ev = NSAppleEventManager.sharedAppleEventManager().currentAppleEvent()
+                pid = ev.attributeDescriptorForKeyword_(0x73706964).int32Value() if ev is not None else 0
+                quem = subprocess.run(["ps", "-p", str(pid), "-o", "command="], capture_output=True, text=True).stdout.strip()[:160] if pid else "interno"
+                sys.stderr.write(f"hud: pedido para SAIR de pid={pid} ({quem})\n")
+                sys.stderr.flush()
+            except Exception as e:
+                sys.stderr.write(f"hud: pedido para sair (não deu para ver quem: {e})\n")
+            return 1
+
         def applicationWillTerminate_(self, _n):
             if ao_sair:
                 try:
@@ -220,11 +233,19 @@ def main(demo: bool = False, entrada=None, saida=None, ao_iniciar=None, ao_sair=
     def agenda():            # em outra thread: o pedido de permissão do Calendário pode demorar
         evs: dict = {"permissao": "pendente", "eventos": []}
         k = 0
+        falhas = 0
         while True:
             try:
                 if k % 12 == 0 or evs["permissao"] != "ok":     # sem acesso, olha a cada 5 s (a pessoa pode ter liberado)
-                    evs = td.eventos_do_mes()
-                    js({"calendario": {"permissao": evs["permissao"], "dias": sorted({e["dia"] for e in evs["eventos"]})}})
+                    novo = td.eventos_do_mes()
+                    if evs["permissao"] == "ok" and novo["permissao"] != "ok":
+                        falhas += 1                              # erro transitório não derruba o cartão: segura os últimos eventos
+                        if falhas >= 4:
+                            evs, falhas = novo, 0
+                    else:
+                        evs, falhas = novo, 0
+                # SEMPRE manda o estado junto: o painel nunca depende de uma mensagem que pode ter chegado antes da página
+                js({"calendario": {"permissao": evs["permissao"], "dias": sorted({e["dia"] for e in evs["eventos"]})}})
                 if evs["permissao"] == "ok":
                     js({"hoje": td.hoje_lista(evs["eventos"], time.time())})
             except Exception as e:

package/voz/primo_voz/transcrever.py

@@ -27,7 +27,7 @@ import threading
 from pathlib import Path
 from typing import Optional
 
-MODELO = os.environ.get("PRIMOCODE_WHISPER_MODELO", "base").strip() or "base"
+MODELO = os.environ.get("PRIMOCODE_WHISPER_MODELO", "small").strip() or "small"
 PASTA = Path.home() / ".primocode" / "modelos" / "whisper"
 
 _modelo = None
@@ -112,6 +112,11 @@ def aproveitavel(segmento) -> bool:
     return not (sem_fala > SEM_FALA and confianca < CONFIANCA_MINIMA)
 
 
+# O vocabulário do Primo vai de dica ao Whisper: medido em 13 frases pt-BR, o WER do `small` caiu de 15,1% para 11,6% (e de 29,6% para 18,5% com ruído).
+PROMPT_INICIAL = ("Primo, PrimoCode, commit, deploy, Spotify, Railway, projeto, testes, servidor, landing page, site, padaria, "
+                  "agenda, volume, abre o projeto, cria um site, roda os testes.")
+
+
 def transcrever(wav: Path, idioma: str = "pt") -> str:
     modelo = carregar()
     entrada: object = str(wav)
@@ -125,8 +130,9 @@ def transcrever(wav: Path, idioma: str = "pt") -> str:
         entrada = str(wav)
     # vad_filter corta o silêncio das pontas: sem ele, o Whisper às vezes
     # "ouve" uma frase inteira inventada no silêncio ("Obrigado por assistir").
-    segmentos, _ = modelo.transcribe(entrada, language=idioma, beam_size=1,
-                                     vad_filter=True, condition_on_previous_text=False)
+    segmentos, _ = modelo.transcribe(entrada, language=idioma, beam_size=2,
+                                     vad_filter=True, condition_on_previous_text=False,
+                                     initial_prompt=PROMPT_INICIAL)
     return limpar(" ".join(s.text.strip() for s in segmentos if aproveitavel(s)))