primocode 10.17.1 → 10.19.0

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,7 +546,7 @@ 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',
+        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', 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',
@@ -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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "10.17.1",
+  "version": "10.19.0",
   "description": "PrimoCode — agente de engenharia com IA e cursor próprio. Requer conta Conecta Primo AI (Premium ou Super). Cria arquivos, roda comandos, controla navegador e desktop: abre apps, clica em botões e ícones pelo nome, digita e usa atalhos.",
   "main": "bin/primocode.js",
   "bin": {
@@ -32,6 +32,9 @@
     "studio/",
     "skills/",
     "editor/",
+    "vendor/",
+    "kits/",
+    "!kits/**/preview.mp4",
     "voz/",
     "LICENSES/",
     "README.md",

package/skills/motion-de-primeira/SKILL.md

@@ -22,7 +22,7 @@ Números, não estilo pronto: o estilo continua seu.
 - **Entrada:** máscara (sobe de baixo, recorte reto), palavra por palavra de desfocado
   para nítido (0,15–0,3 s cada) ou esticando com borrão; `spring` ou ataque rápido e
   freio forte. **Saída:** a frase sai inteira (desliza, recua, corte seco).
-- **Cor:** fundo chapado, 1 tinta + 1 acento, contraste de 3:1 ou mais; até 5 cores.
+- **Cor:** fundo chapado, 1 tinta + 1 acento, contraste de 3:1 ou mais; até 5 cores. O vídeo pronto é conferido (borda, rosto, texto encavalado e o contraste de cada texto contra o fundo atrás dele), e o aviso da conferência diz o que refazer.
 - **Segunda voz:** o apoio é menor (~4% da altura), na segunda fonte, e chega 0,25–0,5 s depois.
 - **À mão:** na palavra que é a tese, um círculo de caneta que se desenha (com ✓ ou seta).
 - **Acento vivo e câmera:** um ponto ou forma acompanha o título e vira o elemento da

package/skills/motion-motioncraft/SKILL.md

@@ -0,0 +1,31 @@
+---
+nome: Motion com MotionCraft
+descricao: faz o motion (explainer, lançamento, reel) com o MotionCraft e a voz do PrimoCode
+quando: motion, vídeo animado, explainer, vídeo de lançamento, reel, motion graphics, motioncraft, vídeo com narração e música
+autor: PrimoCode
+---
+O PrimoCode faz motion pelo **MotionCraft** (`primocode motioncraft <comando>`,
+o mesmo CLI do projeto original). A voz é a do PrimoCode. O resto, o
+MotionCraft já faz: template, música e efeitos sintetizados, sincronia, QA e render.
+
+Fluxo, nesta ordem:
+
+1. **Preparar.** `primocode motioncraft doctor`, depois
+   `primocode motioncraft new <pasta> --style pi-v2`. Pergunte antes do `npm install`.
+2. **Roteiro.** Frases de 8 a 14 palavras, uma por linha. Confira fatos e números.
+   Mostre o roteiro e espere o "ok" antes de gastar voz e render.
+3. **Voz.** `estudio_narrar` (Antonio, Francisca ou Thalita; Edge, ElevenLabs
+   ou Kokoro). Ele devolve `falas` com o tempo medido. Salve a resposta em JSON e rode
+   `primocode motioncraft voz-para-words narrar.json --out audio/words.json`.
+   Converta o mp3 para `audio/vo.wav` com o ffmpeg.
+4. **Música e efeitos.** Os do MotionCraft: `music make`, `sfx auto`, `mix`.
+   Não use trilha com licença.
+5. **Cenas.** Edite `src/scenes/` (copie uma cena, troque as palavras, mantenha os números).
+   Uma ideia por quadro; título e imagem em zonas separadas.
+6. **Conferir.** `qa full <video>` e olhe quadros reais antes de dizer que ficou bom.
+7. **Render.** `primocode motioncraft render --preset wa|ig|yt --audio audio/final.wav`.
+
+Notas:
+- No servidor sem GPU, use `--gl=swangle` (lento; um vídeo de 20 s leva dezenas de minutos).
+- Sem voz, o MotionCraft sincroniza pela batida da música.
+- O MotionCraft é MIT (ahmdd4vd); a cópia fica em `vendor/motioncraft`. Não edite lá.

package/vendor/motioncraft/CREDITS.md

@@ -0,0 +1,18 @@
+# Credits
+
+## Built on
+
+- [Remotion](https://www.remotion.dev) - React video framework. Separate license: https://www.remotion.dev/license
+- [react-three-fiber](https://github.com/pmndrs/react-three-fiber) / [three.js](https://threejs.org) - 3D in the template
+- Fonts from [Google Fonts](https://fonts.google.com) via `@remotion/google-fonts`: Figtree, JetBrains Mono, Manrope, IBM Plex Mono, Newsreader, Space Grotesk
+- Optional tools the CLI can use if installed: [faster-whisper](https://github.com/SYSTRAN/faster-whisper), [yt-dlp](https://github.com/yt-dlp/yt-dlp), [Tesseract](https://github.com/tesseract-ocr/tesseract), [ffmpeg](https://ffmpeg.org)
+
+All music and sound effects in motioncraft are synthesized by its own code. No samples or third-party audio are included.
+
+## Showcase videos
+
+The showcase videos are about other people's projects. They were made independently and are not endorsed by these projects.
+
+- [Pi Coding Agent](https://pi.dev)
+- [Hindsight](https://github.com/vectorize-io/hindsight) by Vectorize
+- [Impeccable](https://github.com/pbakaus/impeccable) by Paul Bakaus

package/vendor/motioncraft/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ahmad David (ahmdd4vd)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/motioncraft/ORIGEM.txt

@@ -0,0 +1 @@
+ahmdd4vd/MotionCraft @ 8f48715 (MIT). Não edite aqui: atualize copiando de novo.