primocode 11.0.0 → 11.1.0

package/lib/skill/skills.js

@@ -0,0 +1,468 @@
+/**
+ * skills.js — o que o PrimoCode sabe fazer bem, escrito em texto.
+ *
+ *   "O Primo Code já vem com várias skills instaladas por padrão. Comandos:
+ *    /skills, /install-skill e /marketplace."
+ *
+ * ── O QUE É UMA SKILL, E O QUE ELA NÃO É ─────────────────────────────────
+ * Uma skill é uma pasta com um `SKILL.md` dentro: um cabeçalho que diz quem
+ * ela é e quando serve, e um corpo que é o prompt dela. Nada de código, nada
+ * de instalar dependência, nada que rode. É conhecimento, não programa.
+ *
+ * Isso é decisão, não limitação. Uma skill que executa código é uma porta
+ * para qualquer pessoa mandar um arquivo e rodar o que quiser na máquina de
+ * quem instalou — e um marketplace de programas executáveis exige assinatura,
+ * revisão e sandbox, que é outro produto. Skill é texto: o pior que um texto
+ * mal-intencionado faz é dar um conselho ruim ao modelo, e o usuário vê o
+ * agente agindo, passo a passo, na tela.
+ *
+ * ── POR QUE NÃO É A MESMA COISA QUE OS ESPECIALISTAS ─────────────────────
+ * `especialistas.js` são sete briefings FIXOS, escolhidos pelo modelo quando
+ * ele delega uma tarefa a um subagente. Eles são do produto: ninguém instala,
+ * ninguém desliga, e a lista não cresce.
+ *
+ * Skill é do USUÁRIO. Ele instala, desliga, escreve a dele. É a resposta para
+ * "o Primo sempre esquece de rodar o lint antes de terminar" — que não se
+ * resolve pedindo de novo a cada conversa, e sim escrevendo uma vez.
+ *
+ * ── COMO ELA CHEGA AO MODELO ─────────────────────────────────────────────
+ * O corpo NÃO vai em todo pedido. São oito skills; mandar todas custaria
+ * milhares de tokens por mensagem num plano limitado por token, para que
+ * sete delas não tenham nada a ver com o pedido.
+ *
+ * O que decide é o `quando:` do cabeçalho — as palavras que fazem aquela
+ * skill valer a pena. Bateu, o corpo dela entra na frente da tarefa; não
+ * bateu, ela não custa nada. É o mesmo desenho dos especialistas, e pelo
+ * mesmo motivo: o teto de tokens é o recurso escasso deste produto.
+ *
+ * ── ONDE ELAS MORAM ──────────────────────────────────────────────────────
+ * Em `~/.primocode/skills/`, fora do pacote — pelo mesmo motivo do Studio:
+ * instalado global, a pasta do pacote costuma ser de sistema, e um `npm
+ * update` apagaria o que o usuário escreveu. As que vêm com o produto são
+ * copiadas na primeira vez; as dele ficam lá, a salvo de atualização.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const portaoSkill = require('./portao-skill.js');
+
+const ORIGEM = path.join(__dirname, '..', '..', 'skills');
+const CASA = path.join(os.homedir(), '.primocode', 'skills');
+const ESTADO = path.join(CASA, 'estado.json');
+
+/* Teto do que entra num pedido. Duas skills longas já são mais texto que a
+   maioria das tarefas — e cada caractere aqui é um caractere a menos de
+   arquivo lido. Estourou, entram as que couberam, das que casaram melhor. */
+const MAX_CARACTERES = 6000;
+
+// ── leitura ──────────────────────────────────────────────────────────────
+
+/**
+ * O cabeçalho e o corpo de um SKILL.md.
+ *
+ * O cabeçalho fica entre duas linhas de `---`, uma chave por linha. Formato
+ * escolhido por ser o que qualquer pessoa já viu, e por caber num parser de
+ * dez linhas — YAML de verdade seria uma dependência para ler quatro campos.
+ */
+function separar(texto) {
+    const bruto = String(texto || '');
+    const m = bruto.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!m) return { cabecalho: {}, corpo: bruto.trim() };
+    const cabecalho = {};
+    for (const linha of m[1].split(/\r?\n/)) {
+        const par = linha.match(/^\s*([a-zA-Z_][\w-]*)\s*:\s*(.*)$/);
+        if (par) cabecalho[par[1].toLowerCase()] = par[2].trim().replace(/^["']|["']$/g, '');
+    }
+    return { cabecalho, corpo: m[2].trim() };
+}
+
+function lerEstado() {
+    let e;
+    try { e = JSON.parse(fs.readFileSync(ESTADO, 'utf8')); } catch { e = null; }
+    // Um estado.json válido sem `desligadas` (um `{}`) derrubava /skills,
+    // /marketplace e a entrada das skills em todo pedido.
+    if (!e || typeof e !== 'object') e = {};
+    if (!Array.isArray(e.desligadas)) e.desligadas = [];
+    return e;
+}
+
+function salvarEstado(estado) {
+    try {
+        fs.mkdirSync(CASA, { recursive: true });
+        fs.writeFileSync(ESTADO, JSON.stringify(estado, null, 2), 'utf8');
+        return true;
+    } catch { return false; }
+}
+
+/* A impressão digital do conteúdo. Serve para responder UMA pergunta: o
+   arquivo que está na casa da pessoa é o que o produto instalou, ou ela
+   mexeu nele? */
+function impressao(texto) {
+    return crypto.createHash('sha256').update(String(texto || ''), 'utf8').digest('hex').slice(0, 16);
+}
+
+/**
+ * Traz as skills do produto para a casa da pessoa — e ATUALIZA as que ela não
+ * tocou.
+ *
+ * ── O DEFEITO QUE ISTO CONSERTA ─────────────────────────────────────────
+ * Era `if (fs.existsSync(destino)) continue;`. Uma vez instalada, a skill do
+ * produto NUNCA mais era atualizada. Quem rodou o PrimoCode um dia ficou com
+ * a versão daquele dia para sempre, e toda melhoria que veio depois — texto
+ * melhor, gatilho novo, regra corrigida — nunca chegou a ninguém. Do lado de
+ * quem usa, o sintoma é "as skills não estão funcionando": elas rodam, só que
+ * são as de antes.
+ *
+ * ── E POR QUE NÃO SOBRESCREVER SEMPRE ───────────────────────────────────
+ * Porque a pessoa pode ter editado. Sobrescrever apagaria o trabalho dela sem
+ * avisar, que é pior que a skill desatualizada. Então guarda-se, ao instalar,
+ * a impressão digital do que foi instalado: se o arquivo ainda bate com ela,
+ * ninguém mexeu e dá para atualizar em silêncio. Se não bate, a edição é
+ * dela e fica como está.
+ *
+ * A skill CRIADA pela pessoa não tem impressão nenhuma, e por isso nunca é
+ * tocada — não veio do produto.
+ */
+function prepararCasa() {
+    fs.mkdirSync(CASA, { recursive: true });
+    let nascidas = 0;
+    let atualizadas = 0;
+    const preservadas = [];
+    const guardadas = [];
+    let origens = [];
+    try { origens = fs.readdirSync(ORIGEM, { withFileTypes: true }); } catch { return 0; }
+
+    for (const item of origens) {
+        if (!item.isDirectory()) continue;
+        const destino = path.join(CASA, item.name);
+        const arquivoDestino = path.join(destino, 'SKILL.md');
+        const marca = path.join(destino, '.origem.json');
+        let novo;
+        try { novo = fs.readFileSync(path.join(ORIGEM, item.name, 'SKILL.md'), 'utf8'); }
+        catch { continue; }
+
+        try {
+            if (!fs.existsSync(arquivoDestino)) {
+                fs.mkdirSync(destino, { recursive: true });
+                fs.writeFileSync(arquivoDestino, novo, 'utf8');
+                fs.writeFileSync(marca, JSON.stringify({ sha: impressao(novo) }), 'utf8');
+                nascidas++;
+                continue;
+            }
+
+            const atual = fs.readFileSync(arquivoDestino, 'utf8');
+            if (impressao(atual) === impressao(novo)) continue;        // já é a nova
+
+            let instalada = null;
+            try { instalada = JSON.parse(fs.readFileSync(marca, 'utf8')).sha; } catch { /* sem marca */ }
+
+            if (instalada && instalada === impressao(atual)) {
+                // Intacta desde a instalação: pode atualizar sem perder nada.
+                fs.writeFileSync(arquivoDestino, novo, 'utf8');
+                fs.writeFileSync(marca, JSON.stringify({ sha: impressao(novo) }), 'utf8');
+                atualizadas++;
+            } else if (instalada) {
+                // Tem marca e não bate: a pessoa editou. Fica como está — o
+                // trabalho dela vale mais que a atualização.
+                preservadas.push(item.name);
+            } else {
+                /* SEM MARCA: instalada antes desta correção existir.
+                   Aqui não dá para saber se a pessoa editou ou se é só uma
+                   versão antiga do produto — e as duas saídas puras são
+                   ruins: preservar congela a skill para sempre (que é o
+                   defeito que estamos consertando, e atingiria justamente
+                   quem já usa), sobrescrever pode apagar o trabalho dela.
+
+                   Então atualiza E GUARDA O ANTERIOR ao lado. Ninguém perde
+                   nada, todo mundo recebe a versão nova, e quem tinha algo
+                   próprio encontra o arquivo ali para trazer de volta. Vale
+                   uma vez só: da próxima já existe marca. */
+                try { fs.writeFileSync(arquivoDestino + '.anterior', atual, 'utf8'); } catch {}
+                fs.writeFileSync(arquivoDestino, novo, 'utf8');
+                fs.writeFileSync(marca, JSON.stringify({ sha: impressao(novo) }), 'utf8');
+                atualizadas++;
+                guardadas.push(item.name);
+            }
+        } catch { /* uma que falha não impede as outras */ }
+    }
+    prepararCasa.ultimo = { nascidas, atualizadas, preservadas, guardadas };
+    return nascidas;
+}
+
+/** Uma skill pelo nome da pasta, ou null. */
+function ler(nome) {
+    const arquivo = path.join(CASA, nome, 'SKILL.md');
+    let texto;
+    try { texto = fs.readFileSync(arquivo, 'utf8'); } catch { return null; }
+    const { cabecalho, corpo } = separar(texto);
+    const estado = lerEstado();
+    return {
+        nome,
+        titulo: cabecalho.nome || cabecalho.titulo || nome,
+        descricao: cabecalho.descricao || '',
+        quando: String(cabecalho.quando || '').split(',').map((s) => s.trim().toLowerCase()).filter(Boolean),
+        autor: cabecalho.autor || '',
+        corpo,
+        ligada: !(Array.isArray(estado.desligadas) && estado.desligadas.includes(nome)),
+        doProduto: fs.existsSync(path.join(ORIGEM, nome, 'SKILL.md')),
+        caminho: arquivo,
+    };
+}
+
+/** Todas as instaladas, em ordem alfabética. */
+function listar() {
+    prepararCasa();
+    let nomes = [];
+    try {
+        nomes = fs.readdirSync(CASA, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name)
+            .sort();
+    } catch { return []; }
+    return nomes.map(ler).filter(Boolean);
+}
+
+// ── escrita ──────────────────────────────────────────────────────────────
+
+/* O nome vira pasta, então precisa ser um nome de pasta: sem barra, sem
+   `..`, sem acento. Um nome com `../` escreveria fora de ~/.primocode. */
+function apelidar(bruto) {
+    return String(bruto || '')
+        .normalize('NFD').replace(/[̀-ͯ]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 48);
+}
+
+/**
+ * Cria (ou reescreve) uma skill.
+ *
+ * @param {string} nome      como a pessoa a chamou
+ * @param {string} corpo     o prompt inteiro
+ * @param {object} extra     { descricao, quando, autor }
+ */
+function criar(nome, corpo, extra = {}) {
+    const apelido = apelidar(nome);
+    if (!apelido) return { ok: false, error: 'Dê um nome à skill.' };
+    if (!String(corpo || '').trim()) return { ok: false, error: 'A skill precisa de um conteúdo — é ele que vai para o modelo.' };
+
+    const cabecalho = [
+        '---',
+        `nome: ${String(nome).trim()}`,
+        `descricao: ${String(extra.descricao || '').replace(/\n/g, ' ').trim()}`,
+        `quando: ${String(extra.quando || '').replace(/\n/g, ' ').trim()}`,
+        `autor: ${String(extra.autor || 'você').trim()}`,
+        '---',
+        '',
+    ].join('\n');
+
+    try {
+        const pasta = path.join(CASA, apelido);
+        fs.mkdirSync(pasta, { recursive: true });
+        fs.writeFileSync(path.join(pasta, 'SKILL.md'), cabecalho + String(corpo).trim() + '\n', 'utf8');
+        // Skill recém-criada nasce LIGADA, mesmo que uma de mesmo nome tenha
+        // sido desligada antes: quem acabou de escrevê-la quer usá-la.
+        const estado = lerEstado();
+        estado.desligadas = estado.desligadas.filter((x) => x !== apelido);
+        salvarEstado(estado);
+        return { ok: true, nome: apelido, caminho: path.join(pasta, 'SKILL.md') };
+    } catch (e) {
+        return { ok: false, error: `Não deu para gravar: ${e.message}` };
+    }
+}
+
+function ligar(nome, ligada) {
+    const estado = lerEstado();
+    estado.desligadas = estado.desligadas.filter((x) => x !== nome);
+    if (!ligada) estado.desligadas.push(nome);
+    salvarEstado(estado);
+    return { ok: true, nome, ligada: !!ligada };
+}
+
+/**
+ * Apaga uma skill.
+ *
+ * As do produto voltam no próximo `listar()` — a cópia nasce de novo a partir
+ * do pacote. Por isso apagar uma delas não é apagar, é DESLIGAR: prometer
+ * remoção e ver a skill reaparecer amanhã é pior que dizer a verdade agora.
+ */
+function apagar(nome) {
+    const s = ler(nome);
+    if (!s) return { ok: false, error: `Não achei a skill "${nome}".` };
+    if (s.doProduto) {
+        ligar(nome, false);
+        return { ok: true, desligada: true,
+            aviso: 'Esta skill vem com o PrimoCode, então ela foi DESLIGADA em vez de apagada — '
+                + 'apagada, ela voltaria na próxima atualização.' };
+    }
+    try {
+        fs.rmSync(path.join(CASA, nome), { recursive: true, force: true });
+        return { ok: true, apagada: true };
+    } catch (e) { return { ok: false, error: e.message }; }
+}
+
+/**
+ * Instala de um arquivo ou de uma pasta que já está no disco.
+ *
+ * Não busca na rede de propósito: baixar e executar texto que virou prompt do
+ * agente é uma decisão que merece o caminho explícito de quem salvou o
+ * arquivo antes. O `/marketplace` traz as do catálogo; `/install-skill
+ * <caminho>` traz as que a pessoa escreveu ou recebeu.
+ */
+function instalarDe(caminho, { forcar = false } = {}) {
+    const alvo = String(caminho || '').replace(/^~(?=$|[/\\])/, os.homedir());
+    let arquivo = alvo;
+    try {
+        if (fs.statSync(alvo).isDirectory()) arquivo = path.join(alvo, 'SKILL.md');
+    } catch { return { ok: false, error: `Não achei ${caminho}.` }; }
+
+    /* O portão (lib/skill/portao-skill.js): skill de fora é texto que vira ordem
+       para um agente com o terminal na mão. Achou comando que manda dado para
+       fora, leitura de segredo ou prosa pedindo isso, não instala — devolve
+       os achados com arquivo:linha, e quem chamou pergunta se a pessoa quer
+       instalar mesmo assim (`forcar`). */
+    if (!forcar) {
+        const { achados } = portaoSkill.varrer(alvo);
+        if (achados.length) {
+            return { ok: false, bloqueada: true, achados,
+                error: `A skill pede coisas que podem vazar seus segredos (${achados.length} achado${achados.length > 1 ? 's' : ''}). Não instalei.` };
+        }
+    }
+
+    let texto;
+    try { texto = fs.readFileSync(arquivo, 'utf8'); }
+    catch { return { ok: false, error: `Não consegui ler ${arquivo}. Uma skill é um arquivo SKILL.md.` }; }
+
+    const { cabecalho, corpo } = separar(texto);
+    const nome = cabecalho.nome || path.basename(path.dirname(arquivo));
+    if (!corpo.trim()) return { ok: false, error: 'O arquivo não tem conteúdo depois do cabeçalho.' };
+    return criar(nome, corpo, cabecalho);
+}
+
+// ── o que entra no pedido ────────────────────────────────────────────────
+
+const semAcento = (v) => String(v || '').toLowerCase()
+    .normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+
+/**
+ * Quantas palavras do `quando:` aparecem no texto do pedido.
+ *
+ * ── PALAVRA INTEIRA, NUNCA PEDACO ────────────────────────────────────────
+ * O primeiro jeito era `texto.includes(palavra)`, e estava errado de um jeito
+ * que so apareceu no ensaio: "faz uma landing page PRO meu curso" puxou a
+ * skill de Git, porque o gatilho `pr` mora dentro de "pro". Gatilhos curtos
+ * — pr, api, seo, css — casam com metade da lingua portuguesa se a borda nao
+ * for exigida.
+ *
+ * Uma skill errada nao e ruido inofensivo: ela ocupa o teto de tokens do
+ * pedido e da ao modelo instrucoes sobre um assunto que ninguem pediu.
+ */
+function pontuar(skill, texto) {
+    const t = semAcento(texto);
+    let pontos = 0;
+    // "página, pagina" no gatilho é UMA palavra escrita de dois jeitos: sem
+    // acento as duas são iguais e contavam dois pontos, e a skill que listava
+    // as duas grafias ganhava das outras só por isso.
+    const vistas = new Set();
+    for (const palavra of skill.quando) {
+        const p = semAcento(palavra).trim();
+        if (!p || vistas.has(p)) continue;
+        vistas.add(p);
+        const escapado = p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // A borda e escrita a mao em vez de `\b`: o gatilho pode comecar ou
+        // terminar em simbolo ("e-mail"), e ali o `\b` nao vale.
+        const re = new RegExp('(^|[^a-z0-9])' + escapado + '($|[^a-z0-9])');
+        // Gatilho de várias palavras é mais específico ("render do vídeo" vale mais que "vídeo"):
+        // sem isso uma skill genérica e grande empata e come o teto da específica.
+        if (re.test(t)) pontos += p.split(/\s+/).length;
+    }
+    return pontos;
+}
+
+/**
+ * As skills que valem a pena para ESTE pedido, das mais ao menos relevantes.
+ *
+ * Só as ligadas, só as que casaram com alguma palavra, e só até o teto de
+ * caracteres. Skill que não casou não entra: mandar as oito em todo pedido
+ * custaria milhares de tokens para sete delas não terem nada a ver com o que
+ * foi pedido.
+ */
+function paraOPedido(texto, { teto = MAX_CARACTERES, todas = null } = {}) {
+    const lista = (todas || listar()).filter((s) => s.ligada && s.corpo);
+    const casadas = lista
+        .map((s) => ({ skill: s, pontos: pontuar(s, texto) }))
+        .filter((x) => x.pontos > 0)
+        .sort((a, b) => b.pontos - a.pontos);
+
+    const escolhidas = [];
+    let tamanho = 0;
+    for (const { skill } of casadas) {
+        if (tamanho + skill.corpo.length > teto) continue;
+        escolhidas.push(skill);
+        tamanho += skill.corpo.length;
+    }
+    return escolhidas;
+}
+
+/**
+ * O texto que vai na frente da tarefa.
+ *
+ * Vem antes do pedido, e não depois, pelo mesmo motivo do briefing dos
+ * especialistas: é contexto para ler o pedido, não um adendo a ele.
+ */
+function montar(texto, op = {}) {
+    const escolhidas = paraOPedido(texto, op);
+    if (!escolhidas.length) return { texto, skills: [] };
+    const blocos = escolhidas.map((s) => `### ${s.titulo}\n${s.corpo}`);
+    const cabeca = 'O QUE VOCÊ SABE SOBRE ESTE TIPO DE TAREFA (siga ao trabalhar):\n\n'
+        + blocos.join('\n\n') + '\n\n---\n\nPEDIDO:\n';
+    return { texto: cabeca + texto, skills: escolhidas };
+}
+
+/**
+ * O CARDÁPIO: a IA escolhe (01/10). "Tem que ser a IA que vai decidir o que
+ * ela vai fazer." Antes a skill entrava INTEIRA por contagem de palavra — e
+ * "faz um roteiro de vídeo" trazia "Motion de primeira", que mandava animar.
+ * Agora entra uma linha por skill (as que casam com o pedido primeiro, até
+ * 12), e o modelo carrega a que servir com `primocode skill <nome>` — como a
+ * ferramenta Skill do Claude Code. Custa uma ida a mais só quando a skill é
+ * usada, e as linhas custam menos que um corpo inteiro.
+ */
+function cardapio(texto, { todas = null, max = 12 } = {}) {
+    const lista = (todas || listar()).filter((s) => s.ligada && s.corpo);
+    if (!lista.length) return { texto, sugeridas: [] };
+    const comNota = lista.map((s) => ({ s, pontos: pontuar(s, texto) }))
+        .sort((a, b) => b.pontos - a.pontos || a.s.nome.localeCompare(b.s.nome));
+    const linhas = comNota.slice(0, max).map(({ s, pontos }) =>
+        `- ${s.nome}${pontos ? ' (pode servir)' : ''} — ${String(s.descricao || s.titulo).replace(/\s+/g, ' ').slice(0, 90)}`);
+    const cabeca = '[skills] Você decide se usa alguma. Se uma é do tipo desta tarefa, CARREGUE antes de começar '
+        + '(run_shell: primocode skill <nome>; várias na mesma resposta). Se nenhuma serve, ignore.\n'
+        + linhas.join('\n') + '\n\nPEDIDO:\n';
+    return { texto: cabeca + texto, sugeridas: comNota.filter((x) => x.pontos > 0).map((x) => x.s) };
+}
+
+/** `primocode skill <nome>` | `primocode skill list` — o corpo da skill, para o agente carregar. */
+function main(argv) {
+    const [nome] = argv;
+    if (!nome || nome === 'list' || nome === 'help') {
+        for (const s of listar().filter((x) => x.ligada)) console.log(`${s.nome} — ${s.descricao || s.titulo}`);
+        return 0;
+    }
+    const s = ler(apelidar(nome)) || listar().find((x) => x.nome.startsWith(String(nome).toLowerCase()));
+    if (!s) { console.log(`não há skill "${nome}" — veja primocode skill list`); return 1; }
+    console.log(`# ${s.titulo}\n\n${s.corpo}`);
+    return 0;
+}
+
+module.exports = {
+    cardapio, main,
+    impressao,
+    CASA, ORIGEM, MAX_CARACTERES,
+    separar, listar, ler, criar, ligar, apagar, instalarDe, apelidar,
+    paraOPedido, montar, pontuar, prepararCasa,
+};

package/lib/team.js

@@ -210,7 +210,7 @@ function rodar(nome, modo, { prompt, dir, linha = () => {}, prazo = PRAZO[modo],
         } catch (e) { resolve({ ok: false, erro: `Não consegui abrir o ${p.titulo}: ${e.message}` }); return; }
         let saida = '', final = null, resto = '', ultimoErro = '', estourou = false;
         const relogio = setTimeout(() => { estourou = true; try { filho.kill('SIGTERM'); } catch { /* já saiu */ } }, prazo);
-        const mostrar = (t) => { for (const l of String(t || '').split('\n')) if (l.trim()) linha(require('./ui').stripAnsi(l).slice(0, 200)); };
+        const mostrar = (t) => { for (const l of String(t || '').split('\n')) if (l.trim()) linha(require('./tui/ui').stripAnsi(l).slice(0, 200)); };
         filho.stdout.on('data', (d) => {
             resto += d.toString();
             const linhas = resto.split('\n');
@@ -226,7 +226,7 @@ function rodar(nome, modo, { prompt, dir, linha = () => {}, prazo = PRAZO[modo],
             clearTimeout(relogio);
             if (resto) { if (p.formato === 'stream-json') { const ev = lerEvento(resto); if (ev.fim !== undefined) final = ev.fim; } else saida += resto; }
             if (estourou) return resolve({ ok: false, erro: `O ${p.titulo} passou de ${Math.round(prazo / 60000)} min e eu parei ele.` });
-            const texto = require('./ui').stripAnsi(final !== null ? final : saida).trim();
+            const texto = require('./tui/ui').stripAnsi(final !== null ? final : saida).trim();
             if (codigo !== 0 && !texto) return resolve({ ok: false, erro: `O ${p.titulo} saiu com erro (código ${codigo})${ultimoErro ? `: ${ultimoErro.slice(0, 160)}` : ''}.` });
             resolve({ ok: true, texto });
         });
@@ -237,7 +237,7 @@ function rodar(nome, modo, { prompt, dir, linha = () => {}, prazo = PRAZO[modo],
  * `/team claude faz <pedido>`: o parceiro trabalha numa cópia do projeto (um
  * git worktree, quando é git; senão uma cópia da pasta), nunca no projeto. O
  * PrimoCode mede o que mudou, mostra, passa cada arquivo pelo portão dele
- * (lib/perigo.js) e só aplica com o "sim" da pessoa. O .env não vai pra cópia. */
+ * (lib/permission/perigo.js) e só aplica com o "sim" da pessoa. O .env não vai pra cópia. */
 
 const IDENTIDADE = ['-c', 'user.name=PrimoCode', '-c', 'user.email=primocode@local'];
 const FORA_DA_COPIA = /(^|[/\\])(node_modules|\.git)([/\\]|$)/;
@@ -287,7 +287,7 @@ function mudancasDaCopia(copia) {
 
 /** Cada arquivo passa pelo portão, como se o PrimoCode fosse escrever (ou apagar). → as recusas, [] = pode. */
 async function passarPeloPortao(arquivos, { projectDir: pasta, aplicarEm, modo, estado, perguntar }) {
-    const perigo = require('./perigo.js');
+    const perigo = require('./permission/perigo.js');
     const projectDir = real(pasta);
     const recusas = [];
     for (const a of arquivos) {

package/lib/tool/diagnostico.js

@@ -6,6 +6,8 @@
  *   .js .mjs .cjs → node --check (+ eslint se o projeto configurou e instalou)
  *   .py → compile() do python3     .ts .tsx → tsc local, se há tsconfig.json
  *   .json → JSON.parse             .sh → bash -n
+ * Com servidor de linguagem instalado (typescript-language-server, pyright, pylsp, gopls) o LSP vem primeiro
+ * pra .ts .tsx .jsx .py .go (lib/tool/lsp.js); PRIMOCODE_SEM_LSP=1 desliga só ele.
  * Sem verificador, ferramenta ausente ou timeout → null (nunca atrapalha a edição).
  * PRIMOCODE_SEM_DIAGNOSTICO=1 desliga.
  */
@@ -88,10 +90,19 @@ function diagnosticar(arquivo, projectDir) {
     } catch { return null; }
 }
 
-/** Anexa `diagnosticos` ao resultado de uma ferramenta de escrita. Não mexe no que não for ok. */
-function anexar(resultado, projectDir) {
+/** Anexa `diagnosticos` ao resultado de uma ferramenta de escrita. Não mexe no que não for ok.
+ *  Servidor de linguagem instalado (lib/tool/lsp.js) vale mais que o verificador simples; .js/.json/.sh ficam nos baratos. */
+async function anexar(resultado, projectDir) {
     if (!resultado || resultado.ok !== true || !resultado.path) return resultado;
-    const d = diagnosticar(path.resolve(projectDir, resultado.path), projectDir);
+    const arquivo = path.resolve(projectDir, resultado.path);
+    let d;
+    const ext = path.extname(arquivo).toLowerCase();
+    if (process.env.PRIMOCODE_SEM_DIAGNOSTICO !== '1' && fs.existsSync(arquivo) && !['.js', '.mjs', '.cjs', '.json', '.sh'].includes(ext)) {
+        const l = await require('./lsp').diagnosticarLsp(arquivo, projectDir);
+        if (l && !l.indisponivel) d = l;
+        else if (l === null) return resultado;           // o servidor checou e está limpo
+    }
+    if (!d) d = diagnosticar(arquivo, projectDir);
     if (!d) return resultado;
     return { ...resultado, diagnosticos: `${d.verificador} achou erro neste arquivo depois da edição:\n${d.erros}`,
         comoCorrigir: 'Corrija o erro acima com edit_file antes de seguir. Não diga que terminou com o arquivo quebrado.' };