primocode 9.10.0 → 10.0.0

package/lib/voz.js

@@ -1,26 +1,18 @@
 /**
  * voz.js — o lado Node do modo voz.
  *
- * O aplicativozinho da orb é Python (ver voz/primo_voz). O que mora aqui é a
- * outra ponta: subir o processo, conversar com ele por JSON, e — a parte que
- * importa — entregar cada pedido ao MESMO agente do terminal.
+ * O ouvido e a boca são Python (voz/primo_voz): microfone, Whisper, a voz
+ * que fala. O que mora aqui é a ponta do terminal: instalar o que falta,
+ * subir o processo, receber o que a pessoa DISSE e mandar falar a resposta.
  *
- * ── POR QUE O CÉREBRO NÃO FOI PARA O PYTHON ──────────────────────────────
- * O Jarvis mantinha uma sessão do Claude Code num processo filho e conversava
- * por stream-json. Copiar aquele desenho aqui significaria uma segunda
- * implementação do laço do agente, das quarenta ferramentas, do portão de
- * permissão do computador e da corrente de conectores — em outra linguagem.
- *
- * Duas implementações do mesmo laço é a garantia de que uma delas está errada,
- * e de que a correção de amanhã vai para só uma. Então o modo voz manda o
- * texto para o `runAct` de sempre: as mesmas ferramentas, as mesmas skills, a
- * mesma permissão, os mesmos conectores.
- *
- * ── O PEDIDO SAI DIFERENTE, E SÓ ISSO ────────────────────────────────────
- * Uma resposta boa de ler é ruim de ouvir: lista com marcador, caminho de
- * arquivo, bloco de código e trecho longo só funcionam para o olho. Então o
- * pedido vai com uma instrução curta de FORMA — não de conteúdo. O agente
- * continua fazendo o mesmo trabalho; ele só conta de outro jeito.
+ * ── O MODO VOZ NÃO PENSA ─────────────────────────────────────────────────
+ * Até a 9.x o /voice tinha um cérebro próprio: chamava o agente por conta
+ * dele, ao lado do terminal, com a própria instrução de forma, o próprio
+ * roteador de conversa e o próprio portão de permissão. Dois agentes na mesma
+ * pasta, e duas versões de cada regra — a correção de amanhã ia para uma só.
+ * Na 10.0 a fala é só uma forma de DIGITAR: o que foi dito entra na mesma
+ * fila, na mesma caixa de recados e no mesmo roteador do terminal, e a
+ * resposta final é lida em voz alta (paraFalar).
  */
 
 'use strict';
@@ -45,28 +37,31 @@ const PASTA = path.join(__dirname, '..', 'voz');
  */
 const DICA_COMPUTADOR = `[COMPUTADOR] Você pode usar o mouse, o teclado, as janelas e os ícones do computador da pessoa com as ferramentas desktop_* (desktop_open_app, desktop_click_element, desktop_click, desktop_type, desktop_key para atalho, desktop_scroll). Cada movimento aparece na tela como o SEU cursor. Para abrir um app, use desktop_open_app; para clicar em algo, prefira desktop_click_element pelo nome (leia os nomes com desktop_elements); coordenadas são em pontos da tela (desktop_size). Se pedirem para "mostrar o seu mouse/cursor", MEXA o cursor com desktop_move — nunca crie uma página ou arquivo para isso.`;
 
-/* A instrução de FORMA. Ela não muda o que o agente faz — muda como ele
-   conta. O que está proibido aqui é o que não existe em voz: marcador,
-   caminho, código, e parágrafo que ninguém segura de ouvido. */
-const COMO_FALAR = `[MODO VOZ] A sua resposta vai ser LIDA EM VOZ ALTA. A pessoa está olhando a tela: ela vê o SEU cursor (o mouse e o teclado do computador dela, que você controla) se mexendo em tempo real.
-
-Responda em no máximo 3 frases curtas, em português falado. Nada de lista com
-marcador, nada de caminho de arquivo, nada de bloco de código, nada de
-markdown — nada disso existe no ouvido de alguém.
-
-Diga o que você FEZ e o que mudou, não como. Se algo deu errado, diga em uma
-frase o que foi e o que você precisa.
-
-${DICA_COMPUTADOR}
-
-Faça o trabalho inteiro normalmente, com as ferramentas de sempre. O que muda
-é só o jeito de contar no fim.`;
-
-/* A forma da resposta de CONVERSA por voz ("oi", "tudo bem?", "o que você
-   faz?"). Sem ferramenta e sem memória de tarefa: um "oi" ia para o agente
-   inteiro, com a lista das tarefas antigas e a ordem de mexer no cursor, e
-   ele respondia falando delas — "eu mandei oi e ele respondeu nada a ver". */
-const COMO_CONVERSAR = `[MODO VOZ] A sua resposta vai ser LIDA EM VOZ ALTA. Responda ao que a pessoa acabou de dizer, e só a isso, em uma ou duas frases curtas, em português falado, sem markdown. Não puxe assunto de tarefa antiga. Se for só um cumprimento, cumprimente de volta e pergunte o que ela quer fazer.`;
+/* ── O QUE SAI EM VOZ ──────────────────────────────────────────────────
+ * O agente responde para a TELA, como sempre — o modo voz não muda o que ele
+ * faz nem como ele escreve. O que vai para o ouvido é um resumo falado da
+ * mesma resposta: sem markdown, sem código, sem caminho, no máximo três
+ * frases. Quem quiser o detalhe olha o terminal, que é onde ele está. */
+function paraFalar(texto, { frases = 3, teto = 420 } = {}) {
+    let t = String(texto || '')
+        .replace(/```[\s\S]*?```/g, ' ')                  // bloco de código
+        .replace(/\s+(em|no|na|de|do|da|para)\s+`[^`]*[\/\\.][^`]*`/g, '')   // "em `/pasta/x`" some inteiro
+        .replace(/`([^`]*)`/g, (_, x) => (/[\/\\.]/.test(x) ? '' : x))   // caminho some, palavra fica
+        .replace(/https?:\/\/\S+/g, '')                     // link
+        .replace(/(^|\s)[~.]?\/[\w.\-\/]+/g, ' ')              // caminho solto
+        .replace(/^\s*(#+|[-*•]|\d+[.)])\s+/gm, '')          // título e marcador
+        .replace(/[*_>|]/g, '')
+        .replace(/\(\^‿\^\)[^\n]*/g, '')                     // o mascote
+        .replace(/\s+/g, ' ')
+        .trim();
+    const partes = t.match(/[^.!?…]+[.!?…]*/g) || [];
+    let fala = '';
+    for (const p of partes.slice(0, frases)) {
+        if ((fala + p).length > teto) break;
+        fala += p;
+    }
+    return (fala || t.slice(0, teto)).trim();
+}
 
 /** Onde está o Python 3. Mesmo problema do Estúdio, mesma cura. */
 function python() {
@@ -86,19 +81,17 @@ function python() {
  * O que falta para o modo voz abrir — e QUAL é a falta.
  *
  * A distinção é a diferença entre um recado que resolve e um que faz a pessoa
- * dar voltas. Dois casos não se resolvem com pip:
+ * dar voltas. Um caso não se resolve com pip:
  *
  *   · `sounddevice` instalado, mas sem o PortAudio do sistema. O import
  *     explode com "PortAudio library not found", e mandar `pip install
  *     sounddevice` ali é mandar instalar o que já está instalado.
- *   · `tkinter` vem com o Python, mas algumas distribuições Linux o separam
- *     num pacote do sistema — e `pip install tkinter` não existe.
  *
  * Por isso a checagem lê a MENSAGEM do erro, e não só o fato de ter falhado.
  */
 function faltando(py) {
     const falta = [];
-    for (const [modulo, pacote] of [['numpy', 'numpy'], ['sounddevice', 'sounddevice'], ['tkinter', null]]) {
+    for (const [modulo, pacote] of [['numpy', 'numpy'], ['sounddevice', 'sounddevice']]) {
         try {
             execFileSync(py, ['-c', `import ${modulo}`], { stdio: ['ignore', 'pipe', 'pipe'], timeout: 20000 });
         } catch (e) {
@@ -120,21 +113,9 @@ const COMO_SISTEMA = {
         linux: 'sudo apt install libportaudio2   (ou o equivalente da sua distribuição)',
         win32: 'no Windows ele vem junto com o sounddevice — reinstale com pip',
     },
-    tkinter: {
-        darwin: 'brew install python-tk',
-        linux: 'sudo apt install python3-tk',
-        win32: 'reinstale o Python pelo python.org, marcando "tcl/tk"',
-    },
 };
 
-/**
- * Confere o que é preciso, sem instalar nada.
- *
- * O tkinter é o caso especial: ele vem com o Python, mas em algumas
- * distribuições Linux ele foi separado num pacote do SISTEMA — e `pip install
- * tkinter` não existe. Dizer "instale com pip" ali seria mandar a pessoa a um
- * lugar onde não há nada.
- */
+/** Confere o que é preciso, sem instalar nada. */
 function conferir() {
     const py = python();
     if (!py) {
@@ -156,9 +137,6 @@ function conferir() {
     if (falta.some((f) => f.modulo === 'sounddevice' && f.sistema)) {
         linhas.push(COMO_SISTEMA.portaudio[process.platform] || COMO_SISTEMA.portaudio.linux);
     }
-    if (falta.some((f) => f.modulo === 'tkinter')) {
-        linhas.push(COMO_SISTEMA.tkinter[process.platform] || COMO_SISTEMA.tkinter.linux);
-    }
 
     return {
         ok: false,
@@ -172,7 +150,7 @@ function conferir() {
     };
 }
 
-/** Instala o que dá para instalar com pip. O tkinter não passa por aqui. */
+/** Instala o que dá para instalar com pip. */
 /* AS TENTATIVAS, EM ORDEM — e por que uma só não serve.
  *
  * O Python do Homebrew e o do Debian/Ubuntu RECUSAM `pip install` no ambiente
@@ -232,20 +210,24 @@ function instalar(py, pacotes, aoFalar = () => {}) {
 }
 
 /**
- * Abre o modo voz e fica de pé até a janela fechar.
+ * Liga o ouvido e a boca (voz/primo_voz). O processo não pensa: devolve o que
+ * ouviu por `aoOuvir` e fala o que receber em `falar`.
  *
  * @param {object} op
  * @param {string} op.python
  * @param {string} op.servidor
  * @param {string} op.token
  * @param {string} op.voz
- * @param {(texto:string)=>Promise<string>} op.pensar   o agente de verdade
- * @param {(texto:string)=>void} op.mostrar             o que aparece no terminal
- * @param {boolean} op.esperando                        fica dormindo até ouvir o nome
- * @returns {{processo, pronto: Promise}}               o processo, e a promessa do fim
+ * @param {(texto:string)=>void} op.aoOuvir     o que a pessoa disse, já transcrito
+ * @param {(texto:string, deErro?:boolean)=>void} op.mostrar   recado para o terminal
+ * @param {()=>void} [op.aoPronto]              o microfone abriu
+ * @returns {{processo, pronto: Promise, falar:(t:string)=>void, calar:()=>void}}
  */
-function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {}, esperando = false }) {
+function abrir({ python: py, servidor, token, voz, aoOuvir, mostrar = () => {}, aoPronto = () => {} }) {
     let p;
+    const manda = (obj) => {
+        try { p.stdin.write(JSON.stringify(obj) + '\n'); } catch { /* já fechou */ }
+    };
     const pronto = new Promise((resolve) => {
         p = spawn(py, ['-m', 'primo_voz'], {
             cwd: PASTA,
@@ -255,24 +237,14 @@ function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {}, e
                 PRIMOCODE_SERVER: servidor,
                 PRIMOCODE_TOKEN: token || '',
                 PRIMOCODE_VOZ: voz || 'antonio',
-                // Dormir até ouvir o nome, em vez de já entrar ouvindo.
-                PRIMOCODE_VOZ_ESPERA: esperando ? '1' : '',
                 PYTHONUNBUFFERED: '1',
                 // O Whisper deixa um semáforo para o sistema recolher na saída,
-                // e o Python avisa disso no stderr — que aqui vira texto no
-                // terminal da pessoa. É inofensivo; o aviso é que não é.
+                // e o Python avisa disso no stderr. É inofensivo; o aviso não é.
                 PYTHONWARNINGS: 'ignore::UserWarning:multiprocessing.resource_tracker',
             },
         });
-
-        const manda = (obj) => {
-            try { p.stdin.write(JSON.stringify(obj) + '\n'); } catch { /* já fechou */ }
-        };
-
         let buffer = '';
-        let ocupado = false;
-
-        p.stdout.on('data', async (d) => {
+        p.stdout.on('data', (d) => {
             buffer += d.toString();
             const linhas = buffer.split('\n');
             buffer = linhas.pop();
@@ -280,136 +252,33 @@ function abrir({ python: py, servidor, token, voz, pensar, mostrar = () => {}, e
                 if (!linha.trim()) continue;
                 let msg;
                 try { msg = JSON.parse(linha); } catch { continue; }
-
                 if (msg.tipo === 'fim') { try { p.kill(); } catch {} return; }
-                if (msg.tipo === 'erro') { mostrar(String(msg.texto || '')); continue; }
-                if (msg.tipo !== 'pedido') continue;
-
-                /* Um pedido por vez. A pessoa pode falar de novo enquanto ele
-                   trabalha — e dois agentes rodando ao mesmo tempo na mesma
-                   pasta é a receita para um escrever por cima do outro. */
-                if (ocupado) { manda({ tipo: 'resposta', texto: 'Ainda estou terminando o anterior.' }); continue; }
-                ocupado = true;
-
-                mostrar(String(msg.texto || ''));
-                manda({ tipo: 'estado', estado: 'pensando' });
-                try {
-                    const resposta = await pensar(String(msg.texto || ''));
-                    manda({ tipo: 'resposta', texto: resposta || 'Feito.' });
-                } catch (e) {
-                    manda({ tipo: 'erro', texto: `Não consegui: ${e.message}` });
-                } finally {
-                    ocupado = false;
+                if (msg.tipo === 'pronto') { try { aoPronto(); } catch {} continue; }
+                if (msg.tipo === 'erro') { mostrar(String(msg.texto || ''), true); continue; }
+                if (msg.tipo === 'ouvi' && String(msg.texto || '').trim()) {
+                    try { aoOuvir(String(msg.texto).trim()); } catch (e) { mostrar(e.message, true); }
                 }
             }
         });
-
         // O Python fala com o terminal pela saída de ERRO, de propósito: o
-        // stdout inteiro é do protocolo, e uma linha solta ali quebraria a
-        // conversa entre os dois processos.
+        // stdout inteiro é do protocolo.
         p.stderr.on('data', (d) => {
             const texto = d.toString().trim();
             if (texto) mostrar(texto, true);
         });
-
         p.on('close', () => resolve({ ok: true }));
         p.on('error', (e) => resolve({ ok: false, error: e.message }));
     });
-
-    /* O PROCESSO VOLTA JUNTO COM A PROMESSA, e não é preciosismo de API.
-       No modo de espera o /voice não bloqueia o terminal: ele sobe o ouvinte
-       e devolve o prompt. Quem chamou precisa de um jeito de ENCERRAR aquilo
-       depois (/voice parar, ou a saída do programa) — e, sem o handle, o
-       único jeito seria matar pelo nome do processo, que atropela outra
-       sessão do PrimoCode aberta na mesma máquina. */
-    return { processo: p, pronto };
-}
-
-
-/* ── O RECONHECEDOR LOCAL DO NOME ────────────────────────────────────────
- *
- * Duas funções, e a razão de existirem é a mesma: no modo de espera o
- * microfone fica ABERTO o tempo todo, e há dois jeitos de saber se alguém
- * disse "ei, primo" — mandar tudo o que ele ouve para um servidor, ou
- * reconhecer a palavra aqui dentro.
- *
- * O primeiro é mais fácil de escrever e significa a conversa da casa inteira
- * subindo para a rede o dia inteiro. O segundo custa ~31 MB de modelo, uma
- * vez. Não é escolha difícil, e não é escolha que o programa faça sozinho:
- * `conferirEspera` só RESPONDE o que falta; quem pergunta à pessoa é o CLI.
- */
-function conferirEspera(py) {
-    const perguntar = `
-import json, sys
-sys.path.insert(0, ${JSON.stringify(PASTA)})
-try:
-    from primo_voz import desperta
-except Exception as e:
-    print(json.dumps({"ok": False, "error": "não consegui ler o módulo: %s" % e})); raise SystemExit
-try:
-    import vosk  # noqa: F401
-    temVosk = True
-except ImportError:
-    temVosk = False
-print(json.dumps({
-    "ok": bool(temVosk and desperta.tem_modelo()),
-    "temVosk": temVosk,
-    "temModelo": desperta.tem_modelo(),
-    "onde": str(desperta.caminho_do_modelo()),
-}))
-`;
-    try {
-        const saida = execFileSync(py, ['-c', perguntar],
-            { stdio: ['ignore', 'pipe', 'pipe'], timeout: 30000 }).toString();
-        const r = JSON.parse(saida.trim().split('\n').pop());
-        if (r.ok) return { ok: true };
-        // Falta só o modelo (ou o vosk, que o pip resolve): dá para oferecer.
-        return { ok: false, baixavel: true, temVosk: r.temVosk, onde: r.onde,
-            error: r.error || 'o reconhecedor local do nome não está instalado' };
-    } catch (e) {
-        return { ok: false, baixavel: false,
-            error: `não consegui conferir o reconhecedor: ${String(e.message || e).slice(-160)}` };
-    }
-}
-
-/** Instala o vosk (se faltar) e baixa o modelo. Uma vez, ~31 MB. */
-function baixarEspera(py) {
-    return new Promise((resolve) => {
-        const script = `
-import json, subprocess, sys
-sys.path.insert(0, ${JSON.stringify(PASTA)})
-try:
-    import vosk  # noqa: F401
-except ImportError:
-    # As mesmas estratégias do narrar.py: o pip do sistema recusa instalar
-    # em Debian/Ubuntu e no Homebrew (PEP 668), e uma tentativa só, calada,
-    # é a falha que ninguém vê.
-    for args in (["-m","pip","install","--user","--quiet","vosk"],
-                 ["-m","pip","install","--user","--quiet","--break-system-packages","vosk"],
-                 ["-m","pip","install","--quiet","vosk"],
-                 ["-m","pip","install","--quiet","--break-system-packages","vosk"]):
-        r = subprocess.run([sys.executable] + args, capture_output=True)
-        if r.returncode == 0:
-            break
-    try:
-        import vosk  # noqa: F401
-    except ImportError as e:
-        print(json.dumps({"ok": False, "error": "não consegui instalar o vosk: %s" % e}))
-        raise SystemExit
-from primo_voz import desperta
-print(json.dumps(desperta.baixar_modelo()))
-`;
-        const p = spawn(py, ['-c', script]);
-        let fora = '';
-        let erro = '';
-        p.stdout.on('data', (d) => { fora += d.toString(); });
-        p.stderr.on('data', (d) => { erro += d.toString(); });
-        p.on('close', () => {
-            try { resolve(JSON.parse(fora.trim().split('\n').pop())); }
-            catch { resolve({ ok: false, error: erro.slice(-300).trim() || 'o download não devolveu resposta' }); }
-        });
-        p.on('error', (e) => resolve({ ok: false, error: e.message }));
-    });
+    /* O processo volta junto com a promessa: o /voice não bloqueia o
+       terminal, e quem chamou precisa de um jeito de encerrar depois (/voice
+       parar, ou a saída do programa) sem matar pelo nome — o que atropelaria
+       outra sessão do PrimoCode aberta na mesma máquina. */
+    return {
+        processo: p,
+        pronto,
+        falar: (texto) => { const t = paraFalar(texto); if (t) manda({ tipo: 'falar', texto: t }); },
+        calar: () => manda({ tipo: 'calar' }),
+    };
 }
 
 /* ── PREPARAR TUDO, SEM PERGUNTAR ────────────────────────────────────────
@@ -421,20 +290,18 @@ print(json.dumps(desperta.baixar_modelo()))
  * parava em cada falta com um comando para a pessoa copiar. Agora ele mesmo
  * resolve o que dá para resolver, nesta ordem:
  *
- *   1. bibliotecas do SISTEMA (PortAudio e o Tk do Python) — pelo Homebrew no
+ *   1. bibliotecas do SISTEMA (o PortAudio) — pelo Homebrew no
  *      macOS; no Linux, `sudo -n` (só funciona sem senha; senão, o comando);
  *   2. pacotes do Python — os obrigatórios (numpy, sounddevice) e os que
- *      deixam tudo bonito e local (faster-whisper, vosk, PyObjC no macOS);
- *   3. os modelos — o Whisper (transcrição local) e o reconhecedor do nome.
+ *      deixam tudo local (faster-whisper; o PyObjC do cursor no macOS);
+ *   3. o modelo do Whisper (transcrição local).
  *
  * Só o que é OBRIGATÓRIO faltar impede o modo voz de abrir. Faltar um opcional
  * vira um aviso de uma linha, e o modo voz abre mesmo assim.
  */
 const OPCIONAIS = () => [
     ['faster_whisper', 'faster-whisper', 'a transcrição local (Whisper)'],
-    ['vosk', 'vosk', 'o reconhecedor local do "ei, primo"'],
     ...(process.platform === 'darwin' ? [
-        ['AppKit', 'pyobjc-framework-Cocoa', 'a orb transparente do macOS'],
         ['Quartz', 'pyobjc-framework-Quartz', 'o cursor do Primo na tela'],
         ['Vision', 'pyobjc-framework-Vision', 'ler o texto da tela (clicar pelo nome em qualquer app)'],
     ] : []),
@@ -473,7 +340,6 @@ async function instalarSistema(py, falta, aoFalar) {
     const avisos = [];
     const precisa = [];
     if (falta.some((f) => f.modulo === 'sounddevice' && f.sistema)) precisa.push('portaudio');
-    if (falta.some((f) => f.modulo === 'tkinter')) precisa.push('tkinter');
     if (!precisa.length) return avisos;
 
     if (process.platform === 'darwin') {
@@ -483,24 +349,20 @@ async function instalarSistema(py, falta, aoFalar) {
                 + precisa.join(' e ') + ' sozinho — instale em brew.sh e rode /voice de novo.');
             return avisos;
         }
-        // O Tk do Homebrew tem versão casada com a do Python: python-tk@3.14
-        // serve ao python3.14, e só a ele.
-        let versao = '';
-        try { versao = execFileSync(py, ['-c', 'import sys;print("%d.%d"%sys.version_info[:2])']).toString().trim(); } catch {}
-        const formulas = precisa.map((x) => (x === 'tkinter' ? (versao ? `python-tk@${versao}` : 'python-tk') : x));
+        const formulas = precisa;
         aoFalar(`instalando ${formulas.join(', ')} pelo Homebrew`);
         const r = await rodar(b, ['install', ...formulas]);
         if (!r.ok) avisos.push(`o Homebrew não instalou ${formulas.join(', ')}: ${porqueOPipFalhou(r.saida)}`);
         return avisos;
     }
     if (process.platform === 'linux') {
-        const pacotes = precisa.map((x) => (x === 'tkinter' ? 'python3-tk' : 'libportaudio2'));
+        const pacotes = precisa.map(() => 'libportaudio2');
         aoFalar(`instalando ${pacotes.join(', ')}`);
         const r = await rodar('sudo', ['-n', 'apt-get', 'install', '-y', ...pacotes]);
         if (!r.ok) avisos.push(`precisa de senha para instalar: sudo apt install ${pacotes.join(' ')}`);
         return avisos;
     }
-    avisos.push(precisa.map((x) => COMO_SISTEMA[x === 'tkinter' ? 'tkinter' : 'portaudio'].win32).join(' · '));
+    avisos.push(COMO_SISTEMA.portaudio.win32);
     return avisos;
 }
 
@@ -568,17 +430,7 @@ async function preparar(aoFalar = () => {}) {
         const w = await baixarWhisper(py);
         if (!w.ok) avisos.push(`a transcrição local não ficou pronta (${w.error}) — vai pelo servidor.`);
     }
-    let esperando = false;
-    const espera = conferirEspera(py);
-    if (espera.ok) esperando = true;
-    else if (espera.baixavel) {
-        aoFalar('baixando o reconhecedor do "ei, primo" (~31 MB)');
-        const r = await baixarEspera(py);
-        if (r.ok) esperando = true;
-        else avisos.push(`sem o "ei, primo": ${r.error} — o modo voz abre já ouvindo.`);
-    }
-
-    return { ok: true, python: py, esperando, avisos };
+    return { ok: true, python: py, avisos };
 }
 
-module.exports = { DICA_COMPUTADOR, COMO_CONVERSAR, conferir, instalar, preparar, porqueOPipFalhou, abrir, conferirEspera, baixarEspera, python, COMO_FALAR, PASTA };
+module.exports = { DICA_COMPUTADOR, paraFalar, conferir, instalar, preparar, porqueOPipFalhou, abrir, python, PASTA };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.10.0",
+  "version": "10.0.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": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/primocode.js",
-    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/voz-conversa.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/app.test.js && node test/app-janela.test.js && node test/aplicativo.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/janela.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js && node test/acervo-site.test.js && node test/impacto.test.js && node test/cinema.test.js && node test/producao.test.js && node test/ende.test.js && node test/capa.test.js && node test/broll.test.js && node test/morfar.test.js && node test/motion.test.js && node test/motion-roteiro.test.js"
+    "test": "node test/tools.test.js && node test/ui.test.js && node test/entrada.test.js && node test/transparencia.test.js && node test/permissao.test.js && node test/compatibilidade.test.js && node test/skills.test.js && node test/skills-de-fora.test.js && node test/skills-novas.test.js && node test/comandos.test.js && node test/estudio.test.js && node test/voz.test.js && node test/modo.test.js && node test/pasta.test.js && node test/projeto.test.js && node test/nome-projeto.test.js && node test/api-propria.test.js && node test/claude-engine.test.js && node test/codex.test.js && node test/conferir.test.js && node test/catalogo.test.js && node test/desktop.test.js && node test/seta.test.js && node test/effort.test.js && node test/regressao.test.js && node test/memoria-conversa.test.js && node test/repeticao.test.js && node test/casar.test.js && node test/recado.test.js && node test/releitura.test.js && node test/snapshot.test.js && node test/video.test.js && node test/limpeza.test.js && node test/autonomia.test.js && node test/desfazer.test.js && node test/desfazer-git.test.js && node test/referencia.test.js && node test/parar.test.js && node test/continuar.test.js && node test/pipeline.test.js && node test/conta.test.mjs && node test/nuvem.test.js && node test/prazo.test.js && node test/primeira-vez.test.js && node test/fala.test.js && node test/especialistas.test.js && node test/empurrao.test.js && node test/terminal-novo.test.js && node test/markdown.test.js && node test/coerencia.test.js && node test/contexto.test.js && node test/perigo.test.js && node test/rapidez.test.js && node test/mascotes.test.js && node test/comandos-extra.test.js && node test/offline.test.js && node test/edicao.test.js && node test/composicao.test.js && node test/acervo-site.test.js && node test/impacto.test.js && node test/cinema.test.js && node test/producao.test.js && node test/ende.test.js && node test/capa.test.js && node test/broll.test.js && node test/morfar.test.js && node test/motion.test.js && node test/motion-roteiro.test.js && node test/kit-motion.test.js"
   },
   "engines": {
     "node": ">=18.17.0"
@@ -27,7 +27,6 @@
   "files": [
     "bin/",
     "lib/",
-    "app/",
     "studio/",
     "skills/",
     "voz/",

package/skills/motion-de-primeira/SKILL.md

@@ -11,7 +11,7 @@ primeira decisão é **não repetir o vídeo anterior**.
 
 Não faça nada disto, em nenhum vídeo:
 
-- gradiente roxo-para-azul (o mais reconhecível de todos), e gradiente de duas
+- gradiente roxo-para-azul, e gradiente de duas
   cores que não têm relação com o assunto;
 - tudo centralizado, do primeiro ao último quadro;
 - uma fonte só, em todos os tamanhos;
@@ -59,9 +59,8 @@ Em vídeo de produto, anúncio e vinheta, escreva **uma cena de 8 a 15 s** no
 - **A troca é no mesmo lugar e instante**: o foguete some onde o ícone nasce; o
   app nasce do tamanho e da COR do ícone.
 
-Espreme ao quicar e deixe a câmera andar até o fim.
-
-Vídeo por roteiro já sai assim (estilo padrão `motion`); escreva à mão só o que o roteiro não descreve.
+Por roteiro, o estilo segue o assunto: `motion` (padrão), `vox` (explicar; dê `destaque` e `fonte`),
+`marca`, `lancamento`; `visual` troca a peça de uma parte.
 
 ## Cor e tipo