primocode 8.42.2 → 9.1.0

package/lib/estudio/slides.js

@@ -0,0 +1,190 @@
+/**
+ * slides.js — o mesmo vocabulário, parado no tempo.
+ *
+ *   "O Studio é completo: também gera apresentações de slides e os demais
+ *    formatos que já existem no repositório hoje. Para todos eles vale a mesma
+ *    regra: remover modelos prontos, elevar muito o nível visual."
+ *
+ * ── POR QUE SLIDE NÃO GANHOU MÓDULO PRÓPRIO ──────────────────────────────
+ * O Studio antigo tinha seis ferramentas — prisma (slides), tela (arte), prosa
+ * (documento), grade (planilha), corte (vídeo), traço (diagrama) —, cada uma
+ * com o seu formato de documento, a sua spec e os seus layouts. Seis
+ * vocabulários para o agente aprender, seis para manter, e cinco deles quase
+ * iguais: todos eram "coisas posicionadas num retângulo".
+ *
+ * Um slide É uma cena parada. Um post é uma cena parada. Uma capa é uma cena
+ * parada. O que muda entre eles é o tamanho do retângulo e o fato de não
+ * haver tempo — e isso não justifica um segundo vocabulário, muito menos
+ * cinco.
+ *
+ * Então slide usa o MESMO plano do vídeo: as mesmas primitivas, as mesmas
+ * cores, as mesmas fontes, a mesma ausência de layout pronto. Cada cena vira
+ * uma página. A animação simplesmente não é usada — e quando é (um GIF, um
+ * slide que se move numa tela de evento), ela continua lá, de graça.
+ *
+ * ── O PDF É ESCRITO À MÃO, E ISSO É MAIS SIMPLES DO QUE PARECE ───────────
+ * Um PDF de imagens é um arquivo de texto com alguns objetos numerados e uma
+ * tabela de deslocamentos no fim. São ~80 linhas. A alternativa era uma
+ * dependência de alguns megabytes num produto cujo `npm i -g` termina em
+ * segundos — e que não tem dependência nenhuma, de propósito.
+ *
+ * JPEG entra no PDF SEM recodificar: o formato aceita o fluxo do arquivo como
+ * está (DCTDecode). Então montar o PDF é copiar bytes, não redesenhar.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+/**
+ * Renderiza cada cena como uma imagem parada.
+ *
+ * `remotion still` desenha UM quadro. O quadro escolhido é o do MEIO da cena,
+ * não o primeiro: quem escreveu animação de entrada — e quase todo mundo
+ * escreve — teria a primeira página em branco, com tudo ainda fora do quadro.
+ */
+function renderizarPaginas({ raiz, destino, plano, aoFalar = () => {} }) {
+    return new Promise((resolve) => {
+        fs.mkdirSync(destino, { recursive: true });
+        const fps = Number((plano.formato || {}).fps) || 30;
+
+        // Onde começa cada cena, em quadros — a mesma conta do Video.jsx.
+        const inicios = [];
+        let cursor = 0;
+        for (const cena of plano.cenas || []) {
+            const dur = Math.max(1, Math.round(cena.duracao * fps));
+            const t = cena.transicao || {};
+            const cruz = (t.tipo || t) === 'corte' ? 0 : Math.round((t.duracao ?? 0.4) * fps);
+            inicios.push({ de: cursor, dur });
+            cursor += dur - cruz;
+        }
+
+        const paginas = [];
+        const correr = (i) => {
+            if (i >= inicios.length) return resolve({ ok: true, paginas });
+            const { de, dur } = inicios[i];
+            const quadro = de + Math.floor(dur / 2);
+            const arquivo = path.join(destino, `pagina-${String(i + 1).padStart(3, '0')}.jpeg`);
+            aoFalar(`página ${i + 1} de ${inicios.length}`);
+
+            const p = spawn('npx', [
+                'remotion', 'still', 'Video', arquivo,
+                '--frame=' + quadro, '--image-format=jpeg', '--quality=95', '--log=warn',
+            ], { cwd: raiz, shell: process.platform === 'win32' });
+
+            let erro = '';
+            p.stderr.on('data', (d) => { erro += d.toString().slice(0, 1000); });
+            const relogio = setTimeout(() => { try { p.kill(); } catch {} }, 5 * 60000);
+            p.on('close', (code) => {
+                clearTimeout(relogio);
+                if (code !== 0) {
+                    return resolve({ ok: false, error: `a página ${i + 1} falhou: ${erro.slice(-400).trim()}` });
+                }
+                paginas.push(arquivo);
+                correr(i + 1);
+            });
+            p.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, error: e.message }); });
+        };
+        correr(0);
+    });
+}
+
+// ── o PDF ────────────────────────────────────────────────────────────────
+
+/** Largura e altura de um JPEG, lidas do próprio arquivo. */
+function medirJpeg(dados) {
+    let i = 2;   // pula o SOI (FFD8)
+    while (i < dados.length) {
+        if (dados[i] !== 0xff) { i++; continue; }
+        const marca = dados[i + 1];
+        // Os marcadores SOFn carregam as dimensões. Os quatro que não são
+        // SOF (C4 tabela de Huffman, C8, CC) ficam de fora de propósito.
+        if (marca >= 0xc0 && marca <= 0xcf && marca !== 0xc4 && marca !== 0xc8 && marca !== 0xcc) {
+            return { altura: dados.readUInt16BE(i + 5), largura: dados.readUInt16BE(i + 7) };
+        }
+        i += 2 + dados.readUInt16BE(i + 2);
+    }
+    return null;
+}
+
+/**
+ * Junta as imagens num PDF, uma por página.
+ *
+ * A estrutura: um catálogo, uma lista de páginas, e por página um objeto de
+ * página + um de conteúdo + a imagem. A tabela `xref` no fim diz em que byte
+ * cada objeto começa — é por ela que o leitor de PDF acha as coisas, e é a
+ * única parte em que um erro de contagem estraga o arquivo inteiro.
+ */
+function montarPDF(imagens, saida) {
+    const objetos = [];
+    const pedacos = [];
+    let deslocamento = 0;
+
+    const escrever = (buf) => {
+        pedacos.push(buf);
+        deslocamento += buf.length;
+    };
+    const objeto = (corpo, fluxo = null) => {
+        const n = objetos.length + 1;
+        objetos.push(deslocamento);
+        escrever(Buffer.from(`${n} 0 obj\n${corpo}\n`, 'latin1'));
+        if (fluxo) {
+            escrever(Buffer.from('stream\n', 'latin1'));
+            escrever(fluxo);
+            escrever(Buffer.from('\nendstream\n', 'latin1'));
+        }
+        escrever(Buffer.from('endobj\n', 'latin1'));
+        return n;
+    };
+
+    escrever(Buffer.from('%PDF-1.4\n%\xe2\xe3\xcf\xd3\n', 'latin1'));
+
+    // 1 é o catálogo e 2 é a árvore de páginas; os dois precisam existir antes
+    // de as páginas saberem a quem pertencem, então ficam reservados.
+    objetos.push(0, 0);
+    const paginas = [];
+
+    for (const arquivo of imagens) {
+        const dados = fs.readFileSync(arquivo);
+        const medida = medirJpeg(dados);
+        if (!medida) return { ok: false, error: `não consegui ler as dimensões de ${path.basename(arquivo)}` };
+
+        const img = objeto(
+            `<< /Type /XObject /Subtype /Image /Width ${medida.largura} /Height ${medida.altura} `
+            + `/ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length ${dados.length} >>`,
+            dados);
+
+        // A página tem o TAMANHO da imagem: apresentação não é papel A4, e
+        // encaixar um 1920×1080 numa folha de carta deixaria margem branca
+        // em cima e embaixo de toda página.
+        const conteudo = Buffer.from(
+            `q\n${medida.largura} 0 0 ${medida.altura} 0 0 cm\n/Im0 Do\nQ\n`, 'latin1');
+        const fluxo = objeto(`<< /Length ${conteudo.length} >>`, conteudo);
+        const pagina = objeto(
+            `<< /Type /Page /Parent 2 0 R /MediaBox [0 0 ${medida.largura} ${medida.altura}] `
+            + `/Resources << /XObject << /Im0 ${img} 0 R >> >> /Contents ${fluxo} 0 R >>`);
+        paginas.push(pagina);
+    }
+
+    // Agora os dois reservados, com os deslocamentos de verdade.
+    objetos[0] = deslocamento;
+    escrever(Buffer.from('1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n', 'latin1'));
+    objetos[1] = deslocamento;
+    escrever(Buffer.from(
+        `2 0 obj\n<< /Type /Pages /Kids [${paginas.map((n) => `${n} 0 R`).join(' ')}] `
+        + `/Count ${paginas.length} >>\nendobj\n`, 'latin1'));
+
+    const inicioXref = deslocamento;
+    let xref = `xref\n0 ${objetos.length + 1}\n0000000000 65535 f \n`;
+    for (const off of objetos) xref += `${String(off).padStart(10, '0')} 00000 n \n`;
+    xref += `trailer\n<< /Size ${objetos.length + 1} /Root 1 0 R >>\nstartxref\n${inicioXref}\n%%EOF\n`;
+    escrever(Buffer.from(xref, 'latin1'));
+
+    fs.mkdirSync(path.dirname(saida), { recursive: true });
+    fs.writeFileSync(saida, Buffer.concat(pedacos));
+    return { ok: true, arquivo: saida, paginas: paginas.length, bytes: fs.statSync(saida).size };
+}
+
+module.exports = { renderizarPaginas, montarPDF, medirJpeg };

package/lib/estudio/video.js

@@ -0,0 +1,296 @@
+/**
+ * video.js — o que se faz com o vídeo que VOCÊ gravou.
+ *
+ *   "Eu subo meus vídeos em uma pasta; a IA trabalha naquela pasta. Cortes de
+ *    silêncio com ritmo natural, sem ficarem forçados ou robóticos."
+ *
+ * ── O QUE ESTE MÓDULO É ──────────────────────────────────────────────────
+ * Uma camada fina sobre o ffmpeg, com uma regra: ela NÃO decide nada de
+ * estética. Ela mede (onde tem silêncio, quanto dura, que tamanho tem) e
+ * executa (corta, extrai, junta). Quem decide o que cortar e como montar é o
+ * agente, com o plano.
+ *
+ * ── POR QUE O CORTE DE SILÊNCIO TEM UMA CONTA E NÃO UM BOTÃO ─────────────
+ * Cortar todo silêncio acima de X é o que faz vídeo editado por máquina soar
+ * como máquina: a fala fica colada, sem ar, e cansa em trinta segundos. O que
+ * se ouve como natural é outra coisa — tirar a PAUSA MORTA e deixar a
+ * respiração.
+ *
+ * Três decisões, e cada uma vale um ajuste aqui:
+ *
+ *   1. só corta silêncio mais longo que `minimoParaCortar` (padrão 0,6s):
+ *      pausa curta é ritmo de fala, não erro;
+ *   2. quando corta, DEIXA `respiro` (padrão 0,18s) em cada ponta, em vez de
+ *      emendar no exato instante em que a voz volta;
+ *   3. nunca corta o trecho inteiro: sobra sempre um mínimo, senão duas
+ *      frases seguidas grudam sem intervalo nenhum.
+ *
+ * Os números são o ponto de partida. O que não pode existir é o botão "cortar
+ * silêncio" sem eles.
+ *
+ * ── E QUANDO NÃO HÁ ffmpeg ───────────────────────────────────────────────
+ * Sem ffmpeg não há edição de vídeo, e isso precisa ser dito na hora, com o
+ * comando de instalar — e não descoberto por um erro de processo no meio da
+ * tarefa. `conferir()` é a primeira coisa que o agente chama.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn, execFileSync } = require('child_process');
+
+// ── o ffmpeg existe? ─────────────────────────────────────────────────────
+
+function achar(nome) {
+    const candidatos = process.platform === 'win32'
+        ? [nome + '.exe', nome]
+        : [nome, '/usr/bin/' + nome, '/usr/local/bin/' + nome, '/opt/homebrew/bin/' + nome];
+    for (const c of candidatos) {
+        try {
+            execFileSync(c, ['-version'], { stdio: 'ignore', timeout: 5000 });
+            return c;
+        } catch { /* próximo */ }
+    }
+    return null;
+}
+
+let _ffmpeg = null;
+let _ffprobe = null;
+const ffmpeg = () => (_ffmpeg ??= achar('ffmpeg'));
+const ffprobe = () => (_ffprobe ??= achar('ffprobe'));
+
+const COMO_INSTALAR = {
+    darwin: 'brew install ffmpeg',
+    linux: 'sudo apt install ffmpeg   (ou o gerenciador da sua distribuição)',
+    win32: 'winget install Gyan.FFmpeg',
+};
+
+function conferir() {
+    if (ffmpeg() && ffprobe()) return { ok: true, ffmpeg: ffmpeg(), ffprobe: ffprobe() };
+    return {
+        ok: false,
+        error: 'O ffmpeg não está instalado, e sem ele não há edição de vídeo.',
+        comoResolver: COMO_INSTALAR[process.platform] || 'instale o ffmpeg pelo gerenciador do seu sistema',
+    };
+}
+
+function rodar(bin, args, { timeout = 15 * 60000 } = {}) {
+    return new Promise((resolve) => {
+        const p = spawn(bin, args);
+        let saida = '', erro = '';
+        p.stdout.on('data', (d) => { saida += d.toString(); });
+        p.stderr.on('data', (d) => { erro += d.toString(); });
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} }, timeout);
+        p.on('close', (code) => {
+            clearTimeout(relogio);
+            resolve({ ok: code === 0, code, saida, erro });
+        });
+        p.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, code: -1, saida: '', erro: e.message }); });
+    });
+}
+
+// ── medir ────────────────────────────────────────────────────────────────
+
+/** Duração, tamanho, fps, se tem áudio. */
+async function medir(arquivo) {
+    const c = conferir();
+    if (!c.ok) return c;
+    const r = await rodar(ffprobe(), [
+        '-v', 'error', '-print_format', 'json',
+        '-show_format', '-show_streams', arquivo,
+    ], { timeout: 60000 });
+    if (!r.ok) return { ok: false, error: `não consegui ler "${path.basename(arquivo)}": ${r.erro.slice(-200)}` };
+    let j;
+    try { j = JSON.parse(r.saida); } catch { return { ok: false, error: 'o ffprobe respondeu algo ilegível' }; }
+
+    const video = (j.streams || []).find((s) => s.codec_type === 'video');
+    const audio = (j.streams || []).find((s) => s.codec_type === 'audio');
+    const [num, den] = String((video && video.r_frame_rate) || '0/1').split('/').map(Number);
+    return {
+        ok: true,
+        segundos: Number((j.format || {}).duration) || 0,
+        bytes: Number((j.format || {}).size) || 0,
+        largura: video ? video.width : 0,
+        altura: video ? video.height : 0,
+        fps: den ? Number((num / den).toFixed(3)) : 0,
+        temAudio: !!audio,
+        codec: video ? video.codec_name : null,
+    };
+}
+
+// ── silêncio ─────────────────────────────────────────────────────────────
+
+/**
+ * Onde há silêncio, segundo o ffmpeg.
+ *
+ * `-40dB` é o limiar. Mais alto que isso e a respiração entre frases vira
+ * "silêncio"; mais baixo e o ruído de fundo de qualquer quarto vira "fala".
+ */
+async function silencios(arquivo, { limiarDb = -40, minimo = 0.35 } = {}) {
+    const c = conferir();
+    if (!c.ok) return c;
+    const r = await rodar(ffmpeg(), [
+        '-hide_banner', '-i', arquivo,
+        '-af', `silencedetect=noise=${limiarDb}dB:d=${minimo}`,
+        '-f', 'null', '-',
+    ]);
+    // O silencedetect escreve na saída de erro, e não em JSON.
+    const trechos = [];
+    let inicio = null;
+    for (const linha of r.erro.split('\n')) {
+        const i = linha.match(/silence_start:\s*(-?[\d.]+)/);
+        if (i) { inicio = Math.max(0, Number(i[1])); continue; }
+        const f = linha.match(/silence_end:\s*([\d.]+)/);
+        if (f && inicio != null) {
+            trechos.push({ de: inicio, ate: Number(f[1]) });
+            inicio = null;
+        }
+    }
+    return { ok: true, silencios: trechos };
+}
+
+/**
+ * Os trechos que FICAM, depois de tirar as pausas mortas.
+ *
+ * Função pura: recebe as medidas e devolve a lista. Assim o ritmo — que é a
+ * parte que se acerta no ouvido — é testável sem vídeo nenhum.
+ */
+function trechosQueFicam(duracao, listaDeSilencios, {
+    minimoParaCortar = 0.6,   // pausa menor que isto é ritmo de fala, não erro
+    respiro = 0.18,           // o ar que sobra em cada ponta do corte
+    minimoDeTrecho = 0.25,    // nada de fatia menor que isto
+} = {}) {
+    const cortar = (listaDeSilencios || [])
+        .map((s) => ({ de: s.de + respiro, ate: s.ate - respiro }))
+        .filter((s) => s.ate - s.de >= minimoParaCortar - respiro * 2)
+        .sort((a, b) => a.de - b.de);
+
+    const ficam = [];
+    let cursor = 0;
+    for (const s of cortar) {
+        const de = Math.max(0, Math.min(s.de, duracao));
+        if (de - cursor >= minimoDeTrecho) ficam.push({ de: cursor, ate: de });
+        cursor = Math.max(cursor, Math.min(s.ate, duracao));
+    }
+    if (duracao - cursor >= minimoDeTrecho) ficam.push({ de: cursor, ate: duracao });
+    // Nenhum corte aproveitável: melhor devolver o vídeo inteiro do que um
+    // arquivo vazio que "tecnicamente" obedeceu ao pedido.
+    if (!ficam.length) return [{ de: 0, ate: duracao }];
+    return ficam.map((t) => ({ de: Number(t.de.toFixed(3)), ate: Number(t.ate.toFixed(3)) }));
+}
+
+/** Corta as pausas mortas e escreve um vídeo novo. */
+async function cortarSilencio(entrada, saida, op = {}) {
+    const c = conferir();
+    if (!c.ok) return c;
+    const m = await medir(entrada);
+    if (!m.ok) return m;
+    const s = await silencios(entrada, op);
+    if (!s.ok) return s;
+
+    const ficam = trechosQueFicam(m.segundos, s.silencios, op);
+    if (ficam.length === 1 && ficam[0].de === 0 && ficam[0].ate >= m.segundos - 0.05) {
+        return { ok: true, semCorte: true, trechos: ficam, arquivo: entrada,
+            aviso: 'não havia pausa morta para tirar — o vídeo segue inteiro' };
+    }
+
+    /* Um filtro só, em vez de N arquivos temporários e um concat: o ffmpeg
+       recodifica uma vez, e não há pasta de sobras para limpar depois. */
+    const partes = ficam.map((t, i) =>
+        `[0:v]trim=start=${t.de}:end=${t.ate},setpts=PTS-STARTPTS[v${i}];`
+        + `[0:a]atrim=start=${t.de}:end=${t.ate},asetpts=PTS-STARTPTS[a${i}];`).join('');
+    const junta = ficam.map((_, i) => `[v${i}][a${i}]`).join('');
+    const filtro = `${partes}${junta}concat=n=${ficam.length}:v=1:a=1[v][a]`;
+
+    const r = await rodar(ffmpeg(), [
+        '-hide_banner', '-y', '-i', entrada,
+        '-filter_complex', filtro, '-map', '[v]', '-map', '[a]',
+        '-c:v', 'libx264', '-preset', 'medium', '-crf', '18',
+        '-c:a', 'aac', '-b:a', '192k', saida,
+    ]);
+    if (!r.ok) return { ok: false, error: `o corte falhou: ${r.erro.slice(-400)}` };
+
+    const depois = await medir(saida);
+    return {
+        ok: true, arquivo: saida, trechos: ficam,
+        antes: Number(m.segundos.toFixed(2)),
+        depois: depois.ok ? Number(depois.segundos.toFixed(2)) : null,
+        cortes: ficam.length - 1,
+    };
+}
+
+// ── extrair ──────────────────────────────────────────────────────────────
+
+/**
+ * O áudio, pequeno, para transcrever.
+ *
+ * Mono, 16kHz, 32kbps: é o que a transcrição precisa e nada além. Dez minutos
+ * cabem em ~2,4 MB — o vídeo original teria centenas. O tamanho importa
+ * porque esse arquivo atravessa a rede.
+ */
+async function extrairAudio(entrada, saida) {
+    const c = conferir();
+    if (!c.ok) return c;
+    const r = await rodar(ffmpeg(), [
+        '-hide_banner', '-y', '-i', entrada,
+        '-vn', '-ac', '1', '-ar', '16000', '-b:a', '32k', saida,
+    ]);
+    if (!r.ok) return { ok: false, error: `não deu para extrair o áudio: ${r.erro.slice(-300)}` };
+    const bytes = fs.existsSync(saida) ? fs.statSync(saida).size : 0;
+    return { ok: true, arquivo: saida, bytes };
+}
+
+/** Um pedaço do vídeo, sem recodificar quando dá. */
+async function recortar(entrada, saida, de, ate) {
+    const c = conferir();
+    if (!c.ok) return c;
+    const r = await rodar(ffmpeg(), [
+        '-hide_banner', '-y', '-ss', String(de), '-to', String(ate), '-i', entrada,
+        '-c:v', 'libx264', '-preset', 'medium', '-crf', '18', '-c:a', 'aac', saida,
+    ]);
+    return r.ok ? { ok: true, arquivo: saida, de, ate }
+        : { ok: false, error: `o recorte falhou: ${r.erro.slice(-300)}` };
+}
+
+/** Um quadro em PNG — para olhar o vídeo, escolher b-roll, medir enquadramento. */
+async function quadro(entrada, saida, segundo = 0) {
+    const c = conferir();
+    if (!c.ok) return c;
+    const r = await rodar(ffmpeg(), [
+        '-hide_banner', '-y', '-ss', String(segundo), '-i', entrada,
+        '-frames:v', '1', '-q:v', '2', saida,
+    ], { timeout: 60000 });
+    return r.ok ? { ok: true, arquivo: saida } : { ok: false, error: r.erro.slice(-300) };
+}
+
+/**
+ * Troca o fundo da pessoa por uma imagem.
+ *
+ *   "Recorte de pessoa: segmentar meu rosto/corpo e trocar o fundo por uma
+ *    imagem relacionada ao que estou falando."
+ *
+ * Isto NÃO é feito aqui: segmentação por quadro é trabalho de modelo de
+ * visão, e o ffmpeg só sabe fazer chroma key (fundo verde). O caminho real
+ * está em `pessoa.py`, que usa o MediaPipe — e esta função existe para
+ * costurar o resultado dele (um vídeo com canal alfa) sobre a imagem.
+ */
+async function sobreporAlfa({ pessoa, fundo, saida, escala = 1 }) {
+    const c = conferir();
+    if (!c.ok) return c;
+    const r = await rodar(ffmpeg(), [
+        '-hide_banner', '-y',
+        '-loop', '1', '-i', fundo,
+        '-c:v', 'libvpx-vp9', '-i', pessoa,
+        '-filter_complex',
+        `[1:v]scale=iw*${escala}:-1[p];[0:v][p]overlay=(W-w)/2:(H-h):shortest=1[v]`,
+        '-map', '[v]', '-map', '1:a?', '-c:v', 'libx264', '-crf', '18', '-c:a', 'aac', saida,
+    ]);
+    return r.ok ? { ok: true, arquivo: saida } : { ok: false, error: r.erro.slice(-400) };
+}
+
+module.exports = {
+    conferir, medir, silencios, trechosQueFicam, cortarSilencio,
+    extrairAudio, recortar, quadro, sobreporAlfa, rodar, ffmpeg, ffprobe,
+};

package/lib/fala.js

@@ -38,6 +38,7 @@
 'use strict';
 
 const { c, actionHeader, friendlyError } = require('./ui');
+const markdown = require('./markdown.js');
 
 /* Até este tamanho, o texto que o modelo escreve antes de chamar uma tool é
    guardado e sai de uma vez, como pensamento. Passou disso sem tool à vista,
@@ -73,14 +74,34 @@ function resultado(profundidade) {
     return ident(profundidade) + c.muted('    ⎿ ');
 }
 
+/* O MESMO recuo, sem o gancho e sem cor — para blocos de várias linhas
+   (o diff) que sentam embaixo do resultado.
+ *
+ * Não dá para obter isto tirando o `⎿` do `resultado()` com um replace: aquela
+ * string termina em código de cor, então o `⎿` não está no fim e a troca não
+ * pega. Medido: o diff saiu com um `⎿` em TODA linha, como se cada uma fosse
+ * um resultado novo. Duas funções, uma verdade só — a largura. */
+const LARGURA_RESULTADO = 6;    // '    ⎿ '
+function recuo(profundidade) {
+    return ident(profundidade) + ' '.repeat(LARGURA_RESULTADO);
+}
+
 function formatar(texto, marca) {
     return linhas(texto).map((l, i) => (i === 0 ? `${marca} ${c.white(l)}` : `  ${c.white(l)}`)).join('\n');
 }
 
-/** A resposta final, pronta. Espelha o ❯ de quem perguntou. */
+/** A resposta final, pronta. Espelha o ❯ de quem perguntou.
+ *
+ *  Passa pelo desenhador de Markdown pelo mesmo motivo do fluxo: o modelo
+ *  escreve com negrito, lista, tabela e bloco de código, e sem desenhar isso
+ *  a resposta chega com a marcação à mostra. `formatar` continua servindo ao
+ *  que NÃO é resposta do modelo (aviso, erro), que é texto nosso e já vem
+ *  pronto. */
 function resposta(texto) {
     if (!String(texto || '').trim()) return '';
-    const saida = '\n' + formatar(texto, c.brand('●'));
+    const largura = Math.max(40, (process.stdout.columns || 80) - 4);
+    const linhasMd = markdown.renderizar(texto, largura);
+    const saida = '\n' + linhasMd.map((l, i) => (i === 0 ? `${c.brand('●')} ${l}` : `  ${l}`)).join('\n');
     console.log(saida);
     return saida;
 }
@@ -108,15 +129,37 @@ const frase = friendlyError;
  * recuo, para o bloco continuar alinhado ao marcador.
  */
 function fluxo() {
+    /* A resposta do modelo vem em MARKDOWN — é o que ele escreve, e é o que o
+       prompt pede. Antes ela saía crua: "**importante**" aparecia com os
+       asteriscos, a tabela virava um monte de barras desalinhadas e o bloco de
+       código vinha com as três crases à mostra. Quem lia recebia o material
+       bruto e formatava de cabeça.
+
+       O desenho é por LINHA, não no fim: a resposta continua aparecendo
+       enquanto chega. Só a tabela e o bloco de código esperam fechar, porque
+       meia tabela na tela é pior que a tabela um segundo depois. */
     let escreveu = false;
+    const largura = Math.max(40, (process.stdout.columns || 80) - 4);
+    const desenho = markdown.fluxo(largura);
+
+    const sair = (linhas) => {
+        for (const linha of linhas) {
+            if (!escreveu) { process.stdout.write('\n' + c.brand('●') + ' '); escreveu = true; }
+            else process.stdout.write('\n  ');
+            process.stdout.write(linha);
+        }
+    };
+
     return {
         escrever(delta) {
             const t = String(delta || '');
             if (!t) return;
-            if (!escreveu) { process.stdout.write('\n' + c.brand('●') + ' '); escreveu = true; }
-            process.stdout.write(c.white(t.replace(/\n/g, '\n  ')));
+            sair(desenho.pedaco(t));
+        },
+        fechar() {
+            sair(desenho.fim());
+            if (escreveu) process.stdout.write('\n');
         },
-        fechar() { if (escreveu) process.stdout.write('\n'); },
         escreveu: () => escreveu,
     };
 }
@@ -143,4 +186,4 @@ function agenteVoltou(resumo, profundidade) {
     return saida;
 }
 
-module.exports = { LIMIAR_PENSAMENTO, pensamento, acao, resultado, resposta, aviso, problema, frase, fluxo, paralelo, agente, agenteVoltou };
+module.exports = { LIMIAR_PENSAMENTO, pensamento, acao, resultado, recuo, resposta, aviso, problema, frase, fluxo, paralelo, agente, agenteVoltou };

package/lib/marca.js

@@ -67,7 +67,10 @@ function candidatasALogo(html, base) {
         const id = atributo(tag, 'id') || '';
         if (/logo|brand|marca/i.test(`${src} ${alt} ${cls} ${id}`) && !/sponsor|partner|cliente|client|parceir/i.test(`${alt} ${cls} ${src}`)) {
             const u = absoluta(src, base);
-            if (u && !/^data:/.test(u)) lista.push({ url: u, fonte: 'img-logo', nota: /\.svg(\?|$)/i.test(u) ? 30 : 20 });
+            // O `alt` vai junto: "Nubank logo" diz de QUEM é a logo, e o
+            // endereço nem sempre diz (CDN devolve hash por nome de arquivo).
+            // Quem usa isso é `ordenarPelaMarca`, no estudio/identidade.js.
+            if (u && !/^data:/.test(u)) lista.push({ url: u, alt, fonte: 'img-logo', nota: /\.svg(\?|$)/i.test(u) ? 30 : 20 });
         }
     }
     // 1b. SVG inline no cabeçalho com "logo" no nome — não dá para baixar,