primocode 9.9.0 → 10.0.0

package/lib/pipeline.js

@@ -217,8 +217,8 @@ Duas regras que valem mais que o resto:
 
 Responda com a especificação e mais nada.`;
 
-const CONSTRUTOR_1 = (spec, pasta) => `Você é o CONSTRUTOR 1, e o seu trabalho é
-o PROTÓTIPO que FUNCIONA.
+const CONSTRUTOR_1 = (spec, pasta) => `Você é o CONSTRUTOR, e o seu trabalho é
+o PRODUTO que FUNCIONA — de primeira, sem protótipo para alguém refazer depois.
 
 Construa na pasta: ${pasta}
 
@@ -243,39 +243,35 @@ Regras:
   digitar não mostra nada.
 · Não deixe função pela metade nem "TODO". O que não der para fazer, não
   prometa na tela.
+· Com TELA: hierarquia de tamanhos, espaço para respirar, estados de foco e de
+  toque, mensagem que diz o que fazer quando o campo está vazio, e nada de
+  rolagem horizontal em 390px. Uma paleta, mantida.
+· RÁPIDO: escreva cada arquivo UMA vez, inteiro, e vários na mesma rodada. O
+  resultado do write_file é a verdade — não releia o que acabou de escrever.
 
 Escreva os arquivos e diga em uma linha o que ficou pronto.`;
 
-const CONSTRUTOR_2 = (spec, pasta, relato) => `Você é o CONSTRUTOR 2, e o seu
-trabalho é virar o protótipo em PRODUTO.
+const CONSTRUTOR_2 = (spec, pasta, relato) => `Você é o CORRETOR. O produto já
+está construído na pasta ${pasta}, e alguém ABRIU e achou problema.
 
-A pasta é: ${pasta}
-LEIA os arquivos que já estão lá antes de mexer. Não recomece do zero: o que
-está funcionando fica.
-
-Especificação:
+O que foi pedido (resumo):
 
 """
 ${spec}
 """
 
-${relato ? `O revisor testou o que existe e achou isto:\n\n"""\n${relato}\n"""\n\n` : ''}\
-O que você faz:
+O que está errado:
 
-· CONSERTA o que o revisor apontou. Isso vem primeiro; nada de recurso novo com
-  erro aberto.
-· COMPLETA o que a especificação pede e o protótipo não faz.
-· REDESENHA: hierarquia de tamanhos, espaço para respirar, estados de foco e de
-  toque, e o que aparece quando não há dados. Escolha uma paleta e mantenha.
-· CUIDA DO ERRO: campo vazio, valor impossível, lista vazia. Cada um com uma
-  mensagem que diz o que fazer, não "erro".
-· RESPONSIVO de verdade: nada de rolagem horizontal em 390px de largura.
+"""
+${relato || '(sem relato)'}
+"""
 
-As três últimas valem para o que TEM TELA. Se isto roda no terminal, o
-equivalente é: mensagem de uso quando faltar argumento, saída legível, e código
-de saída diferente de zero quando der errado.
+· Conserte SÓ o que está apontado. Nada de recurso novo, nada de recomeçar.
+· Leia apenas o arquivo citado no erro — não a pasta inteira — e troque o trecho
+  com edit_file. Reescrever o arquivo inteiro só se ele estiver vazio ou em
+  branco.
+· Não releia o arquivo depois de editar: o resultado do edit_file é a verdade.
 
-Não escreva "pronto" sem ter aberto os arquivos e mudado o que precisa.
 Diga em uma linha o que mudou.`;
 
 const REVISOR = (spec, pasta, arquivos, relato) => `Você é o REVISADOR, e você
@@ -327,11 +323,12 @@ const APROVOU = /^\s*APROVAD[OA]\b/im;
  * @param {(prompt:string,rotulo:string)=>Promise<string>} op.correr  roda um agente
  * @param {(linha:string)=>void} op.mostrar   escreve na tela do usuário
  * @param {(alvo:string)=>any} [op.abrir]     abre no navegador da pessoa
- * @param {number} [op.rodadas]               voltas de correção (padrão 2)
+ * @param {number} [op.rodadas]               conferências, contando a primeira (padrão 3)
  */
 async function construir(op) {
     const { pedido, pasta, correr, mostrar = () => {}, abrir } = op;
-    const rodadasMax = Math.max(1, Math.min(4, op.rodadas == null ? 2 : op.rodadas));
+    // Quantas CONFERÊNCIAS (a primeira + os consertos). 3 = até dois consertos.
+    const rodadasMax = Math.max(1, Math.min(4, op.rodadas == null ? 3 : op.rodadas));
     if (!pedido) return { ok: false, error: 'Diga o que construir.' };
     if (!pasta) return { ok: false, error: 'Diga em que pasta construir.' };
     fs.mkdirSync(pasta, { recursive: true });
@@ -345,45 +342,47 @@ async function construir(op) {
             return { ok: false, error: 'O engenheiro de prompt não devolveu especificação. Faça você mesmo.' };
         }
 
-        mostrar('construtor 1 — protótipo');
-        await correr(CONSTRUTOR_1(spec, pasta), 'construtor 1');
-        etapas.push({ papel: 'construtor 1', arquivos: listar(pasta).length });
-
+        mostrar('construtor');
+        await correr(CONSTRUTOR_1(spec, pasta), 'construtor');
+        etapas.push({ papel: 'construtor', arquivos: listar(pasta).length });
+
+        /* ── CONFERIR: a máquina primeiro, o modelo só quando ela não sabe ──
+         * Antes eram quatro agentes no mínimo: engenheiro, protótipo, um
+         * construtor 2 que RELIA tudo para refazer como MVP, e um revisor que
+         * relia de novo para opinar. Era o "escreve dois arquivos e fica o dia
+         * lendo o que fez". Agora: a página abriu limpa no Chrome escondido?
+         * Está pronta — a medida é fato, e opinião por cima dela só custava.
+         * Abriu com erro? O corretor recebe o erro e troca o trecho. O revisor
+         * de modelo só entra quando não há página para medir (um app de
+         * terminal), porque aí "não sei" precisa de alguém que leia. */
         let relato = null;
         let aprovado = false;
         let ultimoRevisor = '';
 
         for (let volta = 1; volta <= rodadasMax; volta++) {
-            mostrar(`construtor 2 — ${volta === 1 ? 'MVP' : `correção ${volta - 1}`}`);
-            await correr(CONSTRUTOR_2(spec, pasta, relato), `construtor 2 (${volta})`);
-
-            mostrar('revisador — testando escondido');
+            mostrar(volta === 1 ? 'conferindo — abrindo a página escondido' : `conferindo o conserto ${volta - 1}`);
             const medida = await medirNoNavegador(pasta);
-            const arquivos = listar(pasta);
-            ultimoRevisor = await correr(
-                REVISOR(spec, pasta, arquivos, medida.relato), `revisador (${volta})`);
-
-            etapas.push({ papel: `revisador ${volta}`, testou: medida.testou,
-                limpo: medida.limpo, veredito: (ultimoRevisor || '').split('\n')[0] });
-
-            /* O veredito do modelo NÃO passa por cima do que a máquina mediu.
-               Página em branco ou erro de JavaScript é reprovação, e um
-               "APROVADO" escrito em cima disso é o revisor lendo o que ele
-               queria que estivesse lá — que é exatamente o defeito que separar
-               os papéis existe para evitar.
-
-               Mas o VETO precisa de MEDIDA: quando não deu para abrir nada —
-               porque o projeto não é uma página, ou porque não há navegador
-               nesta máquina — o que a máquina tem a dizer é "não sei", e "não
-               sei" não reprova. Sem esta distinção, um app de linha de comando
-               nunca seria aprovado: gastaria as voltas todas e terminaria
-               dizendo que não está pronto, sobre um trabalho que está. */
-            aprovado = APROVOU.test(ultimoRevisor || '') && !(medida.testou && !medida.limpo);
+            let veredito;
+            if (medida.testou) {
+                aprovado = medida.limpo;
+                veredito = medida.limpo ? 'APROVADO pela medida' : 'REPROVADO pela medida';
+                relato = medida.limpo ? null : medida.relato;
+            } else {
+                mostrar('revisador — lendo o que foi feito');
+                ultimoRevisor = await correr(
+                    REVISOR(spec, pasta, listar(pasta), medida.relato), `revisador (${volta})`);
+                aprovado = APROVOU.test(ultimoRevisor || '');
+                veredito = (ultimoRevisor || '').split('\n')[0];
+                relato = aprovado ? null : ultimoRevisor;
+            }
+            etapas.push({ papel: `conferência ${volta}`, testou: medida.testou, limpo: medida.limpo, veredito });
             if (aprovado) { mostrar('aprovado'); break; }
-
-            relato = medida.limpo ? ultimoRevisor : `${medida.relato}\n\n${ultimoRevisor || ''}`;
-            if (volta < rodadasMax) mostrar('reprovado — voltando para o construtor');
+            if (volta === rodadasMax) break;
+            if (!ultimoRevisor) ultimoRevisor = relato || '';
+            mostrar(`corretor — consertando (${volta})`);
+            await correr(CONSTRUTOR_2(spec, pasta, relato), `corretor (${volta})`);
         }
+        if (!ultimoRevisor && relato) ultimoRevisor = relato;
 
         const entrada = acharEntrada(pasta);
         let abriu = false;

package/lib/repeticao.js

@@ -62,7 +62,9 @@ function palavras(texto) {
 /** Quanto duas buscas se sobrepõem, de 0 a 1. */
 function semelhanca(a, b) {
     const A = palavras(a), B = palavras(b);
-    if (!A.size || !B.size) return A.size === B.size ? 1 : 0;
+    // Sem palavra que conte dos dois lados ("go" e "js"): só é a mesma busca
+    // se o texto for o mesmo.
+    if (!A.size || !B.size) return normalizar(a).trim() === normalizar(b).trim() ? 1 : 0;
     let juntos = 0;
     for (const p of A) if (B.has(p)) juntos++;
     return juntos / (A.size + B.size - juntos);

package/lib/skills.js

@@ -80,7 +80,13 @@ function separar(texto) {
 }
 
 function lerEstado() {
-    try { return JSON.parse(fs.readFileSync(ESTADO, 'utf8')); } catch { return { desligadas: [] }; }
+    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) {
@@ -200,7 +206,7 @@ function ler(nome) {
         quando: String(cabecalho.quando || '').split(',').map((s) => s.trim().toLowerCase()).filter(Boolean),
         autor: cabecalho.autor || '',
         corpo,
-        ligada: !estado.desligadas.includes(nome),
+        ligada: !(Array.isArray(estado.desligadas) && estado.desligadas.includes(nome)),
         doProduto: fs.existsSync(path.join(ORIGEM, nome, 'SKILL.md')),
         caminho: arquivo,
     };

package/lib/snapshot.js

@@ -0,0 +1,111 @@
+/**
+ * snapshot.js — a página como o agente precisa dela: o que dá para clicar e
+ * digitar, cada coisa com uma REF curta.
+ *
+ *   @e1 [link] "Preços" → /precos
+ *   @e2 [textbox] "E-mail" (seu@email.com)
+ *   @e3 [button] "Entrar"
+ *
+ * Antes o agente lia o innerText da página (6.000 caracteres de texto corrido,
+ * sem dizer o que é botão) e chutava um seletor CSS — `input[name="q"]` no
+ * Google, que é `textarea`. Errava, lia de novo, chutava de novo. Com a ref,
+ * clicar é `browser_click selector:"@e3"`: sem CSS, sem chute. A ideia é a do
+ * agent-browser da Vercel e do Playwright MCP (árvore de acessibilidade com
+ * refs); o código é nosso, roda no mesmo CDP que o PrimoCode já usa e não pede
+ * instalar nada.
+ *
+ * A ref mora no próprio elemento (data-primo-ref). Navegou ou a página se
+ * redesenhou, a ref some — e o erro diz para ler de novo, em vez de clicar no
+ * lugar errado.
+ */
+
+'use strict';
+
+const ATRIBUTO = 'data-primo-ref';
+
+/** O script que roda DENTRO da página e devolve { titulo, url, linhas, total }. */
+function scriptDoRetrato(max = 80) {
+    return `(function(){
+  var MAX = ${Number(max) || 80};
+  var ATR = ${JSON.stringify(ATRIBUTO)};
+  var velhos = document.querySelectorAll('[' + ATR + ']');
+  for (var i = 0; i < velhos.length; i++) velhos[i].removeAttribute(ATR);
+  function visivel(el) {
+    var r = el.getBoundingClientRect();
+    if (r.width < 2 || r.height < 2) return false;
+    var s = getComputedStyle(el);
+    return s.visibility !== 'hidden' && s.display !== 'none' && Number(s.opacity) > 0.05;
+  }
+  function limpo(t, n) { return String(t || '').replace(/\\s+/g, ' ').trim().slice(0, n || 60); }
+  function papel(el) {
+    var r = el.getAttribute('role');
+    if (r) return r;
+    var tag = el.tagName.toLowerCase();
+    if (tag === 'a') return 'link';
+    if (tag === 'button' || tag === 'summary') return 'button';
+    if (tag === 'select') return 'select';
+    if (tag === 'textarea') return 'textbox';
+    if (tag === 'input') {
+      var t = (el.type || 'text').toLowerCase();
+      if (t === 'checkbox' || t === 'radio') return t;
+      if (t === 'submit' || t === 'button' || t === 'reset') return 'button';
+      return 'textbox';
+    }
+    if (el.isContentEditable) return 'textbox';
+    return 'button';
+  }
+  function nome(el) {
+    var n = el.getAttribute('aria-label') || el.getAttribute('title') || '';
+    if (!n && el.id) { var l = document.querySelector('label[for="' + el.id + '"]'); if (l) n = l.innerText; }
+    if (!n && el.closest && el.closest('label')) n = el.closest('label').innerText;
+    // O innerText de um select são TODAS as opções — o nome dele é o rótulo.
+    if (!n && el.tagName !== 'SELECT') n = el.innerText || el.value || el.getAttribute('alt') || '';
+    if (!n) { var img = el.querySelector && el.querySelector('img[alt]'); if (img) n = img.alt; }
+    return limpo(n);
+  }
+  var SEL = 'a[href],button,input:not([type=hidden]),textarea,select,summary,[contenteditable=""],[contenteditable=true],'
+    + '[role=button],[role=link],[role=checkbox],[role=radio],[role=tab],[role=menuitem],[role=option],[role=textbox],'
+    + '[role=combobox],[role=switch],[role=searchbox],[onclick],h1,h2,h3';
+  var linhas = [], n = 0, total = 0;
+  var todos = document.querySelectorAll(SEL);
+  for (var j = 0; j < todos.length; j++) {
+    var el = todos[j];
+    if (!visivel(el)) continue;
+    var tag = el.tagName.toLowerCase();
+    if (/^h[1-3]$/.test(tag)) { var h = limpo(el.innerText, 80); if (h) linhas.push('#'.repeat(Number(tag[1])) + ' ' + h); continue; }
+    total++;
+    if (n >= MAX) continue;
+    n++;
+    var ref = 'e' + n;
+    el.setAttribute(ATR, ref);
+    var p = papel(el), txt = nome(el), extra = '';
+    if (p === 'link') { var href = el.getAttribute('href') || ''; if (href && href.indexOf('javascript:') !== 0) extra = ' → ' + href.slice(0, 60); }
+    if (p === 'textbox' && el.placeholder && el.placeholder !== txt) extra = ' (' + limpo(el.placeholder, 40) + ')';
+    if ((p === 'textbox' || p === 'select') && el.value) extra += ' = "' + limpo(el.value, 40) + '"';
+    if ((p === 'checkbox' || p === 'radio') && el.checked) extra += ' [marcado]';
+    if (el.disabled) extra += ' [desativado]';
+    linhas.push('@' + ref + ' [' + p + '] "' + txt + '"' + extra);
+  }
+  return { titulo: document.title, url: location.href, linhas: linhas, total: total };
+})()`;
+}
+
+/** Texto do retrato, pronto para o modelo. */
+function formatar(r, max = 80) {
+    if (!r) return '';
+    const cab = `${r.titulo || '(sem título)'} — ${r.url || ''}`;
+    const mais = r.total > max ? `\n… e mais ${r.total - max} elementos (role a página e leia de novo)` : '';
+    return `${cab}\n${(r.linhas || []).join('\n')}${mais}`;
+}
+
+/** "@e3" ou "e3" → o seletor CSS da ref; qualquer outra coisa passa igual. */
+function seletorDaRef(s) {
+    const m = /^@?(e\d+)$/.exec(String(s || '').trim());
+    return m ? `[${ATRIBUTO}="${m[1]}"]` : s;
+}
+function ehRef(s) { return /^@?e\d+$/.test(String(s || '').trim()); }
+
+const COMO_USAR = 'Para agir, use a ref como selector: browser_click selector:"@e3", '
+    + 'browser_type selector:"@e2" text:"…". A ref vale até a página mudar; depois de navegar, leia de novo.';
+
+module.exports = { scriptDoRetrato, formatar, seletorDaRef, ehRef, COMO_USAR, ATRIBUTO };

package/lib/tools.js

@@ -61,6 +61,8 @@ async function clicarPeloCursor(x, y, { botao = 'left', duplo = false, rotulo }
         () => (duplo ? desktop.doubleClick(nx, ny) : desktop.click(nx, ny, botao)));
 }
 const referencia = require('./referencia');
+const snapshot = require('./snapshot');
+const casar = require('./casar');
 const estudio = require('./estudio');
 const cfg = require('./config');
 
@@ -85,7 +87,8 @@ function resolveInProject(rawPath, projectDir) {
     }
     const target = path.resolve(base, rawPath || '.');
     const rel = path.relative(base, target);
-    if (rel.startsWith('..') || path.isAbsolute(rel)) {
+    // `..` como SEGMENTO, não como começo de nome: "..rascunho" é legítimo.
+    if (rel === '..' || rel.startsWith('..' + path.sep) || rel.startsWith('../') || path.isAbsolute(rel)) {
         throw new Error(`Caminho fora da pasta de trabalho: ${rawPath}`);
     }
     return target;
@@ -100,7 +103,10 @@ function treeDir(dir, maxDepth = 2, currentDepth = 0, prefix = '') {
         for (const item of items) {
             if (item.startsWith('.') && item !== '.env') continue;
             if (IGNORAR.has(item)) continue;
-            (fs.statSync(path.join(dir, item)).isDirectory() ? dirs : files).push(item);
+            // Link quebrado não derruba a listagem inteira: entra como arquivo.
+            let ehPasta = false;
+            try { ehPasta = fs.statSync(path.join(dir, item)).isDirectory(); } catch { ehPasta = false; }
+            (ehPasta ? dirs : files).push(item);
         }
         dirs.sort(); files.sort();
         const all = [...dirs, ...files];
@@ -109,7 +115,7 @@ function treeDir(dir, maxDepth = 2, currentDepth = 0, prefix = '') {
             const isLast = i === all.length - 1;
             result += prefix + (isLast ? '└── ' : '├── ') + item + '\n';
             const full = path.join(dir, item);
-            if (fs.statSync(full).isDirectory() && currentDepth < maxDepth) {
+            if (dirs.includes(item) && currentDepth < maxDepth) {
                 result += treeDir(full, maxDepth, currentDepth + 1, prefix + (isLast ? '    ' : '│   '));
             }
         }
@@ -262,7 +268,19 @@ async function runInNewTerminal(command, cwd) {
            como ~/Documents/Meus Projetos virava dois argumentos e o cd falhava
            calado: o terminal abria na pasta errada e o comando rodava no lugar
            errado, que é pior que não abrir. */
-        cmd = `osascript -e 'tell application "Terminal" to do script "cd ${pastaAlvo.replace(/ /g, '\\\\ ')} && ${command}"'`;
+        /* Sem shell no meio: o script vai como UM argumento do osascript
+           (execFile), e dentro dele a string do AppleScript é escapada (\\ e
+           \"). Antes o comando entrava cru entre aspas duplas dentro de aspas
+           simples — `node server.js --name="x"` quebrava o AppleScript. A
+           pasta vai entre aspas simples para o shell do Terminal (a aspa
+           simples está barrada acima). */
+        const doTerminal = `cd '${pastaAlvo}' && ${command}`;
+        const script = `tell application "Terminal" to do script "${doTerminal.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+        return new Promise((resolve) => {
+            execFile('osascript', ['-e', script], { timeout: 60000 }, (erro, _o, stderr) => {
+                resolve(erro ? { ok: false, error: String(stderr || erro.message).trim() || 'falhou' } : { ok: true, opener: 'osascript' });
+            });
+        });
     } else if (p === 'win32') {
         // Aspas em volta do caminho: "C:\Users\Joel Silva\..." é comum, e sem
         // elas o cmd corta no espaço. A aspa dupla já está barrada acima, então
@@ -273,7 +291,8 @@ async function runInNewTerminal(command, cwd) {
            o caminho não precisa entrar na string de shell nenhuma. É a solução
            mais segura das três: o que não é interpolado não pode ser mal
            escapado. */
-        cmd = `x-terminal-emulator -e "bash -c '${command}; exec bash'"`;
+        // A aspa simples do comando fecharia o `bash -c '…'`: vira '\''.
+        cmd = `x-terminal-emulator -e "bash -c '${String(command).replace(/'/g, "'\\''")}; exec bash'"`;
         pastaDoProcesso = pastaAlvo;
     }
     const r = await runShell(cmd, 60000, pastaDoProcesso);
@@ -315,7 +334,19 @@ function editFile({ path: rawPath, old_string, new_string, replace_all }, projec
     const original = fs.readFileSync(filePath, 'utf-8');
     const ocorrencias = original.split(old_string).length - 1;
 
+    // Não bateu letra por letra: o casador frouxo (lib/casar.js) acha o
+    // trecho com o espaço, a indentação ou o número de linha errados — desde
+    // que seja UM lugar só. Poupa a volta "não achei → relê → edita de novo".
+    let casado = null;
     if (ocorrencias === 0) {
+        const r = casar.achar(original, old_string);
+        if (r.erro === 'varios') {
+            return { ok: false, error: `Trecho aparece ${r.vezes} vezes (${r.como}). Inclua mais linhas em volta para ficar único.` };
+        }
+        if (!r.erro) casado = r;
+    }
+
+    if (ocorrencias === 0 && !casado) {
         // Erro seco faz o modelo chutar de novo. Devolvendo o que EXISTE no
         // arquivo, ele acerta na segunda tentativa.
         return {
@@ -329,15 +360,18 @@ function editFile({ path: rawPath, old_string, new_string, replace_all }, projec
         return { ok: false, error: `Trecho aparece ${ocorrencias} vezes. Inclua mais linhas em volta para ficar único, ou use replace_all.` };
     }
 
-    const atualizado = replace_all
-        ? original.split(old_string).join(new_string ?? '')
-        : original.replace(old_string, new_string ?? '');
+    const atualizado = casado
+        ? original.slice(0, casado.inicio) + (new_string ?? '') + original.slice(casado.fim)
+        : replace_all
+            ? original.split(old_string).join(new_string ?? '')
+            : original.replace(old_string, () => new_string ?? '');
 
     fs.writeFileSync(filePath, atualizado, 'utf-8');
     return {
         ok: true,
         path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
-        substituicoes: replace_all ? ocorrencias : 1,
+        substituicoes: replace_all && !casado ? ocorrencias : 1,
+        casouPor: casado ? casado.como : undefined,
         linhasAntes: original.split('\n').length,
         linhasDepois: atualizado.split('\n').length,
         // As duas versões, para a TELA desenhar o diff. O `_` na frente marca
@@ -391,12 +425,21 @@ function multiEdit({ path: rawPath, edits }, projectDir) {
         if (old_string === new_string) return { ok: false, error: `edit ${i + 1}: old_string e new_string são iguais` };
         const ocorrencias = conteudo.split(old_string).length - 1;
         if (ocorrencias === 0) {
-            return { ok: false, error: `edit ${i + 1}: trecho não encontrado`, trechosParecidos: trechosParecidos(conteudo, old_string) };
+            const r = casar.achar(conteudo, old_string);
+            if (r.erro === 'varios') {
+                return { ok: false, error: `edit ${i + 1}: trecho aparece ${r.vezes}x (${r.como}) — inclua mais contexto para torná-lo único` };
+            }
+            if (r.erro) {
+                return { ok: false, error: `edit ${i + 1}: trecho não encontrado`, trechosParecidos: trechosParecidos(conteudo, old_string) };
+            }
+            conteudo = conteudo.slice(0, r.inicio) + (new_string ?? '') + conteudo.slice(r.fim);
+            substituicoes++;
+            continue;
         }
         if (ocorrencias > 1 && !replace_all) {
             return { ok: false, error: `edit ${i + 1}: trecho aparece ${ocorrencias}x — use replace_all ou inclua mais contexto para torná-lo único` };
         }
-        conteudo = replace_all ? conteudo.split(old_string).join(new_string ?? '') : conteudo.replace(old_string, new_string ?? '');
+        conteudo = replace_all ? conteudo.split(old_string).join(new_string ?? '') : conteudo.replace(old_string, () => new_string ?? '');
         substituicoes++;
     }
 
@@ -544,24 +587,40 @@ async function despachar(name, args, ctx) {
             }
 
             // ── Navegador controlado (CDP) — o agente age numa página real ──
+            /* O navegador fala em REFS (lib/snapshot.js): abrir e clicar já
+               devolvem o retrato da página com "@e3 [button] Entrar", e o
+               selector aceita "@e3". Uma leitura a menos por passo, e nenhum
+               seletor CSS chutado. */
             case 'browser_open': {
                 const alvo = /^https?:\/\//i.test(args.url || '')
                     ? args.url
                     : 'file://' + resolveInProject(args.url, projectDir);
-                return browser.open(alvo);
+                const r = await browser.open(alvo);
+                return r && r.ok !== false ? { ...r, pagina: await browser.retrato(40), comoUsar: snapshot.COMO_USAR } : r;
+            }
+            case 'browser_click': {
+                let r;
+                if (args.selector || snapshot.ehRef(args.text)) r = await browser.clickSelector(snapshot.seletorDaRef(args.selector || args.text));
+                else if (args.text) r = await browser.clickText(args.text);
+                else if (args.x != null && args.y != null) r = await browser.click(args.x, args.y);
+                else return { ok: false, error: 'browser_click precisa de selector (ou a ref "@e3"), text ou x/y' };
+                // O clique quase sempre muda a página: o retrato novo vai junto.
+                await new Promise((ok) => setTimeout(ok, 500));
+                return r && r.ok !== false ? { ...r, pagina: await browser.retrato(40) } : r;
             }
-            case 'browser_click':
-                if (args.selector) return browser.clickSelector(args.selector);
-                if (args.text) return browser.clickText(args.text);
-                if (args.x != null && args.y != null) return browser.click(args.x, args.y);
-                return { ok: false, error: 'browser_click precisa de selector, text ou x/y' };
             case 'browser_type':
-                if (args.selector) return browser.typeInSelector(args.selector, args.text || '', args.clear !== false);
+                if (args.selector) return browser.typeInSelector(snapshot.seletorDaRef(args.selector), args.text || '', args.clear !== false);
                 return browser.type(args.text || '');
             case 'browser_key':
                 return browser.key(args.key);
             case 'browser_read': {
-                const sel = args.selector ? `document.querySelector(${JSON.stringify(args.selector)})` : 'document.body';
+                if (!args.selector) {
+                    const pagina = await browser.retrato(80);
+                    const texto = await browser.evaluate('(function(){return document.body?document.body.innerText.slice(0,2500):null;})()');
+                    if (!pagina && texto == null) return { ok: false, error: 'nada na página — ela pode não ter carregado' };
+                    return { ok: true, pagina, text: texto || '', comoUsar: snapshot.COMO_USAR };
+                }
+                const sel = `document.querySelector(${JSON.stringify(snapshot.seletorDaRef(args.selector))})`;
                 const texto = await browser.evaluate(`(function(){const e=${sel};return e?e.innerText.slice(0,6000):null;})()`);
                 return texto == null ? { ok: false, error: 'nada na página (ou seletor não encontrado)' } : { ok: true, text: texto };
             }
@@ -573,7 +632,7 @@ async function despachar(name, args, ctx) {
             case 'browser_scroll':
                 return browser.scroll(args.dy != null ? args.dy : 600);
             case 'browser_wait':
-                return browser.waitFor(args.selector, args.timeout_ms || 15000);
+                return browser.waitFor(snapshot.seletorDaRef(args.selector), args.timeout_ms || 15000);
             case 'browser_eval':
                 return { ok: true, value: await browser.evaluate(args.js || 'null') };
 

package/lib/ui.js

@@ -310,10 +310,10 @@ const TIPS = [
 ];
 
 const NEWS = [
-    'Vídeo com DIRETOR: roteiro, narração e voz decididos antes de produzir',
-    'Ele busca e baixa imagem, logo e música — com a licença junto do arquivo',
-    '/voice abre o Primo Code Voice · /marketplace instala skills',
-    'Do "high" para cima ele PESQUISA referências antes de escrever',
+    'Digite enquanto ele trabalha: o recado entra na tarefa depois do passo atual',
+    'Mais rápido: não relê o que escreveu, e a espera aparece com os segundos',
+    'primocode video help — o editor de vídeo que o agente opera sozinho',
+    'Motion novo: vox, marca e lancamento · /voice: fale, e ele responde em voz',
     'Esc Esc a qualquer momento para o agente no meio do trabalho',
 ];
 
@@ -413,6 +413,7 @@ class Spinner {
         this.text = this.textos[0];
         this.frames = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
         this.i = 0; this.timer = null; this.desde = 0; this.largura = 0;
+        this.detalhe = '';   // o que está chegando agora (act.js atualiza)
     }
     start() {
         // Fora de um terminal (pipe, CI) a animação só sujaria a saída.
@@ -423,10 +424,16 @@ class Spinner {
             // curta que a anterior: o resto da linha velha ficaria na tela, então
             // a linha é sempre preenchida até a maior largura já escrita.
             if (this.textos.length > 1) this.text = this.textos[Math.floor((Date.now() - this.desde) / 4000) % this.textos.length];
-            const cru = `  ${this.frames[this.i]} ${this.text}`;
+            /* O relógio e o que está chegando. "Parece travado" era isto: a
+               mesma frase girando por um minuto inteiro enquanto o modelo
+               escrevia um arquivo grande. Com os segundos contando (e o que
+               já chegou, quando há), quem olha sabe que está andando. */
+            const seg = Math.floor((Date.now() - this.desde) / 1000);
+            const extra = (seg >= 3 ? ` · ${seg}s` : '') + (this.detalhe ? ` · ${this.detalhe}` : '');
+            const cru = `  ${this.frames[this.i]} ${this.text}${extra}`;
             const falta = Math.max(0, this.largura - cru.length);
             this.largura = Math.max(this.largura, cru.length);
-            process.stdout.write(`\r  ${c.muted(this.frames[this.i])} ${c.muted(this.text)}${' '.repeat(falta)}`);
+            process.stdout.write(`\r  ${c.muted(this.frames[this.i])} ${c.muted(this.text)}${c.dim(extra)}${' '.repeat(falta)}`);
             this.i = (this.i+1) % this.frames.length;
         }, 80);
         return this;

package/lib/video/analise.js

@@ -0,0 +1,89 @@
+/**
+ * analise.js — silêncio e batida, como conta pura sobre números medidos.
+ *
+ * O ffmpeg mede (onde o áudio fica abaixo do limiar; as amostras cruas), e
+ * as decisões ficam aqui, testáveis sem áudio nenhum:
+ *
+ *   · o SILÊNCIO vira trecho da linha do tempo com `padding` de respiro em
+ *     cada ponta — cortar no exato instante em que a voz volta é o que faz
+ *     corte automático soar como máquina (lib/estudio/video.js conta a mesma
+ *     história). O silêncio no começo e no fim do arquivo sai inteiro;
+ *   · a BATIDA é o pico de subida de energia (onset), com limiar que se
+ *     adapta ao volume da música em volta. Não é um detector de tempo de
+ *     estúdio; é o bastante para cortar no ritmo.
+ */
+
+'use strict';
+
+const T = require('./timeline.js');
+
+/**
+ * Os trechos (quadros da linha do tempo) a apagar, dados os silêncios de
+ * cada mídia em segundos da origem: {assetId: [{de, ate}]}.
+ */
+function trechosDeSilencio(tl, clipes, silencios, { padding = 0.15, minimo = 2 } = {}) {
+    const ranges = [];
+    for (const c of clipes) {
+        const lista = silencios[c.asset] || [];
+        const dur = (tl.assets[c.asset] || {}).seconds || Infinity;
+        const { de, ate } = T.janelaOrigem(tl, c);
+        for (const s of lista) {
+            const a = s.de <= 0.05 ? s.de : s.de + padding;
+            const b = s.ate >= dur - 0.05 ? s.ate : s.ate - padding;
+            const ia = Math.max(a, de);
+            const ib = Math.min(b, ate);
+            if (ib <= ia) continue;
+            const fa = T.origemParaQuadro(tl, c, ia);
+            const fb = T.origemParaQuadro(tl, c, ib);
+            if (fb - fa >= minimo) ranges.push([fa, fb]);
+        }
+    }
+    return ranges;
+}
+
+/** Amostras (Float32, mono) → {bpm, beats: [segundos]}. */
+function batidas(amostras, taxa, { sensibilidade = 1.4, minimoEntre = 0.22 } = {}) {
+    const hop = Math.max(64, Math.round(taxa * 0.0116));      // ~11,6 ms
+    const janela = hop * 2;
+    const energia = [];
+    for (let i = 0; i + janela <= amostras.length; i += hop) {
+        let s = 0;
+        for (let j = i; j < i + janela; j++) s += amostras[j] * amostras[j];
+        energia.push(Math.log(1e-9 + s / janela));
+    }
+    const onset = energia.map((e, i) => (i ? Math.max(0, e - energia[i - 1]) : 0));
+    const porSeg = taxa / hop;
+    const raio = Math.round(porSeg * 0.5);
+    const beats = [];
+    let ultimo = -Infinity;
+    for (let i = 1; i < onset.length - 1; i++) {
+        const a = Math.max(0, i - raio);
+        const b = Math.min(onset.length, i + raio);
+        let soma = 0;
+        let soma2 = 0;
+        for (let j = a; j < b; j++) { soma += onset[j]; soma2 += onset[j] * onset[j]; }
+        const n = b - a;
+        const media = soma / n;
+        const dp = Math.sqrt(Math.max(0, soma2 / n - media * media));
+        const limiar = media + sensibilidade * dp;
+        let pico = onset[i] > limiar && onset[i] > 0.3;
+        for (let j = Math.max(0, i - 3); pico && j <= Math.min(onset.length - 1, i + 3); j++) if (onset[j] > onset[i]) pico = false;
+        const t = (i * hop) / taxa;
+        if (pico && t - ultimo >= minimoEntre) { beats.push(Math.round(t * 1000) / 1000); ultimo = t; }
+    }
+    return { bpm: bpmDe(beats), beats };
+}
+
+function bpmDe(beats) {
+    if (beats.length < 4) return null;
+    const iv = [];
+    for (let i = 1; i < beats.length; i++) iv.push(beats[i] - beats[i - 1]);
+    iv.sort((a, b) => a - b);
+    let med = iv[Math.floor(iv.length / 2)];
+    let bpm = 60 / med;
+    while (bpm < 70) bpm *= 2;
+    while (bpm > 180) bpm /= 2;
+    return Math.round(bpm);
+}
+
+module.exports = { trechosDeSilencio, batidas, bpmDe };