primocode 11.0.0 → 11.1.0

package/lib/ui.js

@@ -1,763 +0,0 @@
-/**
- * UI components — estilo Claude Code
- */
-
-'use strict';
-
-
-// ── Paleta ───────────────────────────────────────────────────────────────
-// Vem do design system do produto (product-plan/design-system): primária cyan,
-// secundária amber, neutra slate, e rose para falha de ação. Os números são o
-// vizinho mais próximo de cada degrau do Tailwind no cubo de 256 cores do
-// terminal, calculado com peso perceptual — não escolhido a olho.
-//
-//   brand    cyan-400   #22d3ee → 45     o que foi apurado, confirmado
-//   brandDim cyan-600   #0891b2 → 31     a mesma cor recuando
-//   white    slate-200  #e2e8f0 → 254    texto
-//   muted    slate-400  #94a3b8 → 247    texto secundário
-//   dim      slate-500  #64748b → 243    borda, apoio
-//   warn     amber-400  #fbbf24 → 214    aviso que não é falha
-//   err      rose-400   #fb7185 → 204    falha de ação
-//
-// O terminal é fundo escuro, então os degraus usados são os da coluna `dark:`
-// da tabela de contraste validada do design system.
-const PALETTE = {
-    brand:      '\x1b[38;5;45m',
-    brandDim:   '\x1b[38;5;31m',
-    white:      '\x1b[38;5;254m',
-    muted:      '\x1b[38;5;247m',
-    dim:        '\x1b[38;5;243m',
-    ok:         '\x1b[38;5;45m',
-    warn:       '\x1b[38;5;214m',
-    err:        '\x1b[38;5;204m',
-    magenta:    '\x1b[38;5;214m',
-    cyan:       '\x1b[38;5;45m',
-    bold:       '\x1b[1m',
-    reset:      '\x1b[0m',
-};
-
-const c = {
-    ...PALETTE,
-    brand: (s) => `${PALETTE.brand}${s}${PALETTE.reset}`,
-    brandDim: (s) => `${PALETTE.brandDim}${s}${PALETTE.reset}`,
-    white: (s) => `${PALETTE.white}${s}${PALETTE.reset}`,
-    muted: (s) => `${PALETTE.muted}${s}${PALETTE.reset}`,
-    dim: (s) => `${PALETTE.dim}${s}${PALETTE.reset}`,
-    ok: (s) => `${PALETTE.ok}${s}${PALETTE.reset}`,
-    warn: (s) => `${PALETTE.warn}${s}${PALETTE.reset}`,
-    err: (s) => `${PALETTE.err}${s}${PALETTE.reset}`,
-    magenta: (s) => `${PALETTE.magenta}${s}${PALETTE.reset}`,
-    cyan: (s) => `${PALETTE.cyan}${s}${PALETTE.reset}`,
-    bold: (s) => `${PALETTE.bold}${s}${PALETTE.reset}`,
-};
-
-// ── Mascotes ─────────────────────────────────────────────────────────────
-// O mascote é um bloco fixo de 3 linhas × 9 colunas. Tamanho fixo porque ele
-// não fica sozinho: as três linhas de identidade do cabeçalho (nome, saudação,
-// pasta) sentam ao lado dele, uma por linha do desenho. Mudar a altura
-// desalinha o cabeçalho inteiro.
-//
-// Só glifos de bloco (U+2580–U+259F): largura 1 garantida em qualquer terminal
-// monospace, sem emoji e sem depender de fonte instalada.
-//
-// Primo, raposa e gato compartilham corpo e pés — são o mesmo bicho de
-// orelhas diferentes. Os que chegaram depois ("mais mascotes", pedido do
-// dono) têm silhueta própria: um robô de corpo de gato não seria um robô.
-//
-// As cores saem SÓ do PALETTE. `full` pinta o bloco cheio, `edge` o contorno;
-// a `mascara` (opcional, uma letra por coluna) marca o que foge da regra —
-// olho (`o`), acento (`a`), corpo (`c`), borda (`b`). É por ela que o olho do
-// robô acende na primária e a barriga do pinguim fica clara, sem inventar cor.
-//
-// Cada um tem nome, bordão (aparece na saudação) e um rostinho por humor, que
-// sai numa linha discreta depois da resposta do agente (/mascot reacoes off
-// desliga). Rosto em ASCII/Unicode de largura 1 — emoji ocupa duas colunas e
-// muda de desenho de um terminal para outro.
-
-const ART_W = 9;    // colunas de cada linha do desenho
-const ART_H = 3;    // linhas — igual ao número de linhas de identidade
-
-const CORPO = '▝▜█████▛▘';
-const PES   = '  ▘▘ ▝▝  ';
-
-const MASCOTS = {
-    // Padrão: o Primo — cabeça cheia, ombros marcados, dois pezinhos.
-    primo: {
-        nome: 'Primo', frase: 'Bora construir junto?',
-        linhas: [' ▐▛███▜▌ ', CORPO, PES], full: 'brand', edge: 'brandDim',
-        rosto: { feliz: '(^‿^)', preocupado: '(°_°)', parado: '(-_-)' },
-    },
-    // Raposa — orelhas largas, abertas para fora. Na secundária do sistema.
-    fox: {
-        nome: 'Raposa', frase: 'Esperta e rápida no código.',
-        linhas: [' ▛▀   ▀▜ ', CORPO, PES], full: 'warn', edge: 'dim',
-        rosto: { feliz: '(^ᴥ^)', preocupado: '(•ᴥ•;)', parado: '(-ᴥ-)' },
-    },
-    // Gato — orelhas curtas e juntas. Primária recuada, para não repetir o Primo.
-    cat: {
-        nome: 'Gato', frase: 'Curioso até achar o bug.',
-        linhas: [' ▛▘   ▝▜ ', CORPO, PES], full: 'brandDim', edge: 'dim',
-        rosto: { feliz: '(=^.^=)', preocupado: '(=°.°=)', parado: '(=-.-=)' },
-    },
-    // Robô — antena, cabeça quadrada e os dois olhos acesos na primária.
-    // Corpo em slate: é metal, e metal é neutro.
-    robo: {
-        nome: 'Bip', frase: 'Bip-bop: pedido entendido.',
-        linhas: [' ▗▄▄█▄▄▖ ', ' ▐█████▌ ', '  █▀▀▀█  '],
-        mascara: ['  ccccc  ', '   o o   ', '         '],
-        full: 'muted', edge: 'dim', olho: 'brand',
-        rosto: { feliz: '[^_^]', preocupado: '[o_O]', parado: '[-_-]' },
-    },
-    // Coruja — os tufos em cima e dois olhões claros. Na secundária: é a
-    // cor do "aviso que não é falha", e a coruja é a que pensa antes.
-    coruja: {
-        nome: 'Sábia', frase: 'Pensa antes, erra menos.',
-        linhas: [' █▄▄▄▄▄█ ', ' ███▄███ ', ' ▝█▀▀▀█▘ '],
-        mascara: [' ccccccc ', '  oo oo  ', '         '],
-        full: 'warn', edge: 'dim', olho: 'white',
-        rosto: { feliz: '(O,O)', preocupado: '(o,O)', parado: '(-,-)' },
-    },
-    // Dragão — chifres para fora, asinhas nos lados e o rabo à direita.
-    // Chifres na secundária, corpo na primária.
-    dragao: {
-        nome: 'Faísca', frase: 'Bota fogo no projeto!',
-        linhas: ['▝▙▗▄▄▄▖▟▘', '▗▟█████▙▖', ' ▝█▀▀▀█▙▖'],
-        mascara: ['aa     aa', 'a  o o  a', '         '],
-        full: 'brand', edge: 'brandDim', olho: 'white', acento: 'warn',
-        rosto: { feliz: '<^w^>', preocupado: '<°w°;>', parado: '<-w->' },
-    },
-    // Fantasma — cúpula, dois olhos vazados e a barra ondulada embaixo.
-    fantasma: {
-        nome: 'Boo', frase: 'Some com os bugs sem fazer barulho.',
-        linhas: [' ▗▟███▙▖ ', ' ██▄█▄██ ', ' ▛▚▟▀▙▞▜ '],
-        mascara: ['         ', '   c c   ', '         '],
-        full: 'white', edge: 'muted',
-        rosto: { feliz: '(^o^)~', preocupado: '(°o°)~', parado: '(-o-)~' },
-    },
-    // Capivara — de perfil: orelhinha, focinho reto, corpo comprido e as
-    // perninhas curtas. A brasileira da turma, na secundária (o mais perto do
-    // marrom que a paleta tem).
-    capivara: {
-        nome: 'Capi', frase: 'Na calma, tudo sai.',
-        linhas: ['  ▗▖     ', '▗█▀█▄▄▄▄▖', '▝▀█▀▀▀█▀ '],
-        mascara: ['  bb     ', '  o cccc', '         '],
-        full: 'warn', edge: 'dim', olho: 'dim',
-        rosto: { feliz: '(•ᴗ•)', preocupado: '(•_•;)', parado: '(-ᴗ-)' },
-    },
-    // Polvo — cabeça redonda, olhos vazados e os braços abertos embaixo.
-    polvo: {
-        nome: 'Polvinho', frase: 'Oito braços, várias tarefas.',
-        linhas: ['  ▟███▙  ', ' ▐█▄█▄█▌ ', '▗▛▐▘█▝▌▜▖'],
-        full: 'brandDim', edge: 'brandDim',
-        rosto: { feliz: '~(^u^)~', preocupado: '~(°u°)~', parado: '~(-u-)~' },
-    },
-    // Pinguim — cabeça escura, bico na secundária, barriga clara e os pés.
-    pinguim: {
-        nome: 'Gelinho', frase: 'Cabeça fria, código limpo.',
-        linhas: ['  ▟▀█▀▙  ', ' ▟█████▙ ', ' ▝▀▘ ▝▀▘ '],
-        mascara: ['    a    ', '   ooo   ', ' aaa aaa '],
-        full: 'dim', edge: 'dim', olho: 'white', acento: 'warn',
-        rosto: { feliz: '<(^v^)>', preocupado: '<(°v°)>', parado: '<(-v-)>' },
-    },
-};
-
-// A ordem da galeria e dos números do /mascot. Os três de sempre primeiro:
-// quem escolheu o gato ontem acha ele no mesmo lugar hoje.
-const MASCOTES = Object.keys(MASCOTS);
-
-// Quem digita em português escreve "raposa", "robô", "dragão".
-const APELIDOS_MASCOTE = {
-    raposa: 'fox', gato: 'cat', robô: 'robo', robot: 'robo', dragão: 'dragao', dragon: 'dragao',
-    owl: 'coruja', ghost: 'fantasma', capybara: 'capivara', capi: 'capivara', octopus: 'polvo',
-    penguin: 'pinguim', bip: 'robo', boo: 'fantasma', sabia: 'coruja', sábia: 'coruja',
-    faisca: 'dragao', faísca: 'dragao', polvinho: 'polvo', gelinho: 'pinguim',
-};
-
-/** Nome, apelido ou número (1-based) → id do mascote. null se não existe. */
-function resolverMascote(pedido) {
-    const t = String(pedido == null ? '' : pedido).trim().toLowerCase();
-    if (!t) return null;
-    if (/^\d+$/.test(t)) return MASCOTES[Number(t) - 1] || null;
-    if (MASCOTS[t]) return t;
-    return APELIDOS_MASCOTE[t] || null;
-}
-
-function mascoteInfo(style) {
-    const id = MASCOTS[style] ? style : 'primo';
-    const m = MASCOTS[id];
-    return { id, nome: m.nome, frase: m.frase, rosto: { ...m.rosto } };
-}
-
-// Bloco cheio na cor viva, contorno na apagada: dá volume ao desenho sem
-// precisar de gradiente nem de cor de fundo. A máscara ganha da regra.
-const PAPEL = { c: 'full', b: 'edge', o: 'olho', a: 'acento' };
-function shade(line, m, mascara) {
-    let out = '';
-    const letras = [...(mascara || '')];
-    [...line].forEach((ch, i) => {
-        if (ch === ' ') { out += ch; return; }
-        const papel = PAPEL[letras[i]];
-        const cor = (papel && m[papel]) || ((ch === '█' || ch === '▀') ? m.full : m.edge);
-        out += c[cor](ch);
-    });
-    return out;
-}
-
-function mascot(style) {
-    const m = MASCOTS[style] || MASCOTS.primo;
-    return m.linhas.map((l, i) => shade(l, m, m.mascara && m.mascara[i]));
-}
-
-/**
- * A galeria do /mascot: todos lado a lado, com o número e o nome em cima.
- * Célula de 13 colunas ("● 10 pinguim" + folga); quantas cabem por fileira
- * sai da largura do terminal, então 80 colunas dá seis por fileira.
- */
-function galeriaMascotes(atual, colunas) {
-    const CEL = 13;
-    const cols = Math.max(CEL + 2, Math.min(colunas || process.stdout.columns || 80, 120));
-    const porFileira = Math.max(1, Math.floor((cols - 2) / CEL));
-    const out = [];
-    for (let i = 0; i < MASCOTES.length; i += porFileira) {
-        const grupo = MASCOTES.slice(i, i + porFileira);
-        const rotulo = grupo.map((id, j) => {
-            const txt = `${i + j + 1} ${id}`;
-            return id === atual ? padRight(c.brand('● ' + txt), CEL) : padRight(c.muted('  ' + txt), CEL);
-        }).join('');
-        out.push('  ' + rotulo.replace(/\s+$/, ''));
-        for (let l = 0; l < ART_H; l++) {
-            out.push(('  ' + grupo.map((id) => '  ' + mascot(id)[l] + '  ').join('')).replace(/\s+$/, ''));
-        }
-        out.push('');
-    }
-    return out.join('\n');
-}
-
-/* A reação depois da resposta do agente: o rostinho e uma palavra. Uma linha,
-   cor apagada — é tempero, não aviso. O humor sai do que aconteceu:
-   terminou (feliz), parou sem concluir (preocupado), a pessoa mandou parar
-   (parado). Cor segue função: primária para o que deu certo, secundária para
-   o que pede atenção. */
-const DITO = { feliz: 'pronto!', preocupado: 'não terminei tudo, dá uma olhada', parado: 'parei aqui' };
-function reacao(style, humor) {
-    const m = MASCOTS[style] || MASCOTS.primo;
-    const h = m.rosto[humor] ? humor : 'feliz';
-    const cor = h === 'feliz' ? 'brand' : h === 'preocupado' ? 'warn' : 'muted';
-    return `  ${c[cor](m.rosto[h])} ${c.dim(m.nome + ': ' + DITO[h])}`;
-}
-
-// ── Medição de largura ───────────────────────────────────────────────────
-// Alinhar caixa em terminal exige contar colunas VISÍVEIS: os códigos ANSI
-// não ocupam espaço, e emoji/CJK ocupam duas colunas. Usar .length desalinha.
-
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
-
-const stripAnsi = (s) => String(s).replace(ANSI_RE, '');
-
-function charWidth(cp) {
-    if (cp === 0x200d) return 0;                       // zero-width joiner
-    if (cp >= 0xfe00 && cp <= 0xfe0f) return 0;        // seletores de variação
-    if (cp >= 0x0300 && cp <= 0x036f) return 0;        // acentos combinantes
-    if (
-        (cp >= 0x1100 && cp <= 0x115f) ||
-        (cp >= 0x2e80 && cp <= 0xa4cf) ||
-        (cp >= 0xac00 && cp <= 0xd7a3) ||
-        (cp >= 0xf900 && cp <= 0xfaff) ||
-        (cp >= 0xfe30 && cp <= 0xfe6f) ||
-        (cp >= 0xff00 && cp <= 0xff60) ||
-        (cp >= 0xffe0 && cp <= 0xffe6) ||
-        (cp >= 0x1f300 && cp <= 0x1f64f) ||            // emoji
-        (cp >= 0x1f900 && cp <= 0x1f9ff) ||
-        (cp >= 0x1f680 && cp <= 0x1f6ff)
-    ) return 2;
-    return 1;
-}
-
-function visibleWidth(s) {
-    let w = 0;
-    for (const ch of stripAnsi(s)) w += charWidth(ch.codePointAt(0));
-    return w;
-}
-
-// Corta preservando os códigos ANSI (senão a cor "vaza" para o resto da linha).
-function truncate(s, max) {
-    if (visibleWidth(s) <= max) return s;
-    const str = String(s);
-    let out = '', w = 0, i = 0;
-    while (i < str.length) {
-        ANSI_RE.lastIndex = i;
-        const m = ANSI_RE.exec(str);
-        if (m && m.index === i) { out += m[0]; i += m[0].length; continue; }
-        const ch = String.fromCodePoint(str.codePointAt(i));
-        const cw = charWidth(ch.codePointAt(0));
-        if (w + cw > max - 1) break;
-        out += ch; w += cw; i += ch.length;
-    }
-    return out + PALETTE.reset + PALETTE.dim + '…' + PALETTE.reset;
-}
-
-const padRight = (s, w) => s + ' '.repeat(Math.max(0, w - visibleWidth(s)));
-
-// ── O convite da caixa ───────────────────────────────────────────────────
-// Como no OpenCode ("Ask anything… \"Fix a TODO\""): a caixa vazia mostra um
-// exemplo de pedido. Um por abertura, sorteado, para quem chega aprender o
-// que dá para pedir sem ler lista nenhuma.
-const EXEMPLOS = [
-    'um vídeo 3D de dois personagens conversando',
-    'um site de portfólio com animação no scroll',
-    'um motion de 20 segundos explicando o que é API',
-    'clona github.com/vercel/next.js e me explica a pasta app',
-    'tira o logo do site x.com com o fundo transparente',
-];
-function convite() {
-    return `Peça qualquer coisa… "${EXEMPLOS[Math.floor(Math.random() * EXEMPLOS.length)]}"`;
-}
-
-// ── Cabeçalho ────────────────────────────────────────────────────────────
-// O desenho do OpenCode, que é a referência pedida: o nome grande no meio da
-// tela, em letra de pixel, com a primeira metade apagada e a segunda acesa —
-// e nada mais. Dicas, novidades e o mascote saíram da abertura: ao lado da
-// caixa de digitar no centro, qualquer texto a mais é o que o olho lê
-// primeiro, e o que se quer que ele leia é a caixa.
-//
-// A letra é um bitmap de 8 linhas de pixel, juntadas de duas em duas com os
-// meios-blocos ▀ ▄ █: 4 linhas de terminal, largura 1 garantida em qualquer
-// fonte. Linha 0 é a haste de cima (d, pingo do i), 1–5 o corpo, 6 a perna
-// do p.
-const LETRAS = {
-    p: ['    ', '####', '#  #', '#  #', '####', '#   ', '#   ', '    '],
-    r: ['    ', '####', '#   ', '#   ', '#   ', '#   ', '    ', '    '],
-    i: ['#', ' ', '#', '#', '#', '#', ' ', ' '],
-    m: ['     ', '#####', '# # #', '# # #', '# # #', '# # #', '     ', '     '],
-    o: ['    ', '####', '#  #', '#  #', '#  #', '####', '    ', '    '],
-    c: ['    ', '####', '#   ', '#   ', '#   ', '####', '    ', '    '],
-    d: ['   #', '####', '#  #', '#  #', '#  #', '####', '    ', '    '],
-    e: ['    ', '####', '#  #', '####', '#   ', '####', '    ', '    '],
-};
-
-/** Uma palavra em letra de pixel: 4 linhas de texto, sem cor. */
-function letreiro(palavra) {
-    const px = [];
-    for (let y = 0; y < 8; y++) px.push([...palavra].map((ch) => LETRAS[ch][y]).join(' '));
-    const out = [];
-    for (let y = 0; y < 8; y += 2) {
-        let l = '';
-        for (let x = 0; x < px[y].length; x++) {
-            const a = px[y][x] === '#', b = px[y + 1][x] === '#';
-            l += a && b ? '█' : a ? '▀' : b ? '▄' : ' ';
-        }
-        out.push(l);
-    }
-    return out;
-}
-
-/** O logo: "primo" apagado e "code" aceso, lado a lado. */
-function logo() {
-    const a = letreiro('primo'), b = letreiro('code');
-    return a.map((l, i) => `\x1b[38;5;244m${l}${PALETTE.reset} ${PALETTE.bold}\x1b[38;5;255m${b[i]}${PALETTE.reset}`);
-}
-const LOGO_W = visibleWidth(logo()[0]);
-
-/* ── O mascote GRANDE ─────────────────────────────────────────────────
-   O desenho de sempre tem 3 linhas — pequeno ao lado do logo de 4. Para a
-   home ele cresce 2×: cada quarto de bloco (▘ ▝ ▖ ▗) vira um bloco cheio, e
-   cada bloco cheio vira 2×2. Ficam 6 linhas × 18 colunas, com a cor de cada
-   pedaço preservada — o mesmo desenho, não um desenho novo. */
-const QUARTOS = {
-    ' ': [0, 0, 0, 0], '█': [1, 1, 1, 1], '▀': [1, 1, 0, 0], '▄': [0, 0, 1, 1],
-    '▌': [1, 0, 1, 0], '▐': [0, 1, 0, 1], '▘': [1, 0, 0, 0], '▝': [0, 1, 0, 0],
-    '▖': [0, 0, 1, 0], '▗': [0, 0, 0, 1], '▛': [1, 1, 1, 0], '▜': [1, 1, 0, 1],
-    '▙': [1, 0, 1, 1], '▟': [0, 1, 1, 1], '▚': [1, 0, 0, 1], '▞': [0, 1, 1, 0],
-};
-function mascoteGrande(style) {
-    const saida = [];
-    for (const linha of mascot(style)) {
-        // [caractere, cor] de cada coluna da linha colorida
-        const cels = [];
-        let cor = '';
-        for (const m of linha.matchAll(/(\x1b\[[0-9;]*m)|([^\x1b])/gu)) {
-            if (m[1]) { if (m[1] !== PALETTE.reset) cor = m[1]; continue; }
-            cels.push([m[2], cor]);
-        }
-        const cima = [], baixo = [];
-        for (const [ch, cr] of cels) {
-            const q = QUARTOS[ch] || (ch === ' ' ? QUARTOS[' '] : QUARTOS['█']);
-            const bloco = (b) => (b ? `${cr}█${PALETTE.reset}` : ' ');
-            cima.push(bloco(q[0]) + bloco(q[1]));
-            baixo.push(bloco(q[2]) + bloco(q[3]));
-        }
-        saida.push(cima.join(''), baixo.join(''));
-    }
-    while (saida.length && !saida[saida.length - 1].trim()) saida.pop();   // a linha vazia de baixo
-    return saida;
-}
-
-/** O logo da home: o mascote grande e, centrado na altura dele, o letreiro. */
-function logoComMascote(style) {
-    const m = mascoteGrande(style);
-    const l = logo();
-    const desce = Math.floor((m.length - l.length) / 2);
-    const linhas = m.map((linha, i) => linha + '    ' + (l[i - desce] || ''));
-    // Todas com a MESMA largura: a home centraliza linha por linha, e uma
-    // linha mais curta (a dos pés) sairia deslocada do resto do desenho.
-    const larg = Math.max(...linhas.map(visibleWidth));
-    return linhas.map((x) => x + ' '.repeat(larg - visibleWidth(x)));
-}
-
-/* ── O logo animado da barra da direita ──────────────────────────────────
-   Enquanto o Primo trabalha, o mascote pulsa (a cor viva respira entre três
-   tons de ciano), os pés andam, e um brilho corre pelo nome "PrimoCode".
-   Parado, fica quieto: animação sem trabalho é ruído. `quadro` é um número
-   que cresce com o tempo (o chamador passa Date.now()/120). */
-const PULSO = ['\x1b[38;5;45m', '\x1b[38;5;51m', '\x1b[38;5;87m', '\x1b[38;5;51m'];
-function logoAnimado(style, quadro, trabalhando) {
-    const f = Math.floor(quadro || 0);
-    const m = MASCOTS[style] || MASCOTS.primo;
-    // Os pés andam: a linha dos pés troca de passo a cada quadro.
-    const linhas = m.linhas.map((l) => (trabalhando && f % 2 && l === PES ? '  ▝▘ ▘▝  ' : l));
-    let art = linhas.map((l, i) => shade(l, m, m.mascara && m.mascara[i]));
-    if (trabalhando) art = art.map((l) => l.split(PALETTE.brand).join(PULSO[f % PULSO.length]));
-    const nome = 'PrimoCode';
-    const brilho = f % (nome.length + 8);
-    let texto = '';
-    [...nome].forEach((ch, i) => {
-        const base = i < 5 ? '\x1b[38;5;255m' : '\x1b[38;5;45m';
-        const aceso = trabalhando && Math.abs(i - brilho) <= 0;
-        const perto = trabalhando && Math.abs(i - brilho) === 1;
-        texto += (aceso ? '\x1b[1m\x1b[38;5;231m' : perto ? '\x1b[1m\x1b[38;5;159m' : '\x1b[1m' + base) + ch + PALETTE.reset;
-    });
-    return [art[0], art[1] + '  ' + texto, art[2]];
-}
-
-/** Centraliza uma linha (com cor) em `cols` colunas. */
-function centro(s, cols) {
-    return ' '.repeat(Math.max(0, Math.floor((cols - visibleWidth(s)) / 2))) + s;
-}
-
-function welcomeBox(version, contexto, opts = {}) {
-    const { pastaPadrao } = opts;
-    const cols = Math.max(32, Math.min(process.stdout.columns || 100, 200));
-    const out = [''];
-
-    if (cols >= LOGO_W + 2) out.push(...logo().map((l) => centro(l, cols)));
-    else out.push(centro(`${c.dim('primo')}${c.bold(c.white('code'))}`, cols));
-
-    /* A pasta só fala quando é a padrão. Era o que mais confundia quem usa
-       ("onde ele salvou?"), e é aviso, não falha: âmbar, uma linha. Quando foi
-       a pessoa que escolheu, a pasta já está no rodapé da caixa. */
-    out.push('');
-    if (contexto && pastaPadrao) out.push(centro(`${c.warn(contexto)}${c.dim('  · /dir <pasta> muda')}`, cols));
-    out.push(centro(c.dim('v' + version), cols));
-    out.push('');
-    return out.join('\n');
-}
-
-/* As frases que giram enquanto o Primo trabalha. Trocam sozinhas a cada
-   poucos segundos, em ordem, e NENHUMA fala de limite, cota, modelo ou espera
-   — de propósito: a mesma lista cobre o pensamento comum e a janela do minuto
-   que estourou. Quem olha não distingue um do outro, e é isso que o dono
-   pediu ("nunca mostrar limitações tipo limite do minuto, tudo deve ocorrer
-   ocultamente"). */
-const PENSANDO = ['Primo Code pensando', 'organizando as ideias', 'juntando as peças', 'revendo o caminho', 'pensando no próximo passo'];
-
-/* O que vai depois do texto do spinner: os segundos (de 3 s em diante) e o que está chegando. Passou de 60 s sem
-   nada chegando, diz que o modelo está lento e como parar: o /new de 23/10 ficou 207 s "pensando" calado, e
-   parecia travado. Puro. */
-function extraDoSpinner(seg, detalhe, doModelo = false) {
-    if (detalhe) return (seg >= 3 ? ` · ${seg}s` : '') + ` · ${detalhe}`;
-    if (doModelo && seg >= 60) return ` · ${seg}s · o modelo está lento agora · esc esc para`;
-    return seg >= 3 ? ` · ${seg}s` : '';
-}
-
-class Spinner {
-    constructor(text='pensando') {
-        this.textos = Array.isArray(text) ? text : [text];
-        this.text = this.textos[0];
-        this.frames = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
-        this.i = 0; this.timer = null; this.desde = 0; this.largura = 0;
-        this.detalhe = '';   // o que está chegando agora (act.js atualiza)
-        this.doModelo = text === PENSANDO;   // só a espera do modelo ganha o aviso de lento (render longo não é lentidão)
-    }
-    start() {
-        // Fora de um terminal (pipe, CI) a animação só sujaria a saída.
-        if (!process.stdout.isTTY) return this;
-        this.desde = Date.now();
-        /* Com a caixa de digitar no ar, o spinner desenha DENTRO dela (ver
-           mostrarSpinner em lib/entrada.js): escrever "\r" por cima apagava
-           a caixa e a barra de status enquanto ele girava. */
-        const caixa = Spinner.caixa;
-        if (caixa && caixa.mostrarSpinner && caixa.desenhado !== undefined) {
-            this.naCaixa = caixa;
-            this.timer = setInterval(() => {
-                if (this.textos.length > 1) this.text = this.textos[Math.floor((Date.now() - this.desde) / 4000) % this.textos.length];
-                const seg = Math.floor((Date.now() - this.desde) / 1000);
-                const extra = extraDoSpinner(seg, this.detalhe, this.doModelo);
-                caixa.mostrarSpinner(`${c.muted(this.frames[this.i])} ${c.muted(this.text)}${c.dim(extra)}`);
-                this.i = (this.i + 1) % this.frames.length;
-            }, 120);
-            return this;
-        }
-        this.timer = setInterval(() => {
-            // Com mais de uma frase, troca a cada 4s. A frase nova pode ser mais
-            // curta que a anterior: o resto da linha velha ficaria na tela, então
-            // a linha é sempre preenchida até a maior largura já escrita.
-            if (this.textos.length > 1) this.text = this.textos[Math.floor((Date.now() - this.desde) / 4000) % this.textos.length];
-            /* O relógio e o que está chegando. "Parece travado" era isto: a
-               mesma frase girando por um minuto inteiro enquanto o modelo
-               escrevia um arquivo grande. Com os segundos contando (e o que
-               já chegou, quando há), quem olha sabe que está andando. */
-            const seg = Math.floor((Date.now() - this.desde) / 1000);
-            const extra = extraDoSpinner(seg, this.detalhe, this.doModelo);
-            const cru = `  ${this.frames[this.i]} ${this.text}${extra}`;
-            const falta = Math.max(0, this.largura - cru.length);
-            this.largura = Math.max(this.largura, cru.length);
-            process.stdout.write(`\r  ${c.muted(this.frames[this.i])} ${c.muted(this.text)}${c.dim(extra)}${' '.repeat(falta)}`);
-            this.i = (this.i+1) % this.frames.length;
-        }, 80);
-        return this;
-    }
-    stop() {
-        if (this.naCaixa) {
-            if (this.timer) { clearInterval(this.timer); this.timer = null; }
-            this.naCaixa.mostrarSpinner('');
-            this.naCaixa = null;
-            return;
-        }
-        if (this.timer) { clearInterval(this.timer); this.timer = null; process.stdout.write(`\r${' '.repeat(Math.max(80, this.largura + 4))}\r`); }
-    }
-}
-
-/* O TÍTULO DO TERMINAL: é por ele que o Orca (e qualquer terminal com abas)
-   sabe que este painel é um agente e se está trabalhando. O Orca lê o glifo
-   de spinner em braile como "trabalhando" e o nome como identidade — então
-   "⠋ PrimoCode — tarefa" enquanto trabalha, "PrimoCode" parado. Vai pelo
-   canal cru da caixa: pelo stdout embrulhado, um escape sem quebra de linha
-   deixaria a caixa apagada (o mesmo defeito do spinner). */
-function titulo(texto) {
-    if (!process.stdout.isTTY || process.env.PRIMOCODE_SEM_TITULO === '1') return;
-    const limpo = String(texto || '').replace(/[\x00-\x1f\x7f]/g, ' ').slice(0, 80);
-    const escrever = Spinner.caixa && Spinner.caixa.escreverCru ? Spinner.caixa.escreverCru : (s) => process.stdout.write(s);
-    try { escrever(`\x1b]0;${limpo}\x07`); } catch { /* terminal fechado */ }
-}
-
-const agora = { texto: '', desde: 0 };
-
-// O rótulo de cada tool na tela — o que a pessoa lê no lugar do nome interno.
-const ROTULOS = {
-        read_file:'Read', write_file:'Write', edit_file:'Edit', multi_edit:'MultiEdit',
-        list_dir:'List', glob:'Glob', grep:'Grep', run_shell:'Bash',
-        run_in_new_terminal:'Terminal', run_background:'Fundo', background_output:'Fundo·log', stop_background:'Fundo·stop', open_in_browser:'Open', spawn_agent:'Agent',
-        write_todos:'Plano', perguntar:'Pergunta', finish:'Finish', pesquisar_referencia:'Pesquisa',
-        browser_open:'Browser', browser_click:'Browser·click', browser_type:'Browser·type',
-        browser_key:'Browser·key', browser_read:'Browser·read', browser_screenshot:'Browser·shot',
-        browser_scroll:'Browser·scroll', browser_wait:'Browser·wait', browser_eval:'Browser·eval',
-        desktop_screenshot:'Desktop·shot', desktop_click:'Desktop·click', desktop_move:'Desktop·move',
-        desktop_drag:'Desktop·drag', desktop_type:'Desktop·type', desktop_key:'Desktop·key',
-        desktop_scroll:'Desktop·scroll', desktop_size:'Desktop·size',
-        desktop_double_click:'Desktop·2click', desktop_open_app:'Desktop·app',
-        /* Os nomes do Estúdio ATUAL. Os antigos (studio_manual, studio_spec,
-           studio_criar…) saíram daqui de propósito: enquanto estavam, uma
-           chamada a ferramenta que não existe mais aparecia na tela com
-           rótulo bonito ("Estúdio·spec corte"), como se fosse trabalho
-           legítimo — e só a linha de baixo revelava que tinha falhado. */
-        planejar_producao:'Diretor', estudio_projeto:'Estúdio·projeto',
-        estudio_plano:'Estúdio·plano', estudio_narrar:'Estúdio·narração',
-        estudio_video:'Estúdio·vídeo', estudio_render:'Estúdio·render', editor_pro:'Editor·vídeo',
-        estudio_site:'Estúdio·marca',
-        desktop_windows:'Desktop·janelas', desktop_focus:'Desktop·foco',
-        desktop_elements:'Desktop·elementos', desktop_click_element:'Desktop·click',
-    estudio_midia:'Estúdio·mídia', estudio_ae:'Estúdio·After Effects', estudio_motion:'Estúdio·Motion', estudio_editar:'Estúdio·Editar', construir_app:'Construir',
-    remember_general:'Lembrar', lembrar:'Memória',
-    mcp_procurar:'MCP·procurar', mcp_conectar:'MCP·conectar', mcp_usar:'MCP',
-};
-
-/* A linha da AÇÃO: `●` na cor da marca e o rótulo em negrito. O resultado
-   dela vem embaixo, com `⎿`, um degrau para dentro (ver lib/fala.js). Antes
-   cabeçalho e resultado usavam o mesmo `⎿` no mesmo nível, e dez tools
-   seguidas eram uma coluna de ganchos sem dizer o que era ação e o que era
-   saída. O argumento vem numa linha só e cortado: um comando de três linhas
-   no cabeçalho empurra o resultado para fora da vista. */
-/* O CAMINHO LEGÍVEL (13/10: "deixar o layout mais organizado"). O cabeçalho
-   mostrava o caminho cru — "/Users/joel/.primocode/studio/projetos/2026-10/
-   primocode-bastidor-vox/midia/logo-prim…" — e o que importa (o arquivo)
-   era o que o corte comia. Agora: a pasta pessoal vira ~, o projeto do
-   Estúdio vira "projeto <id> ›", e caminho longo fica com o fim. */
-function encurtarCaminhos(texto) {
-    const home = require('os').homedir();
-    return String(texto || '')
-        .replace(/(?:~|\/[^\s'"]*?)\/\.primocode\/studio\/projects\/(?:\d{4}-\d{2}\/)?([^\/\s'"]+)\/?/g, (m, id) => `projeto ${id} › `)
-        .split(home).join('~')
-        .replace(/(?:~|\/)[^\s'"]{50,}/g, (cam) => { const ps = cam.split('/').filter(Boolean); return ps.length > 3 ? '…/' + ps.slice(-2).join('/') : cam; });
-}
-
-function actionHeader(name, args) {
-    const label = ROTULOS[name] || name;
-    let argStr = args ? (args.consulta || args.path || args.pattern || args.command || args.target || args.url || args.selector || args.text || args.app || args.window || args.name || args.ferramenta || args.titulo || args.description || (args.todos ? `${args.todos.length} tarefas` : '') || (args.x != null ? `${args.x},${args.y}` : '') || args.key || args.arquivo || args.id || JSON.stringify(args).slice(0,60)) : '';
-    // Campo que veio como objeto (o modelo às vezes manda {"window": {}})
-    // virava "[object Object]" na tela.
-    if (argStr && typeof argStr === 'object') argStr = JSON.stringify(argStr).slice(0, 60);
-    argStr = encurtarCaminhos(String(argStr || '').replace(/\s+/g, ' ').trim());
-    // O que ele está fazendo AGORA — a barra da direita da tela cheia mostra.
-    agora.texto = label + (argStr ? ' · ' + argStr.slice(0, 60) : '');
-    agora.desde = Date.now();
-    // Uma tool sem argumento nenhum caía no JSON.stringify e desenhava "{}"
-    // ao lado do nome — ruído que não diz nada.
-    if (argStr === '{}' || argStr === 'null' || argStr === 'undefined') argStr = '';
-    if (argStr.length > 96) argStr = argStr.slice(0, 95) + '…';
-    return `  ${c.brand('●')} ${c.bold(label)}${argStr ? '  '+c.muted(argStr) : ''}`;
-}
-
-// Transforma erro cru (JSON do provedor, código HTTP, erro de rede) numa frase
-// humana. O usuário nunca deveria ver um paredão de JSON.
-//
-// Sem emoji na frente, de propósito: um 💳 ou um 🔧 no começo da linha é a
-// tela gritando "ERRO" antes de a pessoa ler a frase — e o que chega aqui é
-// o que ela PRECISA fazer (crédito, chave, rede), dito com calma por
-// lib/fala.js. O que é passageiro (minuto, 429, 5xx) nem chega: o agente e o
-// chat esperam e repetem sem contar a ninguém.
-function friendlyError(raw) {
-    const s = String(raw && raw.message ? raw.message : raw || '').trim();
-    const low = s.toLowerCase();
-    // Muitas vezes o texto útil vem dentro de um JSON: {"error":{"message":"..."}}
-    let inner = s;
-    try {
-        const m = s.match(/\{[\s\S]*\}/);
-        if (m) {
-            const j = JSON.parse(m[0]);
-            inner = (j.error && (j.error.message || j.error)) || j.erro || j.message || s;
-            if (typeof inner !== 'string') inner = s;
-        }
-    } catch {}
-
-    /* FERRAMENTA QUE NÃO ESTÁ NA LISTA DO PEDIDO.
-       O provedor recusa a chamada e devolve, em inglês:
-       "tool call validation failed: attempted to call tool 'X' which was not
-       in request.tools". Isso saía cru na tela e a tarefa morria ali.
-
-       A causa é sempre a mesma e não é do usuário: o servidor declara um
-       conjunto de ferramentas e o cliente esperava outro. Então a frase diz o
-       que É — em português — e aponta para o que resolve. */
-    const foraDaLista = s.match(/attempted to call tool '([^']+)' which was not in request\.tools/i);
-    if (foraDaLista) {
-        return `O servidor não ofereceu a ferramenta "${foraDaLista[1]}" nesta chamada, `
-            + 'então ela foi recusada. Isso acontece quando o servidor está numa versão '
-            + 'anterior à do aplicativo. Confira em /doctor status; se persistir, o servidor precisa '
-            + 'ser atualizado.';
-    }
-
-    // Falta de saldo: nem bug, nem espera. O provedor diz quanto a conta paga,
-    // e o servidor já refaz o pedido com esse teto — se ainda assim chegou aqui,
-    // é porque nem o mínimo cabe.
-    if (/can only afford|requires more credits|\b402\b/i.test(low)) {
-        const q = s.match(/afford\s+(\d+)/i);
-        return 'A conta do OpenRouter não tem crédito para uma resposta deste tamanho'
-            + (q ? ` (dá para ${q[1]} tokens)` : '')
-            + '. Adicione crédito em openrouter.ai/settings/credits, ou use /model fast'
-            + ' para pedidos menores.';
-    }
-    // O corte de prompt da conta sem crédito. Mensagem própria porque a cura é
-    // outra: não é encurtar a conversa nem esperar, é trocar de modelo — e os
-    // apelidos padrão já são grátis, então quem cai aqui forçou um modelo pago.
-    if (/prompt tokens limit exceeded/i.test(low)) {
-        const n = s.match(/exceeded:\s*(\d+)\s*>\s*(\d+)/i);
-        return 'Este modelo é pago e a conta não tem crédito, então o provedor corta o pedido'
-            + (n ? ` em ${n[2]} tokens (o seu tem ${n[1]})` : '')
-            + '. Use /model main — os modelos padrão são grátis e não têm esse corte.';
-    }
-    // Ordem importa: "grande demais" e "muitos pedidos" chegam os dois como
-    // rate_limit_exceeded, e a saída é oposta. Tamanho não se resolve
-    // esperando — o pedido vai estourar igual daqui a uma hora.
-    const porTamanho = /request too large|tokens per minute|\btpm\b|reduce your message size|\b413\b/i.test(low)
-        || /conversa passou do teto/i.test(low);
-    if (porTamanho) {
-        const nums = s.match(/Limit\s+(\d+),\s*Requested\s+(\d+)/i);
-        if (/conversa passou do teto/i.test(low)) return `${inner.replace(/\s+/g, ' ').trim()}`;
-        return 'Este pedido é maior que o teto do plano'
-            + (nums ? ` (${nums[2]} tokens contra um limite de ${nums[1]} por minuto)` : '')
-            + '. Esperar não resolve: use /clear para encurtar a conversa, ou divida o pedido em partes menores.';
-    }
-    // Cota do dia estourada. Nada a fazer no código, mas o provedor diz quanto
-    // falta para liberar — jogar isso fora e escrever "alguns instantes" é
-    // mandar o usuário tentar de novo em vão por uma hora e meia.
-    if (/tokens per day|\btpd\b/i.test(low)) {
-        // A classe [0-9hms.] engole o ponto final da frase do provedor, então tira
-        // a pontuação antes de arredondar os milissegundos fora.
-        const bruto = (s.match(/try again in ([0-9hms.]+)/i) || [])[1];
-        const quando = bruto && bruto.replace(/\.+$/, '').replace(/\.\d+s$/, 's');
-        const uso = s.match(/Limit\s+(\d+),\s*Used\s+(\d+)/i);
-        return 'A cota de tokens do dia acabou'
-            + (uso ? ` (${uso[2]} de ${uso[1]} tokens)` : '')
-            + (quando ? `, libera em ${quando}` : '')
-            + '. Enquanto isso o /mode chat gasta bem menos por pergunta.';
-    }
-    // A cota DIÁRIA de modelos grátis do OpenRouter. Mensagem própria porque a
-    // cura é oposta à do 429 comum: esperar alguns instantes não resolve nada, e a
-    // corrente de reserva também não — o limite é da CONTA, não do modelo, então
-    // todos os elos recusam junto. Medido: 429 idêntico nos três modelos testados.
-    if (/free-models-per-day|free model requests per day/i.test(low)) {
-        // O servidor avisa quando existe provedor de reserva DESLIGADO por falta de
-        // chave. Esse detalhe é a ação que resolve — descartá-lo para mostrar um
-        // texto genérico faria o usuário achar que não havia nada a fazer.
-        const semChave = s.match(/provedor de reserva \(([^)]+)\) está sem chave/i);
-        if (semChave) {
-            return `A cota diária de grátis do OpenRouter acabou (são 50 por dia na conta sem crédito),`
-                + ` e o provedor de reserva (${semChave[1]}) está sem chave no servidor — não houve para onde cair.`
-                + ` Configure a chave dele no Render, ou adicione 10 dólares de crédito no OpenRouter`
-                + ` para subir de 50 para 1.000 pedidos por dia (esse crédito não é gasto pelos modelos grátis).`;
-        }
-        return 'A cota diária de grátis acabou nos DOIS provedores (OpenRouter e Groq).'
-            + ' Se chegou até aqui, o servidor já tentou os dez modelos da corrente.'
-            + ' Trocar de modelo não resolve: o limite é da conta, não do modelo.'
-            + ' Adicionar 10 dólares de crédito no OpenRouter sobe de 50 para 1.000 pedidos'
-            + ' por dia — e esse crédito NÃO é gasto pelos modelos grátis, só destrava a cota.'
-            + ' Sem isso, libera amanhã.';
-    }
-    if (/rate.?limit|too many requests|\b429\b/i.test(low)) {
-        return 'Muitos pedidos em pouco tempo. Espere alguns instantes e tente de novo.';
-    }
-    // "token" solto não serve de pista: a mensagem de TPM tem a palavra e não
-    // tem nada a ver com autenticação. Exige o código ou a frase inteira.
-    if (/\b401\b|unauthorized|forbidden|token (inv[aá]lido|ausente|expirado)|invalid token|missing token/i.test(low)) {
-        return 'Este servidor pede um token. Configure PRIMOCODE_TOKEN ou "token" em ~/.primocode/config.json.';
-    }
-    /* O que ainda chegava em inglês cru (brecha 4 da pesquisa de concorrentes: ninguém fala português do
-       erro à explicação). Cada um diz o que aconteceu e o que fazer, sem o código do provedor. */
-    const programa = s.match(/spawn (\S+) ENOENT/i);
-    if (programa) {
-        const nome = programa[1].split('/').pop();
-        return `O programa "${nome}" não está instalado neste computador.` + (/ffmpeg|ffprobe/.test(nome) ? ' No Mac: brew install ffmpeg.' : ' Instale e tente de novo.');
-    }
-    if (/context.?length|maximum context|context_length_exceeded|too many tokens|input is too long/i.test(low)) {
-        return 'A conversa ficou longa demais pra este modelo. Use /clear pra recomeçar, ou /compact pra resumir e seguir.';
-    }
-    if (/model_not_found|model .{0,60}(does not exist|not found|decommissioned|deprecated)|no such model|unknown model/i.test(low)) {
-        return 'Este modelo não existe mais no provedor. Troque com /model, ou deixe no automático.';
-    }
-    if (/content.?filter|safety|blocked by|responsible ai|content management policy/i.test(low)) {
-        return 'O provedor bloqueou a resposta pelo filtro de conteúdo dele. Tente dizer o pedido de outro jeito.';
-    }
-    if (/enospc|no space left/i.test(low)) {
-        return 'O disco está cheio. Libere espaço e tente de novo.';
-    }
-    if (/eacces|eperm|permission denied|operation not permitted/i.test(low)) {
-        return 'Sem permissão pra mexer nesse arquivo ou pasta. Confira se ele é seu, ou escolha outra pasta com /cd.';
-    }
-    if (/econnrefused|enotfound|etimedout|timeout|socket hang up|network|getaddrinfo|econnreset/i.test(low)) {
-        return 'Não consegui falar com o servidor. Verifique sua conexão e tente de novo.';
-    }
-    // a corrente inteira falhou (server/lib/corrente.js erroFinal, lib/act.js erroDaCorrente): o servidor está de pé
-    if (/nenhum (provedor|modelo)/i.test(low)) {
-        return 'Os modelos de IA não responderam agora (o servidor está de pé). Tente de novo em instantes.';
-    }
-    if (/\b5\d\d\b|internal server|bad gateway|service unavailable|gateway timeout/i.test(low)) {
-        return 'O servidor está fora do ar no momento. Tente de novo em instantes.';
-    }
-    // Sobrou algo específico: mostra só a mensagem interna, sem o JSON gigante.
-    const clean = inner.replace(/\s+/g, ' ').trim();
-    return clean.length > 200 ? clean.slice(0, 200) + '…' : clean || 'Algo deu errado.';
-}
-
-
-module.exports = {
-    extraDoSpinner,
-    titulo, agora, c, logo, logoComMascote, mascoteGrande, logoAnimado, letreiro, convite, EXEMPLOS, mascot, MASCOTES, resolverMascote, mascoteInfo, galeriaMascotes, reacao, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };