primocode 9.8.0-beta.13 → 9.8.0-beta.15

package/README.md

@@ -1,4 +1,4 @@
-# PrimoCode v9.8.0-beta.13
+# PrimoCode v9.8.0-beta.15
 
 Agente de engenharia brasileiro para o terminal, no estilo Claude Code.
 Cria arquivos de verdade, roda comandos, **controla o navegador e o desktop** —
@@ -9,7 +9,7 @@ OpenRouter, e cada apelido (`top`/`main`/`fast`) é uma **corrente**: se um mode
 está no limite de pedidos, o próximo atende. Você não vê o erro, e não paga nada.
 
 ```
- ▐▛███▜▌   Primo Code v9.8.0-beta.13
+ ▐▛███▜▌   Primo Code v9.8.0-beta.15
 ▝▜█████▛▘  Bem-vindo de volta, Joel
   ▘▘ ▝▝    ~/primocode  · /dir <pasta> muda
 ```

package/lib/api.js

@@ -268,6 +268,13 @@ function getConectores(serverUrl, token) {
     return pedirGet(serverUrl, '/api/conectores', token);
 }
 
+/* Foto e vídeo de apoio do Pexels, pela chave do servidor (ninguém precisa
+   ter uma). tipo: "imagens" | "videos". */
+function getMidia(serverUrl, token, tipo, { q, n, orientacao } = {}) {
+    const qs = new URLSearchParams({ q: q || '', n: String(n || 6), ...(orientacao ? { orientacao } : {}) });
+    return pedirGet(serverUrl, `/api/midia/${tipo}?${qs}`, token);
+}
+
 function getHealth(serverUrl, token) {
     return pedirGet(serverUrl, '/health', token);
 }
@@ -300,4 +307,4 @@ function pedirGet(serverUrl, rota, token) {
     });
 }
 
-module.exports = { request, requestStream, requestAct, requestChat, requestResumo, requestRefino, requestPlano, requestTranscricao, getHealth, getConectores };
+module.exports = { request, requestStream, requestAct, requestChat, requestResumo, requestRefino, requestPlano, requestTranscricao, getHealth, getConectores, getMidia };

package/lib/estudio/assets.js

@@ -213,7 +213,28 @@ function extensaoPorConteudo(bytes) {
  *
  * @returns {{ok, imagens: Array<{url, titulo, autor, licenca, creditos, fonte}>}}
  */
-async function procurarImagens(termo, { quantas = 8, transparente = false } = {}) {
+/* O Pexels pelo SERVIDOR: a chave é dele, e ninguém precisa ter uma. Sem
+   servidor (ou sem a chave lá), devolve null e a busca segue no Openverse. */
+async function pexelsDoServidor(tipo, termo, { quantas, orientacao } = {}) {
+    try {
+        const cfg = require('../config').loadConfig();
+        const r = await require('../api').getMidia(cfg.server, cfg.token, tipo, { q: termo, n: quantas, orientacao });
+        const lista = r && r.ok ? r[tipo] : null;
+        return lista && lista.length ? lista : null;
+    } catch { return null; }
+}
+
+/** Procura vídeo de apoio (b-roll). Só Pexels: o Openverse não tem vídeo. */
+async function procurarVideos(termo, { quantas = 5, orientacao = null } = {}) {
+    const videos = await pexelsDoServidor('videos', termo, { quantas, orientacao });
+    return videos ? { ok: true, videos } : { ok: false, error: 'sem acervo de vídeo agora (o servidor está sem a chave do Pexels).', videos: [] };
+}
+
+async function procurarImagens(termo, { quantas = 8, transparente = false, orientacao = null } = {}) {
+    if (!transparente && !process.env.PEXELS_API_KEY) {
+        const imagens = await pexelsDoServidor('imagens', termo, { quantas, orientacao });
+        if (imagens) return { ok: true, imagens };
+    }
     const chave = process.env.PEXELS_API_KEY;
     if (chave && !transparente) {
         try {
@@ -337,7 +358,7 @@ async function conferirFonte(familia) {
 module.exports = {
     extensaoPorConteudo,
     pegar, guardar,
-    icone, procurarIcones, iconesDoPlano, COLECOES,
+    icone, procurarIcones, iconesDoPlano, COLECOES, procurarVideos,
     procurarImagens, procurarSom, baixar,
     FONTES, conferirFonte,
 };

package/lib/estudio/composicao.js

@@ -325,9 +325,11 @@ function comporRoteiro({ roteiro, modo = 'video', largura = 1920, altura = 1080,
                 break;
             }
             case 'imagem': {
-                const src = imagens[i] || p.src;
+                const m = imagens[i] || p.src;
+                const src = m && typeof m === 'object' ? m.src : m;
                 if (src) {
-                    els.push({ tipo: 'imagem', src, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', anima: { escala: [{ t: 0, v: 1.12 }, { t: dur, v: 1, e: 'suave' }] } });
+                    const ehVideo = m && typeof m === 'object' && m.tipo === 'video';
+                    els.push({ tipo: ehVideo ? 'video' : 'imagem', src, ...(ehVideo ? { volume: 0 } : {}), x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover', anima: { escala: [{ t: 0, v: 1.12 }, { t: dur, v: 1, e: 'suave' }] } });
                     els.push({ tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', fundo: { tipo: 'gradiente', cores: ['rgba(0,0,0,0)', 'rgba(0,0,0,0.25)', 'rgba(0,0,0,0.85)'], angulo: 180 } });
                 }
                 const larg = W0 * 0.8;

package/lib/estudio/edicao.js

@@ -32,7 +32,10 @@ const VAZIAS = new Set((
     + 'ou mas como mais menos muito muita muitos muitas isso isto esse essa este esta aquele aquela ele ela '
     + 'eles elas eu voce voces nos meu minha seu sua nosso nossa tem ter ser foi era sao esta estao vai vou '
     + 'ja ai aqui la entao tambem so quando onde porque pois ate sobre depois antes cada todo toda todos '
-    + 'todas qual quais quem nao sim ne ta tipo coisa coisas gente fazer faz feito pode podem vamos hoje'
+    + 'todas qual quais quem nao sim ne ta tipo coisa coisas gente fazer faz feito pode podem vamos hoje '
+    // Verbos de ligação e de fala: não são a ideia da frase.
+    + 'mostra mostrar ajuda ajudar deixa deixar usar usa usando sabe saber quer querer precisa precisar '
+    + 'acho olha vem fica ficar falar fala dizer diz ver vai ir estou estava sendo tendo existe chamado'
 ).split(' '));
 
 /* A palavra (sem acento, minúscula, começo dela) → o emoji colorido. Casa
@@ -133,8 +136,8 @@ function termoDeApoio(palavra) {
     return ic ? FOTO[ic.split(':')[1]] || null : null;
 }
 
-// Em quais cenas entra imagem de apoio: uma a cada três, a partir da segunda.
-const temApoio = (i) => i % 3 === 2;
+// Em quais cenas entra a mídia de apoio: uma a cada duas, a partir da segunda.
+const temApoio = (i) => i % 2 === 1;
 
 function forteDe(g) {
     let forte = null;
@@ -208,8 +211,8 @@ function camera(i, dur) {
 }
 
 const ESTILOS = {
-    viral: { icones: true, letreiro: true, sons: true, barra: true, apoio: true, destaque: '#FFD400', forte: '#00E0A4' },
-    limpo: { icones: false, letreiro: false, sons: false, barra: false, apoio: true, destaque: '#FFFFFF', forte: '#FFD400' },
+    viral: { icones: true, letreiro: true, sons: true, barra: true, apoio: true, recorte: true, fundoRecorte: ['#1B1F3B', '#3A1C71'], destaque: '#FFD400', forte: '#00E0A4' },
+    limpo: { icones: false, letreiro: false, sons: false, barra: false, apoio: true, recorte: false, fundoRecorte: ['#111111', '#333333'], destaque: '#FFFFFF', forte: '#FFD400' },
 };
 
 /**
@@ -225,7 +228,10 @@ const ESTILOS = {
  * @param {object} op.sons        { pop, whoosh } — caminhos na pasta do projeto, opcionais
  * @param {Set}    op.iconesOk    os nomes de ícone que existem de verdade (sem isso, todos valem)
  */
-function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null, imagens = {}, trilha = null }) {
+// Em quais cenas a pessoa é recortada, com a palavra gigante atrás dela.
+const temRecorte = (i) => i % 4 === 2;
+
+function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, estilo = 'viral', sons = {}, iconesOk = null, imagens = {}, trilha = null, recortes = {} }) {
     const e = ESTILOS[estilo] || ESTILOS.viral;
     const lista = (palavras || []).filter((p) => p && p.texto && p.ate > p.de).sort((a, b) => a.de - b.de);
     if (!lista.length) return { ok: false, error: 'a gravação não tem fala transcrita para editar.' };
@@ -236,6 +242,7 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
     const total = duracao || lista[lista.length - 1].ate + 0.3;
     const cenas = [];
     const efeitos = [];
+    const infos = [];   // onde cada cena começa e a palavra forte dela — para o recorte
     let lado = 0;
 
     grupos.forEach((g, i) => {
@@ -253,16 +260,47 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
             deOrigem: r2(ini), ateOrigem: r2(ini + dur), volume: 1,
         }];
 
+        infos.push({ ini: r2(ini), dur, forte: forte ? { de: local(forte.de), texto: forte.texto, peso: peso(forte.texto) } : null });
+
+        /* A PALAVRA ATRÁS DA PESSOA: o fundo do quarto some, entra a cor da
+           marca, a palavra forte aparece enorme e a pessoa, recortada, fica
+           na frente dela. É o efeito que mais denuncia edição de videomaker. */
+        const rec = e.recorte && temRecorte(i) ? recortes[i] : null;
+        if (rec && forte) {
+            const vida = r2(rec.ate - rec.de);
+            const some = [{ t: 0, v: 0 }, { t: 0.1, v: 1 }, { t: vida - 0.12, v: 1 }, { t: vida, v: 0 }];
+            elementos.push({
+                tipo: 'forma', forma: 'retangulo', x: 0, y: 0, largura: '100%', altura: '100%', de: rec.de, ate: rec.ate,
+                fundo: { tipo: 'gradiente', cores: [e.fundoRecorte[0], e.fundoRecorte[1]], angulo: 160 }, anima: { opacidade: some },
+            });
+            const palavra = limpaPontuacao(forte.texto).toUpperCase();
+            const fit = Math.round(Math.min(altura * 0.42, (largura * 0.92) / Math.max(3, palavra.length * 0.46)));
+            elementos.push({
+                tipo: 'texto', texto: palavra, fonte: 'Anton', peso: 400, tamanho: fit, cor: e.forte,
+                x: '50%', y: deitado ? '38%' : '34%', ancora: 'centro', de: rec.de, ate: rec.ate,
+                anima: { escala: [{ t: 0, v: 0.6 }, { t: 0.22, v: 1.06, e: 'saida' }, { t: 0.4, v: 1, e: 'suave' }, { t: vida, v: 1.05 }], opacidade: some },
+            });
+            elementos.push({
+                tipo: 'video', src: rec.src, volume: 0, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover',
+                de: rec.de, ate: rec.ate, anima: { opacidade: some },
+            });
+            if (e.sons && sons.whoosh) efeitos.push({ t: r2(Math.max(0, ini + rec.de - 0.1)), src: sons.whoosh, volume: 0.55 });
+        }
+
         /* A IMAGEM DE APOIO: na hora da palavra forte, a tela vira a imagem do
            que está sendo dito, com um zoom lento, e a legenda continua por
            cima. É o "b-roll" das edições de videomaker. */
-        const apoio = forte && e.apoio && temApoio(i) ? imagens[termoDeApoio(forte.texto)] : null;
+        const apoio = forte && e.apoio && temApoio(i) && !rec ? imagens[termoDeApoio(forte.texto)] : null;
         if (apoio) {
             const de = local(forte.de - 0.1);
             const vida = Math.min(2.2, dur - de);
             if (vida > 0.8) {
+                // O apoio é foto ou vídeo (o Pexels dá os dois; vídeo é melhor).
+                const ehVideo = typeof apoio === 'object' && apoio.tipo === 'video';
                 elementos.push({
-                    tipo: 'imagem', src: apoio, x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover',
+                    tipo: ehVideo ? 'video' : 'imagem', src: typeof apoio === 'object' ? apoio.src : apoio,
+                    ...(ehVideo ? { volume: 0 } : {}),
+                    x: 0, y: 0, largura: '100%', altura: '100%', ajuste: 'cover',
                     de, ate: r2(de + vida),
                     anima: {
                         escala: [{ t: 0, v: 1.12 }, { t: vida, v: 1.0, e: 'suave' }],
@@ -274,7 +312,7 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
         }
 
         // O ícone salta na hora da palavra; sem ícone, o letreiro da ideia.
-        const icone = forte && e.icones && !apoio ? iconeDe(forte.texto) : null;
+        const icone = forte && e.icones && !apoio && !rec ? iconeDe(forte.texto) : null;
         const temIcone = icone && (!iconesOk || iconesOk.has(icone));
         const x = lado++ % 2 === 0 ? '78%' : '22%';
         if (temIcone) {
@@ -294,7 +332,7 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
                 });
                 if (e.sons && sons.pop) efeitos.push({ t: r2(ini + de), src: sons.pop, volume: 0.8 });
             }
-        } else if (forte && e.letreiro && i % 2 === 0 && peso(forte.texto) >= 7) {
+        } else if (forte && e.letreiro && !rec && i % 2 === 0 && peso(forte.texto) >= 7) {
             const de = local(forte.de);
             const vida = Math.min(1.6, dur - de);
             if (vida > 0.5) {
@@ -358,10 +396,12 @@ function montarEdicao({ src, duracao, palavras, largura = 1080, altura = 1920, e
                 ...(trilha ? { trilha: { src: trilha, volume: 0.07, loop: true } } : {}),
             } } : {}),
         },
+        infos,
         resumo: {
             cenas: cenas.length,
+            recortes: Object.keys(recortes).length,
             icones: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'icone').length, 0),
-            imagens: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'imagem').length, 0),
+            apoios: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'imagem' || (x.tipo === 'video' && x.volume === 0)).length, 0),
             musica: Boolean(trilha),
             letreiros: cenas.reduce((n, c) => n + c.elementos.filter((x) => x.tipo === 'texto').length, 0),
             efeitos: efeitos.length,
@@ -398,4 +438,4 @@ async function prepararSons(pasta, video) {
     return sons;
 }
 
-module.exports = { montarEdicao, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, ESTILOS, ICONES, FOTO };
+module.exports = { montarEdicao, temRecorte, prepararSons, iconeDe, peso, frases, blocos, termosDeApoio, termoDeApoio, ESTILOS, ICONES, FOTO };

package/lib/estudio/index.js

@@ -81,6 +81,37 @@ function rodarPython(script, args, { timeout = 20 * 60000 } = {}) {
     });
 }
 
+/* O RECORTE DA PESSOA precisa do MediaPipe, e o MediaPipe só existe até o
+   Python 3.12 — no Python 3.14 do Homebrew ele nem instala (medido em
+   25/09: o recorte nunca tinha rodado nesta máquina). Com o `uv`, o script
+   roda num Python 3.12 isolado, baixado uma vez; sem ele, tenta o Python da
+   máquina, como antes. */
+function acharUv() {
+    const { execFileSync } = require('child_process');
+    for (const c of ['uv', path.join(os.homedir(), '.local', 'bin', 'uv'), '/opt/homebrew/bin/uv', '/usr/local/bin/uv']) {
+        try { execFileSync(c, ['--version'], { stdio: 'ignore', timeout: 5000 }); return c; } catch { /* próximo */ }
+    }
+    return null;
+}
+function rodarPessoa(args, { timeout = 40 * 60000 } = {}) {
+    const uv = acharUv();
+    if (!uv) return rodarPython('pessoa.py', args, { timeout });
+    return new Promise((resolve) => {
+        const p = spawn(uv, ['run', '--quiet', '--python', '3.12', '--with', 'mediapipe<0.10.22',
+            '--with', 'opencv-python', '--with', 'numpy', 'python', path.join(PY, 'pessoa.py'), ...args]);
+        let saida = '', erro = '';
+        p.stdout.on('data', (d) => { saida += d.toString(); });
+        p.stderr.on('data', (d) => { erro += d.toString(); });
+        const relogio = setTimeout(() => { try { p.kill(); } catch {} }, timeout);
+        p.on('close', () => {
+            clearTimeout(relogio);
+            try { resolve(JSON.parse(saida.trim().split('\n').pop())); }
+            catch { resolve({ ok: false, error: (erro || saida).slice(-400).trim() || 'o recorte não respondeu' }); }
+        });
+        p.on('error', (e) => { clearTimeout(relogio); resolve({ ok: false, error: e.message }); });
+    });
+}
+
 // ── estudio_projeto ──────────────────────────────────────────────────────
 
 /**
@@ -462,14 +493,10 @@ async function ferramentaVideo(args, ctx = {}) {
         // As imagens de apoio: uma por termo, a primeira que baixar.
         const imagens = {};
         if ((args.estilo || 'viral') !== 'sem-apoio') {
+            const orientacao = m.largura >= m.altura ? 'landscape' : 'portrait';
             for (const termo of edicao.termosDeApoio(palavras).slice(0, 8)) {
-                try {
-                    const b = await assets.procurarImagens(termo, { quantas: 4 });
-                    for (const item of (b.ok ? b.imagens : [])) {
-                        const d = await assets.baixar(item, { pasta: p.pasta, nome: 'apoio-' + termo });
-                        if (d.ok) { imagens[termo] = d.relativo; break; }
-                    }
-                } catch { /* segue sem esta */ }
+                imagens[termo] = await baixarApoio(p, termo, { orientacao, video: true });
+                if (!imagens[termo]) delete imagens[termo];
             }
         }
 
@@ -485,12 +512,36 @@ async function ferramentaVideo(args, ctx = {}) {
             } catch { /* segue sem música */ }
         }
 
-        const montado = edicao.montarEdicao({
+        const base = {
             src: path.relative(p.pasta, fonte).replace(/\\/g, '/'),
             duracao: m.segundos, palavras, largura: m.largura, altura: m.altura,
             estilo: args.estilo || 'viral', sons, iconesOk, imagens, trilha,
-        });
+        };
+        let montado = edicao.montarEdicao(base);
         if (!montado.ok) return montado;
+
+        /* A segunda passada: nas frases escolhidas, a pessoa recortada na
+           frente da palavra gigante. Só os trechos que entram são recortados
+           (2 s cada), não o vídeo inteiro — recortar 52 s levaria minutos. */
+        if ((args.estilo || 'viral') === 'viral' && args.recorte !== false) {
+            const recortes = {};
+            for (const [i, info] of montado.infos.entries()) {
+                if (!edicao.temRecorte(i) || !info.forte || info.forte.peso < 9 || Object.keys(recortes).length >= 3) continue;
+                const de = Math.max(0, info.forte.de - 0.15);
+                const ate = Math.min(info.dur, de + 2.2);
+                if (ate - de < 1) continue;
+                const seg = path.join(p.pasta, 'midia', `seg-${i + 1}-${Date.now().toString(36)}.mp4`);
+                const corte = await video.rodar(video.ffmpeg(), ['-y', '-ss', String(info.ini + de), '-t', String(ate - de), '-i', fonte,
+                    '-vf', `scale=${Math.min(1280, m.largura)}:-2`, '-an', '-c:v', 'libx264', '-preset', 'veryfast', seg], { timeout: 120000 });
+                if (!corte.ok) continue;
+                const saida = path.join(p.pasta, 'midia', `pessoa-${i + 1}-${Date.now().toString(36)}.webm`);
+                const r = await rodarPessoa(['recortar', '--entrada', seg, '--saida', saida], { timeout: 10 * 60000 });
+                try { fs.unlinkSync(seg); } catch { /* fica */ }
+                if (!r.ok) break;   // sem MediaPipe, nenhum recorte vai dar: não tenta os outros
+                recortes[i] = { src: path.relative(p.pasta, saida).replace(/\\/g, '/'), de: Math.round(de * 100) / 100, ate: Math.round(ate * 100) / 100 };
+            }
+            if (Object.keys(recortes).length) montado = edicao.montarEdicao({ ...base, recortes });
+        }
         const salvo = await ferramentaPlano({ id: args.id, plano: montado.plano, motivo: `edição automática (${args.estilo || 'viral'})` });
         if (!salvo.ok) return salvo;
         projeto.anotar(p.id, 'edicao', `${montado.resumo.cenas} cenas, ${montado.resumo.icones} ícones, ${cortes} cortes de silêncio`);
@@ -503,7 +554,7 @@ async function ferramentaVideo(args, ctx = {}) {
 
     if (acao === 'recortar-pessoa' || acao === 'pessoa') {
         const saida = path.join(p.pasta, 'midia', `pessoa-${Date.now().toString(36)}.webm`);
-        const r = await rodarPython('pessoa.py', [
+        const r = await rodarPessoa([
             'recortar', '--entrada', alvo, '--saida', saida,
             ...(args.suavizar != null ? ['--suavizar', String(args.suavizar)] : []),
             ...(args.encolher != null ? ['--encolher', String(args.encolher)] : []),
@@ -520,6 +571,28 @@ async function ferramentaVideo(args, ctx = {}) {
     return { ok: false, error: `não conheço a ação "${acao}".` };
 }
 
+/* A mídia de apoio de um termo: vídeo do Pexels quando pedido e houver,
+   senão a primeira foto que baixar. Devolve {src, tipo} ou null. */
+async function baixarApoio(p, termo, { orientacao = null, video: querVideo = false } = {}) {
+    if (querVideo) {
+        try {
+            const b = await assets.procurarVideos(termo, { quantas: 4, orientacao });
+            for (const item of (b.ok ? b.videos : []).filter((v) => !v.duracao || v.duracao >= 3)) {
+                const d = await assets.baixar(item, { pasta: p.pasta, nome: 'apoio-' + termo });
+                if (d.ok) return { src: d.relativo, tipo: 'video' };
+            }
+        } catch { /* cai para a foto */ }
+    }
+    try {
+        const b = await assets.procurarImagens(termo, { quantas: 4, orientacao });
+        for (const item of (b.ok ? b.imagens : [])) {
+            const d = await assets.baixar(item, { pasta: p.pasta, nome: 'apoio-' + termo });
+            if (d.ok) return { src: d.relativo, tipo: 'imagem' };
+        }
+    } catch { /* sem apoio */ }
+    return null;
+}
+
 const PROPORCOES = { '16:9': [1920, 1080], '9:16': [1080, 1920], '1:1': [1080, 1080], '4:5': [1080, 1350] };
 
 /** O roteiro vira plano: baixa o que falta, narra, e chama o compositor. */
@@ -537,13 +610,8 @@ async function prepararRoteiro(p, args) {
     const imagens = {};
     for (const [i, parte] of partes.entries()) {
         if (parte.tipo !== 'imagem' || parte.src || !parte.busca) continue;
-        try {
-            const b = await assets.procurarImagens(parte.busca, { quantas: 4 });
-            for (const item of (b.ok ? b.imagens : [])) {
-                const d = await assets.baixar(item, { pasta: p.pasta, nome: 'cena-' + (i + 1) });
-                if (d.ok) { imagens[i] = d.relativo; break; }
-            }
-        } catch { /* a cena sai sem a foto, com o título */ }
+        const m = await baixarApoio(p, parte.busca, { orientacao: largura >= altura ? 'landscape' : 'portrait', video: modo === 'video' });
+        if (m) imagens[i] = m;
     }
 
     let tempos = [], narracao = null, sons = {}, trilha = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "9.8.0-beta.13",
+  "version": "9.8.0-beta.15",
   "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": {