primocode 8.42.1 → 9.0.0

package/lib/skills.js

@@ -0,0 +1,329 @@
+/**
+ * skills.js — o que o PrimoCode sabe fazer bem, escrito em texto.
+ *
+ *   "O Primo Code já vem com várias skills instaladas por padrão. Comandos:
+ *    /skills, /install-skill e /marketplace."
+ *
+ * ── O QUE É UMA SKILL, E O QUE ELA NÃO É ─────────────────────────────────
+ * Uma skill é uma pasta com um `SKILL.md` dentro: um cabeçalho que diz quem
+ * ela é e quando serve, e um corpo que é o prompt dela. Nada de código, nada
+ * de instalar dependência, nada que rode. É conhecimento, não programa.
+ *
+ * Isso é decisão, não limitação. Uma skill que executa código é uma porta
+ * para qualquer pessoa mandar um arquivo e rodar o que quiser na máquina de
+ * quem instalou — e um marketplace de programas executáveis exige assinatura,
+ * revisão e sandbox, que é outro produto. Skill é texto: o pior que um texto
+ * mal-intencionado faz é dar um conselho ruim ao modelo, e o usuário vê o
+ * agente agindo, passo a passo, na tela.
+ *
+ * ── POR QUE NÃO É A MESMA COISA QUE OS ESPECIALISTAS ─────────────────────
+ * `especialistas.js` são sete briefings FIXOS, escolhidos pelo modelo quando
+ * ele delega uma tarefa a um subagente. Eles são do produto: ninguém instala,
+ * ninguém desliga, e a lista não cresce.
+ *
+ * Skill é do USUÁRIO. Ele instala, desliga, escreve a dele. É a resposta para
+ * "o Primo sempre esquece de rodar o lint antes de terminar" — que não se
+ * resolve pedindo de novo a cada conversa, e sim escrevendo uma vez.
+ *
+ * ── COMO ELA CHEGA AO MODELO ─────────────────────────────────────────────
+ * O corpo NÃO vai em todo pedido. São oito skills; mandar todas custaria
+ * milhares de tokens por mensagem num plano limitado por token, para que
+ * sete delas não tenham nada a ver com o pedido.
+ *
+ * O que decide é o `quando:` do cabeçalho — as palavras que fazem aquela
+ * skill valer a pena. Bateu, o corpo dela entra na frente da tarefa; não
+ * bateu, ela não custa nada. É o mesmo desenho dos especialistas, e pelo
+ * mesmo motivo: o teto de tokens é o recurso escasso deste produto.
+ *
+ * ── ONDE ELAS MORAM ──────────────────────────────────────────────────────
+ * Em `~/.primocode/skills/`, fora do pacote — pelo mesmo motivo do Studio:
+ * instalado global, a pasta do pacote costuma ser de sistema, e um `npm
+ * update` apagaria o que o usuário escreveu. As que vêm com o produto são
+ * copiadas na primeira vez; as dele ficam lá, a salvo de atualização.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ORIGEM = path.join(__dirname, '..', 'skills');
+const CASA = path.join(os.homedir(), '.primocode', 'skills');
+const ESTADO = path.join(CASA, 'estado.json');
+
+/* Teto do que entra num pedido. Duas skills longas já são mais texto que a
+   maioria das tarefas — e cada caractere aqui é um caractere a menos de
+   arquivo lido. Estourou, entram as que couberam, das que casaram melhor. */
+const MAX_CARACTERES = 6000;
+
+// ── leitura ──────────────────────────────────────────────────────────────
+
+/**
+ * O cabeçalho e o corpo de um SKILL.md.
+ *
+ * O cabeçalho fica entre duas linhas de `---`, uma chave por linha. Formato
+ * escolhido por ser o que qualquer pessoa já viu, e por caber num parser de
+ * dez linhas — YAML de verdade seria uma dependência para ler quatro campos.
+ */
+function separar(texto) {
+    const bruto = String(texto || '');
+    const m = bruto.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!m) return { cabecalho: {}, corpo: bruto.trim() };
+    const cabecalho = {};
+    for (const linha of m[1].split(/\r?\n/)) {
+        const par = linha.match(/^\s*([a-zA-Z_][\w-]*)\s*:\s*(.*)$/);
+        if (par) cabecalho[par[1].toLowerCase()] = par[2].trim().replace(/^["']|["']$/g, '');
+    }
+    return { cabecalho, corpo: m[2].trim() };
+}
+
+function lerEstado() {
+    try { return JSON.parse(fs.readFileSync(ESTADO, 'utf8')); } catch { return { desligadas: [] }; }
+}
+
+function salvarEstado(estado) {
+    try {
+        fs.mkdirSync(CASA, { recursive: true });
+        fs.writeFileSync(ESTADO, JSON.stringify(estado, null, 2), 'utf8');
+        return true;
+    } catch { return false; }
+}
+
+/* As que vêm com o produto são copiadas na primeira vez. Copiar SEMPRE por
+   cima seria desfazer a edição de quem melhorou uma delas; copiar só o que
+   falta deixa o usuário dono do que ele mexeu. */
+function prepararCasa() {
+    fs.mkdirSync(CASA, { recursive: true });
+    let nascidas = 0;
+    let origens = [];
+    try { origens = fs.readdirSync(ORIGEM, { withFileTypes: true }); } catch { return 0; }
+    for (const item of origens) {
+        if (!item.isDirectory()) continue;
+        const destino = path.join(CASA, item.name);
+        if (fs.existsSync(destino)) continue;
+        try {
+            fs.mkdirSync(destino, { recursive: true });
+            fs.copyFileSync(path.join(ORIGEM, item.name, 'SKILL.md'), path.join(destino, 'SKILL.md'));
+            nascidas++;
+        } catch { /* uma que falha não impede as outras */ }
+    }
+    return nascidas;
+}
+
+/** Uma skill pelo nome da pasta, ou null. */
+function ler(nome) {
+    const arquivo = path.join(CASA, nome, 'SKILL.md');
+    let texto;
+    try { texto = fs.readFileSync(arquivo, 'utf8'); } catch { return null; }
+    const { cabecalho, corpo } = separar(texto);
+    const estado = lerEstado();
+    return {
+        nome,
+        titulo: cabecalho.nome || cabecalho.titulo || nome,
+        descricao: cabecalho.descricao || '',
+        quando: String(cabecalho.quando || '').split(',').map((s) => s.trim().toLowerCase()).filter(Boolean),
+        autor: cabecalho.autor || '',
+        corpo,
+        ligada: !estado.desligadas.includes(nome),
+        doProduto: fs.existsSync(path.join(ORIGEM, nome, 'SKILL.md')),
+        caminho: arquivo,
+    };
+}
+
+/** Todas as instaladas, em ordem alfabética. */
+function listar() {
+    prepararCasa();
+    let nomes = [];
+    try {
+        nomes = fs.readdirSync(CASA, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name)
+            .sort();
+    } catch { return []; }
+    return nomes.map(ler).filter(Boolean);
+}
+
+// ── escrita ──────────────────────────────────────────────────────────────
+
+/* O nome vira pasta, então precisa ser um nome de pasta: sem barra, sem
+   `..`, sem acento. Um nome com `../` escreveria fora de ~/.primocode. */
+function apelidar(bruto) {
+    return String(bruto || '')
+        .normalize('NFD').replace(/[̀-ͯ]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 48);
+}
+
+/**
+ * Cria (ou reescreve) uma skill.
+ *
+ * @param {string} nome      como a pessoa a chamou
+ * @param {string} corpo     o prompt inteiro
+ * @param {object} extra     { descricao, quando, autor }
+ */
+function criar(nome, corpo, extra = {}) {
+    const apelido = apelidar(nome);
+    if (!apelido) return { ok: false, error: 'Dê um nome à skill.' };
+    if (!String(corpo || '').trim()) return { ok: false, error: 'A skill precisa de um conteúdo — é ele que vai para o modelo.' };
+
+    const cabecalho = [
+        '---',
+        `nome: ${String(nome).trim()}`,
+        `descricao: ${String(extra.descricao || '').replace(/\n/g, ' ').trim()}`,
+        `quando: ${String(extra.quando || '').replace(/\n/g, ' ').trim()}`,
+        `autor: ${String(extra.autor || 'você').trim()}`,
+        '---',
+        '',
+    ].join('\n');
+
+    try {
+        const pasta = path.join(CASA, apelido);
+        fs.mkdirSync(pasta, { recursive: true });
+        fs.writeFileSync(path.join(pasta, 'SKILL.md'), cabecalho + String(corpo).trim() + '\n', 'utf8');
+        // Skill recém-criada nasce LIGADA, mesmo que uma de mesmo nome tenha
+        // sido desligada antes: quem acabou de escrevê-la quer usá-la.
+        const estado = lerEstado();
+        estado.desligadas = estado.desligadas.filter((x) => x !== apelido);
+        salvarEstado(estado);
+        return { ok: true, nome: apelido, caminho: path.join(pasta, 'SKILL.md') };
+    } catch (e) {
+        return { ok: false, error: `Não deu para gravar: ${e.message}` };
+    }
+}
+
+function ligar(nome, ligada) {
+    const estado = lerEstado();
+    estado.desligadas = estado.desligadas.filter((x) => x !== nome);
+    if (!ligada) estado.desligadas.push(nome);
+    salvarEstado(estado);
+    return { ok: true, nome, ligada: !!ligada };
+}
+
+/**
+ * Apaga uma skill.
+ *
+ * As do produto voltam no próximo `listar()` — a cópia nasce de novo a partir
+ * do pacote. Por isso apagar uma delas não é apagar, é DESLIGAR: prometer
+ * remoção e ver a skill reaparecer amanhã é pior que dizer a verdade agora.
+ */
+function apagar(nome) {
+    const s = ler(nome);
+    if (!s) return { ok: false, error: `Não achei a skill "${nome}".` };
+    if (s.doProduto) {
+        ligar(nome, false);
+        return { ok: true, desligada: true,
+            aviso: 'Esta skill vem com o PrimoCode, então ela foi DESLIGADA em vez de apagada — '
+                + 'apagada, ela voltaria na próxima atualização.' };
+    }
+    try {
+        fs.rmSync(path.join(CASA, nome), { recursive: true, force: true });
+        return { ok: true, apagada: true };
+    } catch (e) { return { ok: false, error: e.message }; }
+}
+
+/**
+ * Instala de um arquivo ou de uma pasta que já está no disco.
+ *
+ * Não busca na rede de propósito: baixar e executar texto que virou prompt do
+ * agente é uma decisão que merece o caminho explícito de quem salvou o
+ * arquivo antes. O `/marketplace` traz as do catálogo; `/install-skill
+ * <caminho>` traz as que a pessoa escreveu ou recebeu.
+ */
+function instalarDe(caminho) {
+    const alvo = String(caminho || '').replace(/^~(?=$|[/\\])/, os.homedir());
+    let arquivo = alvo;
+    try {
+        if (fs.statSync(alvo).isDirectory()) arquivo = path.join(alvo, 'SKILL.md');
+    } catch { return { ok: false, error: `Não achei ${caminho}.` }; }
+
+    let texto;
+    try { texto = fs.readFileSync(arquivo, 'utf8'); }
+    catch { return { ok: false, error: `Não consegui ler ${arquivo}. Uma skill é um arquivo SKILL.md.` }; }
+
+    const { cabecalho, corpo } = separar(texto);
+    const nome = cabecalho.nome || path.basename(path.dirname(arquivo));
+    if (!corpo.trim()) return { ok: false, error: 'O arquivo não tem conteúdo depois do cabeçalho.' };
+    return criar(nome, corpo, cabecalho);
+}
+
+// ── o que entra no pedido ────────────────────────────────────────────────
+
+const semAcento = (v) => String(v || '').toLowerCase()
+    .normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+
+/**
+ * Quantas palavras do `quando:` aparecem no texto do pedido.
+ *
+ * ── PALAVRA INTEIRA, NUNCA PEDACO ────────────────────────────────────────
+ * O primeiro jeito era `texto.includes(palavra)`, e estava errado de um jeito
+ * que so apareceu no ensaio: "faz uma landing page PRO meu curso" puxou a
+ * skill de Git, porque o gatilho `pr` mora dentro de "pro". Gatilhos curtos
+ * — pr, api, seo, css — casam com metade da lingua portuguesa se a borda nao
+ * for exigida.
+ *
+ * Uma skill errada nao e ruido inofensivo: ela ocupa o teto de tokens do
+ * pedido e da ao modelo instrucoes sobre um assunto que ninguem pediu.
+ */
+function pontuar(skill, texto) {
+    const t = semAcento(texto);
+    let pontos = 0;
+    for (const palavra of skill.quando) {
+        const p = semAcento(palavra).trim();
+        if (!p) continue;
+        const escapado = p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // A borda e escrita a mao em vez de `\b`: o gatilho pode comecar ou
+        // terminar em simbolo ("e-mail"), e ali o `\b` nao vale.
+        const re = new RegExp('(^|[^a-z0-9])' + escapado + '($|[^a-z0-9])');
+        if (re.test(t)) pontos++;
+    }
+    return pontos;
+}
+
+/**
+ * As skills que valem a pena para ESTE pedido, das mais ao menos relevantes.
+ *
+ * Só as ligadas, só as que casaram com alguma palavra, e só até o teto de
+ * caracteres. Skill que não casou não entra: mandar as oito em todo pedido
+ * custaria milhares de tokens para sete delas não terem nada a ver com o que
+ * foi pedido.
+ */
+function paraOPedido(texto, { teto = MAX_CARACTERES, todas = null } = {}) {
+    const lista = (todas || listar()).filter((s) => s.ligada && s.corpo);
+    const casadas = lista
+        .map((s) => ({ skill: s, pontos: pontuar(s, texto) }))
+        .filter((x) => x.pontos > 0)
+        .sort((a, b) => b.pontos - a.pontos);
+
+    const escolhidas = [];
+    let tamanho = 0;
+    for (const { skill } of casadas) {
+        if (tamanho + skill.corpo.length > teto) continue;
+        escolhidas.push(skill);
+        tamanho += skill.corpo.length;
+    }
+    return escolhidas;
+}
+
+/**
+ * O texto que vai na frente da tarefa.
+ *
+ * Vem antes do pedido, e não depois, pelo mesmo motivo do briefing dos
+ * especialistas: é contexto para ler o pedido, não um adendo a ele.
+ */
+function montar(texto, op = {}) {
+    const escolhidas = paraOPedido(texto, op);
+    if (!escolhidas.length) return { texto, skills: [] };
+    const blocos = escolhidas.map((s) => `### ${s.titulo}\n${s.corpo}`);
+    const cabeca = 'O QUE VOCÊ SABE SOBRE ESTE TIPO DE TAREFA (siga ao trabalhar):\n\n'
+        + blocos.join('\n\n') + '\n\n---\n\nPEDIDO:\n';
+    return { texto: cabeca + texto, skills: escolhidas };
+}
+
+module.exports = {
+    CASA, ORIGEM, MAX_CARACTERES,
+    separar, listar, ler, criar, ligar, apagar, instalarDe, apelidar,
+    paraOPedido, montar, pontuar, prepararCasa,
+};

package/lib/tools.js

@@ -14,8 +14,7 @@ const { exec, execFile } = require('child_process');
 const browser = require('./browser');
 const desktop = require('./desktop');
 const referencia = require('./referencia');
-const studio = require('./studio');
-const acervo = require('./acervo');
+const estudio = require('./estudio');
 const cfg = require('./config');
 
 const IGNORAR = new Set(['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.cache', 'vendor']);
@@ -171,11 +170,6 @@ async function runShell(command, timeout = 60000, cwd) {
 // execFile com array de argumentos nunca passa por shell nenhum: "target" vira
 // UM argumento, não texto que um shell reinterpreta — sem isso, um valor tipo
 // `https://x/"; touch /tmp/pwned; echo "` injetava comando (achado de segurança).
-// Quando o auto-abrir do Studio abriu pela última vez — o freio das mil abas.
-let ultimaAberturaStudio = 0;
-// Uma rodada de melhoria por tarefa (ver o aviso em studio_criar).
-let melhorouStudio = false;
-
 function openInBrowser(target) {
     const p = os.platform();
     const [cmd, args, opener] = p === 'darwin' ? ['open', [target], 'open']
@@ -270,6 +264,13 @@ function editFile({ path: rawPath, old_string, new_string, replace_all }, projec
         substituicoes: replace_all ? ocorrencias : 1,
         linhasAntes: original.split('\n').length,
         linhasDepois: atualizado.split('\n').length,
+        // As duas versões, para a TELA desenhar o diff. O `_` na frente marca
+        // o que é só nosso: o act.js apaga estas chaves antes de a conversa
+        // seguir, porque mandar o arquivo de volta ao modelo custaria
+        // centenas de tokens para ensinar a ele o texto que ele acabou de
+        // escrever.
+        _antes: original,
+        _depois: atualizado,
     };
 }
 
@@ -304,6 +305,7 @@ function multiEdit({ path: rawPath, edits }, projectDir) {
     if (!Array.isArray(edits) || !edits.length) return { ok: false, error: 'edits (lista) é obrigatório' };
 
     let conteudo = fs.readFileSync(filePath, 'utf-8');
+    const original = conteudo;
     const linhasAntes = conteudo.split('\n').length;
     let substituicoes = 0;
 
@@ -329,6 +331,8 @@ function multiEdit({ path: rawPath, edits }, projectDir) {
         substituicoes,
         linhasAntes,
         linhasDepois: conteudo.split('\n').length,
+        _antes: original,
+        _depois: conteudo,
     };
 }
 
@@ -401,9 +405,20 @@ async function despachar(name, args, ctx) {
                 const filePath = resolveInProject(args.path, projectDir);
                 const content = args.content || '';
                 const created = !fs.existsSync(filePath);
+                // Reescrever um arquivo que já existe é a operação mais
+                // perigosa do agente: o conteúdo antigo some inteiro. Ler o
+                // que estava lá ANTES de escrever é o que permite mostrar na
+                // tela o que foi perdido.
+                let antes = '';
+                if (!created) { try { antes = fs.readFileSync(filePath, 'utf-8'); } catch { antes = ''; } }
                 fs.mkdirSync(path.dirname(filePath), { recursive: true });
                 fs.writeFileSync(filePath, content, 'utf-8');
-                return { ok: true, created, path: path.relative(projectDir, filePath).replace(/\\/g, '/'), bytes: content.length };
+                return {
+                    ok: true, created,
+                    path: path.relative(projectDir, filePath).replace(/\\/g, '/'),
+                    bytes: content.length,
+                    ...(created ? {} : { _antes: antes, _depois: content }),
+                };
             }
             case 'edit_file':
                 return editFile(args, projectDir);
@@ -441,16 +456,6 @@ async function despachar(name, args, ctx) {
                     paginas: Math.max(1, Math.min(5, Number(args.paginas) || 3)),
                 });
 
-            // Música e efeito sonoro da internet, com licença e crédito. O
-            // arquivo vem para a pasta do projeto e sobe para o estúdio;
-            // volta a URL "/midia/…" pronta para trilha.src ou som.arquivo.
-            case 'buscar_audio':
-                return require('./audio-livre.js').buscarAudio(args, { projectDir, studio });
-
-            // A logo e a identidade visual da empresa, lidas do site dela.
-            case 'marca_da_empresa':
-                return require('./marca.js').marcaDaEmpresa(args, { projectDir, studio });
-
             // memory-geral.md fica FORA da pasta do projeto — write_file/edit_file
             // não alcançam por design (resolveInProject bloqueia ../ de propósito).
             // Esta é a única porta para lá, sem reabrir a sandbox.
@@ -514,171 +519,36 @@ async function despachar(name, args, ctx) {
                 return desktop.scroll(args.dy != null ? args.dy : 300);
             case 'desktop_size':
                 return desktop.getScreenSize();
-            // ── PrimoCode Studio — a suíte de criação (sobe sozinha) ───────
-            case 'studio_manual':
-                return studio.manual();
-            case 'studio_spec':
-                return studio.spec(args.ferramenta || args.slug || '');
-            case 'studio_criar': {
-                const r = await studio.criar({ ferramenta: args.ferramenta, titulo: args.titulo, doc: args.doc });
-                // Criou? ABRE NO NAVEGADOR, sozinho. O dono: "quando ele faz um
-                // vídeo, uma apresentação, abre automático — a pessoa não vai
-                // saber abrir". E cada "abre pra mim" digitado depois custava
-                // uma tarefa inteira de tokens para o modelo redescobrir o
-                // link. Abrir é determinístico: não se gasta modelo com isso.
-                // Fica anotado na memória geral: é assim que "lembra do
-                // vídeo tal" funciona na conversa seguinte. O id é o que
-                // permite reabrir ou ajustar sem recriar.
-                if (r && r.ok !== false && r.id) {
-                    cfg.lembrarCriacao({ ferramenta: r.ferramenta || args.ferramenta,
-                        titulo: r.titulo || args.titulo, id: r.id });
-                }
-                if (r && r.ok !== false && r.ver) {
-                    // UMA aba por tarefa. O modelo às vezes cria três versões
-                    // seguidas, e abrir todas enchia o navegador do usuário de
-                    // abas — "abre 1000 versões". A primeira abre; as outras
-                    // são avisadas a ATUALIZAR a que já existe.
-                    const agora = Date.now();
-                    if (agora - ultimaAberturaStudio > 45000) {
-                        ultimaAberturaStudio = agora;
-                        try { openInBrowser(r.ver); } catch {}
-                        r.abertoNoNavegador = true;
-                        // O estúdio revisa a peça e devolve o que ficou
-                        // monótono (mesmo fundo em tudo, transição repetida,
-                        // sem trilha). Sem este ramo o aviso mandaria "chame
-                        // finish, não ajuste" — e a revisão morreria ali, que
-                        // é justamente o "fica tudo genérico".
-                        //
-                        // UMA rodada de conserto, e acabou: mais que isso
-                        // vira o agente polindo sozinho enquanto o usuário
-                        // espera.
-                        if (Array.isArray(r.podeMelhorar) && r.podeMelhorar.length && !melhorouStudio) {
-                            melhorouStudio = true;
-                            r.aviso = 'JÁ ABERTO no navegador. Antes de finalizar, faça UMA correção: '
-                                + `use studio_atualizar no id "${r.id}" mandando SÓ as chaves que mudam, `
-                                + 'para resolver os pontos de "podeMelhorar". Depois chame finish. '
-                                + 'Não crie outro arquivo e não repita esta correção.';
-                        } else {
-                            r.aviso = 'JÁ ABERTO no navegador do usuário. Chame finish AGORA dizendo o que foi criado — não abra de novo, não leia de volta, não ajuste sem pedido.';
-                        }
-                    } else {
-                        r.aviso = `Você JÁ criou uma versão nesta tarefa, e ela está aberta no navegador. NÃO crie outra: `
-                            + `para mudar algo, use studio_atualizar com o id "${r.id}". Chame finish AGORA.`;
-                    }
-                }
-                return r;
-            }
-            case 'studio_ler':
-                return studio.ler(args.id);
-            case 'studio_atualizar':
-                return studio.atualizar({ id: args.id, titulo: args.titulo, doc: args.doc });
-            case 'studio_versoes':
-                return studio.versoesDe({ id: args.id, restaurar: args.restaurar });
-            case 'studio_listar':
-                return studio.listar();
-            case 'studio_midia':
-                // Sem arquivo, lista o que já foi enviado; com arquivo, envia.
-                return args.arquivo
-                    ? studio.midiaEnviar({ arquivo: resolveInProject(args.arquivo, projectDir), nome: args.nome })
-                    : studio.midiaListar();
-            /* ── MÍDIA DE VERDADE, VINDA DA INTERNET ──────────────────
-             *
-             * Buscar, baixar, recortar o fundo e já deixar na galeria do
-             * estúdio. O caminho inteiro é uma tool só do ponto de vista do
-             * agente (procurar → baixar), e o `paraEstudio` é o que evita a
-             * volta clássica: baixar num canto do disco e depois descobrir
-             * que a cena precisa de uma URL "/midia/...".
+            /* ── O ESTÚDIO ─────────────────────────────────────────────────
+             * Sete ferramentas, e nenhuma delas fala com servidor nenhum: o
+             * Studio antigo subia um Python em localhost:7777 porque tinha
+             * uma interface web para servir. A interface morreu — a IA faz
+             * tudo e abre o vídeo pronto — e o servidor morreu com ela.
              *
-             * A licença desce junto e fica gravada ao lado do arquivo. Um
-             * vídeo de cliente com foto CC BY sem crédito é problema do
-             * cliente, e descobrir isso depois de publicar é tarde. */
-            case 'midia_procurar':
-                return acervo.procurar(args.consulta || args.q || '', {
-                    tipo: args.tipo, quantos: args.quantos, orientacao: args.orientacao,
-                    licenca: args.licenca,
+             * Cada peça é uma PASTA, cada render é o Remotion. Ver
+             * lib/estudio/ para o porquê de cada peça.
+             */
+            case 'estudio_projeto':
+                return estudio.ferramentaProjeto(args);
+            case 'estudio_plano':
+                return estudio.ferramentaPlano(args);
+            case 'estudio_midia':
+                return estudio.ferramentaMidia(args);
+            case 'estudio_narrar':
+                return estudio.ferramentaNarrar(args);
+            case 'estudio_video':
+                // A transcrição precisa do servidor (a chave é dele), então o
+                // contexto do pedido atravessa até aqui.
+                return estudio.ferramentaVideo(args, ctx);
+            case 'estudio_render':
+                return estudio.ferramentaRender(args, {
+                    ...ctx,
+                    // O vídeo pronto abre para a pessoa assistir. É a única
+                    // coisa que abre: foi o vídeo que ela pediu.
+                    abrir: (arquivo) => { try { openInBrowser(arquivo); } catch {} },
                 });
-            case 'midia_baixar': {
-                const r = await acervo.baixar(args.url, { titulo: args.titulo, meta: {
-                    autor: args.autor || null, licenca: args.licenca || null,
-                    fonte: args.fonte || null, pagina: args.pagina || null,
-                } });
-                if (!r.ok) return r;
-                let arquivo = r.arquivo;
-                if (args.semFundo) {
-                    const corte = await acervo.tirarFundo(arquivo);
-                    if (corte.ok) { arquivo = corte.arquivo; r.recorte = corte.metodo; r.avisoRecorte = corte.aviso; }
-                    else r.avisoRecorte = corte.error;
-                }
-                r.arquivo = arquivo;
-                if (args.paraEstudio !== false) {
-                    const g = await studio.midiaEnviar({ arquivo, nome: args.nome });
-                    // O "/midia/..." é o que vai em `src` e em `fundo.imagem`.
-                    if (g && g.ok !== false) r.src = g.url || g.src || null;
-                    else r.avisoGaleria = (g && g.error) || 'não deu para mandar para a galeria';
-                }
-                return r;
-            }
-            case 'midia_sem_fundo':
-                return acervo.tirarFundo(resolveInProject(args.arquivo, projectDir), { destino: args.destino });
-            case 'midia_creditos':
-                return { ok: true, creditos: acervo.creditos() };
-
-            case 'studio_analisar': {
-                // Ouvir o vídeo para achar as pausas. A conta acontece num
-                // navegador (é quem sabe decodificar MP4 sem instalar nada) —
-                // e ESCONDIDO: a conta não é da pessoa, e uma aba piscando no
-                // navegador dela é encanamento aparecendo. Sem Chrome nem
-                // Chromium nesta máquina, cai no navegador dela, como antes.
-                const visivel = process.env.PRIMOCODE_ANALISE_VISIVEL === '1';
-                const abrir = visivel ? openInBrowser : async (url) => {
-                    try { return await browser.abrirEscondido(url); }
-                    catch { openInBrowser(url); return null; }
-                };
-                return studio.analisarAudio({
-                    arquivo: args.arquivo, pausa: args.pausa, manter: args.manter,
-                    repetida: args.repetida, abrir, escondido: visivel ? null : browser.rodarEscondido,
-                });
-            }
-            case 'studio_exportar':
-                // O mp4 sem clique: a página do player roda escondida e gera
-                // pelo mesmo caminho do botão. Ver lib/studio.js.
-                // Com o Remotion mesclado: o vídeo quadro a quadro dele, o
-                // áudio do Studio. PRIMOCODE_SEM_REMOTION=1 desliga.
-                return studio.exportarVideo({
-                    id: args.id, destino: args.destino, fps: args.fps,
-                    escondido: browser.rodarEscondido, pasta: projectDir || process.cwd(),
-                    remotion: process.env.PRIMOCODE_SEM_REMOTION !== '1',
-                });
-
-            /* A MESMA peça, virando projeto Remotion.
-             *
-             * O Studio continua sendo o caminho normal: exporta em segundos,
-             * sem instalar nada. Isto é para quando o usuário pede Remotion
-             * pelo nome, ou quando a peça precisa do que só ele dá — render
-             * determinístico, vídeo longo, fps e codec escolhidos, ou o
-             * projeto em React para a pessoa mexer.
-             *
-             * Parte do documento que já existe: nada de um segundo
-             * vocabulário para o agente aprender. */
-            case 'remotion_projeto': {
-                const remotion = require('./remotion.js');
-                const peca = await studio.ler(args.id);
-                if (!peca || peca.ok === false) {
-                    return peca || { ok: false, error: `não achei a peça ${args.id}` };
-                }
-                const arq = peca.arquivo || peca;
-                const base = projectDir || cfg.ROOT_DIR;
-                const nome = cfg.slugify(args.pasta || arq.titulo || 'video') + '-remotion';
-                const destino = path.join(base, nome);
-                const r = remotion.montar({
-                    destino, titulo: arq.titulo, doc: arq.doc, fps: args.fps,
-                });
-                if (!r.ok || !args.renderizar) return r;
-                // Só renderiza quando pedido: o `npm install` demora minutos e
-                // é escolha do usuário, não efeito colateral de criar a pasta.
-                const feito = await remotion.renderizar({ pasta: destino });
-                return Object.assign(r, { render: feito });
-            }
+            case 'estudio_site':
+                return estudio.ferramentaSite(args);
 
             case 'desktop_double_click':
                 return desktop.doubleClick(args.x, args.y);

package/lib/ui.js

@@ -160,9 +160,10 @@ const TIPS = [
 ];
 
 const NEWS = [
-    'Vídeo com DIRETOR: roteiro, narração, voz e movimento antes de produzir',
-    'Ele busca e baixa imagem, logo e música — com a licença junto',
-    'A escolha da IA na abertura agora anda nas setinhas',
+    'Vídeo com DIRETOR: roteiro, narração e voz decididos antes de produzir',
+    'Ele busca e baixa imagem, logo e música — com a licença junto do arquivo',
+    '/voice abre o Primo Code Voice · /marketplace instala skills',
+    'Do "high" para cima ele PESQUISA referências antes de escrever',
     'Esc Esc a qualquer momento para o agente no meio do trabalho',
 ];
 
@@ -313,6 +314,9 @@ function actionHeader(name, args) {
     const label = ROTULOS[name] || name;
     let argStr = args ? (args.consulta || args.path || args.pattern || args.command || args.target || args.url || args.selector || args.text || args.app || args.window || args.name || args.ferramenta || args.titulo || args.description || (args.todos ? `${args.todos.length} tarefas` : '') || (args.x != null ? `${args.x},${args.y}` : '') || args.key || args.arquivo || args.id || JSON.stringify(args).slice(0,60)) : '';
     argStr = String(argStr || '').replace(/\s+/g, ' ').trim();
+    // Uma tool sem argumento nenhum caía no JSON.stringify e desenhava "{}"
+    // ao lado do nome — ruído que não diz nada.
+    if (argStr === '{}' || argStr === 'null' || argStr === 'undefined') argStr = '';
     if (argStr.length > 96) argStr = argStr.slice(0, 95) + '…';
     return `  ${c.brand('●')} ${c.bold(label)}${argStr ? '  '+c.muted(argStr) : ''}`;
 }