primocode 10.3.0-beta.0 → 10.4.0

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v10.3.0-beta.0
+# PrimoCode v10.4.0
 
 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.3.0-beta.0
+ ▐▛███▜▌   Primo Code v10.4.0
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```
@@ -17,6 +17,25 @@ está no limite de pedidos, o próximo atende. Você não vê o erro, e não pag
 Personalize o mascote (`primo`, `fox`, `cat`) e o nome com que ele te chama —
 veja `/mascot` e `/name`.
 
+## O que mudou na 10.4
+
+- **Vídeo gravado em 3D (`estilo: personagem`).** Personagens modelados — gente
+  ou robô — conversando num set (podcast, estúdio, escritório). A boca segue a
+  voz letra por letra, eles piscam, gesticulam e viram a cabeça para quem fala.
+  A câmera corta como num programa gravado: aberto, ombro, close e detalhe,
+  com o balanço de câmera na mão. Por cima: legenda grossa palavra por
+  palavra, o nome de quem fala, o cartão de destaque, o REC e o grão de filme.
+  Peça "um podcast", "uma entrevista" ou "o Claude falando em 3D".
+- **A peça do site, tirada pelo código.** `estudio_midia acao:elementos` lê o
+  site e lista logo, menu, título, botões, cartões, preço; `acao:elemento` tira
+  uma delas sozinha, em PNG transparente no dobro da resolução, com o código
+  (HTML, fonte, cor, raio) para redesenhar se quiser.
+- **Recorte de fundo com IA sem instalar nada.** Com o `uv` na máquina, o
+  `acao:recortar` usa o rembg num ambiente à parte, em vez do corte por cor.
+- **O logo do Claude saiu do cardápio dos vídeos.**
+- **Com Claude, Codex ou chave própria, o agente não esquece o arquivo que
+  acabou de ler** (antes relia o mesmo arquivo várias vezes).
+
 ## O que mudou na 10.0
 
 - **A potência vem do sistema, não do modelo.** O mesmo pedido de landing

package/bin/primocode.js

@@ -427,30 +427,21 @@ function ramoDoGit(dir) {
     return ramo;
 }
 
+/* O que a caixa mostra além do texto, no desenho do OpenCode: DENTRO do
+   painel, o modo e o esforço ("Auto · alto" — o "Build · Nemotron" de lá);
+   FORA, uma linha só, com a pasta e o ramo à esquerda e o contexto e os
+   atalhos à direita. A cor da barra do painel é a do modo. */
+const COR_MODO = { auto: '\x1b[38;5;75m', primocode: '\x1b[38;5;216m', chat: '\x1b[38;5;45m' };
+const NOME_MODO = { auto: 'Auto', primocode: 'Primo Code', chat: 'Chat' };
+
 function barraDeStatus() {
     const partes = [];
 
-    /* O CONTEXTO. Só aparece depois que há conversa: um "ctx 0%" na abertura
-       é ruído, e ruído que aparece sempre é o que a pessoa aprende a não
-       enxergar — inclusive quando marcar 90%. Âmbar a partir de 70% e
-       vermelho a partir de 100%, que é quando `/compact` deixa de ser
-       conselho e vira o que fazer. */
-    const uso = memoria.usoDoContexto(state.memoria, state.history);
-    if (uso.pct >= 5) {
-        partes.push(uso.pct >= 100 ? c.err(`${uso.pct}% ctx`)
-            : uso.pct >= 70 ? c.warn(`${uso.pct}% ctx`)
-                : c.dim(`${uso.pct}% ctx`));
-    }
-
-    // O esforço, que é o que escolhe o modelo. Não há provedor para mostrar:
-    // a API vem com o produto.
-    partes.push(c.muted(effort.normalizar(state.config.effort)));
-
-    // A PASTA. O nome dela, e o caminho curto quando não é um projeto — quem
-    // apontou com /dir para fora do ~/primocode precisa ver onde está.
+    // A PASTA, e o ramo do git colado nela ("~/primocode/loja:main"), como
+    // o rodapé do OpenCode. Quem apontou com /dir para fora do ~/primocode
+    // precisa ver onde está.
     const dir = state.workDir || process.cwd();
     partes.push(c.brandDim(shortPath(dir)));
-
     const ramo = ramoDoGit(dir);
     if (ramo) partes.push(c.dim('⎇ ' + ramo));
 
@@ -463,25 +454,43 @@ function barraDeStatus() {
        esquece que deu — e ela vale até o PrimoCode fechar. */
     if (state.controle && state.controle.liberado) partes.push(c.warn('controle do pc'));
 
-    // No auto o rótulo mostra "Auto" e, depois do primeiro pedido, qual modo
-    // ele acabou usando — senão você nunca sabe quem respondeu.
-    let modo;
-    if (state.mode === 'auto') {
-        const ultimo = state.modoEfetivo === 'primocode' ? c.warn('primo')
-            : state.modoEfetivo === 'chat' ? c.brandDim('chat') : '';
-        modo = c.brand('auto') + (ultimo ? c.dim('·') + ultimo : '');
-    } else {
-        modo = state.mode === 'primocode' ? c.warn('primo code') : c.brandDim('chat');
+    /* O CONTEXTO. Só aparece depois que há conversa: um "ctx 0%" na abertura
+       é ruído, e ruído que aparece sempre é o que a pessoa aprende a não
+       enxergar — inclusive quando marcar 90%. Âmbar a partir de 70% e
+       vermelho a partir de 100%, que é quando `/compact` deixa de ser
+       conselho e vira o que fazer. */
+    const direita = [];
+    const uso = memoria.usoDoContexto(state.memoria, state.history);
+    if (uso.pct >= 5) {
+        direita.push(uso.pct >= 100 ? c.err(`${uso.pct}% ctx`)
+            : uso.pct >= 70 ? c.warn(`${uso.pct}% ctx`)
+                : c.dim(`${uso.pct}% ctx`));
     }
-    partes.push(modo);
-
-    const primeira = partes.join(c.dim(' | '));
+    direita.push(state.trabalhando
+        ? 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'));
+
+    /* O modo DENTRO do painel. No auto, depois do primeiro pedido, ele diz
+       qual modo acabou respondendo — senão você nunca sabe quem respondeu. */
+    const cor = COR_MODO[state.mode] || COR_MODO.auto;
+    let modo = `${cor}${NOME_MODO[state.mode] || 'Auto'}${c.reset}`;
+    if (state.mode === 'auto' && state.modoEfetivo) {
+        modo += c.dim(' → ') + c.muted(NOME_MODO[state.modoEfetivo] || state.modoEfetivo);
+    }
+    modo += c.dim(' · ') + c.white(effort.normalizar(state.config.effort)) + ' ' + c.dim('PrimoCode');
 
-    const atalhos = state.trabalhando
-        ? c.warn('▸▸ trabalhando') + c.dim('  (Esc Esc interrompe)')
-        : c.dim('/ comandos · ↑ histórico · \\ ou alt+enter quebra linha · Esc Esc interrompe');
+    return { modo, cor, esquerda: partes.join(c.dim(' · ')), direita: direita.join(c.dim('   ')) };
+}
 
-    return [primeira, atalhos];
+/* O Tab com a caixa vazia gira o modo, como o "tab agents" do OpenCode:
+   auto → primo code → chat → auto. A escolha fica salva, como a do /mode. */
+function trocarModo() {
+    const ordem = ['auto', 'primocode', 'chat'];
+    const m = ordem[(ordem.indexOf(state.mode) + 1) % ordem.length];
+    state.mode = m;
+    state.modoEfetivo = null;
+    cfg.saveConfig({ mode: m });
+    refreshPrompt();
 }
 
 // A barra se redesenha sozinha a cada quadro; isto só pede um quadro novo.
@@ -1043,10 +1052,18 @@ async function sendPrompt(userText) {
 
     // PRIMOCODE_TEMPOS=1: uma linha no fim com o custo de cada fase.
     tempos.comecar();
+    const inicio = Date.now();
     try { await enviarPedido(userText); }
     finally {
         const linha = tempos.relatorio();
         if (linha) console.log(c.dim(`  ⏱ ${linha}`));
+        /* O fecho de cada resposta, como no OpenCode ("▣ Build · Nemotron ·
+           4.0s"): quem respondeu, com que esforço, e quanto levou. */
+        const m = state.mode === 'auto' ? (state.modoEfetivo || 'auto') : state.mode;
+        if (!state.semTerminal) {
+            console.log('\n  ' + `${COR_MODO[m] || COR_MODO.auto}▣${c.reset} ` + c.white(NOME_MODO[m] || m)
+                + c.dim(` · ${effort.normalizar(state.config.effort)} · ${((Date.now() - inicio) / 1000).toFixed(1)}s`) + '\n');
+        }
     }
 }
 
@@ -2690,16 +2707,22 @@ async function main() {
         process.exit(0);
     }
 
+    /* A abertura do OpenCode: o nome e a caixa no MEIO da tela, não no pé de
+       um terminal cheio. Quebras de linha empurram o que havia para o
+       histórico do terminal (nada se perde, dá para rolar), o cursor volta ao
+       topo e desce até o ponto em que o logo e a caixa ficam centrados. */
+    if (process.stdout.isTTY && process.stdout.rows >= 20) {
+        const rows = process.stdout.rows;
+        const alto = 8 + 6;                       // o logo com a versão + a caixa
+        process.stdout.write('\n'.repeat(rows) + '\x1b[H' + '\n'.repeat(Math.max(0, Math.floor((rows - alto) / 2) - 1)));
+    }
     console.log(welcomeBox(VERSION, state.workDir ? shortPath(state.workDir) : null, {
-        modo: state.mode,
-        mascot: state.config.mascot,
-        userName: state.config.userName,
         pastaPadrao: state.workDirOrigem === 'padrao',
     }));
     rl = entrada.criar({
         status: barraDeStatus,
         comandos: comandosDoMenu,
-        vazio: 'peça alguma coisa, ou / para os comandos',
+        vazio: ui.convite(),
     });
     // O spinner desenha dentro da caixa (lib/entrada.js mostrarSpinner).
     if (rl.tty) Spinner.caixa = rl;
@@ -2739,6 +2762,7 @@ async function main() {
     // Ctrl+C com a caixa vazia: sair é sair, mas sem deixar o último turno
     // pela metade — o sayBye espera a gravação subir.
     rl.on('sigint', () => rl.close());
+    rl.on('trocar-modo', trocarModo);
 
     function sayBye() {
         if (saidBye) return;

package/lib/act.js

@@ -333,6 +333,16 @@ function summarizeForModel(result) {
 // que o modelo precisa para decidir o próximo passo; os velhos viram peso.
 const RESULTADOS_INTEIROS = 3;
 const RESTO_DO_RESULTADO = 300;
+/* ── COM MOTOR PRÓPRIO, A MEMÓRIA NÃO É AMPUTADA ────────────────────────
+ * Os 3 e os 300 de cima são para o teto de ~6 mil tokens por minuto do
+ * servidor grátis. Com Claude Code, Codex ou chave própria (`provedor.atual()`)
+ * eles valiam igual, e o modelo perdia o arquivo que tinha acabado de ler:
+ * no jogo de carro de 09/10 o Claude leu o world.js (458 linhas) sete vezes,
+ * em fatias, porque a cada três ferramentas a leitura anterior virava 300
+ * caracteres. A pre-leitura já folgava com motor próprio; o compactar agora
+ * também. */
+const RESULTADOS_INTEIROS_FOLGADO = 20;
+const RESTO_DO_RESULTADO_FOLGADO = 1500;
 // A pesquisa é MATÉRIA-PRIMA, não passo intermediário: é dela que saem os
 // fatos do vídeo, do post, do slide. Ela sempre fica velha (pesquisa-se no
 // começo, escreve-se no fim), e a 300 caracteres não sobrava fato nenhum — o
@@ -404,15 +414,17 @@ function encolherEscritas(m) {
  * Nenhuma mensagem é REMOVIDA: a API exige que cada role:'tool' continue
  * pareada com o tool_call que a pediu. Só o texto encolhe.
  */
-function compactar(messages) {
+function compactar(messages, { folgado = false } = {}) {
     const { inteiras, duplicadas } = repeticao.referenciasNaConversa(messages);
+    const quantosInteiros = folgado ? RESULTADOS_INTEIROS_FOLGADO : RESULTADOS_INTEIROS;
+    const resto = folgado ? RESTO_DO_RESULTADO_FOLGADO : RESTO_DO_RESULTADO;
 
     const indices = [];
     for (let i = 0; i < messages.length; i++) if (messages[i].role === 'tool') indices.push(i);
-    if (indices.length <= RESULTADOS_INTEIROS && !duplicadas.size && !assistentesAntigas(messages).size) return messages;
+    if (indices.length <= quantosInteiros && !duplicadas.size && !assistentesAntigas(messages).size) return messages;
 
     const chamadas = repeticao.chamadasPorId(messages);
-    const encolher = new Set(indices.slice(0, -RESULTADOS_INTEIROS));
+    const encolher = new Set(indices.slice(0, -quantosInteiros));
     const antigas = assistentesAntigas(messages);
     return messages.map((m, i) => {
         if (antigas.has(i)) return encolherEscritas(m);
@@ -421,7 +433,7 @@ function compactar(messages) {
         }
         if (inteiras.has(i) || !encolher.has(i)) return m;
         const chamada = chamadas.get(m.tool_call_id);
-        const limite = chamada && MATERIA_PRIMA.has(chamada.nome) ? RESTO_DA_PESQUISA : RESTO_DO_RESULTADO;
+        const limite = chamada && MATERIA_PRIMA.has(chamada.nome) ? Math.max(RESTO_DA_PESQUISA, resto) : resto;
         const texto = String(m.content || '');
         if (texto.length <= limite) return m;
         return { ...m, content: texto.slice(0, limite) + `…(resultado antigo encurtado; eram ${texto.length} caracteres)` };
@@ -984,7 +996,9 @@ async function runAct(userPrompt, opts) {
         emVoo = new AbortController();
         const tRodada = Date.now();
         try {
-            const enviadas = compactar(messages);
+            let folgado = false;
+            try { folgado = !!require('./local/provedor.js').atual(); } catch { /* sem provedor próprio */ }
+            const enviadas = compactar(messages, { folgado });
             traco(`volta ${voltas}${subagent ? ' (agente)' : ''} · ${enviadas.length} mensagens · ${JSON.stringify(enviadas).length} caracteres`);
             await motor.requestAct(server, { messages: enviadas, model, effort, token, projectDir: pastaAtual, projectName, subagent, sinal: emVoo.signal }, (evt) => {
                 if (evt.erro) { streamError = evt.erro; return; }

package/lib/catalogo.js

@@ -94,8 +94,8 @@ const GRUPOS = [
                 + 'logo{titulo} cores{cores:[{nome,hex}]} produto{titulo,texto,destaque,selo,barras}. Em qualquer parte: destaque (a palavra-tese), fonte (a fonte citada). O texto da TELA sai da FALA: o título usa palavras que a fala diz, cedo na frase (a tela entra quando a voz diz; palavra que a voz não diz deixa a tela esperando). '
                 + 'visual:{titulo,texto,paleta} (hibrido, cinema, impacto): fonte e cor do cardápio (estudio_midia acao:fontes); sem visual, o PrimoCode sorteia sem repetir os últimos vídeos. '
                 + 'estilo (SEM IMAGEM é o padrão: escolha o motion que serve a ESTE roteiro, ou deixe vazio e ele gira entre gerativo, fluido e impacto): hibrido (SÓ quando a pessoa pediu imagem: foto e vídeo reais + o motion por cima; dê busca:"termo em inglês" só nas partes em que a imagem agrega) | gerativo (= motion: sem template — a tipografia anima nos eixos da fonte numa linha do tempo contínua, composição, fonte, cor e som sorteados do roteiro; modelo3d fone|celular|notebook|relogio|garrafa|lata|caixa: o objeto gira em 3D numa batida — ponha quando o vídeo é de um produto ou objeto físico; ideia abstrata, história ou explicação: deixe vazio; o vídeo tem UMA identidade (2 chãos, 1 acento, 2 fontes) e o fundo só troca na virada de seção — se o roteiro tem atos, dê secao:"nome curto" nas partes, senão o PrimoCode divide; moldura cantos|completa|false: o quadro fixo do reel (cantos, o assunto no alto, "01 · seção", o tempo) — ponha só se o vídeo pede cara de peça de design; vazio, o PrimoCode alterna com memória e às vezes não põe; heroi em cada parte: o desenho da batida além do texto, tirado do CONTEÚDO — um ícone do Iconify do objeto que a fala cita ("mdi:bread-slice", "mdi:qrcode"; procure com estudio_midia acao:icones), um 3D do kit (raio|relogio|check|balao|escudo|coracao|estrela|sol|play|engrenagem|cadeado|barras|fone|onda|celular|seta|bateria) ou "nenhum" quando a tipografia basta; forma abstrata (explosao|poligono|esfera|toro|truchet|aneis|grade|rastro) só em assunto abstrato ou de tecnologia — numa conversa de padaria, nunca; ambiente limpo|luz|bokeh e acento traco|viagem (o ponto que viaja entre as batidas): vazio, o PrimoCode escolhe com memória e o bokeh quase não sai fora de tecnologia) | classico (o motion 3D antigo) | vox (explainer editorial: tinta sobre papel, câmera que conta a frase) | '
-                + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | fluido (minimalista: uma ideia por batida, a forma de uma vira a próxima, sem corte; paleta noite|breu|preto|cobalto (escuras) ou lavanda|creme|laranja|branco (claras) — escolha pelo assunto e NÃO repita a do vídeo anterior; vazio, o PrimoCode escolhe; fontesFluido aprovado|editorial|revista|carater|tecnico|classico, vazio gira) | impacto | cinema. '
-                + 'marca e lancamento aceitam visual:orbe|vetor|estrela|esfera|grade|site|padrao|cromo|cartoes|painel|cores numa parte. marca.nome dá o nome. '
+                + 'marca (brand reveal: brilho, letras em vetor, marca cromada, padrão) | lancamento (produto: cartões, painel, calendário) | fluido (minimalista: uma ideia por batida, a forma de uma vira a próxima, sem corte; paleta noite|breu|preto|cobalto (escuras) ou lavanda|creme|laranja|branco (claras) — escolha pelo assunto e NÃO repita a do vídeo anterior; vazio, o PrimoCode escolhe; fontesFluido aprovado|editorial|revista|carater|tecnico|classico, vazio gira) | impacto | cinema | personagem (o vídeo GRAVADO em 3D — cada parte é UMA fala {falante, texto, emocao?, destaque?}, sem tipo: personagens modelados — gente ou robô — conversando num set de podcast/estúdio/escritório, a boca segue a voz, gestos, e a câmera corta entre aberto, ombro e close; use quando o pedido fala em personagem, boneco, avatar, podcast, entrevista, ou alguém FALANDO em 3D. Com dois falantes (falante em cada parte) eles conversam; personagens:{"nome":{tipo:robo|pessoa, pele, cabelo:curto|cacheado|longo|topete|coque|careca, corCabelo, roupa, oculos, barba, rotulo}} — nome de IA vira robô sozinho; emocao feliz|serio|surpreso|pensativo|animado|curioso e destaque:"texto curto" (o cartão na tela) em cada parte; cenario podcast|estudio|escritorio|noite). '
+                + 'marca e lancamento aceitam visual:orbe|vetor|esfera|grade|site|padrao|cromo|cartoes|painel|cores numa parte. marca.nome dá o nome. '
                 + 'voz (thalita|antonio|francisca). DUAS VOZES (o pedido fala em dois narradores, diálogo, conversa, entrevista): roteiro.vozes {"nome":"antonio","outro":"thalita"} e falante:"nome" em cada parte — cada um sai na sua voz. Ajuste fino: plano: {formato:{largura,altura,fps}, cenas:[…], audio:{…}} — ou cenas direto. '
                 + 'cena (opcional): o número de UMA cena para trocar só ela, sem reescrever o resto. '
                 + 'motivo (opcional): fica no caderno. voltarPara (opcional): nome de uma versão. '
@@ -104,13 +104,19 @@ const GRUPOS = [
                 + '"anima": {propriedade: [{t,v,e}]} — quadros-chave em segundos. A cena tem "camera": {zoom,x,y,rotacao} e '
                 + '"perspectiva" para 3D. Cena.transicao {tipo,duracao}: corte|esmaecer|deslizar|zoom|giro|mascara|morph|chicote|soco|flash|liquido, '
                 + 'e as 3D virar|cubo|profundidade|inclinar (mexem nas duas cenas) — use 3D se o vídeo pede volume (produto, site, tecnologia); em editorial plano, prefira as planas. '
-                + 'NÃO existe layout pronto nem tema — cada propriedade do vídeo é escolha sua, a cada vídeo.' },
+                + 'NÃO existe layout pronto nem tema — cada propriedade do vídeo é escolha sua, a cada vídeo. '
+                + 'ÁREA SEGURA: nada a menos de 6% da largura e 7% da altura da borda, e 4% do lado curto entre dois elementos no ar juntos — '
+                + 'o render empurra para dentro, encolhe o texto largo e afasta o colado; enfeite de fundo marque decorativo: true.' },
 
             { tool: 'estudio_midia', escreve: true, faz: 'procura e baixa ícone, imagem, música e efeito sonoro da internet, e lista as fontes',
-              args: 'acao: imagem | icones | som | trilha | efeito | fontes | print. termo. id (para baixar). '
+              args: 'acao: imagem | icones | som | trilha | efeito | fontes | print | elementos | elemento | recortar. termo. id (para baixar). '
                 + 'print: url — tira o print REAL do site e devolve o src e um elemento {tipo:"kit", peca:"printsite"} pronto '
                 + '(o site de verdade numa janela 3D que rola a página; celular: true para a tela do celular; inteira: false só a primeira dobra). '
                 + 'Use SE o pedido trouxer um site e o vídeo for SOBRE ele (lançamento, tour, case); vídeo que só cita a marca não precisa. '
+                + 'elementos: url — lê o CÓDIGO do site e lista as peças que dá para tirar (logo, menu, titulo, hero, botao, cartao, imagem, formulario, preco, rodape), cada uma com o seletor. '
+                + 'elemento: url + seletor (ou texto: o que está escrito nele) — tira SÓ aquela peça, em PNG com fundo transparente e no dobro da resolução, e devolve o código dela (html e estilo: fonte, cor, raio, sombra) e um elemento {tipo:"imagem"} pronto; '
+                + 'use para pôr o botão, o cartão de preço ou a logo do site animando no vídeo (ou redesenhe a peça como componente a partir do código). '
+                + 'recortar: arquivo — tira o fundo de qualquer foto com IA (rembg), PNG transparente. '
                 + 'efeitos: lista os componentes guardados (os menos usados primeiro). usar-efeito {nome}: copia para o projeto e devolve o elemento — use se um deles servir a ESTE roteiro. '
                 + 'guardar-efeito {arquivo, nome, descricao}: guarda um componente que você escreveu e ficou bom, para os próximos vídeos '
                 + '(o componente: export default de uma função React que recebe {el, t, fps}, num arquivo só, importando só react, remotion, @remotion/*, three). '

package/lib/entrada.js

@@ -47,7 +47,26 @@ const { c, visibleWidth, truncate } = require('./ui.js');
 const RE_ETIQUETA = /\[Colado #\d+ · [^\]]+\]/g;
 function pintarEtiquetas(s) { return String(s).replace(RE_ETIQUETA, (m) => c.brand(m) + '\x1b[38;5;254m'); }
 
-const BORDA = { ne: '╭', no: '╮', se: '╰', so: '╯', h: '─', v: '│' };
+/* As cores do painel, no cubo de 256 cores. O fundo é um degrau acima do
+   preto do terminal (235); a barra é o azul do OpenCode; o escolhido do menu,
+   o pêssego dele com texto escuro. */
+const COR = {
+    fundo: '\x1b[48;5;235m',
+    barra: '\x1b[38;5;75m',
+    warn: '\x1b[38;5;214m',
+    selFundo: '\x1b[48;5;216m',
+    selTexto: '\x1b[38;5;234m',
+    reset: '\x1b[0m',
+};
+/* Onde o texto começa: a barra, o espaço, e as duas colunas da marca ("$ "
+   no modo bash, vazias no normal). O cursor conta a partir daqui. */
+const PREFIXO = 4;
+
+/** Uma linha do painel: fundo até `w` colunas, religado depois de cada reset. */
+function painel(s, w) {
+    const corpo = String(s).split(COR.reset).join(COR.reset + COR.fundo);
+    return COR.fundo + corpo + ' '.repeat(Math.max(0, w - visibleWidth(s))) + COR.reset;
+}
 
 /** Preenche até `w` colunas VISÍVEIS (códigos de cor não ocupam coluna). */
 function encher(s, w) {
@@ -95,9 +114,13 @@ function quebrar(texto, w) {
  */
 function montar(e) {
     const colunas = Math.max(24, Math.min(e.colunas || 80, 200));
-    const largura = colunas - 1;    // a última coluna fica livre: escrever nela
-                                    // faz o terminal quebrar a linha sozinho
-    const w = Math.max(8, largura - 3);   // espaço + '❯ ' — e mais nada à direita
+    /* Na ABERTURA (nada mandado ainda) a caixa é estreita e centrada embaixo
+       do logo, como a home do OpenCode; depois do primeiro pedido ela ocupa a
+       largura toda. `recuo` é a margem da esquerda, que entra em toda linha. */
+    const largura = e.centro ? Math.min(colunas - 1, 80) : colunas - 1;   // a última coluna
+                                    // fica livre: escrever nela faz o terminal quebrar a linha
+    const recuo = e.centro ? Math.max(0, Math.floor((colunas - largura) / 2)) : 0;
+    const w = Math.max(8, largura - PREFIXO);
 
     const cursor = Math.max(0, Math.min(e.cursor | 0, String(e.texto).length));
     const linhas = quebrar(e.texto, w);
@@ -112,41 +135,39 @@ function montar(e) {
         if (cursor >= l.de && cursor <= fim) { cursorLinha = i; cursorColuna = cursor - l.de; }
     }
 
-    /* DUAS RÉGUAS, NÃO UMA CAIXA.
-       Era uma caixa fechada — cantos e barras laterais. O Claude Code, que é a
-       referência pedida, usa só a linha de cima e a de baixo, e a diferença
-       não é gosto: a barra lateral direita obriga a reservar duas colunas em
-       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
+    /* O DESENHO DO OPENCODE, que é a referência pedida: um PAINEL — fundo um
+       tom mais claro que o terminal, uma barra grossa na esquerda na cor do
+       modo — e não réguas nem caixa de cantos. Dentro dele, o texto; uma
+       linha em branco; e embaixo, ainda dentro, o modo e o esforço ("Auto ·
+       alto"), que é o que muda o que acontece no Enter. Fora do painel, uma
+       linha só: a pasta à esquerda, os atalhos à direita.
+
+       O fundo vai até a última coluna útil em toda linha do painel. É ele que
+       desenha a caixa — sem borda nenhuma — e por isso cada `reset` de cor no
+       meio do texto tem de religar o fundo (ver `painel`). */
+    /* MODO BASH: a linha que começa com "!" roda no shell, e o painel muda de
+       cor para avisar. 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". */
+       a pessoa lembrar do que digitou: ela tem de VER, enquanto digita, que
+       aquele Enter vai ao shell. Âmbar é o "atenção" do resto do programa. */
     const bash = /^\s*!/.test(String(e.texto));
+    const st = Array.isArray(e.status) ? { linhas: e.status } : (e.status || {});
+    const corBarra = bash ? COR.warn : (st.cor || COR.barra);
+    const barra = `${corBarra}┃${COR.reset}`;
+    const linhaDoPainel = (conteudo) => painel(barra + conteudo, largura);
 
     const out = [];
-    const regua = (bash ? c.warn : c.dim)(BORDA.h.repeat(largura));
-    /* O SPINNER MORA AQUI, na linha logo acima da caixa. Ele escrevia direto
-       no terminal com "\r" a cada 80 ms, sem quebra de linha — e a caixa,
-       que espera a linha fechar para se redesenhar, ficava apagada enquanto
-       ele girasse: o que se digitava não aparecia, e a barra de status
-       sumia ("não consigo digitar enquanto ele trabalha"). */
+    /* O SPINNER MORA AQUI, na linha logo acima do painel. Ele escrevia direto
+       no terminal com "\r" a cada 80 ms — e a caixa, que espera a linha fechar
+       para se redesenhar, ficava apagada enquanto ele girasse. */
     if (e.spinner) out.push(' ' + truncate(e.spinner, largura - 2));
-    out.push(regua);
+
+    out.push(linhaDoPainel(''));                 // o respiro de cima
 
     const vazio = !String(e.texto).length;
     linhas.forEach((l, i) => {
-        const marca = i === 0
-            ? (e.ocupado ? c.dim('❯ ') : bash ? c.warn('$ ') : c.brand('❯ '))
-            : c.dim('┆ ');
-        // O "!" some do texto desenhado: quem vê "$ " já sabe que é shell, e
-        // mostrar os dois é mostrar a mesma informação duas vezes.
+        // O "!" some do texto desenhado: quem vê "$ " já sabe que é shell.
+        const marca = i === 0 && bash ? c.warn('$ ') : '  ';
         let conteudo = pintarEtiquetas(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.
@@ -155,56 +176,71 @@ function montar(e) {
         }
         if (i === 0 && vazio && e.ocupado) conteudo = c.dim('mande um recado — ele entra na tarefa depois do passo atual');
         else if (i === 0 && vazio && e.vazio) conteudo = c.dim(e.vazio);
-        // Sem `encher`: sem barra à direita não há nada para alinhar, e o
-        // espaço sobrando só apagaria o que estivesse embaixo.
-        out.push(' ' + marca + conteudo);
+        out.push(linhaDoPainel(' ' + marca + truncate(conteudo, w)));
     });
 
-    out.push(regua);
+    out.push(linhaDoPainel(''));
+    // O modo e o esforço, dentro do painel — "Build · Nemotron" no OpenCode.
+    out.push(linhaDoPainel('   ' + truncate(bash
+        ? c.warn('roda no shell') + c.dim(`, em ${e.pasta || 'a pasta atual'} · apague o ! para voltar ao normal`)
+        : (st.modo || c.dim('PrimoCode')), largura - 4)));
+
+    // ── a linha de baixo: pasta à esquerda, atalhos à direita ────────────
+    if (st.linhas) {
+        for (const linha of st.linhas) out.push(' ' + truncate(linha, largura - 2));
+    } else {
+        const esq = st.esquerda || '';
+        const dir = st.direita || '';
+        const sobra = largura - 2 - visibleWidth(esq) - visibleWidth(dir);
+        out.push(' ' + (sobra >= 2 ? esq + ' '.repeat(sobra) + dir : truncate(esq, largura - 2)));
+    }
 
     // ── o menu dos comandos ──────────────────────────────────────────────
-    // Fica ABAIXO da caixa, não dentro: dentro, ele empurraria o campo de
-    // digitar para cima a cada tecla, e o texto que a pessoa escreve saltaria
-    // de lugar enquanto ela escreve.
+    // Fica ABAIXO de tudo, não em cima do painel: em cima, ele empurraria o
+    // campo de digitar para baixo a cada tecla, e o texto que a pessoa
+    // escreve saltaria de lugar enquanto ela escreve. O desenho é o do
+    // OpenCode: fundo de painel, e o escolhido numa faixa pêssego.
     if (e.menu && e.menu.itens.length) {
         const cabem = Math.max(1, Math.min(e.menu.itens.length, 8));
         // A janela acompanha a seleção: descer na lista rola, em vez de o
         // item escolhido sumir embaixo.
         let topo = Math.max(0, Math.min(e.menu.sel - Math.floor(cabem / 2),
             e.menu.itens.length - cabem));
+        const nomeW = 16;
         for (let i = topo; i < topo + cabem; i++) {
             const [nome, desc] = e.menu.itens[i];
-            const escolhido = i === e.menu.sel;
-            const nomeW = 16;
-            const corpo = (escolhido ? c.brand('❯ ') : '  ')
-                + (escolhido ? c.bold(c.white(encher(nome, nomeW))) : c.muted(encher(nome, nomeW)))
-                + c.dim(desc || '');
-            out.push(' ' + truncate(corpo, largura - 2));
+            if (i === e.menu.sel) {
+                const corpo = ' ' + encher(nome, nomeW) + (desc || '');
+                out.push(`${COR.selFundo}${COR.selTexto}${encher(truncate(corpo, largura), largura)}${COR.reset}`);
+            } else {
+                out.push(painel(' ' + c.white(encher(nome, nomeW)) + c.dim(desc || ''), largura));
+            }
         }
         if (e.menu.itens.length > cabem) {
-            out.push('  ' + c.dim(`… e mais ${e.menu.itens.length - cabem}`));
+            out.push(painel(' ' + c.dim(`… e mais ${e.menu.itens.length - cabem}`), largura));
         }
     }
 
-    /* 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);
-
+    const margem = ' '.repeat(recuo);
     return {
-        linhas: out,
-        cursorLinha: 1 + cursorLinha,                   // +1 pela régua de cima
+        linhas: recuo ? out.map((l) => margem + l) : out,
+        cursorLinha: (e.spinner ? 1 : 0) + 1 + cursorLinha,   // +1 pelo respiro de cima
         /* 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),
+        cursorColuna: recuo + PREFIXO + cursorColuna - (bash && cursorLinha === 0 ? 1 : 0),
     };
 }
 
+/** O pedido que foi mandado, como fica no histórico da tela: um painel. */
+function pedidoNaTela(texto, colunas) {
+    const largura = Math.max(24, Math.min(colunas || 80, 200)) - 1;
+    const barra = `${COR.barra}┃${COR.reset}`;
+    const linhas = quebrar(texto, Math.max(8, largura - PREFIXO))
+        .map((l) => painel(barra + '   ' + pintarEtiquetas(c.white(l.texto)), largura));
+    return [painel(barra, largura), ...linhas, painel(barra, largura)].join('\n');
+}
+
 // ── A caixa viva ─────────────────────────────────────────────────────────
 
 class Entrada extends EventEmitter {
@@ -416,11 +452,16 @@ class Entrada extends EventEmitter {
             menu: this.menu,
             ocupado: this.ocupado,
             spinner: this.spinnerTexto || '',
+            centro: !this.mandou,
         });
     }
 
     _desenhar() {
         if (!this.tty || this.suspenso || this.fechado) return;
+        /* Já desenhada (um `prompt()` de quem não sabe que ela está no ar):
+           apaga antes. Sem isso o quadro novo começava na linha do cursor —
+           a do texto — e o respiro de cima do painel ficava dobrado. */
+        if (this.desenhado && !this._meiaLinha) this._apagar();
         const q = this._quadro();
         this._pintando = true;
         /* Cursor no meio de uma linha (fluxo que ainda não fechou): desce uma
@@ -525,6 +566,9 @@ class Entrada extends EventEmitter {
 
             case 'tab': {
                 if (this.menu) return this._escolherDoMenu();
+                /* Tab com a caixa vazia troca o modo — o "tab agents" do
+                   OpenCode. Com texto, continua completando o comando. */
+                if (!this.line && !this.ocupado) { this.emit('trocar-modo'); return; }
                 const f = this._fantasma();
                 if (f) return this.write(f);
                 if (this.line.startsWith('/')) { this._filtrarMenu(); this._redesenhar(); }
@@ -605,6 +649,12 @@ class Entrada extends EventEmitter {
             }
             case 'l': this._apagar(); this.escreverCru('\x1b[2J\x1b[H'); return this._desenhar();
             case 'j': return this._novaLinha();
+            // Ctrl+P abre os comandos, como no OpenCode: o mesmo menu do "/".
+            case 'p':
+                if (this.line && !this.line.startsWith('/')) return;
+                if (!this.line) { this.line = '/'; this.cursor = 1; }
+                this._filtrarMenu();
+                return this._redesenhar();
             default: return;
         }
     }
@@ -660,10 +710,12 @@ class Entrada extends EventEmitter {
            senão o pedido some no instante em que a resposta começa, e quem
            rola para cima não acha o que perguntou. */
         this._apagar();
+        if (texto.trim()) this.mandou = true;   // a caixa sai do centro e ocupa a largura
         if (texto.trim() && !oculto) {
-            const marca = c.brand('❯ ');
-            // Na tela fica a etiqueta (o que se viu ao mandar); quem vai ao agente é o texto inteiro.
-            this.escreverCru(visto.split('\n').map((l, i) => (i ? '  ' : marca) + pintarEtiquetas(c.white(l))).join('\n') + '\n');
+            // Na tela fica a etiqueta (o que se viu ao mandar); quem vai ao agente
+            // é o texto inteiro. O desenho é o do pedido no OpenCode: o mesmo
+            // painel da caixa, com a barra, e um respiro em cima e embaixo.
+            this.escreverCru(pedidoNaTela(visto, process.stdout.columns || 80) + '\n');
             if (this.historico[this.historico.length - 1] !== texto) this.historico.push(texto);
         }
         this._desenhar();
@@ -673,4 +725,4 @@ class Entrada extends EventEmitter {
 
 function criar(op) { return new Entrada(op).iniciar(); }
 
-module.exports = { criar, Entrada, montar, quebrar, encher, pintarEtiquetas };
+module.exports = { criar, Entrada, montar, quebrar, encher, pintarEtiquetas, painel, pedidoNaTela, PREFIXO, COR };

package/lib/estudio/acervo.js

@@ -320,14 +320,28 @@ function creditos(arquivos = null, pasta = PASTA()) {
  * Qual ferramenta desta máquina sabe recortar. A decisão fica separada do
  * processo para poder ser testada sem recortar nada.
  */
-function comoTirarFundo({ temRembg, temBackgroundRemover, temPython, temFfmpeg } = {}) {
+function comoTirarFundo({ temRembg, temBackgroundRemover, temPython, temUv, temFfmpeg } = {}) {
     if (temRembg) return 'rembg';
     if (temBackgroundRemover) return 'backgroundremover';
     if (temPython) return 'python-rembg';
+    /* Com o uv (o mesmo do recorte de pessoa), o rembg roda sem instalar nada:
+       o uv baixa o pacote num ambiente à parte. Antes, sem `pip install rembg`,
+       a foto caía no corte por cor e saía com o fundo inteiro (10/10). */
+    if (temUv) return 'uv-rembg';
     if (temFfmpeg) return 'ffmpeg-chroma';       // só resolve fundo de cor chapada
     return null;
 }
 
+let _uv;
+function acharUv() {
+    if (_uv !== undefined) return _uv;
+    const os = require('os');
+    for (const c of ['uv', path.join(os.homedir(), '.local', 'bin', 'uv'), '/opt/homebrew/bin/uv', '/usr/local/bin/uv']) {
+        try { if (spawnSync(c, ['--version'], { stdio: 'ignore', timeout: 5000 }).status === 0) return (_uv = c); } catch { /* próximo */ }
+    }
+    return (_uv = null);
+}
+
 function existe(cmd) {
     try { return spawnSync(cmd, ['--help'], { stdio: 'ignore', timeout: 8000 }).status != null; }
     catch { return false; }
@@ -354,6 +368,7 @@ async function tirarFundo(arquivo, { destino, cor = '0x00FF00', tolerancia = 0.3
             try { return spawnSync('python3', ['-c', 'import rembg'], { stdio: 'ignore', timeout: 20000 }).status === 0; }
             catch { return false; }
         })(),
+        temUv: !!acharUv(),
         temFfmpeg: existe('ffmpeg'),
     });
     if (!metodo) {
@@ -381,6 +396,11 @@ async function tirarFundo(arquivo, { destino, cor = '0x00FF00', tolerancia = 0.3
         deu = await rodar('python3', ['-c',
             'import sys;from rembg import remove;open(sys.argv[2],"wb").write(remove(open(sys.argv[1],"rb").read()))',
             arquivo, saida]);
+    } else if (metodo === 'uv-rembg') {
+        // A primeira vez baixa o modelo (~170 MB, fica em ~/.u2net); depois é segundos por imagem.
+        deu = await rodar(acharUv(), ['run', '--quiet', '--python', '3.12', '--with', 'rembg[cpu]', '--with', 'pillow', 'python', '-c',
+            'import sys;from rembg import remove, new_session;open(sys.argv[2],"wb").write(remove(open(sys.argv[1],"rb").read(), session=new_session("isnet-general-use")))',
+            arquivo, saida]);
     } else {
         deu = await rodar('ffmpeg', ['-y', '-i', arquivo, '-vf',
             `colorkey=${cor}:${tolerancia}:0.1`, '-c:a', 'copy', saida]);