primocode 10.0.0 → 10.1.0

package/lib/tools.js

@@ -209,9 +209,35 @@ function grepFiles({ pattern, glob, ignoreCase, contexto = 0, maxResultados = 10
     return { ok: true, arquivosVistos, total: resultados.length, resultados, truncado: resultados.length >= maxResultados };
 }
 
-async function runShell(command, timeout = 60000, cwd) {
+/* ── O SHELL DO AGENTE NASCE SEM SEGREDO ──────────────────────────────────
+   Antes, o run_shell herdava o process.env inteiro: o agente rodava `env` e
+   lia o NPM_TOKEN, a chave da Anthropic, o GH_TOKEN de quem usa — e o que o
+   agente lê pode ir parar no modelo, num arquivo ou numa página (prompt
+   injection). Peça 3 do OpenBot (comum/desmontados/copilotkit-openbot.md):
+   o shell do agente não herda o ambiente do processo pai.
+
+   Filtro por NOME, não lista do que passa: PATH, HOME, LANG, TERM, SHELL,
+   USER, NODE_*, nvm etc. continuam — sem eles `npm`, `node` e `git` quebram.
+   Na dúvida o nome sai: um token a mais escondido custa pouco, um a menos
+   vaza. Só o caminho do agente (execute → run_shell) é filtrado; os usos
+   internos (abrir terminal, desinstalar) seguem com o ambiente inteiro. */
+const NOME_SECRETO = /(TOKEN|SECRET|KEY|PASSWORD|PASSWD|CREDENTIAL|AUTH|COOKIE|SESSION)/i;
+const PREFIXO_SECRETO = /^(AWS_|OPENAI_|ANTHROPIC_|GEMINI_|GOOGLE_API|GROQ_|OPENROUTER_|AZURE_|HF_|HUGGING)/i;
+const SEMPRE_PASSA = new Set(['PATH', 'HOME', 'USER', 'LOGNAME', 'SHELL', 'LANG', 'TERM', 'TMPDIR', 'PWD', 'SSH_AUTH_SOCK']);
+
+function ambienteLimpo(env = process.env) {
+    const limpo = {};
+    for (const [nome, valor] of Object.entries(env)) {
+        if (valor === undefined) continue;
+        if (!SEMPRE_PASSA.has(nome) && (NOME_SECRETO.test(nome) || PREFIXO_SECRETO.test(nome))) continue;
+        limpo[nome] = valor;
+    }
+    return limpo;
+}
+
+async function runShell(command, timeout = 60000, cwd, env) {
     return new Promise((resolve) => {
-        exec(command, { timeout, cwd: cwd || process.cwd(), maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+        exec(command, { timeout, cwd: cwd || process.cwd(), maxBuffer: 10 * 1024 * 1024, env: env || process.env }, (error, stdout, stderr) => {
             if (error) resolve({ ok: false, code: error.code ?? 1, stdout, stderr, killed: error.killed });
             else resolve({ ok: true, code: 0, stdout, stderr });
         });
@@ -402,6 +428,13 @@ function readFile({ path: rawPath, offset, limit }, projectDir) {
         };
     }
 
+    /* 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' };
+    }
     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');
@@ -553,13 +586,21 @@ async function despachar(name, args, ctx) {
             case 'grep':
                 return grepFiles(args, projectDir);
             case 'run_shell':
-                return runShell(args.command, args.timeout_ms || 60000, projectDir);
+                return runShell(args.command, args.timeout_ms || 60000, projectDir, ambienteLimpo());
             case 'run_in_new_terminal':
                 return runInNewTerminal(args.command, args.cwd || projectDir);
             case 'open_in_browser': {
                 const alvo = /^https?:\/\//i.test(args.target || '')
                     ? args.target
                     : resolveInProject(args.target, projectDir);
+                /* Site da web abre À VISTA no Chrome controlado (o cursor vai na
+                   barra e digita). Arquivo do projeto continua no navegador padrão. */
+                if (/^https?:/i.test(alvo) && process.env.PRIMOCODE_BROWSER_HEADLESS !== '1' && require('./cursor').disponivel()) {
+                    try {
+                        const r = await browser.abrirVisivel(alvo);
+                        if (r && r.ok !== false) return { ok: true, opener: 'chrome à vista', url: r.url, pagina: await browser.retrato(40), comoUsar: snapshot.COMO_USAR };
+                    } catch { /* cai no navegador padrão */ }
+                }
                 return openInBrowser(alvo);
             }
             case 'multi_edit':
@@ -570,11 +611,14 @@ async function despachar(name, args, ctx) {
             // 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 'pesquisar_referencia':
-                return referencia.pesquisar({
+            case 'pesquisar_referencia': {
+                const r = await referencia.pesquisar({
                     consulta: args.consulta || args.query || '',
                     paginas: Math.max(1, Math.min(5, Number(args.paginas) || 3)),
                 });
+                // Escopo fechado ("só do site x.com"): o buscador devolve o mundo; aqui só passa o site.
+                return require('./estudio/referencias.js').filtrar(r);
+            }
 
             // memory-geral.md fica FORA da pasta do projeto — write_file/edit_file
             // não alcançam por design (resolveInProject bloqueia ../ de propósito).
@@ -595,7 +639,8 @@ async function despachar(name, args, ctx) {
                 const alvo = /^https?:\/\//i.test(args.url || '')
                     ? args.url
                     : 'file://' + resolveInProject(args.url, projectDir);
-                const r = await browser.open(alvo);
+                // Endereço da web abre À VISTA: o cursor vai na barra e digita (browser.abrirVisivel).
+                const r = /^https?:/i.test(alvo) ? await browser.abrirVisivel(alvo) : await browser.open(alvo);
                 return r && r.ok !== false ? { ...r, pagina: await browser.retrato(40), comoUsar: snapshot.COMO_USAR } : r;
             }
             case 'browser_click': {
@@ -692,7 +737,7 @@ async function despachar(name, args, ctx) {
              * lib/estudio/ para o porquê de cada peça.
              */
             case 'estudio_projeto':
-                return estudio.ferramentaProjeto(args);
+                return estudio.ferramentaProjeto(args, ctx);
             case 'estudio_plano':
                 return estudio.ferramentaPlano(args);
             case 'estudio_midia':
@@ -834,7 +879,7 @@ async function uninstall() {
 }
 
 module.exports = {
-    fmtBytes, treeDir, runShell, openInBrowser, runInNewTerminal,
+    fmtBytes, treeDir, runShell, ambienteLimpo, openInBrowser, runInNewTerminal,
     execute, uninstall, resolveInProject, globToRegex, globFiles, grepFiles, editFile,
     multiEdit, writeTodos, getTodos,
 };

package/lib/ui.js

@@ -310,11 +310,11 @@ const TIPS = [
 ];
 
 const NEWS = [
-    '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',
+    'A IA decide o caminho: skills e equipe num cardápio, ela escolhe o que usa',
+    'Até 8 agentes em paralelo, cada um volta com uma entrega — e passa a vez',
+    'Edite falando no vídeo: primocode video auto aplica o que você diz, na hora',
+    'Colou texto grande? Vira etiqueta [Colado #1 · N linhas] na caixa',
+    'Escopo fechado de verdade: "só do site x.com" filtra a pesquisa',
 ];
 
 // ── Cabeçalho ────────────────────────────────────────────────────────────
@@ -419,6 +419,21 @@ class Spinner {
         // Fora de um terminal (pipe, CI) a animação só sujaria a saída.
         if (!process.stdout.isTTY) return this;
         this.desde = Date.now();
+        /* Com a caixa de digitar no ar, o spinner desenha DENTRO dela (ver
+           mostrarSpinner em lib/entrada.js): escrever "\r" por cima apagava
+           a caixa e a barra de status enquanto ele girava. */
+        const caixa = Spinner.caixa;
+        if (caixa && caixa.mostrarSpinner && caixa.desenhado !== undefined) {
+            this.naCaixa = caixa;
+            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}` : '');
+                caixa.mostrarSpinner(`${c.muted(this.frames[this.i])} ${c.muted(this.text)}${c.dim(extra)}`);
+                this.i = (this.i + 1) % this.frames.length;
+            }, 120);
+            return this;
+        }
         this.timer = setInterval(() => {
             // Com mais de uma frase, troca a cada 4s. A frase nova pode ser mais
             // curta que a anterior: o resto da linha velha ficaria na tela, então
@@ -439,10 +454,29 @@ class Spinner {
         return this;
     }
     stop() {
+        if (this.naCaixa) {
+            if (this.timer) { clearInterval(this.timer); this.timer = null; }
+            this.naCaixa.mostrarSpinner('');
+            this.naCaixa = null;
+            return;
+        }
         if (this.timer) { clearInterval(this.timer); this.timer = null; process.stdout.write(`\r${' '.repeat(Math.max(80, this.largura + 4))}\r`); }
     }
 }
 
+/* O TÍTULO DO TERMINAL: é por ele que o Orca (e qualquer terminal com abas)
+   sabe que este painel é um agente e se está trabalhando. O Orca lê o glifo
+   de spinner em braile como "trabalhando" e o nome como identidade — então
+   "⠋ PrimoCode — tarefa" enquanto trabalha, "PrimoCode" parado. Vai pelo
+   canal cru da caixa: pelo stdout embrulhado, um escape sem quebra de linha
+   deixaria a caixa apagada (o mesmo defeito do spinner). */
+function titulo(texto) {
+    if (!process.stdout.isTTY || process.env.PRIMOCODE_SEM_TITULO === '1') return;
+    const limpo = String(texto || '').replace(/[\x00-\x1f\x7f]/g, ' ').slice(0, 80);
+    const escrever = Spinner.caixa && Spinner.caixa.escreverCru ? Spinner.caixa.escreverCru : (s) => process.stdout.write(s);
+    try { escrever(`\x1b]0;${limpo}\x07`); } catch { /* terminal fechado */ }
+}
+
 // O rótulo de cada tool na tela — o que a pessoa lê no lugar do nome interno.
 const ROTULOS = {
         read_file:'Read', write_file:'Write', edit_file:'Edit', multi_edit:'MultiEdit',
@@ -616,4 +650,5 @@ function friendlyError(raw) {
 }
 
 
-module.exports = { c, mascot, MASCOTES, resolverMascote, mascoteInfo, galeriaMascotes, reacao, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };
+module.exports = {
+    titulo, c, mascot, MASCOTES, resolverMascote, mascoteInfo, galeriaMascotes, reacao, welcomeBox, Spinner, PENSANDO, actionHeader, friendlyError, visibleWidth, stripAnsi, truncate, padRight };

package/lib/video/auto.js

@@ -0,0 +1,329 @@
+/**
+ * auto.js — `primocode video auto`: o vídeo é o pedido.
+ *
+ *   "Quero que ele leia o que eu falo no vídeo e aplique cada pedido no
+ *    momento em que eu digo." (01/10)
+ *
+ * A pessoa grava falando o que quer ("separe em camadas", "coloca o logo do
+ * Claude aqui", "com o estalar de dedos me coloca numa praia") e o editor
+ * acha cada pedido na transcrição e o ancora no que o rastro viu: a palavra,
+ * a mão que aparece logo depois, o estalo que vem em seguida, o juntar das
+ * mãos. Nada de quadro escrito à mão.
+ *
+ *   planejar(dados) → [{op, args(segundos da origem), motivo}]   pura (o teste roda)
+ *   OPS.auto.run    → junta os dados, executa o plano, devolve o que fez
+ *
+ * Tudo em SEGUNDOS DA ORIGEM até a hora de executar: os cortes (silêncio,
+ * fim) vão por último e a legenda depois deles, já nos cortes.
+ */
+
+'use strict';
+
+const PED = require('./pedido.js');
+
+const tira = (s) => String(s || '').normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+const r2 = (n) => Math.round(n * 100) / 100;
+
+/* O que o Whisper ouve no lugar do que a pessoa disse — visto nos dois
+   primeiros vídeos de verdade: "cloud", "Claudio", "xgbt", "estravar",
+   "instruar de dedos". Normaliza antes de qualquer regra. */
+const OUVIDO = [
+    [/\b(claudio|claudia|cloud|clode|clod|claud|cloude)\b/g, 'claude'],
+    [/\b(x ?gbt|x ?gpt|chat ?gbt|chat ?gpt|chat ?jpt|tchat ?gpt|chatgbt|gbt)\b/g, 'chatgpt'],
+    [/\bgoogle\s+(chrome|drive)\b/g, '$1'],
+    [/\b(estr[ae]l\w*|estrav\w*|estal\w*|instru\w*|estral\w*)\s+(?:os|nos|dos|de|o|do)?\s*dedos?\b/g, 'estalar o dedo'],
+    [/\b(estal\w*|estral\w*)\b/g, 'estalar'],
+];
+function normal(t) {
+    let s = tira(t).replace(/[^a-z0-9 ]/g, ' ').replace(/\s+/g, ' ').trim();
+    for (const [re, por] of OUVIDO) s = s.replace(re, por);
+    return s;
+}
+
+/* "colocar um foguete aqui na palma da minha mão": qualquer coisa na mão, não
+   só as logos. Vira o modelo, se houver, ou a placa com o nome. */
+const NA_MAO = /\b(?:coloc\w*|po[er]\w*|bot\w*|aparec\w*)\s+(?:um|uma|o|a)\s+([a-z]{3,20})(?:\s+[a-z]{3,20})?\s+(?:aqui\s+)?(?:na|em|sobre|nas)\s+(?:a\s+)?(?:palma|mao|maos)\b/g;
+const NAO_OBJETO = /^(logo|imagem|foto|fundo|legenda|praia|cerebro|video|mao|coisa)$/;
+function objetoNaMao(t) {
+    const out = [];
+    let m;
+    NA_MAO.lastIndex = 0;
+    while ((m = NA_MAO.exec(t))) if (!NAO_OBJETO.test(m[1])) out.push({ object: m[1], pos: m.index, mao: null });
+    return out;
+}
+
+/** As palavras viram frases: ponto final, ou pausa de mais de 0,7 s. */
+function frases(palavras) {
+    const out = [];
+    let atual = [];
+    const fecha = () => { if (atual.length) out.push({ ws: atual, de: atual[0].de, ate: atual[atual.length - 1].ate }); atual = []; };
+    palavras.forEach((p, i) => {
+        const ant = palavras[i - 1];
+        if (ant && p.de - ant.ate > 0.7) fecha();
+        atual.push(p);
+        if (/[.!?]$/.test(String(p.texto).trim())) fecha();
+    });
+    fecha();
+    for (const f of out) f.t = normal(f.ws.map((w) => w.texto).join(' '));
+    return out;
+}
+
+/** O segundo em que a frase diz `re` (a primeira palavra que casa), ou o começo dela. */
+function quando(f, re) {
+    for (let i = 0; i < f.ws.length; i++) {
+        const um = normal(f.ws[i].texto);
+        const dois = normal(f.ws.slice(i, i + 3).map((w) => w.texto).join(' '));
+        if (re.test(um) || (re.test(dois) && !re.test(normal(f.ws.slice(i + 1, i + 3).map((w) => w.texto).join(' '))))) return f.ws[i].de;
+    }
+    return f.de;
+}
+
+const RE = {
+    camadas: /\bcamadas?\b|\btres dimens|\b(tir\w*|remov\w*|recort\w*|separ\w*)\s+(?:me\s+)?(?:o\s+|do\s+|meu\s+)?fundo\b|\bme\s+(tir\w*|recort\w*)\s+do\s+fundo\b/,
+    volta: /\bvolt\w*\b|\bnormal\b/,
+    estalo: /\bestalar\b/,
+    juntar: /\bjunt\w*\b|\buni\w*\b/,
+    cerebro: /\bcerebro\b/,
+    silencio: /\bsilencios?\b/,
+    fim: /\b(encerr|acab|termin|finaliz)\w*\b/,
+    legenda: /\blegendas?\b/,
+    acima: /\b(em cima|acima|encima|sobre|por cima)\s+da\s+(?:minha\s+)?cabeca\b|\baqui em cima\b|\bla em cima\b/,
+    imagem: /\b(?:imagem|foto|fundo)\s+(?:de|do|da)\s+(?:(?:um|uma)\s+)?([a-z]{3,20})\b/,
+};
+
+/** O fundo pedido na frase: um lugar conhecido, ou "imagem de um tubarão". */
+function fundoPedido(t) {
+    const l = PED.lugar(t);
+    if (l && !/^(tras|atras|aqui)$/.test(l)) return l;
+    const m = t.match(RE.imagem);
+    return m && !/^(tras|atras|aqui|novo|nova)$/.test(m[1]) ? m[1] : null;
+}
+
+/**
+ * dados: {palavras:[{texto,de,ate}], estalos:[{t,score,mao}], juntaAbre:[{junta,abre}],
+ *         maos:{left:[[de,ate]],right:[[de,ate]]}, silencios:[{de,ate}], dur}  — tudo em segundos.
+ * → {passos:[{op,args,motivo}], legenda:{color?,position?,desde?}}
+ */
+function planejar(d) {
+    const fs = frases(d.palavras || []);
+    const passos = [];
+    const bons = (d.estalos || []).filter((e) => e.mao || e.score >= 20);
+    const usados = new Set();
+    /* O estalo da janela é o MAIS FORTE dela, não o primeiro: o dedo que se
+       prepara faz um "tec" fraco antes do estalo de verdade (visto: 10,3 s
+       com 17 antes do 11,8 s com 21). */
+    const estaloDepois = (t, janela) => {
+        const c = bons.filter((x) => x.t >= t - 0.2 && x.t <= t + janela && !usados.has(x.t)).sort((a, b) => b.score - a.score)[0];
+        if (!c) return undefined;
+        usados.add(c.t);
+        return c.t;
+    };
+    const ehPedido = (f) => RE.camadas.test(f.t) || !!fundoPedido(f.t) || PED.objetosCitados(f.t).length || RE.juntar.test(f.t) || RE.silencio.test(f.t) || RE.fim.test(f.t);
+
+    // 1. As camadas em 3D: da palavra até o "volta" (ou o próximo pedido), 2,5–5 s.
+    const iCam = fs.findIndex((f) => RE.camadas.test(f.t) && !fundoPedido(f.t));
+    if (iCam >= 0) {
+        const de = Math.max(0, quando(fs[iCam], /camada|fundo|tir|recort|separ/) - 0.2);
+        const prox = fs.slice(iCam + 1).find((f) => f.de > de + 1 && (RE.volta.test(f.t) || ehPedido(f)));
+        const ate = Math.min(d.dur, de + 5, Math.max(de + 2.5, prox ? prox.de : de + 4));
+        passos.push({ op: 'separate_layers', args: { show3d: true, from: r2(de), to: r2(ate) }, motivo: `"${fs[iCam].t}"` });
+    }
+
+    // 2. Os objetos: na palavra, na mão que aparece logo ali (a outra, se a primeira já tem um).
+    const objetos = [];
+    const maoEm = (t, ocupadas) => {
+        const cand = [];
+        for (const lado of ['left', 'right']) {
+            for (const [a, b] of (d.maos && d.maos[lado]) || []) {
+                if (b < t - 0.2 || a > t + 3) continue;
+                cand.push({ lado, a: Math.max(a, t), b });
+            }
+        }
+        cand.sort((x, y) => (ocupadas.has(x.lado) - ocupadas.has(y.lado)) || x.a - y.a);
+        return cand[0] || null;
+    };
+    for (const f of fs) {
+        for (const o of [...PED.objetosCitados(f.t), ...objetoNaMao(f.t)]) {
+            const nome = o.object === 'chatgpt' ? /chatgpt|gpt/ : new RegExp(o.object.slice(0, 5));
+            const t = quando(f, nome);
+            if (objetos.some((x) => x.object === o.object && Math.abs(x.t - t) < 4)) continue;
+            const ocupadas = new Set(objetos.filter((x) => x.ate === null || x.ate > t).map((x) => x.mao));
+            const m = maoEm(t, ocupadas);
+            const mao = o.mao === 'left' || o.mao === 'right' ? o.mao : m ? m.lado : (ocupadas.has('left') ? 'right' : 'auto');
+            objetos.push({ object: o.object, t, de: m && m.lado === mao ? m.a : t, mao, ate: null, motivo: `"${f.t}"` });
+        }
+    }
+
+    // 3. Juntar as mãos (com objeto na mão): a junção que vem depois da frase; o cérebro se for dito.
+    let fusao = null;
+    if (objetos.length) {
+        const iJ = fs.findIndex((f) => (RE.juntar.test(f.t) || RE.cerebro.test(f.t)) && f.ate > objetos[0].t);
+        if (iJ >= 0) {
+            const f = fs[iJ];
+            const ev = (d.juntaAbre || []).find((e) => e.junta >= f.de - 1.5 && e.junta > objetos[0].de + 0.5);
+            if (ev) {
+                const cerebro = [f, fs[iJ + 1]].some((x) => x && RE.cerebro.test(x.t));
+                fusao = { junta: ev.junta, abre: ev.abre, then: cerebro ? 'brain' : 'none', motivo: `"${f.t}"` };
+            }
+        }
+    }
+    for (const o of objetos) {
+        o.ate = fusao && fusao.junta > o.de ? fusao.junta : Math.min(d.dur, o.de + 4);
+        if (o.ate > o.de + 0.3) passos.push({ op: 'attach_3d', args: { object: o.object, hand: o.mao, from: r2(o.de), to: r2(o.ate) }, motivo: o.motivo });
+    }
+    if (fusao) passos.push({ op: 'merge_on_join', args: { junta: r2(fusao.junta), ...(fusao.abre !== null ? { abre: r2(fusao.abre) } : {}), then: fusao.then }, motivo: fusao.motivo });
+
+    // 4. Fundos novos: no estalo, se a frase (ou a anterior) fala dele, ou se um estalo vem logo depois; senão na palavra.
+    const fundos = [];
+    fs.forEach((f, i) => {
+        const onde = fundoPedido(f.t);
+        if (!onde || !/\b(coloc\w*|poe|pon\w*|bot\w*|lev\w*|troc\w*|mud\w*|fundo|imagem|foto|me\s+em)\b/.test(f.t)) return;
+        const t = quando(f, new RegExp(onde.split(' ')[0].slice(0, 5)));
+        /* Um estalo logo depois do lugar é o gatilho, dito ou não. Se o estalo
+           foi dito ANTES do lugar ("se estalar os dedos ela coloca um
+           tubarão"), ele pode vir uns segundos depois da frase. */
+        const antes = f.t.slice(0, f.t.indexOf(onde.split(' ')[0]));
+        const falaEstalo = RE.estalo.test(antes) || (fs[i - 1] && RE.estalo.test(fs[i - 1].t) && !fundoPedido(fs[i - 1].t));
+        let e = estaloDepois(t, 3);
+        if (e === undefined && falaEstalo) e = estaloDepois(f.de, 10);
+        // "só aqui", "somente aqui": o fundo vale para a frase, depois volta o original.
+        const so = /\b(somente|so|apenas)\s+(aqui|agora|nessa parte|nesse momento)\b/.test(f.t) ? Math.min(d.dur, f.ate + 0.6) : null;
+        fundos.push({ with: onde, at: e !== undefined ? e : t, ...(so ? { ate: so } : {}), motivo: `"${f.t}"` + (e !== undefined ? ' (no estalo)' : '') });
+    });
+    fundos.forEach((b, i) => {
+        const until = b.ate !== undefined ? b.ate : fundos[i + 1] ? fundos[i + 1].at : null;
+        passos.push({ op: 'replace_background', args: { with: b.with, at: r2(b.at), ...(until !== null ? { until: r2(until) } : {}) }, motivo: b.motivo });
+    });
+
+    // 5. Legenda: sempre (é reels); a cor e a posição se forem pedidas, a partir do estalo se ele for citado.
+    const legenda = {};
+    const iL = fs.findIndex((f) => RE.legenda.test(f.t));
+    if (iL >= 0) {
+        const janela = fs.slice(iL, iL + 3);
+        const cor = janela.map((f) => PED.corPedida(f.t)).find(Boolean);
+        if (cor) legenda.color = cor;
+        const fp = janela.find((f) => RE.acima.test(f.t));
+        if (fp) {
+            legenda.position = 'above_head';
+            if (RE.estalo.test(fp.t)) { const e = estaloDepois(fp.de, 8); if (e !== undefined) legenda.desde = e; }
+            // "a legenda que tá aqui… aqui em cima": sobe quando ela diz onde.
+            else if (/\b(aqui|la) em cima\b/.test(fp.t)) legenda.desde = quando(fp, /cima/);
+        } else {
+            /* "a legenda daqui ficar aqui", apontando: o pedido é mudar de lugar, e
+               o lugar que se aponta em quem fala para a câmera é perto do rosto —
+               a legenda sobe para a cabeça no segundo "aqui". (01/10) */
+            const fd = janela.find((f) => /\bdaqui\b[\s\S]*\b(ficar|ir|pra|para)\b[\s\S]*\baqui\b|\b(mud|muda|mover|move|pass)\w*\b[\s\S]*\baqui\b/.test(f.t));
+            if (fd) {
+                legenda.position = 'above_head';
+                const aquis = fd.ws.filter((w) => /^aqui/.test(normal(w.texto)));
+                legenda.desde = (aquis[aquis.length - 1] || fd.ws[0]).de;
+            }
+        }
+    }
+
+    // 6. Cortes, por último: o silêncio que a pessoa cita, e o fim que ela anuncia.
+    const cortes = [];
+    const iS = fs.findIndex((f) => RE.silencio.test(f.t) && /\b(cort\w*|tir\w*|remov\w*|apag\w*|retir\w*)\b/.test(f.t));
+    if (iS >= 0) {
+        const t0 = fs[iS].de;
+        const sil = juntarSilencios(d.silencios || []).filter((s) => s.de >= t0 && s.de <= t0 + 15 && s.ate - s.de >= 1.5)
+            .sort((a, b) => (b.ate - b.de) - (a.ate - a.de))[0];
+        if (sil) cortes.push({ de: r2(sil.de + 0.1), ate: r2(sil.ate - 0.1), motivo: `"${fs[iS].t}" (${r2(sil.ate - sil.de)} s parado)` });
+    }
+    const iF = fs.findIndex((f) => RE.fim.test(f.t) && /\bvideo\b/.test(f.t));
+    if (iF >= 0) {
+        const f = fs[iF];
+        const ultima = fs[fs.length - 1].ate;
+        const e = RE.estalo.test(f.t) ? estaloDepois(f.de, 6) : undefined;
+        const fim = Math.max(ultima, e !== undefined ? e : 0) + 0.4;
+        if (d.dur - fim > 0.8) cortes.push({ de: r2(fim), ate: r2(d.dur), motivo: `"${f.t}"` });
+    }
+    if (cortes.length) passos.push({ op: 'cortes', args: { trechos: cortes.map(({ de, ate }) => [de, ate]) }, motivo: cortes.map((c) => c.motivo).join(' · ') });
+
+    return { passos, legenda };
+}
+
+/** Silêncios separados por um respiro (< 0,4 s) são um só. */
+function juntarSilencios(sil) {
+    const out = [];
+    for (const s of [...sil].sort((a, b) => a.de - b.de)) {
+        const u = out[out.length - 1];
+        if (u && s.de - u.ate < 0.4) u.ate = Math.max(u.ate, s.ate);
+        else out.push({ de: s.de, ate: s.ate });
+    }
+    return out;
+}
+
+const OPS = {
+    auto: {
+        uso: 'auto {asset?,dryRun?} — O VÍDEO É O PEDIDO: lê o que a pessoa FALA na gravação ("separe em camadas", "coloca o logo do Claude aqui", "com o estalar de dedos me coloca numa praia", "junta e vira um cérebro", "cortou o silêncio", "o vídeo acaba") e aplica cada efeito no momento em que ela diz, ancorado na palavra, na mão, no estalo e no juntar das mãos; legenda sempre. Use logo depois do import quando pedirem "edite esse vídeo" sem dizer o quê',
+        async run(ctx, a) {
+            const T = require('./timeline.js');
+            const C = require('./camadas.js');
+            const R = require('./rastro.js');
+            const RT = require('./rastrear.js');
+            const TR = require('./transcript.js');
+            const FXO = require('./ops-fx.js');
+            const tl = ctx.tl;
+            if (!tl) throw T.erro('nenhum projeto aberto: import {"path":"..."} primeiro');
+            const asset = C.base(tl, a.asset);
+            const inicio = Date.now();
+            // O lento e independente junto: rastreio (MediaPipe em paralelo) e transcrição.
+            const [rs, tr] = await Promise.all([RT.garantir(ctx.p.dir, asset), TR.obter(ctx.p.dir, asset)]);
+            if (!rs.ok) return rs;
+            if (!tr.ok) return { ok: false, error: 'sem a fala não sei o que fazer: ' + tr.error };
+            const fps = rs.rastro.fps;
+            const trilhas = R.trilhasDasMaos(rs.rastro);
+            const trechos = (t) => R.trechosVisiveis(t, Math.round(fps * 0.3)).map(([x, y]) => [x / fps, y / fps]);
+            const dados = {
+                palavras: tr.palavras,
+                estalos: (await FXO.estalosDe(ctx, asset)).map((e) => ({ t: e.t, score: e.score, mao: e.mao })),
+                juntaAbre: R.juntaEAbre(trilhas, { rastro: rs.rastro }).map((e) => ({ junta: e.junta / fps, abre: e.abre === null ? null : e.abre / fps })),
+                maos: { left: trechos(trilhas.left), right: trechos(trilhas.right) },
+                silencios: await require('./render.js').silenciosDe(ctx.p.dir, asset, { threshold: -35, minSilence: 0.8 }),
+                dur: asset.seconds,
+            };
+            const plano = planejar(dados);
+            const q = (s) => C.origemParaQuadro(ctx.tl, asset.id, s);
+            const ver = plano.passos.map((p) => ({ op: p.op, motivo: p.motivo, args: p.args }));
+            if (a.dryRun) return { ok: true, plano: ver, legenda: plano.legenda, segundos: 'da gravação' };
+
+            const { OPS: TODAS } = require('./ops.js');
+            const feitos = [];
+            const roda = async (op, args, motivo) => {
+                const res = await TODAS[op].run(ctx, args);
+                feitos.push({ op, motivo, ok: !!res && res.ok !== false, ...(res && res.ok === false ? { error: res.error } : {}) });
+                return res;
+            };
+            for (const p of plano.passos) {
+                const g = p.args;
+                if (p.op === 'separate_layers') await roda(p.op, { show3d: true, from: q(g.from), to: q(g.to) }, p.motivo);
+                else if (p.op === 'attach_3d') await roda(p.op, { object: g.object, hand: g.hand, from: q(g.from), to: q(g.to) }, p.motivo);
+                else if (p.op === 'merge_on_join') await roda(p.op, { junta: q(g.junta), ...(g.abre !== undefined ? { abre: q(g.abre) } : {}), then: g.then }, p.motivo);
+                else if (p.op === 'replace_background') await roda(p.op, { with: g.with, at: q(g.at), ...(g.until !== undefined ? { until: q(g.until) } : {}) }, p.motivo);
+                else if (p.op === 'cortes') {
+                    const ranges = g.trechos.map(([de, ate]) => [q(de), Math.min(T.duracao(ctx.tl), q(Math.min(ate, asset.seconds - 0.001)) + 1)]).filter(([x, y]) => x !== null && y > x);
+                    if (ranges.length) await roda('ripple_delete_ranges', { ranges }, p.motivo);
+                }
+            }
+            // A legenda, já nos cortes; a posição a partir do estalo, se ele foi citado.
+            await roda('add_captions', { maxWords: 3, animation: 'highlightPop' }, 'legenda (reels)');
+            const L = plano.legenda;
+            if (L.color || L.position) {
+                const leg = T.todosOsClipes(ctx.tl).filter((x) => x.clip.caption).map((x) => x.clip);
+                const desde = L.desde !== undefined ? q(L.desde) : null;
+                if (L.color) await roda('style_captions', { color: L.color }, 'cor pedida');
+                const ids = leg.filter((c) => desde === null || c.startFrame >= desde).map((c) => c.id);
+                if (L.position && ids.length) await roda('style_captions', { ids, position: L.position }, desde !== null ? 'em cima da cabeça, desde o momento dito' : 'em cima da cabeça');
+            }
+            const falhou = feitos.filter((f) => !f.ok);
+            return { ok: !falhou.length, feitos, tookS: Math.round((Date.now() - inicio) / 100) / 10,
+                ...(falhou.length ? { error: falhou.map((f) => `${f.op}: ${f.error}`).join('; ') } : {}),
+                depois: 'inspect para OLHAR os momentos; export renderiza (o 3D sai no export)' };
+        },
+    },
+};
+
+const EX = { auto: '{}' };
+
+module.exports = { planejar, frases, normal, fundoPedido, juntarSilencios, OPS, EX };