primocode 10.17.1 → 11.0.0

package/lib/tools.js

@@ -413,6 +413,22 @@ function trechosParecidos(conteudo, alvo, quantas = 8) {
 
 // Edição cirúrgica: troca um trecho exato em vez de reescrever o arquivo.
 // É o que impede o agente de reescrever 800 linhas para mudar uma.
+/* ── O ARQUIVO MUDOU DESDE QUE O AGENTE LEU ──────────────────────────────
+ * O agente lê, pensa, e edita em cima do que leu. Se a pessoa (ou o servidor de dev, ou outro agente)
+ * mexeu no arquivo no meio, a edição apagava o trabalho dela sem aviso. Guardamos a impressão (sha1)
+ * do que o agente viu por último — na leitura e nas próprias escritas — e recusamos editar por cima
+ * de uma versão que ele não viu. Arquivo nunca lido aqui passa (o old_string já confere o trecho). */
+const crypto = require('crypto');
+const VISTOS = new Map();
+const impressao = (texto) => crypto.createHash('sha1').update(texto).digest('hex');
+const marcarVisto = (filePath, texto) => { VISTOS.set(filePath, impressao(texto)); };
+function mudouPorFora(filePath, atual) {
+    const visto = VISTOS.get(filePath);
+    if (!visto || visto === impressao(atual)) return null;
+    return { ok: false, error: 'O arquivo mudou desde a última vez que você leu (alguém editou por fora). Nada foi escrito.',
+        comoResolver: `leia de novo com read_file("${path.basename(filePath)}") e refaça a edição em cima do que está lá agora.` };
+}
+
 function editFile({ path: rawPath, old_string, new_string, replace_all }, projectDir) {
     const filePath = resolveInProject(rawPath, projectDir);
     if (!fs.existsSync(filePath)) return { ok: false, error: `Arquivo não existe: ${rawPath}` };
@@ -420,6 +436,8 @@ function editFile({ path: rawPath, old_string, new_string, replace_all }, projec
     if (old_string === new_string) return { ok: false, error: 'old_string e new_string são iguais' };
 
     const original = fs.readFileSync(filePath, 'utf-8');
+    const mudou = mudouPorFora(filePath, original);
+    if (mudou) return mudou;
     const ocorrencias = original.split(old_string).length - 1;
 
     // Não bateu letra por letra: o casador frouxo (lib/casar.js) acha o
@@ -455,6 +473,7 @@ function editFile({ path: rawPath, old_string, new_string, replace_all }, projec
             : original.replace(old_string, () => new_string ?? '');
 
     fs.writeFileSync(filePath, atualizado, 'utf-8');
+    marcarVisto(filePath, atualizado);
     return {
         ok: true,
         path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
@@ -472,35 +491,51 @@ function editFile({ path: rawPath, old_string, new_string, replace_all }, projec
     };
 }
 
+/* O que volta ao modelo passa por um teto de ~6 mil caracteres de JSON (summarizeForModel, lib/act.js).
+   Antes a leitura devolvia até 40 mil e o teto cortava calado: o modelo via ~90 linhas de um arquivo de 600,
+   com "truncado: false", e editava às cegas o resto. Agora a leitura cabe no teto e diz até onde veio. */
+const TETO_LEITURA = 5000;
+function recortar(todas, inicio, maxLinhas) {
+    const linhas = [];
+    let tam = 0;
+    for (let i = inicio; i < todas.length && linhas.length < maxLinhas; i++) {
+        const l = `${i + 1}\t${todas[i]}`;
+        const t = JSON.stringify(l).length - 1;   // o custo dela dentro do JSON (aspas, \n escapado)
+        if (linhas.length && tam + t > TETO_LEITURA) break;
+        linhas.push(l.length > TETO_LEITURA ? l.slice(0, TETO_LEITURA) + '…(linha cortada)' : l);
+        tam += t;
+    }
+    return { content: linhas.join('\n'), de: inicio + 1, ate: inicio + linhas.length };
+}
+
 function readFile({ path: rawPath, offset, limit }, projectDir) {
     const filePath = resolverParaLer(rawPath, projectDir);
     const bruto = fs.readFileSync(filePath, 'utf-8');
+    marcarVisto(filePath, bruto);
     const todas = bruto.split('\n');
 
-    // Sem recorte pedido: devolve o começo, avisando que cortou.
-    if (offset == null && limit == null) {
-        const truncado = bruto.length > 40000;
-        return {
-            ok: true,
-            content: truncado ? bruto.slice(0, 40000) : bruto,
-            linhas: todas.length,
-            bytes: bruto.length,
-            truncado,
-            dica: truncado ? 'Use offset/limit para ler o resto.' : undefined,
-        };
+    // Cabe inteiro: vem inteiro, do jeito que está.
+    if (offset == null && limit == null && JSON.stringify(bruto).length <= TETO_LEITURA) {
+        return { ok: true, content: bruto, linhas: todas.length, bytes: bruto.length, truncado: false };
     }
 
     /* Arquivo pequeno vem INTEIRO, mesmo pedido aos pedaços: o modelo lia um
        app.js de 393 linhas de 50 em 50, cada pedaço uma ida ao servidor
-       (teste da loja, 01/10). Inteiro, uma vez, custa menos. */
-    if (todas.length <= 400 && bruto.length <= 40000) {
-        return { ok: true, content: todas.map((l, i) => `${i + 1}\t${l}`).join('\n'), linhas: todas.length, bytes: bruto.length,
-            inteiro: true, dica: 'arquivo pequeno: veio inteiro, com o número das linhas — não precisa ler de novo' };
+       (teste da loja, 01/10). Inteiro, uma vez, custa menos — se couber. */
+    const inteiro = recortar(todas, 0, todas.length);
+    if (inteiro.ate === todas.length) {
+        return { ok: true, content: inteiro.content, linhas: todas.length, bytes: bruto.length, inteiro: true,
+            dica: 'veio inteiro, com o número das linhas — não precisa ler de novo' };
     }
-    const inicio = Math.max(0, (offset || 1) - 1);
-    const fim = Math.min(todas.length, inicio + (limit || 200));
-    const recorte = todas.slice(inicio, fim).map((l, i) => `${inicio + i + 1}\t${l}`).join('\n');
-    return { ok: true, content: recorte, linhas: todas.length, de: inicio + 1, ate: fim, bytes: bruto.length };
+    const inicio = Math.min(Math.max(0, (offset || 1) - 1), Math.max(0, todas.length - 1));
+    const pedido = Math.max(1, Number(limit) || 200);
+    const r = recortar(todas, inicio, pedido);
+    const resto = r.ate < todas.length;
+    return {
+        ok: true, content: r.content, linhas: todas.length, de: r.de, ate: r.ate, bytes: bruto.length,
+        truncado: resto,
+        ...(resto ? { proximoOffset: r.ate + 1, dica: `vieram as linhas ${r.de}–${r.ate} de ${todas.length} (o teto de uma leitura). Continue com read_file offset=${r.ate + 1}, ou use grep pra achar o trecho.` } : {}),
+    };
 }
 
 // ── multi_edit: várias trocas no mesmo arquivo, em ordem, tudo-ou-nada ────
@@ -510,6 +545,8 @@ function multiEdit({ path: rawPath, edits }, projectDir) {
     if (!Array.isArray(edits) || !edits.length) return { ok: false, error: 'edits (lista) é obrigatório' };
 
     let conteudo = fs.readFileSync(filePath, 'utf-8');
+    const mudou = mudouPorFora(filePath, conteudo);
+    if (mudou) return mudou;
     const original = conteudo;
     const linhasAntes = conteudo.split('\n').length;
     let substituicoes = 0;
@@ -539,6 +576,7 @@ function multiEdit({ path: rawPath, edits }, projectDir) {
     }
 
     fs.writeFileSync(filePath, conteudo, 'utf-8');
+    marcarVisto(filePath, conteudo);
     return {
         ok: true,
         path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
@@ -580,7 +618,12 @@ function getTodos() { return TODOS; }
  */
 async function execute(name, args, ctx) {
     try {
-        return await despachar(name, args, ctx);
+        const r = await despachar(name, require('./tool/reparar-entrada').reparar(args, require('./tool/reparar-entrada').SCHEMAS[name]), ctx);
+        // Escreveu arquivo? O verificador mais barato da linguagem roda e o erro volta junto (lib/tool/diagnostico.js).
+        if (name === 'write_file' || name === 'edit_file' || name === 'multi_edit') {
+            return require('./tool/diagnostico').anexar(r, (ctx && ctx.projectDir) || process.cwd());
+        }
+        return r;
     } catch (e) {
         // Erro que sabe o que EXISTE leva a informação junto — mesma ideia do
         // `trechosParecidos` do edit_file. Erro seco faz o modelo chutar de novo.
@@ -637,8 +680,10 @@ async function despachar(name, args, ctx) {
                 // tela o que foi perdido.
                 let antes = '';
                 if (!created) { try { antes = fs.readFileSync(filePath, 'utf-8'); } catch { antes = ''; } }
+                if (!created) { const mudou = mudouPorFora(filePath, antes); if (mudou) return mudou; }
                 fs.mkdirSync(path.dirname(filePath), { recursive: true });
                 fs.writeFileSync(filePath, content, 'utf-8');
+                marcarVisto(filePath, content);
                 return {
                     ok: true, created,
                     path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
@@ -672,12 +717,39 @@ async function despachar(name, args, ctx) {
                 const r = grepFiles({ ...args, glob: b.padrao }, b.raiz);
                 return b.outra && r && r.ok !== false ? { ...r, pasta: b.raiz } : r;
             }
-            case 'run_shell':
+            case 'run_shell': {
+                /* `primocode kit …` (lib/kits.js) roda aqui dentro: a tela de gosto e a de referências abrem
+                   deste processo (no app, pela linha de protocolo do stderr dele), e o render fala no terminal. */
+                const kit = await require('./kits.js').doShell(args.command, { projectDir,
+                    abrirVideo: process.stdout.isTTY && process.env.PRIMOCODE_APP !== '1' ? (arq) => { try { openInBrowser(arq); } catch { /* sem navegador */ } } : null,
+                    aoFalar: (t) => { try { process.stdout.write(require('./ui.js').c.muted(`  ⎿ ${t}`) + '\n'); } catch { /* sem terminal */ } } });
+                if (kit) return kit;
                 // Dentro da cerca (lib/sandbox.js); desligada ou sem mecanismo cai no exec de sempre.
-                return sandbox.executar(args.command, { projectDir, timeout: args.timeout_ms || 60000,
+                // em_segundo_plano: devolve um id na hora; a saída se lê com background_output e o fim chega como aviso.
+                if (args.em_segundo_plano === true || args.em_segundo_plano === 'true') {
+                    return require('./fundo').iniciar(args.command, { projectDir, env: ambienteLimpo(process.env, permitidasNoShell()) });
+                }
+                const prazo = Number(args.timeout_ms) || 60000;
+                const r = await sandbox.executar(args.command, { projectDir, timeout: prazo,
                     env: ambienteLimpo(process.env, permitidasNoShell()) });
+                // morto pelo prazo: sem isto parecia um erro do código ("code 1", saída vazia) e o modelo "consertava" o que não quebrou
+                if (r && r.ok === false && r.killed) {
+                    const quanto = prazo >= 1000 ? `${String(+(prazo / 1000).toFixed(1)).replace('.', ',')} s` : `${prazo} ms`;
+                    return { ...r, error: `passou do prazo de ${quanto} e foi parado (não é erro do código). Comando longo (build, install, servidor, testes lentos): rode com run_background e leia com background_output, ou passe timeout_ms maior.` };
+                }
+                return r;
+            }
             case 'run_in_new_terminal':
                 return runInNewTerminal(args.command, args.cwd || projectDir);
+            /* Em segundo plano, com a saída legível (lib/fundo.js). Mesmo env
+               filtrado do run_shell: o servidor de dev não herda as chaves. */
+            case 'run_background':
+                return require('./fundo').iniciar(args.command, { projectDir,
+                    env: ambienteLimpo(process.env, permitidasNoShell()) });
+            case 'background_output':
+                return require('./fundo').saida(args.id, { desde: args.desde });
+            case 'stop_background':
+                return require('./fundo').parar(args.id);
             case 'open_in_browser': {
                 const alvo = /^https?:\/\//i.test(args.target || '')
                     ? args.target
@@ -696,10 +768,20 @@ async function despachar(name, args, ctx) {
                 return multiEdit(args, projectDir);
             case 'write_todos':
                 return writeTodos(args);
+            case 'agentes_buscar':
+                return require('./agentes').ferramentaBuscar(args || {});
+            case 'capacidade_buscar':
+                return require('./agentes').ferramentaCapacidade(args || {});
 
             // Pesquisa de referência: abre documentação e exemplos sobre o
             // pedido e devolve o TEXTO para o modelo aprender antes de
             // escrever. Aparece no terminal, com as fontes — nada oculto.
+            case 'perguntar':
+                return require('./tool/perguntar').perguntar(args, ctx);
+            case 'buscar_web':
+                return require('./tool/web').buscarWeb(args);
+            case 'ler_url':
+                return require('./tool/web').lerUrl(args);
             case 'pesquisar_referencia': {
                 const r = await referencia.pesquisar({
                     consulta: args.consulta || args.query || '',

package/lib/trava.js

@@ -0,0 +1,155 @@
+/**
+ * trava.js — o /lock: arquivo que o agente só pode LER.
+ *
+ *   ler(projectDir)                   → ['login.js', …]                  (as travas deste projeto, relativas)
+ *   travar(projectDir, lista)         → { travados, fora, novos }         (fora = caminho fora da pasta; não entra)
+ *   soltar(projectDir, alvo | 'tudo') → { soltos, travados }
+ *   estaTravado(projectDir, caminho)  → 'login.js' | null                 (o arquivo, ou a pasta travada que o contém)
+ *   recusa(nome, args, projectDir)    → { motivo, error } | null          (o portão: write_file, edit_file, multi_edit e shell)
+ *
+ * Mora em <projeto>/.primocode/travados.json: é do projeto, não da pessoa, e some junto com a pasta. A trava vale em
+ * TODOS os modos, até no livre: quem trava "logo.png" não quer que um "sim" automático a leve embora. O próprio arquivo
+ * das travas também é protegido: sem isso o agente soltava a trava editando o json.
+ *
+ * O shell é a porta dos fundos: `sed -i`, `> arquivo`, `mv`, `rm`, `git checkout -- arquivo`, e um `python3 -c` que
+ * cita o arquivo e escreve. Lê-lo (cat, grep) segue livre.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ESCRITAS = new Set(['write_file', 'edit_file', 'multi_edit']);
+const COMANDOS = new Set(['run_shell', 'run_in_new_terminal', 'run_background']);
+const ARQUIVO_DAS_TRAVAS = '.primocode/travados.json';
+// comandos que escrevem só no ÚLTIMO argumento (o destino); nos demais, qualquer argumento é alvo
+const SO_DESTINO = new Set(['cp', 'rsync', 'install', 'ln']);
+const ESCREVEM = new Set(['tee', 'cp', 'mv', 'ln', 'install', 'touch', 'truncate', 'rm', 'rmdir', 'rsync', 'dd', 'chmod', 'chown', 'trash', 'unlink', 'shred']);
+const GIT_ESCREVE = new Set(['checkout', 'restore', 'rm', 'mv', 'stash', 'reset', 'clean', 'apply', 'merge', 'rebase', 'pull']);
+const INTERPRETES = /^(python[\d.]*|node|bun|deno|ruby|perl|php)$/;
+
+const norm = (p) => String(p || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+const arquivoDe = (projectDir) => path.join(projectDir, ARQUIVO_DAS_TRAVAS);
+const expandir = (a) => String(a).replace(/^~(?=\/|$)/, os.homedir());
+
+function ler(projectDir) {
+    try {
+        const j = JSON.parse(fs.readFileSync(arquivoDe(projectDir), 'utf8'));
+        return (Array.isArray(j.arquivos) ? j.arquivos : []).map(norm).filter(Boolean);
+    } catch { return []; }
+}
+
+function gravar(projectDir, lista) {
+    const f = arquivoDe(projectDir);
+    if (!lista.length) { try { fs.rmSync(f); } catch { /* já não existia */ } return; }
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    fs.writeFileSync(f, JSON.stringify({ arquivos: lista }, null, 2) + '\n');
+}
+
+/** Um caminho digitado → relativo ao projeto, ou null se cai fora dele. */
+function relativo(projectDir, alvo) {
+    const abs = path.resolve(projectDir, expandir(alvo));
+    const rel = path.relative(path.resolve(projectDir), abs);
+    if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return null;
+    return norm(rel);
+}
+
+function travar(projectDir, lista) {
+    const atuais = ler(projectDir), fora = [], novos = [];
+    for (const a of lista) {
+        const rel = relativo(projectDir, a);
+        if (!rel) { fora.push(a); continue; }
+        if (!atuais.includes(rel)) { atuais.push(rel); novos.push(rel); }
+    }
+    if (novos.length) gravar(projectDir, atuais);
+    return { travados: atuais, fora, novos };
+}
+
+function soltar(projectDir, alvo) {
+    const atuais = ler(projectDir);
+    if (String(alvo).toLowerCase() === 'tudo') { gravar(projectDir, []); return { soltos: atuais, travados: [] }; }
+    const rel = relativo(projectDir, alvo);
+    const resto = atuais.filter((x) => x !== rel);
+    if (resto.length !== atuais.length) gravar(projectDir, resto);
+    return { soltos: atuais.filter((x) => x === rel), travados: resto };
+}
+
+/** A trava que cobre este caminho (arquivo igual, ou pasta travada que o contém). */
+function estaTravado(projectDir, caminho, lista = ler(projectDir)) {
+    const rel = relativo(projectDir, caminho);
+    if (!rel) return null;
+    return lista.find((t) => rel === t || rel.startsWith(t + '/')) || null;
+}
+
+const mensagem = (t) => `Recusado: esse arquivo está travado, use /lock off ${t}. A pessoa travou ${t} para você só poder ler. `
+    + 'Não tente escrever nele por outro caminho (outro comando, python -c, cópia por cima): conte na resposta que está travado e siga sem ele.';
+
+function doArquivo(projectDir, caminho, lista) {
+    if (relativo(projectDir, caminho) === ARQUIVO_DAS_TRAVAS) {
+        return { motivo: 'mexe nas travas do /lock', error: 'Recusado: o arquivo das travas só muda pelo comando /lock, que é da pessoa.' };
+    }
+    const t = estaTravado(projectDir, caminho, lista);
+    return t ? { motivo: `arquivo travado (${t})`, error: mensagem(t) } : null;
+}
+
+/** Um trecho de shell (palavras) escreve em arquivo travado? → { motivo, error } | null */
+function trechoEscreve(palavras, cwd, projectDir, lista) {
+    let p = palavras.slice();
+    while (p.length && (/^[A-Za-z_]\w*=/.test(p[0]) || ['env', 'nohup', 'time', 'command', 'exec', 'sudo', 'xargs'].includes(p[0]))) p.shift();
+    if (!p.length) return null;
+    const cmd = path.basename(p[0]);
+    const args = p.slice(1);
+    const confere = (w) => {
+        const alvo = path.resolve(cwd, expandir(w));
+        return doArquivo(projectDir, alvo, lista);
+    };
+    // redirecionamento: `> f`, `>> f`, `2> f`, `>f`
+    for (let i = 0; i < p.length; i++) {
+        const w = p[i];
+        const alvo = /^\d?>>?$/.test(w) ? p[i + 1] : /^\d?>>?./.test(w) ? w.replace(/^\d?>>?/, '') : null;
+        if (alvo && alvo !== '/dev/null') { const r = confere(alvo); if (r) return r; }
+    }
+    if ((cmd === 'sh' || cmd === 'bash' || cmd === 'zsh') && args[0] === '-c' && args[1]) return comandoEscreve(args[1], cwd, projectDir, lista);
+    if (INTERPRETES.test(cmd)) {
+        const i = args.findIndex((x) => /^-[ce]$|^--eval$/.test(x));
+        const codigo = i >= 0 ? String(args[i + 1] || '') : '';
+        if (codigo && /write|open\s*\([^)]*,\s*['"][^'"]*[wax+]|unlink|remove|rename|truncate|>/i.test(codigo)) {
+            for (const t of lista) if (codigo.includes(path.posix.basename(t))) return { motivo: `arquivo travado (${t})`, error: mensagem(t) };
+        }
+        return null;
+    }
+    const alvos = args.filter((x) => !/^-/.test(x));
+    if (cmd === 'git') {
+        if (!GIT_ESCREVE.has(alvos[0])) return null;
+        for (const w of alvos.slice(1)) { const r = confere(w); if (r) return r; }
+        return null;
+    }
+    const sedI = cmd === 'sed' && args.some((w) => /^-[a-zA-Z]*i/.test(w) || w === '--in-place');
+    const perlI = cmd === 'perl' && args.some((w) => /^-[a-zA-Z]*i/.test(w));
+    if (!ESCREVEM.has(cmd) && !sedI && !perlI) return null;
+    for (const w of SO_DESTINO.has(cmd) ? alvos.slice(-1) : alvos) { const r = confere(w); if (r) return r; }
+    return null;
+}
+
+function comandoEscreve(comando, cwd, projectDir, lista) {
+    const { trechos } = require('./perigo.js');   // aqui dentro: o perigo.js também carrega este arquivo
+    for (const t of trechos(comando)) { const r = trechoEscreve(t.palavras, cwd, projectDir, lista); if (r) return r; }
+    return null;
+}
+
+/** O portão: a ação escreve num arquivo travado? */
+function recusa(nome, args, projectDir) {
+    const a = args || {};
+    const projeto = path.resolve(projectDir || process.cwd());
+    if (ESCRITAS.has(nome) && a.path) return doArquivo(projeto, path.resolve(projeto, expandir(a.path)), ler(projeto));
+    if (COMANDOS.has(nome) && a.command) {
+        const lista = ler(projeto);
+        const cwd = a.cwd ? path.resolve(projeto, expandir(a.cwd)) : projeto;
+        return comandoEscreve(a.command, cwd, projeto, lista);
+    }
+    return null;
+}
+
+module.exports = { ler, travar, soltar, estaTravado, recusa, relativo, ARQUIVO_DAS_TRAVAS };

package/lib/ui.js

@@ -460,6 +460,15 @@ function welcomeBox(version, contexto, opts = {}) {
    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];
@@ -467,6 +476,7 @@ class Spinner {
         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.
@@ -481,7 +491,7 @@ class Spinner {
             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 = (seg >= 3 ? ` · ${seg}s` : '') + (this.detalhe ? ` · ${this.detalhe}` : '');
+                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);
@@ -497,7 +507,7 @@ class Spinner {
                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 = (seg >= 3 ? ` · ${seg}s` : '') + (this.detalhe ? ` · ${this.detalhe}` : '');
+            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);
@@ -536,8 +546,8 @@ const agora = { texto: '', desde: 0 };
 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', open_in_browser:'Open', spawn_agent:'Agent',
-        write_todos:'Plano', finish:'Finish', pesquisar_referencia:'Pesquisa',
+        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',
@@ -575,7 +585,7 @@ const ROTULOS = {
 function encurtarCaminhos(texto) {
     const home = require('os').homedir();
     return String(texto || '')
-        .replace(/(?:~|\/[^\s'"]*?)\/\.primocode\/studio\/projetos\/(?:\d{4}-\d{2}\/)?([^\/\s'"]+)\/?/g, (m, id) => `projeto ${id} › `)
+        .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; });
 }
@@ -631,7 +641,7 @@ function friendlyError(raw) {
     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 /status; se persistir, o servidor precisa '
+            + 'anterior à do aplicativo. Confira em /doctor status; se persistir, o servidor precisa '
             + 'ser atualizado.';
     }
 
@@ -710,9 +720,35 @@ function friendlyError(raw) {
     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.';
     }
@@ -723,4 +759,5 @@ function friendlyError(raw) {
 
 
 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 };

package/lib/video/conferir-legenda.js

@@ -0,0 +1,47 @@
+/**
+ * conferir-legenda.js — depois da legenda automática, as palavras que valem uma olhada, com o tempo de cada uma.
+ *
+ *   duvidosas(palavras, { corte, max }) → [{ i, texto, de, motivo }]   (na ordem do tempo; puro)
+ *   texto(lista)                        → a frase pra pessoa (e pro modelo repetir)   (puro)
+ *
+ * A legenda automática erra mais em nome, marca e número, e quem corrige linha por linha não sabe por onde começar
+ * (a página de ajuda do CapCut manda revisar tudo: capcut.com/pt-br/help/auto-captions-in-capcut [VERIFICAR]). O
+ * faster-whisper já diz o quanto teve certeza de cada palavra (`p`, de 0 a 1, voz/primo_voz/transcrever.py); abaixo
+ * do corte, a palavra entra na lista. Número e nome entram sempre: são os erros que mais aparecem. A transcrição do
+ * servidor, ou um cache antigo, não tem `p`: aí só número e nome.
+ */
+
+'use strict';
+
+const CORTE = 0.6;
+const limpa = (t) => String(t || '').replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, '');
+
+function duvidosas(palavras, { corte = CORTE, max = 10 } = {}) {
+    const out = [];
+    (palavras || []).forEach((w, i) => {
+        const t = limpa(w.texto);
+        if (!t) return;
+        const anterior = i > 0 ? String(palavras[i - 1].texto || '') : '.';
+        const comecoDeFrase = /[.!?]\s*$/.test(anterior);
+        let motivo = null;
+        // "e", "o", "da": palavra curta trocada quase não muda o sentido, e encheria a lista
+        if (Number.isFinite(w.p) && w.p < corte && t.length >= 3) motivo = 'o ouvido não teve certeza';
+        else if (/\d/.test(t)) motivo = 'número';
+        else if (/^\p{Lu}/u.test(t) && !comecoDeFrase && t.length > 1) motivo = 'nome';
+        if (motivo) out.push({ i, texto: t, de: Number(w.de) || 0, motivo });
+    });
+    // quando sobra: primeiro a de menos certeza, depois número, depois nome; e aí volta pra ordem do tempo, que é como se confere
+    const peso = (d) => (d.motivo === 'número' ? 2 : d.motivo === 'nome' ? 3 : palavras[d.i].p);
+    const ordem = out.slice().sort((a, b) => peso(a) - peso(b)).slice(0, max);
+    return ordem.sort((a, b) => a.de - b.de);
+}
+
+const relogio = (s) => `${String(Math.floor(s / 60)).padStart(2, '0')}:${String(Math.floor(s % 60)).padStart(2, '0')}`;
+
+function texto(lista) {
+    if (!lista.length) return '';
+    return `Confira ${lista.length === 1 ? 'esta palavra' : `estas ${lista.length} palavras`} na legenda: `
+        + lista.map((d) => `"${d.texto}" (${relogio(d.de)}, ${d.motivo})`).join(', ') + '.';
+}
+
+module.exports = { duvidosas, texto, CORTE };

package/lib/video/ops.js

@@ -205,7 +205,12 @@ const OPS = {
             const asset = T.acharAsset(ctx.tl, a.asset);
             const t = await TR.obter(ctx.p.dir, asset);
             if (!t.ok) return t;
-            return mutar(ctx, 'add_captions', (tl) => ({ captions: E.legendas(tl, TR.mapear(tl, asset.id, t.palavras), a).length }));
+            // o que vale conferir vai junto da resposta: o modelo repete pra pessoa, com o tempo de cada palavra
+            const CL = require('./conferir-legenda.js');
+            const mapa = TR.mapear(ctx.tl, asset.id, t.palavras);
+            // o tempo é o do vídeo editado (depois dos cortes), não o da gravação: é onde a pessoa vai procurar
+            const conferir = CL.texto(CL.duvidosas(mapa.map((w) => ({ texto: w.texto, de: T.segundos(ctx.tl, w.f), p: t.palavras[w.i].p }))));
+            return mutar(ctx, 'add_captions', (tl) => ({ captions: E.legendas(tl, TR.mapear(tl, asset.id, t.palavras), a).length, ...(conferir ? { conferir } : {}) }));
         },
     },
     apply_color: {

package/lib/video/transcript.js

@@ -114,7 +114,7 @@ async function obter(pasta, asset, { force = false, idioma = 'pt' } = {}) {
             comoResolver: 'python3 -m pip install faster-whisper (local), ou entre na conta do PrimoCode' };
     }
     const palavras = (r.palavras || []).filter((p) => p && p.texto && p.ate > p.de)
-        .map((p) => ({ de: Number(p.de), ate: Number(p.ate), texto: String(p.texto).trim() }));
+        .map((p) => ({ de: Number(p.de), ate: Number(p.ate), texto: String(p.texto).trim(), ...(Number.isFinite(Number(p.p)) && p.p != null ? { p: Number(p.p) } : {}) }));
     const dados = { asset: asset.id, fonte, idioma, palavras };
     fs.mkdirSync(path.dirname(cache), { recursive: true });
     fs.writeFileSync(cache, JSON.stringify(dados));

package/lib/web-pagina.js

@@ -0,0 +1,87 @@
+/**
+ * web-pagina.js — o /web <url>: a página vira texto, anexado ao próximo pedido.
+ *
+ *   baixar(url, {buscar, prazoMs, tetoBytes}) → {ok, url, titulo, texto, palavras} | {ok:false, error}
+ *   textoDaPagina(html)                      → {titulo, texto}   (puro)
+ *
+ * Por quê: colar o link no pedido faz o agente gastar rodadas pesquisando, e o modelo grátis às vezes
+ * nem chama a ferramenta. Com o /web, o texto já vai junto, como um /attach, e a pessoa vê o que foi.
+ * Só lê: sem JavaScript da página, sem cookie, sem login. Página que só existe depois do JS chega vazia,
+ * e isso é dito em vez de anexar nada.
+ */
+
+'use strict';
+
+const TETO_TEXTO = 12000;   // ~3 mil tokens: cabe no plano grátis sem empurrar a conversa pra fora
+
+const ENTIDADES = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ', mdash: '—', ndash: '–', hellip: '…', laquo: '«', raquo: '»', copy: '©', ordm: 'º', ordf: 'ª' };
+// os acentos do português por nome (&atilde; &ccedil; …), em minúscula e maiúscula
+for (const [base, marcas] of Object.entries({ a: 'acute grave circ tilde uml', e: 'acute grave circ uml', i: 'acute grave circ uml', o: 'acute grave circ tilde uml', u: 'acute grave circ uml', c: 'cedil', n: 'tilde' })) {
+    const sinal = { acute: '\u0301', grave: '\u0300', circ: '\u0302', tilde: '\u0303', uml: '\u0308', cedil: '\u0327' };
+    for (const m of marcas.split(' ')) { ENTIDADES[base + m] = (base + sinal[m]).normalize('NFC'); ENTIDADES[base.toUpperCase() + m] = (base.toUpperCase() + sinal[m]).normalize('NFC'); }
+}
+function decodificar(t) {
+    return t.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, e) => {
+        if (e[0] === '#') { const n = e[1].toLowerCase() === 'x' ? parseInt(e.slice(2), 16) : Number(e.slice(1)); return Number.isFinite(n) && n > 0 && n < 0x110000 ? String.fromCodePoint(n) : m; }
+        return ENTIDADES[e] != null ? ENTIDADES[e] : ENTIDADES[e.toLowerCase()] != null ? ENTIDADES[e.toLowerCase()] : m;
+    });
+}
+
+/** O texto que se lê na página: sem script, estilo, menu e rodapé; títulos e itens de lista viram linhas próprias. */
+function textoDaPagina(html) {
+    let h = String(html || '');
+    const titulo = decodificar(((h.match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [])[1] || '').replace(/\s+/g, ' ').trim());
+    h = h.replace(/<!--[\s\S]*?-->/g, ' ')
+        .replace(/<(script|style|noscript|svg|nav|footer|header|form|iframe|template)\b[\s\S]*?<\/\1>/gi, ' ');
+    const corpo = (h.match(/<(main|article)\b[\s\S]*?<\/\1>/i) || [])[0] || h;
+    const texto = decodificar(corpo
+        .replace(/<h([1-6])\b[^>]*>/gi, (m, n) => '\n\n' + '#'.repeat(Number(n)) + ' ')
+        .replace(/<li\b[^>]*>/gi, '\n- ')
+        .replace(/<\/h[1-6]\b[^>]*>/gi, '\n\n')
+        .replace(/<(br|\/p|\/div|\/li|\/ul|\/ol|\/tr|\/section)\b[^>]*>/gi, '\n')
+        .replace(/<[^>]+>/g, ' '))
+        .replace(/[ \t ]+/g, ' ')
+        .replace(/ *\n */g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return { titulo, texto };
+}
+
+async function baixar(url, { buscar = fetch, prazoMs = 15000, tetoBytes = 3 * 1024 * 1024 } = {}) {
+    let u;
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(url) && !/^https?:\/\//i.test(url)) return { ok: false, error: 'só leio páginas http e https' };
+    try { u = new URL(/^https?:\/\//i.test(url) ? url : 'https://' + url); } catch { return { ok: false, error: `não entendi o endereço "${url}"` }; }
+    if (!/^https?:$/.test(u.protocol)) return { ok: false, error: 'só leio páginas http e https' };
+    const ctl = new AbortController();
+    const relogio = setTimeout(() => ctl.abort(), prazoMs);
+    try {
+        const r = await buscar(u.href, { signal: ctl.signal, redirect: 'follow', headers: { 'user-agent': 'Mozilla/5.0 (PrimoCode /web)', accept: 'text/html,text/plain;q=0.9,*/*;q=0.5' } });
+        if (!r.ok) return { ok: false, error: `a página respondeu ${r.status}` };
+        const tipo = String((r.headers && r.headers.get && r.headers.get('content-type')) || '');
+        if (tipo && !/text\/|html|xml|json/i.test(tipo)) return { ok: false, error: `isso não é uma página de texto (${tipo.split(';')[0]})` };
+        const bruto = await r.text();
+        if (bruto.length > tetoBytes) return { ok: false, error: 'a página é grande demais pra anexar inteira' };
+        const { titulo, texto } = /html|xml/i.test(tipo) || /<html|<body|<p\b/i.test(bruto) ? textoDaPagina(bruto) : { titulo: '', texto: bruto.trim() };
+        if (texto.length < 80) return { ok: false, error: 'a página veio quase vazia (deve montar o conteúdo com JavaScript, que o /attach não roda)' };
+        const corte = texto.length > TETO_TEXTO ? texto.slice(0, TETO_TEXTO) + '\n\n[… cortado: a página continua]' : texto;
+        return { ok: true, url: u.href, titulo, texto: corte, palavras: corte.split(/\s+/).filter(Boolean).length, cortado: texto.length > TETO_TEXTO };
+    } catch (e) {
+        return { ok: false, error: e.name === 'AbortError' ? `a página não respondeu em ${Math.round(prazoMs / 1000)} s` : `não consegui abrir: ${e.message}` };
+    } finally {
+        clearTimeout(relogio);
+    }
+}
+
+/** Os "@https://…" do pedido: o link vira anexo, como o "@index.html" já vira. Só com @ (link solto é o agente que
+    decide se abre), no máximo 2, sem a pontuação que gruda no fim da frase. Puro. */
+function urlsDoPedido(texto) {
+    const out = [];
+    for (const m of String(texto || '').matchAll(/(?:^|\s)@(https?:\/\/[^\s<>"'`]+)/gi)) {
+        const u = m[1].replace(/[.,;:!?)\]}]+$/, '');
+        if (!out.includes(u)) out.push(u);
+        if (out.length === 2) break;
+    }
+    return out;
+}
+
+module.exports = { baixar, textoDaPagina, urlsDoPedido, TETO_TEXTO };