primocode 10.3.0 → 10.4.1

package/lib/entrada.js

@@ -40,6 +40,7 @@
 const readline = require('readline');
 const { EventEmitter } = require('events');
 const { c, visibleWidth, truncate } = require('./ui.js');
+const tela = require('./tela.js');
 
 // ── O desenho ────────────────────────────────────────────────────────────
 
@@ -47,7 +48,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 +115,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 +136,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 +177,80 @@ 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.
+    /* NA TELA CHEIA (`menuAcima`) ele abre EM CIMA do painel, como no
+       OpenCode: lá a caixa é presa no pé da tela e nada salta — o menu só
+       cobre a conversa. */
+    const menu = [];
     if (e.menu && e.menu.itens.length) {
-        const cabem = Math.max(1, Math.min(e.menu.itens.length, 8));
+        const out = menu;
+        const cabem = Math.max(1, Math.min(e.menu.itens.length, e.menuAcima ? 10 : 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);
+    let acima = 0;
+    if (menu.length && e.menuAcima) { out.splice(e.spinner ? 1 : 0, 0, ...menu); acima = menu.length; }
+    else out.push(...menu);
 
+    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: acima + (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 {
@@ -232,6 +278,12 @@ class Entrada extends EventEmitter {
         this.oculto = false;      // a próxima resposta é senha: ver `ocultarProxima`
         this.tty = !!(process.stdin.isTTY && process.stdout.isTTY);
         this.escreverCru = process.stdout.write.bind(process.stdout);
+        /* A TELA CHEIA (lib/tela.js): a conversa vive aqui, em linhas, e a
+           tela inteira é redesenhada a cada mudança — em vez de o texto subir
+           pelo terminal com a caixa atrás. */
+        this.cheia = !!(op.telaCheia && this.tty);
+        this.conversa = [];
+        this.rolagem = 0;
     }
 
     // ── ciclo de vida ────────────────────────────────────────────────────
@@ -254,7 +306,7 @@ class Entrada extends EventEmitter {
         this._aoTeclar = (ch, key) => this._tecla(ch, key);
         process.stdin.on('keypress', this._aoTeclar);
 
-        this._aoRedimensionar = () => { if (this.desenhado) this._redesenhar(); };
+        this._aoRedimensionar = () => { if (this.cheia) this._pintar(); else if (this.desenhado) this._redesenhar(); };
         process.stdout.on('resize', this._aoRedimensionar);
 
         /* Todo `console.log` do programa passa a apagar a caixa antes de
@@ -264,8 +316,20 @@ class Entrada extends EventEmitter {
            por cima da caixa. */
         this._stdoutOriginal = process.stdout.write;
         const eu = this;
+        if (this.cheia) this._entrarNaTela();
         process.stdout.write = function (texto, ...resto) {
             if (eu._pintando) return eu._stdoutOriginal.call(this, texto, ...resto);
+            /* Na tela cheia, o que o programa escreve vira linha da conversa,
+               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');
+                if (fim) fim();
+                return true;
+            }
             eu._apagar();
             const r = eu._stdoutOriginal.call(this, texto, ...resto);
             /* ── O TEXTO QUE CHEGA EM PEDAÇOS ────────────────────────────
@@ -310,6 +374,7 @@ class Entrada extends EventEmitter {
 
     parar() {
         if (!this.tty) { if (this._rlPipe) this._rlPipe.close(); return; }
+        if (this.cheia) this._sairDaTela();
         this._apagar();
         this.escreverCru('\x1b[?2004l');
         if (this._stdoutOriginal) process.stdout.write = this._stdoutOriginal;
@@ -323,8 +388,88 @@ 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; this._apagar(); }
-    retomar() { this.suspenso = false; if (this.ativo && !this.fechado) this._desenhar(); }
+    suspender() { this.suspenso = true; if (this.cheia) this._sairDaTela(); else this._apagar(); }
+    retomar() {
+        this.suspenso = false;
+        if (this.cheia && this.ativo && !this.fechado) { this._entrarNaTela(); return this._pintar(); }
+        if (this.ativo && !this.fechado) this._desenhar();
+    }
+
+    // ── a tela cheia ─────────────────────────────────────────────────────
+
+    /* A tela alternativa (a do vim): o que estava no terminal fica guardado e
+       volta inteiro na saída. Com ela, a roda do mouse — senão o terminal
+       transformaria a roda em seta para cima e a seta é o histórico. */
+    _entrarNaTela() {
+        if (this._naTela) return;
+        this._naTela = true;
+        /* O resto do programa (o markdown, a fala) quebra linha pela largura
+           do terminal. Na tela cheia a conversa é só a coluna da esquerda —
+           sem a barra da direita — então, enquanto ela está no ar, é ESSA a
+           largura que o programa vê. A real fica guardada para o desenho. */
+        if (!this._colunasReais) {
+            const eu = this;
+            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; },
+                set(v) { eu._colunasReais = v; },   // o Node escreve aqui quando a janela muda
+            });
+        }
+        this.escreverCru('\x1b[?1049h\x1b[?1000h\x1b[?1006h\x1b[2J');
+        if (!this._aoSairDoProcesso) {
+            // Um erro que derruba o programa não pode deixar o terminal na
+            // tela alternativa, sem cursor e capturando o mouse.
+            this._aoSairDoProcesso = () => this._sairDaTela();
+            process.on('exit', this._aoSairDoProcesso);
+        }
+    }
+
+    _sairDaTela() {
+        if (!this._naTela) return;
+        this._naTela = false;
+        this.escreverCru('\x1b[?1000l\x1b[?1006l\x1b[?25h\x1b[?1049l');
+    }
+
+    /** Junta as mudanças de um mesmo instante num quadro só. */
+    _agendar() {
+        if (this._agendado) return;
+        this._agendado = setTimeout(() => { this._agendado = null; this._pintar(); }, 16);
+    }
+
+    /** 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));
+        return tela.quadro({
+            colunas: this._colunasReais || 80,
+            linhas: process.stdout.rows || 24,
+            conversa: this.conversa,
+            rolagem: this.rolagem,
+            home: !this.mandou && !conversa,
+            caixa: (colunas, centro) => montar({ ...this._estado(), colunas, centro, menuAcima: true }),
+            lateral: { titulo: this.titulo, ...(this.op.lateral ? this.op.lateral() : {}) },
+            versao: this.op.versao || '',
+            pasta: this.op.pasta ? this.op.pasta() : '',
+        });
+    }
+
+    _pintar() {
+        if (!this.cheia || this.suspenso || this.fechado || !this._naTela) return;
+        const q = this._quadroCheio();
+        this.rolagem = Math.min(this.rolagem, q.rolagemMax);
+        let out = '\x1b[?25l';
+        q.linhas.forEach((l, i) => { out += `\x1b[${i + 1};1H${l}\x1b[0m\x1b[K`; });
+        out += `\x1b[${q.cursor.linha + 1};${q.cursor.coluna + 1}H\x1b[?25h`;
+        this._pintando = true;
+        this.escreverCru(out);
+        this._pintando = false;
+        this.desenhado = { linhas: q.linhas, cursorLinha: q.cursor.linha };
+    }
+
+    _rolar(passo) {
+        this.rolagem = Math.max(0, this.rolagem + passo);
+        this._pintar();
+    }
 
     /** O agente está trabalhando: a caixa esmaece, e o Enter manda um RECADO
      *  que entra na tarefa em curso (a caixa de entrada de lib/act.js). */
@@ -342,11 +487,13 @@ class Entrada extends EventEmitter {
         const novo = texto || '';
         if (novo === (this.spinnerTexto || '')) return;
         this.spinnerTexto = novo;
+        if (this.cheia) return this._agendar();
         if (this.desenhado && !this._meiaLinha) this._redesenhar();
     }
 
     /** Escreve texto ACIMA da caixa — é por onde todo o resto do programa fala. */
     escreverAcima(texto) {
+        if (this.cheia) { tela.acrescentar(this.conversa, texto); return this._agendar(); }
         if (!this.desenhado) { this.escreverCru(texto); return; }
         this._apagar();
         this.escreverCru(texto);
@@ -405,8 +552,10 @@ class Entrada extends EventEmitter {
 
     // ── desenho ──────────────────────────────────────────────────────────
 
-    _quadro() {
-        return montar({
+    _quadro() { return montar(this._estado()); }
+
+    _estado() {
+        return ({
             texto: this.oculto ? '•'.repeat(this.line.length) : this.line,
             cursor: this.cursor,
             colunas: process.stdout.columns || 80,
@@ -416,11 +565,17 @@ class Entrada extends EventEmitter {
             menu: this.menu,
             ocupado: this.ocupado,
             spinner: this.spinnerTexto || '',
+            centro: !this.mandou,
         });
     }
 
     _desenhar() {
+        if (this.cheia) return this._pintar();
         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
@@ -441,6 +596,7 @@ class Entrada extends EventEmitter {
     }
 
     _apagar() {
+        if (this.cheia) return;
         if (!this.desenhado || !this.tty) return;
         this._pintando = true;
         // Sobe até a primeira linha do quadro e limpa daí para baixo.
@@ -497,6 +653,19 @@ class Entrada extends EventEmitter {
             return;
         }
 
+        /* A roda do mouse chega como "\x1b[<64;x;yM", e o readline a entrega
+           picada, tecla por tecla. Daqui até o M (ou m), tudo é do mouse. */
+        if (key && key.code === '[<') { this._mouse = ''; return; }
+        if (this._mouse != null) {
+            if (/^[mM]$/.test(seq)) {
+                const botao = parseInt(this._mouse, 10);
+                this._mouse = null;
+                if (botao === 64) this._rolar(3);
+                else if (botao === 65) this._rolar(-3);
+            } else this._mouse += seq;
+            return;
+        }
+
         if (!key) { if (ch) this.write(ch); return; }
 
         // Esc Esc e o resto das teclas de fora: quem escuta decide. A caixa
@@ -525,6 +694,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(); }
@@ -563,6 +735,8 @@ class Entrada extends EventEmitter {
                 if (this.cursor < this.line.length) { this.cursor++; this._redesenhar(); }
                 return;
             }
+            case 'pageup': return this._rolar(Math.max(3, (process.stdout.rows || 24) - 8));
+            case 'pagedown': return this._rolar(-Math.max(3, (process.stdout.rows || 24) - 8));
             case 'home': this.cursor = 0; this._redesenhar(); return;
             case 'end':  this.cursor = this.line.length; this._redesenhar(); return;
 
@@ -603,8 +777,16 @@ class Entrada extends EventEmitter {
                 this.cursor = antes.length;
                 return this._mudou();
             }
-            case 'l': this._apagar(); this.escreverCru('\x1b[2J\x1b[H'); return this._desenhar();
+            case 'l':
+                if (this.cheia) { this.conversa = []; this.rolagem = 0; return this._pintar(); }
+                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 +842,22 @@ 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
+        // O título da sessão, na barra da direita: o primeiro pedido.
+        if (texto.trim() && !oculto && !this.titulo && !texto.trim().startsWith('/')) {
+            const t = visto.replace(/\s+/g, ' ').trim();
+            this.titulo = t.length > 70 ? t.slice(0, 69).replace(/\s+\S*$/, '') + '…' : t;
+        }
         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.
+            if (this.cheia) {
+                const W = this._colunasReais || 80;
+                const mainW = W >= tela.LATERAL_MIN ? W - tela.LATERAL_W : W;
+                this.rolagem = 0;
+                tela.acrescentar(this.conversa, (this.conversa.some((l) => /\S/.test(l)) ? '\n' : '') + pedidoNaTela(visto, mainW - 1) + '\n');
+            } else 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 +867,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]);

package/lib/estudio/estilo.js

@@ -25,20 +25,25 @@
 
 const variedade = require('./variedade.js');
 
-const ESTILOS = ['hibrido', 'gerativo', 'motion', 'vox', 'marca', 'lancamento', 'impacto', 'cinema', 'composicao', 'fluido'];
+const ESTILOS = ['hibrido', 'gerativo', 'motion', 'vox', 'marca', 'lancamento', 'impacto', 'cinema', 'composicao', 'fluido', 'personagem'];
 // Nomes que o modelo usa para os mesmos estilos.
 /* "motion" agora é o GERATIVO ("não pode ter template", 29–30/09); o motion
    antigo segue pelo nome "classico" (e "limpo", o nome mais antigo dele). */
 const APELIDOS = { motion: 'gerativo', generativo: 'gerativo', kinetic: 'gerativo', cinetico: 'gerativo', 'cinético': 'gerativo',
     tipografico: 'gerativo', 'tipográfico': 'gerativo', animacao: 'gerativo', 'animação': 'gerativo',
     classico: 'motion', 'clássico': 'motion', 'motion-classico': 'motion', motion3d: 'motion',
-    absurdo: 'hibrido', misto: 'hibrido', mix: 'hibrido', 'híbrido': 'hibrido', limpo: 'motion', explainer: 'vox', editorial: 'vox', brand: 'marca', branding: 'marca', 'brand-reveal': 'marca', minimalista: 'fluido', minimal: 'fluido', clean: 'fluido', apple: 'fluido', launch: 'lancamento', 'lançamento': 'lancamento', produto: 'lancamento' };
+    absurdo: 'hibrido', misto: 'hibrido', mix: 'hibrido', 'híbrido': 'hibrido', limpo: 'motion', explainer: 'vox', editorial: 'vox', brand: 'marca', branding: 'marca', 'brand-reveal': 'marca', minimalista: 'fluido', minimal: 'fluido', clean: 'fluido', apple: 'fluido', launch: 'lancamento', 'lançamento': 'lancamento', produto: 'lancamento',
+    personagens: 'personagem', boneco: 'personagem', bonecos: 'personagem', conversa: 'personagem', dialogo: 'personagem', 'diálogo': 'personagem', podcast: 'personagem', gravado: 'personagem' };
 
 const PEDE_FLUIDO = /\bfluid[oa]\b|minimalista|\bminimal\b|\bclean\b|\bapple\b/i;
 const PEDE_MOTION = /\bmotion\b|anima[çc][ãa]o|animad[oa]/i;
 const PEDE_VOX = /\bvox\b|explica|explainer|document[aá]rio|editorial|hist[oó]ria d[aoe]s?\b/i;
 const PEDE_MARCA = /\bbrand|identidade visual|revela[çc][ãa]o d[ae] marca|\blogo(tipo|marca)?\b|vinheta de marca/i;
 const PEDE_LANCAMENTO = /lan[çc]amento|\blaunch|\bsaas\b|produto novo|apresenta(ndo|r|ção d[oe]) (o |a )?(app|produto|plataforma|ferramenta)/i;
+/* "Uma animação em 3D do Claude falando com o usuário... como se fosse gravado"
+   (10/10): personagem, boneco, avatar, conversa ou podcast em 3D vira o vídeo
+   GRAVADO em 3D (personagem.js). O 3D de produto continua no gerativo. */
+const PEDE_PERSONAGEM = /personage(m|ns)|\bbonec[oa]s?\b|\bavatar|mascote falando|\bpodcast\b|entrevista|(conversa|di[aá]logo|falando|explicando)[^.]{0,60}\b3\s?d\b|\b3\s?d\b[^.]{0,60}(conversa|di[aá]logo|falando|explicando|pessoa|gente)/i;
 const PEDE_IMPACTO = /an[uú]nci|reels?|divulg|promo|lan[çc]a|vend|campanha|convite|inscri/i;
 
 const normal = (e) => {
@@ -73,7 +78,9 @@ function escolherEstilo({ pedido = '', agente = null, roteiro = null, girar = fa
     const doRoteiro = normal(roteiro);
     /* Pedir MOTION (ou animação) é pedir o gerativo — antes do vox, da marca e
        do lançamento, que são leiaute fixo ("não pode ter template", 30/09). */
-    if (doRoteiro && !(doRoteiro !== 'gerativo' && doRoteiro !== 'fluido' && PEDE_MOTION.test(pedido))) return doRoteiro;
+    // O personagem também é animação: "animação 3D do Claude falando" não pode cair no gerativo.
+    if (doRoteiro && !(!['gerativo', 'fluido', 'personagem'].includes(doRoteiro) && PEDE_MOTION.test(pedido))) return doRoteiro;
+    if (PEDE_PERSONAGEM.test(pedido)) return 'personagem';
     // O fluido é um jeito de motion: "motion minimalista" é o fluido, não o gerativo.
     if (PEDE_FLUIDO.test(pedido)) return 'fluido';
     if (PEDE_MOTION.test(pedido)) return 'gerativo';
@@ -88,6 +95,6 @@ function escolherEstilo({ pedido = '', agente = null, roteiro = null, girar = fa
 }
 
 /** Os estilos que usam os efeitos leves e a trilha do ende.app (os de motion, não os de corte). */
-const LEVES = new Set(['gerativo', 'motion', 'vox', 'marca', 'lancamento', 'fluido']);
+const LEVES = new Set(['gerativo', 'motion', 'vox', 'marca', 'lancamento', 'fluido', 'personagem']);
 
-module.exports = { escolherEstilo, estiloDaVez, ESTILOS, LEVES, PEDE_MOTION, PEDE_FLUIDO, RODIZIO, RODIZIO_SEM_IMAGEM };
+module.exports = { escolherEstilo, estiloDaVez, ESTILOS, LEVES, PEDE_MOTION, PEDE_FLUIDO, RODIZIO, RODIZIO_SEM_IMAGEM, PEDE_PERSONAGEM };

package/lib/estudio/gerativo.js

@@ -42,6 +42,7 @@
 const { misturarCor, ehCor } = require('./morfar.js');
 const { volumesDaTrilha } = require('./ritmo.js');
 const { falaDe } = require('./composicao.js');
+const { limitesNaCamera, MARGEM } = require('./margem.js');
 
 const FPS = 30;
 const QUADRO = 1 / FPS;
@@ -1255,6 +1256,23 @@ function partituraDe({ roteiro, largura = 1920, altura = 1080, tempos = [], icon
         } else camera.push({ t: r3(b.ate), x: 0, y: 0, zoom: r3(z1 + 0.03), rot: 0, e: 'camera' });
     });
 
+    /* ── a área segura de cada batida (margem.js) ──────────────────────
+       O bloco parado não pode encostar na borda DA TELA — e a tela vê o
+       mundo pela câmera: com zoom 1,1 e a batida 110 px mais perto da lente,
+       a margem de 8,5% do mundo virava 3% na tela ("pensam" colado na borda,
+       10/10). Aqui o limite da tela vira limite do mundo, batida a batida; o
+       componente encaixa o bloco MEDIDO dentro dele. O ícone vive mais perto
+       da lente (translateZ 150), então tem o limite dele. */
+    const D = Math.round(Math.max(W, H) * 0.85);
+    batidas.forEach((b) => {
+        const assenta = Math.min(b.de + 0.55, (b.de + b.ate) / 2);
+        const fimCalmo = Math.max(assenta + 0.1, b.ate - 0.32);
+        const op = { W, H, camera, de: assenta, ate: fimCalmo, D };
+        b.seguro = limitesNaCamera({ ...op, z: 110 });
+        b.seguroIcone = limitesNaCamera({ ...op, z: 260 });
+        b.vao = Math.round(Math.min(W, H) * MARGEM.vao);
+    });
+
     // ── o produto em 3D: mora nas batidas que o hospedam ─────────────────
     const produtos = batidas.filter((b) => b.produto3d).map((b) => ({ ...b.produto3d, de: b.de, ate: b.ate, modelo: roteiro.modelo3d,
         cor: roteiro.cor3d || '#1b1c20', corAcento: P.acento, ...(roteiro.variacao3d || {}) }));