primocode 11.0.0 → 11.2.0

package/lib/tui/entrada.js

@@ -0,0 +1,1031 @@
+/**
+ * entrada.js — a caixa de digitar do PrimoCode.
+ *
+ * O que havia antes era o `readline` do Node com um prompt de uma linha só:
+ *
+ *     Auto · ctx 12% · loja ❯ _
+ *
+ * Funciona, e é o que qualquer programa de terminal faz. O que ele NÃO faz é
+ * o que se pediu aqui: uma caixa desenhada, ancorada embaixo, que diz em que
+ * pasta o agente está trabalhando e quais teclas existem — sem a pessoa
+ * precisar lembrar de nada.
+ *
+ * ── O QUE O readline NÃO DAVA, E POR ISSO ELE SAIU ───────────────────────
+ * Não é gosto. São quatro coisas que ele não faz e que a caixa precisa:
+ *
+ *   1. desenhar mais de uma linha e continuar sabendo onde o cursor está —
+ *      o readline pensa em UMA linha de texto, e um pedido de três linhas
+ *      vira uma linha comprida que rola de lado;
+ *   2. manter a caixa ANCORADA embaixo enquanto o agente escreve por cima.
+ *      Cada `console.log` do agente precisa apagar a caixa, escrever, e
+ *      redesenhar — senão o texto sai no meio dela;
+ *   3. barra de status embaixo do campo, que é onde a pasta e o modo moram;
+ *   4. um menu de comandos navegável com as setas.
+ *
+ * ── A REGRA DA ÂNCORA ────────────────────────────────────────────────────
+ * A caixa é sempre a última coisa da tela. Para isso, TODA saída que não é
+ * dela passa por `escreverAcima`: apaga a caixa, escreve o texto, redesenha.
+ * O `process.stdout.write` é embrulhado enquanto a caixa está no ar, então
+ * nenhum `console.log` espalhado pelo programa precisa saber disso.
+ *
+ * ── O DESENHO É FUNÇÃO PURA ──────────────────────────────────────────────
+ * `montar()` recebe um estado e devolve as linhas com a posição do cursor.
+ * Ela não toca no terminal, então o teste consegue conferir quadro a quadro
+ * (largura estreita, texto que quebra, menu aberto) sem nada na tela. Foi
+ * assim que o `/effort` foi feito, pelo mesmo motivo.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+const { EventEmitter } = require('events');
+const { c, visibleWidth, truncate } = require('./ui.js');
+const tela = require('./tela.js');
+const stripAnsiLocal = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
+
+// ── O desenho ────────────────────────────────────────────────────────────
+
+/** A etiqueta de colagem em destaque (fininha, na cor da marca), sem mudar a largura. */
+const RE_ETIQUETA = /\[(?:Colado|Imagem) #\d+[^\]]*\]/g;
+
+/* A IMAGEM ARRASTADA (Joel, 13/10: "#imagem1 #imagem2, igual fica aqui").
+   Arrastar arquivo para o terminal é uma colagem do CAMINHO, e cada terminal
+   escreve de um jeito: o do macOS escapa o espaço e põe um no fim
+   ("Captura\ de\ Tela.png "), o iTerm põe entre aspas, outros mandam
+   file://. Devolve os caminhos quando TODOS são imagens que existem; senão
+   null, e a colagem segue como texto. */
+const RE_IMAGEM = /\.(png|jpe?g|gif|webp|heic|bmp|tiff?|svg)$/i;
+function imagensArrastadas(texto) {
+    const t = String(texto || '').trim();
+    if (!t || t.includes('\n')) return null;
+    const pedacos = [];
+    let cur = '', aspas = null;
+    for (let i = 0; i < t.length; i++) {
+        const ch = t[i];
+        if (aspas) { if (ch === aspas) aspas = null; else cur += ch; continue; }
+        if (ch === "'" || ch === '"') { aspas = ch; continue; }
+        if (ch === '\\' && i + 1 < t.length) { cur += t[++i]; continue; }
+        if (/\s/.test(ch)) { if (cur) pedacos.push(cur); cur = ''; continue; }
+        cur += ch;
+    }
+    if (aspas) return null;
+    if (cur) pedacos.push(cur);
+    const arquivos = pedacos.map((p) => (p.startsWith('file://') ? decodeURI(p.slice(7)) : p.replace(/^~(?=\/)/, os.homedir())));
+    const existe = (f) => { try { return fs.statSync(f).isFile(); } catch { return false; } };
+    if (!arquivos.length || !arquivos.every((f) => path.isAbsolute(f) && RE_IMAGEM.test(f) && existe(f))) return null;
+    return arquivos;
+}
+
+/* O QUE A ETIQUETA GUARDAVA, embaixo do pedido já enviado: o nome da imagem,
+   ou as primeiras linhas do texto colado e quanto falta. Na caixa a etiqueta
+   poupa espaço; depois de mandar, quem rola a conversa quer ver o que foi. */
+function guardadosNaTela(guardados, largura) {
+    const out = [];
+    for (const [et, conteudo] of guardados || []) {
+        if (et.startsWith('[Imagem')) { out.push(`⎿ ${et} ${path.basename(conteudo)}`); continue; }
+        const linhas = String(conteudo).split('\n');
+        const mostra = linhas.slice(0, 3).map((l) => truncate(l, Math.max(10, largura - et.length - 6)));
+        out.push(`⎿ ${et} ${mostra[0]}`);
+        for (const l of mostra.slice(1)) out.push(`  ${' '.repeat(et.length)} ${l}`);
+        if (linhas.length > 3) out.push(`  ${' '.repeat(et.length)} … +${linhas.length - 3} linhas`);
+    }
+    return out;
+}
+function pintarEtiquetas(s) { return String(s).replace(RE_ETIQUETA, (m) => c.brand(m) + '\x1b[38;5;254m'); }
+
+/* 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) {
+    const falta = w - visibleWidth(s);
+    return falta > 0 ? s + ' '.repeat(falta) : s;
+}
+
+/**
+ * Quebra o texto em linhas de no máximo `w` colunas, guardando de onde cada
+ * uma começa no texto cru.
+ *
+ * O deslocamento é o que faz o cursor saber em que linha da caixa ele está:
+ * sem ele, um pedido de três linhas põe o cursor sempre na primeira.
+ */
+function quebrar(texto, w) {
+    const linhas = [];
+    let inicio = 0;
+    for (const paragrafo of String(texto).split('\n')) {
+        let resto = paragrafo;
+        let base = inicio;
+        do {
+            const pedaco = resto.slice(0, w);
+            linhas.push({ texto: pedaco, de: base });
+            base += pedaco.length;
+            resto = resto.slice(w);
+        } while (resto.length > 0);
+        inicio += paragrafo.length + 1;   // +1 é o \n que separa
+    }
+    return linhas;
+}
+
+/**
+ * O quadro inteiro: caixa, menu e as duas linhas de status.
+ *
+ * @param {object} e
+ * @param {string} e.texto        o que está digitado
+ * @param {number} e.cursor       posição do cursor dentro de `texto`
+ * @param {number} e.colunas      largura do terminal
+ * @param {string} e.fantasma     sugestão esmaecida depois do cursor
+ * @param {string} e.vazio        o texto de espera, quando não há nada digitado
+ * @param {string[]} e.status     as duas linhas de baixo, já coloridas
+ * @param {object|null} e.menu    { itens: [[nome, descricao]], sel }
+ * @param {boolean} e.ocupado     o agente está trabalhando (a caixa recua)
+ * @returns {{linhas: string[], cursorLinha: number, cursorColuna: number}}
+ */
+function montar(e) {
+    const colunas = Math.max(24, Math.min(e.colunas || 80, 200));
+    /* 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);
+
+    // Em qual linha quebrada o cursor caiu. `<=` no fim de cada linha porque o
+    // cursor pode estar logo depois do último caractere dela.
+    let cursorLinha = 0;
+    let cursorColuna = 0;
+    for (let i = 0; i < linhas.length; i++) {
+        const l = linhas[i];
+        const fim = l.de + l.texto.length;
+        if (cursor >= l.de && cursor <= fim) { cursorLinha = i; cursorColuna = cursor - l.de; }
+    }
+
+    /* 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: 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 = [];
+    /* 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(linhaDoPainel(''));                 // o respiro de cima
+
+    const vazio = !String(e.texto).length;
+    linhas.forEach((l, i) => {
+        // 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.
+        if (i === linhas.length - 1 && e.fantasma && cursor === String(e.texto).length) {
+            conteudo += c.dim(e.fantasma);
+        }
+        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);
+        out.push(linhaDoPainel(' ' + marca + truncate(conteudo, w)));
+    });
+
+    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 {
+        /* Uma linha vazia entre o painel e o rodapé. Colado, o rodapé parecia
+           SOBREPOSTO ao painel em terminais de entrelinha apertada (o Orca):
+           o fundo do painel encostava nas letras da pasta. */
+        out.push('');
+        const esq = st.esquerda || '';
+        const dir = st.direita || '';
+        const sobra = largura - 2 - visibleWidth(esq) - visibleWidth(dir);
+        out.push(' ' + (sobra >= 2 ? esq + ' '.repeat(sobra) + dir : truncate(esq, largura - 2)));
+    }
+
+    // ── o menu dos comandos ──────────────────────────────────────────────
+    // 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 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];
+            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(painel(' ' + c.dim(`… e mais ${e.menu.itens.length - cabem}`), largura));
+        }
+    }
+
+    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: 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: 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, guardados = []) {
+    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));
+    const extras = guardadosNaTela(guardados, largura - PREFIXO)
+        .map((l) => painel(barra + '   ' + c.dim(truncate(l, largura - PREFIXO)), largura));
+    return [painel(barra, largura), ...linhas, ...extras, painel(barra, largura)].join('\n');
+}
+
+// ── A caixa viva ─────────────────────────────────────────────────────────
+
+class Entrada extends EventEmitter {
+    /**
+     * @param {object} op
+     * @param {()=>string[]} op.status      as duas linhas de baixo, sob demanda
+     * @param {()=>Array} op.comandos       [[nome, descrição]] para o menu e o fantasma
+     * @param {string} op.vazio             o texto de espera
+     */
+    constructor(op = {}) {
+        super();
+        this.op = op;
+        this.line = '';
+        this.cursor = 0;
+        this.historico = [];
+        this.noHistorico = -1;
+        this.rascunho = '';
+        this.menu = null;
+        this.desenhado = null;    // {linhas, cursorLinha} do último quadro
+        this.ativo = false;
+        this.suspenso = false;
+        this.ocupado = false;
+        this.fechado = false;
+        this.colando = false;
+        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/tui/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 ────────────────────────────────────────────────────
+
+    iniciar() {
+        if (this.ativo) return this;
+        this.ativo = true;
+        if (!this.tty) { this._semTerminal(); return this; }
+
+        readline.emitKeypressEvents(process.stdin);
+        try { process.stdin.setRawMode(true); } catch { /* alguns terminais recusam */ }
+        process.stdin.resume();
+
+        /* Colagem entre marcas. Sem isto, colar um texto de trinta linhas faz
+           o terminal mandar trinta Enters, e o PrimoCode dispara trinta
+           pedidos — um por linha. Com as marcas, o bloco inteiro chega como
+           texto e vira UM pedido de várias linhas. */
+        this.escreverCru('\x1b[?2004h');
+
+        this._aoTeclar = (ch, key) => this._tecla(ch, key);
+        process.stdin.on('keypress', this._aoTeclar);
+
+        this._aoRedimensionar = () => { if (this.cheia) { this._quadroAnterior = null; 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
+           escrever, e a redesenhá-la depois. Embrulhar aqui é o que evita ter
+           de trocar todas as centenas de `console.log` espalhados pelo
+           código — e, mais importante, o que evita que UM esquecido escreva
+           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) {
+                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 ────────────────────────────
+               A resposta do chat sai em fluxo: dezenas de `write` pequenos,
+               nenhum deles terminando em quebra de linha. Cada um deixa o
+               cursor NO MEIO da linha — e o desenho da caixa começa com
+               "\r\x1b[0J", que volta ao início da linha e limpa dali para
+               baixo. Ou seja: redesenhar ali apagava o pedaço que acabara de
+               ser escrito, e o seguinte apagava o próximo.
+
+               O efeito para quem usa era o pior possível: no modo chat a
+               mensagem ia, o modelo respondia, e a tela não mostrava NADA —
+               parecia que o programa tinha ignorado a pessoa.
+
+               Então a caixa espera a linha fechar. Enquanto o cursor estiver
+               no meio de uma, ela não é redesenhada; quando a quebra de linha
+               chega (o `fechar()` do fluxo manda uma), ela volta. */
+            const t = String(texto == null ? '' : texto);
+            eu._meiaLinha = t.length > 0 && !t.endsWith('\n');
+            if (!eu._meiaLinha) eu._desenhar();
+            return r;
+        };
+        return this;
+    }
+
+    /* Sem terminal de verdade (pipe, CI, `primocode "faça x"`) não há caixa
+       para desenhar nem tecla para escutar: cada linha que chega é um pedido.
+       Desenhar aqui encheria a saída de códigos de cor e de bordas. */
+    _semTerminal() {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        this._rlPipe = rl;
+        rl.on('line', (l) => this.emit('line', l));
+        rl.on('close', () => { this.fechado = true; this.emit('close'); });
+    }
+
+    close() {
+        if (this.fechado) return;
+        this.fechado = true;
+        this.parar();
+        this.emit('close');
+    }
+
+    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;
+        if (this._aoTeclar) process.stdin.removeListener('keypress', this._aoTeclar);
+        if (this._aoRedimensionar) process.stdout.removeListener('resize', this._aoRedimensionar);
+        try { process.stdin.setRawMode(false); } catch {}
+        process.stdin.pause();
+        this.ativo = false;
+    }
+
+    /* 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. */
+    /* Na tela cheia, suspender só LARGA O TECLADO: a tela continua no ar, e
+       quem suspendeu desenha pelo `painel()`. Sair da tela alternativa aqui
+       (o jeito antigo) jogava o /effort por cima do terminal velho, e a
+       volta deixava tudo bagunçado. */
+    suspender() { this.suspenso = true; if (this.cheia) this._agendar(); else this._apagar(); }
+    retomar() {
+        this.suspenso = false;
+        if (this.cheia && this.ativo && !this.fechado) { this.painelTexto = null; this._quadroAnterior = null; return this._pintar(); }
+        if (this.ativo && !this.fechado) this._desenhar();
+    }
+
+    /* UMA ESCOLHA QUE SOME depois de respondida (o /api, 13/10: "só apareça
+       pra qual modelo trocou, aquela lista enorme os números somem").
+       marcar() antes de listar, voltarPara(marca) depois: a lista, a pergunta
+       e a resposta saem da conversa, e fica só o que vier depois. Só na tela
+       cheia; no modo linha o terminal já rolou e o texto fica. */
+    marcar() { return this.cheia ? { n: this.conversa.length, ultima: this.conversa[this.conversa.length - 1] } : null; }
+    voltarPara(marca) {
+        if (!marca || !this.cheia || this.conversa.length < marca.n) return;
+        this.conversa.length = marca.n;
+        if (marca.n) this.conversa[marca.n - 1] = marca.ultima;
+        this.rolagem = 0;
+        this._quadroAnterior = null;
+        this._pintar();
+    }
+
+    /** Um comando com tela própria desenha aqui (na tela cheia). null fecha. */
+    painel(texto) {
+        this.painelTexto = texto == null ? null : String(texto).replace(/\n+$/, '');
+        this._pintar();
+    }
+
+    // ── a tela cheia ─────────────────────────────────────────────────────
+
+    /* A tela alternativa (a do vim): o que estava no terminal fica guardado e
+       volta inteiro na saída.
+
+       SEM capturar o mouse (o modo 1000 do xterm). Capturar dava a roda para rolar a
+       conversa, mas tirava do terminal o clique-e-arrasta: ninguém conseguia
+       selecionar um trecho da resposta para copiar ("na CLI não consigo
+       selecionar texto", 11/10). Selecionar vale mais que a roda: rolar fica
+       no PgUp/PgDn, e o /copy copia a resposta inteira. */
+    _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 ? tela.larguraDaConversa(eu._colunasReais) : eu._colunasReais; },
+                set(v) { eu._colunasReais = v; },   // o Node escreve aqui quando a janela muda
+            });
+        }
+        this.escreverCru('\x1b[?1049h\x1b[2J');
+        this._quadroAnterior = null;   // a tela foi limpa: o próximo quadro vai inteiro
+        if (!this._aoSairDoProcesso) {
+            // Um erro que derruba o programa não pode deixar o terminal na
+            // tela alternativa e sem cursor.
+            this._aoSairDoProcesso = () => this._sairDaTela();
+            process.on('exit', this._aoSairDoProcesso);
+        }
+    }
+
+    _sairDaTela() {
+        if (!this._naTela) return;
+        this._naTela = false;
+        /* Desliga o mouse mesmo sem ter ligado: uma versão antiga (ou um
+           crash dela) pode ter deixado o terminal capturando o clique. */
+        this.escreverCru('\x1b[?1000l\x1b[?1002l\x1b[?1003l\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/tui/tela.js). */
+    _quadroCheio() {
+        const conversa = this.conversa.some((l) => /\S/.test(l));
+        const trabalhando = !!(this.ocupado || this.spinnerTexto);
+        const quadro = Date.now() / 140;
+        /* O topo da barra da direita: o logo do PrimoCode (que anima enquanto
+           ele trabalha) e o ESTADO — trabalhando, há quanto tempo, no quê. */
+        const topo = this.op.logoAnimado ? this.op.logoAnimado(quadro, trabalhando) : [];
+        topo.push('');
+        if (trabalhando) {
+            const giro = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'][Math.floor(quadro) % 10];
+            topo.push(c.warn(giro + ' Trabalhando') + (this._desde ? c.dim(` · ${Math.floor((Date.now() - this._desde) / 1000)}s`) : ''));
+            const agora = this.op.agora ? this.op.agora() : '';
+            if (agora) topo.push(c.muted(agora));
+            if (this.spinnerTexto) topo.push(c.dim(stripAnsiLocal(this.spinnerTexto).replace(/^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]\s*/, '')));
+        } else {
+            topo.push(c.brand('● ') + c.muted('Pronto') + c.dim(' · esperando você'));
+        }
+        if (trabalhando && !this._animando) {
+            // Enquanto trabalha, a barra se redesenha sozinha (o logo anima
+            // e o relógio anda), mesmo que nada novo chegue na conversa.
+            this._animando = setInterval(() => this._pintar(), 140);
+            if (this._animando.unref) this._animando.unref();
+        } else if (!trabalhando && this._animando) { clearInterval(this._animando); this._animando = null; }
+        return tela.quadro({
+            colunas: this._colunasReais || 80,
+            linhas: process.stdout.rows || 24,
+            conversa: this.conversa,
+            rolagem: this.rolagem,
+            home: !this.mandou && !conversa && !this.painelTexto,
+            caixa: (colunas, centro) => montar({ ...this._estado(), colunas, centro, menuAcima: true }),
+            lateral: { titulo: this.titulo, topo, ...(this.op.lateral ? this.op.lateral() : {}) },
+            painel: this.painelTexto,
+            versao: this.op.versao || '',
+            logo: this.op.logo,
+            pasta: this.op.pasta ? this.op.pasta() : '',
+        });
+    }
+
+    _pintar() {
+        if (!this.cheia || this.fechado || !this._naTela) return;
+        const q = this._quadroCheio();
+        this.rolagem = Math.min(this.rolagem, q.rolagemMax);
+        /* Só reescreve a linha que MUDOU. Repintar a tela inteira a cada
+           quadro (140 ms enquanto trabalha) apagava a seleção do mouse no
+           meio do arrasto: o terminal desfaz a seleção quando a linha
+           selecionada é reescrita. A conversa parada fica intocada. */
+        const antes = this._quadroAnterior;
+        const mesmoTamanho = antes && antes.linhas.length === q.linhas.length;
+        let corpo = '';
+        q.linhas.forEach((l, i) => {
+            if (mesmoTamanho && antes.linhas[i] === l) return;
+            corpo += `\x1b[${i + 1};1H${l}\x1b[0m\x1b[K`;
+        });
+        const mesmoCursor = antes && antes.cursor.linha === q.cursor.linha && antes.cursor.coluna === q.cursor.coluna;
+        this._quadroAnterior = { linhas: q.linhas, cursor: q.cursor };
+        if (!corpo && mesmoCursor) { this.desenhado = { linhas: q.linhas, cursorLinha: q.cursor.linha }; return; }
+        const out = (corpo ? '\x1b[?25l' + corpo : '') + `\x1b[${q.cursor.linha + 1};${q.cursor.coluna + 1}H` + (corpo ? '\x1b[?25h' : '');
+        this._pintando = true;
+        this.escreverCru(out);
+        this._pintando = false;
+        this.desenhado = { linhas: q.linhas, cursorLinha: q.cursor.linha };
+    }
+
+    /* A RODA QUE VIRAVA HISTÓRICO (13 e 14/10: "quando eu tento subir o
+       histórico ele fica mostrando meus prompts"). Sem capturar o mouse (por
+       causa da seleção de texto), o terminal manda a roda como setas ↑↓. O
+       ritmo não separa as duas coisas: medido no Orca (14/10), a roda devagar
+       chega uma seta a cada 50–250 ms, e o ↑ segurado no teclado a cada 83 ms.
+       Então, na tela cheia, a seta ROLA a conversa (2 linhas), sempre; o
+       pedido anterior fica no Option+↑/↓ (ou Ctrl/Shift, o que o terminal mandar). */
+    _setaNaCheia(dir, key) {
+        // ESC ESC [A é o Option dos terminais com "Option como Meta": o Node entrega como seta pura.
+        const comOption = key && (key.meta || key.ctrl || key.shift || String(key.sequence || '').startsWith('\x1b\x1b'));
+        if (comOption) return this._historico(dir > 0 ? -1 : 1);
+        return this._rolar(dir * 2);
+    }
+
+    _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/session/runner/act.js). */
+    trabalhando(sim) {
+        if (this.ocupado === !!sim) return;
+        this.ocupado = !!sim;
+        this._desde = sim ? Date.now() : 0;
+        if (this.desenhado) this._redesenhar();
+    }
+
+    prompt() { if (!this.suspenso && this.tty && !this.fechado) this._desenhar(); }
+
+    /** O spinner (lib/tui/ui.js) desenha por aqui quando há caixa: uma linha
+     *  acima dela, redesenhada junto — nunca um "\r" solto por cima. */
+    mostrarSpinner(texto) {
+        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);
+        this._desenhar();
+    }
+
+    /** Põe texto no campo, como se tivesse sido digitado. */
+    write(texto) {
+        if (!this.tty) return;
+        this.line = this.line.slice(0, this.cursor) + texto + this.line.slice(this.cursor);
+        this.cursor += texto.length;
+        this._mudou();
+    }
+
+    limpar() { this.line = ''; this.cursor = 0; this.menu = null; this.colados = new Map(); this.nImagem = 0; this._mudou(); }
+
+    /* COLAR VIRA ETIQUETA, como no Claude Code: texto grande colado (várias
+       linhas, ou mais de 300 caracteres) entra na caixa como
+       "[Colado #1 · 42 linhas]" — a caixa não vira um paredão, dá para
+       escrever o pedido em volta, e no Enter a etiqueta volta a ser o texto
+       inteiro. O que é curto entra como texto mesmo. */
+    colar(texto) {
+        const t = String(texto || '');
+        if (!t) return;
+        if (!this.colados) this.colados = new Map();
+        /* Imagem arrastada: uma etiqueta por arquivo, e no Enter volta o caminho.
+           O contador não reaproveita número: apagar a #1 não faz a próxima repetir a #2. */
+        const imagens = imagensArrastadas(t);
+        if (imagens) {
+            const ets = imagens.map((f) => {
+                this.nImagem = (this.nImagem || 0) + 1;
+                const et = `[Imagem #${this.nImagem}]`;
+                this.colados.set(et, f);
+                return et;
+            });
+            return this.write(ets.join(' ') + (/\s$/.test(t) ? ' ' : ''));
+        }
+        const linhas = t.split('\n').length;
+        if (linhas < 3 && t.length <= 300) return this.write(t);
+        const n = [...this.colados.keys()].filter((k) => k.startsWith('[Colado')).length + 1;
+        const etiqueta = `[Colado #${n} · ${linhas > 1 ? `${linhas} linhas` : `${t.length} caracteres`}]`;
+        this.colados.set(etiqueta, t);
+        this.write(etiqueta);
+    }
+
+    /** A linha com cada etiqueta trocada pelo texto que ela guarda. */
+    expandir(linha) {
+        if (!this.colados || !this.colados.size) return linha;
+        let out = linha;
+        for (const [et, t] of this.colados) out = out.split(et).join(t);
+        return out;
+    }
+
+    /** A etiqueta que termina exatamente no cursor (o backspace apaga ela inteira). */
+    _etiquetaAntes() {
+        if (!this.colados) return null;
+        const antes = this.line.slice(0, this.cursor);
+        for (const et of this.colados.keys()) if (antes.endsWith(et)) return et;
+        return null;
+    }
+
+    /**
+     * A PRÓXIMA linha é senha: a caixa desenha `•` no lugar das letras, não
+     * repete o texto na tela ao enviar e não o guarda no histórico — senão a
+     * seta para cima devolveria a senha. Vale para uma linha só.
+     */
+    ocultarProxima() { this.oculto = true; this.menu = null; this._mudou(); }
+
+    // ── desenho ──────────────────────────────────────────────────────────
+
+    _quadro() { return montar(this._estado()); }
+
+    _estado() {
+        return ({
+            texto: this.oculto ? '•'.repeat(this.line.length) : this.line,
+            cursor: this.cursor,
+            colunas: process.stdout.columns || 80,
+            fantasma: this.oculto ? '' : this._fantasma(),
+            vazio: this.op.vazio || '',
+            status: this.op.status ? this.op.status() : [],
+            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
+           antes de desenhar. Vale para quem chama `_desenhar` por fora do
+           embrulho do stdout — `prompt()`, o fim de uma tela suspensa — e é o
+           que garante que a caixa nunca começa em cima de texto pela metade. */
+        if (this._meiaLinha) { this.escreverCru('\n'); this._meiaLinha = false; }
+        // `\x1b[0J` limpa daqui até o fim da tela: sem isso, um quadro mais
+        // curto que o anterior (menu que fechou) deixa lixo embaixo.
+        this.escreverCru('\r\x1b[0J' + q.linhas.join('\n'));
+        const paraCima = q.linhas.length - 1 - q.cursorLinha;
+        let volta = '\r';
+        if (paraCima > 0) volta += `\x1b[${paraCima}A`;
+        if (q.cursorColuna > 0) volta += `\x1b[${q.cursorColuna}C`;
+        this.escreverCru(volta);
+        this._pintando = false;
+        this.desenhado = q;
+    }
+
+    _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.
+        const acima = this.desenhado.cursorLinha;
+        this.escreverCru((acima > 0 ? `\x1b[${acima}A` : '') + '\r\x1b[0J');
+        this._pintando = false;
+        this.desenhado = null;
+    }
+
+    _redesenhar() { this._apagar(); this._desenhar(); }
+
+    _mudou() {
+        if (this.menu) this._filtrarMenu();
+        this._redesenhar();
+    }
+
+    // ── o fantasma e o menu ──────────────────────────────────────────────
+
+    _fantasma() {
+        if (this.ocupado) return '';
+        const linha = this.line;
+        if (!linha.startsWith('/') || /\s/.test(linha) || linha.length < 2) return '';
+        if (this.cursor !== linha.length) return '';
+        const lista = this.op.comandos ? this.op.comandos() : [];
+        const baixa = linha.toLowerCase();
+        const hit = lista.map(([n]) => n).find((n) => n.startsWith(baixa) && n.length > linha.length);
+        return hit ? hit.slice(linha.length) : '';
+    }
+
+    _filtrarMenu() {
+        if (this.oculto) { this.menu = null; return; }
+        const lista = this.op.comandos ? this.op.comandos() : [];
+        const baixa = this.line.toLowerCase();
+        const itens = this.line.startsWith('/') && !/\s/.test(this.line)
+            ? lista.filter(([n]) => n.startsWith(baixa))
+            : [];
+        if (!itens.length) { this.menu = null; return; }
+        const sel = this.menu ? Math.min(this.menu.sel, itens.length - 1) : 0;
+        this.menu = { itens, sel };
+    }
+
+    // ── teclado ──────────────────────────────────────────────────────────
+
+    _tecla(ch, key) {
+        if (this.suspenso || this.fechado) return;
+        const seq = (key && key.sequence) || ch || '';
+
+        // Colagem entre marcas: tudo que vier até a marca de fim é texto.
+        if (seq.includes('\x1b[200~')) { this.colando = true; this.bufColagem = ''; }
+        if (this.colando) {
+            const limpo = seq.replace('\x1b[200~', '').replace('\x1b[201~', '');
+            if (limpo) this.bufColagem += limpo.replace(/\r\n?/g, '\n');
+            if (seq.includes('\x1b[201~')) { this.colando = false; this.colar(this.bufColagem); this.bufColagem = ''; }
+            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.
+           Não ligamos mais a captura, mas um terminal que ficou com ela
+           ligada (de outro programa) não pode digitar lixo na caixa. */
+        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
+        // não sabe o que é "parar o agente" — isso é assunto do programa.
+        if (key.name === 'escape') {
+            if (this.menu) { this.menu = null; this._redesenhar(); return; }
+            this.emit('escape');
+            return;
+        }
+
+        if (key.ctrl) return this._ctrl(key);
+
+        switch (key.name) {
+            case 'return':
+            case 'enter':
+                /* Alt+Enter (e a barra invertida no fim) quebram linha em vez
+                   de mandar. É o que deixa escrever um pedido de parágrafo
+                   sem ele sair pela metade no primeiro Enter. */
+                if (key.meta) return this._novaLinha();
+                if (this.line.endsWith('\\')) {
+                    this.line = this.line.slice(0, -1);
+                    this.cursor = Math.max(0, this.cursor - 1);
+                    return this._novaLinha();
+                }
+                return this._enviar();
+
+            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(); }
+                return;
+            }
+
+            case 'backspace': {
+                const et = this._etiquetaAntes();
+                if (et) {
+                    this.line = this.line.slice(0, this.cursor - et.length) + this.line.slice(this.cursor);
+                    this.cursor -= et.length;
+                    this.colados.delete(et);
+                    return this._mudou();
+                }
+            }
+                if (this.cursor > 0) {
+                    this.line = this.line.slice(0, this.cursor - 1) + this.line.slice(this.cursor);
+                    this.cursor--;
+                    this._mudou();
+                }
+                return;
+
+            case 'delete':
+                if (this.cursor < this.line.length) {
+                    this.line = this.line.slice(0, this.cursor) + this.line.slice(this.cursor + 1);
+                    this._mudou();
+                }
+                return;
+
+            case 'left':  if (this.cursor > 0) { this.cursor--; this._redesenhar(); } return;
+            case 'right': {
+                // No fim da linha, a seta direita aceita a sugestão inteira —
+                // era assim antes da caixa, e o dedo de quem usa já sabe.
+                const f = this._fantasma();
+                if (f) return this.write(f);
+                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;
+
+            case 'up':
+                if (this.menu) { this.menu.sel = Math.max(0, this.menu.sel - 1); return this._redesenhar(); }
+                if (this.cheia) return this._setaNaCheia(1, key);
+                return this._historico(-1);
+            case 'down':
+                if (this.menu) {
+                    this.menu.sel = Math.min(this.menu.itens.length - 1, this.menu.sel + 1);
+                    return this._redesenhar();
+                }
+                if (this.cheia) return this._setaNaCheia(-1, key);
+                return this._historico(1);
+
+            default:
+                if (seq && !key.meta && seq >= ' ' && seq !== '\x7f') this.write(seq);
+        }
+    }
+
+    _ctrl(key) {
+        switch (key.name) {
+            case 'up': return this.cheia ? this._setaNaCheia(1, key) : this._historico(-1);
+            case 'down': return this.cheia ? this._setaNaCheia(-1, key) : this._historico(1);
+            case 'c':
+                // Com texto no campo, Ctrl+C limpa o que foi digitado — sair
+                // por acidente no meio de um pedido longo é perder o pedido.
+                if (this.line) return this.limpar();
+                this.emit('sigint');
+                return;
+            case 'd':
+                if (!this.line) return this.close();
+                return;
+            case 'u': this.line = this.line.slice(this.cursor); this.cursor = 0; return this._mudou();
+            case 'k': this.line = this.line.slice(0, this.cursor); return this._mudou();
+            case 'a': this.cursor = 0; return this._redesenhar();
+            case 'e': this.cursor = this.line.length; return this._redesenhar();
+            case 'w': {
+                const antes = this.line.slice(0, this.cursor).replace(/\s*\S+$/, '');
+                const depois = this.line.slice(this.cursor);
+                this.line = antes + depois;
+                this.cursor = antes.length;
+                return this._mudou();
+            }
+            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;
+        }
+    }
+
+    _novaLinha() {
+        this.line = this.line.slice(0, this.cursor) + '\n' + this.line.slice(this.cursor);
+        this.cursor++;
+        this._mudou();
+    }
+
+    _escolherDoMenu() {
+        const [nome] = this.menu.itens[this.menu.sel];
+        this.line = nome;
+        this.cursor = nome.length;
+        this.menu = null;
+        this._redesenhar();
+    }
+
+    _historico(passo) {
+        if (!this.historico.length) return;
+        if (this.noHistorico === -1) {
+            if (passo > 0) return;
+            this.rascunho = this.line;
+            this.noHistorico = this.historico.length;
+        }
+        const i = this.noHistorico + passo;
+        if (i >= this.historico.length) {
+            this.noHistorico = -1;
+            this.line = this.rascunho;
+        } else if (i < 0) {
+            return;
+        } else {
+            this.noHistorico = i;
+            this.line = this.historico[i];
+        }
+        this.cursor = this.line.length;
+        this._redesenhar();
+    }
+
+    _enviar() {
+        if (this.menu) return this._escolherDoMenu();
+        const visto = this.line;
+        const texto = this.expandir(visto);
+        const guardados = [...(this.colados || [])].filter(([et]) => visto.includes(et));
+        this.colados = new Map();
+        this.nImagem = 0;
+        const oculto = this.oculto;
+        this.oculto = false;
+        this.line = '';
+        this.cursor = 0;
+        this.menu = null;
+        this.noHistorico = -1;
+
+        /* O que foi mandado sai da caixa e vira linha do histórico da tela —
+           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) {
+            // 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;
+                /* Uma linha em branco antes e outra depois do pedido: cada
+                   troca (pedido, resposta) é um bloco separado na tela. */
+                const temAlgo = this.conversa.some((l) => /\S/.test(l));
+                const ultima = this.conversa[this.conversa.length - 1] || '';
+                const antes = !temAlgo ? '' : /\S/.test(ultima) ? '\n\n' : '\n';
+                tela.acrescentar(this.conversa, antes + pedidoNaTela(visto, mainW - 1, guardados) + '\n\n');
+            } else this.escreverCru(pedidoNaTela(visto, process.stdout.columns || 80, guardados) + '\n');
+            if (this.historico[this.historico.length - 1] !== texto) this.historico.push(texto);
+        }
+        this._desenhar();
+        this.emit('line', texto);
+    }
+}
+
+function criar(op) { return new Entrada(op).iniciar(); }
+
+module.exports = { criar, Entrada, montar, quebrar, encher, pintarEtiquetas, painel, pedidoNaTela, imagensArrastadas, PREFIXO, COR };