primocode 11.4.0 → 11.5.0

package/lib/provider/local/recorte.js

@@ -0,0 +1,170 @@
+/**
+ * recorte.js — quais ferramentas o pedido precisa, por assunto.
+ *
+ * Reaproveita os gatilhos de entrada.js (os mesmos do servidor) e completa o
+ * que o cliente tem a mais: cada ferramenta cai num assunto, e o que nenhum
+ * gatilho pegou continua a UM comando de distância, pela ferramenta pequena
+ * `mais_ferramentas(grupo)`.
+ *
+ * Sempre vai o núcleo (arquivos, terminal, to-dos, finish). O modo atual pode
+ * forçar assuntos: o Estúdio de motion só precisa de motion + arquivos.
+ *
+ * Sem estado: o que o modelo ligou antes aparece na própria conversa (a
+ * chamada a `mais_ferramentas`, ou o uso de uma ferramenta de outro assunto),
+ * e é lido de lá a cada volta.
+ */
+
+'use strict';
+
+const entrada = require('./entrada.js');
+
+/** Ferramentas do cliente que os grupos de entrada.js não conhecem. */
+const EXTRAS = { estudio: ['estudio_criar'], 'after-effects': ['estudio_criar'], gravacao: ['editor_pro'] };
+const NOVOS = [
+    { nome: 'web', tools: ['buscar_web', 'ler_url'],
+      gatilho: /\b(https?:|www\.|link|pesquis\w*|busca\w*|internet|not[íi]cia|site de|documenta[çc][ãa]o)\b/i },
+    { nome: 'memoria', tools: ['lembrar', 'remember_general'],
+      gatilho: /\b(lembr\w*|mem[óo]ria|guarda (isso|que)|anota (isso|que)|n[ãa]o esque[çc]a)\b/i },
+    { nome: 'ajuda', tools: ['perguntar', 'agentes_buscar', 'capacidade_buscar'], gatilho: null },
+];
+
+/** Os nomes que o modelo vê. 'after-effects' aparece como 'motion'. */
+const ALIAS = { motion: 'after-effects', 'after-effects': 'after-effects' };
+
+const RESUMO = {
+    navegador: 'controlar um navegador (abrir, clicar, ler, fotografar)',
+    computador: 'controlar o computador (janelas, mouse, teclado, tela)',
+    mcp: 'conectar serviços (GitHub, Notion, Slack, banco...)',
+    pastas: 'trabalhar em outra pasta',
+    pesquisa: 'pesquisar documentação e referências',
+    pipeline: 'construir um app ou site inteiro',
+    exportar: 'renderizar o vídeo em arquivo',
+    delegar: 'chamar subagentes',
+    terminal: 'servidor ou watch em segundo plano',
+    estudio: 'estúdio: slides, vídeo e arte',
+    gravacao: 'gravação do usuário: cortar, legendar, editar',
+    motion: 'motion: After Effects, estudio_motion, editar o vídeo',
+    web: 'buscar na web e ler links',
+    memoria: 'guardar memória entre sessões',
+    ajuda: 'perguntar ao usuário, achar agente ou receita',
+};
+
+function tabela() {
+    const mapa = new Map();   // nome interno → ferramentas
+    for (const g of entrada.GRUPOS) {
+        if (!g.nome) continue;
+        mapa.set(g.nome, [...g.tools, ...(EXTRAS[g.nome] || [])]);
+    }
+    for (const n of NOVOS) mapa.set(n.nome, n.tools);
+    return mapa;
+}
+
+/** O que o modo atual força. Estúdio de motion: só motion (os arquivos já são o núcleo). */
+function forcarDoModo(modo) {
+    return /^(estudio|motion)$/i.test(String(modo || '')) ? ['after-effects'] : [];
+}
+
+function chamadasDaConversa(mensagens) {
+    const lista = [];
+    for (const m of mensagens || []) {
+        for (const tc of (m && m.tool_calls) || []) {
+            lista.push({ nome: (tc.function && tc.function.name) || tc.name, args: (tc.function && tc.function.arguments) || tc.arguments });
+        }
+    }
+    return lista;
+}
+
+/**
+ * Os assuntos deste pedido. `usados` = o que a conversa já ligou: o grupo que
+ * o modelo pediu em `mais_ferramentas` e o de qualquer ferramenta que ele
+ * chamou (se chamou, vai querer chamar de novo).
+ */
+function gruposDoPedido(texto, mensagens = [], forcar = []) {
+    const grupos = new Set(entrada.gruposDe(texto, forcar));
+    for (const n of NOVOS) if (n.gatilho && n.gatilho.test(String(texto || ''))) grupos.add(n.nome);
+    const usados = new Set();
+    const t = tabela();
+    for (const c of chamadasDaConversa(mensagens)) {
+        if (c.nome === 'mais_ferramentas') {
+            let a = c.args;
+            if (typeof a === 'string') { try { a = JSON.parse(a); } catch { a = {}; } }
+            const g = ALIAS[String(a && a.grupo || '').toLowerCase()] || String(a && a.grupo || '').toLowerCase();
+            if (t.has(g)) usados.add(g);
+            continue;
+        }
+        for (const [g, tools] of t) if (tools.includes(c.nome) && g !== 'nucleo') usados.add(g);
+    }
+    for (const g of usados) grupos.add(g);
+    return { grupos, usados };
+}
+
+/** As ferramentas dos grupos, na ordem original; o núcleo sempre. */
+function escolher(todas, grupos) {
+    const t = tabela();
+    const permitidas = new Set();
+    for (const [g, tools] of t) if (g === 'nucleo' || grupos.has(g)) tools.forEach((x) => permitidas.add(x));
+    permitidas.add('finish');
+    const lista = (todas || []).filter((x) => permitidas.has(x.function.name));
+    return lista.length >= 5 ? lista : todas;   // rede de segurança, como em entrada.js
+}
+
+/** A ferramenta pequena que liga um grupo na próxima volta. Só lista o que ficou de fora. */
+function maisFerramentas(todas, grupos) {
+    const t = tabela();
+    const nomes = new Set((todas || []).map((x) => x.function.name));
+    const fora = [];
+    for (const [g, tools] of t) {
+        if (g === 'nucleo' || grupos.has(g) || !tools.some((x) => nomes.has(x))) continue;
+        fora.push(g === 'after-effects' ? 'motion' : g);
+    }
+    return { type: 'function', function: {
+        name: 'mais_ferramentas',
+        description: `Liga um grupo de ferramentas na próxima volta. Grupos: ${fora.map((g) => `${g} (${RESUMO[g] || g})`).join('; ')}.`,
+        parameters: { type: 'object', properties: { grupo: { type: 'string', enum: fora } }, required: ['grupo'] },
+    } };
+}
+
+/** Sem caber nem no nível mais curto: o assunto secundário sai, o principal fica (motion manda sobre estúdio). */
+function principais(grupos) {
+    if (grupos.has('after-effects')) { const g = new Set(grupos); g.delete('estudio'); g.delete('gravacao'); return g; }
+    return grupos;
+}
+
+/* ── O PEDIDO DE VERDADE ──────────────────────────────────────────────────
+ * O CLI embrulha o que a pessoa escreveu: na frente vão o menu de estilos, a tabela de comandos e a lista de
+ * skills ("PEDIDO: <o que ela escreveu>"), e atrás, o aviso de escopo. Casar gatilho contra o embrulho inteiro
+ * liga todos os assuntos (a tabela cita desktop, navegador, motion...) e o recorte não recorta nada. */
+function pedidoReal(texto) {
+    let s = String(texto || '');
+    const i = s.lastIndexOf('PEDIDO:');
+    if (i >= 0) s = s.slice(i + 7);
+    const j = s.lastIndexOf('RESPOSTA DA PESSOA:');
+    if (j >= 0) s = s.slice(j + 19);
+    return s.split(/\n\n(?:ESCOPO:|\[)/)[0].trim();
+}
+
+/** Teto, em caracteres, da memória persistente em cada nível apertado. */
+const TETO_MEMORIA = { 3: 2500, 4: 1200, 5: 1200 };
+
+/**
+ * O contexto que o CLI cola na conversa, encolhido nos níveis fundos: a frente do último pedido
+ * (tudo antes de "PEDIDO:") sai, e a memória persistente é cortada. O pedido em si nunca é tocado.
+ */
+function enxugarContexto(mensagens, nivel) {
+    if (nivel < 3) return mensagens;
+    const ultimoUser = (() => { for (let i = mensagens.length - 1; i >= 0; i--) if (mensagens[i] && mensagens[i].role === 'user') return i; return -1; })();
+    return mensagens.map((m, i) => {
+        if (!m || typeof m.content !== 'string') return m;
+        if (i === ultimoUser) {
+            const k = m.content.lastIndexOf('PEDIDO:');
+            return k > 0 ? { ...m, content: m.content.slice(k + 7).trim() } : m;
+        }
+        if (m.role === 'system' && /^Memória persistente:/.test(m.content)) {
+            const max = TETO_MEMORIA[nivel] || 1200;
+            return m.content.length > max ? { ...m, content: `${m.content.slice(0, max)}\n…(memória cortada: o provedor grátis limita os tokens por minuto)` } : m;
+        }
+        return m;
+    });
+}
+
+module.exports = { pedidoReal, enxugarContexto, principais, RESUMO, forcarDoModo, gruposDoPedido, escolher, maisFerramentas, tabela };

package/lib/provider/local/revezamento.js

@@ -0,0 +1,121 @@
+/**
+ * revezamento.js — revezar provedores grátis em vez de esperar o limite por minuto.
+ *
+ * O plano grátis do Groq para 6–37 s a cada 429/413. Se a pessoa tem a chave de
+ * outro provedor grátis no ambiente, o pedido segue nele; só espera se nenhum estiver livre.
+ *
+ *   ordem padrão: groq → cerebras → gemini (endpoint compatível com OpenAI do Google)
+ *   entra só quem tem chave no ambiente (GROQ_API_KEY, CEREBRAS_API_KEY, GEMINI_API_KEY)
+ *   e um modelo com ferramentas no catálogo (lib/provider/catalogo.js)
+ *
+ * Config da pessoa, opcional: ~/.primocode/revezamento.json
+ *   { "ativo": true, "ordem": ["groq","cerebras","gemini"], "modelos": { "cerebras": "gpt-oss-120b" } }
+ *   "ativo": false (ou PRIMOCODE_SEM_REVEZAMENTO=1) desliga: volta a esperar, como antes.
+ *
+ * Nenhuma chave nem URL privada mora aqui: as bases vêm do catálogo/provedor.js.
+ * O provedor atual só revezam se ele mesmo está na ordem (quem usa gateway pago não é tocado).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const provedor = require('./provedor.js');
+const catalogo = require('../catalogo');
+
+const ORDEM_PADRAO = ['groq', 'cerebras', 'gemini'];
+const ARQUIVO = () => path.join(os.homedir(), '.primocode', 'revezamento.json');
+const PAUSA_PADRAO_MS = 30000;
+const PAUSA_DIA_MS = 6 * 60 * 60 * 1000;
+
+const OCUPADOS = new Map();     // id do provedor → até quando está em pausa (ms)
+
+function config() {
+    let j = {};
+    try { j = JSON.parse(fs.readFileSync(ARQUIVO(), 'utf8')) || {}; } catch { /* sem arquivo: padrão */ }
+    const ordem = Array.isArray(j.ordem) ? j.ordem.map(String).filter(Boolean) : ORDEM_PADRAO;
+    return {
+        ativo: j.ativo !== false && process.env.PRIMOCODE_SEM_REVEZAMENTO !== '1',
+        ordem: ordem.length ? ordem : ORDEM_PADRAO,
+        modelos: j.modelos && typeof j.modelos === 'object' ? j.modelos : {},
+    };
+}
+
+function capDe(p, modelo) {
+    const k = p.noCatalogo || p.id;
+    return catalogo.capacidades(k, modelo);
+}
+
+/** O melhor modelo do provedor `p` (resolvido): com ferramentas e, se pedido, com visão. null se não há. */
+function modeloDe(p, { visao = false, preferido = '' } = {}) {
+    const lista = [preferido, ...(p.modelos || [])].filter(Boolean);
+    const k = p.noCatalogo || p.id;
+    const doCat = catalogo.carregarSync().provedores[k];
+    if (doCat) for (const m of Object.keys(doCat.modelos)) lista.push(m);
+    for (const m of lista) {
+        const c = capDe(p, m);
+        if (!c) continue;                          // fora do catálogo: não dá para garantir ferramentas
+        if (c.ferramentas && (!visao || c.visao)) return m;
+    }
+    return null;
+}
+
+/** A pausa vale até quando? `esperaMs` vem do header do provedor. */
+function marcarOcupado(id, esperaMs, { dia = false } = {}) {
+    OCUPADOS.set(id, Date.now() + (dia ? PAUSA_DIA_MS : (esperaMs && esperaMs > 0 ? esperaMs + 500 : PAUSA_PADRAO_MS)));
+}
+function livre(id) {
+    const ate = OCUPADOS.get(id);
+    if (!ate) return true;
+    if (ate <= Date.now()) { OCUPADOS.delete(id); return true; }
+    return false;
+}
+function esquecer() { OCUPADOS.clear(); }
+
+/** Os provedores do revezamento, na ordem, prontos para uso. `atual` é o que a pessoa escolheu. */
+function candidatos(atual, { visao = false } = {}) {
+    const cfg = config();
+    if (!cfg.ativo || !atual || !cfg.ordem.includes(atual.id)) return [];
+    const saida = [];
+    for (const id of cfg.ordem) {
+        let p;
+        if (id === atual.id) {
+            p = { ...atual };
+            const resolvido = provedor.resolver(id) || {};
+            p.modelos = [atual.modelo, ...(resolvido.modelos || [])];
+            p.noCatalogo = atual.noCatalogo || resolvido.noCatalogo || (resolvido.catalogo ? id : '');
+        } else {
+            const r = provedor.resolver(id);
+            const chave = r && provedor.chaveDoAmbiente(r);
+            if (!r || r.cli || !chave) continue;
+            p = { id, nome: r.nome, base: r.base, chave, modelos: r.modelos || [], noCatalogo: r.noCatalogo || (r.catalogo ? id : '') };
+        }
+        const modelo = modeloDe(p, { visao, preferido: id === atual.id ? atual.modelo : (cfg.modelos[id] || '') });
+        if (!modelo) continue;
+        saida.push({ id: p.id, nome: p.nome, cli: false, base: p.base, modelo, chave: p.chave, daAmbiente: p.daAmbiente, noCatalogo: p.noCatalogo });
+    }
+    return saida;
+}
+
+/**
+ * Com qual provedor o pedido sai agora? Devolve { p, trocou, de } — `p` é o próprio `atual`
+ * quando nada muda. Pula quem está em pausa; com imagem, prefere quem enxerga.
+ */
+function escolher(atual, { visao = false, evitar = [] } = {}) {
+    const livres = candidatos(atual, { visao }).filter((c) => livre(c.id) && !evitar.includes(c.id));
+    if (!livres.length) return { p: atual, trocou: false, de: atual };
+    // o provedor da pessoa tem preferência enquanto estiver livre (e, com imagem, se enxergar)
+    const proprio = livres.find((c) => c.id === atual.id);
+    const p = proprio || livres[0];
+    if (!visao && proprio) return { p: atual, trocou: false, de: atual };
+    return { p, trocou: p.id !== atual.id || p.modelo !== atual.modelo, de: atual };
+}
+
+/** A frase para a pessoa. */
+function frase(de, para, motivo = 'pausa') {
+    if (motivo === 'visao') return `${para.nome} enxerga imagens; segui nele.`;
+    return `O ${de.nome} pediu pausa; segui no ${para.nome}.`;
+}
+
+module.exports = { ORDEM_PADRAO, ARQUIVO, config, candidatos, escolher, frase, marcarOcupado, livre, esquecer, modeloDe };

package/lib/session/runner/act.js

@@ -29,6 +29,7 @@ const api = require('../../provider/api');
 const cfg = require('../../config/config');
 const catalogo = require('../../skill/catalogo');
 const repeticao = require('../../repeticao');
+const permissaoSistema = require('../../permissao-sistema');
 const diff = require('../../diff');
 const registro = require('../../registro');
 const permissao = require('../../permission/permissao');
@@ -1146,6 +1147,8 @@ async function runActInterno(userPrompt, opts) {
        mesmo arquivo por uma hora). Empurra uma vez; na segunda, para. */
     const circulo = travado.novo();
     let paradoPorTravar = null;
+    /* Falta permissão do macOS (lib/permissao-sistema.js): para na PRIMEIRA falha, sem tentar de novo. */
+    let paradoPorPermissao = null;
     /* Anota ANTES de agir (lib/auditoria.js): recusado também fica no livro. */
     const anotar = (tc, decisao, motivo) => {
         if (decisao !== 'recusada' && decisao !== 'negada') require('../../plugin/voz-ponte').ferramenta(tc.name, tc.arguments);
@@ -1435,7 +1438,8 @@ async function runActInterno(userPrompt, opts) {
             }
             const enviadas = compactar(messages, { folgado });
             traco(`volta ${voltas}${subagent ? ' (agente)' : ''} · ${enviadas.length} mensagens · ${JSON.stringify(enviadas).length} caracteres`);
-            await motor.requestAct(server, { messages: enviadas, model, preferido: preferido || undefined, effort, token, projectDir: pastaAtual, projectName, subagent, sinal: emVoo.signal }, (evt) => {
+            await motor.requestAct(server, { messages: enviadas, model, preferido: preferido || undefined, effort, token, projectDir: pastaAtual, projectName, subagent, modo: opts.modo, sinal: emVoo.signal }, (evt) => {
+                if (evt.aviso) { if (!subagent) ev('linha', { texto: `  ⎿ ${evt.aviso}`, nivel: 'aviso' }); return; }
                 if (evt.erro) { streamError = folgado ? evt.erro : erroDaCorrente(evt.erro); return; }
                 if (evt.modelo) { modeloDaVolta = evt; ultimoModelo = evt.modelo; if (sinais) sinais.modelo = evt.modelo; require('../../cli/statusline').registrarModelo(evt.modelo); return; }
                 if (evt.tool_call) {
@@ -1791,6 +1795,12 @@ async function runActInterno(userPrompt, opts) {
 
         let motivoTravou = null;
         for (const tc of toolCalls) {
+            // A permissão já faltou nesta volta: o resto do lote não roda, mas cada chamada precisa de resposta.
+            if (paradoPorPermissao) {
+                anotar(tc, 'recusada', 'falta permissão do macOS');
+                messages.push({ role: 'tool', tool_call_id: tc.id, content: JSON.stringify({ ok: false, error: permissaoSistema.mensagem(paradoPorPermissao) }) });
+                continue;
+            }
             /* O JSON da chamada veio quebrado (lib/chamada-torta.js): a
                ferramenta não roda, e o modelo recebe o erro com os argumentos
                crus para se corrigir — em vez de rodar com `{}` e repetir. */
@@ -2113,10 +2123,19 @@ async function runActInterno(userPrompt, opts) {
                respondia "a transcrição precisa do servidor". */
             traco(`executando ${tc.name}`);
             const idAcao = idsAdiantados.get(tc.id) || anotar(tc, 'permitida');
-            const result = adiantadas.has(tc.id) ? adiantadas.get(tc.id)
+            let result = adiantadas.has(tc.id) ? adiantadas.get(tc.id)
                 : await tools.execute(tc.name, tc.arguments, { projectDir: pastaAtual, server, token, api, escolher: subagent ? undefined : escolher,
                     // estudio_criar conta o andamento: a tela desenha a barra do item `estudio`.
-                    progresso: tc.name === 'estudio_criar' ? (pct, etapa) => ev('estudio-progresso', { pct, etapa }) : undefined });
+                    progresso: tc.name === 'estudio_criar' ? (pct, etapa) => ev('estudio-progresso', { pct, etapa }) : undefined,
+                    // estudio_motion: o "Plano atualizado" das etapas (ajustar, estruturar, planejar) chega como linha na conversa.
+                    linha: tc.name === 'estudio_motion' ? (texto) => ev('linha', { texto }) : undefined });
+            const faltaPermissao = permissaoSistema.detectar(tc.name, result);
+            if (faltaPermissao) {
+                result = permissaoSistema.comoErro(faltaPermissao, result);
+                paradoPorPermissao = faltaPermissao;
+                // no app desktop, esta linha no stderr abre a tela de permissões
+                if (process.env.PRIMOCODE_APP === '1' && !subagent) { try { process.stderr.write(permissaoSistema.linhaProtocolo(faltaPermissao)); } catch { /* sem stderr */ } }
+            }
             auditoria.depois(idAcao, result);
             if (sinais && result && result.ok && /^(write_file|edit_file|multi_edit)$/.test(tc.name)) sinais.diagSujo = !!result.diagnosticos;   // diagnóstico depois da edição
             if (antesDaEdicao != null && result && result.ok !== false) {
@@ -2225,6 +2244,8 @@ async function runActInterno(userPrompt, opts) {
 
         /* ANDANDO EM CÍRCULO (lib/travado.js): a primeira vez, um empurrão
            com o que ele está repetindo; a segunda, para — antes da cota. */
+        if (paradoPorPermissao) break;   // a primeira falha de permissão encerra: repetir não adianta
+
         const giro = travado.fimDaVolta(circulo);
         const travou = finished ? null : travado.decidir(circulo, motivoTravou || giro);
         if (travou && travou.acao === 'empurrar') {
@@ -2275,6 +2296,10 @@ async function runActInterno(userPrompt, opts) {
     const concluiu = Boolean(finalText) && !PARAR;
 
     let passagemDaParada = null;
+    if (paradoPorPermissao && !finalText) {
+        finalText = permissaoSistema.mensagem(paradoPorPermissao);
+        if (!subagent) ev('aviso', { texto: finalText });
+    }
     if (paradoPorTravar && !finalText) {
         finalText = paradoPorTravar;
         if (!subagent) ev('aviso', { texto: finalText });

package/lib/skill/catalogo.js

@@ -151,7 +151,7 @@ const GRUPOS = [
               args: 'id. script (o JSX: app.project.items.addComp, camadas, setValueAtTime com ease). comp (o nome da composição). fontes [{familia, peso}]. '
                 + 'audio (caminho relativo, juntado ao vídeo). conferir [segundos]: quadros PNG para olhar antes de dar por pronto. Leia a skill after-effects. Sai em video-ae.mp4.' },
             { tool: 'estudio_motion', escreve: true, faz: 'a máquina de motion: do assunto ao vídeo de motion pronto (cenas no After Effects, sons no tempo, trilha e voz opcionais, −14 LUFS)',
-              args: 'id. assunto. formato (9:16|1:1|16:9). duracao (6 a 60 s). receita (id de estudio_midia acao:"projetos": usa o formato e a duração da ficha). '
+              args: 'id. assunto (ou pedido: as palavras do usuário; sem cenas, passa por 3 etapas antes do render: ajustar o pedido, estruturar em batidas e montar o plano cena por cena; etapas:false volta ao caminho antigo). formato (9:16|1:1|16:9). duracao (6 a 60 s). receita (id de estudio_midia acao:"projetos": usa o formato e a duração da ficha). '
                 + 'marca {cores:{fundo,destaque,tinta}, fontes:{titulo,texto,destaque}}. cenas [{papel, tipo?, fala?, titulo, itens, valor, rotulo, antes, depois, texto, autor, botao}] (o diretor escolhe entre 38 primitivas, 15 transições, 8 câmeras e 8 tipografias, com assinatura própria; a palavra-chave vai entre *asteriscos*). '
                 + 'elementos (termos reais do assunto). transicoes. camera. tipografia. semente. voz (texto ou {}; o whisper mede cada palavra). trilha (true ou o que buscar; false desliga). Sem cenas, o diretor monta. Prefira esta a escrever JSX. Sai em video-motion.mp4. previa:true = rascunho em segundos (meia resolução, sem mix final) para aprovar antes do final. gosto:false pula a tela de gosto do primeiro pedido; o gosto salvo da pessoa (~/.primocode/gosto-motion.json) já entra como peso no diretor — trate como direção, não molde.' },
             { tool: 'estudio_editar', escreve: true, faz: 'o editor por comando: muda um vídeo do estudio_motion (texto, cor, fonte, ritmo, cenas, trilha, volume, formato) e guarda versões',
@@ -294,6 +294,10 @@ const GRUPOS = [
               args: 'pedido: o que o usuário quer, com as palavras dele. pasta (opcional): onde construir — sem ela, uma pasta nova com o nome do pedido. rodadas (opcional, 1 a 4, padrão 2): quantas voltas de correção. '
                 + 'USE quando pedirem um app, um site, uma página ou uma ferramenta INTEIRA, do zero. NÃO use para mexer no que já existe, para um arquivo só, nem para conserto: são seis a oito chamadas de agente, '
                 + 'e gastá-las para trocar a cor de um botão come o dia do usuário. O revisor ABRE a página num navegador invisível e mede — página em branco e erro de JavaScript reprovam sozinhos, o que ele achar volta para o construtor.' },
+            // Só vai ao modelo quando o recorte por assunto tirou ferramentas (provedor com limite de TPM):
+            // lib/provider/local/recorte.js monta o schema real; aqui é o registro, e o tools.js atende.
+            { tool: 'mais_ferramentas', escreve: false, faz: 'liga um grupo de ferramentas que ficou de fora, na próxima volta',
+              args: 'grupo: o nome do grupo.' },
             { tool: 'finish',      escreve: false, faz: 'encerra dizendo o que fez', noLoop: true,
               args: 'summary (opcional): uma frase do que foi feito.' },
         ],

package/lib/tool/tools.js

@@ -1004,7 +1004,7 @@ async function despachar(name, args, ctx) {
                     abrir: (arquivo) => { try { openInBrowser(arquivo); } catch {} },
                 });
             case 'estudio_motion':
-                return estudio.ferramentaMotion(args);
+                return estudio.ferramentaMotion(args, ctx);
             case 'estudio_editar':
                 return estudio.ferramentaEditar(args);
             case 'estudio_narrar':
@@ -1083,6 +1083,10 @@ async function despachar(name, args, ctx) {
                 return { ok: true, clicado: alvo.nome, tipo: alvo.tipo, x: alvo.x, y: alvo.y, duplo: !!args.double };
             }
 
+            case 'mais_ferramentas':
+                // O grupo é ligado pelo motor na próxima volta, lendo esta chamada na conversa (recorte.js).
+                return { ok: true, grupo: String(args.grupo || ''), aviso: 'grupo ligado: as ferramentas dele estão disponíveis a partir da próxima chamada' };
+
             default:
                 /* O MODELO PRECISA CONSEGUIR SE CORRIGIR AQUI.
                    "Tool não implementada: studio_criar" não diz o que existe,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primocode",
-  "version": "11.4.0",
+  "version": "11.5.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": {

package/vendor/fontes/ttf/ORIGEM.txt

@@ -0,0 +1 @@
+Inter 800 (ExtraBold), Google Fonts, licença SIL OFL 1.1. Embutida para a pele do Destrava funcionar sem rede (glifos.baixarFonte olha aqui primeiro).

package/vendor/gsap/ORIGEM.txt

@@ -0,0 +1,6 @@
+GSAP 3.15.0 (gsap.min.js, núcleo).
+Origem: copiado de hyperframes@0.8.154 (dist/vendor/npm/gsap@3.15.0), o mesmo pacote que o PrimoCode já usa para renderizar.
+Licença: GreenSock "Standard License" (https://gsap.com/standard-license). Desde a 3.13 o GSAP inteiro é gratuito, inclusive
+uso comercial; a licença proíbe só montar um produto concorrente de ferramenta visual de animação. O cabeçalho original
+com o aviso fica no topo do arquivo e não pode ser removido.
+Por que está aqui: o HTML que a IA escreve para o Hyperframes não precisa de URL de CDN. O motor injeta/troca por este arquivo.