primocode 10.4.2 → 10.4.4

package/README.md

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

package/bin/primocode.js

@@ -305,6 +305,8 @@ function sliderEffort(atual) {
         let anima = null;
 
         const pintar = (primeira) => {
+            // Na tela cheia o slider desenha no painel dela, acima da caixa.
+            if (rl && rl.cheia) return rl.painel(effort.desenharEffort(idx, fase));
             if (!primeira) process.stdout.write(`\x1b[${ALTURA}A\r`);
             process.stdout.write(effort.desenharEffort(idx, fase).split('\n').map((l) => '\x1b[2K' + l).join('\n') + '\n');
         };
@@ -466,7 +468,7 @@ function barraDeStatus() {
             : uso.pct >= 70 ? c.warn(`${uso.pct}% ctx`)
                 : c.dim(`${uso.pct}% ctx`));
     }
-    direita.push(state.trabalhando
+    direita.push(state.trabalhando && rl && rl.ocupado
         ? c.warn('trabalhando') + c.dim(' · ') + c.white('esc esc') + c.dim(' para')
         : c.white('tab') + c.dim(' modos  ') + c.white('ctrl+p') + c.dim(' comandos'));
 
@@ -920,6 +922,7 @@ function abrirMarketplace() {
             const texto = marketplace.montar(estado, {
                 colunas: process.stdout.columns || 80, altura: altura(),
             });
+            if (rl && rl.cheia) return rl.painel(texto);
             const linhas = texto.split('\n');
             // Redesenha POR CIMA do quadro anterior em vez de rolar a tela:
             // sem isso, cada seta empurraria a tela inteira para cima e o
@@ -2760,6 +2763,8 @@ async function main() {
         vazio: ui.convite(),
         telaCheia,
         lateral: barraLateral,
+        logoAnimado: (quadro, trabalhando) => ui.logoAnimado(state.config.mascot, quadro, trabalhando),
+        agora: () => (ui.agora.texto && Date.now() - ui.agora.desde < 10 * 60 * 1000 ? ui.agora.texto : ''),
         versao: VERSION,
         logo: ui.logoComMascote(state.config.mascot),
         pasta: () => {
@@ -2852,6 +2857,9 @@ async function main() {
             const text = queue.shift().trim();
             if (!text) continue;
             ui.titulo(`⠋ PrimoCode — ${text}`);
+            // Comando (/effort, /help) não é trabalho do agente: a caixa e a
+            // barra da direita só dizem "trabalhando" quando ele trabalha.
+            if (rl.trabalhando) rl.trabalhando(!isSlash(text));
             try {
                 if (ehBash(text)) await rodarBash(text);
                 else if (isSlash(text)) await handleSlash(text);
@@ -2867,7 +2875,7 @@ async function main() {
                 vozNaTarefa = false;
                 const ultima = state.history.slice().reverse().find((m) => m.role === 'assistant');
                 if (ultima && ultima.content) vozEmEspera.falar(ultima.content);
-            }
+            } else if (vozEmEspera && vozEmEspera.estado) vozEmEspera.estado('esperando');
             // Recado que chegou tarde demais para a tarefa (ela já tinha
             // acabado): vira o próximo pedido, na ordem. Nada se perde.
             queue.unshift(...sobrasDaCaixa());

package/lib/claude-engine.js

@@ -668,6 +668,6 @@ module.exports = {
     MODELO_CLAUDE, argsDoModelo, argsDoMotor,
     SKILL_DIR, SKILL_PATH, garantirSkill,
     temClaudeCode, temOrca, orcaAlcancavel, escolherCaminho,
-    garantirEngine, requestAct, emitirDecisao,
+    garantirEngine, requestAct, emitirDecisao, rodarClaude,
     _emitirDecisao: emitirDecisao,
 };

package/lib/entrada.js

@@ -41,6 +41,7 @@ const readline = require('readline');
 const { EventEmitter } = require('events');
 const { c, visibleWidth, truncate } = require('./ui.js');
 const tela = require('./tela.js');
+const stripAnsiLocal = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
 
 // ── O desenho ────────────────────────────────────────────────────────────
 
@@ -190,6 +191,10 @@ function montar(e) {
     if (st.linhas) {
         for (const linha of st.linhas) out.push(' ' + truncate(linha, largura - 2));
     } else {
+        /* Uma linha vazia entre o painel e o rodapé. Colado, o rodapé parecia
+           SOBREPOSTO ao painel em terminais de entrelinha apertada (o Orca):
+           o fundo do painel encostava nas letras da pasta. */
+        out.push('');
         const esq = st.esquerda || '';
         const dir = st.direita || '';
         const sobra = largura - 2 - visibleWidth(esq) - visibleWidth(dir);
@@ -323,7 +328,6 @@ class Entrada extends EventEmitter {
                e quem põe na tela é o próximo quadro. Suspensa (o painel do
                /effort desenhando por cima), passa direto. */
             if (eu.cheia) {
-                if (eu.suspenso) return eu._stdoutOriginal.call(this, texto, ...resto);
                 tela.acrescentar(eu.conversa, texto);
                 eu._agendar();
                 const fim = resto.find((r) => typeof r === 'function');
@@ -388,13 +392,23 @@ class Entrada extends EventEmitter {
     /* Enquanto outro desenho é dono da tela — o painel do /effort, uma tela
        do marketplace — a caixa sai da frente e larga o teclado. Sem isso, os
        dois desenhariam no mesmo lugar e as setas moveriam os dois. */
-    suspender() { this.suspenso = true; if (this.cheia) this._sairDaTela(); else this._apagar(); }
+    /* Na tela cheia, suspender só LARGA O TECLADO: a tela continua no ar, e
+       quem suspendeu desenha pelo `painel()`. Sair da tela alternativa aqui
+       (o jeito antigo) jogava o /effort por cima do terminal velho, e a
+       volta deixava tudo bagunçado. */
+    suspender() { this.suspenso = true; if (this.cheia) this._agendar(); else this._apagar(); }
     retomar() {
         this.suspenso = false;
-        if (this.cheia && this.ativo && !this.fechado) { this._entrarNaTela(); return this._pintar(); }
+        if (this.cheia && this.ativo && !this.fechado) { this.painelTexto = null; return this._pintar(); }
         if (this.ativo && !this.fechado) this._desenhar();
     }
 
+    /** Um comando com tela própria desenha aqui (na tela cheia). null fecha. */
+    painel(texto) {
+        this.painelTexto = texto == null ? null : String(texto).replace(/\n+$/, '');
+        this._pintar();
+    }
+
     // ── a tela cheia ─────────────────────────────────────────────────────
 
     /* A tela alternativa (a do vim): o que estava no terminal fica guardado e
@@ -412,7 +426,7 @@ class Entrada extends EventEmitter {
             this._colunasReais = process.stdout.columns || 80;
             Object.defineProperty(process.stdout, 'columns', {
                 configurable: true,
-                get() { return eu._naTela && !eu.suspenso ? tela.larguraDaConversa(eu._colunasReais) : eu._colunasReais; },
+                get() { return eu._naTela ? tela.larguraDaConversa(eu._colunasReais) : eu._colunasReais; },
                 set(v) { eu._colunasReais = v; },   // o Node escreve aqui quando a janela muda
             });
         }
@@ -440,14 +454,36 @@ class Entrada extends EventEmitter {
     /** O estado do quadro, para a tela cheia (função pura em lib/tela.js). */
     _quadroCheio() {
         const conversa = this.conversa.some((l) => /\S/.test(l));
+        const trabalhando = !!(this.ocupado || this.spinnerTexto);
+        const quadro = Date.now() / 140;
+        /* O topo da barra da direita: o logo do PrimoCode (que anima enquanto
+           ele trabalha) e o ESTADO — trabalhando, há quanto tempo, no quê. */
+        const topo = this.op.logoAnimado ? this.op.logoAnimado(quadro, trabalhando) : [];
+        topo.push('');
+        if (trabalhando) {
+            const giro = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'][Math.floor(quadro) % 10];
+            topo.push(c.warn(giro + ' Trabalhando') + (this._desde ? c.dim(` · ${Math.floor((Date.now() - this._desde) / 1000)}s`) : ''));
+            const agora = this.op.agora ? this.op.agora() : '';
+            if (agora) topo.push(c.muted(agora));
+            if (this.spinnerTexto) topo.push(c.dim(stripAnsiLocal(this.spinnerTexto).replace(/^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s*/, '')));
+        } else {
+            topo.push(c.brand('● ') + c.muted('Pronto') + c.dim(' · esperando você'));
+        }
+        if (trabalhando && !this._animando) {
+            // Enquanto trabalha, a barra se redesenha sozinha (o logo anima
+            // e o relógio anda), mesmo que nada novo chegue na conversa.
+            this._animando = setInterval(() => this._pintar(), 140);
+            if (this._animando.unref) this._animando.unref();
+        } else if (!trabalhando && this._animando) { clearInterval(this._animando); this._animando = null; }
         return tela.quadro({
             colunas: this._colunasReais || 80,
             linhas: process.stdout.rows || 24,
             conversa: this.conversa,
             rolagem: this.rolagem,
-            home: !this.mandou && !conversa,
+            home: !this.mandou && !conversa && !this.painelTexto,
             caixa: (colunas, centro) => montar({ ...this._estado(), colunas, centro, menuAcima: true }),
-            lateral: { titulo: this.titulo, ...(this.op.lateral ? this.op.lateral() : {}) },
+            lateral: { titulo: this.titulo, topo, ...(this.op.lateral ? this.op.lateral() : {}) },
+            painel: this.painelTexto,
             versao: this.op.versao || '',
             logo: this.op.logo,
             pasta: this.op.pasta ? this.op.pasta() : '',
@@ -455,7 +491,7 @@ class Entrada extends EventEmitter {
     }
 
     _pintar() {
-        if (!this.cheia || this.suspenso || this.fechado || !this._naTela) return;
+        if (!this.cheia || this.fechado || !this._naTela) return;
         const q = this._quadroCheio();
         this.rolagem = Math.min(this.rolagem, q.rolagemMax);
         let out = '\x1b[?25l';
@@ -477,6 +513,7 @@ class Entrada extends EventEmitter {
     trabalhando(sim) {
         if (this.ocupado === !!sim) return;
         this.ocupado = !!sim;
+        this._desde = sim ? Date.now() : 0;
         if (this.desenhado) this._redesenhar();
     }
 

package/lib/local/motor-cli.js

@@ -16,11 +16,8 @@
 
 'use strict';
 
-const { execFileSync } = require('child_process');
 const cerebro = require('./cerebro.json');
 
-const SEM_APARECER = { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true };
-
 function motorDe(id) {
     if (id === 'codex') {
         /* O padrão antigo do motor (gpt-5-mini) é recusado por conta de
@@ -33,13 +30,19 @@ function motorDe(id) {
     return require('../claude-engine.js');
 }
 
-/** Uma pergunta de texto, resposta de texto. Sem protocolo, sem ferramenta. */
-function perguntar(id, texto) {
-    if (id === 'codex') return String(motorDe('codex').chamarCodex(texto) || '').trim();
+/** Uma pergunta de texto, resposta de texto. Sem protocolo, sem ferramenta.
+ *
+ *  ASSÍNCRONA. Era `execFileSync('claude', …)`: enquanto o Claude pensava, o
+ *  PrimoCode inteiro parava — a tela cheia congelava em "Trabalhando · 0s",
+ *  sem animação, sem Esc Esc, sem dar para digitar. O agente (requestAct) já
+ *  rodava em paralelo; o chat e o resumo eram os que travavam. E o Codex
+ *  devolvia "[object Promise]": a chamada dele já era assíncrona e o
+ *  resultado virava texto sem esperar. */
+async function perguntar(id, texto) {
+    if (id === 'codex') return String((await motorDe('codex').chamarCodex(texto)) || '').trim();
     const claude = motorDe('claude-code');
-    const saida = execFileSync('claude', ['-p', '--output-format', 'json', ...claude.argsDoMotor()], {
-        encoding: 'utf-8', timeout: 120000, input: texto, maxBuffer: 8 * 1024 * 1024, ...SEM_APARECER,
-    });
+    const saida = await claude.rodarClaude(['-p', '--output-format', 'json', ...claude.argsDoMotor()], texto,
+        { timeout: 180000, tentativas: 1 });
     try { return String(JSON.parse(saida).result || '').trim(); } catch { return String(saida || '').trim(); }
 }
 
@@ -54,7 +57,7 @@ function criar(id) {
             const conversa = turnos.filter((m) => m && m.role && typeof m.content === 'string')
                 .map((m) => `${m.role === 'user' ? 'PESSOA' : 'VOCÊ'}: ${m.content}`).join('\n');
             try {
-                const resposta = perguntar(id, `${cerebro.SYSTEM_CHAT}\n\nResponda só à última fala da PESSOA.\n\n${conversa}`);
+                const resposta = await perguntar(id, `${cerebro.SYSTEM_CHAT}\n\nResponda só à última fala da PESSOA.\n\n${conversa}`);
                 if (resposta) emit({ delta: resposta });
             } catch (e) {
                 emit({ erro: e.message });
@@ -69,7 +72,7 @@ function criar(id) {
                 + novas.map((m) => `${m.role === 'user' ? 'USUÁRIO' : m.role === 'assistant' ? 'AGENTE' : 'FERRAMENTA'}: `
                     + String(typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '')).slice(0, 1200)).join('\n');
             try {
-                return { resumo: perguntar(id, `${cerebro.SYSTEM_RESUMO}\n\n${corpo}`) || String(resumo || '') };
+                return { resumo: (await perguntar(id, `${cerebro.SYSTEM_RESUMO}\n\n${corpo}`)) || String(resumo || '') };
             } catch (e) {
                 return { resumo: String(resumo || ''), erro: e.message };
             }

package/lib/tela.js

@@ -116,6 +116,8 @@ function caber(s, w, fundo) {
 function lateral(lat, alto) {
     const w = LATERAL_W - 4;           // 2 de margem de cada lado
     const corpo = [''];
+    // O topo: o logo (animado enquanto trabalha) e o estado do Primo agora.
+    if (lat.topo && lat.topo.length) corpo.push(...lat.topo, '');
     for (const l of quebrarComCor(c.bold(c.white(lat.titulo || 'Nova sessão')), w)) corpo.push(l);
     for (const s of (lat.secoes || [])) {
         corpo.push('');
@@ -170,7 +172,9 @@ function quadro(e) {
         while (linhas.length < H - 1) linhas.push('');
         linhas.length = H - 1;
         const esq = ' ' + c.dim(e.pasta || '');
-        const dir = c.dim(e.versao || '') + ' ';
+        // Folga à direita: terminais como o Orca põem um botão flutuante no
+        // canto de baixo, e ele cobria a versão ("10.").
+        const dir = c.dim(e.versao || '') + '      ';
         linhas.push(esq + ' '.repeat(Math.max(1, W - visibleWidth(esq) - visibleWidth(dir))) + dir);
         return {
             linhas: linhas.map((l) => caber(l, W)),
@@ -179,6 +183,10 @@ function quadro(e) {
         };
     }
 
+    /* O PAINEL de um comando que desenha a própria tela (o slider do
+       /effort, o marketplace): fica no pé da conversa, logo acima da caixa,
+       por cima do que estiver ali — a tela cheia nunca sai do ar. */
+    const painel = (e.painel ? String(e.painel).split('\n') : []);
     const comLateral = W >= LATERAL_MIN;
     const mainW = comLateral ? W - LATERAL_W : W;
     /* Uma coluna de margem dos dois lados, para a conversa e para a caixa: o
@@ -207,6 +215,11 @@ function quadro(e) {
     const conversa = [];
     for (let i = janela.length; i < altoConversa; i++) conversa.push('');
     for (const l of janela) conversa.push(l);
+    if (painel.length) {
+        const inicio = Math.max(0, conversa.length - painel.length - 1);
+        conversa.splice(inicio, conversa.length - inicio, '', ...painel.map((l) => ' ' + l));
+        conversa.length = altoConversa;
+    }
     if (rolagem > 0) {
         conversa[0] = ' ' + c.dim(`↑ ${rolagem} linha${rolagem > 1 ? 's' : ''} abaixo · PgDn ou a roda do mouse para voltar`);
     }

package/lib/ui.js

@@ -358,12 +358,75 @@ function logo() {
 }
 const LOGO_W = visibleWidth(logo()[0]);
 
-/** O logo com o mascote do PrimoCode na frente — o desenho de 3 linhas
- *  alinhado às 3 linhas do corpo das letras (a 4ª é só a perna do p). */
+/* ── O mascote GRANDE ─────────────────────────────────────────────────
+   O desenho de sempre tem 3 linhas — pequeno ao lado do logo de 4. Para a
+   home ele cresce 2×: cada quarto de bloco (▘ ▝ ▖ ▗) vira um bloco cheio, e
+   cada bloco cheio vira 2×2. Ficam 6 linhas × 18 colunas, com a cor de cada
+   pedaço preservada — o mesmo desenho, não um desenho novo. */
+const QUARTOS = {
+    ' ': [0, 0, 0, 0], '█': [1, 1, 1, 1], '▀': [1, 1, 0, 0], '▄': [0, 0, 1, 1],
+    '▌': [1, 0, 1, 0], '▐': [0, 1, 0, 1], '▘': [1, 0, 0, 0], '▝': [0, 1, 0, 0],
+    '▖': [0, 0, 1, 0], '▗': [0, 0, 0, 1], '▛': [1, 1, 1, 0], '▜': [1, 1, 0, 1],
+    '▙': [1, 0, 1, 1], '▟': [0, 1, 1, 1], '▚': [1, 0, 0, 1], '▞': [0, 1, 1, 0],
+};
+function mascoteGrande(style) {
+    const saida = [];
+    for (const linha of mascot(style)) {
+        // [caractere, cor] de cada coluna da linha colorida
+        const cels = [];
+        let cor = '';
+        for (const m of linha.matchAll(/(\x1b\[[0-9;]*m)|([^\x1b])/gu)) {
+            if (m[1]) { if (m[1] !== PALETTE.reset) cor = m[1]; continue; }
+            cels.push([m[2], cor]);
+        }
+        const cima = [], baixo = [];
+        for (const [ch, cr] of cels) {
+            const q = QUARTOS[ch] || (ch === ' ' ? QUARTOS[' '] : QUARTOS['█']);
+            const bloco = (b) => (b ? `${cr}█${PALETTE.reset}` : ' ');
+            cima.push(bloco(q[0]) + bloco(q[1]));
+            baixo.push(bloco(q[2]) + bloco(q[3]));
+        }
+        saida.push(cima.join(''), baixo.join(''));
+    }
+    while (saida.length && !saida[saida.length - 1].trim()) saida.pop();   // a linha vazia de baixo
+    return saida;
+}
+
+/** O logo da home: o mascote grande e, centrado na altura dele, o letreiro. */
 function logoComMascote(style) {
-    const m = mascot(style);
+    const m = mascoteGrande(style);
     const l = logo();
-    return l.map((linha, i) => (m[i] || ' '.repeat(ART_W)) + '   ' + linha);
+    const desce = Math.floor((m.length - l.length) / 2);
+    const linhas = m.map((linha, i) => linha + '    ' + (l[i - desce] || ''));
+    // Todas com a MESMA largura: a home centraliza linha por linha, e uma
+    // linha mais curta (a dos pés) sairia deslocada do resto do desenho.
+    const larg = Math.max(...linhas.map(visibleWidth));
+    return linhas.map((x) => x + ' '.repeat(larg - visibleWidth(x)));
+}
+
+/* ── O logo animado da barra da direita ──────────────────────────────────
+   Enquanto o Primo trabalha, o mascote pulsa (a cor viva respira entre três
+   tons de ciano), os pés andam, e um brilho corre pelo nome "PrimoCode".
+   Parado, fica quieto: animação sem trabalho é ruído. `quadro` é um número
+   que cresce com o tempo (o chamador passa Date.now()/120). */
+const PULSO = ['\x1b[38;5;45m', '\x1b[38;5;51m', '\x1b[38;5;87m', '\x1b[38;5;51m'];
+function logoAnimado(style, quadro, trabalhando) {
+    const f = Math.floor(quadro || 0);
+    const m = MASCOTS[style] || MASCOTS.primo;
+    // Os pés andam: a linha dos pés troca de passo a cada quadro.
+    const linhas = m.linhas.map((l) => (trabalhando && f % 2 && l === PES ? '  ▝▘ ▘▝  ' : l));
+    let art = linhas.map((l, i) => shade(l, m, m.mascara && m.mascara[i]));
+    if (trabalhando) art = art.map((l) => l.split(PALETTE.brand).join(PULSO[f % PULSO.length]));
+    const nome = 'PrimoCode';
+    const brilho = f % (nome.length + 8);
+    let texto = '';
+    [...nome].forEach((ch, i) => {
+        const base = i < 5 ? '\x1b[38;5;255m' : '\x1b[38;5;45m';
+        const aceso = trabalhando && Math.abs(i - brilho) <= 0;
+        const perto = trabalhando && Math.abs(i - brilho) === 1;
+        texto += (aceso ? '\x1b[1m\x1b[38;5;231m' : perto ? '\x1b[1m\x1b[38;5;159m' : '\x1b[1m' + base) + ch + PALETTE.reset;
+    });
+    return [art[0], art[1] + '  ' + texto, art[2]];
 }
 
 /** Centraliza uma linha (com cor) em `cols` colunas. */
@@ -467,6 +530,8 @@ function titulo(texto) {
     try { escrever(`\x1b]0;${limpo}\x07`); } catch { /* terminal fechado */ }
 }
 
+const agora = { texto: '', desde: 0 };
+
 // O rótulo de cada tool na tela — o que a pessoa lê no lugar do nome interno.
 const ROTULOS = {
         read_file:'Read', write_file:'Write', edit_file:'Edit', multi_edit:'MultiEdit',
@@ -508,6 +573,9 @@ function actionHeader(name, args) {
     // virava "[object Object]" na tela.
     if (argStr && typeof argStr === 'object') argStr = JSON.stringify(argStr).slice(0, 60);
     argStr = String(argStr || '').replace(/\s+/g, ' ').trim();
+    // O que ele está fazendo AGORA — a barra da direita da tela cheia mostra.
+    agora.texto = label + (argStr ? ' · ' + argStr.slice(0, 60) : '');
+    agora.desde = Date.now();
     // Uma tool sem argumento nenhum caía no JSON.stringify e desenhava "{}"
     // ao lado do nome — ruído que não diz nada.
     if (argStr === '{}' || argStr === 'null' || argStr === 'undefined') argStr = '';
@@ -641,4 +709,4 @@ function friendlyError(raw) {
 
 
 module.exports = {
-    titulo, c, logo, logoComMascote, letreiro, convite, EXEMPLOS, mascot, MASCOTES, resolverMascote, mascoteInfo, galeriaMascotes, reacao, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };
+    titulo, agora, c, logo, logoComMascote, mascoteGrande, logoAnimado, letreiro, convite, EXEMPLOS, mascot, MASCOTES, resolverMascote, mascoteInfo, galeriaMascotes, reacao, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };

package/lib/voz.js

@@ -278,6 +278,8 @@ function abrir({ python: py, servidor, token, voz, aoOuvir, mostrar = () => {},
         pronto,
         falar: (texto) => { const t = paraFalar(texto); if (t) manda({ tipo: 'falar', texto: t }); },
         calar: () => manda({ tipo: 'calar' }),
+        // A bolinha na tela: 'esperando' quando o terminal termina sem falar.
+        estado: (e) => manda({ tipo: 'estado', estado: e }),
     };
 }
 

package/package.json

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

@@ -44,6 +44,50 @@ sys.path.insert(0, str(AQUI.parent))
 from primo_voz import escuta, transcrever  # noqa: E402
 
 
+class Bolinha:
+    """A orb (orbe.py) num processo à parte: este só diz o estado a ela.
+
+    Sem tkinter, ou se ela morrer, o modo voz segue igual — a bolinha é o
+    rosto, não o ouvido. Mudanças repetidas não são reenviadas, e o nível da
+    voz vai no máximo 15 vezes por segundo."""
+
+    def __init__(self) -> None:
+        self.p = None
+        self.ultimo = None
+        self.quando = 0.0
+        if os.environ.get("PRIMOCODE_SEM_ORB") == "1":
+            return
+        try:
+            self.p = subprocess.Popen([sys.executable, "-m", "primo_voz.orbe"], cwd=str(AQUI.parent),
+                                      stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                                      env={**os.environ, "PYTHONPATH": str(AQUI.parent)}, text=True)
+        except Exception:
+            self.p = None
+
+    def estado(self, estado: str, nivel: float = None) -> None:
+        if not self.p or self.p.poll() is not None:
+            return
+        agora = time.time()
+        if estado == self.ultimo and (nivel is None or agora - self.quando < 1 / 15):
+            return
+        self.ultimo, self.quando = estado, agora
+        msg = {"estado": estado}
+        if nivel is not None:
+            msg["nivel"] = round(min(1.0, nivel), 3)
+        try:
+            self.p.stdin.write(json.dumps(msg) + "\n")
+            self.p.stdin.flush()
+        except Exception:
+            pass
+
+    def fechar(self) -> None:
+        if self.p:
+            try:
+                self.p.stdin.close()
+            except Exception:
+                pass
+
+
 def falar_para_o_node(obj: dict) -> None:
     """Uma linha de JSON no stdout. Nada mais pode sair por aí."""
     sys.stdout.write(json.dumps(obj, ensure_ascii=False) + "\n")
@@ -100,6 +144,7 @@ class Voz:
             transcrever.aquecer()
         self.gravador = escuta.Gravador()
         self.corte = escuta.Corte()
+        self.bolinha = Bolinha()
         self._blocos: "queue.Queue" = queue.Queue()
         self._falas: "queue.Queue" = queue.Queue()
         self._vivo = True
@@ -138,6 +183,7 @@ class Voz:
             self.parar()
             return
         falar_para_o_node({"tipo": "pronto"})
+        self.bolinha.estado("esperando")
         while self._vivo:
             self.gravador.comecar()
             acabou = False
@@ -147,6 +193,10 @@ class Voz:
                 except queue.Empty:
                     continue
                 acabou = self.gravador.alimentar(bloco)
+                # A bolinha acende com a voz da pessoa, no tamanho da voz.
+                if self.gravador._falando and not self._falando:
+                    lim = max(1e-6, self.gravador._limiar())
+                    self.bolinha.estado("ouvindo", min(1.0, escuta.rms(bloco) / lim * 0.35))
             if not self._vivo:
                 break
             if self.gravador.encerrou_por == "ninguem-falou" or self.gravador.segundos < 0.4:
@@ -154,9 +204,14 @@ class Voz:
             wav = self.gravador.gravar_wav(Path(tempfile.gettempdir()) / "primo-voz-fala.wav")
             if not wav:
                 continue
+            self.bolinha.estado("pensando")
             texto = transcrever.limpar(self._transcrever(wav))
             if texto:
+                # Pensando até o terminal dizer o contrário (a resposta em
+                # voz, ou {"tipo":"estado"} quando ele termina sem falar).
                 falar_para_o_node({"tipo": "ouvi", "texto": texto})
+            else:
+                self.bolinha.estado("esperando")
         mic.fechar()
 
     def _transcrever(self, wav: Path) -> str:
@@ -213,10 +268,12 @@ class Voz:
             return
         self._falando = True
         self._parar_fala.clear()
+        self.bolinha.estado("falando", 0.6)
         try:
             self._tocar(mp3)
         finally:
             self._falando = False
+            self.bolinha.estado("esperando")
             self.corte.nivel_dele = 0.0
             # O que o microfone pegou enquanto ele falava é a voz dele.
             self._esvaziar_blocos()
@@ -283,6 +340,8 @@ class Voz:
                         self._falas.get_nowait()
                     except queue.Empty:
                         break
+            elif tipo == "estado":
+                self.bolinha.estado(str(msg.get("estado") or "esperando"))
             elif tipo == "fim":
                 break
         self.parar()
@@ -292,6 +351,7 @@ class Voz:
             return
         self._vivo = False
         self._parar_fala.set()
+        self.bolinha.fechar()
         falar_para_o_node({"tipo": "fim"})
 
     def rodar(self) -> None:

package/voz/primo_voz/orbe.py

@@ -0,0 +1,444 @@
+"""orbe.py — a única coisa que aparece na tela no modo voz.
+
+    "Quero que ele fique na parte inferior da tela, bem centralizado, um pouco
+     maior [...] mas ele tá rodando em uma caixa, deve ser totalmente
+     transparente." (23/09/2026)
+
+── O QUE ERA A "CAIXA" ─────────────────────────────────────────────────────
+Medido com uma captura da própria janela, no Tk 9 do macOS:
+
+1. `overrideredirect(True)` NÃO tira a moldura: a janela nascia com barra de
+   título, os três botões e o nome "Primo Code Voice".
+2. O fundo `systemTransparent` saía PRETO.
+3. O Canvas não apaga o quadro anterior sobre fundo transparente: cada
+   partícula deixava um rastro, e em segundos a janela virava um borrão.
+
+Nenhum dos três se conserta de dentro do Tk. Então, no macOS, a orb é
+desenhada pelo próprio sistema (PyObjC): uma NSWindow sem borda, sem fundo e
+sem sombra, e uma NSView que limpa e pinta cada quadro com transparência de
+verdade — o brilho é um gradiente com alfa, não discos misturados contra uma
+cor de fundo adivinhada. Só a orb aparece; o resto da janela não existe.
+
+O Tk continua sendo quem roda o laço de eventos (é ele que o resto do modo
+voz já usa), e segue como desenho de reserva fora do macOS ou sem PyObjC.
+
+── ONDE ELA MORA ───────────────────────────────────────────────────────────
+Embaixo, centralizada na ÁREA ÚTIL da tela — acima do Dock, não atrás dele.
+A posição é aplicada depois de a janela existir: dada cedo demais, a janela
+sem moldura ignora.
+
+── O QUE ELA DESENHA ───────────────────────────────────────────────────────
+Um núcleo com brilho 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ê.
+"""
+from __future__ import annotations
+
+import math
+import queue
+import random
+import sys
+import tkinter as tk
+from typing import Callable, List, Optional, Tuple
+
+# 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": ("#22b8d8", "#0e3a4a"),   # ciano calmo: 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
+}
+
+LARGURA = 360          # só a área da orb e do brilho — o resto é transparente
+ALTURA = 220
+RAIO_BASE = 34         # o núcleo
+MARGEM_INFERIOR = 24   # acima da área útil (o Dock já fica de fora)
+PARTICULAS = 44
+FUNDO_FALSO = "#05070a"   # só no desenho de reserva, onde não há alfa
+
+
+def _rgb(cor: str) -> Tuple[float, float, float]:
+    return int(cor[1:3], 16) / 255, int(cor[3:5], 16) / 255, int(cor[5:7], 16) / 255
+
+
+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.25, 2.3)         # múltiplo do raio do núcleo
+        self.giro = rnd.uniform(-0.9, 0.9) or 0.4
+        self.tam = rnd.uniform(1.3, 3.0)
+        self.fase = rnd.uniform(0, math.tau)
+        self.brilho = rnd.uniform(0.45, 1.0)
+
+
+class Quadro:
+    """Um quadro da animação, sem saber quem vai pintá-lo."""
+
+    def __init__(self, vivo: str, fundo: str, raio: float, pulso: float,
+                 particulas: List[Tuple[float, float, float, float]]):
+        self.vivo, self.fundo = vivo, fundo
+        self.raio, self.pulso = raio, pulso
+        self.particulas = particulas       # (x, y, tamanho, intensidade 0..1)
+
+
+# ── O desenho nativo do macOS ────────────────────────────────────────────
+
+def _criar_nativa(orbe: "Orbe"):
+    """A janela sem borda e sem fundo, desenhada pelo macOS. None se não der."""
+    if sys.platform != "darwin":
+        return None
+    try:
+        import objc
+        from AppKit import (NSBackingStoreBuffered, NSBezierPath, NSColor,
+                            NSCompositingOperationClear, NSGradient, NSMakeRect,
+                            NSRectFillUsingOperation, NSScreen, NSView, NSWindow)
+    except Exception:
+        return None
+
+    def cor(hexa: str, alfa: float):
+        r, g, b = _rgb(hexa)
+        return NSColor.colorWithSRGBRed_green_blue_alpha_(r, g, b, max(0.0, min(1.0, alfa)))
+
+    # A classe Objective-C só pode ser registrada uma vez por processo.
+    try:
+        Vista = objc.lookUpClass("PrimoOrbeVista")
+    except objc.nosuchclass_error:
+        class PrimoOrbeVista(NSView):
+            def isOpaque(self):
+                return False
+
+            def acceptsFirstMouse_(self, evento):
+                return True
+
+            def drawRect_(self, rect):
+                NSColor.clearColor().set()
+                NSRectFillUsingOperation(self.bounds(), NSCompositingOperationClear)
+                q = getattr(self, "quadro", None)
+                if q is None:
+                    return
+                cx, cy = LARGURA / 2, ALTURA / 2
+                centro = (cx, cy)
+
+                # BRILHO: um gradiente radial com alfa, que some no nada. É o
+                # que o Tk não sabia fazer — e o que tira o "disco escuro".
+                alcance = q.raio * (2.6 + q.pulso * 0.9)
+                brilho = NSGradient.alloc().initWithColors_(
+                    [cor(q.vivo, 0.34 + q.pulso * 0.20), cor(q.vivo, 0.10), cor(q.vivo, 0.0)])
+                brilho.drawFromCenter_radius_toCenter_radius_options_(centro, q.raio * 0.6, centro, alcance, 0)
+
+                # PARTÍCULAS
+                for (px, py, t, forca) in q.particulas:
+                    cor(q.vivo, 0.25 + forca * 0.75).set()
+                    NSBezierPath.bezierPathWithOvalInRect_(NSMakeRect(px - t, py - t, 2 * t, 2 * t)).fill()
+
+                # NÚCLEO: gradiente do claro ao vivo, com um anel fino por fora.
+                r = q.raio
+                nucleo = NSGradient.alloc().initWithColors_(
+                    [cor(_mistura(q.vivo, "#ffffff", 0.55), 1.0), cor(q.vivo, 1.0),
+                     cor(_mistura(q.vivo, q.fundo, 0.45), 1.0)])
+                nucleo.drawFromCenter_radius_toCenter_radius_options_(
+                    (cx - r * 0.25, cy + r * 0.25), 0, centro, r, 0)
+                cor(q.vivo, 0.55).set()
+                anel = NSBezierPath.bezierPathWithOvalInRect_(
+                    NSMakeRect(cx - r * 1.18, cy - r * 1.18, r * 2.36, r * 2.36))
+                anel.setLineWidth_(1.5)
+                anel.stroke()
+
+        Vista = PrimoOrbeVista
+
+    try:
+        janela = NSWindow.alloc().initWithContentRect_styleMask_backing_defer_(
+            NSMakeRect(0, 0, LARGURA, ALTURA), 0, NSBackingStoreBuffered, False)   # 0 = sem borda
+        janela.setOpaque_(False)
+        janela.setBackgroundColor_(NSColor.clearColor())
+        janela.setHasShadow_(False)
+        janela.setLevel_(25)                       # NSStatusWindowLevel: por cima de tudo
+        # O clique ATRAVESSA a orb: ela mora no pé da tela, em cima do Dock e
+        # do que o cursor do Primo precisa clicar. Uma orb que segura o clique
+        # faria o agente clicar nela em vez de no app.
+        janela.setIgnoresMouseEvents_(True)
+        janela.setCollectionBehavior_(1 | 16)      # todos os espaços; fora do Exposé
+        janela.setReleasedWhenClosed_(False)
+        vista = Vista.alloc().initWithFrame_(NSMakeRect(0, 0, LARGURA, ALTURA))
+        janela.setContentView_(vista)
+
+        # Embaixo, centralizada na área útil (acima do Dock). O Cocoa conta
+        # de baixo para cima, então a margem é somada ao pé da área útil.
+        util = NSScreen.mainScreen().visibleFrame()
+        x = util.origin.x + (util.size.width - LARGURA) / 2
+        y = util.origin.y + MARGEM_INFERIOR
+        janela.setFrameOrigin_((x, y))
+        janela.orderFrontRegardless()
+        return janela, vista
+    except Exception:
+        return None
+
+
+class Orbe:
+    """A janela da orb. Roda na thread principal, como toda interface."""
+
+    def __init__(self, ao_fechar: Optional[Callable] = None):
+        self.raiz = tk.Tk()
+        self.raiz.title("Primo Code Voice")
+        self.estado = "esperando"
+        self.visivel = True
+        self.nivel = 0.0          # 0..1, o quanto a pessoa está falando
+        self._fase = 0.0
+        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)]
+
+        nativa = _criar_nativa(self)
+        if nativa:
+            # O macOS desenha; a janela do Tk fica escondida e só roda o laço.
+            self.janela, self.vista = nativa
+            self.nativa = True
+            self.raiz.withdraw()
+        else:
+            self.janela = self.vista = None
+            self.nativa = False
+            self._montar_tk()
+
+        self.raiz.protocol("WM_DELETE_WINDOW", self.fechar)
+        self.raiz.bind("<Escape>", lambda e: self.fechar())
+        self._pintar()
+
+    # ── a reserva em Tk (fora do macOS, ou sem PyObjC) ───────────────────
+    def _montar_tk(self) -> None:
+        self.raiz.overrideredirect(True)
+        self.fundo = FUNDO_FALSO
+        if sys.platform == "win32":
+            # No Windows o Tk dá transparência por cor-chave, e ela funciona.
+            try:
+                self.raiz.attributes("-transparentcolor", FUNDO_FALSO)
+            except tk.TclError:
+                pass
+        try:
+            self.raiz.attributes("-topmost", True)
+        except tk.TclError:
+            pass
+        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()
+        self.raiz.update_idletasks()
+        self._posicionar_tk()
+        self.raiz.after(120, self._posicionar_tk)
+        self.raiz.bind("<Button-1>", self._pegar)
+        self.raiz.bind("<B1-Motion>", self._arrastar)
+        self._pego = (0, 0)
+
+    def _posicionar_tk(self) -> None:
+        x = (self.raiz.winfo_screenwidth() - LARGURA) // 2
+        y = self.raiz.winfo_screenheight() - ALTURA - MARGEM_INFERIOR - 48
+        try:
+            self.raiz.geometry(f"{LARGURA}x{ALTURA}+{x}+{max(0, y)}")
+        except tk.TclError:
+            pass
+
+    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]}")
+
+    # ── a animação ───────────────────────────────────────────────────────
+    def _quadro(self) -> Quadro:
+        self._fase += 0.045
+        vivo, fundo = CORES.get(self.estado, CORES["esperando"])
+        cx, cy = LARGURA / 2, ALTURA / 2
+
+        # 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":
+            pulso = 0.25 + self.nivel * 1.15
+        elif self.estado == "pensando":
+            pulso = 0.42 + 0.30 * math.sin(self._fase * 2.1)
+        elif self.estado == "falando":
+            pulso = 0.55 + 0.38 * math.sin(self._fase * 3.4)
+        else:
+            pulso = 0.16 + 0.10 * math.sin(self._fase * 0.9)
+        raio = RAIO_BASE * (1 + pulso * 0.30)
+
+        pontos = []
+        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.25 * osc + pulso * 0.40)
+            # Elipse leve, mais larga que alta — e dentro da janela: o que
+            # passa da borda é cortado seco, e partícula cortada é defeito.
+            px = cx + math.cos(p.ang) * r * 1.2
+            py = cy + math.sin(p.ang) * r * 0.74
+            t = p.tam * (0.75 + pulso * 0.6)
+            pontos.append((px, py, t, p.brilho * (0.5 + pulso * 0.5)))
+        return Quadro(vivo, fundo, raio, pulso, pontos)
+
+    def _pintar(self) -> None:
+        if not self._vivo:
+            return
+        while True:
+            try:
+                estado, nivel = self._fila.get_nowait()
+                if estado == "__esconder__":
+                    self._aplicarVisibilidade(False)
+                    continue
+                if estado == "__mostrar__":
+                    self._aplicarVisibilidade(True)
+                    continue
+                if estado == "__fechar__":
+                    self.fechar()
+                    return
+                if estado:
+                    self.estado = estado
+                if nivel is not None:
+                    self.nivel = max(0.0, min(1.0, nivel))
+            except queue.Empty:
+                break
+
+        q = self._quadro()
+        if self.nativa:
+            self.vista.quadro = q
+            self.vista.setNeedsDisplay_(True)
+        else:
+            self._pintar_tk(q)
+        self.raiz.after(33, self._pintar)
+
+    def _pintar_tk(self, q: Quadro) -> None:
+        """A reserva: forma chapada, sem alfa. Misturas contra o fundo."""
+        cx, cy = LARGURA / 2, ALTURA / 2
+        self.tela.delete("all")
+        for i in range(6, 0, -1):
+            f = i / 6
+            r = q.raio * (1 + f * 1.3)
+            self.tela.create_oval(cx - r, cy - r, cx + r, cy + r,
+                                  outline=_mistura(self.fundo, q.vivo, (1 - f) ** 1.6 * 0.7), width=2)
+        for (px, py, t, forca) in q.particulas:
+            self.tela.create_oval(px - t, py - t, px + t, py + t,
+                                  fill=_mistura(self.fundo, q.vivo, 0.3 + forca * 0.7), outline="")
+        r = q.raio
+        self.tela.create_oval(cx - r, cy - r, cx + r, cy + r,
+                              fill=_mistura(q.fundo, q.vivo, 0.8), outline="")
+        rn = r * 0.55
+        self.tela.create_oval(cx - rn, cy - rn, cx + rn, cy + rn,
+                              fill=_mistura(q.vivo, "#ffffff", 0.4), outline="")
+
+    # ── visibilidade ─────────────────────────────────────────────────────
+    def esconder(self) -> None:
+        """Some da tela sem morrer.
+
+        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 pisca e, em alguns sistemas, rouba o foco de onde a pessoa
+        estava digitando. Esconder guarda tudo de pé.
+        """
+        self._fila.put(("__esconder__", None))
+
+    def mostrar(self) -> None:
+        self._fila.put(("__mostrar__", None))
+
+    def _aplicarVisibilidade(self, visivel: bool) -> None:
+        # Só na thread da interface: nem o Tk nem o AppKit perdoam chamada de fora.
+        try:
+            if self.nativa:
+                if visivel:
+                    self.janela.orderFrontRegardless()
+                else:
+                    self.janela.orderOut_(None)
+            elif visivel:
+                self.raiz.deiconify()
+                self.raiz.lift()
+                if sys.platform != "linux":
+                    self.raiz.attributes("-topmost", True)
+            else:
+                self.raiz.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
+        try:
+            if self._ao_fechar:
+                self._ao_fechar()
+        except Exception:
+            pass
+        try:
+            if self.janela is not None:
+                self.janela.orderOut_(None)
+                self.janela.close()
+        except Exception:
+            pass
+        try:
+            self.raiz.destroy()
+        except Exception:
+            pass
+
+    def rodar(self) -> None:
+        self.raiz.mainloop()
+
+
+# ── como processo próprio (10.4.4) ──────────────────────────────────────
+# A orb voltou, mas SÓ como desenho: "é a bolinha do primo que aparece na
+# tela quando falo" (Joel, 10/10). Ela saiu na 10.0 junto com o cérebro
+# paralelo do modo voz; o cérebro continua fora. Roda num processo à parte
+# (a janela precisa da thread principal, e a do primo_voz é do microfone),
+# e só obedece: uma linha de JSON por mudança no stdin.
+#
+#     {"estado": "ouvindo", "nivel": 0.6}    esperando | ouvindo | pensando | falando
+#     {"esconder": true} / {"mostrar": true}
+#
+# O stdin fechar (o modo voz acabou) fecha a orb.
+def _ler_comandos(orbe: "Orbe") -> None:
+    import json as _json
+    for linha in sys.stdin:
+        try:
+            msg = _json.loads(linha)
+        except ValueError:
+            continue
+        if msg.get("esconder"):
+            orbe.mudar("__esconder__")
+        elif msg.get("mostrar"):
+            orbe.mudar("__mostrar__")
+        else:
+            nivel = msg.get("nivel")
+            orbe.mudar(msg.get("estado"), float(nivel) if nivel is not None else None)
+    orbe.mudar("__fechar__")
+
+
+if __name__ == "__main__":
+    import threading as _threading
+    _orbe = Orbe()
+    _threading.Thread(target=_ler_comandos, args=(_orbe,), daemon=True).start()
+    _orbe.rodar()