primocode 8.42.2 → 9.1.0

package/lib/entrada.js

@@ -0,0 +1,576 @@
+/**
+ * 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 readline = require('readline');
+const { EventEmitter } = require('events');
+const { c, visibleWidth, truncate } = require('./ui.js');
+
+// ── O desenho ────────────────────────────────────────────────────────────
+
+const BORDA = { ne: '╭', no: '╮', se: '╰', so: '╯', h: '─', v: '│' };
+
+/** 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));
+    const largura = colunas - 1;    // a última coluna fica livre: escrever nela
+                                    // faz o terminal quebrar a linha sozinho
+    const w = Math.max(8, largura - 3);   // espaço + '❯ ' — e mais nada à direita
+
+    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; }
+    }
+
+    /* DUAS RÉGUAS, NÃO UMA CAIXA.
+       Era uma caixa fechada — cantos e barras laterais. O Claude Code, que é a
+       referência pedida, usa só a linha de cima e a de baixo, e a diferença
+       não é gosto: a barra lateral direita obriga a reservar duas colunas em
+       toda linha e a preencher o resto com espaço, e é ela que faz o texto
+       colado parecer desalinhado quando o terminal é estreito. Sem as laterais
+       o campo ganha as colunas de volta e a emenda some. */
+    const out = [];
+    const regua = c.dim(BORDA.h.repeat(largura));
+    out.push(regua);
+
+    const vazio = !String(e.texto).length;
+    linhas.forEach((l, i) => {
+        const marca = i === 0
+            ? (e.ocupado ? c.dim('❯ ') : c.brand('❯ '))
+            : c.dim('┆ ');
+        let conteudo = c.white(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.vazio) conteudo = c.dim(e.vazio);
+        // Sem `encher`: sem barra à direita não há nada para alinhar, e o
+        // espaço sobrando só apagaria o que estivesse embaixo.
+        out.push(' ' + marca + conteudo);
+    });
+
+    out.push(regua);
+
+    // ── o menu dos comandos ──────────────────────────────────────────────
+    // Fica ABAIXO da caixa, não dentro: dentro, ele empurraria o campo de
+    // digitar para cima a cada tecla, e o texto que a pessoa escreve saltaria
+    // de lugar enquanto ela escreve.
+    if (e.menu && e.menu.itens.length) {
+        const cabem = Math.max(1, Math.min(e.menu.itens.length, 8));
+        // A janela acompanha a seleção: descer na lista rola, em vez de o
+        // item escolhido sumir embaixo.
+        let topo = Math.max(0, Math.min(e.menu.sel - Math.floor(cabem / 2),
+            e.menu.itens.length - cabem));
+        for (let i = topo; i < topo + cabem; i++) {
+            const [nome, desc] = e.menu.itens[i];
+            const escolhido = i === e.menu.sel;
+            const nomeW = 16;
+            const corpo = (escolhido ? c.brand('❯ ') : '  ')
+                + (escolhido ? c.bold(c.white(encher(nome, nomeW))) : c.muted(encher(nome, nomeW)))
+                + c.dim(desc || '');
+            out.push(' ' + truncate(corpo, largura - 2));
+        }
+        if (e.menu.itens.length > cabem) {
+            out.push('  ' + c.dim(`… e mais ${e.menu.itens.length - cabem}`));
+        }
+    }
+
+    for (const linha of (e.status || [])) out.push(' ' + linha);
+
+    return {
+        linhas: out,
+        cursorLinha: 1 + cursorLinha,                   // +1 pela régua de cima
+        cursorColuna: 1 + 2 + cursorColuna,             // espaço + '❯ '
+    };
+}
+
+// ── 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.tty = !!(process.stdin.isTTY && process.stdout.isTTY);
+        this.escreverCru = process.stdout.write.bind(process.stdout);
+    }
+
+    // ── 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.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;
+        process.stdout.write = function (texto, ...resto) {
+            if (eu._pintando) return eu._stdoutOriginal.call(this, texto, ...resto);
+            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; }
+        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. */
+    suspender() { this.suspenso = true; this._apagar(); }
+    retomar() { this.suspenso = false; if (this.ativo && !this.fechado) this._desenhar(); }
+
+    /** O agente está trabalhando: a caixa esmaece e o Enter não manda nada. */
+    trabalhando(sim) {
+        if (this.ocupado === !!sim) return;
+        this.ocupado = !!sim;
+        if (this.desenhado) this._redesenhar();
+    }
+
+    prompt() { if (!this.suspenso && this.tty && !this.fechado) this._desenhar(); }
+
+    /** Escreve texto ACIMA da caixa — é por onde todo o resto do programa fala. */
+    escreverAcima(texto) {
+        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._mudou(); }
+
+    // ── desenho ──────────────────────────────────────────────────────────
+
+    _quadro() {
+        return montar({
+            texto: this.line,
+            cursor: this.cursor,
+            colunas: process.stdout.columns || 80,
+            fantasma: this._fantasma(),
+            vazio: this.op.vazio || '',
+            status: this.op.status ? this.op.status() : [],
+            menu: this.menu,
+            ocupado: this.ocupado,
+        });
+    }
+
+    _desenhar() {
+        if (!this.tty || this.suspenso || this.fechado) return;
+        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.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() {
+        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; }
+        if (this.colando) {
+            const limpo = seq.replace('\x1b[200~', '').replace('\x1b[201~', '');
+            if (limpo) this.write(limpo.replace(/\r/g, '\n'));
+            if (seq.includes('\x1b[201~')) this.colando = false;
+            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();
+                const f = this._fantasma();
+                if (f) return this.write(f);
+                if (this.line.startsWith('/')) { this._filtrarMenu(); this._redesenhar(); }
+                return;
+            }
+
+            case 'backspace':
+                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 '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(); }
+                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();
+                }
+                return this._historico(1);
+
+            default:
+                if (seq && !key.meta && seq >= ' ' && seq !== '\x7f') this.write(seq);
+        }
+    }
+
+    _ctrl(key) {
+        switch (key.name) {
+            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': this._apagar(); this.escreverCru('\x1b[2J\x1b[H'); return this._desenhar();
+            case 'j': return this._novaLinha();
+            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 texto = this.line;
+        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()) {
+            const marca = c.brand('❯ ');
+            this.escreverCru(texto.split('\n').map((l, i) => (i ? '  ' : marca) + c.white(l)).join('\n') + '\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 };

package/lib/especialistas.js

@@ -11,8 +11,8 @@
  * generalista escreve o CSS que qualquer um escreveria. O briefing é o que um
  * sênior daquela área diria a um colega antes de ele começar — o que olhar
  * primeiro, o que nunca fazer, como PROVAR que acabou. Ele vai na frente da
- * tarefa, na MESMA mensagem: o servidor não precisa conhecer os especialistas,
- * e o /claude e o /codex os recebem igual.
+ * tarefa, na MESMA mensagem — assim o servidor não precisa conhecer os
+ * especialistas.
  *
  * ── CURTO DE PROPÓSITO ──────────────────────────────────────────────────
  * Cada briefing cabe em ~800 caracteres. O subagente vive no mesmo teto de