primocode 8.22.1 → 8.26.0

package/lib/app.js

@@ -0,0 +1,334 @@
+/**
+ * app.js — o PrimoCode como aplicativo de janela.
+ *
+ *   "Se mandar /app pra ele, ele abre o aplicativo que você vai desenvolver
+ *    para o Mac e o Windows, já instala junto com o npm. Vai ser um aplicativo
+ *    desktop bem bonito com as cores do PrimoCode, com aquele azul. Bem estilo
+ *    Codex. Vai ter o chat em localhost. Um chat estilo terminal para quem não
+ *    quer o terminal."
+ *
+ * ── POR QUE NÃO É ELECTRON ───────────────────────────────────────────────
+ * O PrimoCode tem ZERO dependência de npm, e isso não é purismo: é o que faz
+ * `npm i -g primocode` levar segundos em vez de baixar 200 MB de navegador
+ * empacotado. Electron levaria os dois embora — a promessa de "já instala
+ * junto com o npm" e a instalação leve.
+ *
+ * O que Electron entrega, no fundo, é uma janela sem barra de endereço
+ * mostrando uma página local. Chrome, Edge e Brave fazem exatamente isso com
+ * `--app=<url>`: janela limpa, ícone próprio na barra de tarefas, sem abas.
+ * O navegador já está na máquina do usuário — no Windows o Edge vem com o
+ * sistema, no Mac o Safari (e quase sempre o Chrome).
+ *
+ * Então: servidor HTTP local (http do Node, nada instalado) + janela do
+ * navegador em modo app. Se não houver nenhum navegador de Chromium, abre
+ * numa aba normal, que continua funcionando.
+ *
+ * ── POR QUE ELE ESPELHA O TERMINAL ───────────────────────────────────────
+ * O pedido foi "um chat estilo terminal para quem não quer o terminal" — e o
+ * agente já conta o que faz, linha por linha, com cor. Reescrever essa saída
+ * para a web daria duas verdades para manter, e uma delas ficaria velha.
+ *
+ * Aqui a saída é a MESMA: o `process.stdout.write` é espelhado, os códigos
+ * ANSI viram cor de verdade na página, e o terminal continua imprimindo
+ * normalmente. Quem abrir os dois vê a mesma coisa nos dois.
+ *
+ * ── SEGURANÇA ────────────────────────────────────────────────────────────
+ * Este servidor MANDA NO AGENTE: quem fala com ele executa comando, escreve
+ * arquivo e gasta a cota do usuário. Por isso ele só escuta em 127.0.0.1 e
+ * exige uma chave sorteada a cada abertura — sem ela, uma página qualquer
+ * aberta no mesmo navegador dispararia pedidos para cá.
+ */
+
+'use strict';
+
+const http = require('http');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { execFile } = require('child_process');
+
+const WEB = path.join(__dirname, '..', 'app');
+const PORTA_PADRAO = Number(process.env.PRIMOCODE_APP_PORT) || 7788;
+
+// ── espelho da saída ─────────────────────────────────────────────────────
+
+/* Duplica tudo que vai para o terminal, sem tirar nada de lá.
+ *
+ * O `write` original continua sendo chamado com os mesmos argumentos e o mesmo
+ * retorno: se este espelho mudasse o valor de volta, o Node passaria a achar
+ * que o buffer encheu (ou que não encheu) e a saída sairia picada. */
+function espelhar(aoEscrever) {
+    const real = process.stdout.write.bind(process.stdout);
+    process.stdout.write = function (pedaco, enc, cb) {
+        try {
+            aoEscrever(typeof pedaco === 'string' ? pedaco : Buffer.from(pedaco).toString('utf8'));
+        } catch { /* o espelho nunca pode derrubar a saída */ }
+        return real(pedaco, enc, cb);
+    };
+    return function parar() { process.stdout.write = real; };
+}
+
+/* O prompt do readline e os quadros do rodinha não são conteúdo: são a
+   interface do TERMINAL se redesenhando. Na página eles viravam lixo piscando
+   no meio da conversa. O jeito de reconhecê-los é o que sobra depois de tirar
+   o ANSI: pedaço curto e sem quebra de linha é desenho, não texto. */
+function ehRuido(texto) {
+    const limpo = texto.replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '').replace(/\r/g, '');
+    if (limpo.includes('\n')) return false;
+    return limpo.trim().length < 12;
+}
+
+// ── o servidor ───────────────────────────────────────────────────────────
+
+function tipoDe(arquivo) {
+    if (arquivo.endsWith('.html')) return 'text/html; charset=utf-8';
+    if (arquivo.endsWith('.css')) return 'text/css; charset=utf-8';
+    if (arquivo.endsWith('.js')) return 'application/javascript; charset=utf-8';
+    if (arquivo.endsWith('.svg')) return 'image/svg+xml';
+    return 'application/octet-stream';
+}
+
+/**
+ * Sobe a janela do PrimoCode.
+ *
+ * @param {object} op
+ * @param {(texto:string)=>Promise} op.enviar      manda um pedido ao agente
+ * @param {(texto:string)=>Promise} op.barra       trata um comando /barra
+ * @param {()=>void}                op.interromper para o que estiver rodando
+ * @param {()=>object}              op.estado      { pasta, modo, esforco, projeto }
+ * @param {string}                  op.versao
+ */
+async function abrir(op) {
+    const chave = crypto.randomBytes(16).toString('hex');
+    const ouvintes = new Set();
+    let ocupado = false;
+    const fila = [];
+
+    // O histórico de saída para quem abrir a janela DEPOIS de o agente já ter
+    // começado — sem isto a página nasceria vazia no meio de uma tarefa.
+    const memoria = [];
+    const MEMORIA_MAX = 400;
+
+    function emitir(evento, dados) {
+        const linha = `event: ${evento}\ndata: ${JSON.stringify(dados)}\n\n`;
+        for (const res of ouvintes) {
+            try { res.write(linha); } catch { ouvintes.delete(res); }
+        }
+    }
+
+    const pararEspelho = espelhar((pedaco) => {
+        if (ehRuido(pedaco)) return;
+        memoria.push(pedaco);
+        if (memoria.length > MEMORIA_MAX) memoria.shift();
+        emitir('saida', pedaco);
+    });
+
+    async function processar(texto) {
+        fila.push(texto);
+        if (ocupado) return;
+        ocupado = true;
+        emitir('ocupado', true);
+        while (fila.length) {
+            const t = String(fila.shift() || '').trim();
+            if (!t) continue;
+            emitir('voce', t);
+            try {
+                if (t.startsWith('/')) await op.barra(t);
+                else await op.enviar(t);
+            } catch (e) {
+                emitir('erro', (e && e.message) || String(e));
+            }
+        }
+        ocupado = false;
+        emitir('ocupado', false);
+        emitir('estado', op.estado());
+    }
+
+    const servidor = http.createServer((req, res) => {
+        const url = new URL(req.url, 'http://127.0.0.1');
+        const rota = url.pathname;
+
+        /* A chave protege a API, que é onde está tudo o que importa: a conversa
+           do usuário e a capacidade de dar ordens ao agente. A página em si —
+           HTML, CSS, JS — não guarda segredo nenhum e não faz nada sem a
+           chave, então ela é servida solta.
+
+           Não é frouxidão, é o contrário: exigir chave nos estáticos também
+           quebrava a própria janela, porque o navegador pede /app.css e
+           /app.js sem parâmetro nenhum. A página vinha, ficava sem estilo e
+           sem script, e o "app bonito" era um formulário branco. */
+        if (rota.startsWith('/api/')) {
+            const dada = url.searchParams.get('k') || req.headers['x-primo-chave'];
+            if (dada !== chave) {
+                res.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' });
+                return res.end('chave inválida — abra a janela com o comando /app');
+            }
+        }
+        /* CSRF: uma página de terceiro consegue disparar POST simples para
+           127.0.0.1 sem preflight. Ela não saberia a chave, mas o cinto e o
+           suspensório custam três linhas. */
+        const origem = req.headers.origin;
+        if (origem && !origem.startsWith(`http://127.0.0.1:${servidor.__porta}`)
+            && !origem.startsWith(`http://localhost:${servidor.__porta}`)) {
+            res.writeHead(403).end();
+            return;
+        }
+
+        if (rota === '/api/fluxo') {
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream; charset=utf-8',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive',
+                // Sem isto um proxy no meio segura os eventos até fechar.
+                'X-Accel-Buffering': 'no',
+            });
+            res.write(': ligado\n\n');
+            ouvintes.add(res);
+            res.write(`event: estado\ndata: ${JSON.stringify(op.estado())}\n\n`);
+            for (const pedaco of memoria) {
+                res.write(`event: saida\ndata: ${JSON.stringify(pedaco)}\n\n`);
+            }
+            res.write(`event: ocupado\ndata: ${JSON.stringify(ocupado)}\n\n`);
+            // Batida a cada 20s: proxy e sistema derrubam conexão parada, e
+            // uma janela que "morre sozinha depois de um tempo" seria um bug
+            // impossível de achar depois.
+            const batida = setInterval(() => { try { res.write(': ok\n\n'); } catch {} }, 20000);
+            req.on('close', () => { clearInterval(batida); ouvintes.delete(res); });
+            return;
+        }
+
+        if (rota === '/api/enviar' && req.method === 'POST') {
+            let corpo = '';
+            req.on('data', (c) => { corpo += c; if (corpo.length > 200000) req.destroy(); });
+            req.on('end', () => {
+                let texto = '';
+                try { texto = JSON.parse(corpo).texto || ''; } catch { /* vazio */ }
+                res.writeHead(200, { 'Content-Type': 'application/json' }).end('{"ok":true}');
+                if (texto.trim()) processar(texto);
+            });
+            return;
+        }
+
+        if (rota === '/api/parar' && req.method === 'POST') {
+            try { op.interromper(); } catch {}
+            res.writeHead(200, { 'Content-Type': 'application/json' }).end('{"ok":true}');
+            return;
+        }
+
+        if (rota === '/api/estado') {
+            res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+            return res.end(JSON.stringify(Object.assign({ versao: op.versao }, op.estado())));
+        }
+
+        // Estáticos. `basename` corta qualquer "../" antes de virar caminho:
+        // este servidor fala com o disco do usuário e não pode servir o que
+        // estiver fora da pasta do aplicativo.
+        const nome = rota === '/' ? 'index.html' : path.basename(rota);
+        const arquivo = path.join(WEB, nome);
+        fs.readFile(arquivo, (erro, dados) => {
+            if (erro) { res.writeHead(404).end('não encontrado'); return; }
+            res.writeHead(200, { 'Content-Type': tipoDe(nome) });
+            res.end(dados);
+        });
+    });
+
+    const porta = await escutar(servidor, PORTA_PADRAO);
+    servidor.__porta = porta;
+    const url = `http://127.0.0.1:${porta}/?k=${chave}`;
+
+    const janela = await abrirJanela(url);
+    return {
+        url, porta, chave, servidor, janela,
+        fechar() { try { pararEspelho(); } catch {} try { servidor.close(); } catch {} },
+    };
+}
+
+/* Porta ocupada não é erro: é outra janela do PrimoCode, ou qualquer coisa
+   que pegou a 7788 primeiro. Anda dez casas e desiste — se dez portas
+   seguidas estão tomadas, o problema é outro. */
+function escutar(servidor, inicial) {
+    return new Promise((ok, falha) => {
+        let porta = inicial;
+        const tentar = () => {
+            servidor.once('error', (e) => {
+                if (e.code === 'EADDRINUSE' && porta < inicial + 10) { porta++; tentar(); }
+                else falha(e);
+            });
+            servidor.listen(porta, '127.0.0.1', () => ok(porta));
+        };
+        tentar();
+    });
+}
+
+/* ── a janela ────────────────────────────────────────────────────────────
+   `--app=` abre sem barra de endereço, sem abas e com entrada própria na
+   barra de tarefas: é o que faz parecer aplicativo em vez de site. Chrome,
+   Edge, Brave e Vivaldi entendem, porque todos são Chromium.
+
+   `--user-data-dir` aponta para uma pasta do PrimoCode de propósito: sem ele,
+   o Chrome que JÁ ESTÁ ABERTO recebe o pedido e devolve uma aba comum — o
+   modo app é ignorado quando há um perfil em uso. Com perfil próprio nasce
+   uma janela de verdade, e o histórico do usuário fica fora disto. */
+function candidatosDeNavegador() {
+    const p = os.platform();
+    if (p === 'darwin') {
+        return [
+            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+            '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+            '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+            '/Applications/Chromium.app/Contents/MacOS/Chromium',
+            '/Applications/Arc.app/Contents/MacOS/Arc',
+        ];
+    }
+    if (p === 'win32') {
+        const bases = [process.env['PROGRAMFILES'], process.env['PROGRAMFILES(X86)'],
+            process.env.LOCALAPPDATA].filter(Boolean);
+        const relativos = [
+            'Google\\Chrome\\Application\\chrome.exe',
+            'Microsoft\\Edge\\Application\\msedge.exe',
+            'BraveSoftware\\Brave-Browser\\Application\\brave.exe',
+        ];
+        const fora = [];
+        for (const b of bases) for (const r of relativos) fora.push(path.join(b, r));
+        return fora;
+    }
+    return ['/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium',
+        '/usr/bin/chromium-browser', '/usr/bin/microsoft-edge', '/usr/bin/brave-browser'];
+}
+
+function abrirJanela(url) {
+    const perfil = path.join(os.homedir(), '.primocode', 'janela');
+    try { fs.mkdirSync(perfil, { recursive: true }); } catch {}
+
+    for (const exe of candidatosDeNavegador()) {
+        if (!fs.existsSync(exe)) continue;
+        try {
+            const filho = execFile(exe, [
+                `--app=${url}`,
+                `--user-data-dir=${perfil}`,
+                '--window-size=1180,820',
+                '--no-first-run',
+                '--no-default-browser-check',
+            ], () => {});
+            // A janela é do usuário: se o PrimoCode do terminal terminar, ela
+            // continua de pé.
+            filho.unref();
+            return Promise.resolve({ modo: 'janela', navegador: path.basename(exe) });
+        } catch { /* tenta o próximo */ }
+    }
+
+    // Nenhum Chromium instalado: aba comum no navegador padrão. Funciona
+    // igual — só não fica com cara de aplicativo.
+    const p = os.platform();
+    const [cmd, args] = p === 'darwin' ? ['open', [url]]
+        : p === 'win32' ? ['cmd.exe', ['/c', 'start', '', url]]
+        : ['xdg-open', [url]];
+    return new Promise((ok) => {
+        execFile(cmd, args, { timeout: 10000 }, (erro) => {
+            ok(erro ? { modo: 'nenhum', erro: erro.message } : { modo: 'aba' });
+        });
+    });
+}
+
+module.exports = { abrir, abrirJanela, espelhar, ehRuido, candidatosDeNavegador };

package/lib/catalogo.js

@@ -89,6 +89,8 @@ const GRUPOS = [
             { tool: 'studio_listar',    escreve: false, faz: 'lista o que já existe no estúdio', args: null },
             { tool: 'studio_midia',     escreve: false, faz: 'manda imagem, música ou vídeo seu para usar nas peças',
               args: 'arquivo (opcional): caminho no projeto — sem ele, lista a galeria. nome (opcional).' },
+            { tool: 'studio_analisar',  escreve: false, faz: 'ouve um vídeo já enviado e diz onde estão as pausas, para cortá-las',
+              args: 'arquivo: a URL "/midia/..." do vídeo. pausa (opcional): segundos a partir dos quais conta como pausa (padrão 0.6). Devolve "trechos": vire cada um numa cena com {"tipo":"clipe","de":...,"ate":...}.' },
         ],
     },
     {

package/lib/config.js

@@ -135,9 +135,31 @@ function findSimilarProject(projectName, minScore = 0.4) {
     return best;
 }
 
-function readGeneralMemory(limit = 2000) {
-    try { return fs.readFileSync(GENERAL_MEMORY, 'utf-8').slice(0, limit); }
+/* A memória geral como o modelo precisa vê-la: o começo E o fim.
+ *
+ * Isto lia os PRIMEIROS 2000 caracteres — que são o cabeçalho do template.
+ * As anotações vão para o FIM do arquivo, então tudo que o agente aprendia
+ * ficava fora do corte e nunca chegava ao modelo. O usuário via o sintoma
+ * exato: "nunca lembra do que fez no chat anterior". O arquivo enchia, a
+ * poda funcionava, e nada daquilo era lido.
+ *
+ * Agora vêm as duas pontas: o cabeçalho (o que a PESSOA escreveu sobre si,
+ * que é permanente) e as anotações mais recentes (o que o agente aprendeu,
+ * que é o que muda). O meio é o que se perde — e é o certo a perder. */
+function readGeneralMemory(limit = 2600) {
+    let texto;
+    try { texto = fs.readFileSync(GENERAL_MEMORY, 'utf-8'); }
     catch { return ''; }
+    if (texto.length <= limit) return texto;
+
+    const blocos = texto.split(/\n(?=### )/);
+    const cabeca = (blocos.shift() || '').slice(0, Math.floor(limit * 0.45));
+    let recente = '';
+    for (let i = blocos.length - 1; i >= 0; i--) {
+        if (cabeca.length + recente.length + blocos[i].length > limit) break;
+        recente = '\n' + blocos[i] + recente;
+    }
+    return cabeca + (recente ? '\n' + recente : '');
 }
 
 // Recebem o DIRETÓRIO de trabalho, não o nome do projeto: quando o PrimoCode
@@ -156,6 +178,34 @@ function appendProjectMemory(dir, entry) {
     } catch {}
 }
 
+/* O que o usuário JÁ criou no estúdio, para "lembra do vídeo tal" funcionar.
+ *
+ * A memória geral guarda "pedido → resultado" em texto corrido, e o id da
+ * peça se perdia no meio da frase. O dono pediu:
+ *
+ *   "Ter memória entre os chats. Ela lembrar do que fez no chat anterior.
+ *    Quando eu falar 'lembra do vídeo tal', ela vai lembrar. Na estrutura de
+ *    arquivos, eu quero que você crie para mim a partir de vídeos, não só de
+ *    código."
+ *
+ * Uma linha por peça, com tipo, título e id — que é o que o agente precisa
+ * para chamar studio_atualizar ou abrir de novo. Sem link: ele é derivável
+ * do id e ocuparia espaço em todo pedido seguinte, para sempre.
+ *
+ * A entrada é DEDUPLICADA por id: recriar ou atualizar a mesma peça não pode
+ * encher a memória de cópias — foi o que aconteceria num vídeo ajustado dez
+ * vezes numa tarefa só. */
+function lembrarCriacao({ ferramenta, titulo, id }) {
+    if (!id) return;
+    const linha = `- criou ${ferramenta || 'peça'} "${String(titulo || 'sem título').slice(0, 70)}" — id \`${id}\``;
+    try {
+        ensureStructure();
+        const texto = fs.existsSync(GENERAL_MEMORY) ? fs.readFileSync(GENERAL_MEMORY, 'utf-8') : '';
+        if (texto.includes(`\`${id}\``)) return;      // já anotada
+        appendGeneralMemory(linha);
+    } catch {}
+}
+
 // A contraparte de appendProjectMemory, para o que vale em TODOS os projetos
 // (nome do usuário, preferência, decisão de longo prazo). Existia a promessa
 // no prompt — "escreve aqui o que descobrir sobre você" — mas nenhuma função
@@ -240,4 +290,5 @@ module.exports = {
     ensureStructure, slugify, stripAccents,
     createProjectDir, getProjectDir, listProjects, findSimilarProject,
     readGeneralMemory, readProjectMemory, appendProjectMemory, appendGeneralMemory,
+    lembrarCriacao,
 };

package/lib/studio.js

@@ -412,9 +412,32 @@ const TIPOS_MIDIA = {
 
 const midiaListar = () => comStudio(async () => ({ ok: true, midia: await pedir('GET', '/api/midia') }));
 
+/* O caminho como ele chega quando a pessoa ARRASTA o arquivo para o terminal.
+ *
+ * "Eu quero que eu consiga arrastar os meus vídeos pra dentro do terminal."
+ * Arrastar, num terminal, cola o caminho — e cola do jeito do sistema: o
+ * macOS escapa espaço com barra invertida, o Windows põe aspas em volta, e
+ * alguns colam file:// na frente. `path.resolve` de qualquer um desses dá um
+ * caminho que não existe, e a resposta era "arquivo não existe" para um
+ * arquivo que está bem ali.
+ */
+function limparCaminho(bruto) {
+    let s = String(bruto || '').trim();
+    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+        s = s.slice(1, -1);
+    }
+    if (/^file:\/\//i.test(s)) {
+        try { s = decodeURIComponent(s.replace(/^file:\/\//i, '')); } catch { /* fica como está */ }
+    }
+    // Só desescapa o que o shell escapa; um "\" de caminho do Windows fica.
+    s = s.replace(/\\([ ()'"&!$`\\])/g, '$1');
+    if (s.startsWith('~/') || s === '~') s = path.join(os.homedir(), s.slice(1));
+    return s.trim();
+}
+
 const midiaEnviar = ({ arquivo, nome }) => comStudio(async () => {
     if (!arquivo) return { ok: false, error: 'Diga o caminho do arquivo (arquivo: "foto.jpg").' };
-    const caminho = path.resolve(arquivo);
+    const caminho = path.resolve(limparCaminho(arquivo));
     if (!fs.existsSync(caminho)) {
         return {
             ok: false,
@@ -430,22 +453,113 @@ const midiaEnviar = ({ arquivo, nome }) => comStudio(async () => {
         return { ok: false, error: `Formato não aceito: ${ext}`, aceitos: Object.keys(TIPOS_MIDIA).join(' ') };
     }
     const bytes = fs.statSync(caminho).size;
-    if (bytes > 60 * 1024 * 1024) return { ok: false, error: `Arquivo tem ${(bytes / 1048576).toFixed(1)} MB; o limite é 60 MB.` };
+    const ehVideo = ext === '.mp4' || ext === '.webm' || ext === '.mov';
+    const teto = ehVideo ? 2 * 1024 * 1024 * 1024 : 60 * 1024 * 1024;
+    if (bytes > teto) {
+        return { ok: false, error: `Arquivo tem ${(bytes / 1048576).toFixed(1)} MB; `
+            + `o limite é ${Math.round(teto / 1048576)} MB.` };
+    }
 
-    const tipo = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif',
-        '.webp': 'image/webp', '.svg': 'image/svg+xml', '.avif': 'image/avif', '.mp3': 'audio/mpeg',
-        '.m4a': 'audio/mp4', '.wav': 'audio/wav', '.ogg': 'audio/ogg', '.aac': 'audio/aac',
-        '.flac': 'audio/flac', '.opus': 'audio/opus', '.weba': 'audio/webm', '.mp4': 'video/mp4',
-        '.webm': 'video/webm', '.mov': 'video/quicktime' }[ext] || 'application/octet-stream';
+    // O corpo vai em pedaços, direto do disco para o socket. Em base64 um
+    // vídeo de celular precisaria caber inteiro na memória três vezes — e o
+    // Node estourava antes de o estúdio ver um byte.
+    const r = await enviarArquivo(caminho, nome || path.basename(caminho));
+    const comoUsar = ehVideo
+        ? `Use "${r.url}" no "src" de um elemento {"tipo":"clipe"}. Para cortar as pausas, `
+          + 'escreva VÁRIOS clipes do mesmo src, cada um com "de" e "ate" em segundos.'
+        : `Use "${r.url}" em fundo.imagem, em src de uma imagem, ou em trilha.src.`;
+    return { ok: true, ...r, comoUsar };
+});
 
-    const dados = `data:${tipo};base64,` + fs.readFileSync(caminho).toString('base64');
-    const r = await pedir('POST', '/api/midia', { nome: nome || path.basename(caminho), dados }, 120000);
-    return { ok: true, ...r, comoUsar: `Use "${r.url}" em fundo.imagem, em src de uma imagem, ou em trilha.src.` };
+/* PUT /api/midia/<nome> com o arquivo cru no corpo. */
+function enviarArquivo(caminho, nome) {
+    return new Promise((resolve, reject) => {
+        const bytes = fs.statSync(caminho).size;
+        const req = http.request({
+            hostname: '127.0.0.1', port: PORTA, method: 'PUT',
+            path: '/api/midia/' + encodeURIComponent(nome),
+            // Vídeo grande copiando para o disco leva tempo; meia hora é
+            // folga para um arquivo de duas horas, e continua sendo um teto.
+            timeout: 30 * 60 * 1000,
+            headers: { 'X-Primo-Agente': '1', 'Content-Type': 'application/octet-stream',
+                'Content-Length': bytes },
+        }, (res) => {
+            let texto = '';
+            res.setEncoding('utf8');
+            res.on('data', (c) => { texto += c; });
+            res.on('end', () => {
+                let corpo = null;
+                try { corpo = JSON.parse(texto); } catch { /* texto cru serve */ }
+                if (res.statusCode >= 400) {
+                    return reject(new Error((corpo && corpo.erro) || texto.slice(0, 300)));
+                }
+                resolve(corpo || {});
+            });
+        });
+        req.on('timeout', () => { req.destroy(new Error('o envio demorou demais')); });
+        req.on('error', reject);
+        const leitura = fs.createReadStream(caminho);
+        leitura.on('error', (e) => { req.destroy(e); reject(e); });
+        leitura.pipe(req);
+    });
+}
+
+/* ── Ouvir o vídeo para achar as pausas ──────────────────────────────────
+ *
+ * "Ele vai cortar as pausas demoradas no vídeo."
+ *
+ * Cortar pausa exige saber onde a fala para, e nada aqui lê o áudio de um
+ * .mp4: o PrimoCode não tem dependência, e o Python da máquina lê WAV e mais
+ * nada. ffmpeg resolveria e seria mais uma instalação de 80 MB para quem só
+ * quer editar um vídeo.
+ *
+ * Quem decodifica MP4, MOV e webm já está aberto na mesa. A conta roda numa
+ * aba que abre, trabalha e se fecha; aqui a gente espera a resposta.
+ *
+ * `abrir` é injetado (é a função de abrir navegador do tools.js) para esta
+ * camada não passar a conhecer o sistema operacional.
+ */
+const analisarAudio = ({ arquivo, pausa, abrir }) => comStudio(async () => {
+    if (!arquivo) return { ok: false, error: 'Diga qual mídia analisar (arquivo: "/midia/x.mp4").' };
+    const tarefa = await pedir('POST', '/api/analise', { arquivo, pausa });
+    if (abrir) { try { abrir(`${BASE}${tarefa.pagina}`); } catch { /* segue e expira */ } }
+
+    // Um vídeo de meia hora leva alguns segundos para decodificar; três
+    // minutos é folga com sobra, e continua sendo um teto — sem ele um
+    // navegador que nunca abriu deixaria a tarefa pendurada para sempre.
+    const prazo = Date.now() + 180000;
+    while (Date.now() < prazo) {
+        await new Promise((ok) => setTimeout(ok, 700));
+        const estado = await pedir('GET', `/api/analise/${tarefa.id}`, null, 8000).catch(() => null);
+        if (!estado) continue;
+        if (estado.estado === 'erro') {
+            return { ok: false, error: (estado.resultado && estado.resultado.erro) || 'a análise falhou' };
+        }
+        if (estado.estado === 'pronto') {
+            const r = estado.resultado || {};
+            return {
+                ok: true,
+                duracao: r.duracao,
+                cortado: r.cortado,
+                pausas: r.pausas,
+                trechos: r.trechos,
+                comoUsar: `${(r.trechos || []).length} trecho(s) sem pausa. Escreva UMA CENA por trecho, `
+                    + `cada uma com {"tipo":"clipe","src":"${arquivo}","de":<início>,"ate":<fim>}. `
+                    + 'NÃO escreva "duracao" nessas cenas: a cena já dura o trecho.',
+            };
+        }
+    }
+    return {
+        ok: false,
+        error: 'A aba de análise não respondeu em 3 minutos. Ela precisa do navegador aberto. '
+            + 'Siga sem o corte automático: escreva os trechos que o usuário pedir, ou use o vídeo inteiro '
+            + 'num clipe só (sem "de"/"ate").',
+    };
 });
 
 module.exports = {
     BASE, PORTA, CASA,
     garantirNoAr, estaNoAr, prepararCasa, pythonCmd,
     manual, ferramentas, spec, listar, ler, criar, atualizar, versoesDe,
-    midiaListar, midiaEnviar,
+    midiaListar, midiaEnviar, analisarAudio,
 };

package/lib/tools.js

@@ -172,6 +172,8 @@ async function runShell(command, timeout = 60000, cwd) {
 // `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();
@@ -513,6 +515,13 @@ async function despachar(name, args, ctx) {
                 // 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
@@ -523,7 +532,24 @@ async function despachar(name, args, ctx) {
                         ultimaAberturaStudio = agora;
                         try { openInBrowser(r.ver); } catch {}
                         r.abertoNoNavegador = true;
-                        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.';
+                        // 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.`;
@@ -544,6 +570,14 @@ async function despachar(name, args, ctx) {
                 return args.arquivo
                     ? studio.midiaEnviar({ arquivo: resolveInProject(args.arquivo, projectDir), nome: args.nome })
                     : studio.midiaListar();
+            case 'studio_analisar':
+                // Ouvir o vídeo para achar as pausas. A conta acontece no
+                // navegador (é quem sabe decodificar MP4 sem instalar nada) —
+                // por isso passa a função de abrir, e por isso demora alguns
+                // segundos em vez de responder na hora.
+                return studio.analisarAudio({
+                    arquivo: args.arquivo, pausa: args.pausa, abrir: openInBrowser,
+                });
 
             case 'desktop_double_click':
                 return desktop.doubleClick(args.x, args.y);