primocode 9.2.3 → 9.3.0

package/README.md

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

package/bin/primocode.js

@@ -151,6 +151,7 @@ const SLASH_COMANDOS = [
     ['/account', 'sua conta, plano e computadores conectados'],
     ['/chats', 'suas conversas salvas, as mesmas do app e do celular'],
     ['/logout', 'desconecta este computador da conta'],
+    ['!comando', 'roda direto no shell, sem passar pelo agente (o campo fica âmbar)'],
     ['/voice', 'fica ouvindo em segundo plano — diga "ei, primo" e a orb aparece'],
     ['/voice parar', 'desliga o modo voz e fecha o microfone'],
     ['/skills', 'o que ele sabe fazer bem — ligue e desligue'],
@@ -1029,6 +1030,62 @@ async function runChat(promptForModel, userTextForMemory) {
 
 function isSlash(text) { return text.trim().startsWith('/'); }
 
+/* ── "!comando" RODA NO SHELL ────────────────────────────────────────────
+ *
+ *   "quando eu mande uma mensagem que comece com ! ele rode em bash"
+ *
+ * Por que não mandar ao agente e deixar ele chamar run_shell: porque são
+ * coisas diferentes. Pedir ao agente é dizer o QUE se quer e deixá-lo
+ * decidir; o "!" é dizer o COMANDO. Quem digita `!git status` não quer que
+ * alguém interprete a intenção — quer a saída do git status, agora, sem
+ * volta ao modelo, sem gastar cota e sem o risco de o agente achar que
+ * entendeu melhor.
+ *
+ * A saída sai CRUA, como no terminal: ela não passa pelo desenhador de
+ * Markdown. Saída de comando tem alinhamento próprio (colunas do `ls`,
+ * tabela do `docker ps`), e reformatá-la seria estragá-la.
+ */
+function ehBash(text) { return /^\s*!/.test(String(text || '')); }
+
+async function rodarBash(text) {
+    const comando = String(text).replace(/^\s*!/, '').trim();
+    if (!comando) return;
+
+    const pasta = state.workDir || process.cwd();
+    console.log('');
+    console.log('  ' + c.warn('$ ') + c.white(comando));
+
+    const inicio = Date.now();
+    const r = await tools.execute('run_shell', { command: comando, timeout: 600000 },
+        { projectDir: pasta });
+    const segundos = ((Date.now() - inicio) / 1000).toFixed(1);
+
+    /* Crua, e inteira. `run_shell` corta em 10 MB, que é o teto do buffer;
+       cortar mais aqui esconderia justamente a linha do erro, que costuma
+       estar no fim. */
+    const saida = [r.stdout, r.stderr].filter((x) => String(x || '').trim()).join('\n');
+    if (saida) console.log(saida.replace(/\n$/, ''));
+
+    if (r.ok) {
+        console.log('  ' + c.dim(`ok · ${segundos}s`));
+    } else if (r.killed) {
+        console.log('  ' + c.warn(`interrompido depois de ${segundos}s`));
+    } else {
+        console.log('  ' + c.warn(`saiu com ${r.code} · ${segundos}s`));
+    }
+    console.log('');
+
+    /* O agente FICA SABENDO, e isto é o que torna o "!" útil dentro de uma
+       conversa: rodar o teste e depois perguntar "por que falhou?" só
+       funciona se ele tiver visto a saída. Sem isto seriam dois mundos
+       separados na mesma tela. */
+    state.history.push({ role: 'user', content: `Rodei no shell: ${comando}` });
+    state.history.push({
+        role: 'assistant',
+        content: `Saída (código ${r.code ?? 0}):\n${saida.slice(0, 4000) || '(vazia)'}`,
+    });
+}
+
 /* ── OS NOMES ANTIGOS ────────────────────────────────────────────────────
  * Os comandos passaram a ser todos em inglês. Metade já era; a outra metade
  * estava em português, e a mistura era o que a especificação chamou de
@@ -1430,7 +1487,14 @@ async function handleSlash(text) {
             }
 
             const pronto = vozModo.conferir();
-            if (!pronto.ok && !pronto.instalavel) {
+            /* `.length`, e não a lista: [] é VERDADEIRO em JavaScript.
+               Quando só falta o tkinter — que o pip não instala, porque ele
+               vem com o Python ou num pacote do sistema — a lista de
+               instaláveis volta VAZIA. Sem o `.length`, este ramo era pulado,
+               o "Instalar agora?" aparecia, e o pip era chamado sem pacote
+               nenhum: "You must give at least one requirement to install".
+               Visto na máquina do dono. */
+            if (!pronto.ok && !(pronto.instalavel && pronto.instalavel.length)) {
                 console.log(c.err(`  ${pronto.error}`));
                 if (pronto.comoResolver) console.log(c.muted(`  ${pronto.comoResolver}`));
                 break;
@@ -2070,7 +2134,8 @@ async function main() {
             const text = queue.shift().trim();
             if (!text) continue;
             try {
-                if (isSlash(text)) await handleSlash(text);
+                if (ehBash(text)) await rodarBash(text);
+                else if (isSlash(text)) await handleSlash(text);
                 else await sendPrompt(text);
             } catch (e) {
                 fala.problema(e);

package/lib/entrada.js

@@ -115,16 +115,29 @@ function montar(e) {
        toda linha e a preencher o resto com espaço, e é ela que faz o texto
        colado parecer desalinhado quando o terminal é estreito. Sem as laterais
        o campo ganha as colunas de volta e a emenda some. */
+    /* MODO BASH: a linha que começa com "!" roda no shell, e a caixa INTEIRA
+       muda de cor para avisar.
+
+       O aviso é o ponto. Um comando de shell faz coisa irreversível, e a
+       diferença entre "pedir ao agente" e "rodar direto" não pode depender de
+       a pessoa lembrar do que digitou três segundos atrás: ela tem de VER, no
+       momento em que digita, que aquele Enter vai ao shell. Daí o âmbar — a
+       mesma cor que o resto do programa usa para "atenção, não é o caminho
+       comum". */
+    const bash = /^\s*!/.test(String(e.texto));
+
     const out = [];
-    const regua = c.dim(BORDA.h.repeat(largura));
+    const regua = (bash ? c.warn : c.dim)(BORDA.h.repeat(largura));
     out.push(regua);
 
     const vazio = !String(e.texto).length;
     linhas.forEach((l, i) => {
         const marca = i === 0
-            ? (e.ocupado ? c.dim('❯ ') : c.brand('❯ '))
+            ? (e.ocupado ? c.dim('❯ ') : bash ? c.warn('$ ') : c.brand('❯ '))
             : c.dim('┆ ');
-        let conteudo = c.white(l.texto);
+        // O "!" some do texto desenhado: quem vê "$ " já sabe que é shell, e
+        // mostrar os dois é mostrar a mesma informação duas vezes.
+        let conteudo = c.white(i === 0 && bash ? l.texto.replace(/^\s*!/, '') : l.texto);
         // O fantasma só existe na última linha e só com o cursor no fim dela:
         // desenhado no meio do texto, ele empurraria o que vem depois.
         if (i === linhas.length - 1 && e.fantasma && cursor === String(e.texto).length) {
@@ -162,12 +175,22 @@ function montar(e) {
         }
     }
 
+    /* A linha que explica, só no modo bash. Ela ocupa o lugar do rodapé
+       normal de propósito: no instante em que a pessoa vai rodar um comando,
+       o que importa não é lembrar os atalhos, é saber onde ele vai rodar. */
+    if (bash) {
+        out.push(' ' + c.warn('roda no shell') + c.dim(`, em ${e.pasta || 'a pasta atual'}`)
+            + c.dim(' · apague o ! para voltar ao normal'));
+    }
     for (const linha of (e.status || [])) out.push(' ' + linha);
 
     return {
         linhas: out,
         cursorLinha: 1 + cursorLinha,                   // +1 pela régua de cima
-        cursorColuna: 1 + 2 + cursorColuna,             // espaço + '❯ '
+        /* No modo bash o "!" não é desenhado, então tudo depois dele anda uma
+           coluna para a esquerda — e o cursor tem de andar junto, ou ele
+           aparece um caractere à frente de onde o texto realmente está. */
+        cursorColuna: 1 + 2 + cursorColuna - (bash && cursorLinha === 0 ? 1 : 0),
     };
 }
 

package/lib/skills.js

@@ -47,6 +47,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const crypto = require('crypto');
 
 const ORIGEM = path.join(__dirname, '..', 'skills');
 const CASA = path.join(os.homedir(), '.primocode', 'skills');
@@ -90,24 +91,98 @@ function salvarEstado(estado) {
     } catch { return false; }
 }
 
-/* As que vêm com o produto são copiadas na primeira vez. Copiar SEMPRE por
-   cima seria desfazer a edição de quem melhorou uma delas; copiar só o que
-   falta deixa o usuário dono do que ele mexeu. */
+/* A impressão digital do conteúdo. Serve para responder UMA pergunta: o
+   arquivo que está na casa da pessoa é o que o produto instalou, ou ela
+   mexeu nele? */
+function impressao(texto) {
+    return crypto.createHash('sha256').update(String(texto || ''), 'utf8').digest('hex').slice(0, 16);
+}
+
+/**
+ * Traz as skills do produto para a casa da pessoa — e ATUALIZA as que ela não
+ * tocou.
+ *
+ * ── O DEFEITO QUE ISTO CONSERTA ─────────────────────────────────────────
+ * Era `if (fs.existsSync(destino)) continue;`. Uma vez instalada, a skill do
+ * produto NUNCA mais era atualizada. Quem rodou o PrimoCode um dia ficou com
+ * a versão daquele dia para sempre, e toda melhoria que veio depois — texto
+ * melhor, gatilho novo, regra corrigida — nunca chegou a ninguém. Do lado de
+ * quem usa, o sintoma é "as skills não estão funcionando": elas rodam, só que
+ * são as de antes.
+ *
+ * ── E POR QUE NÃO SOBRESCREVER SEMPRE ───────────────────────────────────
+ * Porque a pessoa pode ter editado. Sobrescrever apagaria o trabalho dela sem
+ * avisar, que é pior que a skill desatualizada. Então guarda-se, ao instalar,
+ * a impressão digital do que foi instalado: se o arquivo ainda bate com ela,
+ * ninguém mexeu e dá para atualizar em silêncio. Se não bate, a edição é
+ * dela e fica como está.
+ *
+ * A skill CRIADA pela pessoa não tem impressão nenhuma, e por isso nunca é
+ * tocada — não veio do produto.
+ */
 function prepararCasa() {
     fs.mkdirSync(CASA, { recursive: true });
     let nascidas = 0;
+    let atualizadas = 0;
+    const preservadas = [];
+    const guardadas = [];
     let origens = [];
     try { origens = fs.readdirSync(ORIGEM, { withFileTypes: true }); } catch { return 0; }
+
     for (const item of origens) {
         if (!item.isDirectory()) continue;
         const destino = path.join(CASA, item.name);
-        if (fs.existsSync(destino)) continue;
+        const arquivoDestino = path.join(destino, 'SKILL.md');
+        const marca = path.join(destino, '.origem.json');
+        let novo;
+        try { novo = fs.readFileSync(path.join(ORIGEM, item.name, 'SKILL.md'), 'utf8'); }
+        catch { continue; }
+
         try {
-            fs.mkdirSync(destino, { recursive: true });
-            fs.copyFileSync(path.join(ORIGEM, item.name, 'SKILL.md'), path.join(destino, 'SKILL.md'));
-            nascidas++;
+            if (!fs.existsSync(arquivoDestino)) {
+                fs.mkdirSync(destino, { recursive: true });
+                fs.writeFileSync(arquivoDestino, novo, 'utf8');
+                fs.writeFileSync(marca, JSON.stringify({ sha: impressao(novo) }), 'utf8');
+                nascidas++;
+                continue;
+            }
+
+            const atual = fs.readFileSync(arquivoDestino, 'utf8');
+            if (impressao(atual) === impressao(novo)) continue;        // já é a nova
+
+            let instalada = null;
+            try { instalada = JSON.parse(fs.readFileSync(marca, 'utf8')).sha; } catch { /* sem marca */ }
+
+            if (instalada && instalada === impressao(atual)) {
+                // Intacta desde a instalação: pode atualizar sem perder nada.
+                fs.writeFileSync(arquivoDestino, novo, 'utf8');
+                fs.writeFileSync(marca, JSON.stringify({ sha: impressao(novo) }), 'utf8');
+                atualizadas++;
+            } else if (instalada) {
+                // Tem marca e não bate: a pessoa editou. Fica como está — o
+                // trabalho dela vale mais que a atualização.
+                preservadas.push(item.name);
+            } else {
+                /* SEM MARCA: instalada antes desta correção existir.
+                   Aqui não dá para saber se a pessoa editou ou se é só uma
+                   versão antiga do produto — e as duas saídas puras são
+                   ruins: preservar congela a skill para sempre (que é o
+                   defeito que estamos consertando, e atingiria justamente
+                   quem já usa), sobrescrever pode apagar o trabalho dela.
+
+                   Então atualiza E GUARDA O ANTERIOR ao lado. Ninguém perde
+                   nada, todo mundo recebe a versão nova, e quem tinha algo
+                   próprio encontra o arquivo ali para trazer de volta. Vale
+                   uma vez só: da próxima já existe marca. */
+                try { fs.writeFileSync(arquivoDestino + '.anterior', atual, 'utf8'); } catch {}
+                fs.writeFileSync(arquivoDestino, novo, 'utf8');
+                fs.writeFileSync(marca, JSON.stringify({ sha: impressao(novo) }), 'utf8');
+                atualizadas++;
+                guardadas.push(item.name);
+            }
         } catch { /* uma que falha não impede as outras */ }
     }
+    prepararCasa.ultimo = { nascidas, atualizadas, preservadas, guardadas };
     return nascidas;
 }
 
@@ -323,6 +398,7 @@ function montar(texto, op = {}) {
 }
 
 module.exports = {
+    impressao,
     CASA, ORIGEM, MAX_CARACTERES,
     separar, listar, ler, criar, ligar, apagar, instalarDe, apelidar,
     paraOPedido, montar, pontuar, prepararCasa,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.2.3",
+  "version": "9.3.0",
   "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/skills/pagina-que-converte/SKILL.md

@@ -1,28 +1,75 @@
 ---
 nome: Página que converte
-descricao: estrutura e acabamento de landing page, site e página de venda
-quando: landing, landing page, site, página, pagina, home, hero, seção, secao, cta, conversão, conversao, vendas, institucional
+descricao: estrutura, direção de arte e acabamento de landing page, site e página de venda
+quando: landing, landing page, site, página, pagina, home, hero, seção, secao, cta, conversão, conversao, vendas, institucional, portfólio, portfolio, one page, onepage
 autor: PrimoCode
 ---
-Uma página que converte tem ordem, não mais elementos.
+Evitar erro não produz beleza. A página genérica não nasce de um erro: nasce
+da AUSÊNCIA de decisão — quem não escolhe tipografia usa a do sistema, quem não
+escolhe paleta usa azul, quem não escolhe ritmo centraliza tudo. Então decida,
+por escrito, ANTES de abrir o editor:
 
-**A ordem que funciona**: promessa clara em até 8 palavras → uma linha que
-explica para quem é → prova (número real, print, nome de cliente) → o que a
-pessoa ganha, em 3 blocos → objeção respondida → um único pedido de ação,
-repetido no fim.
+**1. A DIREÇÃO, em uma frase.** "Editorial e severa, como um jornal econômico."
+"Técnica e escura, como uma ferramenta de desenvolvedor." "Calorosa e
+artesanal." Ela decide tudo o que vem depois, e assuntos diferentes não podem
+receber a mesma.
 
-**Um CTA por página.** Dois pedidos de ação competem entre si e a pessoa não
-faz nenhum.
+**2. A TIPOGRAFIA — duas famílias, e elas têm de CONTRASTAR.** Duas grotescas
+parecidas é o que dá cara de modelo pronto. Combinações que funcionam:
 
-**O que denuncia página genérica** — não faça nada disto:
-gradiente roxo-para-azul no fundo, tudo centralizado do topo ao rodapé,
-sombra em todo cartão, emoji no lugar de ícone, "Bem-vindo ao nosso site",
-"Soluções inovadoras", texto de exemplo em qualquer lugar.
+| Direção | Título | Texto |
+|---|---|---|
+| Editorial, autoridade | Playfair Display, Fraunces | Inter, Source Serif |
+| Técnica, produto | Space Grotesk, Sora | Inter, IBM Plex Sans |
+| Impacto, anúncio | Anton, Archivo Black | Inter, DM Sans |
+| Calorosa, humana | Instrument Serif, Lora | Karla, Figtree |
 
-**Acabamento**: escala de espaço consistente (4/8/12/16/24/32/48), no máximo
-dois pesos de fonte, contraste de 4.5:1 no texto, botão com hover e
-focus-visible, largura de leitura entre 60 e 75 caracteres. Funciona de 360px
-a 1440px sem rolagem horizontal.
+Título grande é grande DE VERDADE: `clamp(2.5rem, 6vw, 5.5rem)`, peso 700+,
+`letter-spacing: -0.03em` (fonte grande precisa apertar; fonte pequena, não).
+Texto em 17–19px, `line-height: 1.6`, largura de 60 a 75 caracteres.
 
-Escreva o texto de verdade, sobre o assunto de verdade. Uma página bonita com
+**3. A PALETA — do ASSUNTO, nunca a padrão.** Uma cor de marca, uma neutra
+escura para o texto, uma clara para o fundo, e UMA de destaque usada com
+avareza — no CTA e em mais nada. Se a empresa existe, as cores são dela: leia
+do site com `estudio_site`. Inventar a cor de uma marca real é erro que chega
+pronto ao cliente.
+
+**4. O RITMO VERTICAL.** Seção não tem todas a mesma altura nem o mesmo
+tratamento. Alterne: fundo claro → fundo escuro → claro → imagem sangrando de
+borda a borda. Respiro grande entre seções (96–160px), pequeno dentro delas.
+
+**5. QUEBRE A SIMETRIA.** Tudo centralizado do topo ao rodapé é o sinal número
+um de página feita às pressas. Herói em duas colunas 7/5, número grande
+alinhado à esquerda com o texto encostado nele, imagem que ultrapassa a
+margem. Grade de 12 colunas, e use-a de verdade.
+
+**6. MOVIMENTO, com parcimônia.** Entrada por `IntersectionObserver`:
+`opacity 0 → 1` e `translateY(16px → 0)`, 400ms, `cubic-bezier(.16,1,.3,1)`,
+escalonado em 60ms entre irmãos. Estado de hover em tudo que é clicável.
+Sempre dentro de `@media (prefers-reduced-motion: reduce)`.
+
+**7. OS DETALHES QUE SEPARAM PROFISSIONAL DE AMADOR.**
+Um raio de borda só, repetido. Sombra em camadas
+(`0 1px 2px rgba(0,0,0,.06), 0 8px 24px rgba(0,0,0,.08)`), nunca a sombra
+padrão em tudo. `font-variant-numeric: tabular-nums` em número. `text-wrap:
+balance` em título. Ícone de biblioteca de verdade (Lucide, Phosphor), nunca
+emoji. `:focus-visible` visível. Imagem com `width`/`height` declarados para
+a página não pular ao carregar.
+
+**8. ESTRUTURA que converte**: promessa em até 8 palavras → para quem é →
+prova (número real, nome de cliente) → o que a pessoa ganha, em 3 blocos →
+objeção respondida → UM pedido de ação, repetido no fim. Um CTA por página:
+dois competem entre si e a pessoa não faz nenhum.
+
+**O QUE DENUNCIA PÁGINA GENÉRICA** — nenhum destes:
+gradiente roxo-para-azul, tudo centralizado, sombra igual em todo cartão,
+emoji no lugar de ícone, "Bem-vindo ao nosso site", "Soluções inovadoras",
+três cartões idênticos lado a lado, texto de exemplo em qualquer lugar.
+
+**ANTES DE ENTREGAR**: abra no navegador e olhe. Confira em 360px, 768px e
+1440px, sem rolagem horizontal. Contraste de 4.5:1 no texto. Se a página
+servisse para qualquer outra empresa trocando o logotipo, ela está genérica —
+volte ao passo 1.
+
+Escreva o texto de verdade, sobre o assunto de verdade. Página bonita com
 texto vazio não convence ninguém.

package/voz/primo_voz/orbe.py

@@ -1,60 +1,90 @@
-"""orbe.py — a interface inteira: um núcleo pequeno e um fundo fosco.
-
-    "Redesenhar a interface: nada de fundo escuro cheio de elementos. Apenas
-     um núcleo pequeno, tipo uma orb, com um fundo fosco/desfocado por trás.
-     Ocultar transcrição, chat e qualquer painel. É só a orb e o áudio."
-
-── O QUE ISTO NÃO TEM ──────────────────────────────────────────────────────
-Não há transcrição do que você falou, não há legenda do que ele está fazendo,
-não há resposta escrita, não há janela de conversa, não há barra de comando.
-Não é economia de trabalho: ler a resposta de um assistente de voz é trabalho,
-e ouvir não é. Se a interface mostrasse o texto, a pessoa leria — e aí o modo
-voz vira um chat com um microfone.
-
-O que a orb comunica é o ESTADO, por cor e movimento: parada quando espera,
-pulsando quando ouve, girando devagar quando pensa, brilhando quando fala.
-Quatro estados, nenhuma palavra.
-
-── POR QUE tkinter ─────────────────────────────────────────────────────────
-Ele vem com o Python. Qualquer outra escolha (Qt, GTK, pywebview, Electron)
-significaria dezenas ou centenas de megabytes para desenhar um círculo — e o
-`/voice` já precisa instalar sounddevice e numpy. Cada dependência a mais é
-uma chance a mais de o modo voz não abrir na máquina de alguém.
-
-── O FUNDO FOSCO, E O QUE ELE É DE VERDADE ─────────────────────────────────
-Desfoque real do que está ATRÁS da janela não existe de forma portátil: no
-macOS é NSVisualEffectView, no Windows é DwmEnableBlurBehindWindow, no Linux
-depende do compositor. Nenhum deles está no Python padrão.
-
-O que dá para fazer em todo lugar é uma camada escura semitransparente por
-cima da tela inteira. Não é desfoque; é escurecimento. A diferença aparece num
-fundo cheio de detalhe, e some num fundo comum.
-
-Onde o desfoque de verdade existe sem custo — macOS com pyobjc já instalado —
-ele é usado. Onde não existe, a camada escura entra, e a orb continua sendo o
-que importa. O que não se faz é fingir: nada aqui chama de "desfoque" o que é
-só uma sombra.
+"""orbe.py — a única coisa que aparece na tela no modo voz.
+
+    "ia ser a flutuante ali na parte inferior da tela, bem centralizada,
+     toda cheia de partículas, toda bonita."
+
+── POR QUE A PRIMEIRA VERSÃO FICOU FEIA, E A CULPA É DE QUATRO COISAS ──────
+
+1. `-transparentcolor` SÓ EXISTE NO WINDOWS. No macOS ele levanta TclError,
+   que o código engolia — e a janela ficava com o fundo opaco pintado nela.
+   Era o "quadrado feio": não era desenho, era a janela inteira aparecendo.
+   No macOS a transparência de verdade se pede de outro jeito:
+   `-transparent` mais o fundo mágico `systemTransparent`.
+
+2. O VÉU cobria a tela inteira com 72% de preto. A ideia era destacar a orb;
+   o efeito é escurecer o trabalho da pessoa enquanto ela fala. Saiu.
+
+3. Ela nascia no CENTRO da tela — bem no meio do que a pessoa está fazendo.
+   Agora mora embaixo, centralizada na horizontal, como uma barra flutuante.
+
+4. Não havia partícula nenhuma. Havia três círculos concêntricos.
+
+── O QUE ELA DESENHA ───────────────────────────────────────────────────────
+Um núcleo com halo suave e um enxame de partículas em órbita. A cor diz o
+estado; o MOVIMENTO diz a intensidade — as partículas se afastam e aceleram
+com a voz, e respiram devagar quando ele está pensando. Nenhuma palavra: quem
+está falando não lê.
+
+── O QUE NÃO DÁ PARA FAZER EM TKINTER, E COMO SE CONTORNA ─────────────────
+Não há desfoque nem gradiente: o Canvas do Tk desenha forma chapada. O halo é
+feito de círculos concêntricos com a cor interpolada contra o fundo — o
+mesmo truque de sempre, e o motivo de o fundo precisar ser conhecido. Onde a
+janela é transparente de verdade, o "fundo" para a mistura é o preto, que é o
+que mais se aproxima de qualquer tela.
 """
 from __future__ import annotations
 
 import math
 import queue
+import random
 import sys
-import threading
 import tkinter as tk
 from typing import Callable, Optional
 
 # Os quatro estados, e a cor de cada um. A paleta é a do PrimoCode (ciano de
 # marca, âmbar de aviso) para o modo voz não parecer outro produto.
 CORES = {
-    "esperando": ("#0891b2", "#164e63"),   # ciano recuado: pronto, sem pressa
+    "esperando": ("#0891b2", "#0e3a4a"),   # ciano recuado: pronto, sem pressa
     "ouvindo":   ("#22d3ee", "#0e7490"),   # ciano vivo: a vez é sua
     "pensando":  ("#fbbf24", "#78350f"),   # âmbar: ele está trabalhando
     "falando":   ("#67e8f9", "#0891b2"),   # ciano claro: a voz é dele
 }
 
-TAMANHO = 220          # a janela da orb, em pixels
-RAIO_BASE = 46         # o núcleo
+LARGURA = 340          # a janela, deitada: é uma barra flutuante, não um disco
+ALTURA = 170
+RAIO_BASE = 26         # o núcleo
+MARGEM_INFERIOR = 72   # distância do pé da tela
+PARTICULAS = 34
+FUNDO_FALSO = "#05070a"   # só onde o sistema não dá transparência
+
+
+def _mistura(a: str, b: str, quanto: float) -> str:
+    """Duas cores hex, uma fração — a cor no meio do caminho."""
+    quanto = max(0.0, min(1.0, quanto))
+    ra, ga, ba = int(a[1:3], 16), int(a[3:5], 16), int(a[5:7], 16)
+    rb, gb, bb = int(b[1:3], 16), int(b[3:5], 16), int(b[5:7], 16)
+    return "#%02x%02x%02x" % (
+        int(ra + (rb - ra) * quanto),
+        int(ga + (gb - ga) * quanto),
+        int(ba + (bb - ba) * quanto),
+    )
+
+
+class Particula:
+    """Um ponto em órbita.
+
+    Cada uma tem ângulo, raio e velocidade PRÓPRIOS, sorteados uma vez. É o
+    que separa um enxame de um relógio: com os mesmos valores para todas,
+    elas giram em formação e o olho lê como engrenagem, não como vida.
+    """
+
+    def __init__(self, rnd: random.Random) -> None:
+        self.ang = rnd.uniform(0, math.tau)
+        self.raio = rnd.uniform(1.0, 2.2)          # múltiplo do raio do núcleo
+        self.giro = rnd.uniform(-0.9, 0.9) or 0.4
+        self.tam = rnd.uniform(1.2, 3.0)
+        self.fase = rnd.uniform(0, math.tau)
+        self.brilho = rnd.uniform(0.35, 1.0)
 
 
 class Orbe:
@@ -70,61 +100,76 @@ class Orbe:
         self._fila = queue.Queue()
         self._ao_fechar = ao_fechar
         self._vivo = True
+        self._rnd = random.Random(7)   # semente fixa: o enxame é sempre o mesmo
+        self._particulas = [Particula(self._rnd) for _ in range(PARTICULAS)]
 
-        self._montar_veu()
-        self._montar_orbe()
+        self._montar()
         self.raiz.protocol("WM_DELETE_WINDOW", self.fechar)
         self.raiz.bind("<Escape>", lambda e: self.fechar())
         self._pintar()
 
-    # ── o véu ────────────────────────────────────────────────────────────
-    def _montar_veu(self) -> None:
-        """A camada escura sobre a tela inteira.
+    # ── a janela ─────────────────────────────────────────────────────────
+    def _montar(self) -> None:
+        """Sem moldura, embaixo, centralizada — e transparente onde dá.
 
-        `-alpha` é o único jeito portátil de ter transparência de janela em
-        tkinter, e ele vale para a janela INTEIRA — por isso o véu é uma
-        janela separada da orb: se fossem a mesma, a orb ficaria translúcida
-        junto com o fundo, e um núcleo translúcido some.
+        A transparência se pede de um jeito em cada sistema, e pedir errado
+        não avisa: devolve TclError, que engolido deixa a janela OPACA. Era
+        exatamente o "quadrado feio". Por isso aqui cada caminho é explícito,
+        e o fundo falso só entra quando nenhum funcionou.
         """
-        self.veu = tk.Toplevel(self.raiz)
-        self.veu.overrideredirect(True)
-        largura = self.veu.winfo_screenwidth()
-        altura = self.veu.winfo_screenheight()
-        self.veu.geometry(f"{largura}x{altura}+0+0")
-        self.veu.configure(bg="#05070a")
-        try:
-            self.veu.attributes("-alpha", 0.72)
-            self.veu.attributes("-topmost", True)
-        except tk.TclError:
-            pass
-        # O véu não recebe clique: a pessoa continua usando o computador por
-        # baixo dele. Onde o sistema não deixa, ele simplesmente cobre.
-        try:
-            self.veu.attributes("-transparent", True)
-        except tk.TclError:
-            pass
-
-    # ── a orb ────────────────────────────────────────────────────────────
-    def _montar_orbe(self) -> None:
         self.raiz.overrideredirect(True)
-        largura = self.raiz.winfo_screenwidth()
-        altura = self.raiz.winfo_screenheight()
-        x = (largura - TAMANHO) // 2
-        y = (altura - TAMANHO) // 2
-        self.raiz.geometry(f"{TAMANHO}x{TAMANHO}+{x}+{y}")
-        self.raiz.configure(bg="#05070a")
+        larguraTela = self.raiz.winfo_screenwidth()
+        alturaTela = self.raiz.winfo_screenheight()
+        x = (larguraTela - LARGURA) // 2
+        y = alturaTela - ALTURA - MARGEM_INFERIOR
+        self.raiz.geometry(f"{LARGURA}x{ALTURA}+{x}+{max(0, y)}")
+
+        self.fundo = FUNDO_FALSO
+        transparente = False
+
+        if sys.platform == "darwin":
+            # macOS: `-transparent` mais o fundo mágico. Os dois juntos, ou
+            # nenhum dos dois funciona.
+            try:
+                self.raiz.attributes("-transparent", True)
+                self.fundo = "systemTransparent"
+                transparente = True
+            except tk.TclError:
+                pass
+        elif sys.platform == "win32":
+            try:
+                self.raiz.attributes("-transparentcolor", FUNDO_FALSO)
+                transparente = True
+            except tk.TclError:
+                pass
+
         try:
             self.raiz.attributes("-topmost", True)
-            # A cor de fundo vira transparente onde o sistema deixa (Windows),
-            # e no resto ela é a mesma do véu — o que dá o mesmo efeito.
-            self.raiz.attributes("-transparentcolor", "#05070a")
         except tk.TclError:
             pass
 
-        self.tela = tk.Canvas(self.raiz, width=TAMANHO, height=TAMANHO,
-                              bg="#05070a", highlightthickness=0)
+        self.raiz.configure(bg=self.fundo)
+        self.tela = tk.Canvas(self.raiz, width=LARGURA, height=ALTURA,
+                              bg=self.fundo, highlightthickness=0, bd=0)
         self.tela.pack()
 
+        # Para a MISTURA de cor do halo, o fundo tem de ser um valor de cor —
+        # e "systemTransparent" não é. Contra o preto é a aproximação que
+        # some melhor em qualquer tela.
+        self.fundoDaMistura = FUNDO_FALSO if transparente else self.fundo
+
+        # Sem moldura não há barra de título para arrastar: o arrasto é na
+        # janela toda. Quem quiser a orb noutro canto, leva.
+        self.raiz.bind("<Button-1>", self._pegar)
+        self.raiz.bind("<B1-Motion>", self._arrastar)
+        self._pego = (0, 0)
+
+    def _pegar(self, e) -> None:
+        self._pego = (e.x_root - self.raiz.winfo_x(), e.y_root - self.raiz.winfo_y())
+
+    def _arrastar(self, e) -> None:
+        self.raiz.geometry(f"+{e.x_root - self._pego[0]}+{e.y_root - self._pego[1]}")
+
     # ── o desenho ────────────────────────────────────────────────────────
     def _pintar(self) -> None:
         if not self._vivo:
@@ -132,124 +177,112 @@ class Orbe:
         while True:
             try:
                 estado, nivel = self._fila.get_nowait()
-                if estado == '__esconder__':
-                    self._aplicar_visibilidade(False)
+                if estado == "__esconder__":
+                    self._aplicarVisibilidade(False)
                     continue
-                if estado == '__mostrar__':
-                    self._aplicar_visibilidade(True)
+                if estado == "__mostrar__":
+                    self._aplicarVisibilidade(True)
                     continue
+                if estado:
+                    self.estado = estado
+                if nivel is not None:
+                    self.nivel = max(0.0, min(1.0, nivel))
             except queue.Empty:
                 break
-            if estado:
-                self.estado = estado
-            if nivel is not None:
-                self.nivel = max(0.0, min(1.0, nivel))
 
-        self.tela.delete("all")
+        self._fase += 0.045
         vivo, fundo = CORES.get(self.estado, CORES["esperando"])
-        centro = TAMANHO / 2
-        self._fase += 0.06
+        cx, cy = LARGURA / 2, ALTURA / 2
+        self.tela.delete("all")
 
-        # O movimento é diferente em cada estado, e é ele que diz o que está
-        # acontecendo — sem uma palavra escrita.
+        # A respiração de cada estado. Quem espera respira devagar; quem
+        # pensa, num ritmo próprio; quem ouve pulsa com a VOZ, não com o
+        # relógio — é o que faz a orb parecer estar escutando de verdade.
         if self.estado == "ouvindo":
-            # Responde à VOZ: o núcleo cresce com o que ela está falando.
-            raio = RAIO_BASE * (1 + 0.35 * self.nivel)
-            pulso = 1.0
+            pulso = 0.25 + self.nivel * 1.15
         elif self.estado == "pensando":
-            # Respiração lenta: trabalho em andamento, sem pressa aparente.
-            raio = RAIO_BASE * (1 + 0.06 * math.sin(self._fase * 0.8))
-            pulso = 0.8 + 0.2 * math.sin(self._fase * 0.8)
+            pulso = 0.42 + 0.30 * math.sin(self._fase * 2.1)
         elif self.estado == "falando":
-            raio = RAIO_BASE * (1 + 0.12 * math.sin(self._fase * 2.4))
-            pulso = 1.0
+            pulso = 0.55 + 0.38 * math.sin(self._fase * 3.4)
         else:
-            raio = RAIO_BASE * (1 + 0.03 * math.sin(self._fase * 0.5))
-            pulso = 0.55
-
-        # O halo: anéis concêntricos cada vez mais fracos. É o que faz a orb
-        # parecer luz em vez de um círculo pintado — tkinter não tem gradiente,
-        # então o degradê é feito com camadas.
-        camadas = 7
-        for i in range(camadas, 0, -1):
-            r = raio * (1 + i * 0.28)
-            cor = self._misturar(fundo, "#05070a", i / camadas * 0.85)
-            self.tela.create_oval(centro - r, centro - r, centro + r, centro + r,
-                                  fill=cor, outline="")
-
-        self.tela.create_oval(centro - raio, centro - raio, centro + raio, centro + raio,
-                              fill=self._misturar(vivo, fundo, 1 - pulso), outline="")
-        # O brilho de cima, deslocado: dá volume à esfera.
-        br = raio * 0.42
-        self.tela.create_oval(centro - br, centro - raio * 0.62,
-                              centro + br * 0.5, centro - raio * 0.05,
-                              fill=self._misturar("#ffffff", vivo, 0.62), outline="")
+            pulso = 0.16 + 0.10 * math.sin(self._fase * 0.9)
+
+        raio = RAIO_BASE * (1 + pulso * 0.42)
+
+        # HALO: círculos concêntricos, do mais largo e apagado ao núcleo. É o
+        # desfoque que o Canvas não tem — e por isso a cor de cada anel é
+        # interpolada contra o fundo, em vez de ter opacidade.
+        for i in range(11, 0, -1):
+            f = i / 11
+            r = raio * (1 + f * 2.6)
+            cor = _mistura(self.fundoDaMistura, fundo, (1 - f) ** 2 * 0.85)
+            self.tela.create_oval(cx - r, cy - r, cx + r, cy + r, fill=cor, outline="")
+
+        # PARTÍCULAS: entre o halo e o núcleo, para o núcleo ficar por cima.
+        for p in self._particulas:
+            p.ang += p.giro * 0.012 * (0.6 + pulso)
+            # O raio respira junto com a voz: quanto mais alto se fala, mais
+            # longe o enxame se abre.
+            osc = math.sin(self._fase * 1.7 + p.fase)
+            r = raio * (p.raio + 0.30 * osc + pulso * 0.55)
+            px = cx + math.cos(p.ang) * r * 1.55      # elipse: a janela é deitada
+            py = cy + math.sin(p.ang) * r * 0.80
+            t = p.tam * (0.7 + pulso * 0.8)
+            cor = _mistura(self.fundoDaMistura, vivo, p.brilho * (0.35 + pulso * 0.65))
+            self.tela.create_oval(px - t, py - t, px + t, py + t, fill=cor, outline="")
+
+        # NÚCLEO: dois discos, o de dentro mais claro. Dá volume sem gradiente.
+        self.tela.create_oval(cx - raio, cy - raio, cx + raio, cy + raio,
+                              fill=_mistura(fundo, vivo, 0.72), outline="")
+        rn = raio * 0.55
+        self.tela.create_oval(cx - rn, cy - rn, cx + rn, cy + rn,
+                              fill=_mistura(vivo, "#ffffff", 0.35), outline="")
 
         self.raiz.after(33, self._pintar)
 
-    @staticmethod
-    def _misturar(a: str, b: str, quanto: float) -> str:
-        """`a` misturado com `b`. tkinter não tem alpha por forma, então a
-        transparência é resolvida na cor."""
-        quanto = max(0.0, min(1.0, quanto))
-        ra, ga, ba = int(a[1:3], 16), int(a[3:5], 16), int(a[5:7], 16)
-        rb, gb, bb = int(b[1:3], 16), int(b[3:5], 16), int(b[5:7], 16)
-        r = round(ra + (rb - ra) * quanto)
-        g = round(ga + (gb - ga) * quanto)
-        bl = round(ba + (bb - ba) * quanto)
-        return f"#{r:02x}{g:02x}{bl:02x}"
-
-    # ── de fora ──────────────────────────────────────────────────────────
-    def mudar(self, estado: Optional[str] = None, nivel: Optional[float] = None) -> None:
-        """Chamado de OUTRAS threads. tkinter não é seguro fora da thread
-        principal, então o que chega vai para uma fila e é lido no desenho."""
-        self._fila.put((estado, nivel))
-
+    # ── visibilidade ─────────────────────────────────────────────────────
     def esconder(self) -> None:
         """Some da tela sem morrer.
 
-        O modo de espera fica MINUTOS ou horas sem nada acontecer, e uma orbe
-        parada no meio do monitor todo esse tempo é um estorvo — ela cobre o
-        que a pessoa está fazendo. Então ela some e volta quando chamada.
-
-        Destruir e recriar a janela a cada despertar seria o caminho óbvio, e é
-        o errado: recriar uma Tk leva centenas de milissegundos, pisca, e em
-        alguns sistemas rouba o foco da janela onde a pessoa estava digitando.
-        `withdraw` tira da tela e guarda tudo de pé.
+        No modo de espera ele fica horas sem nada acontecer, e uma orb parada
+        na tela todo esse tempo é estorvo. Destruir e recriar a janela a cada
+        despertar seria o caminho óbvio, e é o errado: recriar uma Tk leva
+        centenas de milissegundos, pisca, e em alguns sistemas rouba o foco da
+        janela onde a pessoa estava digitando. `withdraw` guarda tudo de pé.
         """
         self._fila.put(("__esconder__", None))
 
     def mostrar(self) -> None:
-        """Volta para a tela, no centro, por cima de tudo."""
         self._fila.put(("__mostrar__", None))
 
-    def _aplicar_visibilidade(self, visivel: bool) -> None:
+    def _aplicarVisibilidade(self, visivel: bool) -> None:
         # Só na thread da interface: tkinter não perdoa chamada de fora.
         try:
             if visivel:
-                self.veu.deiconify()
                 self.raiz.deiconify()
                 self.raiz.lift()
                 if sys.platform != "linux":
                     self.raiz.attributes("-topmost", True)
             else:
                 self.raiz.withdraw()
-                self.veu.withdraw()
         except Exception:
             pass          # janela já fechando: nada a fazer
         self.visivel = visivel
 
+    # ── ciclo de vida ────────────────────────────────────────────────────
+    def mudar(self, estado: Optional[str] = None, nivel: Optional[float] = None) -> None:
+        self._fila.put((estado, nivel))
+
     def fechar(self) -> None:
         if not self._vivo:
             return
         self._vivo = False
-        if self._ao_fechar:
-            try:
+        try:
+            if self._ao_fechar:
                 self._ao_fechar()
-            except Exception:
-                pass
+        except Exception:
+            pass
         try:
-            self.raiz.quit()
             self.raiz.destroy()
         except Exception:
             pass